it works now in dev mode

Author: jwasinger

core/state/statedb.go

@@ -902,7 +902,6 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
 			}
 		}
 	}
-	workers.Wait()
 	s.StorageUpdates += time.Since(start)
 
 	// Now we're about to start to write changes to the trie. The trie is so far
@@ -970,6 +969,7 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
 			s.witnessStats.Add(witness, common.Hash{})
 		}
 	}
+
 	return hash
 }
 

trie/committer.go

@@ -158,7 +158,7 @@ func (c *committer) store(path []byte, n node) node {
 	if c.collectLeaf {
 		if sn, ok := n.(*shortNode); ok {
 			if val, ok := sn.Val.(valueNode); ok {
-				c.nodes.AddLeaf(nhash, val())
+				c.nodes.AddLeaf(nhash, val.resolve())
 			}
 		}
 	}
@@ -182,7 +182,7 @@ func forGatherChildren(n node, onChild func(hash common.Hash)) {
 		}
 	case hashNode:
 		onChild(common.BytesToHash(n))
-	case valueNode, nil:
+	case *valueNode, nil:
 	default:
 		panic(fmt.Sprintf("unknown node type: %T", n))
 	}

trie/hasher.go

@@ -110,7 +110,7 @@ func (h *hasher) encodeShortNode(n *shortNode) []byte {
 	if hasTerm(n.Key) {
 		var ln leafNodeEncoder
 		ln.Key = hexToCompact(n.Key)
-		ln.Val = n.Val.(valueNode)()
+		ln.Val = n.Val.(*valueNode).resolve()
 		ln.encode(h.encbuf)
 		return h.encodedBytes()
 	}
@@ -162,7 +162,7 @@ func (h *hasher) encodeFullNode(n *fullNode) []byte {
 		}
 	}
 	if n.Children[16] != nil {
-		fn.Children[16] = n.Children[16].(valueNode)()
+		fn.Children[16] = n.Children[16].(*valueNode).resolve()
 	}
 	fn.encode(h.encbuf)
 	fnEncoderPool.Put(fn)

trie/iterator.go

@@ -224,8 +224,8 @@ func (it *nodeIterator) LeafKey() []byte {
 
 func (it *nodeIterator) LeafBlob() []byte {
 	if len(it.stack) > 0 {
-		if node, ok := it.stack[len(it.stack)-1].node.(valueNode); ok {
-			return node()
+		if node, ok := it.stack[len(it.stack)-1].node.(*valueNode); ok {
+			return node.resolve()
 		}
 	}
 	panic("not at leaf")

trie/node.go

@@ -44,7 +44,10 @@ type (
 		flags nodeFlag
 	}
 	hashNode  []byte
-	valueNode func() []byte
+	valueNode struct {
+		resolver func() []byte
+		val      []byte
+	}
 
 	// fullnodeEncoder is a type used exclusively for encoding fullNode.
 	// Briefly instantiating a fullnodeEncoder and initializing with
@@ -68,6 +71,19 @@ type (
 	}
 )
 
+func newValueNode(resolver func() []byte) *valueNode {
+	return &valueNode{
+		resolver: resolver,
+	}
+}
+
+func (v *valueNode) resolve() []byte {
+	if v.val == nil {
+		v.val = v.resolver()
+	}
+	return v.val
+}
+
 // EncodeRLP encodes a full node into the consensus RLP format.
 func (n *fullNode) EncodeRLP(w io.Writer) error {
 	eb := rlp.NewEncoderBuffer(w)
@@ -118,7 +134,7 @@ func (n hashNode) fstring(ind string) string {
 	return fmt.Sprintf("<%x> ", []byte(n))
 }
 func (n valueNode) fstring(ind string) string {
-	return fmt.Sprintf("%x ", n())
+	return fmt.Sprintf("%x ", n.resolve())
 }
 
 // mustDecodeNode is a wrapper of decodeNode and panic if any error is encountered.
@@ -185,7 +201,7 @@ func decodeShort(hash, elems []byte) (node, error) {
 		if err != nil {
 			return nil, fmt.Errorf("invalid value node: %v", err)
 		}
-		return &shortNode{key, valueNode(func() []byte { return val }), flag}, nil
+		return &shortNode{key, newValueNode(func() []byte { return val }), flag}, nil
 	}
 	r, _, err := decodeRef(rest)
 	if err != nil {
@@ -208,7 +224,7 @@ func decodeFull(hash, elems []byte) (*fullNode, error) {
 		return n, err
 	}
 	if len(val) > 0 {
-		n.Children[16] = valueNode(func() []byte { return val })
+		n.Children[16] = newValueNode(func() []byte { return val })
 	}
 	return n, nil
 }

trie/node_enc.go

@@ -102,5 +102,5 @@ func (n hashNode) encode(w rlp.EncoderBuffer) {
 }
 
 func (n valueNode) encode(w rlp.EncoderBuffer) {
-	w.WriteBytes(n())
+	w.WriteBytes(n.resolve())
 }

trie/proof.go

@@ -129,7 +129,7 @@ func VerifyProof(rootHash common.Hash, key []byte, proofDb ethdb.KeyValueReader)
 			key = keyrest
 			copy(wantHash[:], cld)
 		case valueNode:
-			return cld(), nil
+			return cld.resolve(), nil
 		}
 	}
 }
