From 66f8b736baad88daa6dddc7dc7e559a661a623f4 Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Fri, 10 Jan 2025 18:27:40 -0300 Subject: [PATCH 01/28] Add rewards coordinarot ro ContractAddresses --- testutils/anvil.go | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/testutils/anvil.go b/testutils/anvil.go index bb3a8c41..cdaef69f 100644 --- a/testutils/anvil.go +++ b/testutils/anvil.go @@ -65,6 +65,7 @@ type ContractAddresses struct { OperatorStateRetriever common.Address DelegationManager common.Address Erc20MockStrategy common.Address + RewardsCoordinator common.Address } func GetContractAddressesFromContractRegistry(ethHttpUrl string) (mockAvsContracts ContractAddresses) { @@ -121,12 +122,20 @@ func GetContractAddressesFromContractRegistry(ethHttpUrl string) (mockAvsContrac if erc20MockStrategyAddr == (common.Address{}) { panic("erc20MockStrategyAddr is empty") } + rewardsCoordinatorAddr, err := contractsRegistry.Contracts(&bind.CallOpts{}, "rewardsCoordinator") + if err != nil { + panic(err) + } + if rewardsCoordinatorAddr == (common.Address{}) { + panic("rewardsCoordinatorAddr is empty") + } mockAvsContracts = ContractAddresses{ ServiceManager: mockAvsServiceManagerAddr, RegistryCoordinator: mockAvsRegistryCoordinatorAddr, OperatorStateRetriever: mockAvsOperatorStateRetrieverAddr, DelegationManager: delegationManagerAddr, Erc20MockStrategy: erc20MockStrategyAddr, + RewardsCoordinator: rewardsCoordinatorAddr, } return mockAvsContracts } From cc8abb8cbc0bd122e4f5a7083e5781f7d97f4815 Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Fri, 10 Jan 2025 18:28:44 -0300 Subject: [PATCH 02/28] Add some test cases of get functions --- chainio/clients/elcontracts/reader_test.go | 111 +++++++++++++++++++++ 1 file changed, 111 insertions(+) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index d3d1fdb0..855b2ed8 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -3,15 +3,25 @@ package elcontracts_test import ( "context" "math/big" + "os" "testing" + "github.com/Layr-Labs/eigensdk-go/chainio/clients/elcontracts" + "github.com/Layr-Labs/eigensdk-go/chainio/clients/wallet" + "github.com/Layr-Labs/eigensdk-go/chainio/txmgr" erc20 "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IERC20" + "github.com/Layr-Labs/eigensdk-go/logging" + "github.com/Layr-Labs/eigensdk-go/signerv2" "github.com/Layr-Labs/eigensdk-go/testutils" "github.com/Layr-Labs/eigensdk-go/testutils/testclients" "github.com/Layr-Labs/eigensdk-go/types" + "github.com/Layr-Labs/eigensdk-go/utils" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestChainReader(t *testing.T) { @@ -111,4 +121,105 @@ func TestChainReader(t *testing.T) { assert.NoError(t, err) assert.NotEmpty(t, digest) }) + + t.Run("staker shares test (GetStakerShares)", func(t *testing.T) { + strategies, shares, err := clients.ElChainReader.GetStakerShares( + ctx, + common.HexToAddress(operator.Address), + ) + assert.NotZero(t, len(strategies)) // Strategies has at least one element + assert.NotZero(t, len(shares)) // Shares has at least one element + assert.Equal(t, len(strategies), len(shares)) // Strategies has the same ammount of elements as + assert.NoError(t, err) + }) + + t.Run("get delegated operator", func(t *testing.T) { + // The delegated operator of an operator is the operator itself + val := big.NewInt(0) + address, err := clients.ElChainReader.GetDelegatedOperator( + ctx, + common.HexToAddress(operator.Address), + val, + ) + + assert.NoError(t, err) + assert.Equal(t, address.String(), operator.Address) + }) + + t.Run("get current claimable distribution root without submitted roots is zero", func(t *testing.T) { + contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint) + + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + config := elcontracts.Config{ + DelegationManagerAddress: contractAddrs.DelegationManager, + RewardsCoordinatorAddress: rewardsCoordinatorAddr, + } + + chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + require.NoError(t, err) + + root, err := chainReader.GetCurrentClaimableDistributionRoot( + ctx, + ) + + assert.NoError(t, err) + assert.Zero(t, root) + }) + +} + +// Creates a testing ChainWriter from an httpEndpoint, private key and config. +// This is needed because the existing testclients.BuildTestClients returns a +// ChainReader with a null rewardsCoordinator, which is required for some of the tests. +func NewTestChainReaderFromConfig( + httpEndpoint string, + config elcontracts.Config, +) (*elcontracts.ChainReader, error) { + testConfig := testutils.GetDefaultTestConfig() + logger := logging.NewTextSLogger(os.Stdout, &logging.SLoggerOptions{Level: testConfig.LogLevel}) + ethHttpClient, err := ethclient.Dial(httpEndpoint) + if err != nil { + return nil, utils.WrapError("Failed to create eth client", err) + } + + testReader, err := elcontracts.NewReaderFromConfig( + config, + ethHttpClient, + logger, + ) + if err != nil { + return nil, utils.WrapError("Failed to create chain reader from config", err) + } + return testReader, nil +} + +func NewTestTxManager(httpEndpoint string, privateKeyHex string) (*txmgr.SimpleTxManager, error) { + testConfig := testutils.GetDefaultTestConfig() + ethHttpClient, err := ethclient.Dial(httpEndpoint) + if err != nil { + return nil, utils.WrapError("Failed to create eth client", err) + } + + chainid, err := ethHttpClient.ChainID(context.Background()) + if err != nil { + return nil, utils.WrapError("Failed to retrieve chain id", err) + } + privateKey, err := crypto.HexToECDSA(privateKeyHex) + if err != nil { + return nil, utils.WrapError("Failed to convert hex string to private key", err) + } + signerV2, addr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: privateKey}, chainid) + if err != nil { + return nil, utils.WrapError("Failed to create signer", err) + } + + logger := logging.NewTextSLogger(os.Stdout, &logging.SLoggerOptions{Level: testConfig.LogLevel}) + + pkWallet, err := wallet.NewPrivateKeyWallet(ethHttpClient, signerV2, addr, logger) + if err != nil { + return nil, utils.WrapError("Failed to create wallet", err) + } + + txManager := txmgr.NewSimpleTxManager(pkWallet, ethHttpClient, logger, addr) + return txManager, nil } From 08ef32bf2978bf4f47ebd21c2f0d5e09d841586c Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Fri, 10 Jan 2025 18:29:14 -0300 Subject: [PATCH 03/28] Add GetCurrentClaimableDistributionRoot test --- chainio/clients/elcontracts/reader_test.go | 52 ++++++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index 855b2ed8..f68d3152 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -10,6 +10,7 @@ import ( "github.com/Layr-Labs/eigensdk-go/chainio/clients/wallet" "github.com/Layr-Labs/eigensdk-go/chainio/txmgr" erc20 "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IERC20" + rewardscoordinator "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IRewardsCoordinator" "github.com/Layr-Labs/eigensdk-go/logging" "github.com/Layr-Labs/eigensdk-go/signerv2" "github.com/Layr-Labs/eigensdk-go/testutils" @@ -166,6 +167,57 @@ func TestChainReader(t *testing.T) { assert.Zero(t, root) }) + t.Run("get current claimable distribution root with submitted roots is not zero", func(t *testing.T) { + root := [32]byte{ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + } + + contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint) + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + config := elcontracts.Config{ + DelegationManagerAddress: contractAddrs.DelegationManager, + RewardsCoordinatorAddress: rewardsCoordinatorAddr, + } + + chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + require.NoError(t, err) + + // Fetch the current timestamp to increase it + currRewardsCalculationEndTimestamp, _ := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) + + ethClient, _ := ethclient.Dial(anvilHttpEndpoint) + rewardsCoordinator, _ := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) + + txManager, _ := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") + noSendTxOpts, _ := txManager.GetNoSendTxOpts() + + tx, _ := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266")) + print("", tx) + + waitForReceipt := true + _, erri := txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, erri) + + _, erre := rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) + require.NoError(t, erre) + + distr_root, err := chainReader.GetCurrentClaimableDistributionRoot( + ctx, + ) + + assert.Zero(t, distr_root) + + distr_root, _ = chainReader.GetCurrentClaimableDistributionRoot( + ctx, + ) + assert.NoError(t, err) + assert.Zero(t, distr_root) + // assert.Equal(t, distr_root, root) + // This assert fails + }) } // Creates a testing ChainWriter from an httpEndpoint, private key and config. From ae43c9e82256db500b555528daf8a145d28907ae Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Fri, 10 Jan 2025 18:40:22 -0300 Subject: [PATCH 04/28] Improve error handling --- chainio/clients/elcontracts/reader_test.go | 27 ++++++++++++++-------- 1 file changed, 17 insertions(+), 10 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index f68d3152..a0f1d214 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -188,21 +188,28 @@ func TestChainReader(t *testing.T) { // Fetch the current timestamp to increase it currRewardsCalculationEndTimestamp, _ := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) - ethClient, _ := ethclient.Dial(anvilHttpEndpoint) - rewardsCoordinator, _ := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) + ethClient, err := ethclient.Dial(anvilHttpEndpoint) + require.NoError(t, err) + rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) + require.NoError(t, err) - txManager, _ := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") - noSendTxOpts, _ := txManager.GetNoSendTxOpts() + txManager, err := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") + require.NoError(t, err) + noSendTxOpts, err := txManager.GetNoSendTxOpts() + require.NoError(t, err) - tx, _ := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266")) - print("", tx) + tx, err := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266")) + require.NoError(t, err) waitForReceipt := true - _, erri := txManager.Send(context.Background(), tx, waitForReceipt) - require.NoError(t, erri) + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, err) + + _, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) + require.NoError(t, err) - _, erre := rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) - require.NoError(t, erre) + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, err) distr_root, err := chainReader.GetCurrentClaimableDistributionRoot( ctx, From 03cc6e0e80d3f91e31ecc6c4a62b7bf4c29b0851 Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Mon, 13 Jan 2025 11:43:01 -0300 Subject: [PATCH 05/28] Fix GetCurrentClaimableDistributionRoot test --- chainio/clients/elcontracts/reader_test.go | 131 ++++++++++++++++++--- 1 file changed, 114 insertions(+), 17 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index a0f1d214..394c81d1 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -12,6 +12,7 @@ import ( erc20 "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IERC20" rewardscoordinator "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IRewardsCoordinator" "github.com/Layr-Labs/eigensdk-go/logging" + "github.com/Layr-Labs/eigensdk-go/metrics" "github.com/Layr-Labs/eigensdk-go/signerv2" "github.com/Layr-Labs/eigensdk-go/testutils" "github.com/Layr-Labs/eigensdk-go/testutils/testclients" @@ -19,8 +20,10 @@ import ( "github.com/Layr-Labs/eigensdk-go/utils" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" + gethtypes "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethclient" + "github.com/prometheus/client_golang/prometheus" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -167,7 +170,8 @@ func TestChainReader(t *testing.T) { assert.Zero(t, root) }) - t.Run("get current claimable distribution root with submitted roots is not zero", func(t *testing.T) { + t.Run("get current claimable distribution root with and without submitted roots", func(t *testing.T) { + // Verifies GetCurrentClaimableDistributionRoot returns 0 if no root and the root if there's one root := [32]byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, @@ -175,7 +179,6 @@ func TestChainReader(t *testing.T) { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, } - contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint) rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator config := elcontracts.Config{ DelegationManagerAddress: contractAddrs.DelegationManager, @@ -185,48 +188,98 @@ func TestChainReader(t *testing.T) { chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) require.NoError(t, err) - // Fetch the current timestamp to increase it - currRewardsCalculationEndTimestamp, _ := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) - + // Create and configure rewards coordinator ethClient, err := ethclient.Dial(anvilHttpEndpoint) require.NoError(t, err) rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) require.NoError(t, err) + // Set delay to zero to inmediatly operate with coordinator + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", uint32(0)) + require.NoError(t, err) + require.Equal(t, receipt.Status, uint64(1)) + + // Create txManager to send transactions to the Ethereum node txManager, err := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") require.NoError(t, err) noSendTxOpts, err := txManager.GetNoSendTxOpts() require.NoError(t, err) - tx, err := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266")) - require.NoError(t, err) - - waitForReceipt := true - _, err = txManager.Send(context.Background(), tx, waitForReceipt) - require.NoError(t, err) + rewardsUpdater := common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266") - _, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) + // Change the rewards updater to be able to submit the new root + tx, err := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) require.NoError(t, err) + waitForReceipt := true _, err = txManager.Send(context.Background(), tx, waitForReceipt) require.NoError(t, err) + // Check that if there is no root submitted the result is zero distr_root, err := chainReader.GetCurrentClaimableDistributionRoot( ctx, ) + assert.NoError(t, err) + assert.Zero(t, distr_root.Root) - assert.Zero(t, distr_root) + currRewardsCalculationEndTimestamp, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) + require.NoError(t, err) + + tx, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) + require.NoError(t, err) - distr_root, _ = chainReader.GetCurrentClaimableDistributionRoot( + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, err) + + // Check that if there is a root submitted the result is that root + distr_root, err = chainReader.GetCurrentClaimableDistributionRoot( ctx, ) assert.NoError(t, err) - assert.Zero(t, distr_root) - // assert.Equal(t, distr_root, root) - // This assert fails + assert.Equal(t, distr_root.Root, root) }) } +// The functions below will be replaced for those placed in testutils/testclients/testclients.go +func setTestRewardsCoordinatorActivationDelay( + httpEndpoint string, + privateKeyHex string, + activationDelay uint32, +) (*gethtypes.Receipt, error) { + contractAddrs := testutils.GetContractAddressesFromContractRegistry(httpEndpoint) + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + ethHttpClient, err := ethclient.Dial(httpEndpoint) + if err != nil { + return nil, utils.WrapError("Failed to create eth client", err) + } + + rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethHttpClient) + if err != nil { + return nil, utils.WrapError("Failed to create rewards coordinator", err) + } + + txManager, err := NewTestTxManager(httpEndpoint, privateKeyHex) + if err != nil { + return nil, utils.WrapError("Failed to create tx manager", err) + } + + noSendOpts, err := txManager.GetNoSendTxOpts() + if err != nil { + return nil, utils.WrapError("Failed to get NoSend tx opts", err) + } + + tx, err := rewardsCoordinator.SetActivationDelay(noSendOpts, activationDelay) + if err != nil { + return nil, utils.WrapError("Failed to create SetActivationDelay tx", err) + } + + receipt, err := txManager.Send(context.Background(), tx, true) + if err != nil { + return nil, utils.WrapError("Failed to send SetActivationDelay tx", err) + } + return receipt, err +} + // Creates a testing ChainWriter from an httpEndpoint, private key and config. // This is needed because the existing testclients.BuildTestClients returns a // ChainReader with a null rewardsCoordinator, which is required for some of the tests. @@ -282,3 +335,47 @@ func NewTestTxManager(httpEndpoint string, privateKeyHex string) (*txmgr.SimpleT txManager := txmgr.NewSimpleTxManager(pkWallet, ethHttpClient, logger, addr) return txManager, nil } + +func NewTestChainWriterFromConfig( + httpEndpoint string, + privateKeyHex string, + config elcontracts.Config, +) (*elcontracts.ChainWriter, error) { + privateKey, err := crypto.HexToECDSA(privateKeyHex) + if err != nil { + return nil, utils.WrapError("Failed convert hex string to ecdsa private key", err) + } + testConfig := testutils.GetDefaultTestConfig() + logger := logging.NewTextSLogger(os.Stdout, &logging.SLoggerOptions{Level: testConfig.LogLevel}) + ethHttpClient, err := ethclient.Dial(httpEndpoint) + if err != nil { + return nil, utils.WrapError("Failed to create eth client", err) + } + chainid, err := ethHttpClient.ChainID(context.Background()) + if err != nil { + return nil, utils.WrapError("Failed to get chain id", err) + } + promReg := prometheus.NewRegistry() + eigenMetrics := metrics.NewEigenMetrics("", "", promReg, logger) + signerV2, addr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: privateKey}, chainid) + if err != nil { + return nil, utils.WrapError("Failed to create the signer from the given config", err) + } + + pkWallet, err := wallet.NewPrivateKeyWallet(ethHttpClient, signerV2, addr, logger) + if err != nil { + return nil, utils.WrapError("Failed to create wallet", err) + } + txManager := txmgr.NewSimpleTxManager(pkWallet, ethHttpClient, logger, addr) + testWriter, err := elcontracts.NewWriterFromConfig( + config, + ethHttpClient, + logger, + eigenMetrics, + txManager, + ) + if err != nil { + return nil, err + } + return testWriter, nil +} From 6fd4ecf4f0b8dc975c901dcda5eeef4a6ec6331a Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Mon, 13 Jan 2025 14:38:19 -0300 Subject: [PATCH 06/28] Add GetRootIndexFromHash test with 0, 1 and 2 case --- chainio/clients/elcontracts/reader_test.go | 95 ++++++++++++++++++++++ 1 file changed, 95 insertions(+) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index 394c81d1..2a2bee5a 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -238,6 +238,101 @@ func TestChainReader(t *testing.T) { assert.NoError(t, err) assert.Equal(t, distr_root.Root, root) }) + + t.Run("get root index from root hash with and without submitted roots", func(t *testing.T) { + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + config := elcontracts.Config{ + DelegationManagerAddress: contractAddrs.DelegationManager, + RewardsCoordinatorAddress: rewardsCoordinatorAddr, + } + + chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + require.NoError(t, err) + + // Create and configure rewards coordinator + ethClient, err := ethclient.Dial(anvilHttpEndpoint) + require.NoError(t, err) + rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) + require.NoError(t, err) + + // Set delay to zero to inmediatly operate with coordinator + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", uint32(0)) + require.NoError(t, err) + require.Equal(t, receipt.Status, uint64(1)) + + // Create txManager to send transactions to the Ethereum node + txManager, err := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") + require.NoError(t, err) + noSendTxOpts, err := txManager.GetNoSendTxOpts() + require.NoError(t, err) + + rewardsUpdater := common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266") + + // Change the rewards updater to be able to submit the new root + tx, err := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) + require.NoError(t, err) + + waitForReceipt := true + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, err) + + root := [32]byte{ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + } + + // Check that if there is no root submitted the result is an InvalidRoot error + root_index, err := chainReader.GetRootIndexFromHash( + ctx, + root, + ) + assert.Error(t, err) + assert.Equal(t, err.Error(), "execution reverted: custom error 0x504570e3") + assert.Zero(t, root_index) + + currRewardsCalculationEndTimestamp, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) + require.NoError(t, err) + + tx, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) + require.NoError(t, err) + + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, err) + + root2 := [32]byte{ + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + } + + currRewardsCalculationEndTimestamp2, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) + require.NoError(t, err) + + tx, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root2, currRewardsCalculationEndTimestamp2+1) + require.NoError(t, err) + + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, err) + + // Check that the first root inserted is the first indexed (zero) + root_index, err = chainReader.GetRootIndexFromHash( + ctx, + root, + ) + assert.NoError(t, err) + assert.Equal(t, root_index, uint32(0)) + + // Check that the second root inserted is the second indexed (zero) + root_index, err = chainReader.GetRootIndexFromHash( + ctx, + root2, + ) + assert.NoError(t, err) + assert.Equal(t, root_index, uint32(1)) + }) } // The functions below will be replaced for those placed in testutils/testclients/testclients.go From eeadea9331c3baa7755eefdb502e546b770bdb7f Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Mon, 13 Jan 2025 17:39:48 -0300 Subject: [PATCH 07/28] Add simple case of GetCumulativeClaimed --- chainio/clients/elcontracts/reader_test.go | 57 ++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index 2a2bee5a..db1e9a05 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -333,6 +333,63 @@ func TestChainReader(t *testing.T) { assert.NoError(t, err) assert.Equal(t, root_index, uint32(1)) }) + + t.Run("get cumulative claimed rewards", func(t *testing.T) { + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + config := elcontracts.Config{ + DelegationManagerAddress: contractAddrs.DelegationManager, + RewardsCoordinatorAddress: rewardsCoordinatorAddr, + } + + //chainWriter, err := NewTestChainWriterFromConfig(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", config) + //require.NoError(t, err) + chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + require.NoError(t, err) + + // Create and configure rewards coordinator + ethClient, err := ethclient.Dial(anvilHttpEndpoint) + require.NoError(t, err) + rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) + require.NoError(t, err) + + // Set delay to zero to inmediatly operate with coordinator + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", uint32(0)) + require.NoError(t, err) + require.Equal(t, receipt.Status, uint64(1)) + + // Create txManager to send transactions to the Ethereum node + txManager, err := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") + require.NoError(t, err) + noSendTxOpts, err := txManager.GetNoSendTxOpts() + require.NoError(t, err) + + rewardsUpdater := common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266") + + // Change the rewards updater to be able to submit the new root + tx, err := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) + require.NoError(t, err) + + waitForReceipt := true + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, err) + + strategyAddr := contractAddrs.Erc20MockStrategy + strategy, contractUnderlyingToken, underlyingTokenAddr, err := clients.ElChainReader.GetStrategyAndUnderlyingERC20Token( + ctx, + strategyAddr, + ) + assert.NoError(t, err) + assert.NotNil(t, strategy) + assert.NotEqual(t, common.Address{}, underlyingTokenAddr) + assert.NotNil(t, contractUnderlyingToken) + + claimed, err := chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) + assert.True(t, claimed.Cmp(big.NewInt(0)) == 0) + assert.NoError(t, err) + + // This tests that without claims result is zero, should add claims and test that the cumulative increases + }) + } // The functions below will be replaced for those placed in testutils/testclients/testclients.go From 7f621efa9c8637fd348c48d94034d39a106d9d17 Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Mon, 13 Jan 2025 18:25:04 -0300 Subject: [PATCH 08/28] Improve GetCumulativeClaimed test --- chainio/clients/elcontracts/reader_test.go | 204 ++++++++++++++++++--- 1 file changed, 176 insertions(+), 28 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index db1e9a05..fd6941c0 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -11,6 +11,8 @@ import ( "github.com/Layr-Labs/eigensdk-go/chainio/txmgr" erc20 "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IERC20" rewardscoordinator "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IRewardsCoordinator" + strategy "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IStrategy" + mockerc20 "github.com/Layr-Labs/eigensdk-go/contracts/bindings/MockERC20" "github.com/Layr-Labs/eigensdk-go/logging" "github.com/Layr-Labs/eigensdk-go/metrics" "github.com/Layr-Labs/eigensdk-go/signerv2" @@ -340,38 +342,20 @@ func TestChainReader(t *testing.T) { DelegationManagerAddress: contractAddrs.DelegationManager, RewardsCoordinatorAddress: rewardsCoordinatorAddr, } + privateKeyHex := ANVIL_FIRST_PRIVATE_KEY - //chainWriter, err := NewTestChainWriterFromConfig(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", config) - //require.NoError(t, err) - chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) - require.NoError(t, err) - - // Create and configure rewards coordinator - ethClient, err := ethclient.Dial(anvilHttpEndpoint) - require.NoError(t, err) - rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) + // Create ChainWriter + chainWriter, err := NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) require.NoError(t, err) - // Set delay to zero to inmediatly operate with coordinator - receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", uint32(0)) - require.NoError(t, err) - require.Equal(t, receipt.Status, uint64(1)) - - // Create txManager to send transactions to the Ethereum node - txManager, err := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") - require.NoError(t, err) - noSendTxOpts, err := txManager.GetNoSendTxOpts() - require.NoError(t, err) - - rewardsUpdater := common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266") - - // Change the rewards updater to be able to submit the new root - tx, err := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) + chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) require.NoError(t, err) - waitForReceipt := true - _, err = txManager.Send(context.Background(), tx, waitForReceipt) + activationDelay := uint32(0) + // Set activation delay to zero so that the earnings can be claimed right after submitting the root + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, privateKeyHex, activationDelay) require.NoError(t, err) + require.True(t, receipt.Status == uint64(1)) strategyAddr := contractAddrs.Erc20MockStrategy strategy, contractUnderlyingToken, underlyingTokenAddr, err := clients.ElChainReader.GetStrategyAndUnderlyingERC20Token( @@ -383,13 +367,24 @@ func TestChainReader(t *testing.T) { assert.NotEqual(t, common.Address{}, underlyingTokenAddr) assert.NotNil(t, contractUnderlyingToken) + // This tests that without claims result is zero claimed, err := chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) assert.True(t, claimed.Cmp(big.NewInt(0)) == 0) assert.NoError(t, err) - // This tests that without claims result is zero, should add claims and test that the cumulative increases - }) + cumulativeEarnings := int64(45) + claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) + require.NoError(t, err) + + earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") + receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) + require.NoError(t, err) + require.True(t, receipt.Status == uint64(1)) + claimed, err = chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) + assert.Equal(t, claimed, big.NewInt(cumulativeEarnings)) + assert.NoError(t, err) + }) } // The functions below will be replaced for those placed in testutils/testclients/testclients.go @@ -531,3 +526,156 @@ func NewTestChainWriterFromConfig( } return testWriter, nil } + +const ANVIL_FIRST_ADDRESS = "f39Fd6e51aad88F6F4ce6aB8827279cffFb92266" +const ANVIL_FIRST_PRIVATE_KEY = "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" + +// Returns a (test) claim for the given cumulativeEarnings, whose earner is +// the account given by the testutils.ANVIL_FIRST_ADDRESS address. +func newTestClaim( + chainReader *elcontracts.ChainReader, + httpEndpoint string, + cumulativeEarnings int64, + privateKeyHex string, +) (*rewardscoordinator.IRewardsCoordinatorTypesRewardsMerkleClaim, error) { + contractAddrs := testutils.GetContractAddressesFromContractRegistry(httpEndpoint) + mockStrategyAddr := contractAddrs.Erc20MockStrategy + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + waitForReceipt := true + + ethClient, err := ethclient.Dial(httpEndpoint) + if err != nil { + return nil, utils.WrapError("Failed to create eth client", err) + } + + txManager, err := NewTestTxManager(httpEndpoint, privateKeyHex) + if err != nil { + return nil, utils.WrapError("Failed to create tx manager", err) + } + + contractStrategy, err := strategy.NewContractIStrategy(mockStrategyAddr, ethClient) + if err != nil { + return nil, utils.WrapError("Failed to fetch strategy contract", err) + } + + tokenAddr, err := contractStrategy.UnderlyingToken(&bind.CallOpts{Context: context.Background()}) + if err != nil { + return nil, utils.WrapError("Failed to fetch token address", err) + } + + token, err := mockerc20.NewContractMockERC20(tokenAddr, ethClient) + + if err != nil { + return nil, utils.WrapError("Failed to create token contract", err) + } + + noSendTxOpts, err := txManager.GetNoSendTxOpts() + if err != nil { + return nil, utils.WrapError("Failed to get NoSend tx opts", err) + } + + // Mint tokens for the RewardsCoordinator + tx, err := token.Mint(noSendTxOpts, rewardsCoordinatorAddr, big.NewInt(cumulativeEarnings)) + if err != nil { + return nil, utils.WrapError("Failed to create Mint tx", err) + } + + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + if err != nil { + return nil, utils.WrapError("Failed to mint tokens for RewardsCoordinator", err) + } + + // Generate token tree leaf + // For the tree structure, see + // https://github.com/Layr-Labs/eigenlayer-contracts/blob/a888a1cd1479438dda4b138245a69177b125a973/docs/core/RewardsCoordinator.md#rewards-merkle-tree-structure + earnerAddr := common.HexToAddress(ANVIL_FIRST_ADDRESS) + tokenLeaf := rewardscoordinator.IRewardsCoordinatorTypesTokenTreeMerkleLeaf{ + Token: tokenAddr, + CumulativeEarnings: big.NewInt(cumulativeEarnings), + } + encodedTokenLeaf := []byte{} + tokenLeafSalt := uint8(1) + + // Write the *big.Int to a 32-byte sized buffer to match the uint256 length + cumulativeEarningsBytes := [32]byte{} + tokenLeaf.CumulativeEarnings.FillBytes(cumulativeEarningsBytes[:]) + + encodedTokenLeaf = append(encodedTokenLeaf, tokenLeafSalt) + encodedTokenLeaf = append(encodedTokenLeaf, tokenLeaf.Token.Bytes()...) + encodedTokenLeaf = append(encodedTokenLeaf, cumulativeEarningsBytes[:]...) + + // Hash token tree leaf to get root + earnerTokenRoot := crypto.Keccak256(encodedTokenLeaf) + + // Generate earner tree leaf + earnerLeaf := rewardscoordinator.IRewardsCoordinatorTypesEarnerTreeMerkleLeaf{ + Earner: earnerAddr, + EarnerTokenRoot: [32]byte(earnerTokenRoot), + } + // Encode earner leaft + encodedEarnerLeaf := []byte{} + earnerLeafSalt := uint8(0) + encodedEarnerLeaf = append(encodedEarnerLeaf, earnerLeafSalt) + encodedEarnerLeaf = append(encodedEarnerLeaf, earnerLeaf.Earner.Bytes()...) + encodedEarnerLeaf = append(encodedEarnerLeaf, earnerTokenRoot...) + + // Hash encoded earner tree leaf to get root + earnerTreeRoot := crypto.Keccak256(encodedEarnerLeaf) + + // Fetch the next root index from contract + nextRootIndex, err := chainReader.GetDistributionRootsLength(context.Background()) + if err != nil { + return nil, utils.WrapError("Failed to call GetDistributionRootsLength", err) + } + + tokenLeaves := []rewardscoordinator.IRewardsCoordinatorTypesTokenTreeMerkleLeaf{tokenLeaf} + // Construct the claim + claim := rewardscoordinator.IRewardsCoordinatorTypesRewardsMerkleClaim{ + RootIndex: uint32(nextRootIndex.Uint64()), + EarnerIndex: 0, + // Empty proof because leaf == root + EarnerTreeProof: []byte{}, + EarnerLeaf: earnerLeaf, + TokenIndices: []uint32{0}, + // Empty proof because leaf == root + TokenTreeProofs: [][]byte{{}}, + TokenLeaves: tokenLeaves, + } + + root := [32]byte(earnerTreeRoot) + // Fetch the current timestamp to increase it + currRewardsCalculationEndTimestamp, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) + if err != nil { + return nil, utils.WrapError("Failed to call CurrRewardsCalculationEndTimestamp", err) + } + + rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) + if err != nil { + return nil, utils.WrapError("Failed to create rewards coordinator contract", err) + } + + rewardsUpdater := common.HexToAddress(ANVIL_FIRST_ADDRESS) + + // Change the rewards updater to be able to submit the new root + tx, err = rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) + if err != nil { + return nil, utils.WrapError("Failed to create SetRewardsUpdater tx", err) + } + + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + if err != nil { + return nil, utils.WrapError("Failed to setRewardsUpdate", err) + } + + tx, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) + if err != nil { + return nil, utils.WrapError("Failed to create SubmitRoot tx", err) + } + + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + if err != nil { + return nil, utils.WrapError("Failed to submit root", err) + } + + return &claim, nil +} From 419004d75b37e2312e21c9dd4380aacf2ba1e88a Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Mon, 13 Jan 2025 18:28:09 -0300 Subject: [PATCH 09/28] Add CheckClaim test case (happy path) --- chainio/clients/elcontracts/reader_test.go | 46 ++++++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index fd6941c0..5fb20be9 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -381,10 +381,56 @@ func TestChainReader(t *testing.T) { require.NoError(t, err) require.True(t, receipt.Status == uint64(1)) + // This tests that with a claim result is cumulativeEarnings claimed, err = chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) assert.Equal(t, claimed, big.NewInt(cumulativeEarnings)) assert.NoError(t, err) }) + + t.Run("Check claim", func(t *testing.T) { + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + config := elcontracts.Config{ + DelegationManagerAddress: contractAddrs.DelegationManager, + RewardsCoordinatorAddress: rewardsCoordinatorAddr, + } + privateKeyHex := ANVIL_FIRST_PRIVATE_KEY + + // Create ChainWriter and chain reader + chainWriter, err := NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) + require.NoError(t, err) + + chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + require.NoError(t, err) + + activationDelay := uint32(0) + // Set activation delay to zero so that the earnings can be claimed right after submitting the root + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, privateKeyHex, activationDelay) + require.NoError(t, err) + require.True(t, receipt.Status == uint64(1)) + + cumulativeEarnings := int64(45) + claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) + require.NoError(t, err) + + earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") + receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) + require.NoError(t, err) + require.True(t, receipt.Status == uint64(1)) + + strategyAddr := contractAddrs.Erc20MockStrategy + strategy, contractUnderlyingToken, underlyingTokenAddr, err := clients.ElChainReader.GetStrategyAndUnderlyingERC20Token( + ctx, + strategyAddr, + ) + assert.NoError(t, err) + assert.NotNil(t, strategy) + assert.NotEqual(t, common.Address{}, underlyingTokenAddr) + assert.NotNil(t, contractUnderlyingToken) + + checked, err := chainReader.CheckClaim(ctx, *claim) + require.NoError(t, err) + assert.True(t, checked) + }) } // The functions below will be replaced for those placed in testutils/testclients/testclients.go From a492f2c8149557827d8bb340d91c648c8a701be4 Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Mon, 13 Jan 2025 18:35:30 -0300 Subject: [PATCH 10/28] Remove duplicated test case --- Makefile | 2 +- chainio/clients/elcontracts/reader_test.go | 20 -------------------- 2 files changed, 1 insertion(+), 21 deletions(-) diff --git a/Makefile b/Makefile index 6b5f81ee..99228903 100644 --- a/Makefile +++ b/Makefile @@ -67,7 +67,7 @@ middleware_default := "RegistryCoordinator IndexRegistry OperatorStateRetriever middleware_location := "./lib/eigenlayer-middleware" middleware_bindings_location := "../../bindings" -sdk_default := "MockAvsServiceManager ContractsRegistry" +sdk_default := "MockAvsServiceManager ContractsRegistry MockERC20" sdk_location := "." sdk_bindings_location := "./bindings" diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index 5fb20be9..e32d65d9 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -152,26 +152,6 @@ func TestChainReader(t *testing.T) { assert.Equal(t, address.String(), operator.Address) }) - t.Run("get current claimable distribution root without submitted roots is zero", func(t *testing.T) { - contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint) - - rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator - config := elcontracts.Config{ - DelegationManagerAddress: contractAddrs.DelegationManager, - RewardsCoordinatorAddress: rewardsCoordinatorAddr, - } - - chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) - require.NoError(t, err) - - root, err := chainReader.GetCurrentClaimableDistributionRoot( - ctx, - ) - - assert.NoError(t, err) - assert.Zero(t, root) - }) - t.Run("get current claimable distribution root with and without submitted roots", func(t *testing.T) { // Verifies GetCurrentClaimableDistributionRoot returns 0 if no root and the root if there's one root := [32]byte{ From 08a0379c8d5cf93119f2f7ab2904b79c33e982ea Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Mon, 13 Jan 2025 18:41:16 -0300 Subject: [PATCH 11/28] Move big tests to separate functions --- chainio/clients/elcontracts/reader_test.go | 415 +++++++++++---------- 1 file changed, 215 insertions(+), 200 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index e32d65d9..346a8597 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -152,265 +152,280 @@ func TestChainReader(t *testing.T) { assert.Equal(t, address.String(), operator.Address) }) - t.Run("get current claimable distribution root with and without submitted roots", func(t *testing.T) { - // Verifies GetCurrentClaimableDistributionRoot returns 0 if no root and the root if there's one - root := [32]byte{ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - } - + t.Run("get cumulative claimed rewards", func(t *testing.T) { rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator config := elcontracts.Config{ DelegationManagerAddress: contractAddrs.DelegationManager, RewardsCoordinatorAddress: rewardsCoordinatorAddr, } + privateKeyHex := ANVIL_FIRST_PRIVATE_KEY - chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) - require.NoError(t, err) - - // Create and configure rewards coordinator - ethClient, err := ethclient.Dial(anvilHttpEndpoint) - require.NoError(t, err) - rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) - require.NoError(t, err) - - // Set delay to zero to inmediatly operate with coordinator - receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", uint32(0)) - require.NoError(t, err) - require.Equal(t, receipt.Status, uint64(1)) - - // Create txManager to send transactions to the Ethereum node - txManager, err := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") - require.NoError(t, err) - noSendTxOpts, err := txManager.GetNoSendTxOpts() + // Create ChainWriter + chainWriter, err := NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) require.NoError(t, err) - rewardsUpdater := common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266") - - // Change the rewards updater to be able to submit the new root - tx, err := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) + chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) require.NoError(t, err) - waitForReceipt := true - _, err = txManager.Send(context.Background(), tx, waitForReceipt) + activationDelay := uint32(0) + // Set activation delay to zero so that the earnings can be claimed right after submitting the root + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, privateKeyHex, activationDelay) require.NoError(t, err) + require.True(t, receipt.Status == uint64(1)) - // Check that if there is no root submitted the result is zero - distr_root, err := chainReader.GetCurrentClaimableDistributionRoot( + strategyAddr := contractAddrs.Erc20MockStrategy + strategy, contractUnderlyingToken, underlyingTokenAddr, err := clients.ElChainReader.GetStrategyAndUnderlyingERC20Token( ctx, + strategyAddr, ) assert.NoError(t, err) - assert.Zero(t, distr_root.Root) + assert.NotNil(t, strategy) + assert.NotEqual(t, common.Address{}, underlyingTokenAddr) + assert.NotNil(t, contractUnderlyingToken) - currRewardsCalculationEndTimestamp, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) - require.NoError(t, err) + // This tests that without claims result is zero + claimed, err := chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) + assert.True(t, claimed.Cmp(big.NewInt(0)) == 0) + assert.NoError(t, err) - tx, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) + cumulativeEarnings := int64(45) + claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) require.NoError(t, err) - _, err = txManager.Send(context.Background(), tx, waitForReceipt) + earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") + receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) require.NoError(t, err) + require.True(t, receipt.Status == uint64(1)) - // Check that if there is a root submitted the result is that root - distr_root, err = chainReader.GetCurrentClaimableDistributionRoot( - ctx, - ) + // This tests that with a claim result is cumulativeEarnings + claimed, err = chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) + assert.Equal(t, claimed, big.NewInt(cumulativeEarnings)) assert.NoError(t, err) - assert.Equal(t, distr_root.Root, root) }) +} - t.Run("get root index from root hash with and without submitted roots", func(t *testing.T) { - rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator - config := elcontracts.Config{ - DelegationManagerAddress: contractAddrs.DelegationManager, - RewardsCoordinatorAddress: rewardsCoordinatorAddr, - } +func TestGetCurrentClaimableDistributionRoot(t *testing.T) { + // Verifies GetCurrentClaimableDistributionRoot returns 0 if no root and the root if there's one + _, anvilHttpEndpoint := testclients.BuildTestClients(t) + ctx := context.Background() - chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) - require.NoError(t, err) + contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint) - // Create and configure rewards coordinator - ethClient, err := ethclient.Dial(anvilHttpEndpoint) - require.NoError(t, err) - rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) - require.NoError(t, err) + root := [32]byte{ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + } - // Set delay to zero to inmediatly operate with coordinator - receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", uint32(0)) - require.NoError(t, err) - require.Equal(t, receipt.Status, uint64(1)) + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + config := elcontracts.Config{ + DelegationManagerAddress: contractAddrs.DelegationManager, + RewardsCoordinatorAddress: rewardsCoordinatorAddr, + } - // Create txManager to send transactions to the Ethereum node - txManager, err := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") - require.NoError(t, err) - noSendTxOpts, err := txManager.GetNoSendTxOpts() - require.NoError(t, err) + chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + require.NoError(t, err) - rewardsUpdater := common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266") + // Create and configure rewards coordinator + ethClient, err := ethclient.Dial(anvilHttpEndpoint) + require.NoError(t, err) + rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) + require.NoError(t, err) - // Change the rewards updater to be able to submit the new root - tx, err := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) - require.NoError(t, err) + // Set delay to zero to inmediatly operate with coordinator + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", uint32(0)) + require.NoError(t, err) + require.Equal(t, receipt.Status, uint64(1)) - waitForReceipt := true - _, err = txManager.Send(context.Background(), tx, waitForReceipt) - require.NoError(t, err) + // Create txManager to send transactions to the Ethereum node + txManager, err := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") + require.NoError(t, err) + noSendTxOpts, err := txManager.GetNoSendTxOpts() + require.NoError(t, err) - root := [32]byte{ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - } + rewardsUpdater := common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266") - // Check that if there is no root submitted the result is an InvalidRoot error - root_index, err := chainReader.GetRootIndexFromHash( - ctx, - root, - ) - assert.Error(t, err) - assert.Equal(t, err.Error(), "execution reverted: custom error 0x504570e3") - assert.Zero(t, root_index) + // Change the rewards updater to be able to submit the new root + tx, err := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) + require.NoError(t, err) - currRewardsCalculationEndTimestamp, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) - require.NoError(t, err) + waitForReceipt := true + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, err) - tx, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) - require.NoError(t, err) + // Check that if there is no root submitted the result is zero + distr_root, err := chainReader.GetCurrentClaimableDistributionRoot( + ctx, + ) + assert.NoError(t, err) + assert.Zero(t, distr_root.Root) - _, err = txManager.Send(context.Background(), tx, waitForReceipt) - require.NoError(t, err) + currRewardsCalculationEndTimestamp, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) + require.NoError(t, err) - root2 := [32]byte{ - 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - } + tx, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) + require.NoError(t, err) - currRewardsCalculationEndTimestamp2, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) - require.NoError(t, err) + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, err) - tx, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root2, currRewardsCalculationEndTimestamp2+1) - require.NoError(t, err) + // Check that if there is a root submitted the result is that root + distr_root, err = chainReader.GetCurrentClaimableDistributionRoot( + ctx, + ) + assert.NoError(t, err) + assert.Equal(t, distr_root.Root, root) +} - _, err = txManager.Send(context.Background(), tx, waitForReceipt) - require.NoError(t, err) +func TestGetRootIndexFromRootHash(t *testing.T) { + _, anvilHttpEndpoint := testclients.BuildTestClients(t) + ctx := context.Background() - // Check that the first root inserted is the first indexed (zero) - root_index, err = chainReader.GetRootIndexFromHash( - ctx, - root, - ) - assert.NoError(t, err) - assert.Equal(t, root_index, uint32(0)) + contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint) - // Check that the second root inserted is the second indexed (zero) - root_index, err = chainReader.GetRootIndexFromHash( - ctx, - root2, - ) - assert.NoError(t, err) - assert.Equal(t, root_index, uint32(1)) - }) + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + config := elcontracts.Config{ + DelegationManagerAddress: contractAddrs.DelegationManager, + RewardsCoordinatorAddress: rewardsCoordinatorAddr, + } - t.Run("get cumulative claimed rewards", func(t *testing.T) { - rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator - config := elcontracts.Config{ - DelegationManagerAddress: contractAddrs.DelegationManager, - RewardsCoordinatorAddress: rewardsCoordinatorAddr, - } - privateKeyHex := ANVIL_FIRST_PRIVATE_KEY + chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + require.NoError(t, err) - // Create ChainWriter - chainWriter, err := NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) - require.NoError(t, err) + // Create and configure rewards coordinator + ethClient, err := ethclient.Dial(anvilHttpEndpoint) + require.NoError(t, err) + rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) + require.NoError(t, err) - chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) - require.NoError(t, err) + // Set delay to zero to inmediatly operate with coordinator + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", uint32(0)) + require.NoError(t, err) + require.Equal(t, receipt.Status, uint64(1)) - activationDelay := uint32(0) - // Set activation delay to zero so that the earnings can be claimed right after submitting the root - receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, privateKeyHex, activationDelay) - require.NoError(t, err) - require.True(t, receipt.Status == uint64(1)) + // Create txManager to send transactions to the Ethereum node + txManager, err := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") + require.NoError(t, err) + noSendTxOpts, err := txManager.GetNoSendTxOpts() + require.NoError(t, err) - strategyAddr := contractAddrs.Erc20MockStrategy - strategy, contractUnderlyingToken, underlyingTokenAddr, err := clients.ElChainReader.GetStrategyAndUnderlyingERC20Token( - ctx, - strategyAddr, - ) - assert.NoError(t, err) - assert.NotNil(t, strategy) - assert.NotEqual(t, common.Address{}, underlyingTokenAddr) - assert.NotNil(t, contractUnderlyingToken) + rewardsUpdater := common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266") - // This tests that without claims result is zero - claimed, err := chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) - assert.True(t, claimed.Cmp(big.NewInt(0)) == 0) - assert.NoError(t, err) + // Change the rewards updater to be able to submit the new root + tx, err := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) + require.NoError(t, err) - cumulativeEarnings := int64(45) - claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) - require.NoError(t, err) + waitForReceipt := true + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, err) - earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") - receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) - require.NoError(t, err) - require.True(t, receipt.Status == uint64(1)) + root := [32]byte{ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + } - // This tests that with a claim result is cumulativeEarnings - claimed, err = chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) - assert.Equal(t, claimed, big.NewInt(cumulativeEarnings)) - assert.NoError(t, err) - }) + // Check that if there is no root submitted the result is an InvalidRoot error + root_index, err := chainReader.GetRootIndexFromHash( + ctx, + root, + ) + assert.Error(t, err) + assert.Equal(t, err.Error(), "execution reverted: custom error 0x504570e3") + assert.Zero(t, root_index) - t.Run("Check claim", func(t *testing.T) { - rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator - config := elcontracts.Config{ - DelegationManagerAddress: contractAddrs.DelegationManager, - RewardsCoordinatorAddress: rewardsCoordinatorAddr, - } - privateKeyHex := ANVIL_FIRST_PRIVATE_KEY + currRewardsCalculationEndTimestamp, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) + require.NoError(t, err) - // Create ChainWriter and chain reader - chainWriter, err := NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) - require.NoError(t, err) + tx, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) + require.NoError(t, err) - chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) - require.NoError(t, err) + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, err) - activationDelay := uint32(0) - // Set activation delay to zero so that the earnings can be claimed right after submitting the root - receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, privateKeyHex, activationDelay) - require.NoError(t, err) - require.True(t, receipt.Status == uint64(1)) + root2 := [32]byte{ + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + } - cumulativeEarnings := int64(45) - claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) - require.NoError(t, err) + currRewardsCalculationEndTimestamp2, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) + require.NoError(t, err) - earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") - receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) - require.NoError(t, err) - require.True(t, receipt.Status == uint64(1)) + tx, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root2, currRewardsCalculationEndTimestamp2+1) + require.NoError(t, err) - strategyAddr := contractAddrs.Erc20MockStrategy - strategy, contractUnderlyingToken, underlyingTokenAddr, err := clients.ElChainReader.GetStrategyAndUnderlyingERC20Token( - ctx, - strategyAddr, - ) - assert.NoError(t, err) - assert.NotNil(t, strategy) - assert.NotEqual(t, common.Address{}, underlyingTokenAddr) - assert.NotNil(t, contractUnderlyingToken) + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + require.NoError(t, err) - checked, err := chainReader.CheckClaim(ctx, *claim) - require.NoError(t, err) - assert.True(t, checked) - }) + // Check that the first root inserted is the first indexed (zero) + root_index, err = chainReader.GetRootIndexFromHash( + ctx, + root, + ) + assert.NoError(t, err) + assert.Equal(t, root_index, uint32(0)) + + // Check that the second root inserted is the second indexed (zero) + root_index, err = chainReader.GetRootIndexFromHash( + ctx, + root2, + ) + assert.NoError(t, err) + assert.Equal(t, root_index, uint32(1)) +} + +func TestCheckClaim(t *testing.T) { + clients, anvilHttpEndpoint := testclients.BuildTestClients(t) + ctx := context.Background() + + contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint) + + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + config := elcontracts.Config{ + DelegationManagerAddress: contractAddrs.DelegationManager, + RewardsCoordinatorAddress: rewardsCoordinatorAddr, + } + privateKeyHex := ANVIL_FIRST_PRIVATE_KEY + + // Create ChainWriter and chain reader + chainWriter, err := NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) + require.NoError(t, err) + + chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + require.NoError(t, err) + + activationDelay := uint32(0) + // Set activation delay to zero so that the earnings can be claimed right after submitting the root + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, privateKeyHex, activationDelay) + require.NoError(t, err) + require.True(t, receipt.Status == uint64(1)) + + cumulativeEarnings := int64(45) + claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) + require.NoError(t, err) + + earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") + receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) + require.NoError(t, err) + require.True(t, receipt.Status == uint64(1)) + + strategyAddr := contractAddrs.Erc20MockStrategy + strategy, contractUnderlyingToken, underlyingTokenAddr, err := clients.ElChainReader.GetStrategyAndUnderlyingERC20Token( + ctx, + strategyAddr, + ) + assert.NoError(t, err) + assert.NotNil(t, strategy) + assert.NotEqual(t, common.Address{}, underlyingTokenAddr) + assert.NotNil(t, contractUnderlyingToken) + + checked, err := chainReader.CheckClaim(ctx, *claim) + require.NoError(t, err) + assert.True(t, checked) } // The functions below will be replaced for those placed in testutils/testclients/testclients.go From 92bb5a5767949ebbb3f31ed6837a5bd3ac54402e Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Tue, 14 Jan 2025 09:42:10 -0300 Subject: [PATCH 12/28] Move GetCumulativeClaimed test to a separate function --- chainio/clients/elcontracts/reader_test.go | 108 +++++++++++---------- 1 file changed, 57 insertions(+), 51 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index 346a8597..e12e3a0f 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -135,7 +135,7 @@ func TestChainReader(t *testing.T) { ) assert.NotZero(t, len(strategies)) // Strategies has at least one element assert.NotZero(t, len(shares)) // Shares has at least one element - assert.Equal(t, len(strategies), len(shares)) // Strategies has the same ammount of elements as + assert.Equal(t, len(strategies), len(shares)) // Strategies has the same ammount of elements as shares assert.NoError(t, err) }) @@ -152,56 +152,6 @@ func TestChainReader(t *testing.T) { assert.Equal(t, address.String(), operator.Address) }) - t.Run("get cumulative claimed rewards", func(t *testing.T) { - rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator - config := elcontracts.Config{ - DelegationManagerAddress: contractAddrs.DelegationManager, - RewardsCoordinatorAddress: rewardsCoordinatorAddr, - } - privateKeyHex := ANVIL_FIRST_PRIVATE_KEY - - // Create ChainWriter - chainWriter, err := NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) - require.NoError(t, err) - - chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) - require.NoError(t, err) - - activationDelay := uint32(0) - // Set activation delay to zero so that the earnings can be claimed right after submitting the root - receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, privateKeyHex, activationDelay) - require.NoError(t, err) - require.True(t, receipt.Status == uint64(1)) - - strategyAddr := contractAddrs.Erc20MockStrategy - strategy, contractUnderlyingToken, underlyingTokenAddr, err := clients.ElChainReader.GetStrategyAndUnderlyingERC20Token( - ctx, - strategyAddr, - ) - assert.NoError(t, err) - assert.NotNil(t, strategy) - assert.NotEqual(t, common.Address{}, underlyingTokenAddr) - assert.NotNil(t, contractUnderlyingToken) - - // This tests that without claims result is zero - claimed, err := chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) - assert.True(t, claimed.Cmp(big.NewInt(0)) == 0) - assert.NoError(t, err) - - cumulativeEarnings := int64(45) - claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) - require.NoError(t, err) - - earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") - receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) - require.NoError(t, err) - require.True(t, receipt.Status == uint64(1)) - - // This tests that with a claim result is cumulativeEarnings - claimed, err = chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) - assert.Equal(t, claimed, big.NewInt(cumulativeEarnings)) - assert.NoError(t, err) - }) } func TestGetCurrentClaimableDistributionRoot(t *testing.T) { @@ -378,6 +328,62 @@ func TestGetRootIndexFromRootHash(t *testing.T) { assert.Equal(t, root_index, uint32(1)) } +func TestGetCumulativeClaimedRewards(t *testing.T) { + clients, anvilHttpEndpoint := testclients.BuildTestClients(t) + ctx := context.Background() + + contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint) + + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + config := elcontracts.Config{ + DelegationManagerAddress: contractAddrs.DelegationManager, + RewardsCoordinatorAddress: rewardsCoordinatorAddr, + } + privateKeyHex := ANVIL_FIRST_PRIVATE_KEY + + // Create ChainWriter + chainWriter, err := NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) + require.NoError(t, err) + + chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + require.NoError(t, err) + + activationDelay := uint32(0) + // Set activation delay to zero so that the earnings can be claimed right after submitting the root + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, privateKeyHex, activationDelay) + require.NoError(t, err) + require.True(t, receipt.Status == uint64(1)) + + strategyAddr := contractAddrs.Erc20MockStrategy + strategy, contractUnderlyingToken, underlyingTokenAddr, err := clients.ElChainReader.GetStrategyAndUnderlyingERC20Token( + ctx, + strategyAddr, + ) + assert.NoError(t, err) + assert.NotNil(t, strategy) + assert.NotEqual(t, common.Address{}, underlyingTokenAddr) + assert.NotNil(t, contractUnderlyingToken) + + // This tests that without claims result is zero + claimed, err := chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) + assert.True(t, claimed.Cmp(big.NewInt(0)) == 0) + assert.NoError(t, err) + + cumulativeEarnings := int64(45) + claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) + require.NoError(t, err) + + earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") + receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) + require.NoError(t, err) + require.True(t, receipt.Status == uint64(1)) + + // This tests that with a claim result is cumulativeEarnings + claimed, err = chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) + assert.Equal(t, claimed, big.NewInt(cumulativeEarnings)) + assert.NoError(t, err) +} + func TestCheckClaim(t *testing.T) { clients, anvilHttpEndpoint := testclients.BuildTestClients(t) ctx := context.Background() From a27b93ce711e380327392ff85ffaa605f921ede5 Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Wed, 15 Jan 2025 10:06:30 -0300 Subject: [PATCH 13/28] Adapt tests done with dev changes --- chainio/clients/elcontracts/reader_test.go | 175 ++------------------- 1 file changed, 13 insertions(+), 162 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index e12e3a0f..cce074c8 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -3,29 +3,21 @@ package elcontracts_test import ( "context" "math/big" - "os" "testing" "github.com/Layr-Labs/eigensdk-go/chainio/clients/elcontracts" - "github.com/Layr-Labs/eigensdk-go/chainio/clients/wallet" - "github.com/Layr-Labs/eigensdk-go/chainio/txmgr" erc20 "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IERC20" rewardscoordinator "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IRewardsCoordinator" strategy "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IStrategy" mockerc20 "github.com/Layr-Labs/eigensdk-go/contracts/bindings/MockERC20" - "github.com/Layr-Labs/eigensdk-go/logging" - "github.com/Layr-Labs/eigensdk-go/metrics" - "github.com/Layr-Labs/eigensdk-go/signerv2" "github.com/Layr-Labs/eigensdk-go/testutils" "github.com/Layr-Labs/eigensdk-go/testutils/testclients" "github.com/Layr-Labs/eigensdk-go/types" "github.com/Layr-Labs/eigensdk-go/utils" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" - gethtypes "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethclient" - "github.com/prometheus/client_golang/prometheus" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -174,7 +166,7 @@ func TestGetCurrentClaimableDistributionRoot(t *testing.T) { RewardsCoordinatorAddress: rewardsCoordinatorAddr, } - chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + chainReader, err := testclients.NewTestChainReaderFromConfig(anvilHttpEndpoint, config) require.NoError(t, err) // Create and configure rewards coordinator @@ -189,7 +181,7 @@ func TestGetCurrentClaimableDistributionRoot(t *testing.T) { require.Equal(t, receipt.Status, uint64(1)) // Create txManager to send transactions to the Ethereum node - txManager, err := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") + txManager, err := testclients.NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") require.NoError(t, err) noSendTxOpts, err := txManager.GetNoSendTxOpts() require.NoError(t, err) @@ -240,7 +232,7 @@ func TestGetRootIndexFromRootHash(t *testing.T) { RewardsCoordinatorAddress: rewardsCoordinatorAddr, } - chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + chainReader, err := testclients.NewTestChainReaderFromConfig(anvilHttpEndpoint, config) require.NoError(t, err) // Create and configure rewards coordinator @@ -255,7 +247,7 @@ func TestGetRootIndexFromRootHash(t *testing.T) { require.Equal(t, receipt.Status, uint64(1)) // Create txManager to send transactions to the Ethereum node - txManager, err := NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") + txManager, err := testclients.NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") require.NoError(t, err) noSendTxOpts, err := txManager.GetNoSendTxOpts() require.NoError(t, err) @@ -339,13 +331,13 @@ func TestGetCumulativeClaimedRewards(t *testing.T) { DelegationManagerAddress: contractAddrs.DelegationManager, RewardsCoordinatorAddress: rewardsCoordinatorAddr, } - privateKeyHex := ANVIL_FIRST_PRIVATE_KEY + privateKeyHex := testutils.ANVIL_FIRST_PRIVATE_KEY // Create ChainWriter - chainWriter, err := NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) + chainWriter, err := testclients.NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) require.NoError(t, err) - chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + chainReader, err := testclients.NewTestChainReaderFromConfig(anvilHttpEndpoint, config) require.NoError(t, err) activationDelay := uint32(0) @@ -395,13 +387,13 @@ func TestCheckClaim(t *testing.T) { DelegationManagerAddress: contractAddrs.DelegationManager, RewardsCoordinatorAddress: rewardsCoordinatorAddr, } - privateKeyHex := ANVIL_FIRST_PRIVATE_KEY + privateKeyHex := testutils.ANVIL_FIRST_PRIVATE_KEY // Create ChainWriter and chain reader - chainWriter, err := NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) + chainWriter, err := testclients.NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) require.NoError(t, err) - chainReader, err := NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + chainReader, err := testclients.NewTestChainReaderFromConfig(anvilHttpEndpoint, config) require.NoError(t, err) activationDelay := uint32(0) @@ -435,147 +427,6 @@ func TestCheckClaim(t *testing.T) { } // The functions below will be replaced for those placed in testutils/testclients/testclients.go -func setTestRewardsCoordinatorActivationDelay( - httpEndpoint string, - privateKeyHex string, - activationDelay uint32, -) (*gethtypes.Receipt, error) { - contractAddrs := testutils.GetContractAddressesFromContractRegistry(httpEndpoint) - rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator - ethHttpClient, err := ethclient.Dial(httpEndpoint) - if err != nil { - return nil, utils.WrapError("Failed to create eth client", err) - } - - rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethHttpClient) - if err != nil { - return nil, utils.WrapError("Failed to create rewards coordinator", err) - } - - txManager, err := NewTestTxManager(httpEndpoint, privateKeyHex) - if err != nil { - return nil, utils.WrapError("Failed to create tx manager", err) - } - - noSendOpts, err := txManager.GetNoSendTxOpts() - if err != nil { - return nil, utils.WrapError("Failed to get NoSend tx opts", err) - } - - tx, err := rewardsCoordinator.SetActivationDelay(noSendOpts, activationDelay) - if err != nil { - return nil, utils.WrapError("Failed to create SetActivationDelay tx", err) - } - - receipt, err := txManager.Send(context.Background(), tx, true) - if err != nil { - return nil, utils.WrapError("Failed to send SetActivationDelay tx", err) - } - return receipt, err -} - -// Creates a testing ChainWriter from an httpEndpoint, private key and config. -// This is needed because the existing testclients.BuildTestClients returns a -// ChainReader with a null rewardsCoordinator, which is required for some of the tests. -func NewTestChainReaderFromConfig( - httpEndpoint string, - config elcontracts.Config, -) (*elcontracts.ChainReader, error) { - testConfig := testutils.GetDefaultTestConfig() - logger := logging.NewTextSLogger(os.Stdout, &logging.SLoggerOptions{Level: testConfig.LogLevel}) - ethHttpClient, err := ethclient.Dial(httpEndpoint) - if err != nil { - return nil, utils.WrapError("Failed to create eth client", err) - } - - testReader, err := elcontracts.NewReaderFromConfig( - config, - ethHttpClient, - logger, - ) - if err != nil { - return nil, utils.WrapError("Failed to create chain reader from config", err) - } - return testReader, nil -} - -func NewTestTxManager(httpEndpoint string, privateKeyHex string) (*txmgr.SimpleTxManager, error) { - testConfig := testutils.GetDefaultTestConfig() - ethHttpClient, err := ethclient.Dial(httpEndpoint) - if err != nil { - return nil, utils.WrapError("Failed to create eth client", err) - } - - chainid, err := ethHttpClient.ChainID(context.Background()) - if err != nil { - return nil, utils.WrapError("Failed to retrieve chain id", err) - } - privateKey, err := crypto.HexToECDSA(privateKeyHex) - if err != nil { - return nil, utils.WrapError("Failed to convert hex string to private key", err) - } - signerV2, addr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: privateKey}, chainid) - if err != nil { - return nil, utils.WrapError("Failed to create signer", err) - } - - logger := logging.NewTextSLogger(os.Stdout, &logging.SLoggerOptions{Level: testConfig.LogLevel}) - - pkWallet, err := wallet.NewPrivateKeyWallet(ethHttpClient, signerV2, addr, logger) - if err != nil { - return nil, utils.WrapError("Failed to create wallet", err) - } - - txManager := txmgr.NewSimpleTxManager(pkWallet, ethHttpClient, logger, addr) - return txManager, nil -} - -func NewTestChainWriterFromConfig( - httpEndpoint string, - privateKeyHex string, - config elcontracts.Config, -) (*elcontracts.ChainWriter, error) { - privateKey, err := crypto.HexToECDSA(privateKeyHex) - if err != nil { - return nil, utils.WrapError("Failed convert hex string to ecdsa private key", err) - } - testConfig := testutils.GetDefaultTestConfig() - logger := logging.NewTextSLogger(os.Stdout, &logging.SLoggerOptions{Level: testConfig.LogLevel}) - ethHttpClient, err := ethclient.Dial(httpEndpoint) - if err != nil { - return nil, utils.WrapError("Failed to create eth client", err) - } - chainid, err := ethHttpClient.ChainID(context.Background()) - if err != nil { - return nil, utils.WrapError("Failed to get chain id", err) - } - promReg := prometheus.NewRegistry() - eigenMetrics := metrics.NewEigenMetrics("", "", promReg, logger) - signerV2, addr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: privateKey}, chainid) - if err != nil { - return nil, utils.WrapError("Failed to create the signer from the given config", err) - } - - pkWallet, err := wallet.NewPrivateKeyWallet(ethHttpClient, signerV2, addr, logger) - if err != nil { - return nil, utils.WrapError("Failed to create wallet", err) - } - txManager := txmgr.NewSimpleTxManager(pkWallet, ethHttpClient, logger, addr) - testWriter, err := elcontracts.NewWriterFromConfig( - config, - ethHttpClient, - logger, - eigenMetrics, - txManager, - ) - if err != nil { - return nil, err - } - return testWriter, nil -} - -const ANVIL_FIRST_ADDRESS = "f39Fd6e51aad88F6F4ce6aB8827279cffFb92266" -const ANVIL_FIRST_PRIVATE_KEY = "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" // Returns a (test) claim for the given cumulativeEarnings, whose earner is // the account given by the testutils.ANVIL_FIRST_ADDRESS address. @@ -595,7 +446,7 @@ func newTestClaim( return nil, utils.WrapError("Failed to create eth client", err) } - txManager, err := NewTestTxManager(httpEndpoint, privateKeyHex) + txManager, err := testclients.NewTestTxManager(httpEndpoint, privateKeyHex) if err != nil { return nil, utils.WrapError("Failed to create tx manager", err) } @@ -635,7 +486,7 @@ func newTestClaim( // Generate token tree leaf // For the tree structure, see // https://github.com/Layr-Labs/eigenlayer-contracts/blob/a888a1cd1479438dda4b138245a69177b125a973/docs/core/RewardsCoordinator.md#rewards-merkle-tree-structure - earnerAddr := common.HexToAddress(ANVIL_FIRST_ADDRESS) + earnerAddr := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS) tokenLeaf := rewardscoordinator.IRewardsCoordinatorTypesTokenTreeMerkleLeaf{ Token: tokenAddr, CumulativeEarnings: big.NewInt(cumulativeEarnings), @@ -701,7 +552,7 @@ func newTestClaim( return nil, utils.WrapError("Failed to create rewards coordinator contract", err) } - rewardsUpdater := common.HexToAddress(ANVIL_FIRST_ADDRESS) + rewardsUpdater := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS) // Change the rewards updater to be able to submit the new root tx, err = rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) From e9aaebec0f117148a2e84d520210795c2e9d328c Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Wed, 15 Jan 2025 10:12:56 -0300 Subject: [PATCH 14/28] Use variables and constants to avoid long lines --- chainio/clients/elcontracts/reader_test.go | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index cce074c8..86c42a6f 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -175,13 +175,15 @@ func TestGetCurrentClaimableDistributionRoot(t *testing.T) { rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) require.NoError(t, err) + ecdsaPrivKeyHex := "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" + // Set delay to zero to inmediatly operate with coordinator - receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", uint32(0)) + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, ecdsaPrivKeyHex, uint32(0)) require.NoError(t, err) require.Equal(t, receipt.Status, uint64(1)) // Create txManager to send transactions to the Ethereum node - txManager, err := testclients.NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") + txManager, err := testclients.NewTestTxManager(anvilHttpEndpoint, ecdsaPrivKeyHex) require.NoError(t, err) noSendTxOpts, err := txManager.GetNoSendTxOpts() require.NoError(t, err) @@ -240,14 +242,15 @@ func TestGetRootIndexFromRootHash(t *testing.T) { require.NoError(t, err) rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) require.NoError(t, err) + ecdsaPrivKeyHex := "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" // Set delay to zero to inmediatly operate with coordinator - receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", uint32(0)) + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, ecdsaPrivKeyHex, uint32(0)) require.NoError(t, err) require.Equal(t, receipt.Status, uint64(1)) // Create txManager to send transactions to the Ethereum node - txManager, err := testclients.NewTestTxManager(anvilHttpEndpoint, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") + txManager, err := testclients.NewTestTxManager(anvilHttpEndpoint, ecdsaPrivKeyHex) require.NoError(t, err) noSendTxOpts, err := txManager.GetNoSendTxOpts() require.NoError(t, err) @@ -356,8 +359,10 @@ func TestGetCumulativeClaimedRewards(t *testing.T) { assert.NotEqual(t, common.Address{}, underlyingTokenAddr) assert.NotNil(t, contractUnderlyingToken) + anvil_address := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS) + // This tests that without claims result is zero - claimed, err := chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) + claimed, err := chainReader.GetCumulativeClaimed(ctx, anvil_address, underlyingTokenAddr) assert.True(t, claimed.Cmp(big.NewInt(0)) == 0) assert.NoError(t, err) @@ -371,7 +376,7 @@ func TestGetCumulativeClaimedRewards(t *testing.T) { require.True(t, receipt.Status == uint64(1)) // This tests that with a claim result is cumulativeEarnings - claimed, err = chainReader.GetCumulativeClaimed(ctx, common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266"), underlyingTokenAddr) + claimed, err = chainReader.GetCumulativeClaimed(ctx, anvil_address, underlyingTokenAddr) assert.Equal(t, claimed, big.NewInt(cumulativeEarnings)) assert.NoError(t, err) } From 8ebcb234d0952b6830d6ab710d42927265897f9f Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Wed, 15 Jan 2025 10:19:41 -0300 Subject: [PATCH 15/28] Move comments and use constants --- chainio/clients/elcontracts/reader_test.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index 86c42a6f..daf97fe7 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -120,7 +120,7 @@ func TestChainReader(t *testing.T) { assert.NotEmpty(t, digest) }) - t.Run("staker shares test (GetStakerShares)", func(t *testing.T) { + t.Run("get staker shares", func(t *testing.T) { strategies, shares, err := clients.ElChainReader.GetStakerShares( ctx, common.HexToAddress(operator.Address), @@ -132,7 +132,6 @@ func TestChainReader(t *testing.T) { }) t.Run("get delegated operator", func(t *testing.T) { - // The delegated operator of an operator is the operator itself val := big.NewInt(0) address, err := clients.ElChainReader.GetDelegatedOperator( ctx, @@ -141,6 +140,7 @@ func TestChainReader(t *testing.T) { ) assert.NoError(t, err) + // The delegated operator of an operator is the operator itself assert.Equal(t, address.String(), operator.Address) }) @@ -175,7 +175,7 @@ func TestGetCurrentClaimableDistributionRoot(t *testing.T) { rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) require.NoError(t, err) - ecdsaPrivKeyHex := "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" + ecdsaPrivKeyHex := testutils.ANVIL_FIRST_PRIVATE_KEY // Set delay to zero to inmediatly operate with coordinator receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, ecdsaPrivKeyHex, uint32(0)) @@ -188,7 +188,7 @@ func TestGetCurrentClaimableDistributionRoot(t *testing.T) { noSendTxOpts, err := txManager.GetNoSendTxOpts() require.NoError(t, err) - rewardsUpdater := common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266") + rewardsUpdater := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS) // Change the rewards updater to be able to submit the new root tx, err := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) @@ -242,7 +242,7 @@ func TestGetRootIndexFromRootHash(t *testing.T) { require.NoError(t, err) rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) require.NoError(t, err) - ecdsaPrivKeyHex := "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" + ecdsaPrivKeyHex := testutils.ANVIL_FIRST_PRIVATE_KEY // Set delay to zero to inmediatly operate with coordinator receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, ecdsaPrivKeyHex, uint32(0)) @@ -255,7 +255,7 @@ func TestGetRootIndexFromRootHash(t *testing.T) { noSendTxOpts, err := txManager.GetNoSendTxOpts() require.NoError(t, err) - rewardsUpdater := common.HexToAddress("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266") + rewardsUpdater := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS) // Change the rewards updater to be able to submit the new root tx, err := rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) From a4035bd12540a1c99c1b81bfa600d0d9b59e9f7f Mon Sep 17 00:00:00 2001 From: ricomateo Date: Thu, 9 Jan 2025 17:40:03 -0300 Subject: [PATCH 16/28] add MockERC20 bindings --- contracts/bindings/MockERC20/binding.go | 883 ++++++++++++++++++++++++ 1 file changed, 883 insertions(+) create mode 100644 contracts/bindings/MockERC20/binding.go diff --git a/contracts/bindings/MockERC20/binding.go b/contracts/bindings/MockERC20/binding.go new file mode 100644 index 00000000..de7fc24b --- /dev/null +++ b/contracts/bindings/MockERC20/binding.go @@ -0,0 +1,883 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package contractMockERC20 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ContractMockERC20MetaData contains all meta data concerning the ContractMockERC20 contract. +var ContractMockERC20MetaData = &bind.MetaData{ + ABI: "[{\"type\":\"function\",\"name\":\"allowance\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"approve\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"balanceOf\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decimals\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"subtractedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"increaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"addedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"mint\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"name\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"symbol\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"totalSupply\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transfer\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferFrom\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Approval\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Transfer\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false}]", + Bin: "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", +} + +// ContractMockERC20ABI is the input ABI used to generate the binding from. +// Deprecated: Use ContractMockERC20MetaData.ABI instead. +var ContractMockERC20ABI = ContractMockERC20MetaData.ABI + +// ContractMockERC20Bin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ContractMockERC20MetaData.Bin instead. +var ContractMockERC20Bin = ContractMockERC20MetaData.Bin + +// DeployContractMockERC20 deploys a new Ethereum contract, binding an instance of ContractMockERC20 to it. +func DeployContractMockERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ContractMockERC20, error) { + parsed, err := ContractMockERC20MetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ContractMockERC20Bin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &ContractMockERC20{ContractMockERC20Caller: ContractMockERC20Caller{contract: contract}, ContractMockERC20Transactor: ContractMockERC20Transactor{contract: contract}, ContractMockERC20Filterer: ContractMockERC20Filterer{contract: contract}}, nil +} + +// ContractMockERC20Methods is an auto generated interface around an Ethereum contract. +type ContractMockERC20Methods interface { + ContractMockERC20Calls + ContractMockERC20Transacts + ContractMockERC20Filters +} + +// ContractMockERC20Calls is an auto generated interface that defines the call methods available for an Ethereum contract. +type ContractMockERC20Calls interface { + Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) + + BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) + + Decimals(opts *bind.CallOpts) (uint8, error) + + Name(opts *bind.CallOpts) (string, error) + + Symbol(opts *bind.CallOpts) (string, error) + + TotalSupply(opts *bind.CallOpts) (*big.Int, error) +} + +// ContractMockERC20Transacts is an auto generated interface that defines the transact methods available for an Ethereum contract. +type ContractMockERC20Transacts interface { + Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) + + DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) + + IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) + + Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) + + Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) + + TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) +} + +// ContractMockERC20Filterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. +type ContractMockERC20Filters interface { + FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ContractMockERC20ApprovalIterator, error) + WatchApproval(opts *bind.WatchOpts, sink chan<- *ContractMockERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) + ParseApproval(log types.Log) (*ContractMockERC20Approval, error) + + FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ContractMockERC20TransferIterator, error) + WatchTransfer(opts *bind.WatchOpts, sink chan<- *ContractMockERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) + ParseTransfer(log types.Log) (*ContractMockERC20Transfer, error) +} + +// ContractMockERC20 is an auto generated Go binding around an Ethereum contract. +type ContractMockERC20 struct { + ContractMockERC20Caller // Read-only binding to the contract + ContractMockERC20Transactor // Write-only binding to the contract + ContractMockERC20Filterer // Log filterer for contract events +} + +// ContractMockERC20 implements the ContractMockERC20Methods interface. +var _ ContractMockERC20Methods = (*ContractMockERC20)(nil) + +// ContractMockERC20Caller is an auto generated read-only Go binding around an Ethereum contract. +type ContractMockERC20Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ContractMockERC20Caller implements the ContractMockERC20Calls interface. +var _ ContractMockERC20Calls = (*ContractMockERC20Caller)(nil) + +// ContractMockERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. +type ContractMockERC20Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ContractMockERC20Transactor implements the ContractMockERC20Transacts interface. +var _ ContractMockERC20Transacts = (*ContractMockERC20Transactor)(nil) + +// ContractMockERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ContractMockERC20Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ContractMockERC20Filterer implements the ContractMockERC20Filters interface. +var _ ContractMockERC20Filters = (*ContractMockERC20Filterer)(nil) + +// ContractMockERC20Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ContractMockERC20Session struct { + Contract *ContractMockERC20 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ContractMockERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ContractMockERC20CallerSession struct { + Contract *ContractMockERC20Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ContractMockERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ContractMockERC20TransactorSession struct { + Contract *ContractMockERC20Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ContractMockERC20Raw is an auto generated low-level Go binding around an Ethereum contract. +type ContractMockERC20Raw struct { + Contract *ContractMockERC20 // Generic contract binding to access the raw methods on +} + +// ContractMockERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ContractMockERC20CallerRaw struct { + Contract *ContractMockERC20Caller // Generic read-only contract binding to access the raw methods on +} + +// ContractMockERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ContractMockERC20TransactorRaw struct { + Contract *ContractMockERC20Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewContractMockERC20 creates a new instance of ContractMockERC20, bound to a specific deployed contract. +func NewContractMockERC20(address common.Address, backend bind.ContractBackend) (*ContractMockERC20, error) { + contract, err := bindContractMockERC20(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ContractMockERC20{ContractMockERC20Caller: ContractMockERC20Caller{contract: contract}, ContractMockERC20Transactor: ContractMockERC20Transactor{contract: contract}, ContractMockERC20Filterer: ContractMockERC20Filterer{contract: contract}}, nil +} + +// NewContractMockERC20Caller creates a new read-only instance of ContractMockERC20, bound to a specific deployed contract. +func NewContractMockERC20Caller(address common.Address, caller bind.ContractCaller) (*ContractMockERC20Caller, error) { + contract, err := bindContractMockERC20(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ContractMockERC20Caller{contract: contract}, nil +} + +// NewContractMockERC20Transactor creates a new write-only instance of ContractMockERC20, bound to a specific deployed contract. +func NewContractMockERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ContractMockERC20Transactor, error) { + contract, err := bindContractMockERC20(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ContractMockERC20Transactor{contract: contract}, nil +} + +// NewContractMockERC20Filterer creates a new log filterer instance of ContractMockERC20, bound to a specific deployed contract. +func NewContractMockERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ContractMockERC20Filterer, error) { + contract, err := bindContractMockERC20(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ContractMockERC20Filterer{contract: contract}, nil +} + +// bindContractMockERC20 binds a generic wrapper to an already deployed contract. +func bindContractMockERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ContractMockERC20MetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ContractMockERC20 *ContractMockERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ContractMockERC20.Contract.ContractMockERC20Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ContractMockERC20 *ContractMockERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ContractMockERC20.Contract.ContractMockERC20Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ContractMockERC20 *ContractMockERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ContractMockERC20.Contract.ContractMockERC20Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ContractMockERC20 *ContractMockERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ContractMockERC20.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ContractMockERC20 *ContractMockERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ContractMockERC20.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ContractMockERC20 *ContractMockERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ContractMockERC20.Contract.contract.Transact(opts, method, params...) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _ContractMockERC20.contract.Call(opts, &out, "allowance", owner, spender) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _ContractMockERC20.Contract.Allowance(&_ContractMockERC20.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _ContractMockERC20.Contract.Allowance(&_ContractMockERC20.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { + var out []interface{} + err := _ContractMockERC20.contract.Call(opts, &out, "balanceOf", account) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20Session) BalanceOf(account common.Address) (*big.Int, error) { + return _ContractMockERC20.Contract.BalanceOf(&_ContractMockERC20.CallOpts, account) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { + return _ContractMockERC20.Contract.BalanceOf(&_ContractMockERC20.CallOpts, account) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_ContractMockERC20 *ContractMockERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _ContractMockERC20.contract.Call(opts, &out, "decimals") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_ContractMockERC20 *ContractMockERC20Session) Decimals() (uint8, error) { + return _ContractMockERC20.Contract.Decimals(&_ContractMockERC20.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_ContractMockERC20 *ContractMockERC20CallerSession) Decimals() (uint8, error) { + return _ContractMockERC20.Contract.Decimals(&_ContractMockERC20.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_ContractMockERC20 *ContractMockERC20Caller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _ContractMockERC20.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_ContractMockERC20 *ContractMockERC20Session) Name() (string, error) { + return _ContractMockERC20.Contract.Name(&_ContractMockERC20.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_ContractMockERC20 *ContractMockERC20CallerSession) Name() (string, error) { + return _ContractMockERC20.Contract.Name(&_ContractMockERC20.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_ContractMockERC20 *ContractMockERC20Caller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _ContractMockERC20.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_ContractMockERC20 *ContractMockERC20Session) Symbol() (string, error) { + return _ContractMockERC20.Contract.Symbol(&_ContractMockERC20.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_ContractMockERC20 *ContractMockERC20CallerSession) Symbol() (string, error) { + return _ContractMockERC20.Contract.Symbol(&_ContractMockERC20.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _ContractMockERC20.contract.Call(opts, &out, "totalSupply") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20Session) TotalSupply() (*big.Int, error) { + return _ContractMockERC20.Contract.TotalSupply(&_ContractMockERC20.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20CallerSession) TotalSupply() (*big.Int, error) { + return _ContractMockERC20.Contract.TotalSupply(&_ContractMockERC20.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.contract.Transact(opts, "approve", spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.Approve(&_ContractMockERC20.TransactOpts, spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.Approve(&_ContractMockERC20.TransactOpts, spender, amount) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.DecreaseAllowance(&_ContractMockERC20.TransactOpts, spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_ContractMockERC20 *ContractMockERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.DecreaseAllowance(&_ContractMockERC20.TransactOpts, spender, subtractedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.contract.Transact(opts, "increaseAllowance", spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.IncreaseAllowance(&_ContractMockERC20.TransactOpts, spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_ContractMockERC20 *ContractMockERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.IncreaseAllowance(&_ContractMockERC20.TransactOpts, spender, addedValue) +} + +// Mint is a paid mutator transaction binding the contract method 0x40c10f19. +// +// Solidity: function mint(address account, uint256 amount) returns() +func (_ContractMockERC20 *ContractMockERC20Transactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.contract.Transact(opts, "mint", account, amount) +} + +// Mint is a paid mutator transaction binding the contract method 0x40c10f19. +// +// Solidity: function mint(address account, uint256 amount) returns() +func (_ContractMockERC20 *ContractMockERC20Session) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.Mint(&_ContractMockERC20.TransactOpts, account, amount) +} + +// Mint is a paid mutator transaction binding the contract method 0x40c10f19. +// +// Solidity: function mint(address account, uint256 amount) returns() +func (_ContractMockERC20 *ContractMockERC20TransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.Mint(&_ContractMockERC20.TransactOpts, account, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.contract.Transact(opts, "transfer", to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.Transfer(&_ContractMockERC20.TransactOpts, to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.Transfer(&_ContractMockERC20.TransactOpts, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.contract.Transact(opts, "transferFrom", from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Session) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.TransferFrom(&_ContractMockERC20.TransactOpts, from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20TransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.TransferFrom(&_ContractMockERC20.TransactOpts, from, to, amount) +} + +// ContractMockERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ContractMockERC20 contract. +type ContractMockERC20ApprovalIterator struct { + Event *ContractMockERC20Approval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractMockERC20ApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractMockERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractMockERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractMockERC20ApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractMockERC20ApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractMockERC20Approval represents a Approval event raised by the ContractMockERC20 contract. +type ContractMockERC20Approval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ContractMockERC20 *ContractMockERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ContractMockERC20ApprovalIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _ContractMockERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &ContractMockERC20ApprovalIterator{contract: _ContractMockERC20.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ContractMockERC20 *ContractMockERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ContractMockERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _ContractMockERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractMockERC20Approval) + if err := _ContractMockERC20.contract.UnpackLog(event, "Approval", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ContractMockERC20 *ContractMockERC20Filterer) ParseApproval(log types.Log) (*ContractMockERC20Approval, error) { + event := new(ContractMockERC20Approval) + if err := _ContractMockERC20.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractMockERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ContractMockERC20 contract. +type ContractMockERC20TransferIterator struct { + Event *ContractMockERC20Transfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractMockERC20TransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractMockERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractMockERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractMockERC20TransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractMockERC20TransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractMockERC20Transfer represents a Transfer event raised by the ContractMockERC20 contract. +type ContractMockERC20Transfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ContractMockERC20 *ContractMockERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ContractMockERC20TransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ContractMockERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &ContractMockERC20TransferIterator{contract: _ContractMockERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ContractMockERC20 *ContractMockERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ContractMockERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ContractMockERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractMockERC20Transfer) + if err := _ContractMockERC20.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ContractMockERC20 *ContractMockERC20Filterer) ParseTransfer(log types.Log) (*ContractMockERC20Transfer, error) { + event := new(ContractMockERC20Transfer) + if err := _ContractMockERC20.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} From 77a3e280147d562b982c31661449cc5e222f5414 Mon Sep 17 00:00:00 2001 From: ricomateo Date: Tue, 14 Jan 2025 14:50:48 -0300 Subject: [PATCH 17/28] remove MockERC20 bindings --- contracts/bindings/MockERC20/binding.go | 883 ------------------------ 1 file changed, 883 deletions(-) delete mode 100644 contracts/bindings/MockERC20/binding.go diff --git a/contracts/bindings/MockERC20/binding.go b/contracts/bindings/MockERC20/binding.go deleted file mode 100644 index de7fc24b..00000000 --- a/contracts/bindings/MockERC20/binding.go +++ /dev/null @@ -1,883 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package contractMockERC20 - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// ContractMockERC20MetaData contains all meta data concerning the ContractMockERC20 contract. -var ContractMockERC20MetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"allowance\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"approve\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"balanceOf\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decimals\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"subtractedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"increaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"addedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"mint\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"name\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"symbol\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"totalSupply\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transfer\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferFrom\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Approval\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Transfer\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false}]", - Bin: "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", -} - -// ContractMockERC20ABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractMockERC20MetaData.ABI instead. -var ContractMockERC20ABI = ContractMockERC20MetaData.ABI - -// ContractMockERC20Bin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ContractMockERC20MetaData.Bin instead. -var ContractMockERC20Bin = ContractMockERC20MetaData.Bin - -// DeployContractMockERC20 deploys a new Ethereum contract, binding an instance of ContractMockERC20 to it. -func DeployContractMockERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ContractMockERC20, error) { - parsed, err := ContractMockERC20MetaData.GetAbi() - if err != nil { - return common.Address{}, nil, nil, err - } - if parsed == nil { - return common.Address{}, nil, nil, errors.New("GetABI returned nil") - } - - address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ContractMockERC20Bin), backend) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &ContractMockERC20{ContractMockERC20Caller: ContractMockERC20Caller{contract: contract}, ContractMockERC20Transactor: ContractMockERC20Transactor{contract: contract}, ContractMockERC20Filterer: ContractMockERC20Filterer{contract: contract}}, nil -} - -// ContractMockERC20Methods is an auto generated interface around an Ethereum contract. -type ContractMockERC20Methods interface { - ContractMockERC20Calls - ContractMockERC20Transacts - ContractMockERC20Filters -} - -// ContractMockERC20Calls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractMockERC20Calls interface { - Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) - - BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) - - Decimals(opts *bind.CallOpts) (uint8, error) - - Name(opts *bind.CallOpts) (string, error) - - Symbol(opts *bind.CallOpts) (string, error) - - TotalSupply(opts *bind.CallOpts) (*big.Int, error) -} - -// ContractMockERC20Transacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractMockERC20Transacts interface { - Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) - - DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) - - IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) - - Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) - - Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) - - TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) -} - -// ContractMockERC20Filterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractMockERC20Filters interface { - FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ContractMockERC20ApprovalIterator, error) - WatchApproval(opts *bind.WatchOpts, sink chan<- *ContractMockERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) - ParseApproval(log types.Log) (*ContractMockERC20Approval, error) - - FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ContractMockERC20TransferIterator, error) - WatchTransfer(opts *bind.WatchOpts, sink chan<- *ContractMockERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) - ParseTransfer(log types.Log) (*ContractMockERC20Transfer, error) -} - -// ContractMockERC20 is an auto generated Go binding around an Ethereum contract. -type ContractMockERC20 struct { - ContractMockERC20Caller // Read-only binding to the contract - ContractMockERC20Transactor // Write-only binding to the contract - ContractMockERC20Filterer // Log filterer for contract events -} - -// ContractMockERC20 implements the ContractMockERC20Methods interface. -var _ ContractMockERC20Methods = (*ContractMockERC20)(nil) - -// ContractMockERC20Caller is an auto generated read-only Go binding around an Ethereum contract. -type ContractMockERC20Caller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractMockERC20Caller implements the ContractMockERC20Calls interface. -var _ ContractMockERC20Calls = (*ContractMockERC20Caller)(nil) - -// ContractMockERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractMockERC20Transactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractMockERC20Transactor implements the ContractMockERC20Transacts interface. -var _ ContractMockERC20Transacts = (*ContractMockERC20Transactor)(nil) - -// ContractMockERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractMockERC20Filterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractMockERC20Filterer implements the ContractMockERC20Filters interface. -var _ ContractMockERC20Filters = (*ContractMockERC20Filterer)(nil) - -// ContractMockERC20Session is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ContractMockERC20Session struct { - Contract *ContractMockERC20 // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ContractMockERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ContractMockERC20CallerSession struct { - Contract *ContractMockERC20Caller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ContractMockERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ContractMockERC20TransactorSession struct { - Contract *ContractMockERC20Transactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ContractMockERC20Raw is an auto generated low-level Go binding around an Ethereum contract. -type ContractMockERC20Raw struct { - Contract *ContractMockERC20 // Generic contract binding to access the raw methods on -} - -// ContractMockERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractMockERC20CallerRaw struct { - Contract *ContractMockERC20Caller // Generic read-only contract binding to access the raw methods on -} - -// ContractMockERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractMockERC20TransactorRaw struct { - Contract *ContractMockERC20Transactor // Generic write-only contract binding to access the raw methods on -} - -// NewContractMockERC20 creates a new instance of ContractMockERC20, bound to a specific deployed contract. -func NewContractMockERC20(address common.Address, backend bind.ContractBackend) (*ContractMockERC20, error) { - contract, err := bindContractMockERC20(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ContractMockERC20{ContractMockERC20Caller: ContractMockERC20Caller{contract: contract}, ContractMockERC20Transactor: ContractMockERC20Transactor{contract: contract}, ContractMockERC20Filterer: ContractMockERC20Filterer{contract: contract}}, nil -} - -// NewContractMockERC20Caller creates a new read-only instance of ContractMockERC20, bound to a specific deployed contract. -func NewContractMockERC20Caller(address common.Address, caller bind.ContractCaller) (*ContractMockERC20Caller, error) { - contract, err := bindContractMockERC20(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ContractMockERC20Caller{contract: contract}, nil -} - -// NewContractMockERC20Transactor creates a new write-only instance of ContractMockERC20, bound to a specific deployed contract. -func NewContractMockERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ContractMockERC20Transactor, error) { - contract, err := bindContractMockERC20(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ContractMockERC20Transactor{contract: contract}, nil -} - -// NewContractMockERC20Filterer creates a new log filterer instance of ContractMockERC20, bound to a specific deployed contract. -func NewContractMockERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ContractMockERC20Filterer, error) { - contract, err := bindContractMockERC20(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ContractMockERC20Filterer{contract: contract}, nil -} - -// bindContractMockERC20 binds a generic wrapper to an already deployed contract. -func bindContractMockERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractMockERC20MetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_ContractMockERC20 *ContractMockERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractMockERC20.Contract.ContractMockERC20Caller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_ContractMockERC20 *ContractMockERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractMockERC20.Contract.ContractMockERC20Transactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractMockERC20 *ContractMockERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractMockERC20.Contract.ContractMockERC20Transactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_ContractMockERC20 *ContractMockERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractMockERC20.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_ContractMockERC20 *ContractMockERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractMockERC20.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractMockERC20 *ContractMockERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractMockERC20.Contract.contract.Transact(opts, method, params...) -} - -// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. -// -// Solidity: function allowance(address owner, address spender) view returns(uint256) -func (_ContractMockERC20 *ContractMockERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractMockERC20.contract.Call(opts, &out, "allowance", owner, spender) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. -// -// Solidity: function allowance(address owner, address spender) view returns(uint256) -func (_ContractMockERC20 *ContractMockERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { - return _ContractMockERC20.Contract.Allowance(&_ContractMockERC20.CallOpts, owner, spender) -} - -// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. -// -// Solidity: function allowance(address owner, address spender) view returns(uint256) -func (_ContractMockERC20 *ContractMockERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { - return _ContractMockERC20.Contract.Allowance(&_ContractMockERC20.CallOpts, owner, spender) -} - -// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. -// -// Solidity: function balanceOf(address account) view returns(uint256) -func (_ContractMockERC20 *ContractMockERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractMockERC20.contract.Call(opts, &out, "balanceOf", account) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. -// -// Solidity: function balanceOf(address account) view returns(uint256) -func (_ContractMockERC20 *ContractMockERC20Session) BalanceOf(account common.Address) (*big.Int, error) { - return _ContractMockERC20.Contract.BalanceOf(&_ContractMockERC20.CallOpts, account) -} - -// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. -// -// Solidity: function balanceOf(address account) view returns(uint256) -func (_ContractMockERC20 *ContractMockERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { - return _ContractMockERC20.Contract.BalanceOf(&_ContractMockERC20.CallOpts, account) -} - -// Decimals is a free data retrieval call binding the contract method 0x313ce567. -// -// Solidity: function decimals() view returns(uint8) -func (_ContractMockERC20 *ContractMockERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error) { - var out []interface{} - err := _ContractMockERC20.contract.Call(opts, &out, "decimals") - - if err != nil { - return *new(uint8), err - } - - out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) - - return out0, err - -} - -// Decimals is a free data retrieval call binding the contract method 0x313ce567. -// -// Solidity: function decimals() view returns(uint8) -func (_ContractMockERC20 *ContractMockERC20Session) Decimals() (uint8, error) { - return _ContractMockERC20.Contract.Decimals(&_ContractMockERC20.CallOpts) -} - -// Decimals is a free data retrieval call binding the contract method 0x313ce567. -// -// Solidity: function decimals() view returns(uint8) -func (_ContractMockERC20 *ContractMockERC20CallerSession) Decimals() (uint8, error) { - return _ContractMockERC20.Contract.Decimals(&_ContractMockERC20.CallOpts) -} - -// Name is a free data retrieval call binding the contract method 0x06fdde03. -// -// Solidity: function name() view returns(string) -func (_ContractMockERC20 *ContractMockERC20Caller) Name(opts *bind.CallOpts) (string, error) { - var out []interface{} - err := _ContractMockERC20.contract.Call(opts, &out, "name") - - if err != nil { - return *new(string), err - } - - out0 := *abi.ConvertType(out[0], new(string)).(*string) - - return out0, err - -} - -// Name is a free data retrieval call binding the contract method 0x06fdde03. -// -// Solidity: function name() view returns(string) -func (_ContractMockERC20 *ContractMockERC20Session) Name() (string, error) { - return _ContractMockERC20.Contract.Name(&_ContractMockERC20.CallOpts) -} - -// Name is a free data retrieval call binding the contract method 0x06fdde03. -// -// Solidity: function name() view returns(string) -func (_ContractMockERC20 *ContractMockERC20CallerSession) Name() (string, error) { - return _ContractMockERC20.Contract.Name(&_ContractMockERC20.CallOpts) -} - -// Symbol is a free data retrieval call binding the contract method 0x95d89b41. -// -// Solidity: function symbol() view returns(string) -func (_ContractMockERC20 *ContractMockERC20Caller) Symbol(opts *bind.CallOpts) (string, error) { - var out []interface{} - err := _ContractMockERC20.contract.Call(opts, &out, "symbol") - - if err != nil { - return *new(string), err - } - - out0 := *abi.ConvertType(out[0], new(string)).(*string) - - return out0, err - -} - -// Symbol is a free data retrieval call binding the contract method 0x95d89b41. -// -// Solidity: function symbol() view returns(string) -func (_ContractMockERC20 *ContractMockERC20Session) Symbol() (string, error) { - return _ContractMockERC20.Contract.Symbol(&_ContractMockERC20.CallOpts) -} - -// Symbol is a free data retrieval call binding the contract method 0x95d89b41. -// -// Solidity: function symbol() view returns(string) -func (_ContractMockERC20 *ContractMockERC20CallerSession) Symbol() (string, error) { - return _ContractMockERC20.Contract.Symbol(&_ContractMockERC20.CallOpts) -} - -// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. -// -// Solidity: function totalSupply() view returns(uint256) -func (_ContractMockERC20 *ContractMockERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _ContractMockERC20.contract.Call(opts, &out, "totalSupply") - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. -// -// Solidity: function totalSupply() view returns(uint256) -func (_ContractMockERC20 *ContractMockERC20Session) TotalSupply() (*big.Int, error) { - return _ContractMockERC20.Contract.TotalSupply(&_ContractMockERC20.CallOpts) -} - -// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. -// -// Solidity: function totalSupply() view returns(uint256) -func (_ContractMockERC20 *ContractMockERC20CallerSession) TotalSupply() (*big.Int, error) { - return _ContractMockERC20.Contract.TotalSupply(&_ContractMockERC20.CallOpts) -} - -// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. -// -// Solidity: function approve(address spender, uint256 amount) returns(bool) -func (_ContractMockERC20 *ContractMockERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.contract.Transact(opts, "approve", spender, amount) -} - -// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. -// -// Solidity: function approve(address spender, uint256 amount) returns(bool) -func (_ContractMockERC20 *ContractMockERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.Contract.Approve(&_ContractMockERC20.TransactOpts, spender, amount) -} - -// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. -// -// Solidity: function approve(address spender, uint256 amount) returns(bool) -func (_ContractMockERC20 *ContractMockERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.Contract.Approve(&_ContractMockERC20.TransactOpts, spender, amount) -} - -// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. -// -// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) -func (_ContractMockERC20 *ContractMockERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) -} - -// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. -// -// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) -func (_ContractMockERC20 *ContractMockERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.Contract.DecreaseAllowance(&_ContractMockERC20.TransactOpts, spender, subtractedValue) -} - -// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. -// -// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) -func (_ContractMockERC20 *ContractMockERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.Contract.DecreaseAllowance(&_ContractMockERC20.TransactOpts, spender, subtractedValue) -} - -// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. -// -// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) -func (_ContractMockERC20 *ContractMockERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.contract.Transact(opts, "increaseAllowance", spender, addedValue) -} - -// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. -// -// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) -func (_ContractMockERC20 *ContractMockERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.Contract.IncreaseAllowance(&_ContractMockERC20.TransactOpts, spender, addedValue) -} - -// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. -// -// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) -func (_ContractMockERC20 *ContractMockERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.Contract.IncreaseAllowance(&_ContractMockERC20.TransactOpts, spender, addedValue) -} - -// Mint is a paid mutator transaction binding the contract method 0x40c10f19. -// -// Solidity: function mint(address account, uint256 amount) returns() -func (_ContractMockERC20 *ContractMockERC20Transactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.contract.Transact(opts, "mint", account, amount) -} - -// Mint is a paid mutator transaction binding the contract method 0x40c10f19. -// -// Solidity: function mint(address account, uint256 amount) returns() -func (_ContractMockERC20 *ContractMockERC20Session) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.Contract.Mint(&_ContractMockERC20.TransactOpts, account, amount) -} - -// Mint is a paid mutator transaction binding the contract method 0x40c10f19. -// -// Solidity: function mint(address account, uint256 amount) returns() -func (_ContractMockERC20 *ContractMockERC20TransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.Contract.Mint(&_ContractMockERC20.TransactOpts, account, amount) -} - -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address to, uint256 amount) returns(bool) -func (_ContractMockERC20 *ContractMockERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.contract.Transact(opts, "transfer", to, amount) -} - -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address to, uint256 amount) returns(bool) -func (_ContractMockERC20 *ContractMockERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.Contract.Transfer(&_ContractMockERC20.TransactOpts, to, amount) -} - -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address to, uint256 amount) returns(bool) -func (_ContractMockERC20 *ContractMockERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.Contract.Transfer(&_ContractMockERC20.TransactOpts, to, amount) -} - -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) -func (_ContractMockERC20 *ContractMockERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.contract.Transact(opts, "transferFrom", from, to, amount) -} - -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) -func (_ContractMockERC20 *ContractMockERC20Session) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.Contract.TransferFrom(&_ContractMockERC20.TransactOpts, from, to, amount) -} - -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) -func (_ContractMockERC20 *ContractMockERC20TransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractMockERC20.Contract.TransferFrom(&_ContractMockERC20.TransactOpts, from, to, amount) -} - -// ContractMockERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ContractMockERC20 contract. -type ContractMockERC20ApprovalIterator struct { - Event *ContractMockERC20Approval // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ContractMockERC20ApprovalIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ContractMockERC20Approval) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ContractMockERC20Approval) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractMockERC20ApprovalIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractMockERC20ApprovalIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractMockERC20Approval represents a Approval event raised by the ContractMockERC20 contract. -type ContractMockERC20Approval struct { - Owner common.Address - Spender common.Address - Value *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. -// -// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) -func (_ContractMockERC20 *ContractMockERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ContractMockERC20ApprovalIterator, error) { - - var ownerRule []interface{} - for _, ownerItem := range owner { - ownerRule = append(ownerRule, ownerItem) - } - var spenderRule []interface{} - for _, spenderItem := range spender { - spenderRule = append(spenderRule, spenderItem) - } - - logs, sub, err := _ContractMockERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) - if err != nil { - return nil, err - } - return &ContractMockERC20ApprovalIterator{contract: _ContractMockERC20.contract, event: "Approval", logs: logs, sub: sub}, nil -} - -// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. -// -// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) -func (_ContractMockERC20 *ContractMockERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ContractMockERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { - - var ownerRule []interface{} - for _, ownerItem := range owner { - ownerRule = append(ownerRule, ownerItem) - } - var spenderRule []interface{} - for _, spenderItem := range spender { - spenderRule = append(spenderRule, spenderItem) - } - - logs, sub, err := _ContractMockERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ContractMockERC20Approval) - if err := _ContractMockERC20.contract.UnpackLog(event, "Approval", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. -// -// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) -func (_ContractMockERC20 *ContractMockERC20Filterer) ParseApproval(log types.Log) (*ContractMockERC20Approval, error) { - event := new(ContractMockERC20Approval) - if err := _ContractMockERC20.contract.UnpackLog(event, "Approval", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractMockERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ContractMockERC20 contract. -type ContractMockERC20TransferIterator struct { - Event *ContractMockERC20Transfer // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ContractMockERC20TransferIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ContractMockERC20Transfer) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ContractMockERC20Transfer) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractMockERC20TransferIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractMockERC20TransferIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractMockERC20Transfer represents a Transfer event raised by the ContractMockERC20 contract. -type ContractMockERC20Transfer struct { - From common.Address - To common.Address - Value *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. -// -// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) -func (_ContractMockERC20 *ContractMockERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ContractMockERC20TransferIterator, error) { - - var fromRule []interface{} - for _, fromItem := range from { - fromRule = append(fromRule, fromItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ContractMockERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) - if err != nil { - return nil, err - } - return &ContractMockERC20TransferIterator{contract: _ContractMockERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil -} - -// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. -// -// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) -func (_ContractMockERC20 *ContractMockERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ContractMockERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { - - var fromRule []interface{} - for _, fromItem := range from { - fromRule = append(fromRule, fromItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ContractMockERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ContractMockERC20Transfer) - if err := _ContractMockERC20.contract.UnpackLog(event, "Transfer", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. -// -// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) -func (_ContractMockERC20 *ContractMockERC20Filterer) ParseTransfer(log types.Log) (*ContractMockERC20Transfer, error) { - event := new(ContractMockERC20Transfer) - if err := _ContractMockERC20.contract.UnpackLog(event, "Transfer", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} From 3b4ae7643b7de7cb9f3d31b30fc8c25ce9a0d498 Mon Sep 17 00:00:00 2001 From: ricomateo Date: Tue, 14 Jan 2025 14:54:11 -0300 Subject: [PATCH 18/28] add MockERC20 bindings --- contracts/bindings/MockERC20/binding.go | 883 ++++++++++++++++++++++++ 1 file changed, 883 insertions(+) create mode 100644 contracts/bindings/MockERC20/binding.go diff --git a/contracts/bindings/MockERC20/binding.go b/contracts/bindings/MockERC20/binding.go new file mode 100644 index 00000000..de7fc24b --- /dev/null +++ b/contracts/bindings/MockERC20/binding.go @@ -0,0 +1,883 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package contractMockERC20 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ContractMockERC20MetaData contains all meta data concerning the ContractMockERC20 contract. +var ContractMockERC20MetaData = &bind.MetaData{ + ABI: "[{\"type\":\"function\",\"name\":\"allowance\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"approve\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"balanceOf\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decimals\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"subtractedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"increaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"addedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"mint\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"name\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"symbol\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"totalSupply\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transfer\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferFrom\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Approval\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Transfer\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false}]", + Bin: "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", +} + +// ContractMockERC20ABI is the input ABI used to generate the binding from. +// Deprecated: Use ContractMockERC20MetaData.ABI instead. +var ContractMockERC20ABI = ContractMockERC20MetaData.ABI + +// ContractMockERC20Bin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ContractMockERC20MetaData.Bin instead. +var ContractMockERC20Bin = ContractMockERC20MetaData.Bin + +// DeployContractMockERC20 deploys a new Ethereum contract, binding an instance of ContractMockERC20 to it. +func DeployContractMockERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ContractMockERC20, error) { + parsed, err := ContractMockERC20MetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ContractMockERC20Bin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &ContractMockERC20{ContractMockERC20Caller: ContractMockERC20Caller{contract: contract}, ContractMockERC20Transactor: ContractMockERC20Transactor{contract: contract}, ContractMockERC20Filterer: ContractMockERC20Filterer{contract: contract}}, nil +} + +// ContractMockERC20Methods is an auto generated interface around an Ethereum contract. +type ContractMockERC20Methods interface { + ContractMockERC20Calls + ContractMockERC20Transacts + ContractMockERC20Filters +} + +// ContractMockERC20Calls is an auto generated interface that defines the call methods available for an Ethereum contract. +type ContractMockERC20Calls interface { + Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) + + BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) + + Decimals(opts *bind.CallOpts) (uint8, error) + + Name(opts *bind.CallOpts) (string, error) + + Symbol(opts *bind.CallOpts) (string, error) + + TotalSupply(opts *bind.CallOpts) (*big.Int, error) +} + +// ContractMockERC20Transacts is an auto generated interface that defines the transact methods available for an Ethereum contract. +type ContractMockERC20Transacts interface { + Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) + + DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) + + IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) + + Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) + + Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) + + TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) +} + +// ContractMockERC20Filterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. +type ContractMockERC20Filters interface { + FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ContractMockERC20ApprovalIterator, error) + WatchApproval(opts *bind.WatchOpts, sink chan<- *ContractMockERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) + ParseApproval(log types.Log) (*ContractMockERC20Approval, error) + + FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ContractMockERC20TransferIterator, error) + WatchTransfer(opts *bind.WatchOpts, sink chan<- *ContractMockERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) + ParseTransfer(log types.Log) (*ContractMockERC20Transfer, error) +} + +// ContractMockERC20 is an auto generated Go binding around an Ethereum contract. +type ContractMockERC20 struct { + ContractMockERC20Caller // Read-only binding to the contract + ContractMockERC20Transactor // Write-only binding to the contract + ContractMockERC20Filterer // Log filterer for contract events +} + +// ContractMockERC20 implements the ContractMockERC20Methods interface. +var _ ContractMockERC20Methods = (*ContractMockERC20)(nil) + +// ContractMockERC20Caller is an auto generated read-only Go binding around an Ethereum contract. +type ContractMockERC20Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ContractMockERC20Caller implements the ContractMockERC20Calls interface. +var _ ContractMockERC20Calls = (*ContractMockERC20Caller)(nil) + +// ContractMockERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. +type ContractMockERC20Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ContractMockERC20Transactor implements the ContractMockERC20Transacts interface. +var _ ContractMockERC20Transacts = (*ContractMockERC20Transactor)(nil) + +// ContractMockERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ContractMockERC20Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ContractMockERC20Filterer implements the ContractMockERC20Filters interface. +var _ ContractMockERC20Filters = (*ContractMockERC20Filterer)(nil) + +// ContractMockERC20Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ContractMockERC20Session struct { + Contract *ContractMockERC20 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ContractMockERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ContractMockERC20CallerSession struct { + Contract *ContractMockERC20Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ContractMockERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ContractMockERC20TransactorSession struct { + Contract *ContractMockERC20Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ContractMockERC20Raw is an auto generated low-level Go binding around an Ethereum contract. +type ContractMockERC20Raw struct { + Contract *ContractMockERC20 // Generic contract binding to access the raw methods on +} + +// ContractMockERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ContractMockERC20CallerRaw struct { + Contract *ContractMockERC20Caller // Generic read-only contract binding to access the raw methods on +} + +// ContractMockERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ContractMockERC20TransactorRaw struct { + Contract *ContractMockERC20Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewContractMockERC20 creates a new instance of ContractMockERC20, bound to a specific deployed contract. +func NewContractMockERC20(address common.Address, backend bind.ContractBackend) (*ContractMockERC20, error) { + contract, err := bindContractMockERC20(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ContractMockERC20{ContractMockERC20Caller: ContractMockERC20Caller{contract: contract}, ContractMockERC20Transactor: ContractMockERC20Transactor{contract: contract}, ContractMockERC20Filterer: ContractMockERC20Filterer{contract: contract}}, nil +} + +// NewContractMockERC20Caller creates a new read-only instance of ContractMockERC20, bound to a specific deployed contract. +func NewContractMockERC20Caller(address common.Address, caller bind.ContractCaller) (*ContractMockERC20Caller, error) { + contract, err := bindContractMockERC20(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ContractMockERC20Caller{contract: contract}, nil +} + +// NewContractMockERC20Transactor creates a new write-only instance of ContractMockERC20, bound to a specific deployed contract. +func NewContractMockERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ContractMockERC20Transactor, error) { + contract, err := bindContractMockERC20(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ContractMockERC20Transactor{contract: contract}, nil +} + +// NewContractMockERC20Filterer creates a new log filterer instance of ContractMockERC20, bound to a specific deployed contract. +func NewContractMockERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ContractMockERC20Filterer, error) { + contract, err := bindContractMockERC20(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ContractMockERC20Filterer{contract: contract}, nil +} + +// bindContractMockERC20 binds a generic wrapper to an already deployed contract. +func bindContractMockERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ContractMockERC20MetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ContractMockERC20 *ContractMockERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ContractMockERC20.Contract.ContractMockERC20Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ContractMockERC20 *ContractMockERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ContractMockERC20.Contract.ContractMockERC20Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ContractMockERC20 *ContractMockERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ContractMockERC20.Contract.ContractMockERC20Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ContractMockERC20 *ContractMockERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ContractMockERC20.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ContractMockERC20 *ContractMockERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ContractMockERC20.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ContractMockERC20 *ContractMockERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ContractMockERC20.Contract.contract.Transact(opts, method, params...) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _ContractMockERC20.contract.Call(opts, &out, "allowance", owner, spender) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _ContractMockERC20.Contract.Allowance(&_ContractMockERC20.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _ContractMockERC20.Contract.Allowance(&_ContractMockERC20.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { + var out []interface{} + err := _ContractMockERC20.contract.Call(opts, &out, "balanceOf", account) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20Session) BalanceOf(account common.Address) (*big.Int, error) { + return _ContractMockERC20.Contract.BalanceOf(&_ContractMockERC20.CallOpts, account) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { + return _ContractMockERC20.Contract.BalanceOf(&_ContractMockERC20.CallOpts, account) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_ContractMockERC20 *ContractMockERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _ContractMockERC20.contract.Call(opts, &out, "decimals") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_ContractMockERC20 *ContractMockERC20Session) Decimals() (uint8, error) { + return _ContractMockERC20.Contract.Decimals(&_ContractMockERC20.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_ContractMockERC20 *ContractMockERC20CallerSession) Decimals() (uint8, error) { + return _ContractMockERC20.Contract.Decimals(&_ContractMockERC20.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_ContractMockERC20 *ContractMockERC20Caller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _ContractMockERC20.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_ContractMockERC20 *ContractMockERC20Session) Name() (string, error) { + return _ContractMockERC20.Contract.Name(&_ContractMockERC20.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_ContractMockERC20 *ContractMockERC20CallerSession) Name() (string, error) { + return _ContractMockERC20.Contract.Name(&_ContractMockERC20.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_ContractMockERC20 *ContractMockERC20Caller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _ContractMockERC20.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_ContractMockERC20 *ContractMockERC20Session) Symbol() (string, error) { + return _ContractMockERC20.Contract.Symbol(&_ContractMockERC20.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_ContractMockERC20 *ContractMockERC20CallerSession) Symbol() (string, error) { + return _ContractMockERC20.Contract.Symbol(&_ContractMockERC20.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _ContractMockERC20.contract.Call(opts, &out, "totalSupply") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20Session) TotalSupply() (*big.Int, error) { + return _ContractMockERC20.Contract.TotalSupply(&_ContractMockERC20.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ContractMockERC20 *ContractMockERC20CallerSession) TotalSupply() (*big.Int, error) { + return _ContractMockERC20.Contract.TotalSupply(&_ContractMockERC20.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.contract.Transact(opts, "approve", spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.Approve(&_ContractMockERC20.TransactOpts, spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.Approve(&_ContractMockERC20.TransactOpts, spender, amount) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.DecreaseAllowance(&_ContractMockERC20.TransactOpts, spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_ContractMockERC20 *ContractMockERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.DecreaseAllowance(&_ContractMockERC20.TransactOpts, spender, subtractedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.contract.Transact(opts, "increaseAllowance", spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.IncreaseAllowance(&_ContractMockERC20.TransactOpts, spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_ContractMockERC20 *ContractMockERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.IncreaseAllowance(&_ContractMockERC20.TransactOpts, spender, addedValue) +} + +// Mint is a paid mutator transaction binding the contract method 0x40c10f19. +// +// Solidity: function mint(address account, uint256 amount) returns() +func (_ContractMockERC20 *ContractMockERC20Transactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.contract.Transact(opts, "mint", account, amount) +} + +// Mint is a paid mutator transaction binding the contract method 0x40c10f19. +// +// Solidity: function mint(address account, uint256 amount) returns() +func (_ContractMockERC20 *ContractMockERC20Session) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.Mint(&_ContractMockERC20.TransactOpts, account, amount) +} + +// Mint is a paid mutator transaction binding the contract method 0x40c10f19. +// +// Solidity: function mint(address account, uint256 amount) returns() +func (_ContractMockERC20 *ContractMockERC20TransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.Mint(&_ContractMockERC20.TransactOpts, account, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.contract.Transact(opts, "transfer", to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.Transfer(&_ContractMockERC20.TransactOpts, to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.Transfer(&_ContractMockERC20.TransactOpts, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.contract.Transact(opts, "transferFrom", from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20Session) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.TransferFrom(&_ContractMockERC20.TransactOpts, from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_ContractMockERC20 *ContractMockERC20TransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ContractMockERC20.Contract.TransferFrom(&_ContractMockERC20.TransactOpts, from, to, amount) +} + +// ContractMockERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ContractMockERC20 contract. +type ContractMockERC20ApprovalIterator struct { + Event *ContractMockERC20Approval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractMockERC20ApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractMockERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractMockERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractMockERC20ApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractMockERC20ApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractMockERC20Approval represents a Approval event raised by the ContractMockERC20 contract. +type ContractMockERC20Approval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ContractMockERC20 *ContractMockERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ContractMockERC20ApprovalIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _ContractMockERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &ContractMockERC20ApprovalIterator{contract: _ContractMockERC20.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ContractMockERC20 *ContractMockERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ContractMockERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _ContractMockERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractMockERC20Approval) + if err := _ContractMockERC20.contract.UnpackLog(event, "Approval", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ContractMockERC20 *ContractMockERC20Filterer) ParseApproval(log types.Log) (*ContractMockERC20Approval, error) { + event := new(ContractMockERC20Approval) + if err := _ContractMockERC20.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractMockERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ContractMockERC20 contract. +type ContractMockERC20TransferIterator struct { + Event *ContractMockERC20Transfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractMockERC20TransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractMockERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractMockERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractMockERC20TransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractMockERC20TransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractMockERC20Transfer represents a Transfer event raised by the ContractMockERC20 contract. +type ContractMockERC20Transfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ContractMockERC20 *ContractMockERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ContractMockERC20TransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ContractMockERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &ContractMockERC20TransferIterator{contract: _ContractMockERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ContractMockERC20 *ContractMockERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ContractMockERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ContractMockERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractMockERC20Transfer) + if err := _ContractMockERC20.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ContractMockERC20 *ContractMockERC20Filterer) ParseTransfer(log types.Log) (*ContractMockERC20Transfer, error) { + event := new(ContractMockERC20Transfer) + if err := _ContractMockERC20.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} From 30912fe5a259898cb2b075add51bfae21cdd6cee Mon Sep 17 00:00:00 2001 From: ricomateo Date: Tue, 14 Jan 2025 14:56:08 -0300 Subject: [PATCH 19/28] add TestProcessClaim and TestProcessClaims --- chainio/clients/elcontracts/writer_test.go | 242 ++++++++++++++++++++- 1 file changed, 241 insertions(+), 1 deletion(-) diff --git a/chainio/clients/elcontracts/writer_test.go b/chainio/clients/elcontracts/writer_test.go index 7c368de4..aa9d290d 100644 --- a/chainio/clients/elcontracts/writer_test.go +++ b/chainio/clients/elcontracts/writer_test.go @@ -9,14 +9,16 @@ import ( "github.com/Layr-Labs/eigensdk-go/chainio/clients" "github.com/Layr-Labs/eigensdk-go/chainio/clients/elcontracts" allocationmanager "github.com/Layr-Labs/eigensdk-go/contracts/bindings/AllocationManager" - rewardscoordinator "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IRewardsCoordinator" + strategy "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IStrategy" + mockerc20 "github.com/Layr-Labs/eigensdk-go/contracts/bindings/MockERC20" regcoord "github.com/Layr-Labs/eigensdk-go/contracts/bindings/RegistryCoordinator" "github.com/Layr-Labs/eigensdk-go/logging" "github.com/Layr-Labs/eigensdk-go/testutils" "github.com/Layr-Labs/eigensdk-go/testutils/testclients" "github.com/Layr-Labs/eigensdk-go/types" "github.com/Layr-Labs/eigensdk-go/utils" + "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" gethtypes "github.com/ethereum/go-ethereum/core/types" @@ -661,6 +663,244 @@ func TestRemoveAdmin(t *testing.T) { }) } +func TestProcessClaim(t *testing.T) { + testConfig := testutils.GetDefaultTestConfig() + anvilC, err := testutils.StartAnvilContainer(testConfig.AnvilStateFileName) + require.NoError(t, err) + anvilHttpEndpoint, err := anvilC.Endpoint(context.Background(), "http") + require.NoError(t, err) + + privateKeyHex := testutils.ANVIL_FIRST_PRIVATE_KEY + contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint) + + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + config := elcontracts.Config{ + DelegationManagerAddress: contractAddrs.DelegationManager, + RewardsCoordinatorAddress: rewardsCoordinatorAddr, + } + + // Create ChainWriter + chainWriter, err := testclients.NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) + require.NoError(t, err) + + chainReader, err := testclients.NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + require.NoError(t, err) + + activationDelay := uint32(0) + // Set activation delay to zero so that the earnings can be claimed right after submitting the root + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, privateKeyHex, activationDelay) + require.NoError(t, err) + require.Equal(t, gethtypes.ReceiptStatusSuccessful, receipt.Status) + + waitForReceipt := true + cumulativeEarnings := int64(42) + earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") + claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) + require.NoError(t, err) + + receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, waitForReceipt) + require.NoError(t, err) + require.Equal(t, gethtypes.ReceiptStatusSuccessful, receipt.Status) +} + +func TestProcessClaims(t *testing.T) { + testConfig := testutils.GetDefaultTestConfig() + anvilC, err := testutils.StartAnvilContainer(testConfig.AnvilStateFileName) + require.NoError(t, err) + anvilHttpEndpoint, err := anvilC.Endpoint(context.Background(), "http") + require.NoError(t, err) + + privateKeyHex := testutils.ANVIL_FIRST_PRIVATE_KEY + contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint) + + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + config := elcontracts.Config{ + DelegationManagerAddress: contractAddrs.DelegationManager, + RewardsCoordinatorAddress: rewardsCoordinatorAddr, + } + + // Create ChainWriter + chainWriter, err := testclients.NewTestChainWriterFromConfig(anvilHttpEndpoint, privateKeyHex, config) + require.NoError(t, err) + + chainReader, err := testclients.NewTestChainReaderFromConfig(anvilHttpEndpoint, config) + require.NoError(t, err) + + activationDelay := uint32(0) + // Set activation delay to zero so that the earnings can be claimed right after submitting the root + receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, privateKeyHex, activationDelay) + require.NoError(t, err) + require.Equal(t, gethtypes.ReceiptStatusSuccessful, receipt.Status) + + earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") + + waitForReceipt := true + cumulativeEarnings1 := int64(42) + cumulativeEarnings2 := int64(4256) + + // Generate 2 claims + claim1, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings1, privateKeyHex) + require.NoError(t, err) + + claim2, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings2, privateKeyHex) + require.NoError(t, err) + claims := []rewardscoordinator.IRewardsCoordinatorTypesRewardsMerkleClaim{ + *claim1, *claim2, + } + receipt, err = chainWriter.ProcessClaims(context.Background(), claims, earner, waitForReceipt) + require.NoError(t, err) + require.Equal(t, gethtypes.ReceiptStatusSuccessful, receipt.Status) +} + +// Returns a (test) claim for the given cumulativeEarnings, whose earner is +// the account given by the testutils.ANVIL_FIRST_ADDRESS address. +func newTestClaim( + chainReader *elcontracts.ChainReader, + httpEndpoint string, + cumulativeEarnings int64, + privateKeyHex string, +) (*rewardscoordinator.IRewardsCoordinatorTypesRewardsMerkleClaim, error) { + contractAddrs := testutils.GetContractAddressesFromContractRegistry(httpEndpoint) + mockStrategyAddr := contractAddrs.Erc20MockStrategy + rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator + waitForReceipt := true + + ethClient, err := ethclient.Dial(httpEndpoint) + if err != nil { + return nil, utils.WrapError("Failed to create eth client", err) + } + + txManager, err := testclients.NewTestTxManager(httpEndpoint, privateKeyHex) + if err != nil { + return nil, utils.WrapError("Failed to create tx manager", err) + } + + contractStrategy, err := strategy.NewContractIStrategy(mockStrategyAddr, ethClient) + if err != nil { + return nil, utils.WrapError("Failed to fetch strategy contract", err) + } + + tokenAddr, err := contractStrategy.UnderlyingToken(&bind.CallOpts{Context: context.Background()}) + if err != nil { + return nil, utils.WrapError("Failed to fetch token address", err) + } + + token, err := mockerc20.NewContractMockERC20(tokenAddr, ethClient) + if err != nil { + return nil, utils.WrapError("Failed to create token contract", err) + } + + noSendTxOpts, err := txManager.GetNoSendTxOpts() + if err != nil { + return nil, utils.WrapError("Failed to get NoSend tx opts", err) + } + + // Mint tokens for the RewardsCoordinator + tx, err := token.Mint(noSendTxOpts, rewardsCoordinatorAddr, big.NewInt(cumulativeEarnings)) + if err != nil { + return nil, utils.WrapError("Failed to create Mint tx", err) + } + + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + if err != nil { + return nil, utils.WrapError("Failed to mint tokens for RewardsCoordinator", err) + } + + // Generate token tree leaf + // For the tree structure, see + // https://github.com/Layr-Labs/eigenlayer-contracts/blob/a888a1cd1479438dda4b138245a69177b125a973/docs/core/RewardsCoordinator.md#rewards-merkle-tree-structure + earnerAddr := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS) + tokenLeaf := rewardscoordinator.IRewardsCoordinatorTypesTokenTreeMerkleLeaf{ + Token: tokenAddr, + CumulativeEarnings: big.NewInt(cumulativeEarnings), + } + encodedTokenLeaf := []byte{} + tokenLeafSalt := uint8(1) + + // Write the *big.Int to a 32-byte sized buffer to match the uint256 length + cumulativeEarningsBytes := [32]byte{} + tokenLeaf.CumulativeEarnings.FillBytes(cumulativeEarningsBytes[:]) + + encodedTokenLeaf = append(encodedTokenLeaf, tokenLeafSalt) + encodedTokenLeaf = append(encodedTokenLeaf, tokenLeaf.Token.Bytes()...) + encodedTokenLeaf = append(encodedTokenLeaf, cumulativeEarningsBytes[:]...) + + // Hash token tree leaf to get root + earnerTokenRoot := crypto.Keccak256(encodedTokenLeaf) + + // Generate earner tree leaf + earnerLeaf := rewardscoordinator.IRewardsCoordinatorTypesEarnerTreeMerkleLeaf{ + Earner: earnerAddr, + EarnerTokenRoot: [32]byte(earnerTokenRoot), + } + // Encode earner leaft + encodedEarnerLeaf := []byte{} + earnerLeafSalt := uint8(0) + encodedEarnerLeaf = append(encodedEarnerLeaf, earnerLeafSalt) + encodedEarnerLeaf = append(encodedEarnerLeaf, earnerLeaf.Earner.Bytes()...) + encodedEarnerLeaf = append(encodedEarnerLeaf, earnerTokenRoot...) + + // Hash encoded earner tree leaf to get root + earnerTreeRoot := crypto.Keccak256(encodedEarnerLeaf) + + // Fetch the next root index from contract + nextRootIndex, err := chainReader.GetDistributionRootsLength(context.Background()) + if err != nil { + return nil, utils.WrapError("Failed to call GetDistributionRootsLength", err) + } + + tokenLeaves := []rewardscoordinator.IRewardsCoordinatorTypesTokenTreeMerkleLeaf{tokenLeaf} + // Construct the claim + claim := rewardscoordinator.IRewardsCoordinatorTypesRewardsMerkleClaim{ + RootIndex: uint32(nextRootIndex.Uint64()), + EarnerIndex: 0, + // Empty proof because leaf == root + EarnerTreeProof: []byte{}, + EarnerLeaf: earnerLeaf, + TokenIndices: []uint32{0}, + // Empty proof because leaf == root + TokenTreeProofs: [][]byte{{}}, + TokenLeaves: tokenLeaves, + } + + root := [32]byte(earnerTreeRoot) + // Fetch the current timestamp to increase it + currRewardsCalculationEndTimestamp, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) + if err != nil { + return nil, utils.WrapError("Failed to call CurrRewardsCalculationEndTimestamp", err) + } + + rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) + if err != nil { + return nil, utils.WrapError("Failed to create rewards coordinator contract", err) + } + + rewardsUpdater := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS) + + // Change the rewards updater to be able to submit the new root + tx, err = rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) + if err != nil { + return nil, utils.WrapError("Failed to create SetRewardsUpdater tx", err) + } + + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + if err != nil { + return nil, utils.WrapError("Failed to setRewardsUpdate", err) + } + + tx, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) + if err != nil { + return nil, utils.WrapError("Failed to create SubmitRoot tx", err) + } + + _, err = txManager.Send(context.Background(), tx, waitForReceipt) + if err != nil { + return nil, utils.WrapError("Failed to submit root", err) + } + + return &claim, nil +} + // Creates an operator set with `avsAddress`, `operatorSetId` and `erc20MockStrategyAddr`. func createOperatorSet( anvilHttpEndpoint string, From a4644232ea2e211707528fb1a495fe7de38c3897 Mon Sep 17 00:00:00 2001 From: ricomateo Date: Tue, 14 Jan 2025 15:09:28 -0300 Subject: [PATCH 20/28] mention the rust sdk in newTestClaim function --- chainio/clients/elcontracts/writer_test.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/chainio/clients/elcontracts/writer_test.go b/chainio/clients/elcontracts/writer_test.go index aa9d290d..b794662f 100644 --- a/chainio/clients/elcontracts/writer_test.go +++ b/chainio/clients/elcontracts/writer_test.go @@ -754,6 +754,8 @@ func TestProcessClaims(t *testing.T) { // Returns a (test) claim for the given cumulativeEarnings, whose earner is // the account given by the testutils.ANVIL_FIRST_ADDRESS address. +// This was taken from the eigensdk-rs +// https://github.com/Layr-Labs/eigensdk-rs/blob/d79b3672584b92f3c5fb204fde6bea394fbf0f12/crates/chainio/clients/elcontracts/src/lib.rs#L146 func newTestClaim( chainReader *elcontracts.ChainReader, httpEndpoint string, From 66bfaf2193b43561b9c9f5c9a938c076d0ea5ff3 Mon Sep 17 00:00:00 2001 From: ricomateo Date: Tue, 14 Jan 2025 16:53:07 -0300 Subject: [PATCH 21/28] increase tests timeout --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 742aca3c..e36cf383 100644 --- a/Makefile +++ b/Makefile @@ -19,7 +19,7 @@ mocks: ## generates mocks .PHONY: tests tests: ## runs all tests - go test -race ./... -timeout=3m + go test -race ./... -timeout=4m .PHONY: tests-cover tests-cover: ## run all tests with test coverge From e77e8e83aed709e2c9b5e64547dfa88281fc6f54 Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Mon, 13 Jan 2025 18:35:30 -0300 Subject: [PATCH 22/28] Remove duplicated test case --- chainio/clients/elcontracts/reader_test.go | 156 --------------------- 1 file changed, 156 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index daf97fe7..351101e3 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -8,15 +8,11 @@ import ( "github.com/Layr-Labs/eigensdk-go/chainio/clients/elcontracts" erc20 "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IERC20" rewardscoordinator "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IRewardsCoordinator" - strategy "github.com/Layr-Labs/eigensdk-go/contracts/bindings/IStrategy" - mockerc20 "github.com/Layr-Labs/eigensdk-go/contracts/bindings/MockERC20" "github.com/Layr-Labs/eigensdk-go/testutils" "github.com/Layr-Labs/eigensdk-go/testutils/testclients" "github.com/Layr-Labs/eigensdk-go/types" - "github.com/Layr-Labs/eigensdk-go/utils" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -430,155 +426,3 @@ func TestCheckClaim(t *testing.T) { require.NoError(t, err) assert.True(t, checked) } - -// The functions below will be replaced for those placed in testutils/testclients/testclients.go - -// Returns a (test) claim for the given cumulativeEarnings, whose earner is -// the account given by the testutils.ANVIL_FIRST_ADDRESS address. -func newTestClaim( - chainReader *elcontracts.ChainReader, - httpEndpoint string, - cumulativeEarnings int64, - privateKeyHex string, -) (*rewardscoordinator.IRewardsCoordinatorTypesRewardsMerkleClaim, error) { - contractAddrs := testutils.GetContractAddressesFromContractRegistry(httpEndpoint) - mockStrategyAddr := contractAddrs.Erc20MockStrategy - rewardsCoordinatorAddr := contractAddrs.RewardsCoordinator - waitForReceipt := true - - ethClient, err := ethclient.Dial(httpEndpoint) - if err != nil { - return nil, utils.WrapError("Failed to create eth client", err) - } - - txManager, err := testclients.NewTestTxManager(httpEndpoint, privateKeyHex) - if err != nil { - return nil, utils.WrapError("Failed to create tx manager", err) - } - - contractStrategy, err := strategy.NewContractIStrategy(mockStrategyAddr, ethClient) - if err != nil { - return nil, utils.WrapError("Failed to fetch strategy contract", err) - } - - tokenAddr, err := contractStrategy.UnderlyingToken(&bind.CallOpts{Context: context.Background()}) - if err != nil { - return nil, utils.WrapError("Failed to fetch token address", err) - } - - token, err := mockerc20.NewContractMockERC20(tokenAddr, ethClient) - - if err != nil { - return nil, utils.WrapError("Failed to create token contract", err) - } - - noSendTxOpts, err := txManager.GetNoSendTxOpts() - if err != nil { - return nil, utils.WrapError("Failed to get NoSend tx opts", err) - } - - // Mint tokens for the RewardsCoordinator - tx, err := token.Mint(noSendTxOpts, rewardsCoordinatorAddr, big.NewInt(cumulativeEarnings)) - if err != nil { - return nil, utils.WrapError("Failed to create Mint tx", err) - } - - _, err = txManager.Send(context.Background(), tx, waitForReceipt) - if err != nil { - return nil, utils.WrapError("Failed to mint tokens for RewardsCoordinator", err) - } - - // Generate token tree leaf - // For the tree structure, see - // https://github.com/Layr-Labs/eigenlayer-contracts/blob/a888a1cd1479438dda4b138245a69177b125a973/docs/core/RewardsCoordinator.md#rewards-merkle-tree-structure - earnerAddr := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS) - tokenLeaf := rewardscoordinator.IRewardsCoordinatorTypesTokenTreeMerkleLeaf{ - Token: tokenAddr, - CumulativeEarnings: big.NewInt(cumulativeEarnings), - } - encodedTokenLeaf := []byte{} - tokenLeafSalt := uint8(1) - - // Write the *big.Int to a 32-byte sized buffer to match the uint256 length - cumulativeEarningsBytes := [32]byte{} - tokenLeaf.CumulativeEarnings.FillBytes(cumulativeEarningsBytes[:]) - - encodedTokenLeaf = append(encodedTokenLeaf, tokenLeafSalt) - encodedTokenLeaf = append(encodedTokenLeaf, tokenLeaf.Token.Bytes()...) - encodedTokenLeaf = append(encodedTokenLeaf, cumulativeEarningsBytes[:]...) - - // Hash token tree leaf to get root - earnerTokenRoot := crypto.Keccak256(encodedTokenLeaf) - - // Generate earner tree leaf - earnerLeaf := rewardscoordinator.IRewardsCoordinatorTypesEarnerTreeMerkleLeaf{ - Earner: earnerAddr, - EarnerTokenRoot: [32]byte(earnerTokenRoot), - } - // Encode earner leaft - encodedEarnerLeaf := []byte{} - earnerLeafSalt := uint8(0) - encodedEarnerLeaf = append(encodedEarnerLeaf, earnerLeafSalt) - encodedEarnerLeaf = append(encodedEarnerLeaf, earnerLeaf.Earner.Bytes()...) - encodedEarnerLeaf = append(encodedEarnerLeaf, earnerTokenRoot...) - - // Hash encoded earner tree leaf to get root - earnerTreeRoot := crypto.Keccak256(encodedEarnerLeaf) - - // Fetch the next root index from contract - nextRootIndex, err := chainReader.GetDistributionRootsLength(context.Background()) - if err != nil { - return nil, utils.WrapError("Failed to call GetDistributionRootsLength", err) - } - - tokenLeaves := []rewardscoordinator.IRewardsCoordinatorTypesTokenTreeMerkleLeaf{tokenLeaf} - // Construct the claim - claim := rewardscoordinator.IRewardsCoordinatorTypesRewardsMerkleClaim{ - RootIndex: uint32(nextRootIndex.Uint64()), - EarnerIndex: 0, - // Empty proof because leaf == root - EarnerTreeProof: []byte{}, - EarnerLeaf: earnerLeaf, - TokenIndices: []uint32{0}, - // Empty proof because leaf == root - TokenTreeProofs: [][]byte{{}}, - TokenLeaves: tokenLeaves, - } - - root := [32]byte(earnerTreeRoot) - // Fetch the current timestamp to increase it - currRewardsCalculationEndTimestamp, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background()) - if err != nil { - return nil, utils.WrapError("Failed to call CurrRewardsCalculationEndTimestamp", err) - } - - rewardsCoordinator, err := rewardscoordinator.NewContractIRewardsCoordinator(rewardsCoordinatorAddr, ethClient) - if err != nil { - return nil, utils.WrapError("Failed to create rewards coordinator contract", err) - } - - rewardsUpdater := common.HexToAddress(testutils.ANVIL_FIRST_ADDRESS) - - // Change the rewards updater to be able to submit the new root - tx, err = rewardsCoordinator.SetRewardsUpdater(noSendTxOpts, rewardsUpdater) - if err != nil { - return nil, utils.WrapError("Failed to create SetRewardsUpdater tx", err) - } - - _, err = txManager.Send(context.Background(), tx, waitForReceipt) - if err != nil { - return nil, utils.WrapError("Failed to setRewardsUpdate", err) - } - - tx, err = rewardsCoordinator.SubmitRoot(noSendTxOpts, root, currRewardsCalculationEndTimestamp+1) - if err != nil { - return nil, utils.WrapError("Failed to create SubmitRoot tx", err) - } - - _, err = txManager.Send(context.Background(), tx, waitForReceipt) - if err != nil { - return nil, utils.WrapError("Failed to submit root", err) - } - - return &claim, nil -} From 8bcf88d00e321887d6c7240bcaf0c89e214fae76 Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Wed, 15 Jan 2025 12:00:57 -0300 Subject: [PATCH 23/28] Use ReceiptStatusSuccessful constant from gethtypes --- chainio/clients/elcontracts/reader_test.go | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index 351101e3..640991bc 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -13,6 +13,7 @@ import ( "github.com/Layr-Labs/eigensdk-go/types" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" + gethtypes "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -176,7 +177,7 @@ func TestGetCurrentClaimableDistributionRoot(t *testing.T) { // Set delay to zero to inmediatly operate with coordinator receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, ecdsaPrivKeyHex, uint32(0)) require.NoError(t, err) - require.Equal(t, receipt.Status, uint64(1)) + require.Equal(t, receipt.Status, gethtypes.ReceiptStatusSuccessful) // Create txManager to send transactions to the Ethereum node txManager, err := testclients.NewTestTxManager(anvilHttpEndpoint, ecdsaPrivKeyHex) @@ -243,7 +244,7 @@ func TestGetRootIndexFromRootHash(t *testing.T) { // Set delay to zero to inmediatly operate with coordinator receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, ecdsaPrivKeyHex, uint32(0)) require.NoError(t, err) - require.Equal(t, receipt.Status, uint64(1)) + require.Equal(t, receipt.Status, gethtypes.ReceiptStatusSuccessful) // Create txManager to send transactions to the Ethereum node txManager, err := testclients.NewTestTxManager(anvilHttpEndpoint, ecdsaPrivKeyHex) @@ -343,7 +344,7 @@ func TestGetCumulativeClaimedRewards(t *testing.T) { // Set activation delay to zero so that the earnings can be claimed right after submitting the root receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, privateKeyHex, activationDelay) require.NoError(t, err) - require.True(t, receipt.Status == uint64(1)) + require.True(t, receipt.Status == gethtypes.ReceiptStatusSuccessful) strategyAddr := contractAddrs.Erc20MockStrategy strategy, contractUnderlyingToken, underlyingTokenAddr, err := clients.ElChainReader.GetStrategyAndUnderlyingERC20Token( @@ -369,7 +370,7 @@ func TestGetCumulativeClaimedRewards(t *testing.T) { earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) require.NoError(t, err) - require.True(t, receipt.Status == uint64(1)) + require.True(t, receipt.Status == gethtypes.ReceiptStatusSuccessful) // This tests that with a claim result is cumulativeEarnings claimed, err = chainReader.GetCumulativeClaimed(ctx, anvil_address, underlyingTokenAddr) @@ -401,7 +402,7 @@ func TestCheckClaim(t *testing.T) { // Set activation delay to zero so that the earnings can be claimed right after submitting the root receipt, err := setTestRewardsCoordinatorActivationDelay(anvilHttpEndpoint, privateKeyHex, activationDelay) require.NoError(t, err) - require.True(t, receipt.Status == uint64(1)) + require.True(t, receipt.Status == gethtypes.ReceiptStatusSuccessful) cumulativeEarnings := int64(45) claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) @@ -410,7 +411,7 @@ func TestCheckClaim(t *testing.T) { earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) require.NoError(t, err) - require.True(t, receipt.Status == uint64(1)) + require.True(t, receipt.Status == gethtypes.ReceiptStatusSuccessful) strategyAddr := contractAddrs.Erc20MockStrategy strategy, contractUnderlyingToken, underlyingTokenAddr, err := clients.ElChainReader.GetStrategyAndUnderlyingERC20Token( From 7e280af965dd4c4a6a55d0f7cc2f7e371ed2d52b Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Wed, 15 Jan 2025 12:25:27 -0300 Subject: [PATCH 24/28] Add RewardsCoordinator address as constant --- chainio/clients/elcontracts/reader_test.go | 4 ++-- testutils/anvil.go | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index 640991bc..5cdb168e 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -367,7 +367,7 @@ func TestGetCumulativeClaimedRewards(t *testing.T) { claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) require.NoError(t, err) - earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") + earner := common.HexToAddress(testutils.REWARDS_COORDINATOR_ADDRESS) receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) require.NoError(t, err) require.True(t, receipt.Status == gethtypes.ReceiptStatusSuccessful) @@ -408,7 +408,7 @@ func TestCheckClaim(t *testing.T) { claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) require.NoError(t, err) - earner := common.HexToAddress("0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6") + earner := common.HexToAddress(testutils.REWARDS_COORDINATOR_ADDRESS) receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) require.NoError(t, err) require.True(t, receipt.Status == gethtypes.ReceiptStatusSuccessful) diff --git a/testutils/anvil.go b/testutils/anvil.go index 592c5758..947f759d 100644 --- a/testutils/anvil.go +++ b/testutils/anvil.go @@ -22,6 +22,8 @@ import ( const ANVIL_FIRST_ADDRESS = "f39Fd6e51aad88F6F4ce6aB8827279cffFb92266" const ANVIL_FIRST_PRIVATE_KEY = "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" +const REWARDS_COORDINATOR_ADDRESS = "2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6" + // This address is hardcoded because it is required by the elcontracts tests but is not // registered in the ContractRegistry in the contracts-deployed-anvil-state.json anvil state. const PERMISSION_CONTROLLER_ADDRESS = "610178dA211FEF7D417bC0e6FeD39F05609AD788" From 121176dcc58f5f17f61e7e05cb266486747da477 Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Wed, 15 Jan 2025 18:02:58 -0300 Subject: [PATCH 25/28] Remove REWARDS_COOR_ADDR cons, use value from contractAddrs --- chainio/clients/elcontracts/reader_test.go | 6 ++---- testutils/anvil.go | 2 -- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index a309d627..adfbbc30 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -367,8 +367,7 @@ func TestGetCumulativeClaimedRewards(t *testing.T) { claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) require.NoError(t, err) - earner := common.HexToAddress(testutils.REWARDS_COORDINATOR_ADDRESS) - receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) + receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, rewardsCoordinatorAddr, true) require.NoError(t, err) require.True(t, receipt.Status == gethtypes.ReceiptStatusSuccessful) @@ -408,8 +407,7 @@ func TestCheckClaim(t *testing.T) { claim, err := newTestClaim(chainReader, anvilHttpEndpoint, cumulativeEarnings, privateKeyHex) require.NoError(t, err) - earner := common.HexToAddress(testutils.REWARDS_COORDINATOR_ADDRESS) - receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, earner, true) + receipt, err = chainWriter.ProcessClaim(context.Background(), *claim, rewardsCoordinatorAddr, true) require.NoError(t, err) require.True(t, receipt.Status == gethtypes.ReceiptStatusSuccessful) diff --git a/testutils/anvil.go b/testutils/anvil.go index 58c4d7b7..ffdace4d 100644 --- a/testutils/anvil.go +++ b/testutils/anvil.go @@ -27,8 +27,6 @@ const ( ANVIL_THIRD_ADDRESS = "3C44CdDdB6a900fa2b585dd299e03d12FA4293BC" ) -const REWARDS_COORDINATOR_ADDRESS = "2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6" - // This address is hardcoded because it is required by the elcontracts tests but is not // registered in the ContractRegistry in the contracts-deployed-anvil-state.json anvil state. const PERMISSION_CONTROLLER_ADDRESS = "610178dA211FEF7D417bC0e6FeD39F05609AD788" From d95d2cefa060d89fe8d2e85e60be1a28a8003058 Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Wed, 15 Jan 2025 18:14:25 -0300 Subject: [PATCH 26/28] Change the comparing of claimed (bigInt) with zero --- chainio/clients/elcontracts/reader_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index adfbbc30..6494fb81 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -360,7 +360,7 @@ func TestGetCumulativeClaimedRewards(t *testing.T) { // This tests that without claims result is zero claimed, err := chainReader.GetCumulativeClaimed(ctx, anvil_address, underlyingTokenAddr) - assert.True(t, claimed.Cmp(big.NewInt(0)) == 0) + assert.Zero(t, claimed.Cmp(big.NewInt(0))) assert.NoError(t, err) cumulativeEarnings := int64(45) From 64b4c622b4405c601bb99af1c7aa11d184b742b8 Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Thu, 16 Jan 2025 12:22:01 -0300 Subject: [PATCH 27/28] Turn comments into assert messages --- chainio/clients/elcontracts/reader_test.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index 6494fb81..2fddd17d 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -122,9 +122,9 @@ func TestChainReader(t *testing.T) { ctx, common.HexToAddress(operator.Address), ) - assert.NotZero(t, len(strategies)) // Strategies has at least one element - assert.NotZero(t, len(shares)) // Shares has at least one element - assert.Equal(t, len(strategies), len(shares)) // Strategies has the same ammount of elements as shares + assert.NotZero(t, len(strategies), "Strategies has at least one element") + assert.NotZero(t, len(shares), "Shares has at least one element") + assert.Equal(t, len(strategies), len(shares), "Strategies has the same ammount of elements as shares") assert.NoError(t, err) }) From 4022472c440f0b6a697bf3cc45430122f1ca5144 Mon Sep 17 00:00:00 2001 From: maximopalopoli Date: Thu, 16 Jan 2025 12:37:41 -0300 Subject: [PATCH 28/28] Add assert message when expecting an invalidRoot error --- chainio/clients/elcontracts/reader_test.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/chainio/clients/elcontracts/reader_test.go b/chainio/clients/elcontracts/reader_test.go index 589b6dbb..92d59164 100644 --- a/chainio/clients/elcontracts/reader_test.go +++ b/chainio/clients/elcontracts/reader_test.go @@ -275,7 +275,9 @@ func TestGetRootIndexFromRootHash(t *testing.T) { root, ) assert.Error(t, err) - assert.Equal(t, err.Error(), "execution reverted: custom error 0x504570e3") + assert.Equal(t, err.Error(), "execution reverted: custom error 0x504570e3", + "GetRootIndexFromHash should return an InvalidRoot() error", + ) assert.Zero(t, root_index) currRewardsCalculationEndTimestamp, err := chainReader.CurrRewardsCalculationEndTimestamp(context.Background())