2c03c8cbd0
* Implement debug_traceCall API * Use API implementation from geth with custom backend * Update refs in GitHub workflow
672 lines
26 KiB
Go
672 lines
26 KiB
Go
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"
|
|
sdtypes "github.com/ethereum/go-ethereum/statediff/types"
|
|
. "github.com/onsi/ginkgo"
|
|
. "github.com/onsi/gomega"
|
|
|
|
integration "github.com/cerc-io/ipld-eth-server/v4/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())
|
|
|
|
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 {
|
|
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 := sdtypes.Add
|
|
args := []sdtypes.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 := sdtypes.Add
|
|
args := []sdtypes.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 := sdtypes.Remove
|
|
args := []sdtypes.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 := sdtypes.Set
|
|
args := []sdtypes.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 := sdtypes.Clear
|
|
args := []sdtypes.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 := sdtypes.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))
|
|
})
|
|
})
|
|
})
|