prysm-pulse/beacon-chain/db/block.go
2018-10-31 23:05:55 +01:00

214 lines
5.4 KiB
Go

package db
import (
"errors"
"fmt"
"time"
"github.com/boltdb/bolt"
"github.com/gogo/protobuf/proto"
"github.com/prysmaticlabs/prysm/beacon-chain/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 determinechain 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, aState *types.ActiveState, cState *types.CrystallizedState) error {
blockhash, err := block.Hash()
if err != nil {
return fmt.Errorf("unable to get the block hash: %v", err)
}
aStateEnc, err := aState.Marshal()
if err != nil {
return fmt.Errorf("unable to encode the active state: %v", err)
}
var cStateEnc []byte
if cState != nil {
cStateEnc, err = cState.Marshal()
if err != nil {
return fmt.Errorf("unable to encode the crystallized 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(aStateLookupKey, aStateEnc); err != nil {
return fmt.Errorf("failed to save active state as canonical: %v", err)
}
if cStateEnc != nil {
if err := chainInfo.Put(cStateLookupKey, cStateEnc); err != nil {
return fmt.Errorf("failed to save crystallized 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
}