trie: make value node resolvable via a callback

Author: jwasinger

tests/testdata

@@ -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())
 			}
 		}
 	}

trie/committer.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)()
 		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)()
 	}
 	fn.encode(h.encbuf)
 	fnEncoderPool.Put(fn)

trie/hasher.go

@@ -225,7 +225,7 @@ 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
+			return node()
 		}
 	}
 	panic("not at leaf")

trie/iterator.go

@@ -44,7 +44,7 @@ type (
 		flags nodeFlag
 	}
 	hashNode  []byte
-	valueNode []byte
+	valueNode func() []byte
 
 	// fullnodeEncoder is a type used exclusively for encoding fullNode.
 	// Briefly instantiating a fullnodeEncoder and initializing with
@@ -118,7 +118,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 ", []byte(n))
+	return fmt.Sprintf("%x ", n())
 }
 
 // mustDecodeNode is a wrapper of decodeNode and panic if any error is encountered.
@@ -185,7 +185,7 @@ func decodeShort(hash, elems []byte) (node, error) {
 		if err != nil {
 			return nil, fmt.Errorf("invalid value node: %v", err)
 		}
-		return &shortNode{key, valueNode(val), flag}, nil
+		return &shortNode{key, valueNode(func() []byte { return val }), flag}, nil
 	}
 	r, _, err := decodeRef(rest)
 	if err != nil {
@@ -208,7 +208,7 @@ func decodeFull(hash, elems []byte) (*fullNode, error) {
 		return n, err
 	}
 	if len(val) > 0 {
-		n.Children[16] = valueNode(val)
+		n.Children[16] = valueNode(func() []byte { return val })
 	}
 	return n, nil
 }

trie/node.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())
 }

trie/node_enc.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(), 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()
 		}
 		// Link the parent and child.
 		switch pnode := parent.(type) {

trie/proof.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(), req.hash, req.path); err != nil {
 					return nil, err
 				}
 			}

trie/sync.go

@@ -194,7 +194,7 @@ func (t *Trie) get(origNode node, key []byte, pos int) (value []byte, newnode no
 	case nil:
 		return nil, nil, false, nil
 	case valueNode:
-		return n, n, false, nil
+		return n(), n, false, nil
 	case *shortNode:
 		if !bytes.HasPrefix(key[pos:], n.Key) {
 			// key not found in trie
@@ -382,12 +382,26 @@ func (t *Trie) Update(key, value []byte) error {
 	return t.update(key, value)
 }
 
+func (t *Trie) UpdateAsync(key []byte, valueResolver func() []byte) error {
+	t.unhashed++
+	t.uncommitted++
+	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))
+	if err != nil {
+		return err
+	}
+	t.root = n
+	return nil
+}
+
 func (t *Trie) update(key, value []byte) error {
 	t.unhashed++
 	t.uncommitted++
 	k := keybytesToHex(key)
 	if len(value) != 0 {
-		_, n, err := t.insert(t.root, nil, k, valueNode(value))
+		_, n, err := t.insert(t.root, nil, k, valueNode(func() []byte { return value }))
 		if err != nil {
 			return err
 		}
@@ -405,7 +419,7 @@ func (t *Trie) update(key, value []byte) error {
 func (t *Trie) insert(n node, prefix, key []byte, value node) (bool, node, error) {
 	if len(key) == 0 {
 		if v, ok := n.(valueNode); ok {
-			return !bytes.Equal(v, value.(valueNode)), value, nil
+			return !bytes.Equal(v(), value.(valueNode)()), value, nil
 		}
 		return true, value, nil
 	}
@@ -647,7 +661,7 @@ func copyNode(n node) node {
 	case nil:
 		return nil
 	case valueNode:
-		return valueNode(common.CopyBytes(n))
+		return valueNode(func() []byte { return common.CopyBytes(n()) })
 
 	case *shortNode:
 		return &shortNode{