mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2024-12-24 12:27:18 +00:00
954af67882
* deprecate hashutil * Revert "deprecate hashutil" This reverts commit 6ee40f916c6fcf73fe372b980ba5645fe0456f9d. * changing to golang crypto lib * Add comment * add test
199 lines
5.0 KiB
Go
199 lines
5.0 KiB
Go
package db
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/boltdb/bolt"
|
|
"github.com/gogo/protobuf/proto"
|
|
"github.com/prysmaticlabs/prysm/beacon-chain/core/types"
|
|
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
|
|
)
|
|
|
|
func createBlock(enc []byte) (*types.Block, error) {
|
|
protoBlock := &pb.BeaconBlock{}
|
|
err := proto.Unmarshal(enc, protoBlock)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to unmarshal encoding: %v", err)
|
|
}
|
|
|
|
block := types.NewBlock(protoBlock)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to instantiate a block from the encoding: %v", err)
|
|
}
|
|
|
|
return block, nil
|
|
}
|
|
|
|
// GetBlock accepts a block hash and returns the corresponding block.
|
|
// Returns nil if the block does not exist.
|
|
func (db *BeaconDB) GetBlock(hash [32]byte) (*types.Block, error) {
|
|
var block *types.Block
|
|
err := db.view(func(tx *bolt.Tx) error {
|
|
b := tx.Bucket(blockBucket)
|
|
|
|
enc := b.Get(hash[:])
|
|
if enc == nil {
|
|
return nil
|
|
}
|
|
|
|
var err error
|
|
block, err = createBlock(enc)
|
|
return err
|
|
})
|
|
|
|
return block, err
|
|
}
|
|
|
|
// HasBlock accepts a block hash and returns true if the block does not exist.
|
|
func (db *BeaconDB) HasBlock(hash [32]byte) bool {
|
|
hasBlock := false
|
|
// #nosec G104
|
|
_ = db.view(func(tx *bolt.Tx) error {
|
|
b := tx.Bucket(blockBucket)
|
|
|
|
hasBlock = b.Get(hash[:]) != nil
|
|
|
|
return nil
|
|
})
|
|
|
|
return hasBlock
|
|
}
|
|
|
|
// SaveBlock accepts a block and writes it to disk.
|
|
func (db *BeaconDB) SaveBlock(block *types.Block) error {
|
|
hash, err := block.Hash()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to hash block: %v", err)
|
|
}
|
|
enc, err := block.Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to encode block: %v", err)
|
|
}
|
|
|
|
return db.update(func(tx *bolt.Tx) error {
|
|
b := tx.Bucket(blockBucket)
|
|
|
|
return b.Put(hash[:], enc)
|
|
})
|
|
}
|
|
|
|
// GetChainHead returns the head of the main chain.
|
|
func (db *BeaconDB) GetChainHead() (*types.Block, error) {
|
|
var block *types.Block
|
|
|
|
err := db.view(func(tx *bolt.Tx) error {
|
|
chainInfo := tx.Bucket(chainInfoBucket)
|
|
mainChain := tx.Bucket(mainChainBucket)
|
|
blockBkt := tx.Bucket(blockBucket)
|
|
|
|
height := chainInfo.Get(mainChainHeightKey)
|
|
if height == nil {
|
|
return errors.New("unable to determine chain height")
|
|
}
|
|
|
|
blockhash := mainChain.Get(height)
|
|
if blockhash == nil {
|
|
return fmt.Errorf("hash at the current height not found: %d", height)
|
|
}
|
|
|
|
enc := blockBkt.Get(blockhash)
|
|
if enc == nil {
|
|
return fmt.Errorf("block not found: %x", blockhash)
|
|
}
|
|
|
|
var err error
|
|
block, err = createBlock(enc)
|
|
|
|
return err
|
|
})
|
|
|
|
return block, err
|
|
}
|
|
|
|
// UpdateChainHead atomically updates the head of the chain as well as the corresponding state changes
|
|
// Including a new crystallized state is optional.
|
|
func (db *BeaconDB) UpdateChainHead(block *types.Block, beaconState *types.BeaconState) error {
|
|
blockHash, err := block.Hash()
|
|
if err != nil {
|
|
return fmt.Errorf("unable to get the block hash: %v", err)
|
|
}
|
|
|
|
beaconStateEnc, err := beaconState.Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("unable to encode the beacon state: %v", err)
|
|
}
|
|
|
|
slotBinary := encodeSlotNumber(block.SlotNumber())
|
|
|
|
return db.update(func(tx *bolt.Tx) error {
|
|
blockBucket := tx.Bucket(blockBucket)
|
|
chainInfo := tx.Bucket(chainInfoBucket)
|
|
mainChain := tx.Bucket(mainChainBucket)
|
|
|
|
if blockBucket.Get(blockHash[:]) == nil {
|
|
return fmt.Errorf("expected block %#x to have already been saved before updating head: %v", blockHash, err)
|
|
}
|
|
|
|
if err := mainChain.Put(slotBinary, blockHash[:]); err != nil {
|
|
return fmt.Errorf("failed to include the block in the main chain bucket: %v", err)
|
|
}
|
|
|
|
if err := chainInfo.Put(mainChainHeightKey, slotBinary); err != nil {
|
|
return fmt.Errorf("failed to record the block as the head of the main chain: %v", err)
|
|
}
|
|
|
|
if err := chainInfo.Put(stateLookupKey, beaconStateEnc); err != nil {
|
|
return fmt.Errorf("failed to save beacon state as canonical: %v", err)
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
// GetBlockBySlot accepts a slot number and returns the corresponding block in the main chain.
|
|
// Returns nil if a block was not recorded for the given slot.
|
|
func (db *BeaconDB) GetBlockBySlot(slot uint64) (*types.Block, error) {
|
|
var block *types.Block
|
|
slotEnc := encodeSlotNumber(slot)
|
|
|
|
err := db.view(func(tx *bolt.Tx) error {
|
|
mainChain := tx.Bucket(mainChainBucket)
|
|
blockBkt := tx.Bucket(blockBucket)
|
|
|
|
blockhash := mainChain.Get(slotEnc)
|
|
if blockhash == nil {
|
|
return nil
|
|
}
|
|
|
|
enc := blockBkt.Get(blockhash)
|
|
if enc == nil {
|
|
return fmt.Errorf("block not found: %x", blockhash)
|
|
}
|
|
|
|
var err error
|
|
block, err = createBlock(enc)
|
|
return err
|
|
})
|
|
|
|
return block, err
|
|
}
|
|
|
|
// GetGenesisTime returns the timestamp for the genesis block
|
|
func (db *BeaconDB) GetGenesisTime() (time.Time, error) {
|
|
genesis, err := db.GetBlockBySlot(0)
|
|
if err != nil {
|
|
return time.Time{}, fmt.Errorf("could not get genesis block: %v", err)
|
|
}
|
|
if genesis == nil {
|
|
return time.Time{}, fmt.Errorf("genesis block not found: %v", err)
|
|
}
|
|
|
|
genesisTime, err := genesis.Timestamp()
|
|
if err != nil {
|
|
return time.Time{}, fmt.Errorf("could not get genesis timestamp: %v", err)
|
|
}
|
|
|
|
return genesisTime, nil
|
|
}
|