mirror of
https://github.com/nspcc-dev/neo-go.git
synced 2024-11-25 23:42:23 +00:00
115 lines
3.3 KiB
Go
115 lines
3.3 KiB
Go
package core
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/sha256"
|
|
"encoding/binary"
|
|
"io"
|
|
|
|
. "github.com/CityOfZion/neo-go/pkg/util"
|
|
)
|
|
|
|
// BlockBase holds the base info of a block
|
|
type BlockBase struct {
|
|
Version uint32
|
|
// hash of the previous block.
|
|
PrevBlock Uint256
|
|
// Root hash of a transaction list.
|
|
MerkleRoot Uint256
|
|
// The time stamp of each block must be later than previous block's time stamp.
|
|
// Generally the difference of two block's time stamp is about 15 seconds and imprecision is allowed.
|
|
// The height of the block must be exactly equal to the height of the previous block plus 1.
|
|
Timestamp uint32
|
|
// height of the block
|
|
Height uint32
|
|
// Random number
|
|
Nonce uint64
|
|
// contract addresss of the next miner
|
|
NextMiner Uint160
|
|
// fixed to 1
|
|
_sep uint8
|
|
// Script used to validate the block
|
|
Script *Witness
|
|
}
|
|
|
|
// BlockHead holds the head info of a block
|
|
type BlockHead struct {
|
|
BlockBase
|
|
// fixed to 0
|
|
_sep1 uint8
|
|
}
|
|
|
|
// Block represents one block in the chain.
|
|
type Block struct {
|
|
BlockBase
|
|
// transaction list
|
|
Transactions []*Transaction
|
|
}
|
|
|
|
// encodeHashableFields will only encode the fields used for hashing.
|
|
// see Hash() for more information about the fields.
|
|
func (b *Block) encodeHashableFields(w io.Writer) error {
|
|
err := binary.Write(w, binary.LittleEndian, &b.Version)
|
|
err = binary.Write(w, binary.LittleEndian, &b.PrevBlock)
|
|
err = binary.Write(w, binary.LittleEndian, &b.MerkleRoot)
|
|
err = binary.Write(w, binary.LittleEndian, &b.Timestamp)
|
|
err = binary.Write(w, binary.LittleEndian, &b.Height)
|
|
err = binary.Write(w, binary.LittleEndian, &b.Nonce)
|
|
err = binary.Write(w, binary.LittleEndian, &b.NextMiner)
|
|
|
|
return err
|
|
}
|
|
|
|
// EncodeBinary encodes the block to the given writer.
|
|
func (b *Block) EncodeBinary(w io.Writer) error {
|
|
return nil
|
|
}
|
|
|
|
// DecodeBinary decods the block from the given reader.
|
|
func (b *Block) DecodeBinary(r io.Reader) error {
|
|
err := binary.Read(r, binary.LittleEndian, &b.Version)
|
|
err = binary.Read(r, binary.LittleEndian, &b.PrevBlock)
|
|
err = binary.Read(r, binary.LittleEndian, &b.MerkleRoot)
|
|
err = binary.Read(r, binary.LittleEndian, &b.Timestamp)
|
|
err = binary.Read(r, binary.LittleEndian, &b.Height)
|
|
err = binary.Read(r, binary.LittleEndian, &b.Nonce)
|
|
err = binary.Read(r, binary.LittleEndian, &b.NextMiner)
|
|
err = binary.Read(r, binary.LittleEndian, &b._sep)
|
|
|
|
b.Script = &Witness{}
|
|
if err := b.Script.DecodeBinary(r); err != nil {
|
|
return err
|
|
}
|
|
|
|
var lentx uint8
|
|
err = binary.Read(r, binary.LittleEndian, &lentx)
|
|
|
|
b.Transactions = make([]*Transaction, lentx)
|
|
for i := 0; i < int(lentx); i++ {
|
|
tx := &Transaction{}
|
|
if err := tx.DecodeBinary(r); err != nil {
|
|
return err
|
|
}
|
|
b.Transactions[i] = tx
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
// Hash return the hash of the block.
|
|
// When calculating the hash value of the block, instead of calculating the entire block,
|
|
// only first seven fields in the block head will be calculated, which are
|
|
// version, PrevBlock, MerkleRoot, timestamp, and height, the nonce, NextMiner.
|
|
// Since MerkleRoot already contains the hash value of all transactions,
|
|
// the modification of transaction will influence the hash value of the block.
|
|
func (b *Block) Hash() (hash Uint256, err error) {
|
|
buf := new(bytes.Buffer)
|
|
if err = b.encodeHashableFields(buf); err != nil {
|
|
return
|
|
}
|
|
hash = sha256.Sum256(buf.Bytes())
|
|
return
|
|
}
|
|
|
|
// Size implements the payload interface.
|
|
func (b *Block) Size() uint32 { return 0 }
|