From 9f00aeae29d53fec358fcecdc9bcc162b8e3984c Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 18 Jul 2014 16:13:21 +0200 Subject: [PATCH 1/3] Base time on previous parent, not last block --- ethchain/state_manager.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ethchain/state_manager.go b/ethchain/state_manager.go index a12ce53e5..f28f45eab 100644 --- a/ethchain/state_manager.go +++ b/ethchain/state_manager.go @@ -312,9 +312,9 @@ func (sm *StateManager) ValidateBlock(block *Block) error { } } - diff := block.Time - sm.bc.CurrentBlock.Time + diff := block.Time - previousBlock.Time if diff < 0 { - return ValidationError("Block timestamp less then prev block %v", diff) + return ValidationError("Block timestamp less then prev block %v (%v - %v)", diff, block.Time, sm.bc.CurrentBlock.Time) } /* XXX From 93261b98c2bc664af30676129def291ff9e8a9ce Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 21 Jul 2014 11:56:04 +0200 Subject: [PATCH 2/3] Changed iterator --- ethchain/state.go | 14 ++------------ ethchain/state_object.go | 26 ++++++++++++++++++++++++++ ethchain/vm.go | 2 +- ethpub/types.go | 4 ++-- 4 files changed, 31 insertions(+), 15 deletions(-) diff --git a/ethchain/state.go b/ethchain/state.go index 684b81102..3a9929ecc 100644 --- a/ethchain/state.go +++ b/ethchain/state.go @@ -1,7 +1,6 @@ package ethchain import ( - "fmt" "github.com/ethereum/eth-go/ethcrypto" "github.com/ethereum/eth-go/ethtrie" "github.com/ethereum/eth-go/ethutil" @@ -27,12 +26,6 @@ func NewState(trie *ethtrie.Trie) *State { return &State{trie: trie, stateObjects: make(map[string]*StateObject), manifest: NewManifest()} } -// Iterate over each storage address and yield callback -func (s *State) EachStorage(cb ethtrie.EachCallback) { - it := s.trie.NewIterator() - it.Each(cb) -} - // Retrieve the balance from the given address or 0 if object not found func (self *State) GetBalance(addr []byte) *big.Int { stateObject := self.GetStateObject(addr) @@ -214,11 +207,8 @@ func (self *State) Update() { // Debug stuff func (self *State) CreateOutputForDiff() { - for addr, stateObject := range self.stateObjects { - fmt.Printf("%x %x %x %x\n", addr, stateObject.state.Root(), stateObject.Amount.Bytes(), stateObject.Nonce) - stateObject.state.EachStorage(func(addr string, value *ethutil.Value) { - fmt.Printf("%x %x\n", addr, value.Bytes()) - }) + for _, stateObject := range self.stateObjects { + stateObject.CreateOutputForDiff() } } diff --git a/ethchain/state_object.go b/ethchain/state_object.go index 8e7b5fece..184609015 100644 --- a/ethchain/state_object.go +++ b/ethchain/state_object.go @@ -151,6 +151,24 @@ func (self *StateObject) setStorage(k []byte, value *ethutil.Value) { */ } +// Iterate over each storage address and yield callback +func (self *StateObject) EachStorage(cb ethtrie.EachCallback) { + // First loop over the uncommit/cached values in storage + for key, value := range self.storage { + // XXX Most iterators Fns as it stands require encoded values + encoded := ethutil.NewValue(value.Encode()) + cb(key, encoded) + } + + it := self.state.trie.NewIterator() + it.Each(func(key string, value *ethutil.Value) { + // If it's cached don't call the callback. + if self.storage[key] == nil { + cb(key, value) + } + }) +} + func (self *StateObject) Sync() { /* fmt.Println("############# BEFORE ################") @@ -303,6 +321,14 @@ func (c *StateObject) Init() Code { return c.initScript } +// Debug stuff +func (self *StateObject) CreateOutputForDiff() { + fmt.Printf("%x %x %x %x\n", self.Address(), self.state.Root(), self.Amount.Bytes(), self.Nonce) + self.EachStorage(func(addr string, value *ethutil.Value) { + fmt.Printf("%x %x\n", addr, value.Bytes()) + }) +} + // // Encoding // diff --git a/ethchain/vm.go b/ethchain/vm.go index 4fdf8b31a..9d47f950d 100644 --- a/ethchain/vm.go +++ b/ethchain/vm.go @@ -158,7 +158,7 @@ func (vm *Vm) RunClosure(closure *Closure) (ret []byte, err error) { switch op { case STOP, RETURN, SUICIDE: closure.object.Sync() - closure.object.state.EachStorage(func(key string, value *ethutil.Value) { + closure.object.EachStorage(func(key string, value *ethutil.Value) { value.Decode() fmt.Printf("%x %x\n", new(big.Int).SetBytes([]byte(key)).Bytes(), value.Bytes()) }) diff --git a/ethpub/types.go b/ethpub/types.go index 9e5159a4c..52ea5a6bb 100644 --- a/ethpub/types.go +++ b/ethpub/types.go @@ -215,7 +215,7 @@ func (c *PStateObject) IsContract() bool { } func (self *PStateObject) EachStorage(cb ethtrie.EachCallback) { - self.object.State().EachStorage(cb) + self.object.EachStorage(cb) } type KeyVal struct { @@ -226,7 +226,7 @@ type KeyVal struct { func (c *PStateObject) StateKeyVal(asJson bool) interface{} { var values []KeyVal if c.object != nil { - c.object.State().EachStorage(func(name string, value *ethutil.Value) { + c.object.EachStorage(func(name string, value *ethutil.Value) { values = append(values, KeyVal{name, ethutil.Bytes2Hex(value.Bytes())}) }) } From 5d2669dbd35b9449cbbb249dcec89e2a64c90f30 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 21 Jul 2014 12:21:34 +0200 Subject: [PATCH 3/3] Fixed tx sha creation --- ethchain/block.go | 33 ++++++++++++++++++++++++++++----- ethchain/state_manager.go | 17 ++++++----------- ethminer/miner.go | 1 + 3 files changed, 35 insertions(+), 16 deletions(-) diff --git a/ethchain/block.go b/ethchain/block.go index a0f9ecd86..447d55f99 100644 --- a/ethchain/block.go +++ b/ethchain/block.go @@ -7,7 +7,7 @@ import ( "github.com/ethereum/eth-go/ethtrie" "github.com/ethereum/eth-go/ethutil" "math/big" - "strconv" + _ "strconv" "time" ) @@ -252,20 +252,43 @@ func (self *Block) SetReceipts(receipts []*Receipt, txs []*Transaction) { func (block *Block) setTransactions(txs []*Transaction) { block.transactions = txs + /* + trie := ethtrie.NewTrie(ethutil.Config.Db, "") + for i, tx := range txs { + trie.Update(strconv.Itoa(i), string(tx.RlpEncode())) + } + + switch trie.Root.(type) { + case string: + block.TxSha = []byte(trie.Root.(string)) + case []byte: + block.TxSha = trie.Root.([]byte) + default: + panic(fmt.Sprintf("invalid root type %T", trie.Root)) + } + */ +} + +func CreateTxSha(receipts Receipts) (sha []byte) { trie := ethtrie.NewTrie(ethutil.Config.Db, "") - for i, tx := range txs { - trie.Update(strconv.Itoa(i), string(tx.RlpEncode())) + for i, receipt := range receipts { + trie.Update(string(ethutil.NewValue(i).Encode()), string(ethutil.NewValue(receipt.RlpData()).Encode())) } switch trie.Root.(type) { case string: - block.TxSha = []byte(trie.Root.(string)) + sha = []byte(trie.Root.(string)) case []byte: - block.TxSha = trie.Root.([]byte) + sha = trie.Root.([]byte) default: panic(fmt.Sprintf("invalid root type %T", trie.Root)) } + return sha +} + +func (self *Block) SetTxHash(receipts Receipts) { + self.TxSha = CreateTxSha(receipts) } func (block *Block) Value() *ethutil.Value { diff --git a/ethchain/state_manager.go b/ethchain/state_manager.go index f28f45eab..6a6c67492 100644 --- a/ethchain/state_manager.go +++ b/ethchain/state_manager.go @@ -201,11 +201,16 @@ func (sm *StateManager) Process(block *Block, dontReact bool) (err error) { fmt.Printf("## %x %x ##\n", block.Hash(), block.Number) } - _, err = sm.ApplyDiff(state, parent, block) + receipts, err := sm.ApplyDiff(state, parent, block) if err != nil { return err } + txSha := CreateTxSha(receipts) + if bytes.Compare(txSha, block.TxSha) != 0 { + return fmt.Errorf("Error validating tx sha. Received %x, got %x", block.TxSha, txSha) + } + // Block validation if err = sm.ValidateBlock(block); err != nil { statelogger.Errorln("Error validating block:", err) @@ -219,17 +224,7 @@ func (sm *StateManager) Process(block *Block, dontReact bool) (err error) { return err } - /* - if ethutil.Config.Paranoia { - valid, _ := ethtrie.ParanoiaCheck(state.trie) - if !valid { - err = fmt.Errorf("PARANOIA: World state trie corruption") - } - } - */ - if !block.State().Cmp(state) { - err = fmt.Errorf("Invalid merkle root.\nrec: %x\nis: %x", block.State().trie.Root, state.trie.Root) return } diff --git a/ethminer/miner.go b/ethminer/miner.go index a50b3712f..bfea8e580 100644 --- a/ethminer/miner.go +++ b/ethminer/miner.go @@ -165,6 +165,7 @@ func (self *Miner) mineNewBlock() { logger.Debugln(err) } self.txs = append(txs, unhandledTxs...) + self.block.SetTxHash(receipts) // Set the transactions to the block so the new SHA3 can be calculated self.block.SetReceipts(receipts, txs)