plugeth/chain/block.go

420 lines
9.2 KiB
Go
Raw Normal View History

2014-10-31 09:59:17 +00:00
package chain
2014-02-14 22:56:09 +00:00
import (
2014-05-22 15:56:33 +00:00
"bytes"
2014-02-14 22:56:09 +00:00
"fmt"
2014-07-26 09:24:44 +00:00
"math/big"
2014-09-15 13:42:12 +00:00
"sort"
2014-07-26 09:24:44 +00:00
"time"
2014-10-31 11:37:43 +00:00
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethtrie"
"github.com/ethereum/go-ethereum/ethutil"
2014-02-14 22:56:09 +00:00
)
type BlockInfo struct {
Number uint64
Hash []byte
Parent []byte
2014-09-24 09:39:17 +00:00
TD *big.Int
2014-02-14 22:56:09 +00:00
}
func (bi *BlockInfo) RlpDecode(data []byte) {
decoder := ethutil.NewValueFromBytes(data)
bi.Number = decoder.Get(0).Uint()
bi.Hash = decoder.Get(1).Bytes()
bi.Parent = decoder.Get(2).Bytes()
2014-09-24 09:39:17 +00:00
bi.TD = decoder.Get(3).BigInt()
2014-02-14 22:56:09 +00:00
}
func (bi *BlockInfo) RlpEncode() []byte {
2014-09-24 09:39:17 +00:00
return ethutil.Encode([]interface{}{bi.Number, bi.Hash, bi.Parent, bi.TD})
2014-02-14 22:56:09 +00:00
}
2014-09-14 23:11:01 +00:00
type Blocks []*Block
func (self Blocks) AsSet() ethutil.UniqueSet {
set := make(ethutil.UniqueSet)
for _, block := range self {
set.Insert(block.Hash())
}
return set
}
2014-09-15 13:42:12 +00:00
type BlockBy func(b1, b2 *Block) bool
func (self BlockBy) Sort(blocks Blocks) {
bs := blockSorter{
blocks: blocks,
by: self,
}
sort.Sort(bs)
}
type blockSorter struct {
blocks Blocks
by func(b1, b2 *Block) bool
}
func (self blockSorter) Len() int { return len(self.blocks) }
func (self blockSorter) Swap(i, j int) {
self.blocks[i], self.blocks[j] = self.blocks[j], self.blocks[i]
}
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.Number.Cmp(b2.Number) < 0 }
2014-02-14 22:56:09 +00:00
type Block struct {
// Hash to the previous block
2014-09-15 13:42:12 +00:00
PrevHash ethutil.Bytes
2014-02-14 22:56:09 +00:00
// Uncles of this block
2014-09-14 23:11:01 +00:00
Uncles Blocks
2014-02-14 22:56:09 +00:00
UncleSha []byte
// The coin base address
Coinbase []byte
// Block Trie state
//state *ethutil.Trie
2014-07-24 10:04:15 +00:00
state *ethstate.State
2014-02-14 22:56:09 +00:00
// Difficulty for the current block
Difficulty *big.Int
// Creation time
Time int64
2014-05-20 12:29:52 +00:00
// The block number
Number *big.Int
// Minimum Gas Price
MinGasPrice *big.Int
// Gas limit
GasLimit *big.Int
// Gas used
GasUsed *big.Int
2014-02-14 22:56:09 +00:00
// Extra data
Extra string
// Block Nonce for verification
2014-09-15 13:42:12 +00:00
Nonce ethutil.Bytes
2014-02-14 22:56:09 +00:00
// List of transactions and/or contracts
transactions Transactions
receipts Receipts
TxSha, ReceiptSha []byte
LogsBloom []byte
2014-02-14 22:56:09 +00:00
}
func NewBlockFromBytes(raw []byte) *Block {
block := &Block{}
block.RlpDecode(raw)
return block
}
// New block takes a raw encoded string
func NewBlockFromRlpValue(rlpValue *ethutil.Value) *Block {
block := &Block{}
block.RlpValueDecode(rlpValue)
return block
}
func CreateBlock(root interface{},
prevHash []byte,
base []byte,
Difficulty *big.Int,
Nonce []byte,
extra string) *Block {
2014-02-14 22:56:09 +00:00
block := &Block{
PrevHash: prevHash,
Coinbase: base,
Difficulty: Difficulty,
Nonce: Nonce,
Time: time.Now().Unix(),
Extra: extra,
2014-10-21 11:30:23 +00:00
UncleSha: nil,
GasUsed: new(big.Int),
MinGasPrice: new(big.Int),
GasLimit: new(big.Int),
2014-02-14 22:56:09 +00:00
}
block.SetUncles([]*Block{})
2014-08-04 08:42:40 +00:00
block.state = ethstate.New(ethtrie.New(ethutil.Config.Db, root))
2014-02-14 22:56:09 +00:00
return block
}
// Returns a hash of the block
2014-09-15 13:42:12 +00:00
func (block *Block) Hash() ethutil.Bytes {
2014-10-31 11:37:43 +00:00
return crypto.Sha3(ethutil.NewValue(block.header()).Encode())
//return crypto.Sha3(block.Value().Encode())
2014-02-14 22:56:09 +00:00
}
func (block *Block) HashNoNonce() []byte {
2014-10-31 11:37:43 +00:00
return crypto.Sha3(ethutil.Encode(block.miningHeader()))
2014-02-14 22:56:09 +00:00
}
2014-07-24 10:04:15 +00:00
func (block *Block) State() *ethstate.State {
2014-02-14 22:56:09 +00:00
return block.state
}
func (block *Block) Transactions() []*Transaction {
return block.transactions
}
func (block *Block) CalcGasLimit(parent *Block) *big.Int {
2014-06-11 14:16:57 +00:00
if block.Number.Cmp(big.NewInt(0)) == 0 {
return ethutil.BigPow(10, 6)
}
2014-06-11 14:16:57 +00:00
2014-08-09 17:06:16 +00:00
// ((1024-1) * parent.gasLimit + (gasUsed * 6 / 5)) / 1024
previous := new(big.Int).Mul(big.NewInt(1024-1), parent.GasLimit)
current := new(big.Rat).Mul(new(big.Rat).SetInt(parent.GasUsed), big.NewRat(6, 5))
curInt := new(big.Int).Div(current.Num(), current.Denom())
result := new(big.Int).Add(previous, curInt)
result.Div(result, big.NewInt(1024))
2014-07-01 13:25:57 +00:00
min := big.NewInt(125000)
return ethutil.BigMax(min, result)
}
2014-02-14 22:56:09 +00:00
func (block *Block) BlockInfo() BlockInfo {
bi := BlockInfo{}
data, _ := ethutil.Config.Db.Get(append(block.Hash(), []byte("Info")...))
bi.RlpDecode(data)
return bi
}
2014-05-22 15:56:33 +00:00
func (self *Block) GetTransaction(hash []byte) *Transaction {
for _, tx := range self.transactions {
if bytes.Compare(tx.Hash(), hash) == 0 {
return tx
2014-05-22 15:56:33 +00:00
}
}
return nil
}
2014-02-19 10:35:17 +00:00
// Sync the block's state and contract respectively
func (block *Block) Sync() {
block.state.Sync()
2014-02-19 10:35:17 +00:00
}
func (block *Block) Undo() {
// Sync the block state itself
block.state.Reset()
2014-02-19 10:35:17 +00:00
}
2014-02-14 22:56:09 +00:00
/////// Block Encoding
func (block *Block) rlpReceipts() interface{} {
2014-02-14 22:56:09 +00:00
// Marshal the transactions of this block
encR := make([]interface{}, len(block.receipts))
for i, r := range block.receipts {
2014-02-14 22:56:09 +00:00
// Cast it to a string (safe)
encR[i] = r.RlpData()
2014-02-14 22:56:09 +00:00
}
return encR
2014-02-14 22:56:09 +00:00
}
func (block *Block) rlpUncles() interface{} {
// Marshal the transactions of this block
uncles := make([]interface{}, len(block.Uncles))
for i, uncle := range block.Uncles {
// Cast it to a string (safe)
uncles[i] = uncle.header()
}
return uncles
}
func (block *Block) SetUncles(uncles []*Block) {
block.Uncles = uncles
2014-10-31 11:37:43 +00:00
block.UncleSha = crypto.Sha3(ethutil.Encode(block.rlpUncles()))
2014-02-14 22:56:09 +00:00
}
2014-10-29 13:20:42 +00:00
func (self *Block) SetReceipts(receipts Receipts) {
self.receipts = receipts
self.ReceiptSha = DeriveSha(receipts)
self.LogsBloom = CreateBloom(self)
2014-10-29 13:20:42 +00:00
}
func (self *Block) SetTransactions(txs Transactions) {
self.transactions = txs
self.TxSha = DeriveSha(txs)
2014-02-14 22:56:09 +00:00
}
2014-02-15 00:34:18 +00:00
func (block *Block) Value() *ethutil.Value {
return ethutil.NewValue([]interface{}{block.header(), block.transactions, block.rlpUncles()})
2014-02-14 22:56:09 +00:00
}
func (block *Block) RlpEncode() []byte {
// Encode a slice interface which contains the header and the list of
// transactions.
2014-02-15 00:34:18 +00:00
return block.Value().Encode()
2014-02-14 22:56:09 +00:00
}
func (block *Block) RlpDecode(data []byte) {
rlpValue := ethutil.NewValueFromBytes(data)
block.RlpValueDecode(rlpValue)
}
func (block *Block) RlpValueDecode(decoder *ethutil.Value) {
block.setHeader(decoder.Get(0))
2014-02-14 22:56:09 +00:00
// Tx list might be empty if this is an uncle. Uncles only have their
// header set.
if decoder.Get(1).IsNil() == false { // Yes explicitness
//receipts := decoder.Get(1)
//block.receipts = make([]*Receipt, receipts.Len())
txs := decoder.Get(1)
block.transactions = make(Transactions, txs.Len())
for i := 0; i < txs.Len(); i++ {
block.transactions[i] = NewTransactionFromValue(txs.Get(i))
//receipt := NewRecieptFromValue(receipts.Get(i))
//block.transactions[i] = receipt.Tx
//block.receipts[i] = receipt
2014-02-14 22:56:09 +00:00
}
}
if decoder.Get(2).IsNil() == false { // Yes explicitness
uncles := decoder.Get(2)
block.Uncles = make([]*Block, uncles.Len())
for i := 0; i < uncles.Len(); i++ {
block.Uncles[i] = NewUncleBlockFromValue(uncles.Get(i))
}
}
}
func (self *Block) setHeader(header *ethutil.Value) {
self.PrevHash = header.Get(0).Bytes()
self.UncleSha = header.Get(1).Bytes()
self.Coinbase = header.Get(2).Bytes()
self.state = ethstate.New(ethtrie.New(ethutil.Config.Db, header.Get(3).Val))
self.TxSha = header.Get(4).Bytes()
self.ReceiptSha = header.Get(5).Bytes()
self.LogsBloom = header.Get(6).Bytes()
self.Difficulty = header.Get(7).BigInt()
self.Number = header.Get(8).BigInt()
self.MinGasPrice = header.Get(9).BigInt()
self.GasLimit = header.Get(10).BigInt()
self.GasUsed = header.Get(11).BigInt()
self.Time = int64(header.Get(12).BigInt().Uint64())
self.Extra = header.Get(13).Str()
self.Nonce = header.Get(14).Bytes()
}
2014-02-14 22:56:09 +00:00
func NewUncleBlockFromValue(header *ethutil.Value) *Block {
block := &Block{}
block.setHeader(header)
2014-02-14 22:56:09 +00:00
return block
}
2014-10-10 22:41:37 +00:00
func (block *Block) Trie() *ethtrie.Trie {
return block.state.Trie
}
2014-03-20 10:20:29 +00:00
func (block *Block) GetRoot() interface{} {
2014-07-24 10:04:15 +00:00
return block.state.Trie.Root
2014-03-20 10:20:29 +00:00
}
2014-02-14 22:56:09 +00:00
func (block *Block) Diff() *big.Int {
return block.Difficulty
}
func (self *Block) Receipts() []*Receipt {
return self.receipts
}
func (block *Block) miningHeader() []interface{} {
2014-02-14 22:56:09 +00:00
return []interface{}{
// Sha of the previous block
block.PrevHash,
// Sha of uncles
block.UncleSha,
// Coinbase address
block.Coinbase,
// root state
2014-07-24 10:04:15 +00:00
block.state.Trie.Root,
// tx root
2014-02-14 22:56:09 +00:00
block.TxSha,
// Sha of tx
block.ReceiptSha,
// Bloom
block.LogsBloom,
2014-02-14 22:56:09 +00:00
// Current block Difficulty
block.Difficulty,
2014-05-20 12:29:52 +00:00
// The block number
block.Number,
// Block minimum gas price
block.MinGasPrice,
// Block upper gas bound
block.GasLimit,
// Block gas used
block.GasUsed,
2014-02-14 22:56:09 +00:00
// Time the block was found?
block.Time,
// Extra data
block.Extra,
}
}
2014-05-20 13:02:46 +00:00
func (block *Block) header() []interface{} {
return append(block.miningHeader(), block.Nonce)
}
2014-05-20 13:02:46 +00:00
func (block *Block) String() string {
return fmt.Sprintf(`
2014-08-25 10:53:06 +00:00
BLOCK(%x): Size: %v
2014-05-20 13:02:46 +00:00
PrevHash: %x
UncleSha: %x
Coinbase: %x
Root: %x
TxSha %x
ReceiptSha: %x
Bloom: %x
2014-05-20 13:02:46 +00:00
Difficulty: %v
Number: %v
MinGas: %v
MaxLimit: %v
GasUsed: %v
Time: %v
Extra: %v
Nonce: %x
NumTx: %v
2014-05-20 13:02:46 +00:00
`,
block.Hash(),
2014-08-25 10:53:06 +00:00
block.Size(),
2014-05-20 13:02:46 +00:00
block.PrevHash,
block.UncleSha,
block.Coinbase,
2014-07-24 10:04:15 +00:00
block.state.Trie.Root,
2014-05-20 13:02:46 +00:00
block.TxSha,
block.ReceiptSha,
block.LogsBloom,
2014-05-20 13:02:46 +00:00
block.Difficulty,
block.Number,
block.MinGasPrice,
block.GasLimit,
block.GasUsed,
block.Time,
block.Extra,
block.Nonce,
len(block.transactions),
)
2014-05-20 13:02:46 +00:00
}
2014-08-25 10:53:06 +00:00
func (self *Block) Size() ethutil.StorageSize {
return ethutil.StorageSize(len(self.RlpEncode()))
}
2014-10-29 13:20:42 +00:00
// Implement RlpEncodable
func (self *Block) RlpData() interface{} {
return self.Value().Val
}