Partial EIP1186 eth_getProof implementation

cmd/rpcdaemon/commands/eth_api.go

@@ -25,6 +25,7 @@ import (
 	"github.com/ledgerwatch/erigon/consensus/misc"
 	"github.com/ledgerwatch/erigon/core/rawdb"
 	"github.com/ledgerwatch/erigon/core/types"
+	"github.com/ledgerwatch/erigon/core/types/accounts"
 	ethFilters "github.com/ledgerwatch/erigon/eth/filters"
 	"github.com/ledgerwatch/erigon/rpc"
 	ethapi2 "github.com/ledgerwatch/erigon/turbo/adapter/ethapi"
@@ -87,7 +88,7 @@ type EthAPI interface {
 	SendTransaction(_ context.Context, txObject interface{}) (libcommon.Hash, error)
 	Sign(ctx context.Context, _ libcommon.Address, _ hexutil.Bytes) (hexutil.Bytes, error)
 	SignTransaction(_ context.Context, txObject interface{}) (libcommon.Hash, error)
-	GetProof(ctx context.Context, address libcommon.Address, storageKeys []string, blockNr rpc.BlockNumber) (*interface{}, error)
+	GetProof(ctx context.Context, address libcommon.Address, storageKeys []string, blockNr rpc.BlockNumberOrHash) (*accounts.AccProofResult, error)
 	CreateAccessList(ctx context.Context, args ethapi2.CallArgs, blockNrOrHash *rpc.BlockNumberOrHash, optimizeGas *bool) (*accessListResult, error)
 
 	// Mining related (see ./eth_mining.go)

cmd/rpcdaemon/commands/eth_call.go

@@ -21,13 +21,15 @@ import (
 	"github.com/ledgerwatch/erigon/core"
 	"github.com/ledgerwatch/erigon/core/state"
 	"github.com/ledgerwatch/erigon/core/types"
+	"github.com/ledgerwatch/erigon/core/types/accounts"
 	"github.com/ledgerwatch/erigon/core/vm"
 	"github.com/ledgerwatch/erigon/crypto"
 	"github.com/ledgerwatch/erigon/eth/tracers/logger"
 	"github.com/ledgerwatch/erigon/params"
 	"github.com/ledgerwatch/erigon/rpc"
 	"github.com/ledgerwatch/erigon/turbo/rpchelper"
 	"github.com/ledgerwatch/erigon/turbo/transactions"
+	"github.com/ledgerwatch/erigon/turbo/trie"
 )
 
 var latestNumOrHash = rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber)
@@ -301,10 +303,52 @@ func (api *APIImpl) EstimateGas(ctx context.Context, argsOrNil *ethapi2.CallArgs
 	return hexutil.Uint64(hi), nil
 }
 
-// GetProof not implemented
-func (api *APIImpl) GetProof(ctx context.Context, address libcommon.Address, storageKeys []string, blockNr rpc.BlockNumber) (*interface{}, error) {
-	var stub interface{}
-	return &stub, fmt.Errorf(NotImplemented, "eth_getProof")
+// GetProof is partially implemented; no Storage proofs; only for the latest block
+func (api *APIImpl) GetProof(ctx context.Context, address libcommon.Address, storageKeys []string, blockNrOrHash rpc.BlockNumberOrHash) (*accounts.AccProofResult, error) {
+
+	tx, err := api.db.BeginRo(ctx)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+
+	blockNr, _, _, err := rpchelper.GetBlockNumber(blockNrOrHash, tx, api.filters)
+	if err != nil {
+		return nil, err
+	}
+
+	latestBlock, err := rpchelper.GetLatestBlockNumber(tx)
+	if err != nil {
+		return nil, err
+	} else if blockNr != latestBlock {
+		return nil, fmt.Errorf(NotImplemented, "eth_getProof for block != latest")
+	} else if len(storageKeys) != 0 {
+		return nil, fmt.Errorf(NotImplemented, "eth_getProof with storageKeys")
+	} else {
+		addrHash, err := common.HashData(address[:])
+		if err != nil {
+			return nil, err
+		}
+
+		rl := trie.NewRetainList(0)
+		rl.AddKey(addrHash[:])
+
+		loader := trie.NewFlatDBTrieLoader("getProof")
+		trace := true
+		if err := loader.Reset(rl, nil, nil, trace); err != nil {
+			return nil, err
+		}
+
+		var accProof accounts.AccProofResult
+		accProof.Address = address
+		loader.SetProofReturn(&accProof)
+
+		_, err = loader.CalcTrieRoot(tx, nil, nil)
+		if err != nil {
+			return nil, err
+		}
+		return &accProof, nil
+	}
 }
 
 func (api *APIImpl) tryBlockFromLru(hash libcommon.Hash) *types.Block {

core/types/accounts/account_proof.go

@@ -0,0 +1,22 @@
+package accounts
+
+import (
+	libcommon "github.com/ledgerwatch/erigon-lib/common"
+	"github.com/ledgerwatch/erigon/common/hexutil"
+)
+
+// Result structs for GetProof
+type AccProofResult struct {
+	Address      libcommon.Address `json:"address"`
+	AccountProof []string          `json:"accountProof"`
+	Balance      *hexutil.Big      `json:"balance"`
+	CodeHash     libcommon.Hash    `json:"codeHash"`
+	Nonce        hexutil.Uint64    `json:"nonce"`
+	StorageHash  libcommon.Hash    `json:"storageHash"`
+	StorageProof []StorProofResult `json:"storageProof"`
+}
+type StorProofResult struct {
+	Key   string       `json:"key"`
+	Value *hexutil.Big `json:"value"`
+	Proof []string     `json:"proof"`
+}

turbo/trie/gen_struct_step.go

@@ -41,6 +41,10 @@ type structInfoReceiver interface {
 	topHash() []byte
 	topHashes(prefix []byte, branches, children uint16) []byte
 	printTopHashes(prefix []byte, branches, children uint16)
+
+	// eth_getProof extensions
+	branchEx(set uint16, doProof bool) error
+	branchHashEx(set uint16, doProof bool) error
 }
 
 // hashCollector gets called whenever there might be a need to create intermediate hash record
@@ -99,7 +103,10 @@ func (GenStructStepHashData) GenStructStepData() {}
 // Whenever a `BRANCH` or `BRANCHHASH` opcode is emitted, the set of digits is taken from the corresponding `groups` item, which is
 // then removed from the slice. This signifies the usage of the number of the stack items by the `BRANCH` or `BRANCHHASH` opcode.
 // DESCRIBED: docs/programmers_guide/guide.md#separation-of-keys-and-the-structure
-func GenStructStep(
+
+// GenStructStepEx is extended to support optional generation of an Account Proof during trie_root.go CalcTrieRoot().
+// The wrapper below calls it with nil/false defaults so that other callers do not need to be modified.
+func GenStructStepEx(
 	retain func(prefix []byte) bool,
 	curr, succ []byte,
 	e structInfoReceiver,
@@ -109,6 +116,8 @@ func GenStructStep(
 	hasTree []uint16,
 	hasHash []uint16,
 	trace bool,
+	wantProof func(prefix []byte) bool,
+	cutoff bool,
 ) ([]uint16, []uint16, []uint16, error) {
 	for precLen, buildExtensions := calcPrecLen(groups), false; precLen >= 0; precLen, buildExtensions = calcPrecLen(groups), true {
 		var precExists = len(groups) > 0
@@ -164,7 +173,7 @@ func GenStructStep(
 				}
 				buildExtensions = true
 			case *GenStructStepAccountData:
-				if retain(curr[:maxLen]) {
+				if retain(curr[:maxLen]) || (wantProof != nil && wantProof(curr[:len(curr)-1])) {
 					if err := e.accountLeaf(remainderLen, curr, &v.Balance, v.Nonce, v.Incarnation, v.FieldSet, codeSizeUncached); err != nil {
 						return nil, nil, nil, err
 					}
@@ -267,11 +276,21 @@ func GenStructStep(
 				}
 			}
 
+			var doProof bool
+			if wantProof != nil {
+				if maxLen > 0 && wantProof(curr[:maxLen]) {
+					doProof = true
+				}
+				if len(succ) == 0 && maxLen == 0 && cutoff {
+					doProof = true
+				}
+			}
+
 			if trace {
 				e.printTopHashes(curr[:maxLen], 0, groups[maxLen])
 			}
-			if retain(curr[:maxLen]) {
-				if err := e.branch(groups[maxLen]); err != nil {
+			if retain(curr[:maxLen]) || doProof {
+				if err := e.branchEx(groups[maxLen], doProof); err != nil {
 					return nil, nil, nil, err
 				}
 			} else {
@@ -305,6 +324,19 @@ func GenStructStep(
 	}
 	return nil, nil, nil, nil
 }
+func GenStructStep(
+	retain func(prefix []byte) bool,
+	curr, succ []byte,
+	e structInfoReceiver,
+	h HashCollector2,
+	data GenStructStepData,
+	groups []uint16,
+	hasTree []uint16,
+	hasHash []uint16,
+	trace bool,
+) ([]uint16, []uint16, []uint16, error) {
+	return GenStructStepEx(retain, curr, succ, e, h, data, groups, hasTree, hasHash, trace, nil, false)
+}
 
 func GenStructStepOld(
 	retain func(prefix []byte) bool,