From 42c8afd44006b170c20159abaadc31cc7545bec2 Mon Sep 17 00:00:00 2001 From: Péter Szilágyi Date: Tue, 29 Sep 2015 19:36:16 +0300 Subject: core: differentiate receipt concensus and storage decoding --- core/block_processor.go | 4 +- core/block_processor_test.go | 4 +- core/chain_makers.go | 2 +- core/transaction_util.go | 10 ++-- core/types/bloom9.go | 2 +- core/types/receipt.go | 122 ++++++++++++++++++++++++++----------------- core/vm/log.go | 37 +++++++------ eth/filters/filter.go | 2 +- rpc/api/parsing.go | 4 +- 9 files changed, 110 insertions(+), 77 deletions(-) diff --git a/core/block_processor.go b/core/block_processor.go index 5dadd2a27..ba6350805 100644 --- a/core/block_processor.go +++ b/core/block_processor.go @@ -111,7 +111,7 @@ func (self *BlockProcessor) ApplyTransaction(gp GasPool, statedb *state.StateDB, } logs := statedb.GetLogs(tx.Hash()) - receipt.SetLogs(logs) + receipt.Logs = logs receipt.Bloom = types.CreateBloom(types.Receipts{receipt}) glog.V(logger.Debug).Infoln(receipt) @@ -364,7 +364,7 @@ func (sm *BlockProcessor) GetLogs(block *types.Block) (logs vm.Logs, err error) receipts := GetBlockReceipts(sm.chainDb, block.Hash()) // coalesce logs for _, receipt := range receipts { - logs = append(logs, receipt.Logs()...) + logs = append(logs, receipt.Logs...) } return logs, nil } diff --git a/core/block_processor_test.go b/core/block_processor_test.go index e0e5607b9..c2c85ebfa 100644 --- a/core/block_processor_test.go +++ b/core/block_processor_test.go @@ -70,7 +70,7 @@ func TestPutReceipt(t *testing.T) { hash[0] = 2 receipt := new(types.Receipt) - receipt.SetLogs(vm.Logs{&vm.Log{ + receipt.Logs = vm.Logs{&vm.Log{ Address: addr, Topics: []common.Hash{hash}, Data: []byte("hi"), @@ -79,7 +79,7 @@ func TestPutReceipt(t *testing.T) { TxIndex: 0, BlockHash: hash, Index: 0, - }}) + }} PutReceipts(db, types.Receipts{receipt}) receipt = GetReceipt(db, common.Hash{}) diff --git a/core/chain_makers.go b/core/chain_makers.go index eb451c00d..be6ba04e4 100644 --- a/core/chain_makers.go +++ b/core/chain_makers.go @@ -99,7 +99,7 @@ func (b *BlockGen) AddTx(tx *types.Transaction) { b.header.GasUsed.Add(b.header.GasUsed, gas) receipt := types.NewReceipt(root.Bytes(), b.header.GasUsed) logs := b.statedb.GetLogs(tx.Hash()) - receipt.SetLogs(logs) + receipt.Logs = logs receipt.Bloom = types.CreateBloom(types.Receipts{receipt}) b.txs = append(b.txs, tx) b.receipts = append(b.receipts, receipt) diff --git a/core/transaction_util.go b/core/transaction_util.go index 9a82ec4dc..dbda4cfe7 100644 --- a/core/transaction_util.go +++ b/core/transaction_util.go @@ -140,12 +140,16 @@ func GetBlockReceipts(db ethdb.Database, hash common.Hash) types.Receipts { if len(data) == 0 { return nil } - receipts := new(types.Receipts) - if err := rlp.DecodeBytes(data, receipts); err != nil { + rs := []*types.ReceiptForStorage{} + if err := rlp.DecodeBytes(data, &rs); err != nil { glog.V(logger.Error).Infof("invalid receipt array RLP for hash %x: %v", hash, err) return nil } - return *receipts + receipts := make(types.Receipts, len(rs)) + for i, receipt := range rs { + receipts[i] = (*types.Receipt)(receipt) + } + return receipts } // PutBlockReceipts stores the block's transactions associated receipts diff --git a/core/types/bloom9.go b/core/types/bloom9.go index 97db20ee9..cd90fd971 100644 --- a/core/types/bloom9.go +++ b/core/types/bloom9.go @@ -72,7 +72,7 @@ func (b Bloom) TestBytes(test []byte) bool { func CreateBloom(receipts Receipts) Bloom { bin := new(big.Int) for _, receipt := range receipts { - bin.Or(bin, LogsBloom(receipt.logs)) + bin.Or(bin, LogsBloom(receipt.Logs)) } return BytesToBloom(bin.Bytes()) diff --git a/core/types/receipt.go b/core/types/receipt.go index bcb4bd8a5..d85fe16cf 100644 --- a/core/types/receipt.go +++ b/core/types/receipt.go @@ -17,7 +17,6 @@ package types import ( - "bytes" "fmt" "io" "math/big" @@ -27,89 +26,116 @@ import ( "github.com/ethereum/go-ethereum/rlp" ) +// Receipt represents the results of a transaction. type Receipt struct { + // Consensus fields PostState []byte CumulativeGasUsed *big.Int Bloom Bloom - TxHash common.Hash - ContractAddress common.Address - logs vm.Logs - GasUsed *big.Int + Logs vm.Logs + + // Implementation fields + TxHash common.Hash + ContractAddress common.Address + GasUsed *big.Int } +// NewReceipt creates a barebone transaction receipt, copying the init fields. func NewReceipt(root []byte, cumalativeGasUsed *big.Int) *Receipt { return &Receipt{PostState: common.CopyBytes(root), CumulativeGasUsed: new(big.Int).Set(cumalativeGasUsed)} } -func (self *Receipt) SetLogs(logs vm.Logs) { - self.logs = logs -} - -func (self *Receipt) Logs() vm.Logs { - return self.logs -} - -func (self *Receipt) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, []interface{}{self.PostState, self.CumulativeGasUsed, self.Bloom, self.logs}) +// EncodeRLP implements rlp.Encoder, and flattens the consensus fields of a receipt +// into an RLP stream. +func (r *Receipt) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, []interface{}{r.PostState, r.CumulativeGasUsed, r.Bloom, r.Logs}) } -func (self *Receipt) DecodeRLP(s *rlp.Stream) error { - var r struct { +// DecodeRLP implements rlp.Decoder, and loads the consensus fields of a receipt +// from an RLP stream. +func (r *Receipt) DecodeRLP(s *rlp.Stream) error { + var receipt struct { PostState []byte CumulativeGasUsed *big.Int Bloom Bloom - TxHash common.Hash - ContractAddress common.Address Logs vm.Logs - GasUsed *big.Int } - if err := s.Decode(&r); err != nil { + if err := s.Decode(&receipt); err != nil { return err } - self.PostState, self.CumulativeGasUsed, self.Bloom, self.TxHash, self.ContractAddress, self.logs, self.GasUsed = r.PostState, r.CumulativeGasUsed, r.Bloom, r.TxHash, r.ContractAddress, r.Logs, r.GasUsed - + r.PostState, r.CumulativeGasUsed, r.Bloom, r.Logs = receipt.PostState, receipt.CumulativeGasUsed, receipt.Bloom, receipt.Logs return nil } -type ReceiptForStorage Receipt - -func (self *ReceiptForStorage) EncodeRLP(w io.Writer) error { - storageLogs := make([]*vm.LogForStorage, len(self.logs)) - for i, log := range self.logs { - storageLogs[i] = (*vm.LogForStorage)(log) - } - return rlp.Encode(w, []interface{}{self.PostState, self.CumulativeGasUsed, self.Bloom, self.TxHash, self.ContractAddress, storageLogs, self.GasUsed}) -} - -func (self *Receipt) RlpEncode() []byte { - bytes, err := rlp.EncodeToBytes(self) +// RlpEncode implements common.RlpEncode required for SHA derivation. +func (r *Receipt) RlpEncode() []byte { + bytes, err := rlp.EncodeToBytes(r) if err != nil { - fmt.Println("TMP -- RECEIPT ENCODE ERROR", err) + panic(err) } return bytes } -func (self *Receipt) Cmp(other *Receipt) bool { - if bytes.Compare(self.PostState, other.PostState) != 0 { - return false - } +// String implements the Stringer interface. +func (r *Receipt) String() string { + return fmt.Sprintf("receipt{med=%x cgas=%v bloom=%x logs=%v}", r.PostState, r.CumulativeGasUsed, r.Bloom, r.Logs) +} - return true +// ReceiptForStorage is a wrapper around a Receipt that flattens and parses the +// entire content of a receipt, opposed to only the consensus fields originally. +type ReceiptForStorage Receipt + +// EncodeRLP implements rlp.Encoder, and flattens all content fields of a receipt +// into an RLP stream. +func (r *ReceiptForStorage) EncodeRLP(w io.Writer) error { + logs := make([]*vm.LogForStorage, len(r.Logs)) + for i, log := range r.Logs { + logs[i] = (*vm.LogForStorage)(log) + } + return rlp.Encode(w, []interface{}{r.PostState, r.CumulativeGasUsed, r.Bloom, r.TxHash, r.ContractAddress, logs, r.GasUsed}) } -func (self *Receipt) String() string { - return fmt.Sprintf("receipt{med=%x cgas=%v bloom=%x logs=%v}", self.PostState, self.CumulativeGasUsed, self.Bloom, self.logs) +// DecodeRLP implements rlp.Decoder, and loads the consensus fields of a receipt +// from an RLP stream. +func (r *ReceiptForStorage) DecodeRLP(s *rlp.Stream) error { + var receipt struct { + PostState []byte + CumulativeGasUsed *big.Int + Bloom Bloom + TxHash common.Hash + ContractAddress common.Address + Logs []*vm.LogForStorage + GasUsed *big.Int + } + if err := s.Decode(&receipt); err != nil { + return err + } + // Assign the consensus fields + r.PostState, r.CumulativeGasUsed, r.Bloom = receipt.PostState, receipt.CumulativeGasUsed, receipt.Bloom + r.Logs = make(vm.Logs, len(receipt.Logs)) + for i, log := range receipt.Logs { + r.Logs[i] = (*vm.Log)(log) + } + // Assign the implementation fields + r.TxHash, r.ContractAddress, r.GasUsed = receipt.TxHash, receipt.ContractAddress, receipt.GasUsed + + return nil } +// Receipts is a wrapper around a Receipt array to implement types.DerivableList. type Receipts []*Receipt -func (self Receipts) RlpEncode() []byte { - bytes, err := rlp.EncodeToBytes(self) +// RlpEncode implements common.RlpEncode required for SHA derivation. +func (r Receipts) RlpEncode() []byte { + bytes, err := rlp.EncodeToBytes(r) if err != nil { - fmt.Println("TMP -- RECEIPTS ENCODE ERROR", err) + panic(err) } return bytes } -func (self Receipts) Len() int { return len(self) } -func (self Receipts) GetRlp(i int) []byte { return common.Rlp(self[i]) } +// Len returns the number of receipts in this list. +func (r Receipts) Len() int { return len(r) } + +// GetRlp returns the RLP encoding of one receipt from the list. +func (r Receipts) GetRlp(i int) []byte { return common.Rlp(r[i]) } diff --git a/core/vm/log.go b/core/vm/log.go index 354f0ad35..822476f85 100644 --- a/core/vm/log.go +++ b/core/vm/log.go @@ -40,27 +40,30 @@ func NewLog(address common.Address, topics []common.Hash, data []byte, number ui return &Log{Address: address, Topics: topics, Data: data, Number: number} } -func (self *Log) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, []interface{}{self.Address, self.Topics, self.Data}) +func (l *Log) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, []interface{}{l.Address, l.Topics, l.Data}) } -func (self *Log) String() string { - return fmt.Sprintf(`log: %x %x %x %x %d %x %d`, self.Address, self.Topics, self.Data, self.TxHash, self.TxIndex, self.BlockHash, self.Index) +func (l *Log) DecodeRLP(s *rlp.Stream) error { + var log struct { + Address common.Address + Topics []common.Hash + Data []byte + } + if err := s.Decode(&log); err != nil { + return err + } + l.Address, l.Topics, l.Data = log.Address, log.Topics, log.Data + return nil +} + +func (l *Log) String() string { + return fmt.Sprintf(`log: %x %x %x %x %d %x %d`, l.Address, l.Topics, l.Data, l.TxHash, l.TxIndex, l.BlockHash, l.Index) } type Logs []*Log +// LogForStorage is a wrapper around a Log that flattens and parses the entire +// content of a log, opposed to only the consensus fields originally (by hiding +// the rlp interface methods). type LogForStorage Log - -func (self *LogForStorage) EncodeRLP(w io.Writer) error { - return rlp.Encode(w, []interface{}{ - self.Address, - self.Topics, - self.Data, - self.Number, - self.TxHash, - self.TxIndex, - self.BlockHash, - self.Index, - }) -} diff --git a/eth/filters/filter.go b/eth/filters/filter.go index 2e81ea177..ff192cdf6 100644 --- a/eth/filters/filter.go +++ b/eth/filters/filter.go @@ -138,7 +138,7 @@ func (self *Filter) getLogs(start, end uint64) (logs vm.Logs) { unfiltered vm.Logs ) for _, receipt := range receipts { - unfiltered = append(unfiltered, receipt.Logs()...) + unfiltered = append(unfiltered, receipt.Logs...) } logs = append(logs, self.FilterLogs(unfiltered)...) } diff --git a/rpc/api/parsing.go b/rpc/api/parsing.go index cdfaa0ed1..7667616ff 100644 --- a/rpc/api/parsing.go +++ b/rpc/api/parsing.go @@ -453,8 +453,8 @@ func NewReceiptRes(rec *types.Receipt) *ReceiptRes { v.ContractAddress = newHexData(rec.ContractAddress) } - logs := make([]interface{}, len(rec.Logs())) - for i, log := range rec.Logs() { + logs := make([]interface{}, len(rec.Logs)) + for i, log := range rec.Logs { logs[i] = NewLogRes(log) } v.Logs = &logs -- cgit