@@ -192,7 +192,7 @@ func proofToPath(rootHash common.Hash, root node, key []byte, proofDb ethdb.KeyV
 				return nil, nil, err
 			}
 		case valueNode:
-			valnode = cld()
+			valnode = cld.resolve()
 		}
 		// Link the parent and child.
 		switch pnode := parent.(type) {

trie/sync.go

@@ -620,7 +620,7 @@ func (s *Sync) children(req *nodeRequest, object node) ([]*nodeRequest, error) {
 					paths = append(paths, hexToKeybytes(child.path[:2*common.HashLength]))
 					paths = append(paths, hexToKeybytes(child.path[2*common.HashLength:]))
 				}
-				if err := req.callback(paths, child.path, node(), req.hash, req.path); err != nil {
+				if err := req.callback(paths, child.path, node.resolve(), req.hash, req.path); err != nil {
 					return nil, err
 				}
 			}

trie/trie.go

@@ -193,8 +193,8 @@ func (t *Trie) get(origNode node, key []byte, pos int) (value []byte, newnode no
 	switch n := (origNode).(type) {
 	case nil:
 		return nil, nil, false, nil
-	case valueNode:
-		return n(), n, false, nil
+	case *valueNode:
+		return n.resolve(), n, false, nil
 	case *shortNode:
 		if !bytes.HasPrefix(key[pos:], n.Key) {
 			// key not found in trie
@@ -388,7 +388,7 @@ func (t *Trie) UpdateAsync(key []byte, valueResolver func() []byte) error {
 	k := keybytesToHex(key)
 
 	// NOTE: this does not support deletions (the length of the value is not known until it is resolved)
-	_, n, err := t.insert(t.root, nil, k, valueNode(valueResolver))
+	_, n, err := t.insert(t.root, nil, k, newValueNode(valueResolver))
 	if err != nil {
 		return err
 	}
@@ -401,7 +401,7 @@ func (t *Trie) update(key, value []byte) error {
 	t.uncommitted++
 	k := keybytesToHex(key)
 	if len(value) != 0 {
-		_, n, err := t.insert(t.root, nil, k, valueNode(func() []byte { return value }))
+		_, n, err := t.insert(t.root, nil, k, newValueNode(func() []byte { return value }))
 		if err != nil {
 			return err
 		}
@@ -657,8 +657,8 @@ func copyNode(n node) node {
 	switch n := (n).(type) {
 	case nil:
 		return nil
-	case valueNode:
-		return valueNode(func() []byte { return common.CopyBytes(n()) })
+	case *valueNode:
+		return newValueNode(func() []byte { return common.CopyBytes(n.resolve()) })
 
 	case *shortNode:
 		return &shortNode{