github.com/prysmaticlabs/prysm@v1.4.4/beacon-chain/db/kv/operations.go (about)

     1  package kv
     2  
     3  import (
     4  	"context"
     5  
     6  	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
     7  	bolt "go.etcd.io/bbolt"
     8  	"go.opencensus.io/trace"
     9  )
    10  
    11  // VoluntaryExit retrieval by signing root.
    12  func (s *Store) VoluntaryExit(ctx context.Context, exitRoot [32]byte) (*ethpb.VoluntaryExit, error) {
    13  	ctx, span := trace.StartSpan(ctx, "BeaconDB.VoluntaryExit")
    14  	defer span.End()
    15  	enc, err := s.voluntaryExitBytes(ctx, exitRoot)
    16  	if err != nil {
    17  		return nil, err
    18  	}
    19  	if len(enc) == 0 {
    20  		return nil, nil
    21  	}
    22  	exit := &ethpb.VoluntaryExit{}
    23  	if err := decode(ctx, enc, exit); err != nil {
    24  		return nil, err
    25  	}
    26  	return exit, nil
    27  }
    28  
    29  // HasVoluntaryExit verifies if a voluntary exit is stored in the db by its signing root.
    30  func (s *Store) HasVoluntaryExit(ctx context.Context, exitRoot [32]byte) bool {
    31  	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasVoluntaryExit")
    32  	defer span.End()
    33  	enc, err := s.voluntaryExitBytes(ctx, exitRoot)
    34  	if err != nil {
    35  		panic(err)
    36  	}
    37  	return len(enc) > 0
    38  }
    39  
    40  // SaveVoluntaryExit to the db by its signing root.
    41  func (s *Store) SaveVoluntaryExit(ctx context.Context, exit *ethpb.VoluntaryExit) error {
    42  	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveVoluntaryExit")
    43  	defer span.End()
    44  	exitRoot, err := exit.HashTreeRoot()
    45  	if err != nil {
    46  		return err
    47  	}
    48  	enc, err := encode(ctx, exit)
    49  	if err != nil {
    50  		return err
    51  	}
    52  	return s.db.Update(func(tx *bolt.Tx) error {
    53  		bucket := tx.Bucket(voluntaryExitsBucket)
    54  		return bucket.Put(exitRoot[:], enc)
    55  	})
    56  }
    57  
    58  func (s *Store) voluntaryExitBytes(ctx context.Context, exitRoot [32]byte) ([]byte, error) {
    59  	ctx, span := trace.StartSpan(ctx, "BeaconDB.voluntaryExitBytes")
    60  	defer span.End()
    61  	var dst []byte
    62  	err := s.db.View(func(tx *bolt.Tx) error {
    63  		bkt := tx.Bucket(voluntaryExitsBucket)
    64  		dst = bkt.Get(exitRoot[:])
    65  		return nil
    66  	})
    67  	return dst, err
    68  }
    69  
    70  // deleteVoluntaryExit clears a voluntary exit from the db by its signing root.
    71  func (s *Store) deleteVoluntaryExit(ctx context.Context, exitRoot [32]byte) error {
    72  	ctx, span := trace.StartSpan(ctx, "BeaconDB.deleteVoluntaryExit")
    73  	defer span.End()
    74  	return s.db.Update(func(tx *bolt.Tx) error {
    75  		bucket := tx.Bucket(voluntaryExitsBucket)
    76  		return bucket.Delete(exitRoot[:])
    77  	})
    78  }