Add forwardGetStorageAt setting.

pkg/eth/api.go

@@ -57,18 +57,22 @@ type PublicEthAPI struct {
 	B *Backend
 
 	// Proxy node for forwarding cache misses
-	supportsStateDiff bool // Whether the remote node supports the statediff_writeStateDiffAt endpoint, if it does we can fill the local cache when we hit a miss
-	rpc               *rpc.Client
-	ethClient         *ethclient.Client
-	forwardEthCalls   bool // if true, forward eth_call calls directly to the configured proxy node
-	proxyOnError      bool // turn on regular proxy fall-through on errors; needed to test difference between direct and indirect fall-through
+	supportsStateDiff   bool // Whether the remote node supports the statediff_writeStateDiffAt endpoint, if it does we can fill the local cache when we hit a miss
+	rpc                 *rpc.Client
+	ethClient           *ethclient.Client
+	forwardEthCalls     bool // if true, forward eth_call calls directly to the configured proxy node
+	forwardGetStorageAt bool // if true, forward eth_getStorageAt calls directly to the configured proxy node
+	proxyOnError        bool // turn on regular proxy fall-through on errors; needed to test difference between direct and indirect fall-through
 }
 
 // NewPublicEthAPI creates a new PublicEthAPI with the provided underlying Backend
