From 56c85709c1c038eb52596c0cf90804f56a85b2fa Mon Sep 17 00:00:00 2001 From: nabarun Date: Thu, 17 Mar 2022 16:18:18 +0530 Subject: [PATCH] Add unit tests for fill service --- pkg/eth/api_test.go | 5 +- pkg/eth/cid_retriever_test.go | 5 +- pkg/eth/eth_state_test.go | 5 +- pkg/eth/ipld_fetcher_test.go | 5 +- pkg/eth/test_helpers.go | 32 -- pkg/fill/fill_suite_test.go | 29 ++ pkg/fill/service_test.go | 412 ++++++++++++++++++ pkg/graphql/graphql_test.go | 5 +- pkg/shared/test_helpers.go | 53 +++ scripts/run_integration_test.sh | 3 +- .../run_integration_test_forward_eth_calls.sh | 1 + ...gration_test_watched_address_gap_filler.sh | 2 +- test/contract/src/utils.js | 2 + 13 files changed, 515 insertions(+), 44 deletions(-) create mode 100644 pkg/fill/fill_suite_test.go create mode 100644 pkg/fill/service_test.go diff --git a/pkg/eth/api_test.go b/pkg/eth/api_test.go index 38c42161..62d77140 100644 --- a/pkg/eth/api_test.go +++ b/pkg/eth/api_test.go @@ -38,6 +38,7 @@ import ( "github.com/vulcanize/ipld-eth-server/pkg/eth" "github.com/vulcanize/ipld-eth-server/pkg/eth/test_helpers" + "github.com/vulcanize/ipld-eth-server/pkg/shared" ethServerShared "github.com/vulcanize/ipld-eth-server/pkg/shared" ) @@ -195,7 +196,7 @@ var _ = Describe("API", func() { tx interfaces.Batch ) - db = eth.SetupTestDB() + db = shared.SetupDB() indexAndPublisher := eth.SetupTestStateDiffIndexer(ctx, chainConfig, test_helpers.Genesis.Hash()) backend, err := eth.NewEthBackend(db, ð.Config{ @@ -251,7 +252,7 @@ var _ = Describe("API", func() { }) // Single test db tear down at end of all tests - defer It("test teardown", func() { eth.TearDownTestDB(db) }) + defer It("test teardown", func() { shared.TearDownDB(db) }) /* Headers and blocks diff --git a/pkg/eth/cid_retriever_test.go b/pkg/eth/cid_retriever_test.go index ff8d0698..1aa62ad3 100644 --- a/pkg/eth/cid_retriever_test.go +++ b/pkg/eth/cid_retriever_test.go @@ -31,6 +31,7 @@ import ( "github.com/vulcanize/ipld-eth-server/pkg/eth" "github.com/vulcanize/ipld-eth-server/pkg/eth/test_helpers" + "github.com/vulcanize/ipld-eth-server/pkg/shared" ) var ( @@ -215,13 +216,13 @@ var _ = Describe("Retriever", func() { retriever *eth.CIDRetriever ) BeforeEach(func() { - db = eth.SetupTestDB() + db = shared.SetupDB() diffIndexer = eth.SetupTestStateDiffIndexer(ctx, params.TestChainConfig, test_helpers.Genesis.Hash()) retriever = eth.NewCIDRetriever(db) }) AfterEach(func() { - eth.TearDownTestDB(db) + shared.TearDownDB(db) }) Describe("Retrieve", func() { diff --git a/pkg/eth/eth_state_test.go b/pkg/eth/eth_state_test.go index 17d0434f..362089c9 100644 --- a/pkg/eth/eth_state_test.go +++ b/pkg/eth/eth_state_test.go @@ -39,6 +39,7 @@ import ( "github.com/vulcanize/ipld-eth-server/pkg/eth" "github.com/vulcanize/ipld-eth-server/pkg/eth/test_helpers" + "github.com/vulcanize/ipld-eth-server/pkg/shared" ethServerShared "github.com/vulcanize/ipld-eth-server/pkg/shared" ) @@ -74,7 +75,7 @@ var _ = Describe("eth state reading tests", func() { It("test init", func() { // db and type initializations var err error - db = eth.SetupTestDB() + db = shared.SetupDB() transformer := eth.SetupTestStateDiffIndexer(ctx, chainConfig, test_helpers.Genesis.Hash()) backend, err = eth.NewEthBackend(db, ð.Config{ @@ -181,7 +182,7 @@ var _ = Describe("eth state reading tests", func() { Expect(err).ToNot(HaveOccurred()) }) defer It("test teardown", func() { - eth.TearDownTestDB(db) + shared.TearDownDB(db) chain.Stop() }) diff --git a/pkg/eth/ipld_fetcher_test.go b/pkg/eth/ipld_fetcher_test.go index f5521188..668966fb 100644 --- a/pkg/eth/ipld_fetcher_test.go +++ b/pkg/eth/ipld_fetcher_test.go @@ -25,6 +25,7 @@ import ( "github.com/vulcanize/ipld-eth-server/pkg/eth" "github.com/vulcanize/ipld-eth-server/pkg/eth/test_helpers" + "github.com/vulcanize/ipld-eth-server/pkg/shared" ) var _ = Describe("IPLDFetcher", func() { @@ -39,7 +40,7 @@ var _ = Describe("IPLDFetcher", func() { err error tx interfaces.Batch ) - db = eth.SetupTestDB() + db = shared.SetupDB() pubAndIndexer = eth.SetupTestStateDiffIndexer(ctx, params.TestChainConfig, test_helpers.Genesis.Hash()) tx, err = pubAndIndexer.PushBlock(test_helpers.MockBlock, test_helpers.MockReceipts, test_helpers.MockBlock.Difficulty()) @@ -54,7 +55,7 @@ var _ = Describe("IPLDFetcher", func() { }) AfterEach(func() { - eth.TearDownTestDB(db) + shared.TearDownDB(db) }) It("Fetches and returns IPLDs for the CIDs provided in the CIDWrapper", func() { diff --git a/pkg/eth/test_helpers.go b/pkg/eth/test_helpers.go index 621ea6fd..19625adb 100644 --- a/pkg/eth/test_helpers.go +++ b/pkg/eth/test_helpers.go @@ -28,41 +28,9 @@ import ( "github.com/ethereum/go-ethereum/statediff/indexer/interfaces" "github.com/ethereum/go-ethereum/statediff/indexer/models" "github.com/ethereum/go-ethereum/statediff/indexer/node" - "github.com/jmoiron/sqlx" . "github.com/onsi/gomega" - "github.com/vulcanize/ipld-eth-server/pkg/shared" ) -func SetupTestDB() *sqlx.DB { - config := getTestDBConfig() - - db, err := shared.NewDB(config.DbConnectionString(), config) - Expect(err).NotTo(HaveOccurred()) - - return db -} - -// TearDownTestDB is used to tear down the watcher dbs after tests -func TearDownTestDB(db *sqlx.DB) { - tx, err := db.Beginx() - Expect(err).NotTo(HaveOccurred()) - _, err = tx.Exec(`DELETE FROM eth.transaction_cids`) - Expect(err).NotTo(HaveOccurred()) - _, err = tx.Exec(`DELETE FROM eth.receipt_cids`) - Expect(err).NotTo(HaveOccurred()) - _, err = tx.Exec(`DELETE FROM eth.state_cids`) - Expect(err).NotTo(HaveOccurred()) - _, err = tx.Exec(`DELETE FROM eth.storage_cids`) - Expect(err).NotTo(HaveOccurred()) - _, err = tx.Exec(`DELETE FROM blocks`) - Expect(err).NotTo(HaveOccurred()) - _, err = tx.Exec(`DELETE FROM eth.log_cids`) - Expect(err).NotTo(HaveOccurred()) - - err = tx.Commit() - Expect(err).NotTo(HaveOccurred()) -} - func SetupTestStateDiffIndexer(ctx context.Context, chainConfig *params.ChainConfig, genHash common.Hash) interfaces.StateDiffIndexer { testInfo := node.Info{ GenesisBlock: genHash.String(), diff --git a/pkg/fill/fill_suite_test.go b/pkg/fill/fill_suite_test.go new file mode 100644 index 00000000..4b5a9103 --- /dev/null +++ b/pkg/fill/fill_suite_test.go @@ -0,0 +1,29 @@ +// VulcanizeDB +// Copyright © 2022 Vulcanize + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. + +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +package fill_test + +import ( + "testing" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +func TestFill(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "ipld eth server fill test suite") +} diff --git a/pkg/fill/service_test.go b/pkg/fill/service_test.go new file mode 100644 index 00000000..7d4b19ae --- /dev/null +++ b/pkg/fill/service_test.go @@ -0,0 +1,412 @@ +// VulcanizeDB +// Copyright © 2022 Vulcanize + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. + +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +package fill_test + +import ( + "context" + "math/big" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/statediff/indexer/interfaces" + sdtypes "github.com/ethereum/go-ethereum/statediff/types" + "github.com/jmoiron/sqlx" + + "github.com/vulcanize/ipld-eth-server/pkg/eth" + "github.com/vulcanize/ipld-eth-server/pkg/eth/test_helpers" + fill "github.com/vulcanize/ipld-eth-server/pkg/fill" + "github.com/vulcanize/ipld-eth-server/pkg/serve" + "github.com/vulcanize/ipld-eth-server/pkg/shared" +) + +var _ = Describe("Service", func() { + + var ( + db *sqlx.DB + watchedAddressGapFiller *fill.Service + statediffIndexer interfaces.StateDiffIndexer + err error + + contract1Address = "0x5d663F5269090bD2A7DC2390c911dF6083D7b28F" + contract2Address = "0x6Eb7e5C66DB8af2E96159AC440cbc8CDB7fbD26B" + contract3Address = "0xcfeB164C328CA13EFd3C77E1980d94975aDfedfc" + + chainConfig = params.TestChainConfig + ctx = context.Background() + ) + + It("test init", func() { + // db initialization + db = shared.SetupDB() + + // indexer initialization + // statediffIndexer, err = indexer.NewStateDiffIndexer(nil, db) + statediffIndexer = eth.SetupTestStateDiffIndexer(ctx, chainConfig, test_helpers.Genesis.Hash()) + Expect(err).ToNot(HaveOccurred()) + + // fill service intialization + watchedAddressGapFiller = fill.New(&serve.Config{ + DB: db, + }) + }) + + defer It("test teardown", func() { + shared.TearDownDB(db) + }) + + Describe("GetFillAddresses", func() { + Context("overlapping fill ranges", func() { + It("gives the range to run fill for each address", func() { + // input data + rows := []fill.WatchedAddress{ + { + Address: contract1Address, + CreatedAt: 10, + WatchedAt: 50, + LastFilledAt: 0, + }, + { + Address: contract2Address, + CreatedAt: 40, + WatchedAt: 70, + LastFilledAt: 0, + }, + { + Address: contract3Address, + CreatedAt: 20, + WatchedAt: 30, + LastFilledAt: 0, + }, + } + + // expected output data + expectedOutputAddresses := []fill.WatchedAddress{ + { + Address: contract1Address, + CreatedAt: 10, + WatchedAt: 50, + LastFilledAt: 0, + StartBlock: 10, + EndBlock: 50, + }, + { + Address: contract2Address, + CreatedAt: 40, + WatchedAt: 70, + LastFilledAt: 0, + StartBlock: 40, + EndBlock: 70, + }, + { + Address: contract3Address, + CreatedAt: 20, + WatchedAt: 30, + LastFilledAt: 0, + StartBlock: 20, + EndBlock: 30, + }, + } + expectedOutputStartBlock := uint64(10) + expectedOutputEndBlock := uint64(70) + + fillWatchedAddresses, minStartBlock, maxEndBlock := watchedAddressGapFiller.GetFillAddresses(rows) + + Expect(fillWatchedAddresses).To(Equal(expectedOutputAddresses)) + Expect(minStartBlock).To(Equal(expectedOutputStartBlock)) + Expect(maxEndBlock).To(Equal(expectedOutputEndBlock)) + }) + }) + + Context("non-overlapping fill ranges", func() { + It("gives the range to run fill for each address", func() { + // input data + rows := []fill.WatchedAddress{ + { + Address: contract1Address, + CreatedAt: 10, + WatchedAt: 50, + LastFilledAt: 0, + }, + { + Address: contract2Address, + CreatedAt: 70, + WatchedAt: 90, + LastFilledAt: 0, + }, + } + + // expected output data + expectedOutputAddresses := []fill.WatchedAddress{ + { + Address: contract1Address, + CreatedAt: 10, + WatchedAt: 50, + LastFilledAt: 0, + StartBlock: 10, + EndBlock: 50, + }, + { + Address: contract2Address, + CreatedAt: 70, + WatchedAt: 90, + LastFilledAt: 0, + StartBlock: 70, + EndBlock: 90, + }, + } + expectedOutputStartBlock := uint64(10) + expectedOutputEndBlock := uint64(90) + + fillWatchedAddresses, minStartBlock, maxEndBlock := watchedAddressGapFiller.GetFillAddresses(rows) + + Expect(fillWatchedAddresses).To(Equal(expectedOutputAddresses)) + Expect(minStartBlock).To(Equal(expectedOutputStartBlock)) + Expect(maxEndBlock).To(Equal(expectedOutputEndBlock)) + }) + }) + + Context("a contract watched before it was created", func() { + It("gives no range for an address when it is watched before it's created", func() { + // input data + rows := []fill.WatchedAddress{ + { + Address: contract1Address, + CreatedAt: 10, + WatchedAt: 50, + LastFilledAt: 0, + }, + { + Address: contract2Address, + CreatedAt: 90, + WatchedAt: 70, + LastFilledAt: 0, + }, + } + + // expected output data + expectedOutputAddresses := []fill.WatchedAddress{ + { + Address: contract1Address, + CreatedAt: 10, + WatchedAt: 50, + LastFilledAt: 0, + StartBlock: 10, + EndBlock: 50, + }, + } + expectedOutputStartBlock := uint64(10) + expectedOutputEndBlock := uint64(50) + + fillWatchedAddresses, minStartBlock, maxEndBlock := watchedAddressGapFiller.GetFillAddresses(rows) + + Expect(fillWatchedAddresses).To(Equal(expectedOutputAddresses)) + Expect(minStartBlock).To(Equal(expectedOutputStartBlock)) + Expect(maxEndBlock).To(Equal(expectedOutputEndBlock)) + }) + }) + + Context("a contract having some of the gap filled earlier", func() { + It("gives the remaining range for an address to run fill for", func() { + // input data + rows := []fill.WatchedAddress{ + { + Address: contract1Address, + CreatedAt: 10, + WatchedAt: 50, + LastFilledAt: 0, + }, + { + Address: contract2Address, + CreatedAt: 40, + WatchedAt: 70, + LastFilledAt: 50, + }, + } + + // expected output data + expectedOutputAddresses := []fill.WatchedAddress{ + { + Address: contract1Address, + CreatedAt: 10, + WatchedAt: 50, + LastFilledAt: 0, + StartBlock: 10, + EndBlock: 50, + }, + { + Address: contract2Address, + CreatedAt: 40, + WatchedAt: 70, + LastFilledAt: 50, + StartBlock: 51, + EndBlock: 70, + }, + } + expectedOutputStartBlock := uint64(10) + expectedOutputEndBlock := uint64(70) + + fillWatchedAddresses, minStartBlock, maxEndBlock := watchedAddressGapFiller.GetFillAddresses(rows) + + Expect(fillWatchedAddresses).To(Equal(expectedOutputAddresses)) + Expect(minStartBlock).To(Equal(expectedOutputStartBlock)) + Expect(maxEndBlock).To(Equal(expectedOutputEndBlock)) + }) + + It("gives no range for an address when the gap is already filled", func() { + // input data + rows := []fill.WatchedAddress{ + { + Address: contract1Address, + CreatedAt: 10, + WatchedAt: 50, + LastFilledAt: 0, + }, + { + Address: contract2Address, + CreatedAt: 40, + WatchedAt: 70, + LastFilledAt: 70, + }, + } + + // expected output data + expectedOutputAddresses := []fill.WatchedAddress{ + { + Address: contract1Address, + CreatedAt: 10, + WatchedAt: 50, + LastFilledAt: 0, + StartBlock: 10, + EndBlock: 50, + }, + } + expectedOutputStartBlock := uint64(10) + expectedOutputEndBlock := uint64(50) + + fillWatchedAddresses, minStartBlock, maxEndBlock := watchedAddressGapFiller.GetFillAddresses(rows) + + Expect(fillWatchedAddresses).To(Equal(expectedOutputAddresses)) + Expect(minStartBlock).To(Equal(expectedOutputStartBlock)) + Expect(maxEndBlock).To(Equal(expectedOutputEndBlock)) + }) + }) + }) + + Describe("UpdateLastFilledAt", func() { + pgStr := "SELECT * FROM eth_meta.watched_addresses" + + BeforeEach(func() { + shared.TearDownDB(db) + }) + + It("updates last filled at for a single address", func() { + // fill db with watched addresses + watchedAddresses := []sdtypes.WatchAddressArg{ + { + Address: contract1Address, + CreatedAt: 10, + }, + } + watchedAt := uint64(50) + err = statediffIndexer.InsertWatchedAddresses(watchedAddresses, big.NewInt(int64(watchedAt))) + Expect(err).ToNot(HaveOccurred()) + + // update last filled at block in the db + fillAddresses := []interface{}{ + contract1Address, + } + fillAt := uint64(12) + watchedAddressGapFiller.UpdateLastFilledAt(fillAt, fillAddresses) + + // expected data + expectedData := []fill.WatchedAddress{ + { + Address: contract1Address, + CreatedAt: 10, + WatchedAt: watchedAt, + LastFilledAt: fillAt, + }, + } + + rows := []fill.WatchedAddress{} + err = db.Select(&rows, pgStr) + Expect(err).ToNot(HaveOccurred()) + + Expect(rows).To(Equal(expectedData)) + }) + + It("updates last filled at for multiple address", func() { + // fill db with watched addresses + watchedAddresses := []sdtypes.WatchAddressArg{ + { + Address: contract1Address, + CreatedAt: 10, + }, + { + Address: contract2Address, + CreatedAt: 20, + }, + { + Address: contract3Address, + CreatedAt: 30, + }, + } + watchedAt := uint64(50) + err = statediffIndexer.InsertWatchedAddresses(watchedAddresses, big.NewInt(int64(watchedAt))) + Expect(err).ToNot(HaveOccurred()) + + // update last filled at block in the db + fillAddresses := []interface{}{ + contract1Address, + contract2Address, + contract3Address, + } + fillAt := uint64(50) + watchedAddressGapFiller.UpdateLastFilledAt(fillAt, fillAddresses) + + // expected data + expectedData := []fill.WatchedAddress{ + { + Address: contract1Address, + CreatedAt: 10, + WatchedAt: watchedAt, + LastFilledAt: fillAt, + }, + { + Address: contract2Address, + CreatedAt: 20, + WatchedAt: watchedAt, + LastFilledAt: fillAt, + }, + { + Address: contract3Address, + CreatedAt: 30, + WatchedAt: watchedAt, + LastFilledAt: fillAt, + }, + } + + rows := []fill.WatchedAddress{} + err = db.Select(&rows, pgStr) + Expect(err).ToNot(HaveOccurred()) + + Expect(rows).To(Equal(expectedData)) + }) + }) +}) diff --git a/pkg/graphql/graphql_test.go b/pkg/graphql/graphql_test.go index dec0d0dd..1770ef25 100644 --- a/pkg/graphql/graphql_test.go +++ b/pkg/graphql/graphql_test.go @@ -38,6 +38,7 @@ import ( "github.com/vulcanize/ipld-eth-server/pkg/eth" "github.com/vulcanize/ipld-eth-server/pkg/eth/test_helpers" "github.com/vulcanize/ipld-eth-server/pkg/graphql" + "github.com/vulcanize/ipld-eth-server/pkg/shared" ethServerShared "github.com/vulcanize/ipld-eth-server/pkg/shared" ) @@ -65,7 +66,7 @@ var _ = Describe("GraphQL", func() { It("test init", func() { var err error - db = eth.SetupTestDB() + db = shared.SetupDB() transformer := eth.SetupTestStateDiffIndexer(ctx, chainConfig, test_helpers.Genesis.Hash()) backend, err = eth.NewEthBackend(db, ð.Config{ @@ -166,7 +167,7 @@ var _ = Describe("GraphQL", func() { defer It("test teardown", func() { err := graphQLServer.Stop() Expect(err).ToNot(HaveOccurred()) - eth.TearDownTestDB(db) + shared.TearDownDB(db) chain.Stop() }) diff --git a/pkg/shared/test_helpers.go b/pkg/shared/test_helpers.go index eed5a7f0..d2b0e56d 100644 --- a/pkg/shared/test_helpers.go +++ b/pkg/shared/test_helpers.go @@ -18,8 +18,14 @@ package shared import ( "bytes" + "os" + "strconv" + . "github.com/onsi/gomega" + + "github.com/ethereum/go-ethereum/statediff/indexer/database/sql/postgres" "github.com/ethereum/go-ethereum/statediff/indexer/models" + "github.com/jmoiron/sqlx" ) // IPLDsContainBytes used to check if a list of strings contains a particular string @@ -31,3 +37,50 @@ func IPLDsContainBytes(iplds []models.IPLDModel, b []byte) bool { } return false } + +// SetupDB is use to setup a db for watcher tests +func SetupDB() *sqlx.DB { + config := getTestDBConfig() + + db, err := NewDB(config.DbConnectionString(), config) + Expect(err).NotTo(HaveOccurred()) + + return db +} + +// TearDownDB is used to tear down the watcher dbs after tests +func TearDownDB(db *sqlx.DB) { + tx, err := db.Beginx() + Expect(err).NotTo(HaveOccurred()) + _, err = tx.Exec(`DELETE FROM eth.header_cids`) + Expect(err).NotTo(HaveOccurred()) + _, err = tx.Exec(`DELETE FROM eth.transaction_cids`) + Expect(err).NotTo(HaveOccurred()) + _, err = tx.Exec(`DELETE FROM eth.receipt_cids`) + Expect(err).NotTo(HaveOccurred()) + _, err = tx.Exec(`DELETE FROM eth.state_cids`) + Expect(err).NotTo(HaveOccurred()) + _, err = tx.Exec(`DELETE FROM eth.storage_cids`) + Expect(err).NotTo(HaveOccurred()) + _, err = tx.Exec(`DELETE FROM blocks`) + Expect(err).NotTo(HaveOccurred()) + _, err = tx.Exec(`DELETE FROM eth.log_cids`) + Expect(err).NotTo(HaveOccurred()) + _, err = tx.Exec(`DELETE FROM eth_meta.watched_addresses`) + Expect(err).NotTo(HaveOccurred()) + + err = tx.Commit() + Expect(err).NotTo(HaveOccurred()) +} + +func getTestDBConfig() postgres.Config { + port, _ := strconv.Atoi(os.Getenv("DATABASE_PORT")) + return postgres.Config{ + Hostname: os.Getenv("DATABASE_HOSTNAME"), + DatabaseName: os.Getenv("DATABASE_NAME"), + Username: os.Getenv("DATABASE_USER"), + Password: os.Getenv("DATABASE_PASSWORD"), + Port: port, + Driver: postgres.SQLX, + } +} diff --git a/scripts/run_integration_test.sh b/scripts/run_integration_test.sh index 7e834f89..8548491a 100755 --- a/scripts/run_integration_test.sh +++ b/scripts/run_integration_test.sh @@ -3,9 +3,10 @@ set -o xtrace export ETH_FORWARD_ETH_CALLS=false export DB_WRITE=true -export ETH_HTTP_PATH="" +export ETH_HTTP_PATH="dapptools:8545" export ETH_PROXY_ON_ERROR=false export WATCHED_ADDRESS_GAP_FILLER_ENABLED=false +export WATCHED_ADDRESS_GAP_FILLER_INTERVAL=5 # 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 97985ceb..882c887b 100644 --- a/scripts/run_integration_test_forward_eth_calls.sh +++ b/scripts/run_integration_test_forward_eth_calls.sh @@ -6,6 +6,7 @@ export DB_WRITE=false export ETH_HTTP_PATH="dapptools:8545" export ETH_PROXY_ON_ERROR=false export WATCHED_ADDRESS_GAP_FILLER_ENABLED=false +export WATCHED_ADDRESS_GAP_FILLER_INTERVAL=5 # Clear up existing docker images and volume. docker-compose down --remove-orphans --volumes diff --git a/scripts/run_integration_test_watched_address_gap_filler.sh b/scripts/run_integration_test_watched_address_gap_filler.sh index 1201782e..1e436098 100644 --- a/scripts/run_integration_test_watched_address_gap_filler.sh +++ b/scripts/run_integration_test_watched_address_gap_filler.sh @@ -3,7 +3,7 @@ set -o xtrace export ETH_FORWARD_ETH_CALLS=false export DB_WRITE=true -export ETH_HTTP_PATH="" +export ETH_HTTP_PATH="dapptools:8545" export ETH_PROXY_ON_ERROR=false export WATCHED_ADDRESS_GAP_FILLER_ENABLED=true export WATCHED_ADDRESS_GAP_FILLER_INTERVAL=5 diff --git a/test/contract/src/utils.js b/test/contract/src/utils.js index be7ed0ef..f07e9e41 100644 --- a/test/contract/src/utils.js +++ b/test/contract/src/utils.js @@ -34,3 +34,5 @@ async function getStorageSlotKey(contractName, variableName) { key = utils.hexlify(BigNumber.from(targetState.slot)); return key }; + +module.exports = { getStorageSlotKey }