cerc-io/ipld-eth-server
18
0
Fork 1
Code Issues 10 Pull Requests 1 Actions Packages Projects Releases 37 Wiki Activity

Add integration tests for API to change storage slots watched by geth

Browse Source
This commit is contained in:
Prathamesh Musale 2022-01-27 19:48:16 +05:30
parent 779bada218
commit 20bd8db21c
7 changed files with 827 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
test/contract/contracts/GLDToken.sol
View File

@ -7,5 +7,4 @@ contract GLDToken is ERC20 {
function destroy() public {
selfdestruct(payable(msg.sender));
}
receive() external payable {}
}

23
test/contract/contracts/SLVToken.sol Normal file
View File

@ -0,0 +1,23 @@
// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract SLVToken is ERC20 {
uint256 private countA;
uint256 private countB;
constructor() ERC20("Silver", "SLV") {
_mint(msg.sender, 1000000000000000000000);
}
function incrementCountA() public {
countA = countA + 1;
}
function incrementCountB() public {
countB = countB + 1;
}
receive() external payable {}
}

13
test/contract/hardhat.config.js
View File

@ -17,7 +17,18 @@ task("accounts", "Prints the list of accounts", async () => {
* @type import('hardhat/config').HardhatUserConfig
*/
module.exports = {
solidity: "0.8.0",
solidity: {
version: "0.8.0",
settings: {
outputSelection: {
'*': {
'*': [
'abi', 'storageLayout',
]
}
}
}
},
networks: {
local: {
url: 'http://127.0.0.1:8545',

60
test/contract/src/index.js
View File

@ -1,5 +1,6 @@
const fastify = require('fastify')({ logger: true });
const hre = require("hardhat");
const { getStorageSlotKey } = require('./utils');
// readiness check
@ -12,15 +13,14 @@ fastify.get('/v1/healthz', async (req, reply) => {
fastify.get('/v1/deployContract', async (req, reply) => {
const GLDToken = await hre.ethers.getContractFactory("GLDToken");
const token = await GLDToken.deploy();
let token = await GLDToken.deploy();
await token.deployed();
const rct = await token.deployTransaction.wait();
return {
address: token.address,
txHash: token.deployTransaction.hash,
blockNumber: rct.blockNumber,
blockHash: rct.blockHash,
blockNumber: token.deployTransaction.blockNumber,
blockHash: token.deployTransaction.blockHash,
}
});
@ -64,6 +64,58 @@ fastify.get('/v1/sendEth', async (req, reply) => {
}
});
fastify.get('/v1/deploySLVContract', async (req, reply) => {
const SLVToken = await hre.ethers.getContractFactory("SLVToken");
const token = await SLVToken.deploy();
const receipt = await token.deployTransaction.wait();
return {
address: token.address,
txHash: token.deployTransaction.hash,
blockNumber: receipt.blockNumber,
blockHash: receipt.blockHash,
}
});
fastify.get('/v1/incrementCountA', async (req, reply) => {
const addr = req.query.addr;
const SLVToken = await hre.ethers.getContractFactory("SLVToken");
const token = await SLVToken.attach(addr);
const tx = await token.incrementCountA();
const receipt = await tx.wait();
return {
blockNumber: receipt.blockNumber,
}
});
fastify.get('/v1/incrementCountB', async (req, reply) => {
const addr = req.query.addr;
const SLVToken = await hre.ethers.getContractFactory("SLVToken");
const token = await SLVToken.attach(addr);
const tx = await token.incrementCountB();
const receipt = await tx.wait();
return {
blockNumber: receipt.blockNumber,
}
});
fastify.get('/v1/getStorageKey', async (req, reply) => {
const contract = req.query.contract;
const label = req.query.label;
const key = await getStorageSlotKey(contract, label)
return {
key
}
});
async function main() {
try {
await fastify.listen(3000, '0.0.0.0');

38
test/contract/src/utils.js Normal file
View File

@ -0,0 +1,38 @@
// import { artifacts } from 'hardhat';
const { artifacts } = require("hardhat")
const { utils, BigNumber } = require("ethers")
async function getStorageLayout(contractName) {
const artifact = await artifacts.readArtifact(contractName);
const buildInfo = await artifacts.getBuildInfo(`${artifact.sourceName}:${artifact.contractName}`);
if (!buildInfo) {
throw new Error('storageLayout not present in compiler output.');
}
const output = buildInfo.output;
const { storageLayout } = output.contracts[artifact.sourceName][artifact.contractName];
if (!storageLayout) {
throw new Error('Contract hasn\'t been compiled.');
}
return storageLayout;
};
async function getStorageSlotKey(contractName, variableName) {
storageLayout = await getStorageLayout(contractName)
const { storage } = storageLayout;
const targetState = storage.find((state) => state.label === variableName);
// Throw if state variable could not be found in storage layout.
if (!targetState) {
throw new Error('Variable not present in storage layout.');
}
key = utils.hexlify(BigNumber.from(targetState.slot));
return key
};
module.exports = { getStorageSlotKey }

58
test/helper.go
View File

@ -27,6 +27,10 @@ type Tx struct {
BlockHash string `json:"blockHash"`
}
type StorageKey struct {
Key string `json:"key"`
}
const srvUrl = "http://localhost:3000"
func DeployContract() (*ContractDeployed, error) {
@ -77,3 +81,57 @@ func SendEth(to string, value string) (*Tx, error) {
return &tx, nil
}
func DeploySLVContract() (*ContractDeployed, error) {
res, err := http.Get(fmt.Sprintf("%s/v1/deploySLVContract", srvUrl))
if err != nil {
return nil, err
}
defer res.Body.Close()
var contract ContractDeployed
decoder := json.NewDecoder(res.Body)
err = decoder.Decode(&contract)
if err != nil {
return nil, err
}
return &contract, nil
}
func IncrementCountA(addr string) error {
_, err := http.Get(fmt.Sprintf("%s/v1/incrementCountA?addr=%s", srvUrl, addr))
if err != nil {
return err
}
return nil
}
func IncrementCountB(addr string) error {
_, err := http.Get(fmt.Sprintf("%s/v1/incrementCountB?addr=%s", srvUrl, addr))
if err != nil {
return err
}
return nil
}
func GetStorageSlotKey(contract string, label string) (*StorageKey, error) {
res, err := http.Get(fmt.Sprintf("%s/v1/getStorageKey?contract=%s&label=%s", srvUrl, contract, label))
if err != nil {
return nil, err
}
defer res.Body.Close()
var key StorageKey
decoder := json.NewDecoder(res.Body)
err = decoder.Decode(&key)
if err != nil {
return nil, err
}
return &key, nil
}

464
test/watch_address_integration_test.go
View File

@ -7,8 +7,10 @@ import (
"strconv"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethclient"
"github.com/ethereum/go-ethereum/rpc"
"github.com/ethereum/go-ethereum/statediff"
sdtypes "github.com/ethereum/go-ethereum/statediff/types"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
@ -32,7 +34,6 @@ var _ = Describe("WatchAddressIntegration", func() {
ctx := context.Background()
var (
txErr error
contractErr error
gethMethod = "statediff_watchAddress"
@ -41,14 +42,6 @@ var _ = Describe("WatchAddressIntegration", func() {
contract1 *integration.ContractDeployed
contract2 *integration.ContractDeployed
contract3 *integration.ContractDeployed
prevBalance1 *big.Int
prevBalance2 *big.Int
prevBalance3 *big.Int
actualBalance1 *big.Int
actualBalance2 *big.Int
actualBalance3 *big.Int
)
BeforeEach(func() {
@ -59,28 +52,46 @@ var _ = Describe("WatchAddressIntegration", func() {
It("WatchAddress test init", func() {
// Deploy three contracts
contract1, contractErr = integration.DeployContract()
contract1, contractErr = integration.DeploySLVContract()
Expect(contractErr).ToNot(HaveOccurred())
contract2, contractErr = integration.DeployContract()
contract2, contractErr = integration.DeploySLVContract()
Expect(contractErr).ToNot(HaveOccurred())
contract3, contractErr = integration.DeployContract()
contract3, contractErr = integration.DeploySLVContract()
Expect(contractErr).ToNot(HaveOccurred())
})
Describe("watched addresses", func() {
var (
txErr error
prevBalance1 *big.Int
prevBalance2 *big.Int
prevBalance3 *big.Int
actualBalance1 *big.Int
actualBalance2 *big.Int
actualBalance3 *big.Int
)
It("gets initial balances", func() {
// Get initial balances for all the contracts
// Contract 1
actualBalance1 = big.NewInt(0)
prevBalance1 = big.NewInt(0)
initBalance1, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract1.Address), nil)
Expect(err).ToNot(HaveOccurred())
Expect(initBalance1.String()).To(Equal(actualBalance1.String()))
// Contract 2
actualBalance2 = big.NewInt(0)
prevBalance2 = big.NewInt(0)
initBalance2, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract2.Address), nil)
Expect(err).ToNot(HaveOccurred())
Expect(initBalance2.String()).To(Equal(actualBalance2.String()))
// Contract 3
actualBalance3 = big.NewInt(0)
prevBalance3 = big.NewInt(0)
initBalance3, err := ipldClient.BalanceAt(ctx, common.HexToAddress(contract3.Address), nil)
@ -91,6 +102,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Context("no contracts being watched", func() {
It("indexes state for all the contracts", func() {
// Send eth to all three contract accounts
// Contract 1
_, txErr = integration.SendEth(contract1.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance1.Add(actualBalance1, big.NewInt(10000000000000000))
@ -100,6 +112,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(balance1AfterTransfer.String()).To(Equal(actualBalance1.String()))
prevBalance1.Set(actualBalance1)
// Contract 2
_, txErr = integration.SendEth(contract2.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance2.Add(actualBalance2, big.NewInt(10000000000000000))
@ -109,6 +122,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(balance2AfterTransfer.String()).To(Equal(actualBalance2.String()))
prevBalance2.Set(actualBalance2)
// Contract 3
_, txErr = integration.SendEth(contract3.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance3.Add(actualBalance3, big.NewInt(10000000000000000))
@ -122,7 +136,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Context("one contract being watched", func() {
It("indexes state only for the watched contract", func() {
operation := "AddAddresses"
operation := statediff.AddAddresses
args := []sdtypes.WatchAddressArg{
{
Address: contract1.Address,
@ -133,6 +147,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(ipldErr).ToNot(HaveOccurred())
// Send eth to all three contract accounts
// Contract 1
_, txErr = integration.SendEth(contract1.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance1.Add(actualBalance1, big.NewInt(10000000000000000))
@ -142,6 +157,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(balance1AfterTransfer.String()).To(Equal(actualBalance1.String()))
prevBalance1.Set(actualBalance1)
// Contract 2
_, txErr = integration.SendEth(contract2.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance2.Add(actualBalance2, big.NewInt(10000000000000000))
@ -150,6 +166,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(err).ToNot(HaveOccurred())
Expect(balance2AfterTransfer.String()).To(Equal(prevBalance2.String()))
// Contract 3
_, txErr = integration.SendEth(contract3.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance3.Add(actualBalance3, big.NewInt(10000000000000000))
@ -162,7 +179,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Context("contract added to a non-empty watch-list", func() {
It("indexes state only for the watched contracts", func() {
operation := "AddAddresses"
operation := statediff.AddAddresses
args := []sdtypes.WatchAddressArg{
{
Address: contract2.Address,
@ -173,6 +190,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(ipldErr).ToNot(HaveOccurred())
// Send eth to all three contract accounts
// Contract 1
_, txErr = integration.SendEth(contract1.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance1.Add(actualBalance1, big.NewInt(10000000000000000))
@ -182,6 +200,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(balance1AfterTransfer.String()).To(Equal(actualBalance1.String()))
prevBalance1.Set(actualBalance1)
// Contract 2
_, txErr = integration.SendEth(contract2.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance2.Add(actualBalance2, big.NewInt(10000000000000000))
@ -191,6 +210,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(balance2AfterTransfer.String()).To(Equal(actualBalance2.String()))
prevBalance2.Set(actualBalance2)
// Contract 3
_, txErr = integration.SendEth(contract3.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance3.Add(actualBalance3, big.NewInt(10000000000000000))
@ -203,7 +223,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Context("contract removed from the watch-list", func() {
It("indexes state only for the watched contract", func() {
operation := "RemoveAddresses"
operation := statediff.RemoveAddresses
args := []sdtypes.WatchAddressArg{
{
Address: contract1.Address,
@ -214,6 +234,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(ipldErr).ToNot(HaveOccurred())
// Send eth to all three contract accounts
// Contract 1
_, txErr = integration.SendEth(contract1.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance1.Add(actualBalance1, big.NewInt(10000000000000000))
@ -222,8 +243,8 @@ var _ = Describe("WatchAddressIntegration", func() {
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))
@ -232,8 +253,8 @@ var _ = Describe("WatchAddressIntegration", func() {
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))
@ -245,7 +266,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Context("set the list of watched addresses", func() {
It("indexes state only for the watched contracts", func() {
operation := "SetAddresses"
operation := statediff.SetAddresses
args := []sdtypes.WatchAddressArg{
{
Address: contract1.Address,
@ -260,6 +281,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(ipldErr).ToNot(HaveOccurred())
// Send eth to all three contract accounts
// Contract 1
_, txErr = integration.SendEth(contract1.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance1.Add(actualBalance1, big.NewInt(10000000000000000))
@ -269,6 +291,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(balance1AfterTransfer.String()).To(Equal(actualBalance1.String()))
prevBalance1.Set(actualBalance1)
// Contract 2
_, txErr = integration.SendEth(contract2.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance2.Add(actualBalance2, big.NewInt(10000000000000000))
@ -277,6 +300,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(err).ToNot(HaveOccurred())
Expect(balance2AfterTransfer.String()).To(Equal(prevBalance2.String()))
// Contract 3
_, txErr = integration.SendEth(contract3.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance3.Add(actualBalance3, big.NewInt(10000000000000000))
@ -290,12 +314,13 @@ var _ = Describe("WatchAddressIntegration", func() {
Context("clear the list of watched addresses", func() {
It("indexes state for all the contracts", func() {
operation := "ClearAddresses"
operation := statediff.ClearAddresses
args := []sdtypes.WatchAddressArg{}
ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
Expect(ipldErr).ToNot(HaveOccurred())
// Send eth to all three contract accounts
// Contract 1
_, txErr = integration.SendEth(contract1.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance1.Add(actualBalance1, big.NewInt(10000000000000000))
@ -305,6 +330,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(balance1AfterTransfer.String()).To(Equal(actualBalance1.String()))
prevBalance1.Set(actualBalance1)
// Contract 2
_, txErr = integration.SendEth(contract2.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance2.Add(actualBalance2, big.NewInt(10000000000000000))
@ -314,6 +340,7 @@ var _ = Describe("WatchAddressIntegration", func() {
Expect(balance2AfterTransfer.String()).To(Equal(actualBalance2.String()))
prevBalance2.Set(actualBalance2)
// Contract 3
_, txErr = integration.SendEth(contract3.Address, "0.01")
Expect(txErr).ToNot(HaveOccurred())
actualBalance3.Add(actualBalance3, big.NewInt(10000000000000000))
@ -324,6 +351,403 @@ var _ = Describe("WatchAddressIntegration", func() {
prevBalance3.Set(actualBalance3)
})
})
})
Describe("watched storage slots", func() {
storageSlotAKey, err := integration.GetStorageSlotKey("SLVToken", "countA")
Expect(err).ToNot(HaveOccurred())
countAIndex := storageSlotAKey.Key
storageSlotBKey, err := integration.GetStorageSlotKey("SLVToken", "countB")
Expect(err).ToNot(HaveOccurred())
countBIndex := storageSlotBKey.Key
var (
incErr error
countAStorageHash = crypto.Keccak256Hash(common.HexToHash(countAIndex).Bytes())
countBStorageHash = crypto.Keccak256Hash(common.HexToHash(countBIndex).Bytes())
prevCountA1 *big.Int
prevCountB1 *big.Int
prevCountA2 *big.Int
prevCountB2 *big.Int
actualCountA1 *big.Int
actualCountB1 *big.Int
actualCountA2 *big.Int
actualCountB2 *big.Int
)
It("gets initial storage values", func() {
// Get initial storage values for the contracts
// Contract 1, countA
actualCountA1 = big.NewInt(0)
prevCountA1 = 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()))
// Contract 1, countB
actualCountB1 = big.NewInt(0)
prevCountB1 = big.NewInt(0)
ipldCountB1Storage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
ipldCountB1 := new(big.Int).SetBytes(ipldCountB1Storage)
Expect(ipldCountB1.String()).To(Equal(actualCountB1.String()))
// Contract 2, countA
actualCountA2 = big.NewInt(0)
prevCountA2 = 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()))
// Contract 2, countB
actualCountB2 = big.NewInt(0)
prevCountB2 = big.NewInt(0)
ipldCountB2Storage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
ipldCountB2 := new(big.Int).SetBytes(ipldCountB2Storage)
Expect(ipldCountB2.String()).To(Equal(actualCountB2.String()))
})
Context("no addresses or storage slots being watched", func() {
It("indexes state for all the slots", func() {
// Increment counts
// Contract 1, countA
incErr = integration.IncrementCountA(contract1.Address)
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 1, countB
incErr = integration.IncrementCountB(contract1.Address)
Expect(incErr).ToNot(HaveOccurred())
actualCountB1.Add(actualCountB1, big.NewInt(1))
countB1AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
countB1AfterIncrement := new(big.Int).SetBytes(countB1AfterIncrementStorage)
Expect(countB1AfterIncrement.String()).To(Equal(actualCountB1.String()))
prevCountB1.Set(actualCountB1)
// Contract 2, countA
incErr = integration.IncrementCountA(contract2.Address)
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 2, countB
incErr = integration.IncrementCountB(contract2.Address)
Expect(incErr).ToNot(HaveOccurred())
actualCountB2.Add(actualCountB2, big.NewInt(1))
countB2AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
countB2AfterIncrement := new(big.Int).SetBytes(countB2AfterIncrementStorage)
Expect(countB2AfterIncrement.String()).To(Equal(actualCountB2.String()))
prevCountB2.Set(actualCountB2)
})
})
Context("one storage slot being watched", func() {
It("indexes only for the watched storage slot", func() {
operation := statediff.AddStorageSlots
args := []sdtypes.WatchAddressArg{
{
Address: countAStorageHash.Hex(),
CreatedAt: uint64(contract1.BlockNumber),
},
}
ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
Expect(ipldErr).ToNot(HaveOccurred())
// Increment counts
// Contract 1, countA
incErr = integration.IncrementCountA(contract1.Address)
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 1, countB
incErr = integration.IncrementCountB(contract1.Address)
Expect(incErr).ToNot(HaveOccurred())
actualCountB1.Add(actualCountB1, big.NewInt(1))
countB1AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
countB1AfterIncrement := new(big.Int).SetBytes(countB1AfterIncrementStorage)
Expect(countB1AfterIncrement.String()).To(Equal(prevCountB1.String()))
// Contract 2, countA
incErr = integration.IncrementCountA(contract2.Address)
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 2, countB
incErr = integration.IncrementCountB(contract2.Address)
Expect(incErr).ToNot(HaveOccurred())
actualCountB2.Add(actualCountB2, big.NewInt(1))
countB2AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
countB2AfterIncrement := new(big.Int).SetBytes(countB2AfterIncrementStorage)
Expect(countB2AfterIncrement.String()).To(Equal(prevCountB2.String()))
})
})
Context("set the list of watched storage slots", func() {
It("indexes state only for the watched storage slots", func() {
operation := statediff.SetStorageSlots
args := []sdtypes.WatchAddressArg{
{
Address: countAStorageHash.Hex(),
CreatedAt: uint64(contract1.BlockNumber),
},
{
Address: countBStorageHash.Hex(),
CreatedAt: uint64(contract2.BlockNumber),
},
}
ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
Expect(ipldErr).ToNot(HaveOccurred())
// Increment counts
// Contract 1, countA
incErr = integration.IncrementCountA(contract1.Address)
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 1, countB
incErr = integration.IncrementCountB(contract1.Address)
Expect(incErr).ToNot(HaveOccurred())
actualCountB1.Add(actualCountB1, big.NewInt(1))
countB1AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
countB1AfterIncrement := new(big.Int).SetBytes(countB1AfterIncrementStorage)
Expect(countB1AfterIncrement.String()).To(Equal(actualCountB1.String()))
prevCountB1.Set(actualCountB1)
// Contract 2, countA
incErr = integration.IncrementCountA(contract2.Address)
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 2, countB
incErr = integration.IncrementCountB(contract2.Address)
Expect(incErr).ToNot(HaveOccurred())
actualCountB2.Add(actualCountB2, big.NewInt(1))
countB2AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
countB2AfterIncrement := new(big.Int).SetBytes(countB2AfterIncrementStorage)
Expect(countB2AfterIncrement.String()).To(Equal(actualCountB2.String()))
prevCountB2.Set(actualCountB2)
})
})
Context("storage slot removed from the watch-list", func() {
It("indexes state only for the watched storage slots", func() {
operation := statediff.RemoveStorageSlots
args := []sdtypes.WatchAddressArg{
{
Address: countAStorageHash.Hex(),
CreatedAt: uint64(contract1.BlockNumber),
},
}
ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
Expect(ipldErr).ToNot(HaveOccurred())
// Increment counts
// Contract 1, countA
incErr = integration.IncrementCountA(contract1.Address)
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 1, countB
incErr = integration.IncrementCountB(contract1.Address)
Expect(incErr).ToNot(HaveOccurred())
actualCountB1.Add(actualCountB1, big.NewInt(1))
countB1AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
countB1AfterIncrement := new(big.Int).SetBytes(countB1AfterIncrementStorage)
Expect(countB1AfterIncrement.String()).To(Equal(actualCountB1.String()))
prevCountB1.Set(actualCountB1)
// Contract 2, countA
incErr = integration.IncrementCountA(contract2.Address)
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 2, countB
incErr = integration.IncrementCountB(contract2.Address)
Expect(incErr).ToNot(HaveOccurred())
actualCountB2.Add(actualCountB2, big.NewInt(1))
countB2AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
countB2AfterIncrement := new(big.Int).SetBytes(countB2AfterIncrementStorage)
Expect(countB2AfterIncrement.String()).To(Equal(actualCountB2.String()))
prevCountB2.Set(actualCountB2)
})
})
Context("one contract and one storage slot being watched", func() {
It("indexes state only for the watched storage slots of watched contracts", func() {
operation := statediff.SetAddresses
args := []sdtypes.WatchAddressArg{
{
Address: contract1.Address,
CreatedAt: uint64(contract1.BlockNumber),
},
}
ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
Expect(ipldErr).ToNot(HaveOccurred())
// Increment counts
// Contract 1, countA
incErr = integration.IncrementCountA(contract1.Address)
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 1, countB
incErr = integration.IncrementCountB(contract1.Address)
Expect(incErr).ToNot(HaveOccurred())
actualCountB1.Add(actualCountB1, big.NewInt(1))
countB1AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
countB1AfterIncrement := new(big.Int).SetBytes(countB1AfterIncrementStorage)
Expect(countB1AfterIncrement.String()).To(Equal(actualCountB1.String()))
prevCountB1.Set(actualCountB1)
// Contract 2, countA
incErr = integration.IncrementCountA(contract2.Address)
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 2, countB
incErr = integration.IncrementCountB(contract2.Address)
Expect(incErr).ToNot(HaveOccurred())
actualCountB2.Add(actualCountB2, big.NewInt(1))
countB2AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
countB2AfterIncrement := new(big.Int).SetBytes(countB2AfterIncrementStorage)
Expect(countB2AfterIncrement.String()).To(Equal(prevCountB2.String()))
})
})
Context("clear the list of watched storage slots", func() {
It("indexes state for all the storage slots of watched contracts", func() {
operation := statediff.ClearStorageSlots
args := []sdtypes.WatchAddressArg{}
ipldErr := ipldRPCClient.Call(nil, ipldMethod, operation, args)
Expect(ipldErr).ToNot(HaveOccurred())
// Increment counts
// Contract 1, countA
incErr = integration.IncrementCountA(contract1.Address)
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 1, countB
incErr = integration.IncrementCountB(contract1.Address)
Expect(incErr).ToNot(HaveOccurred())
actualCountB1.Add(actualCountB1, big.NewInt(1))
countB1AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract1.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
countB1AfterIncrement := new(big.Int).SetBytes(countB1AfterIncrementStorage)
Expect(countB1AfterIncrement.String()).To(Equal(actualCountB1.String()))
prevCountB1.Set(actualCountB1)
// Contract 2, countA
incErr = integration.IncrementCountA(contract2.Address)
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 2, countB
incErr = integration.IncrementCountB(contract2.Address)
Expect(incErr).ToNot(HaveOccurred())
actualCountB2.Add(actualCountB2, big.NewInt(1))
countB2AfterIncrementStorage, err := ipldClient.StorageAt(ctx, common.HexToAddress(contract2.Address), common.HexToHash(countBIndex), nil)
Expect(err).ToNot(HaveOccurred())
countB2AfterIncrement := new(big.Int).SetBytes(countB2AfterIncrementStorage)
Expect(countB2AfterIncrement.String()).To(Equal(prevCountB2.String()))
})
})
})
Context("with invalid args", func() {
It("returns an error on invalid operation arg", func() {
@ -340,7 +764,7 @@ var _ = Describe("WatchAddressIntegration", func() {
})
It("returns an error on args of invalid type", func() {
operation := "AddAddresses"
operation := statediff.AddAddresses
args := []string{"WrongArg"}
gethErr := gethRPCClient.Call(nil, gethMethod, operation, args)