@ -15,71 +15,59 @@ import (
"github.com/ethereum/go-ethereum/rlp"
)
type Header struct {
// Hash to the previous block
ParentHash common . Hash
// Uncles of this block
UncleHash common . Hash
// The coin base address
Coinbase common . Address
// Block Trie state
Root common . Hash
// Tx sha
TxHash common . Hash
// Receipt sha
ReceiptHash common . Hash
// Bloom
Bloom Bloom
// Difficulty for the current block
Difficulty * big . Int
// The block number
Number * big . Int
// Gas limit
GasLimit * big . Int
// Gas used
GasUsed * big . Int
// Creation time
Time uint64
// Extra data
Extra [ ] byte
// Mix digest for quick checking to prevent DOS
MixDigest common . Hash
// Nonce
Nonce [ 8 ] byte
}
// A BlockNonce is a 64-bit hash which proves (combined with the
// mix-hash) that a suffcient amount of computation has been carried
// out on a block.
type BlockNonce [ 8 ] byte
func ( self * Header ) Hash ( ) common . Hash {
return rlpHash ( self . rlpData ( true ) )
func EncodeNonce ( i uint64 ) BlockNonce {
var n BlockNonce
binary . BigEndian . PutUint64 ( n [ : ] , i )
return n
}
func ( self * Header ) HashNoNonce ( ) common . Hash {
return rlpHash ( self . rlpData ( false ) )
func ( n BlockNonce ) Uint64 ( ) uint64 {
return binary . BigEndian . Uint64 ( n [ : ] )
}
func ( self * Header ) rlpData ( withNonce bool ) [ ] interface { } {
fields := [ ] interface { } {
self . ParentHash ,
self . UncleHash ,
self . Coinbase ,
self . Root ,
self . TxHash ,
self . ReceiptHash ,
self . Bloom ,
self . Difficulty ,
self . Number ,
self . GasLimit ,
self . GasUsed ,
self . Time ,
self . Extra ,
}
if withNonce {
fields = append ( fields , self . MixDigest , self . Nonce )
}
return fields
}
func ( self * Header ) RlpData ( ) interface { } {
return self . rlpData ( true )
type Header struct {
ParentHash common . Hash // Hash to the previous block
UncleHash common . Hash // Uncles of this block
Coinbase common . Address // The coin base address
Root common . Hash // Block Trie state
TxHash common . Hash // Tx sha
ReceiptHash common . Hash // Receipt sha
Bloom Bloom // Bloom
Difficulty * big . Int // Difficulty for the current block
Number * big . Int // The block number
GasLimit * big . Int // Gas limit
GasUsed * big . Int // Gas used
Time uint64 // Creation time
Extra [ ] byte // Extra data
MixDigest common . Hash // for quick difficulty verification
Nonce BlockNonce
}
func ( h * Header ) Hash ( ) common . Hash {
return rlpHash ( h )
}
func ( h * Header ) HashNoNonce ( ) common . Hash {
return rlpHash ( [ ] interface { } {
h . ParentHash ,
h . UncleHash ,
h . Coinbase ,
h . Root ,
h . TxHash ,
h . ReceiptHash ,
h . Bloom ,
h . Difficulty ,
h . Number ,
h . GasLimit ,
h . GasUsed ,
h . Time ,
h . Extra ,
} )
}
func ( h * Header ) UnmarshalJSON ( data [ ] byte ) error {
@ -112,20 +100,14 @@ func rlpHash(x interface{}) (h common.Hash) {
}
type Block struct {
// Preset Hash for mock (Tests)
HeaderHash common . Hash
ParentHeaderHash common . Hash
// ^^^^ ignore ^^^^
header * Header
uncles [ ] * Header
transactions Transactions
Td * big . Int
queued bool // flag for blockpool to skip TD check
receipts Receipts
Td * big . Int
queued bool // flag for blockpool to skip TD check
ReceivedAt time . Time
receipts Receipts
}
// StorageBlock defines the RLP encoding of a Block stored in the
@ -148,43 +130,90 @@ type storageblock struct {
TD * big . Int
}
func NewBlock ( parentHash common . Hash , coinbase common . Address , root common . Hash , difficulty * big . Int , nonce uint64 , extra [ ] byte ) * Block {
header := & Header {
Root : root ,
ParentHash : parentHash ,
Coinbase : coinbase ,
Difficulty : difficulty ,
Time : uint64 ( time . Now ( ) . Unix ( ) ) ,
Extra : extra ,
GasUsed : new ( big . Int ) ,
GasLimit : new ( big . Int ) ,
Number : new ( big . Int ) ,
var (
emptyRootHash = DeriveSha ( Transactions { } )
emptyUncleHash = CalcUncleHash ( nil )
)
// NewBlock creates a new block. The input data is copied,
// changes to header and to the field values will not affect the
// block.
//
// The values of TxHash, UncleHash, ReceiptHash and Bloom in header
// are ignored and set to values derived from the given txs, uncles
// and receipts.
func NewBlock ( header * Header , txs [ ] * Transaction , uncles [ ] * Header , receipts [ ] * Receipt ) * Block {
b := & Block { header : copyHeader ( header ) , Td : new ( big . Int ) }
// TODO: panic if len(txs) != len(receipts)
if len ( txs ) == 0 {
b . header . TxHash = emptyRootHash
} else {
b . header . TxHash = DeriveSha ( Transactions ( txs ) )
b . transactions = make ( Transactions , len ( txs ) )
copy ( b . transactions , txs )
}
header . SetNonce ( nonce )
block := & Block { header : header }
block . Td = new ( big . Int )
return block
}
if len ( receipts ) == 0 {
b . header . ReceiptHash = emptyRootHash
} else {
b . header . ReceiptHash = DeriveSha ( Receipts ( receipts ) )
b . header . Bloom = CreateBloom ( receipts )
b . receipts = make ( [ ] * Receipt , len ( receipts ) )
copy ( b . receipts , receipts )
}
func ( self * Header ) SetNonce ( nonce uint64 ) {
binary . BigEndian . PutUint64 ( self . Nonce [ : ] , nonce )
if len ( uncles ) == 0 {
b . header . UncleHash = emptyUncleHash
} else {
b . header . UncleHash = CalcUncleHash ( uncles )
b . uncles = make ( [ ] * Header , len ( uncles ) )
for i := range uncles {
b . uncles [ i ] = copyHeader ( uncles [ i ] )
}
}
return b
}
// NewBlockWithHeader creates a block with the given header data. The
// header data is copied, changes to header and to the field values
// will not affect the block.
func NewBlockWithHeader ( header * Header ) * Block {
return & Block { header : header }
return & Block { header : copyHeader ( header ) }
}
func copyHeader ( h * Header ) * Header {
cpy := * h
if cpy . Difficulty = new ( big . Int ) ; h . Difficulty != nil {
cpy . Difficulty . Set ( h . Difficulty )
}
if cpy . Number = new ( big . Int ) ; h . Number != nil {
cpy . Number . Set ( h . Number )
}
if cpy . GasLimit = new ( big . Int ) ; h . GasLimit != nil {
cpy . GasLimit . Set ( h . GasLimit )
}
if cpy . GasUsed = new ( big . Int ) ; h . GasUsed != nil {
cpy . GasUsed . Set ( h . GasUsed )
}
if len ( h . Extra ) > 0 {
cpy . Extra = make ( [ ] byte , len ( h . Extra ) )
copy ( cpy . Extra , h . Extra )
}
return & cpy
}
func ( self * Block ) ValidateFields ( ) error {
if self . header == nil {
func ( b * Block ) ValidateFields ( ) error {
if b . header == nil {
return fmt . Errorf ( "header is nil" )
}
for i , transaction := range self . transactions {
for i , transaction := range b . transactions {
if transaction == nil {
return fmt . Errorf ( "transaction %d is nil" , i )
}
}
for i , uncle := range self . uncles {
for i , uncle := range b . uncles {
if uncle == nil {
return fmt . Errorf ( "uncle %d is nil" , i )
}
@ -192,64 +221,48 @@ func (self *Block) ValidateFields() error {
return nil
}
func ( self * Block ) DecodeRLP ( s * rlp . Stream ) error {
func ( b * Block ) DecodeRLP ( s * rlp . Stream ) error {
var eb extblock
if err := s . Decode ( & eb ) ; err != nil {
return err
}
self . header , self . uncles , self . transactions = eb . Header , eb . Uncles , eb . Txs
b . header , b . uncles , b . transactions = eb . Header , eb . Uncles , eb . Txs
return nil
}
func ( self Block ) EncodeRLP ( w io . Writer ) error {
func ( b Block ) EncodeRLP ( w io . Writer ) error {
return rlp . Encode ( w , extblock {
Header : self . header ,
Txs : self . transactions ,
Uncles : self . uncles ,
Header : b . header ,
Txs : b . transactions ,
Uncles : b . uncles ,
} )
}
func ( self * StorageBlock ) DecodeRLP ( s * rlp . Stream ) error {
func ( b * StorageBlock ) DecodeRLP ( s * rlp . Stream ) error {
var sb storageblock
if err := s . Decode ( & sb ) ; err != nil {
return err
}
self . header , self . uncles , self . transactions , self . Td = sb . Header , sb . Uncles , sb . Txs , sb . TD
b . header , b . uncles , b . transactions , b . Td = sb . Header , sb . Uncles , sb . Txs , sb . TD
return nil
}
func ( self StorageBlock ) EncodeRLP ( w io . Writer ) error {
func ( b StorageBlock ) EncodeRLP ( w io . Writer ) error {
return rlp . Encode ( w , storageblock {
Header : self . header ,
Txs : self . transactions ,
Uncles : self . uncles ,
TD : self . Td ,
Header : b . header ,
Txs : b . transactions ,
Uncles : b . uncles ,
TD : b . Td ,
} )
}
func ( self * Block ) Header ( ) * Header {
return self . header
}
func ( self * Block ) Uncles ( ) [ ] * Header {
return self . uncles
}
func ( self * Block ) CalculateUnclesHash ( ) common . Hash {
return rlpHash ( self . uncles )
}
// TODO: copies
func ( b * Block ) Uncles ( ) [ ] * Header { return b . uncles }
func ( b * Block ) Transactions ( ) Transactions { return b . transactions }
func ( b * Block ) Receipts ( ) Receipts { return b . receipts }
func ( self * Block ) SetUncles ( uncleHeaders [ ] * Header ) {
self . uncles = uncleHeaders
self . header . UncleHash = rlpHash ( uncleHeaders )
}
func ( self * Block ) Transactions ( ) Transactions {
return self . transactions
}
func ( self * Block ) Transaction ( hash common . Hash ) * Transaction {
for _ , transaction := range self . transactions {
func ( b * Block ) Transaction ( hash common . Hash ) * Transaction {
for _ , transaction := range b . transactions {
if transaction . Hash ( ) == hash {
return transaction
}
@ -257,74 +270,33 @@ func (self *Block) Transaction(hash common.Hash) *Transaction {
return nil
}
func ( self * Block ) SetTransactions ( transactions Transactions ) {
self . transactions = transactions
self . header . TxHash = DeriveSha ( transactions )
}
func ( self * Block ) AddTransaction ( transaction * Transaction ) {
self . transactions = append ( self . transactions , transaction )
self . SetTransactions ( self . transactions )
}
func ( self * Block ) Receipts ( ) Receipts {
return self . receipts
}
func ( self * Block ) SetReceipts ( receipts Receipts ) {
self . receipts = receipts
self . header . ReceiptHash = DeriveSha ( receipts )
self . header . Bloom = CreateBloom ( receipts )
}
func ( self * Block ) AddReceipt ( receipt * Receipt ) {
self . receipts = append ( self . receipts , receipt )
self . SetReceipts ( self . receipts )
}
func ( self * Block ) RlpData ( ) interface { } {
return [ ] interface { } { self . header , self . transactions , self . uncles }
}
func ( b * Block ) Number ( ) * big . Int { return new ( big . Int ) . Set ( b . header . Number ) }
func ( b * Block ) GasLimit ( ) * big . Int { return new ( big . Int ) . Set ( b . header . GasLimit ) }
func ( b * Block ) GasUsed ( ) * big . Int { return new ( big . Int ) . Set ( b . header . GasUsed ) }
func ( b * Block ) Difficulty ( ) * big . Int { return new ( big . Int ) . Set ( b . header . Difficulty ) }
func ( self * Block ) RlpDataForStorage ( ) interface { } {
return [ ] interface { } { self . header , self . transactions , self . uncles , self . Td /* TODO receipts */ }
}
func ( b * Block ) NumberU64 ( ) uint64 { return b . header . Number . Uint64 ( ) }
func ( b * Block ) MixDigest ( ) common . Hash { return b . header . MixDigest }
func ( b * Block ) Nonce ( ) uint64 { return binary . BigEndian . Uint64 ( b . header . Nonce [ : ] ) }
func ( b * Block ) Bloom ( ) Bloom { return b . header . Bloom }
func ( b * Block ) Coinbase ( ) common . Address { return b . header . Coinbase }
func ( b * Block ) Time ( ) int64 { return int64 ( b . header . Time ) }
func ( b * Block ) Root ( ) common . Hash { return b . header . Root }
func ( b * Block ) ParentHash ( ) common . Hash { return b . header . ParentHash }
func ( b * Block ) TxHash ( ) common . Hash { return b . header . TxHash }
func ( b * Block ) ReceiptHash ( ) common . Hash { return b . header . ReceiptHash }
func ( b * Block ) UncleHash ( ) common . Hash { return b . header . UncleHash }
func ( b * Block ) Extra ( ) [ ] byte { return common . CopyBytes ( b . header . Extra ) }
// Header accessors (add as you need them)
func ( self * Block ) Number ( ) * big . Int { return self . header . Number }
func ( self * Block ) NumberU64 ( ) uint64 { return self . header . Number . Uint64 ( ) }
func ( self * Block ) MixDigest ( ) common . Hash { return self . header . MixDigest }
func ( self * Block ) Nonce ( ) uint64 {
return binary . BigEndian . Uint64 ( self . header . Nonce [ : ] )
}
func ( self * Block ) SetNonce ( nonce uint64 ) {
self . header . SetNonce ( nonce )
}
func ( b * Block ) Header ( ) * Header { return copyHeader ( b . header ) }
func ( self * Block ) Queued ( ) bool { return self . queued }
func ( self * Block ) SetQueued ( q bool ) { self . queued = q }
func ( self * Block ) Bloom ( ) Bloom { return self . header . Bloom }
func ( self * Block ) Coinbase ( ) common . Address { return self . header . Coinbase }
func ( self * Block ) Time ( ) int64 { return int64 ( self . header . Time ) }
func ( self * Block ) GasLimit ( ) * big . Int { return self . header . GasLimit }
func ( self * Block ) GasUsed ( ) * big . Int { return self . header . GasUsed }
func ( self * Block ) Root ( ) common . Hash { return self . header . Root }
func ( self * Block ) SetRoot ( root common . Hash ) { self . header . Root = root }
func ( self * Block ) GetTransaction ( i int ) * Transaction {
if len ( self . transactions ) > i {
return self . transactions [ i ]
}
return nil
}
func ( self * Block ) GetUncle ( i int ) * Header {
if len ( self . uncles ) > i {
return self . uncles [ i ]
}
return nil
func ( b * Block ) HashNoNonce ( ) common . Hash {
return b . header . HashNoNonce ( )
}
func ( self * Block ) Size ( ) common . StorageSize {
func ( b * Block ) Size ( ) common . StorageSize {
c := writeCounter ( 0 )
rlp . Encode ( & c , self )
rlp . Encode ( & c , b )
return common . StorageSize ( c )
}
@ -335,48 +307,32 @@ func (c *writeCounter) Write(b []byte) (int, error) {
return len ( b ) , nil
}
// Implement pow.Block
func ( self * Block ) Difficulty ( ) * big . Int { return self . header . Difficulty }
func ( self * Block ) HashNoNonce ( ) common . Hash { return self . header . HashNoNonce ( ) }
func ( self * Block ) Hash ( ) common . Hash {
if ( self . HeaderHash != common . Hash { } ) {
return self . HeaderHash
} else {
return self . header . Hash ( )
}
func CalcUncleHash ( uncles [ ] * Header ) common . Hash {
return rlpHash ( uncles )
}
func ( self * Block ) ParentHash ( ) common . Hash {
if ( self . ParentHeaderHash != common . Hash { } ) {
return self . ParentHeaderHash
} else {
return self . header . ParentHash
// WithMiningResult returns a new block with the data from b
// where nonce and mix digest are set to the provided values.
func ( b * Block ) WithMiningResult ( nonce uint64 , mixDigest common . Hash ) * Block {
cpy := * b . header
binary . BigEndian . PutUint64 ( cpy . Nonce [ : ] , nonce )
cpy . MixDigest = mixDigest
return & Block {
header : & cpy ,
transactions : b . transactions ,
receipts : b . receipts ,
uncles : b . uncles ,
Td : b . Td ,
}
}
func ( self * Block ) Copy ( ) * Block {
block := NewBlock ( self . header . ParentHash , self . Coinbase ( ) , self . Root ( ) , new ( big . Int ) , self . Nonce ( ) , self . header . Extra )
block . header . Bloom = self . header . Bloom
block . header . TxHash = self . header . TxHash
block . transactions = self . transactions
block . header . UncleHash = self . header . UncleHash
block . uncles = self . uncles
block . header . GasLimit . Set ( self . header . GasLimit )
block . header . GasUsed . Set ( self . header . GasUsed )
block . header . ReceiptHash = self . header . ReceiptHash
block . header . Difficulty . Set ( self . header . Difficulty )
block . header . Number . Set ( self . header . Number )
block . header . Time = self . header . Time
block . header . MixDigest = self . header . MixDigest
if self . Td != nil {
block . Td . Set ( self . Td )
}
// Implement pow.Block
return block
func ( b * Block ) Hash ( ) common . Hash {
return b . header . Hash ( )
}
func ( self * Block ) String ( ) string {
func ( b * Block ) String ( ) string {
str := fmt . Sprintf ( ` Block ( # % v ) : Size : % v TD : % v {
MinerHash : % x
% v
@ -385,20 +341,11 @@ Transactions:
Uncles :
% v
}
` , self . Number ( ) , self . Size ( ) , self . Td , self . header . HashNoNonce ( ) , self . header , self . transactions , self . uncles )
if ( self . HeaderHash != common . Hash { } ) {
str += fmt . Sprintf ( "\nFake hash = %x" , self . HeaderHash )
}
if ( self . ParentHeaderHash != common . Hash { } ) {
str += fmt . Sprintf ( "\nFake parent hash = %x" , self . ParentHeaderHash )
}
` , b . Number ( ) , b . Size ( ) , b . Td , b . header . HashNoNonce ( ) , b . header , b . transactions , b . uncles )
return str
}
func ( self * Header ) String ( ) string {
func ( h * Header ) String ( ) string {
return fmt . Sprintf ( ` Header ( % x ) :
[
ParentHash : % x
@ -414,9 +361,9 @@ func (self *Header) String() string {
GasUsed : % v
Time : % v
Extra : % s
MixDigest : % x
MixDigest : % x
Nonce : % x
] ` , self . Hash ( ) , self . ParentHash , self . UncleHash , self . Coinbase , self . Root , self . TxHash , self . ReceiptHash , self . Bloom , self . Difficulty , self . Number , self . GasLimit , self . GasUsed , self . Time , self . Extra , self . MixDigest , self . Nonce )
] ` , h . Hash ( ) , h . ParentHash , h . UncleHash , h . Coinbase , h . Root , h . TxHash , h . ReceiptHash , h . Bloom , h . Difficulty , h . Number , h . GasLimit , h . GasUsed , h . Time , h . Extra , h . MixDigest , h . Nonce )
}
type Blocks [ ] * Block
@ -442,4 +389,4 @@ func (self blockSorter) Swap(i, j int) {
}
func ( self blockSorter ) Less ( i , j int ) bool { return self . by ( self . blocks [ i ] , self . blocks [ j ] ) }
func Number ( b1 , b2 * Block ) bool { return b1 . Header ( ) . Number . Cmp ( b2 . Header ( ) . Number ) < 0 }
func Number ( b1 , b2 * Block ) bool { return b1 . header . Number . Cmp ( b2 . header . Number ) < 0 }
Felix Lange
10 years ago
committed by
Jeffrey Wilcke