Add unit tests for fill service

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, &eth.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

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() {

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, &eth.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()
 	})
 

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() {

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(),

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 <http://www.gnu.org/licenses/>.
+
+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")
+}

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 <http://www.gnu.org/licenses/>.
+
+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))
+		})
+	})
+})

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, &eth.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()
 	})
 

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,
+	}
+}

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

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

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

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 }