github.com/prysmaticlabs/prysm@v1.4.4/beacon-chain/db/kv/slashings.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  // ProposerSlashing retrieval by slashing root.
    12  func (s *Store) ProposerSlashing(ctx context.Context, slashingRoot [32]byte) (*ethpb.ProposerSlashing, error) {
    13  	ctx, span := trace.StartSpan(ctx, "BeaconDB.ProposerSlashing")
    14  	defer span.End()
    15  	enc, err := s.proposerSlashingBytes(ctx, slashingRoot)
    16  	if err != nil {
    17  		return nil, err
    18  	}
    19  	if len(enc) == 0 {
    20  		return nil, nil
    21  	}
    22  	proposerSlashing := &ethpb.ProposerSlashing{}
    23  	if err := decode(ctx, enc, proposerSlashing); err != nil {
    24  		return nil, err
    25  	}
    26  	return proposerSlashing, nil
    27  }
    28  
    29  // HasProposerSlashing verifies if a slashing is stored in the db.
    30  func (s *Store) HasProposerSlashing(ctx context.Context, slashingRoot [32]byte) bool {
    31  	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasProposerSlashing")
    32  	defer span.End()
    33  	enc, err := s.proposerSlashingBytes(ctx, slashingRoot)
    34  	if err != nil {
    35  		panic(err)
    36  	}
    37  	return len(enc) > 0
    38  }
    39  
    40  // SaveProposerSlashing to the db by its hash tree root.
    41  func (s *Store) SaveProposerSlashing(ctx context.Context, slashing *ethpb.ProposerSlashing) error {
    42  	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveProposerSlashing")
    43  	defer span.End()
    44  	slashingRoot, err := slashing.HashTreeRoot()
    45  	if err != nil {
    46  		return err
    47  	}
    48  	enc, err := encode(ctx, slashing)
    49  	if err != nil {
    50  		return err
    51  	}
    52  	return s.db.Update(func(tx *bolt.Tx) error {
    53  		bucket := tx.Bucket(proposerSlashingsBucket)
    54  		return bucket.Put(slashingRoot[:], enc)
    55  	})
    56  }
    57  
    58  func (s *Store) proposerSlashingBytes(ctx context.Context, slashingRoot [32]byte) ([]byte, error) {
    59  	ctx, span := trace.StartSpan(ctx, "BeaconDB.proposerSlashingBytes")
    60  	defer span.End()
    61  	var dst []byte
    62  	err := s.db.View(func(tx *bolt.Tx) error {
    63  		bkt := tx.Bucket(proposerSlashingsBucket)
    64  		dst = bkt.Get(slashingRoot[:])
    65  		return nil
    66  	})
    67  	return dst, err
    68  }
    69  
    70  // deleteProposerSlashing clears a proposer slashing from the db by its hash tree root.
    71  func (s *Store) deleteProposerSlashing(ctx context.Context, slashingRoot [32]byte) error {
    72  	ctx, span := trace.StartSpan(ctx, "BeaconDB.deleteProposerSlashing")
    73  	defer span.End()
    74  	return s.db.Update(func(tx *bolt.Tx) error {
    75  		bucket := tx.Bucket(proposerSlashingsBucket)
    76  		return bucket.Delete(slashingRoot[:])
    77  	})
    78  }
    79  
    80  // AttesterSlashing retrieval by hash tree root.
    81  func (s *Store) AttesterSlashing(ctx context.Context, slashingRoot [32]byte) (*ethpb.AttesterSlashing, error) {
    82  	ctx, span := trace.StartSpan(ctx, "BeaconDB.AttesterSlashing")
    83  	defer span.End()
    84  	enc, err := s.attesterSlashingBytes(ctx, slashingRoot)
    85  	if err != nil {
    86  		return nil, err
    87  	}
    88  	if len(enc) == 0 {
    89  		return nil, nil
    90  	}
    91  	attSlashing := &ethpb.AttesterSlashing{}
    92  	if err := decode(ctx, enc, attSlashing); err != nil {
    93  		return nil, err
    94  	}
    95  	return attSlashing, nil
    96  }
    97  
    98  // HasAttesterSlashing verifies if a slashing is stored in the db.
    99  func (s *Store) HasAttesterSlashing(ctx context.Context, slashingRoot [32]byte) bool {
   100  	ctx, span := trace.StartSpan(ctx, "BeaconDB.HasAttesterSlashing")
   101  	defer span.End()
   102  	enc, err := s.attesterSlashingBytes(ctx, slashingRoot)
   103  	if err != nil {
   104  		panic(err)
   105  	}
   106  	return len(enc) > 0
   107  }
   108  
   109  // SaveAttesterSlashing to the db by its hash tree root.
   110  func (s *Store) SaveAttesterSlashing(ctx context.Context, slashing *ethpb.AttesterSlashing) error {
   111  	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveAttesterSlashing")
   112  	defer span.End()
   113  	slashingRoot, err := slashing.HashTreeRoot()
   114  	if err != nil {
   115  		return err
   116  	}
   117  	enc, err := encode(ctx, slashing)
   118  	if err != nil {
   119  		return err
   120  	}
   121  	return s.db.Update(func(tx *bolt.Tx) error {
   122  		bucket := tx.Bucket(attesterSlashingsBucket)
   123  		return bucket.Put(slashingRoot[:], enc)
   124  	})
   125  }
   126  
   127  func (s *Store) attesterSlashingBytes(ctx context.Context, slashingRoot [32]byte) ([]byte, error) {
   128  	ctx, span := trace.StartSpan(ctx, "BeaconDB.attesterSlashingBytes")
   129  	defer span.End()
   130  	var dst []byte
   131  	err := s.db.View(func(tx *bolt.Tx) error {
   132  		bkt := tx.Bucket(attesterSlashingsBucket)
   133  		dst = bkt.Get(slashingRoot[:])
   134  		return nil
   135  	})
   136  	return dst, err
   137  }
   138  
   139  // deleteAttesterSlashing clears an attester slashing from the db by its hash tree root.
   140  func (s *Store) deleteAttesterSlashing(ctx context.Context, slashingRoot [32]byte) error {
   141  	ctx, span := trace.StartSpan(ctx, "BeaconDB.deleteAttesterSlashing")
   142  	defer span.End()
   143  	return s.db.Update(func(tx *bolt.Tx) error {
   144  		bucket := tx.Bucket(attesterSlashingsBucket)
   145  		return bucket.Delete(slashingRoot[:])
   146  	})
   147  }