package integration_test

import (
	"context"
	"math/big"
	"os"
	"strconv"
	"time"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/ethclient"
	"github.com/ethereum/go-ethereum/rpc"
	"github.com/ethereum/go-ethereum/statediff/types"
	sdtypes "github.com/ethereum/go-ethereum/statediff/types"
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	integration "github.com/vulcanize/ipld-eth-server/v3/test"
)

var (
	gethMethod = "statediff_watchAddress"
	ipldMethod = "vdb_watchAddress"

	sleepInterval = 2 * time.Second
)

var _ = Describe("WatchAddress integration test", func() {
	dbWrite, err := strconv.ParseBool(os.Getenv("DB_WRITE"))
	Expect(err).To(BeNil())

	watchedAddressServiceEnabled, err := strconv.ParseBool(os.Getenv("WATCHED_ADDRESS_GAP_FILLER_ENABLED"))
	Expect(err).To(BeNil())

	gethHttpPath := "http://127.0.0.1:8545"
	gethRPCClient, err := rpc.Dial(gethHttpPath)
	Expect(err).ToNot(HaveOccurred())

	ipldEthHttpPath := "http://127.0.0.1:8081"
	ipldClient, err := ethclient.Dial(ipldEthHttpPath)
	Expect(err).ToNot(HaveOccurred())
	ipldRPCClient, err := rpc.Dial(ipldEthHttpPath)
	Expect(err).ToNot(HaveOccurred())

	var (
		ctx = context.Background()

		txErr       error
		contractErr error
		incErr      error

		contract1 *integration.ContractDeployed
		contract2 *integration.ContractDeployed
		contract3 *integration.ContractDeployed

		countAIndex string

		prevBalance1 *big.Int
		prevBalance2 *big.Int
		prevBalance3 *big.Int

		actualBalance1 *big.Int
		actualBalance2 *big.Int
		actualBalance3 *big.Int

		prevCountA1 *big.Int
		prevCountA2 *big.Int
		prevCountA3 *big.Int

		actualCountA1 *big.Int
		actualCountA2 *big.Int
		actualCountA3 *big.Int
	)

	BeforeEach(func() {
		if !dbWrite || watchedAddressServiceEnabled {
			Skip("skipping WatchAddress API integration tests")
		}
	})

	It("test init", func() {
		// Deploy three contracts
		contract1, contractErr = integration.DeploySLVContract()
		Expect(contractErr).ToNot(HaveOccurred())

		contract2, contractErr = integration.DeploySLVContract()
		Expect(contractErr).ToNot(HaveOccurred())

		contract3, contractErr = integration.DeploySLVContract()
		Expect(contractErr).ToNot(HaveOccurred())

		// Get the storage slot key
		storageSlotAKey, err := integration.GetStorageSlotKey("SLVToken", "countA")
		Expect(err).ToNot(HaveOccurred())
		countAIndex = storageSlotAKey.Key

		// Clear out watched addresses
		err = integration.ClearWatchedAddresses(gethRPCClient)
		Expect(err).ToNot(HaveOccurred())

		// Get initial balances for all the contracts
		// Contract 1
		actualBalance1 = big.NewInt(0)
		initBalance1, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract1.Address), nil)
		Expect(err).ToNot(HaveOccurred())
		Expect(initBalance1.String()).To(Equal(actualBalance1.String()))
		prevBalance1 = big.NewInt(0)

		// Contract 2
		actualBalance2 = big.NewInt(0)
		initBalance2, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract2.Address), nil)
		Expect(err).ToNot(HaveOccurred())
		Expect(initBalance2.String()).To(Equal(actualBalance2.String()))
		prevBalance2 = big.NewInt(0)

		// Contract 3
		actualBalance3 = big.NewInt(0)
		initBalance3, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract3.Address), nil)
		Expect(err).ToNot(HaveOccurred())
		Expect(initBalance3.String()).To(Equal(actualBalance3.String()))
		prevBalance3 = big.NewInt(0)

		// Get initial storage values for the contracts
		// Contract 1, countA
		actualCountA1 = big.NewInt(0)
		ipldCountA1Storage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countAIndex), nil)
		Expect(err).ToNot(HaveOccurred())
		ipldCountA1 := new(big.Int).SetBytes(ipldCountA1Storage)
		Expect(ipldCountA1.String()).To(Equal(actualCountA1.String()))
		prevCountA1 = big.NewInt(0)

		// Contract 2, countA
		actualCountA2 = big.NewInt(0)
		ipldCountA2Storage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countAIndex), nil)
		Expect(err).ToNot(HaveOccurred())
		ipldCountA2 := new(big.Int).SetBytes(ipldCountA2Storage)
		Expect(ipldCountA2.String()).To(Equal(actualCountA2.String()))
		prevCountA2 = big.NewInt(0)

		// Contract 3, countA
		actualCountA3 = big.NewInt(0)
		ipldCountA3Storage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract3.Address), common.HexToHash(countAIndex), nil)
		Expect(err).ToNot(HaveOccurred())
		ipldCountA3 := new(big.Int).SetBytes(ipldCountA3Storage)
		Expect(ipldCountA3.String()).To(Equal(actualCountA2.String()))
		prevCountA3 = big.NewInt(0)
	})

	defer It("test cleanup", func() {
		// Clear out watched addresses
		err := integration.ClearWatchedAddresses(gethRPCClient)
		Expect(err).ToNot(HaveOccurred())
	})

	Context("no contracts being watched", func() {
		It("indexes state for all the contracts", func() {
			// WatchedAddresses = []
			// Send eth to all three contract accounts
			// Contract 1
			_, txErr = integration.SendEth(contract1.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance1.Add(actualBalance1, big.NewInt(10000000000000000))

			balance1AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract1.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance1AfterTransfer.String()).To(Equal(actualBalance1.String()))
			prevBalance1.Set(actualBalance1)

			// Contract 2
			_, txErr = integration.SendEth(contract2.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance2.Add(actualBalance2, big.NewInt(10000000000000000))

			balance2AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract2.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance2AfterTransfer.String()).To(Equal(actualBalance2.String()))
			prevBalance2.Set(actualBalance2)

			// Contract 3
			_, txErr = integration.SendEth(contract3.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance3.Add(actualBalance3, big.NewInt(10000000000000000))

			balance3AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract3.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance3AfterTransfer.String()).To(Equal(actualBalance3.String()))
			prevBalance3.Set(actualBalance3)

			// Increment counts
			// Contract 1, countA
			_, incErr = integration.IncrementCount(contract1.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA1.Add(actualCountA1, big.NewInt(1))

			countA1AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA1AfterIncrement := new(big.Int).SetBytes(countA1AfterIncrementStorage)
			Expect(countA1AfterIncrement.String()).To(Equal(actualCountA1.String()))
			prevCountA1.Set(actualCountA1)

			// Contract 2, countA
			_, incErr = integration.IncrementCount(contract2.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA2.Add(actualCountA2, big.NewInt(1))

			countA2AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA2AfterIncrement := new(big.Int).SetBytes(countA2AfterIncrementStorage)
			Expect(countA2AfterIncrement.String()).To(Equal(actualCountA2.String()))
			prevCountA2.Set(actualCountA2)

			// Contract 3, countA
			_, incErr = integration.IncrementCount(contract3.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA3.Add(actualCountA3, big.NewInt(1))

			countA3AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract3.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA3AfterIncrement := new(big.Int).SetBytes(countA3AfterIncrementStorage)
			Expect(countA3AfterIncrement.String()).To(Equal(actualCountA3.String()))
			prevCountA3.Set(actualCountA3)
		})
	})

	Context("one contract being watched", func() {
		It("indexes state only for the watched contract", func() {
			operation := types.Add
			args := []types.WatchAddressArg{
				{
					Address:   contract1.Address,
					CreatedAt: uint64(contract1.BlockNumber),
				},
			}
			ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
			Expect(ipldErr).ToNot(HaveOccurred())

			// WatchedAddresses = [Contract1]
			// Send eth to all three contract accounts
			// Contract 1
			_, txErr = integration.SendEth(contract1.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance1.Add(actualBalance1, big.NewInt(10000000000000000))

			balance1AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract1.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance1AfterTransfer.String()).To(Equal(actualBalance1.String()))
			prevBalance1.Set(actualBalance1)

			// Contract 2
			_, txErr = integration.SendEth(contract2.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance2.Add(actualBalance2, big.NewInt(10000000000000000))

			balance2AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract2.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance2AfterTransfer.String()).To(Equal(prevBalance2.String()))

			// Contract 3
			_, txErr = integration.SendEth(contract3.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance3.Add(actualBalance3, big.NewInt(10000000000000000))

			balance3AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract3.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance3AfterTransfer.String()).To(Equal(prevBalance3.String()))

			// Increment counts
			// Contract 1, countA
			_, incErr = integration.IncrementCount(contract1.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA1.Add(actualCountA1, big.NewInt(1))

			countA1AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA1AfterIncrement := new(big.Int).SetBytes(countA1AfterIncrementStorage)
			Expect(countA1AfterIncrement.String()).To(Equal(actualCountA1.String()))
			prevCountA1.Set(actualCountA1)

			// Contract 2, countA
			_, incErr = integration.IncrementCount(contract2.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA2.Add(actualCountA2, big.NewInt(1))

			countA2AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA2AfterIncrement := new(big.Int).SetBytes(countA2AfterIncrementStorage)
			Expect(countA2AfterIncrement.String()).To(Equal(prevCountA2.String()))

			// Contract 3, countA
			_, incErr = integration.IncrementCount(contract3.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA3.Add(actualCountA3, big.NewInt(1))

			countA3AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract3.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA3AfterIncrement := new(big.Int).SetBytes(countA3AfterIncrementStorage)
			Expect(countA3AfterIncrement.String()).To(Equal(prevCountA3.String()))
		})
	})

	Context("contract added to a non-empty watch-list", func() {
		It("indexes state only for the watched contracts", func() {
			operation := types.Add
			args := []types.WatchAddressArg{
				{
					Address:   contract2.Address,
					CreatedAt: uint64(contract2.BlockNumber),
				},
			}
			ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
			Expect(ipldErr).ToNot(HaveOccurred())

			// WatchedAddresses = [Contract1, Contract2]
			// Send eth to all three contract accounts
			// Contract 1
			_, txErr = integration.SendEth(contract1.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance1.Add(actualBalance1, big.NewInt(10000000000000000))

			balance1AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract1.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance1AfterTransfer.String()).To(Equal(actualBalance1.String()))
			prevBalance1.Set(actualBalance1)

			// Contract 2
			_, txErr = integration.SendEth(contract2.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance2.Add(actualBalance2, big.NewInt(10000000000000000))

			balance2AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract2.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance2AfterTransfer.String()).To(Equal(actualBalance2.String()))
			prevBalance2.Set(actualBalance2)

			// Contract 3
			_, txErr = integration.SendEth(contract3.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance3.Add(actualBalance3, big.NewInt(10000000000000000))

			balance3AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract3.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance3AfterTransfer.String()).To(Equal(prevBalance3.String()))

			// Increment counts
			// Contract 1, countA
			_, incErr = integration.IncrementCount(contract1.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA1.Add(actualCountA1, big.NewInt(1))

			countA1AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA1AfterIncrement := new(big.Int).SetBytes(countA1AfterIncrementStorage)
			Expect(countA1AfterIncrement.String()).To(Equal(actualCountA1.String()))
			prevCountA1.Set(actualCountA1)

			// Contract 2, countA
			_, incErr = integration.IncrementCount(contract2.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA2.Add(actualCountA2, big.NewInt(1))

			countA2AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA2AfterIncrement := new(big.Int).SetBytes(countA2AfterIncrementStorage)
			Expect(countA2AfterIncrement.String()).To(Equal(actualCountA2.String()))
			prevCountA2.Set(actualCountA2)

			// Contract 3, countA
			_, incErr = integration.IncrementCount(contract3.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA3.Add(actualCountA3, big.NewInt(1))

			countA3AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract3.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA3AfterIncrement := new(big.Int).SetBytes(countA3AfterIncrementStorage)
			Expect(countA3AfterIncrement.String()).To(Equal(prevCountA3.String()))
		})
	})

	Context("contract removed from the watch-list", func() {
		It("indexes state only for the watched contract", func() {
			operation := types.Remove
			args := []types.WatchAddressArg{
				{
					Address:   contract1.Address,
					CreatedAt: uint64(contract1.BlockNumber),
				},
			}
			ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
			Expect(ipldErr).ToNot(HaveOccurred())

			// WatchedAddresses = [Contract2]
			// Send eth to all three contract accounts
			// Contract 1
			_, txErr = integration.SendEth(contract1.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance1.Add(actualBalance1, big.NewInt(10000000000000000))

			balance1AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract1.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance1AfterTransfer.String()).To(Equal(prevBalance1.String()))

			// Contract 2
			_, txErr = integration.SendEth(contract2.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance2.Add(actualBalance2, big.NewInt(10000000000000000))

			balance2AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract2.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance2AfterTransfer.String()).To(Equal(actualBalance2.String()))
			prevBalance2.Set(actualBalance2)

			// Contract 3
			_, txErr = integration.SendEth(contract3.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance3.Add(actualBalance3, big.NewInt(10000000000000000))

			balance3AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract3.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance3AfterTransfer.String()).To(Equal(prevBalance3.String()))

			// Increment counts
			// Contract 1, countA
			_, incErr = integration.IncrementCount(contract1.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA1.Add(actualCountA1, big.NewInt(1))

			countA1AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA1AfterIncrement := new(big.Int).SetBytes(countA1AfterIncrementStorage)
			Expect(countA1AfterIncrement.String()).To(Equal(prevCountA1.String()))

			// Contract 2, countA
			_, incErr = integration.IncrementCount(contract2.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA2.Add(actualCountA2, big.NewInt(1))

			countA2AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA2AfterIncrement := new(big.Int).SetBytes(countA2AfterIncrementStorage)
			Expect(countA2AfterIncrement.String()).To(Equal(actualCountA2.String()))
			prevCountA2.Set(actualCountA2)

			// Contract 3, countA
			_, incErr = integration.IncrementCount(contract3.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA3.Add(actualCountA3, big.NewInt(1))

			countA3AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract3.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA3AfterIncrement := new(big.Int).SetBytes(countA3AfterIncrementStorage)
			Expect(countA3AfterIncrement.String()).To(Equal(prevCountA3.String()))
		})
	})

	Context("list of watched addresses set", func() {
		It("indexes state only for the watched contracts", func() {
			operation := types.Set
			args := []types.WatchAddressArg{
				{
					Address:   contract1.Address,
					CreatedAt: uint64(contract1.BlockNumber),
				},
				{
					Address:   contract3.Address,
					CreatedAt: uint64(contract3.BlockNumber),
				},
			}
			ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
			Expect(ipldErr).ToNot(HaveOccurred())

			// WatchedAddresses = [Contract1, Contract3]
			// Send eth to all three contract accounts
			// Contract 1
			_, txErr = integration.SendEth(contract1.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance1.Add(actualBalance1, big.NewInt(10000000000000000))

			balance1AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract1.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance1AfterTransfer.String()).To(Equal(actualBalance1.String()))
			prevBalance1.Set(actualBalance1)

			// Contract 2
			_, txErr = integration.SendEth(contract2.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance2.Add(actualBalance2, big.NewInt(10000000000000000))

			balance2AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract2.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance2AfterTransfer.String()).To(Equal(prevBalance2.String()))

			// Contract 3
			_, txErr = integration.SendEth(contract3.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance3.Add(actualBalance3, big.NewInt(10000000000000000))

			balance3AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract3.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance3AfterTransfer.String()).To(Equal(actualBalance3.String()))
			prevBalance3.Set(actualBalance3)

			// Increment counts
			// Contract 1, countA
			_, incErr = integration.IncrementCount(contract1.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA1.Add(actualCountA1, big.NewInt(1))

			countA1AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA1AfterIncrement := new(big.Int).SetBytes(countA1AfterIncrementStorage)
			Expect(countA1AfterIncrement.String()).To(Equal(actualCountA1.String()))
			prevCountA1.Set(actualCountA1)

			// Contract 2, countA
			_, incErr = integration.IncrementCount(contract2.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA2.Add(actualCountA2, big.NewInt(1))

			countA2AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA2AfterIncrement := new(big.Int).SetBytes(countA2AfterIncrementStorage)
			Expect(countA2AfterIncrement.String()).To(Equal(prevCountA2.String()))

			// Contract 3, countA
			_, incErr = integration.IncrementCount(contract3.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA3.Add(actualCountA3, big.NewInt(1))

			countA3AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract3.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA3AfterIncrement := new(big.Int).SetBytes(countA3AfterIncrementStorage)
			Expect(countA3AfterIncrement.String()).To(Equal(actualCountA3.String()))
			prevCountA3.Set(actualCountA3)
		})
	})

	Context("list of watched addresses cleared", func() {
		It("indexes state for all the contracts", func() {
			operation := types.Clear
			args := []types.WatchAddressArg{}
			ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
			Expect(ipldErr).ToNot(HaveOccurred())

			// WatchedAddresses = []
			// Send eth to all three contract accounts
			// Contract 1
			_, txErr = integration.SendEth(contract1.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance1.Add(actualBalance1, big.NewInt(10000000000000000))

			balance1AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract1.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance1AfterTransfer.String()).To(Equal(actualBalance1.String()))
			prevBalance1.Set(actualBalance1)

			// Contract 2
			_, txErr = integration.SendEth(contract2.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance2.Add(actualBalance2, big.NewInt(10000000000000000))

			balance2AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract2.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance2AfterTransfer.String()).To(Equal(actualBalance2.String()))
			prevBalance2.Set(actualBalance2)

			// Contract 3
			_, txErr = integration.SendEth(contract3.Address, "0.01")
			time.Sleep(sleepInterval)
			Expect(txErr).ToNot(HaveOccurred())
			actualBalance3.Add(actualBalance3, big.NewInt(10000000000000000))

			balance3AfterTransfer, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract3.Address), nil)
			Expect(err).ToNot(HaveOccurred())
			Expect(balance3AfterTransfer.String()).To(Equal(actualBalance3.String()))
			prevBalance3.Set(actualBalance3)

			// Increment counts
			// Contract 1, countA
			_, incErr = integration.IncrementCount(contract1.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA1.Add(actualCountA1, big.NewInt(1))

			countA1AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA1AfterIncrement := new(big.Int).SetBytes(countA1AfterIncrementStorage)
			Expect(countA1AfterIncrement.String()).To(Equal(actualCountA1.String()))
			prevCountA1.Set(actualCountA1)

			// Contract 2, countA
			_, incErr = integration.IncrementCount(contract2.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA2.Add(actualCountA2, big.NewInt(1))

			countA2AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA2AfterIncrement := new(big.Int).SetBytes(countA2AfterIncrementStorage)
			Expect(countA2AfterIncrement.String()).To(Equal(actualCountA2.String()))
			prevCountA2.Set(actualCountA2)

			// Contract 3, countA
			_, incErr = integration.IncrementCount(contract3.Address, "A")
			time.Sleep(sleepInterval)
			Expect(incErr).ToNot(HaveOccurred())
			actualCountA3.Add(actualCountA3, big.NewInt(1))

			countA3AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract3.Address), common.HexToHash(countAIndex), nil)
			Expect(err).ToNot(HaveOccurred())
			countA3AfterIncrement := new(big.Int).SetBytes(countA3AfterIncrementStorage)
			Expect(countA3AfterIncrement.String()).To(Equal(actualCountA3.String()))
			prevCountA3.Set(actualCountA3)
		})
	})

	Context("with invalid args", func() {
		It("returns an error on invalid operation arg", func() {
			operation := "WrongOp"
			args := []sdtypes.WatchAddressArg{}

			gethErr := gethRPCClient.Call(nil, gethMethod, operation, args)
			Expect(gethErr).To(HaveOccurred())

			ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
			Expect(ipldErr).To(HaveOccurred())

			Expect(ipldErr).To(Equal(gethErr))
		})

		It("returns an error on args of invalid type", func() {
			operation := types.Add
			args := []string{"WrongArg"}

			gethErr := gethRPCClient.Call(nil, gethMethod, operation, args)
			Expect(gethErr).To(HaveOccurred())

			ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
			Expect(ipldErr).To(HaveOccurred())

			Expect(ipldErr).To(Equal(gethErr))
		})
	})
})