-func NewPublicEthAPI(b *Backend, client *rpc.Client, supportsStateDiff, forwardEthCalls, proxyOnError bool) (*PublicEthAPI, error) {
+func NewPublicEthAPI(b *Backend, client *rpc.Client, supportsStateDiff, forwardEthCalls, forwardGetStorageAt, proxyOnError bool) (*PublicEthAPI, error) {
 	if forwardEthCalls && client == nil {
 		return nil, errors.New("ipld-eth-server is configured to forward eth_calls to proxy node but no proxy node is configured")
 	}
+	if forwardGetStorageAt && client == nil {
+		return nil, errors.New("ipld-eth-server is configured to forward eth_getStorageAt to proxy node but no proxy node is configured")
+	}
 	if proxyOnError && client == nil {
 		return nil, errors.New("ipld-eth-server is configured to forward all calls to proxy node on errors but no proxy node is configured")
 	}
@@ -77,12 +81,13 @@ func NewPublicEthAPI(b *Backend, client *rpc.Client, supportsStateDiff, forwardE
 		ethClient = ethclient.NewClient(client)
 	}
 	return &PublicEthAPI{
-		B:                 b,
-		supportsStateDiff: supportsStateDiff,
-		rpc:               client,
-		ethClient:         ethClient,
-		forwardEthCalls:   forwardEthCalls,
-		proxyOnError:      proxyOnError,
+		B:                   b,
+		supportsStateDiff:   supportsStateDiff,
+		rpc:                 client,
+		ethClient:           ethClient,
+		forwardEthCalls:     forwardEthCalls,
+		forwardGetStorageAt: forwardGetStorageAt,
+		proxyOnError:        proxyOnError,
 	}, nil
 }
 
@@ -720,6 +725,13 @@ func (pea *PublicEthAPI) localGetBalance(ctx context.Context, address common.Add
 // block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta block
 // numbers are also allowed.
 func (pea *PublicEthAPI) GetStorageAt(ctx context.Context, address common.Address, key string, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
+	if pea.forwardGetStorageAt {
+		var res hexutil.Bytes
+		// If forwarding all getStorageAt calls, don't request statediffing.
+		if err := pea.rpc.CallContext(ctx, &res, "eth_getStorageAt", address, key, blockNrOrHash); res != nil && err == nil {
+			return res, nil
+		}
+	}
 	storageVal, err := pea.B.GetStorageByNumberOrHash(ctx, address, common.HexToHash(key), blockNrOrHash)
 	if storageVal != nil && err == nil {
 		var value common.Hash
@@ -735,8 +747,10 @@ func (pea *PublicEthAPI) GetStorageAt(ctx context.Context, address common.Addres
 		return value[:], nil
 	}
 	if pea.proxyOnError {
+		logrus.Warnf("Missing eth_getStorageAt(%s, %s, %s)", address.Hash().String(), key, blockNrOrHash.String())
 		var res hexutil.Bytes
 		if err := pea.rpc.CallContext(ctx, &res, "eth_getStorageAt", address, key, blockNrOrHash); res != nil && err == nil {
+			// If only proxying on error, request statediffing for the missing data.
 			go pea.writeStateDiffAtOrFor(blockNrOrHash)
 			return res, nil
 		}
@@ -1065,6 +1079,7 @@ func (pea *PublicEthAPI) writeStateDiffAt(height int64) {
 		IncludeTD:                true,
 		IncludeCode:              true,
 	}
+	logrus.Debugf("Calling statediff_writeStateDiffAt(%d)", height)
 	if err := pea.rpc.CallContext(ctx, &data, "statediff_writeStateDiffAt", uint64(height), params); err != nil {
 		logrus.Errorf("writeStateDiffAt %d faild with err %s", height, err.Error())
 	}
@@ -1087,6 +1102,7 @@ func (pea *PublicEthAPI) writeStateDiffFor(blockHash common.Hash) {
 		IncludeTD:                true,
 		IncludeCode:              true,
 	}
+	logrus.Debugf("Calling statediff_writeStateDiffFor(%s)", blockHash.Hex())
 	if err := pea.rpc.CallContext(ctx, &data, "statediff_writeStateDiffFor", blockHash, params); err != nil {
 		logrus.Errorf("writeStateDiffFor %s faild with err %s", blockHash.Hex(), err.Error())
 	}

pkg/eth/api_test.go

@@ -213,7 +213,7 @@ var _ = Describe("API", func() {
 			},
 		})
 		Expect(err).ToNot(HaveOccurred())
-		api, _ = eth.NewPublicEthAPI(backend, nil, false, false, false)
+		api, _ = eth.NewPublicEthAPI(backend, nil, false, false, false, false)
 		tx, err = indexAndPublisher.PushBlock(test_helpers.MockBlock, test_helpers.MockReceipts, test_helpers.MockBlock.Difficulty())
 		Expect(err).ToNot(HaveOccurred())
 

pkg/eth/eth_state_test.go

@@ -92,7 +92,7 @@ var _ = Describe("eth state reading tests", func() {
 			},
 		})
 		Expect(err).ToNot(HaveOccurred())
-		api, _ = eth.NewPublicEthAPI(backend, nil, false, false, false)
+		api, _ = eth.NewPublicEthAPI(backend, nil, false, false, false, false)
 
 		// make the test blockchain (and state)
 		blocks, receipts, chain = test_helpers.MakeChain(chainLength, test_helpers.Genesis, test_helpers.TestChainGen)

pkg/eth/ipld_retriever.go

@@ -27,6 +27,7 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/lib/pq"
+	log "github.com/sirupsen/logrus"
 )
 
 const (
@@ -493,6 +494,8 @@ func (r *IPLDRetriever) RetrieveStorageAtByAddressAndStorageSlotAndBlockHash(add
 	if err := r.db.Get(storageResult, RetrieveStorageLeafByAddressHashAndLeafKeyAndBlockHashPgStr, stateLeafKey.Hex(), storageHash.Hex(), hash.Hex()); err != nil {
 		return "", nil, nil, err
 	}
+	log.Debugf("getStorageAt: state_leaf_key=%s, storage_hex=%s, storage_leaf_key=%s, block_hash=%s",
+		stateLeafKey.Hex(), key.Hex(), storageHash.Hex(), hash.Hex())
 	if storageResult.StateLeafRemoved || storageResult.NodeType == removedNode {
 		return "", EmptyNodeValue, EmptyNodeValue, nil
 	}