ethereum/go-ethereum · error

not implemented

Error message

not implemented

What it means

Error "not implemented" thrown in ethereum/go-ethereum.

Source

Thrown at trie/transitiontrie/transition.go:220

// corresponding node hash. All collected nodes(including dirty leaves if
// collectLeaf is true) will be encapsulated into a nodeset for return.
// The returned nodeset can be nil if the trie is clean(nothing to commit).
// Once the trie is committed, it's not usable anymore. A new trie must
// be created with new root and updated trie database for following usage
func (t *TransitionTrie) Commit(collectLeaf bool) (common.Hash, *trienode.NodeSet) {
	// Just return if the trie is a storage trie: otherwise,
	// the overlay trie will be committed as many times as
	// there are storage tries. This would kill performance.
	if t.storage {
		return common.Hash{}, nil
	}
	return t.overlay.Commit(collectLeaf)
}

// NodeIterator returns an iterator that returns nodes of the trie. Iteration
// starts at the key after the given start key.
func (t *TransitionTrie) NodeIterator(startKey []byte) (trie.NodeIterator, error) {
	panic("not implemented") // TODO: Implement
}

// Prove constructs a Merkle proof for key. The result contains all encoded nodes
// on the path to the value at key. The value itself is also included in the last
// node and can be retrieved by verifying the proof.
//
// If the trie does not contain a value for key, the returned proof contains all
// nodes of the longest existing prefix of the key (at least the root), ending
// with the node that proves the absence of the key.
func (t *TransitionTrie) Prove(key []byte, proofDb ethdb.KeyValueWriter) error {
	panic("not implemented") // TODO: Implement
}

// IsUBT returns true if the trie is verkle-tree based
func (t *TransitionTrie) IsUBT() bool {
	// For all intents and purposes, the calling code should treat this as a verkle trie
	return true
}

View on GitHub (pinned to 6bb0588ad8)

Solutions

1. TransitionTrie.NodeIterator is not implemented. Use the underlying overlay/base trie's iterator (e.g., iterate the Verkle/stem trie or the MPT base) instead of iterating the transition wrapper directly.
2. Avoid calling NodeIterator on a TransitionTrie during the transition period; gate the call on trie type.

Example fix

if tt, ok := tr.(*transitiontrie.TransitionTrie); ok {
    return tt.Base().NodeIterator(startKey) // or Overlay(), as appropriate
}
return tr.NodeIterator(startKey)

When it happens

Trigger: Calling NodeIterator on a TransitionTrie (MPT-to-Verkle transition wrapper), which has no iterator implementation.

Common situations: Debug/snap/iteration code paths running against a chain in the Verkle transition period.

AI-assisted analysis of ethereum/go-ethereum@6bb0588ad8 (2026-08-15). Data as JSON: /api/errors/01d8ab81ebf49746. Report an issue: GitHub.