From e6869f4236cd420a04be5e84603a36211806d472 Mon Sep 17 00:00:00 2001 From: i-norden Date: Wed, 29 Dec 2021 20:29:59 -0600 Subject: [PATCH] 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 | 4 + cmd/serve.go | 2 + docker-compose.yml | 3 +- environments/example.toml | 1 + pkg/eth/api.go | 72 ++++++++------- pkg/eth/api_test.go | 2 +- pkg/eth/eth_state_test.go | 2 +- pkg/serve/config.go | 4 + pkg/serve/service.go | 5 +- scripts/run_integration_test.sh | 2 + .../run_integration_test_forward_eth_calls.sh | 2 + test/direct_proxy_integration_test.go | 88 +++++++++---------- test/integration_test.go | 3 + 13 files changed, 105 insertions(+), 85 deletions(-) diff --git a/.github/workflows/on-pr.yaml b/.github/workflows/on-pr.yaml index 5f889365..0770355a 100644 --- a/.github/workflows/on-pr.yaml +++ b/.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 ] diff --git a/cmd/serve.go b/cmd/serve.go index d31abc61..11330ad6 100644 --- a/cmd/serve.go +++ b/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")) diff --git a/docker-compose.yml b/docker-compose.yml index d637bf2f..fe0baff1 100644 --- a/docker-compose.yml +++ b/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 diff --git a/environments/example.toml b/environments/example.toml index 1950c804..102a592c 100644 --- a/environments/example.toml +++ b/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 diff --git a/pkg/eth/api.go b/pkg/eth/api.go index 0a83f518..340d1ec2 100644 --- a/pkg/eth/api.go +++ b/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 { - chainID := new(big.Int) +func (pea *PublicEthAPI) ChainId() (*hexutil.Big, error) { block, err := pea.B.CurrentBlock() if err != nil { - logrus.Errorf("ChainId failed with err %s", err.Error()) - - return 0 + if pea.proxyOnError { + if id, err := pea.ethClient.ChainID(context.Background()); err == nil { + 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 (hexutil.Uint64)(chainID.Uint64()) + return nil, fmt.Errorf("chain not synced beyond EIP-155 replay-protection fork block") } /* @@ -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) diff --git a/pkg/eth/api_test.go b/pkg/eth/api_test.go index f3a7d0ac..203a7572 100644 --- a/pkg/eth/api_test.go +++ b/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()) diff --git a/pkg/eth/eth_state_test.go b/pkg/eth/eth_state_test.go index 9a165192..581c0628 100644 --- a/pkg/eth/eth_state_test.go +++ b/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) diff --git a/pkg/serve/config.go b/pkg/serve/config.go index 3fb0e900..b378bf31 100644 --- a/pkg/serve/config.go +++ b/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 diff --git a/pkg/serve/service.go b/pkg/serve/service.go index ada685f8..b1c295f2 100644 --- a/pkg/serve/service.go +++ b/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, ð.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) } diff --git a/scripts/run_integration_test.sh b/scripts/run_integration_test.sh index e34efb6f..09bffcef 100755 --- a/scripts/run_integration_test.sh +++ b/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 diff --git a/scripts/run_integration_test_forward_eth_calls.sh b/scripts/run_integration_test_forward_eth_calls.sh index 763eda41..0b7ab672 100644 --- a/scripts/run_integration_test_forward_eth_calls.sh +++ b/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 diff --git a/test/direct_proxy_integration_test.go b/test/direct_proxy_integration_test.go index 7e6a075a..4256c18d 100644 --- a/test/direct_proxy_integration_test.go +++ b/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) - Expect(err).To(HaveOccurred()) + ipldLogs, err := ipldClient.FilterLogs(ctx, filterQuery) + 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(gethBalance).To(Equal(ipldBalance)) + Expect(ipldBalance.String()).To(Equal(big.NewInt(0).String())) }) 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))) - Expect(err).ToNot(HaveOccurred()) - - Expect(gethBalance).To(Equal(ipldBalance)) + _, err = ipldClient.BalanceAt(ctx, common.HexToAddress(address), big.NewInt(int64(tx.BlockNumber))) + Expect(err).To(HaveOccurred()) }) 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))) - Expect(err).ToNot(HaveOccurred()) - - Expect(gethBalance).To(Equal(ipldBalance)) + _, err = ipldClient.BalanceAt(ctx, common.HexToAddress(address), big.NewInt(int64(tx.BlockNumber-1))) + Expect(err).To(HaveOccurred()) }) 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()) - - ipldTotalSupply := new(big.Int).SetBytes(ipldStorage) - Expect(ipldTotalSupply).To(Equal(erc20TotalSupply)) - - Expect(gethStorage).To(Equal(ipldStorage)) + Expect(ipldStorage).To(Equal(make([]byte, 32))) }) 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))) - Expect(err).ToNot(HaveOccurred()) - Expect(gethStorage).To(Equal(ipldStorage)) + _, err = ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), common.HexToHash(totalSupplyIndex), big.NewInt(int64(contract.BlockNumber))) + Expect(err).To(HaveOccurred()) }) 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))) - Expect(err).ToNot(HaveOccurred()) - Expect(gethStorage).To(Equal(ipldStorage)) + _, err = ipldClient.StorageAt(ctx, common.HexToAddress(nonExistingAddress), common.HexToHash(totalSupplyIndex), big.NewInt(int64(contract.BlockNumber))) + Expect(err).To(MatchError("header not found")) }) 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))) - Expect(err).ToNot(HaveOccurred()) - Expect(gethStorage).To(Equal(ipldStorage)) + _, err = ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), randomHash, big.NewInt(int64(contract.BlockNumber))) + Expect(err).To(MatchError("header not found")) }) 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)) - Expect(err).ToNot(HaveOccurred()) - ipldStorage2, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), common.HexToHash(totalSupplyIndex), big.NewInt(tx.BlockNumber)) - Expect(err).ToNot(HaveOccurred()) - - Expect(ipldStorage1).To(Equal(gethStorage1)) - Expect(ipldStorage2).To(Equal(gethStorage2)) + _, err = ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), common.HexToHash(totalSupplyIndex), big.NewInt(tx.BlockNumber-1)) + Expect(err).To(HaveOccurred()) + _, err = ipldClient.StorageAt(ctx, common.HexToAddress(contract.Address), common.HexToHash(totalSupplyIndex), big.NewInt(tx.BlockNumber)) + Expect(err).To(MatchError("header not found")) // 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) - Expect(err).ToNot(HaveOccurred()) - - Expect(gethChainId).To(Equal(ipldChainId)) + _, err = ipldClient.ChainID(ctx) + Expect(err).To(HaveOccurred()) }) }) }) diff --git a/test/integration_test.go b/test/integration_test.go index 2c19815a..9abaaaff 100644 --- a/test/integration_test.go +++ b/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())