You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

455 lines
15 KiB

package blockchain
import "fmt"
import "encoding/binary"
//import log "github.com/sirupsen/logrus"
import "github.com/deroproject/derosuite/crypto"
import "github.com/deroproject/derosuite/globals"
/* this file implements the only interface which translates comands to/from blockchain to storage layer *
*
*
*/
var TOP_ID = []byte("TOP_ID") // stores current TOP, only stores single value
var TX_ID = []byte("TX") // stores transactions
var BLOCK_ID = []byte("BLOCK") // stores blocks
var CHAIN = []byte("CHAIN") // this stores the actual chain, parents keeps child list, starts from genesis block
var HEIGHT_TO_BLOCK_ID = []byte("HEIGHT_TO_BLOCK_ID") // stores block height to block id mapping
var BLOCK_ID_TO_HEIGHT = []byte("BLOCK_ID_TO_HEIGHT") // stores block id to height mapping
var BLOCK_ID_POW = []byte("BLOCK_ID_POW") // stores block_id to pow, this is slow to calculate, do we even need to store it
// all orphan ids are stored here, it id exists its orphan,
// once a block is adden to orphan list it cannot be removed, since we have a better block
var ORPHAN = []byte("ORPHAN")
var ORPHAN_HEIGHT = []byte("ORPHAN_HEIGHT") // height wise orphans are store here
var OO_ID = []byte{0x4} // mapping of incremental numbers to respective transaction ID
var ALTERNATIVE_BLOCKS_ID = []byte{0x5} // each block contains lists of alternative child blocks
var BLOCKCHAIN_UNIVERSE = []byte("BLOCKCHAIN_UNIVERSE") // all block chain data is store in this BLOCKCHAIN_UNIVERSE
// there are only 3 galaxies
var GALAXY_BLOCK = []byte("BLOCK")
var GALAXY_TRANSACTION = []byte("TRANSACTION")
var GALAXY_KEYIMAGE = []byte("KEYIMAGE")
//2 galaxies store inverse mapping
var GALAXY_HEIGHT = []byte("HEIGHT") // height to block id mapping
var GALAXY_OUTPUT_INDEX = []byte("OUTPUT_INDEX") // incremental index over output index
// the unique TXID or block ID becomes the solar system , which is common and saves lot of space
// individual attributes becomes the planets
// individual attributes should be max 1 or 2 chars long, as they will be repeated millions of times and storing a static string millions of times shows foolishness
var PLANET_BLOB = []byte("BLOB") //it shows serialised block
var PLANET_HEIGHT = []byte("HEIGHT") // contains height
var PLANET_PARENT = []byte("PARENT") // parent of block
var PLANET_SIZE = []byte("SIZE") // sum of block + all txs
var PLANET_ALREADY_GENERATED_COINS = []byte("CCOINS") // all coins generated till this block
var PLANET_OUTPUT_INDEX = []byte("OUTPUT_INDEX") // tx outputs indexing starts from here for this block
var PLANET_CUMULATIVE_DIFFICULTY = []byte("CDIFFICULTY")
var PLANET_CHILD = []byte("CHILD")
//var PLANET_ORPHAN = []byte("ORPHAN")
var PLANET_TIMESTAMP = []byte("TIMESTAMP")
// this ill only be present if more tahn 1 child exists
var PLANET_CHILDREN = []byte("CHILREN") // children list excludes the main child, so its a multiple of 32
// the TX has the following attributes
var PLANET_TX_BLOB = []byte("BLOB") // contains serialised TX , this attribute is also found in BLOCK where
var PLANET_TX_MINED_IN_BLOCK = []byte("MINERBLOCK") // which block mined this tx
var PLANET_TX_SIZE = []byte("SIZE")
// the universe concept is there, as we bring in smart contracts, we will give each of them a universe to play within
// while communicating with external universe
/*
func (chain *Blockchain) Store_Main_Chain(parent_id crypto.Hash, child_id crypto.Hash){
err := chain.store.StoreObject(BLOCKCHAIN_UNIVERSE,GALAXY_BLOCK,parent_id[:],PLANET_CHILD, child_id[:] )
_ = err
}
func (chain *Blockchain) Load_Main_Chain(parent_id crypto.Hash) (child_id crypto.Hash ){
var err error
// store OO to TXID automatically
object_data,err = chain.store.LoadObject(BLOCKCHAIN_UNIVERSE,GALAXY_BLOCK,parent_id[:],PLANET_CHILD )
if err != nil {
return child_id,err
}
if len(object_data) == 0 {
return child_id, fmt.Errorf("No Block at such Height %d", Height)
}
if len(object_data) != 32 {
panic("Database corruption, invalid block hash ")
}
copy(child_id[:],object_data[:32])
_ = err
return child_id
}
*/
// check whether the block has a child
func (chain *Blockchain) Does_Block_Have_Child(block_id crypto.Hash) bool {
var err error
object_data, err := chain.store.LoadObject(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, block_id[:], PLANET_CHILD)
if err != nil || len(object_data) == 0 {
return false
}
if len(object_data) != 32 {
panic("Database corruption, invalid block hash ")
}
return true
}
// load the main child
func (chain *Blockchain) Load_Block_Child(parent_id crypto.Hash) (child_id crypto.Hash) {
if !chain.Does_Block_Have_Child(parent_id) {
panic("Block does not have a child")
}
object_data, _ := chain.store.LoadObject(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, parent_id[:], PLANET_CHILD)
copy(child_id[:], object_data)
return
}
// changes or set child block of a parent
// there can be only 1 child, rest all are alternatives and stored as
func (chain *Blockchain) Store_Block_Child(parent_id crypto.Hash, child_id crypto.Hash) {
err := chain.store.StoreObject(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, parent_id[:], PLANET_CHILD, child_id[:])
// load block children
_ = err
}
// while store children
func (chain *Blockchain) Store_Block_Children(parent_id crypto.Hash, children []crypto.Hash, exclude_child crypto.Hash) {
var children_bytes []byte
for i := range children {
if children[i] != exclude_child { // exclude main child
children_bytes = append(children_bytes, children[i][:]...)
}
}
err := chain.store.StoreObject(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, parent_id[:], PLANET_CHILDREN, children_bytes)
_ = err
}
func (chain *Blockchain) Load_Block_Children(parent_id crypto.Hash) (children []crypto.Hash) {
var child_hash crypto.Hash
if !chain.Does_Block_Have_Child(parent_id) { // block doesnot have a child, so it cannot have children
return
}
// we are here means parent does have child
children = append(children, chain.Load_Block_Child(parent_id))
// check for children
children_bytes, _ := chain.store.LoadObject(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, parent_id[:], PLANET_CHILDREN)
if len(children_bytes)%32 != 0 {
panic(fmt.Sprintf("parent does not have child hash in multiples of 32, block_hash %x", parent_id))
}
for i := 0; i < len(children_bytes); i = i + 32 {
copy(child_hash[:], children_bytes[i:i+32])
children = append(children, child_hash)
}
return children
}
// store a tx
// this only occurs when a tx has been mined
func (chain *Blockchain) Store_TX(tx *Transaction) {
hash := tx.GetHash()
serialized := tx.Serialize()
err := chain.store.StoreObject(BLOCKCHAIN_UNIVERSE, GALAXY_TRANSACTION, hash[:], PLANET_TX_BLOB, serialized)
// store size of tx
chain.store.StoreUint64(BLOCKCHAIN_UNIVERSE, GALAXY_TRANSACTION, hash[:], PLANET_TX_SIZE, uint64(len(serialized)))
_ = err
}
func (chain *Blockchain) Store_TX_Miner(txhash crypto.Hash, block_id crypto.Hash) {
// store block id which mined this tx
err := chain.store.StoreObject(BLOCKCHAIN_UNIVERSE, GALAXY_TRANSACTION, txhash[:], PLANET_TX_MINED_IN_BLOCK, block_id[:])
_ = err
}
func (chain *Blockchain) Load_TX_Size(txhash crypto.Hash) uint64 {
// store block id which mined this tx
size, err := chain.store.LoadUint64(BLOCKCHAIN_UNIVERSE, GALAXY_TRANSACTION, txhash[:], PLANET_TX_SIZE)
if err != nil {
logger.Warnf("Size not stored for tx %x", txhash)
}
return size
}
// BUG we should be able to delete any arbitrary key
// since a tx mined by one block, can be back in pool after chain reorganises
// TODO the miner tx should be extracted ands stored from somewhere else
// NOTE: before storing a block, its transactions must be stored
func (chain *Blockchain) Store_BL(bl *Block) {
// store block height BHID automatically
hash := bl.GetHash()
// we should deserialize the block here
serialized_bytes := bl.Serialize() // we are storing the miner transactions within
err := chain.store.StoreObject(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, hash[:], PLANET_BLOB, serialized_bytes)
// get height of parent, add 1 and store it
height := uint64(0)
if hash != globals.Config.Genesis_Block_Hash { // genesis block has no parent
height = chain.Load_Height_for_BL_ID(bl.Prev_Hash)
height++
}
// store new height
chain.store.StoreUint64(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, hash[:], PLANET_HEIGHT, height)
// store timestamp
chain.store.StoreUint64(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, hash[:], PLANET_TIMESTAMP, bl.Timestamp)
// store parent
chain.store.StoreObject(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, hash[:], PLANET_PARENT, bl.Prev_Hash[:])
// calculate cumulative difficulty at last block
difficulty_of_current_block := uint64(0)
cumulative_difficulty := uint64(0)
if hash != globals.Config.Genesis_Block_Hash { // genesis block has no parent
cumulative_difficulty = chain.Load_Block_Cumulative_Difficulty(bl.Prev_Hash)
difficulty_of_current_block = chain.Get_Difficulty_At_Block(bl.Prev_Hash)
} else {
cumulative_difficulty = 1 // genesis block cumulative difficulty is 1
}
total_difficulty := cumulative_difficulty + difficulty_of_current_block
chain.store.StoreUint64(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, hash[:], PLANET_CUMULATIVE_DIFFICULTY, total_difficulty)
// total size of block = size of block + size of all transactions in block ( excludind miner tx)
size_of_block := uint64(len(serialized_bytes))
for i := 0; i < len(bl.Tx_hashes); i++ {
size_of_tx := chain.Load_TX_Size(bl.Tx_hashes[i])
size_of_block += size_of_tx
}
chain.store.StoreUint64(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, hash[:], PLANET_SIZE, size_of_block)
// calculated position of vouts in global index
/* TODO below code has been disabled and should be enabled for extensive testing
index_pos := uint64(0)
if hash != globals.Config.Genesis_Block_Hash {
// load index pos from last block + add count of vouts from last block
index_pos = chain.Get_Block_Output_Index(bl.Prev_Hash)
vout_count_prev_block := chain.Block_Count_Vout(bl.Prev_Hash)
index_pos += vout_count_prev_block
}
chain.store.StoreUint64(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, hash[:], PLANET_OUTPUT_INDEX, index_pos)
logger.Debugf("height %d output index %d\n",height, index_pos)
*/
// TODO calculate total coins emitted till this block
// also extract and store the miner tx separetly, fr direct querying purpose
chain.Store_TX(&bl.Miner_tx)
_ = err
}
func (chain *Blockchain) Load_TX_FROM_ID(hash [32]byte) (*Transaction, error) {
var tx Transaction
tx_data, err := chain.store.LoadObject(BLOCKCHAIN_UNIVERSE, GALAXY_TRANSACTION, hash[:], PLANET_TX_BLOB)
if err != nil {
return nil, err
}
// we should deserialize the block here
err = tx.DeserializeHeader(tx_data)
if err != nil {
logger.Printf("fError deserialiing tx, block id %x len(data) %d data %x\n", hash[:], len(tx_data), tx_data)
return nil, err
}
return &tx, nil
}
func (chain *Blockchain) Load_TX_FROM_OO(Offset uint64) {
}
func (chain *Blockchain) Load_BL_FROM_ID(hash [32]byte) (*Block, error) {
var bl Block
block_data, err := chain.store.LoadObject(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, hash[:], PLANET_BLOB)
if err != nil {
return nil, err
}
if len(block_data) == 0 {
return nil, fmt.Errorf("Block not found in DB")
}
// we should deserialize the block here
err = bl.Deserialize(block_data)
if err != nil {
logger.Warnf("fError deserialiing block, block id %x len(data) %d data %x\n", hash[:], len(block_data), block_data)
return nil, err
}
return &bl, nil
}
// this will give you a block id at a specific height
func (chain *Blockchain) Load_BL_ID_at_Height(Height uint64) (hash crypto.Hash, err error) {
object_data, err := chain.store.LoadObject(BLOCKCHAIN_UNIVERSE, GALAXY_HEIGHT, PLANET_HEIGHT, itob(Height))
if err != nil {
return hash, err
}
if len(object_data) == 0 {
return hash, fmt.Errorf("No Block at such Height %d", Height)
}
if len(object_data) != 32 {
panic("Database corruption, invalid block hash ")
}
copy(hash[:], object_data[:32])
return hash, nil
}
// this will give you a block id at a specific height
func (chain *Blockchain) Store_BL_ID_at_Height(Height uint64, hash crypto.Hash) {
// store height to block id mapping
chain.store.StoreObject(BLOCKCHAIN_UNIVERSE, GALAXY_HEIGHT, PLANET_HEIGHT, itob(Height), hash[:])
}
func (chain *Blockchain) Load_Height_for_BL_ID(hash crypto.Hash) (Height uint64) {
object_data, err := chain.store.LoadObject(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, hash[:], PLANET_HEIGHT)
if err != nil {
logger.Warnf("Error while querying height for block %x\n", hash)
return
}
if len(object_data) == 0 {
//return hash, fmt.Errorf("No Height for block %x", hash[:])
return
}
if len(object_data) != 8 {
panic("Database corruption, invalid block hash ")
}
Height = binary.BigEndian.Uint64(object_data)
return Height
}
func (chain *Blockchain) Load_Block_Timestamp(hash crypto.Hash) uint64 {
timestamp, err := chain.store.LoadUint64(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, hash[:], PLANET_TIMESTAMP)
if err != nil {
logger.Fatalf("Error while querying timestamp for block %x\n", hash)
panic("Error while querying timestamp for block")
}
return timestamp
}
func (chain *Blockchain) Load_Block_Cumulative_Difficulty(hash crypto.Hash) uint64 {
cdifficulty, err := chain.store.LoadUint64(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, hash[:], PLANET_CUMULATIVE_DIFFICULTY)
if err != nil {
logger.Panicf("Error while querying cumulative difficulty for block %x\n", hash)
}
return cdifficulty
}
func (chain *Blockchain) Load_Block_Parent_ID(hash crypto.Hash) crypto.Hash {
var parent_id crypto.Hash
object_data, err := chain.store.LoadObject(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, hash[:], PLANET_PARENT)
if err != nil || len(object_data) != 32 {
logger.Panicf("Error while querying parent id for block %x\n", hash)
}
copy(parent_id[:], object_data)
return parent_id
}
// store current top id
func (chain *Blockchain) Store_TOP_ID(hash crypto.Hash) {
chain.store.StoreObject(BLOCKCHAIN_UNIVERSE, TOP_ID, TOP_ID, TOP_ID, hash[:])
}
func (chain *Blockchain) Load_TOP_ID() (hash crypto.Hash) {
object_data, err := chain.store.LoadObject(BLOCKCHAIN_UNIVERSE, TOP_ID, TOP_ID, TOP_ID)
if err != nil {
panic("Backend failure")
}
if len(object_data) == 0 {
panic(fmt.Errorf("most probably Database corruption, No TOP_ID stored "))
}
if len(object_data) != 32 {
panic("Database corruption, invalid block hash ")
}
copy(hash[:], object_data[:32])
return hash
}
// itob returns an 8-byte big endian representation of v.
func itob(v uint64) []byte {
b := make([]byte, 8)
binary.BigEndian.PutUint64(b, uint64(v))
return b
}
// get the position from where indexing must start for this block
// indexing mean vout based index
// cryptonote works by giving each vout a unique index
func (chain *Blockchain)Get_Block_Output_Index(block_id crypto.Hash) uint64 {
if block_id == globals.Config.Genesis_Block_Hash { // genesis block has no output index
return 0 ; // counting starts from zero
}
index, err := chain.store.LoadUint64(BLOCKCHAIN_UNIVERSE, GALAXY_BLOCK, block_id[:], PLANET_OUTPUT_INDEX)
if err != nil {
// TODO this panic must be enabled to catch some bugs
panic(fmt.Errorf("Cannot load output index for %x err %s", block_id, err))
return 0
}
return index
}