explicity set whether to forward to proxy on errors, so that we can turn it off and test the direct forwarding

.github/workflows/on-pr.yaml

@@ -40,6 +40,8 @@ jobs:
       GOPATH: /tmp/go
       DB_WRITE: true
       ETH_FORWARD_ETH_CALLS: false
+      ETH_PROXY_ON_ERROR: false
+      ETH_HTTP_PATH: ""
     strategy:
       matrix:
         go-version: [1.16.x]
@@ -67,6 +69,8 @@ jobs:
       GOPATH: /tmp/go
       DB_WRITE: false
       ETH_FORWARD_ETH_CALLS: true
+      ETH_PROXY_ON_ERROR: false
+      ETH_HTTP_PATH: "dapptools:8545"
     strategy:
       matrix:
         go-version: [ 1.16.x ]

cmd/serve.go

@@ -346,6 +346,7 @@ func init() {
 	serveCmd.PersistentFlags().String("eth-chain-config", "", "json chain config file location")
 	serveCmd.PersistentFlags().Bool("eth-supports-state-diff", false, "whether the proxy ethereum client supports statediffing endpoints")
 	serveCmd.PersistentFlags().Bool("eth-forward-eth-calls", false, "whether to immediately forward eth_calls to proxy client")
+	serveCmd.PersistentFlags().Bool("eth-proxy-on-error", true, "whether to forward all failed calls to proxy client")
 
 	// groupcache flags
 	serveCmd.PersistentFlags().Bool("gcache-pool-enabled", false, "turn on the groupcache pool")
@@ -394,6 +395,7 @@ func init() {
 	viper.BindPFlag("ethereum.chainConfig", serveCmd.PersistentFlags().Lookup("eth-chain-config"))
 	viper.BindPFlag("ethereum.supportsStateDiff", serveCmd.PersistentFlags().Lookup("eth-supports-state-diff"))
 	viper.BindPFlag("ethereum.forwardEthCalls", serveCmd.PersistentFlags().Lookup("eth-forward-eth-calls"))
+	viper.BindPFlag("ethereum.proxyOnError", serveCmd.PersistentFlags().Lookup("eth-proxy-on-error"))
 
 	// groupcache flags
 	viper.BindPFlag("groupcache.pool.enabled", serveCmd.PersistentFlags().Lookup("gcache-pool-enabled"))

docker-compose.yml

@@ -52,7 +52,8 @@ services:
       DATABASE_PASSWORD: "password"
       ETH_CHAIN_ID: 4
       ETH_FORWARD_ETH_CALLS: $ETH_FORWARD_ETH_CALLS
-      ETH_HTTP_PATH: "dapptools:8545"
+      ETH_PROXY_ON_ERROR: $ETH_PROXY_ON_ERROR
+      ETH_HTTP_PATH: $ETH_HTTP_PATH
     volumes:
     - type: bind
       source: ./chain.json

environments/example.toml

@@ -22,6 +22,7 @@
     httpPath = "127.0.0.1:8545" # $ETH_HTTP_PATH
     supportsStateDiff = true # $ETH_SUPPORTS_STATEDIFF
     forwardEthCalls = false # $ETH_FORWARD_ETH_CALLS
+    proxyOnError = true # $ETH_PROXY_ON_ERROR
     nodeID = "arch1" # $ETH_NODE_ID
     clientName = "Geth" # $ETH_CLIENT_NAME
     genesisBlock = "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3" # $ETH_GENESIS_BLOCK

pkg/eth/api.go

@@ -61,13 +61,17 @@ type PublicEthAPI struct {
 	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
 }
 
 // NewPublicEthAPI creates a new PublicEthAPI with the provided underlying Backend
-func NewPublicEthAPI(b *Backend, client *rpc.Client, supportsStateDiff, forwardEthCalls bool) (*PublicEthAPI, error) {
+func NewPublicEthAPI(b *Backend, client *rpc.Client, supportsStateDiff, forwardEthCalls, 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 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")
+	}
 	var ethClient *ethclient.Client
 	if client != nil {
 		ethClient = ethclient.NewClient(client)
@@ -78,6 +82,7 @@ func NewPublicEthAPI(b *Backend, client *rpc.Client, supportsStateDiff, forwardE
 		rpc:               client,
 		ethClient:         ethClient,
 		forwardEthCalls:   forwardEthCalls,
+		proxyOnError:      proxyOnError,
 	}, nil
 }
 
@@ -95,7 +100,7 @@ func (pea *PublicEthAPI) GetHeaderByNumber(ctx context.Context, number rpc.Block
 	if header != nil && err == nil {
 		return pea.rpcMarshalHeader(header)
 	}
-	if pea.ethClient != nil {
+	if pea.proxyOnError {
 		if header, err := pea.ethClient.HeaderByNumber(ctx, big.NewInt(number.Int64())); header != nil && err == nil {
 			go pea.writeStateDiffAt(number.Int64())
 			return pea.rpcMarshalHeader(header)
@@ -114,7 +119,7 @@ func (pea *PublicEthAPI) GetHeaderByHash(ctx context.Context, hash common.Hash)
 		}
 	}
 
-	if pea.ethClient != nil {
+	if pea.proxyOnError {
 		if header, err := pea.ethClient.HeaderByHash(ctx, hash); header != nil && err == nil {
 			go pea.writeStateDiffFor(hash)
 			if res, err := pea.rpcMarshalHeader(header); err != nil {
@@ -156,7 +161,7 @@ func (pea *PublicEthAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockN
 		return pea.rpcMarshalBlock(block, true, fullTx)
 	}
 
-	if pea.ethClient != nil {
+	if pea.proxyOnError {
 		if block, err := pea.ethClient.BlockByNumber(ctx, big.NewInt(number.Int64())); block != nil && err == nil {
 			go pea.writeStateDiffAt(number.Int64())
 			return pea.rpcMarshalBlock(block, true, fullTx)
@@ -174,7 +179,7 @@ func (pea *PublicEthAPI) GetBlockByHash(ctx context.Context, hash common.Hash, f
 		return pea.rpcMarshalBlock(block, true, fullTx)
 	}
 
-	if pea.ethClient != nil {
+	if pea.proxyOnError {
 		if block, err := pea.ethClient.BlockByHash(ctx, hash); block != nil && err == nil {
 			go pea.writeStateDiffFor(hash)
 			return pea.rpcMarshalBlock(block, true, fullTx)
@@ -185,20 +190,21 @@ func (pea *PublicEthAPI) GetBlockByHash(ctx context.Context, hash common.Hash, f
 }
 
 // ChainId is the EIP-155 replay-protection chain id for the current ethereum chain config.
-func (pea *PublicEthAPI) ChainId() hexutil.Uint64 {
+func (pea *PublicEthAPI) ChainId() (*hexutil.Big, error) {
-	chainID := new(big.Int)
 	block, err := pea.B.CurrentBlock()
 	if err != nil {
-		logrus.Errorf("ChainId failed with err %s", err.Error())
+		if pea.proxyOnError {
-
+			if id, err := pea.ethClient.ChainID(context.Background()); err == nil {
-		return 0
+				return (*hexutil.Big)(id), nil
+			}
+		}
+		return nil, err
 	}
 
 	if config := pea.B.Config.ChainConfig; config.IsEIP155(block.Number()) {
-		chainID = config.ChainID
+		return (*hexutil.Big)(config.ChainID), nil
 	}
-
+	return nil, fmt.Errorf("chain not synced beyond EIP-155 replay-protection fork block")
-	return (hexutil.Uint64)(chainID.Uint64())
 }
 
 /*
@@ -221,7 +227,7 @@ func (pea *PublicEthAPI) GetUncleByBlockNumberAndIndex(ctx context.Context, bloc
 		return pea.rpcMarshalBlock(block, false, false)
 	}
 
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		if uncle, uncleHashes, err := getBlockAndUncleHashes(pea.rpc, ctx, "eth_getUncleByBlockNumberAndIndex", blockNr, index); uncle != nil && err == nil {
 			go pea.writeStateDiffAt(blockNr.Int64())
 			return pea.rpcMarshalBlockWithUncleHashes(uncle, uncleHashes, false, false)
@@ -245,7 +251,7 @@ func (pea *PublicEthAPI) GetUncleByBlockHashAndIndex(ctx context.Context, blockH
 		return pea.rpcMarshalBlock(block, false, false)
 	}
 
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		if uncle, uncleHashes, err := getBlockAndUncleHashes(pea.rpc, ctx, "eth_getUncleByBlockHashAndIndex", blockHash, index); uncle != nil && err == nil {
 			go pea.writeStateDiffFor(blockHash)
 			return pea.rpcMarshalBlockWithUncleHashes(uncle, uncleHashes, false, false)
@@ -262,7 +268,7 @@ func (pea *PublicEthAPI) GetUncleCountByBlockNumber(ctx context.Context, blockNr
 		return &n
 	}
 
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var num *hexutil.Uint
 		if err := pea.rpc.CallContext(ctx, &num, "eth_getUncleCountByBlockNumber", blockNr); num != nil && err == nil {
 			go pea.writeStateDiffAt(blockNr.Int64())
@@ -280,7 +286,7 @@ func (pea *PublicEthAPI) GetUncleCountByBlockHash(ctx context.Context, blockHash
 		return &n
 	}
 
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var num *hexutil.Uint
 		if err := pea.rpc.CallContext(ctx, &num, "eth_getUncleCountByBlockHash", blockHash); num != nil && err == nil {
 			go pea.writeStateDiffFor(blockHash)
@@ -304,7 +310,7 @@ func (pea *PublicEthAPI) GetTransactionCount(ctx context.Context, address common
 		return count, nil
 	}
 
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var num *hexutil.Uint64
 		if err := pea.rpc.CallContext(ctx, &num, "eth_getTransactionCount", address, blockNrOrHash); num != nil && err == nil {
 			go pea.writeStateDiffAtOrFor(blockNrOrHash)
@@ -332,7 +338,7 @@ func (pea *PublicEthAPI) GetBlockTransactionCountByNumber(ctx context.Context, b
 		return &n
 	}
 
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var num *hexutil.Uint
 		if err := pea.rpc.CallContext(ctx, &num, "eth_getBlockTransactionCountByNumber", blockNr); num != nil && err == nil {
 			go pea.writeStateDiffAt(blockNr.Int64())
@@ -350,7 +356,7 @@ func (pea *PublicEthAPI) GetBlockTransactionCountByHash(ctx context.Context, blo
 		return &n
 	}
 
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var num *hexutil.Uint
 		if err := pea.rpc.CallContext(ctx, &num, "eth_getBlockTransactionCountByHash", blockHash); num != nil && err == nil {
 			go pea.writeStateDiffFor(blockHash)
@@ -367,7 +373,7 @@ func (pea *PublicEthAPI) GetTransactionByBlockNumberAndIndex(ctx context.Context
 		return newRPCTransactionFromBlockIndex(block, uint64(index))
 	}
 
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var tx *RPCTransaction
 		if err := pea.rpc.CallContext(ctx, &tx, "eth_getTransactionByBlockNumberAndIndex", blockNr, index); tx != nil && err == nil {
 			go pea.writeStateDiffAt(blockNr.Int64())
@@ -384,7 +390,7 @@ func (pea *PublicEthAPI) GetTransactionByBlockHashAndIndex(ctx context.Context,
 		return newRPCTransactionFromBlockIndex(block, uint64(index))
 	}
 
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var tx *RPCTransaction
 		if err := pea.rpc.CallContext(ctx, &tx, "eth_getTransactionByBlockHashAndIndex", blockHash, index); tx != nil && err == nil {
 			go pea.writeStateDiffFor(blockHash)
@@ -400,7 +406,7 @@ func (pea *PublicEthAPI) GetRawTransactionByBlockNumberAndIndex(ctx context.Cont
 	if block, _ := pea.B.BlockByNumber(ctx, blockNr); block != nil {
 		return newRPCRawTransactionFromBlockIndex(block, uint64(index))
 	}
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var tx hexutil.Bytes
 		if err := pea.rpc.CallContext(ctx, &tx, "eth_getRawTransactionByBlockNumberAndIndex", blockNr, index); tx != nil && err == nil {
 			go pea.writeStateDiffAt(blockNr.Int64())
@@ -415,7 +421,7 @@ func (pea *PublicEthAPI) GetRawTransactionByBlockHashAndIndex(ctx context.Contex
 	if block, _ := pea.B.BlockByHash(ctx, blockHash); block != nil {
 		return newRPCRawTransactionFromBlockIndex(block, uint64(index))
 	}
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var tx hexutil.Bytes
 		if err := pea.rpc.CallContext(ctx, &tx, "eth_getRawTransactionByBlockHashAndIndex", blockHash, index); tx != nil && err == nil {
 			go pea.writeStateDiffFor(blockHash)
@@ -437,7 +443,7 @@ func (pea *PublicEthAPI) GetTransactionByHash(ctx context.Context, hash common.H
 
 		return NewRPCTransaction(tx, blockHash, blockNumber, index, header.BaseFee), nil
 	}
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var tx *RPCTransaction
 		if err := pea.rpc.CallContext(ctx, &tx, "eth_getTransactionByHash", hash); tx != nil && err == nil {
 			go pea.writeStateDiffFor(hash)
@@ -454,7 +460,7 @@ func (pea *PublicEthAPI) GetRawTransactionByHash(ctx context.Context, hash commo
 	if tx != nil && err == nil {
 		return rlp.EncodeToBytes(tx)
 	}
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var tx hexutil.Bytes
 		if err := pea.rpc.CallContext(ctx, &tx, "eth_getRawTransactionByHash", hash); tx != nil && err == nil {
 			go pea.writeStateDiffFor(hash)
@@ -476,7 +482,7 @@ func (pea *PublicEthAPI) GetTransactionReceipt(ctx context.Context, hash common.
 	if receipt != nil && err == nil {
 		return receipt, nil
 	}
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		if receipt := pea.remoteGetTransactionReceipt(ctx, hash); receipt != nil {
 			go pea.writeStateDiffFor(hash)
 			return receipt, nil
@@ -574,7 +580,7 @@ func (pea *PublicEthAPI) remoteGetTransactionReceipt(ctx context.Context, hash c
 // https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_getlogs
 func (pea *PublicEthAPI) GetLogs(ctx context.Context, crit filters.FilterCriteria) ([]*types.Log, error) {
 	logs, err := pea.localGetLogs(crit)
-	if err != nil && pea.rpc != nil {
+	if err != nil && pea.proxyOnError {
 		var res []*types.Log
 		if err := pea.rpc.CallContext(ctx, &res, "eth_getLogs", crit); err == nil {
 			go pea.writeStateDiffWithCriteria(crit)
@@ -688,7 +694,7 @@ func (pea *PublicEthAPI) GetBalance(ctx context.Context, address common.Address,
 	if bal != nil && err == nil {
 		return bal, nil
 	}
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var res *hexutil.Big
 		if err := pea.rpc.CallContext(ctx, &res, "eth_getBalance", address, blockNrOrHash); res != nil && err == nil {
 			go pea.writeStateDiffAtOrFor(blockNrOrHash)
@@ -728,7 +734,7 @@ func (pea *PublicEthAPI) GetStorageAt(ctx context.Context, address common.Addres
 
 		return value[:], nil
 	}
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var res hexutil.Bytes
 		if err := pea.rpc.CallContext(ctx, &res, "eth_getStorageAt", address, key, blockNrOrHash); res != nil && err == nil {
 			go pea.writeStateDiffAtOrFor(blockNrOrHash)
@@ -747,7 +753,7 @@ func (pea *PublicEthAPI) GetCode(ctx context.Context, address common.Address, bl
 	if code != nil && err == nil {
 		return code, nil
 	}
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var res hexutil.Bytes
 		if err := pea.rpc.CallContext(ctx, &res, "eth_getCode", address, blockNrOrHash); res != nil && err == nil {
 			go pea.writeStateDiffAtOrFor(blockNrOrHash)
@@ -767,7 +773,7 @@ func (pea *PublicEthAPI) GetProof(ctx context.Context, address common.Address, s
 	if proof != nil && err == nil {
 		return proof, nil
 	}
-	if pea.rpc != nil {
+	if pea.proxyOnError {
 		var res *AccountResult
 		if err := pea.rpc.CallContext(ctx, &res, "eth_getProof", address, storageKeys, blockNrOrHash); res != nil && err == nil {
 			go pea.writeStateDiffAtOrFor(blockNrOrHash)
@@ -932,7 +938,7 @@ func (pea *PublicEthAPI) Call(ctx context.Context, args CallArgs, blockNrOrHash
 		}
 	}
 
-	if err != nil && pea.rpc != nil {
+	if err != nil && pea.proxyOnError {
 		var hex hexutil.Bytes
 		if err := pea.rpc.CallContext(ctx, &hex, "eth_call", args, blockNrOrHash, overrides); hex != nil && err == nil {
 			go pea.writeStateDiffAtOrFor(blockNrOrHash)

pkg/eth/api_test.go

@@ -229,7 +229,7 @@ var _ = Describe("API", func() {
 			},
 		})
 		Expect(err).ToNot(HaveOccurred())
-		api, _ = eth.NewPublicEthAPI(backend, nil, false, false)
+		api, _ = eth.NewPublicEthAPI(backend, nil, 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

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

pkg/serve/config.go

@@ -49,6 +49,7 @@ const (
 	ETH_CHAIN_CONFIG        = "ETH_CHAIN_CONFIG"
 	ETH_SUPPORTS_STATEDIFF  = "ETH_SUPPORTS_STATEDIFF"
 	ETH_FORWARD_ETH_CALLS   = "ETH_FORWARD_ETH_CALLS"
+	ETH_PROXY_ON_ERROR      = "ETH_PROXY_ON_ERROR"
 
 	VALIDATOR_ENABLED         = "VALIDATOR_ENABLED"
 	VALIDATOR_EVERY_NTH_BLOCK = "VALIDATOR_EVERY_NTH_BLOCK"
@@ -85,6 +86,7 @@ type Config struct {
 	Client           *rpc.Client
 	SupportStateDiff bool
 	ForwardEthCalls  bool
+	ProxyOnError     bool
 
 	// Cache configuration.
 	GroupCache *ethServerShared.GroupCacheConfig
@@ -104,6 +106,7 @@ func NewConfig() (*Config, error) {
 	viper.BindEnv("ethereum.chainConfig", ETH_CHAIN_CONFIG)
 	viper.BindEnv("ethereum.supportsStateDiff", ETH_SUPPORTS_STATEDIFF)
 	viper.BindEnv("ethereum.forwardEthCalls", ETH_FORWARD_ETH_CALLS)
+	viper.BindEnv("ethereum.proxyOnError", ETH_PROXY_ON_ERROR)
 
 	c.dbInit()
 	ethHTTP := viper.GetString("ethereum.httpPath")
@@ -115,6 +118,7 @@ func NewConfig() (*Config, error) {
 	c.Client = cli
 	c.SupportStateDiff = viper.GetBool("ethereum.supportsStateDiff")
 	c.ForwardEthCalls = viper.GetBool("ethereum.forwardEthCalls")
+	c.ProxyOnError = viper.GetBool("ethereum.proxyOnError")
 	c.EthHttpEndpoint = ethHTTPEndpoint
 
 	// websocket server

pkg/serve/service.go

@@ -85,6 +85,8 @@ type Service struct {
 	backend *eth.Backend
 	// whether to forward eth_calls directly to proxy node
 	forwardEthCalls bool
+	// whether to forward all calls to proxy node if they throw an error locally
+	proxyOnError bool
 }
 
 // NewServer creates a new Server using an underlying Service struct
@@ -100,6 +102,7 @@ func NewServer(settings *Config) (Server, error) {
 	sap.client = settings.Client
 	sap.supportsStateDiffing = settings.SupportStateDiff
 	sap.forwardEthCalls = settings.ForwardEthCalls
+	sap.proxyOnError = settings.ProxyOnError
 	var err error
 	sap.backend, err = eth.NewEthBackend(sap.db, &eth.Config{
 		ChainConfig:      settings.ChainConfig,
@@ -133,7 +136,7 @@ func (sap *Service) APIs() []rpc.API {
 			Public:    true,
 		},
 	}
-	ethAPI, err := eth.NewPublicEthAPI(sap.backend, sap.client, sap.supportsStateDiffing, sap.forwardEthCalls)
+	ethAPI, err := eth.NewPublicEthAPI(sap.backend, sap.client, sap.supportsStateDiffing, sap.forwardEthCalls, sap.proxyOnError)
 	if err != nil {
 		log.Fatalf("unable to create public eth api: %v", err)
 	}

scripts/run_integration_test.sh

@@ -3,6 +3,8 @@ set -o xtrace
 
 export ETH_FORWARD_ETH_CALLS=false
 export DB_WRITE=true
+export ETH_HTTP_PATH=""
+export ETH_PROXY_ON_ERROR=false
 
 # Clear up existing docker images and volume.
 docker-compose down --remove-orphans --volumes

scripts/run_integration_test_forward_eth_calls.sh

@@ -3,6 +3,8 @@ set -o xtrace
 
 export ETH_FORWARD_ETH_CALLS=true
 export DB_WRITE=false
+export ETH_HTTP_PATH="dapptools:8545"
+export ETH_PROXY_ON_ERROR=false
 
 # Clear up existing docker images and volume.
 docker-compose down --remove-orphans --volumes

test/direct_proxy_integration_test.go

@@ -159,11 +159,16 @@ var _ = Describe("Integration test", func() {
 				Topics:    [][]common.Hash{},
 			}
 
-			_, err := gethClient.FilterLogs(ctx, filterQuery)
+			gethLogs, err := gethClient.FilterLogs(ctx, filterQuery)
 			Expect(err).ToNot(HaveOccurred())
 
-			_, err = ipldClient.FilterLogs(ctx, filterQuery)
+			ipldLogs, err := ipldClient.FilterLogs(ctx, filterQuery)
-			Expect(err).To(HaveOccurred())
+			Expect(err).ToNot(HaveOccurred())
+
+			// not empty list
+			Expect(gethLogs).ToNot(BeEmpty())
+			// empty list
+			Expect(ipldLogs).To(BeEmpty())
 		})
 	})
 
@@ -189,20 +194,20 @@ var _ = Describe("Integration test", func() {
 			Expect(gethCode).To(Equal(ipldCode))
 		})
 		It("gets code of deployed contract without block number", func() {
-			gethCode, err := gethClient.CodeAt(ctx, common.HexToAddress(contract.Address), nil)
+			_, err := gethClient.CodeAt(ctx, common.HexToAddress(contract.Address), nil)
 			Expect(err).ToNot(HaveOccurred())
 
 			ipldCode, err := ipldClient.CodeAt(ctx, common.HexToAddress(contract.Address), nil)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(gethCode).To(Equal(ipldCode))
+			Expect(ipldCode).To(BeEmpty())
 		})
 		It("gets code of deployed contract with block number", func() {
-			gethCode, err := gethClient.CodeAt(ctx, common.HexToAddress(contract.Address), big.NewInt(int64(contract.BlockNumber)))
+			_, err := gethClient.CodeAt(ctx, common.HexToAddress(contract.Address), big.NewInt(int64(contract.BlockNumber)))
 			Expect(err).ToNot(HaveOccurred())
 
 			ipldCode, err := ipldClient.CodeAt(ctx, common.HexToAddress(contract.Address), big.NewInt(int64(contract.BlockNumber)))
 			Expect(err).ToNot(HaveOccurred())
-			Expect(gethCode).To(Equal(ipldCode))
+			Expect(ipldCode).To(BeEmpty())
 		})
 		It("gets code of contract that doesn't exist at this height", func() {
 			gethCode, err := gethClient.CodeAt(ctx, common.HexToAddress(contract.Address), big.NewInt(int64(contract.BlockNumber-1)))
@@ -231,33 +236,29 @@ var _ = Describe("Integration test", func() {
 
 			gethBalance, err := gethClient.BalanceAt(ctx, common.HexToAddress(address), nil)
 			Expect(err).ToNot(HaveOccurred())
+			Expect(gethBalance.String()).To(Equal(big.NewInt(10000000000000000).String()))
 
 			ipldBalance, err := ipldClient.BalanceAt(ctx, common.HexToAddress(address), nil)
 			Expect(err).ToNot(HaveOccurred())
-
+			Expect(ipldBalance.String()).To(Equal(big.NewInt(0).String()))
-			Expect(gethBalance).To(Equal(ipldBalance))
 		})
 		It("gets balance for an account with eth with block number", func() {
 			Expect(txErr).ToNot(HaveOccurred())
 
-			gethBalance, err := gethClient.BalanceAt(ctx, common.HexToAddress(address), big.NewInt(int64(tx.BlockNumber)))
+			_, err := gethClient.BalanceAt(ctx, common.HexToAddress(address), big.NewInt(int64(tx.BlockNumber)))
 			Expect(err).ToNot(HaveOccurred())
 
-			ipldBalance, err := ipldClient.BalanceAt(ctx, common.HexToAddress(address), big.NewInt(int64(tx.BlockNumber)))
+			_, err = ipldClient.BalanceAt(ctx, common.HexToAddress(address), big.NewInt(int64(tx.BlockNumber)))
-			Expect(err).ToNot(HaveOccurred())
+			Expect(err).To(HaveOccurred())
-
-			Expect(gethBalance).To(Equal(ipldBalance))
 		})
 		It("gets historical balance for an account with eth with block number", func() {
 			Expect(txErr).ToNot(HaveOccurred())
 
-			gethBalance, err := gethClient.BalanceAt(ctx, common.HexToAddress(address), big.NewInt(int64(tx.BlockNumber-1)))
+			_, err := gethClient.BalanceAt(ctx, common.HexToAddress(address), big.NewInt(int64(tx.BlockNumber-1)))
 			Expect(err).ToNot(HaveOccurred())
 
-			ipldBalance, err := ipldClient.BalanceAt(ctx, common.HexToAddress(address), big.NewInt(int64(tx.BlockNumber-1)))
+			_, err = ipldClient.BalanceAt(ctx, common.HexToAddress(address), big.NewInt(int64(tx.BlockNumber-1)))
-			Expect(err).ToNot(HaveOccurred())
+			Expect(err).To(HaveOccurred())
-
-			Expect(gethBalance).To(Equal(ipldBalance))
 		})
 		It("gets balance for a non-existing account without block number", func() {
 			Expect(txErr).ToNot(HaveOccurred())
@@ -308,11 +309,7 @@ var _ = Describe("Integration test", func() {
 
 			ipldStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), common.HexToHash(totalSupplyIndex), nil)
 			Expect(err).ToNot(HaveOccurred())
-
+			Expect(ipldStorage).To(Equal(make([]byte, 32)))
-			ipldTotalSupply := new(big.Int).SetBytes(ipldStorage)
-			Expect(ipldTotalSupply).To(Equal(erc20TotalSupply))
-
-			Expect(gethStorage).To(Equal(ipldStorage))
 		})
 
 		It("gets ERC20 total supply (with block number)", func() {
@@ -324,27 +321,24 @@ var _ = Describe("Integration test", func() {
 			gethTotalSupply := new(big.Int).SetBytes(gethStorage)
 			Expect(gethTotalSupply).To(Equal(erc20TotalSupply))
 
-			ipldStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), common.HexToHash(totalSupplyIndex), big.NewInt(int64(contract.BlockNumber)))
+			_, err = ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), common.HexToHash(totalSupplyIndex), big.NewInt(int64(contract.BlockNumber)))
-			Expect(err).ToNot(HaveOccurred())
+			Expect(err).To(HaveOccurred())
-			Expect(gethStorage).To(Equal(ipldStorage))
 		})
 		It("gets storage for non-existing account", func() {
 			totalSupplyIndex := "0x2"
 
-			gethStorage, err := gethClient.StorageAt(ctx, common.HexToAddress(nonExistingAddress), common.HexToHash(totalSupplyIndex), big.NewInt(int64(contract.BlockNumber)))
+			_, err := gethClient.StorageAt(ctx, common.HexToAddress(nonExistingAddress), common.HexToHash(totalSupplyIndex), big.NewInt(int64(contract.BlockNumber)))
 			Expect(err).ToNot(HaveOccurred())
 
-			ipldStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(nonExistingAddress), common.HexToHash(totalSupplyIndex), big.NewInt(int64(contract.BlockNumber)))
+			_, err = ipldClient.StorageAt(ctx, common.HexToAddress(nonExistingAddress), common.HexToHash(totalSupplyIndex), big.NewInt(int64(contract.BlockNumber)))
-			Expect(err).ToNot(HaveOccurred())
+			Expect(err).To(MatchError("header not found"))
-			Expect(gethStorage).To(Equal(ipldStorage))
 		})
 		It("gets storage for non-existing contract slot", func() {
-			gethStorage, err := gethClient.StorageAt(ctx, common.HexToAddress(contract.Address), randomHash, big.NewInt(int64(contract.BlockNumber)))
+			_, err := gethClient.StorageAt(ctx, common.HexToAddress(contract.Address), randomHash, big.NewInt(int64(contract.BlockNumber)))
 			Expect(err).ToNot(HaveOccurred())
 
-			ipldStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), randomHash, big.NewInt(int64(contract.BlockNumber)))
+			_, err = ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), randomHash, big.NewInt(int64(contract.BlockNumber)))
-			Expect(err).ToNot(HaveOccurred())
+			Expect(err).To(MatchError("header not found"))
-			Expect(gethStorage).To(Equal(ipldStorage))
 		})
 		It("gets storage for non-existing contract", func() {
 			totalSupplyIndex := "0x2"
@@ -383,19 +377,16 @@ var _ = Describe("Integration test", func() {
 			Expect(gethStorage1).NotTo(Equal(gethStorage2))
 			Expect(gethStorage2).To(Equal(eth.EmptyNodeValue))
 
-			ipldStorage1, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), common.HexToHash(totalSupplyIndex), big.NewInt(tx.BlockNumber-1))
+			_, err = ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), common.HexToHash(totalSupplyIndex), big.NewInt(tx.BlockNumber-1))
-			Expect(err).ToNot(HaveOccurred())
+			Expect(err).To(HaveOccurred())
-			ipldStorage2, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), common.HexToHash(totalSupplyIndex), big.NewInt(tx.BlockNumber))
+			_, err = ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), common.HexToHash(totalSupplyIndex), big.NewInt(tx.BlockNumber))
-			Expect(err).ToNot(HaveOccurred())
+			Expect(err).To(MatchError("header not found"))
-
-			Expect(ipldStorage1).To(Equal(gethStorage1))
-			Expect(ipldStorage2).To(Equal(gethStorage2))
 
 			// Query the current block
 			ipldStorage3, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), common.HexToHash(totalSupplyIndex), nil)
 			Expect(err).ToNot(HaveOccurred())
 
-			Expect(ipldStorage2).To(Equal(ipldStorage3))
+			Expect(eth.EmptyNodeValue).To(Equal(ipldStorage3))
 		})
 	})
 
@@ -454,13 +445,14 @@ var _ = Describe("Integration test", func() {
 
 	Describe("Chain ID", func() {
 		It("Check chain id", func() {
-			gethChainId, err := gethClient.ChainID(ctx)
+			if !directProxyEthCalls {
+				Skip("skipping direct-proxy-forwarding integration tests")
+			}
+			_, err := gethClient.ChainID(ctx)
 			Expect(err).ToNot(HaveOccurred())
 
-			ipldChainId, err := ipldClient.ChainID(ctx)
+			_, err = ipldClient.ChainID(ctx)
-			Expect(err).ToNot(HaveOccurred())
+			Expect(err).To(HaveOccurred())
-
-			Expect(gethChainId).To(Equal(ipldChainId))
 		})
 	})
 })

test/integration_test.go

@@ -505,6 +505,9 @@ var _ = Describe("Integration test", func() {
 
 	Describe("Chain ID", func() {
 		It("Check chain id", func() {
+			if directProxyEthCalls {
+				Skip("skipping no-direct-proxy-forwarding integration tests")
+			}
 			gethChainId, err := gethClient.ChainID(ctx)
 			Expect(err).ToNot(HaveOccurred())