feat!: bank precompile

Dockerfile-localnet

@@ -59,7 +59,7 @@ EXPOSE 22
 FROM base-runtime AS latest-runtime
 
 COPY --from=cosmovisor-build /go/bin/cosmovisor /usr/local/bin
-COPY --from=latest-build /go/bin/zetacored /go/bin/zetaclientd /go/bin/zetaclientd-supervisor /go/bin/zetae2e /usr/local/bin
+COPY --from=latest-build /go/bin/zetacored /go/bin/zetaclientd /go/bin/zetaclientd-supervisor /go/bin/zetae2e /usr/local/bin/
 
 # Optional old version build (from source). This old build is used as the genesis version in the upgrade tests. 
 # Use --target latest-runtime to skip.
@@ -75,7 +75,7 @@ RUN cd node && make install
 FROM base-runtime AS old-runtime-source
 
 COPY --from=cosmovisor-build /go/bin/cosmovisor /usr/local/bin
-COPY --from=old-build-source /go/bin/zetacored /go/bin/zetaclientd /usr/local/bin
+COPY --from=old-build-source /go/bin/zetacored /go/bin/zetaclientd /usr/local/bin/
 COPY --from=latest-build /go/bin/zetaclientd-supervisor /usr/local/bin
 
 # Optional old version build (from binary).

app/app.go

@@ -570,6 +570,7 @@ func New(
 		precompiles.StatefulContracts(
 			&app.FungibleKeeper,
 			app.StakingKeeper,
+			app.BankKeeper,
 			appCodec,
 			storetypes.TransientGasConfig(),
 		),

changelog.md

@@ -9,6 +9,7 @@
 * [2784](https://github.com/zeta-chain/node/pull/2784) - staking precompiled contract
 * [2795](https://github.com/zeta-chain/node/pull/2795) - support restricted address in Solana
 * [2861](https://github.com/zeta-chain/node/pull/2861) - emit events from staking precompile
+* [2860](https://github.com/zeta-chain/node/pull/2860) - bank precompiled contract
 * [2870](https://github.com/zeta-chain/node/pull/2870) - support for multiple Bitcoin chains in the zetaclient
 * [2883](https://github.com/zeta-chain/node/pull/2883) - add chain static information for btc signet testnet
 

cmd/zetae2e/local/local.go

@@ -322,6 +322,8 @@ func localE2ETest(cmd *cobra.Command, _ []string) {
 				e2etests.TestPrecompilesPrototypeThroughContractName,
 				e2etests.TestPrecompilesStakingName,
 				e2etests.TestPrecompilesStakingThroughContractName,
+				e2etests.TestPrecompilesBankName,
+				e2etests.TestPrecompilesBankFailName,
 			}
 		}
 

cmd/zetae2e/local/precompiles.go

@@ -35,6 +35,10 @@ func statefulPrecompilesTestRoutine(
 		precompileRunner.Logger.Print("🏃 starting stateful precompiled contracts tests")
 		startTime := time.Now()
 
+		// Send ERC20 that will be depositted into ERC20ZRC20 tokens.
+		txERC20Send := deployerRunner.SendERC20OnEvm(account.EVMAddress(), 10000)
+		precompileRunner.WaitForTxReceiptOnEvm(txERC20Send)
+
 		testsToRun, err := precompileRunner.GetE2ETestsToRunByName(
 			e2etests.AllE2ETests,
 			testNames...,

codecov.yml

@@ -80,5 +80,4 @@ ignore:
   - "precompiles/**/*.abi"
   - "precompiles/**/*.json"
   - "precompiles/**/*.sol"
-  - "precompiles/prototype/IPrototype.go"
-  - "precompiles/staking/IStaking.go"
+  - "precompiles/**/*.gen.go"

contrib/localnet/orchestrator/start-zetae2e.sh

@@ -117,7 +117,7 @@ fund_eth_from_config '.additional_accounts.user_admin.evm_address' 10000 "admin
 fund_eth_from_config '.additional_accounts.user_migration.evm_address' 10000 "migration tester"
 
 # unlock precompile tests accounts
-fund_eth_from_config '.additional_accounts.user_precompile.evm_address' 10000 "precompile tester"
+fund_eth_from_config '.additional_accounts.user_precompile.evm_address' 10000 "precompiles tester"
 
 # unlock v2 ethers tests accounts
 fund_eth_from_config '.additional_accounts.user_v2_ether.evm_address' 10000  "V2 ethers tester"
@@ -131,16 +131,6 @@ fund_eth_from_config '.additional_accounts.user_v2_ether_revert.evm_address' 100
 # unlock v2 erc20 revert tests accounts
 fund_eth_from_config '.additional_accounts.user_v2_erc20_revert.evm_address' 10000 "V2 ERC20 revert tester"
 
-# unlock precompile tests accounts
-address=$(yq -r '.additional_accounts.user_precompile.evm_address' config.yml)
-echo "funding precompile tester address ${address} with 10000 Ether"
-geth --exec "eth.sendTransaction({from: eth.coinbase, to: '${address}', value: web3.toWei(10000,'ether')})" attach http://eth:8545 > /dev/null
-
-# unlock precompile tests accounts
-address=$(yq -r '.additional_accounts.user_precompile.evm_address' config.yml)
-echo "funding precompile tester address ${address} with 10000 Ether"
-geth --exec "eth.sendTransaction({from: eth.coinbase, to: '${address}', value: web3.toWei(10000,'ether')})" attach http://eth:8545 > /dev/null
-
 # unlock local solana relayer accounts
 if host solana > /dev/null; then
   solana_url=$(config_str '.rpcs.solana')

e2e/e2etests/e2etests.go

@@ -160,6 +160,9 @@ const (
 	TestPrecompilesPrototypeThroughContractName = "precompile_contracts_prototype_through_contract"
 	TestPrecompilesStakingName                  = "precompile_contracts_staking"
 	TestPrecompilesStakingThroughContractName   = "precompile_contracts_staking_through_contract"
+	TestPrecompilesBankName                     = "precompile_contracts_bank"
+	TestPrecompilesBankFailName                 = "precompile_contracts_bank_fail"
+	TestPrecompilesBankThroughContractName      = "precompile_contracts_bank_through_contract"
 )
 
 // AllE2ETests is an ordered list of all e2e tests
@@ -886,4 +889,16 @@ var AllE2ETests = []runner.E2ETest{
 		[]runner.ArgDefinition{},
 		TestPrecompilesStakingThroughContract,
 	),
+	runner.NewE2ETest(
+		TestPrecompilesBankName,
+		"test stateful precompiled contracts bank with ZRC20 tokens",
+		[]runner.ArgDefinition{},
+		TestPrecompilesBank,
+	),
+	runner.NewE2ETest(
+		TestPrecompilesBankFailName,
+		"test stateful precompiled contracts bank with non ZRC20 tokens",
+		[]runner.ArgDefinition{},
+		TestPrecompilesBankNonZRC20,
+	),
 }

e2e/e2etests/test_precompiles_bank.go

@@ -0,0 +1,192 @@
+package e2etests
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/stretchr/testify/require"
+
+	"github.com/zeta-chain/node/e2e/runner"
+	"github.com/zeta-chain/node/e2e/utils"
+	"github.com/zeta-chain/node/precompiles/bank"
+)
+
+func TestPrecompilesBank(r *runner.E2ERunner, args []string) {
+	require.Len(r, args, 0, "No arguments expected")
+
+	// Increase the gasLimit. It's required because of the gas consumed by precompiled functions.
+	previousGasLimit := r.ZEVMAuth.GasLimit
+	r.ZEVMAuth.GasLimit = 10_000_000
+	defer func() {
+		r.ZEVMAuth.GasLimit = previousGasLimit
+
+		// Reset the allowance to 0; this is needed when running upgrade tests where
+		// this test runs twice.
+		tx, err := r.ERC20ZRC20.Approve(r.ZEVMAuth, bank.ContractAddress, big.NewInt(0))
+		require.NoError(r, err)
+		receipt := utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+		utils.RequireTxSuccessful(r, receipt, "Resetting allowance failed")
+	}()
+
+	totalAmount := big.NewInt(1e3)
+	depositAmount := big.NewInt(500)
+	higherBalanceAmount := big.NewInt(1001)
+	higherAllowanceAmount := big.NewInt(501)
+	spender := r.EVMAddress()
+
+	// Get ERC20ZRC20.
+	txHash := r.DepositERC20WithAmountAndMessage(r.EVMAddress(), totalAmount, []byte{})
+	utils.WaitCctxMinedByInboundHash(r.Ctx, txHash.Hex(), r.CctxClient, r.Logger, r.CctxTimeout)
+
+	// Create a bank contract caller.
+	bankContract, err := bank.NewIBank(bank.ContractAddress, r.ZEVMClient)
+	require.NoError(r, err, "Failed to create bank contract caller")
+
+	// Cosmos coin balance should be 0 at this point.
+	cosmosBalance, err := bankContract.BalanceOf(&bind.CallOpts{Context: r.Ctx}, r.ERC20ZRC20Addr, spender)
+	require.NoError(r, err, "Call bank.BalanceOf()")
+	require.Equal(r, uint64(0), cosmosBalance.Uint64(), "spender cosmos coin balance should be 0")
+
+	// Approve allowance of 500 ERC20ZRC20 tokens for the bank contract. Should pass.
+	tx, err := r.ERC20ZRC20.Approve(r.ZEVMAuth, bank.ContractAddress, depositAmount)
+	require.NoError(r, err)
+	receipt := utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+	utils.RequireTxSuccessful(r, receipt, "Approve ETHZRC20 bank allowance tx failed")
+
+	// Deposit 501 ERC20ZRC20 tokens to the bank contract.
+	// It's higher than allowance but lower than balance, should fail.
+	tx, err = bankContract.Deposit(r.ZEVMAuth, r.ERC20ZRC20Addr, higherAllowanceAmount)
+	require.NoError(r, err, "Call bank.Deposit() with amout higher than allowance")
+	receipt = utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+	utils.RequiredTxFailed(r, receipt, "Depositting an amount higher than allowed should fail")
+
+	// Approve allowance of 1000 ERC20ZRC20 tokens.
+	tx, err = r.ERC20ZRC20.Approve(r.ZEVMAuth, bank.ContractAddress, big.NewInt(1e3))
+	require.NoError(r, err)
+	receipt = utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+	utils.RequireTxSuccessful(r, receipt, "Approve ETHZRC20 bank allowance tx failed")
+
+	// Deposit 1001 ERC20ZRC20 tokens to the bank contract.
+	// It's higher than spender balance but within approved allowance, should fail.
+	tx, err = bankContract.Deposit(r.ZEVMAuth, r.ERC20ZRC20Addr, higherBalanceAmount)
+	require.NoError(r, err, "Call bank.Deposit() with amout higher than balance")
+	receipt = utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+	utils.RequiredTxFailed(r, receipt, "Depositting an amount higher than balance should fail")
+
+	// Deposit 500 ERC20ZRC20 tokens to the bank contract. Should pass.
+	tx, err = bankContract.Deposit(r.ZEVMAuth, r.ERC20ZRC20Addr, depositAmount)
+	require.NoError(r, err, "Call bank.Deposit() with correct amount")
+	receipt = utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+	utils.RequireTxSuccessful(r, receipt, "Depositting a correct amount should pass")
+
+	// Check the deposit event.
+	eventDeposit, err := bankContract.ParseDeposit(*receipt.Logs[0])
+	require.NoError(r, err, "Parse Deposit event")
+	require.Equal(r, r.EVMAddress(), eventDeposit.Zrc20Depositor, "Deposit event token should be r.EVMAddress()")
+	require.Equal(r, r.ERC20ZRC20Addr, eventDeposit.Zrc20Token, "Deposit event token should be ERC20ZRC20Addr")
+	require.Equal(r, depositAmount, eventDeposit.Amount, "Deposit event amount should be 500")
+
+	// Spender: cosmos coin balance should be 500 at this point.
+	cosmosBalance, err = bankContract.BalanceOf(&bind.CallOpts{Context: r.Ctx}, r.ERC20ZRC20Addr, spender)
+	require.NoError(r, err, "Call bank.BalanceOf()")
+	require.Equal(r, uint64(500), cosmosBalance.Uint64(), "spender cosmos coin balance should be 500")
+
+	// Bank: ERC20ZRC20 balance should be 500 tokens locked.
+	bankZRC20Balance, err := r.ERC20ZRC20.BalanceOf(&bind.CallOpts{Context: r.Ctx}, bank.ContractAddress)
+	require.NoError(r, err, "Call ERC20ZRC20.BalanceOf")
+	require.Equal(r, uint64(500), bankZRC20Balance.Uint64(), "bank ERC20ZRC20 balance should be 500")
+
+	// Try to withdraw 501 ERC20ZRC20 tokens. Should fail.
+	tx, err = bankContract.Withdraw(r.ZEVMAuth, r.ERC20ZRC20Addr, big.NewInt(501))
+	require.NoError(r, err, "Error calling bank.withdraw()")
+	receipt = utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+	utils.RequiredTxFailed(r, receipt, "Withdrawing more than cosmos coin balance amount should fail")
+
+	// Bank: ERC20ZRC20 balance should be 500 tokens locked after a failed withdraw.
+	// No tokens should be unlocked with a failed withdraw.
+	bankZRC20Balance, err = r.ERC20ZRC20.BalanceOf(&bind.CallOpts{Context: r.Ctx}, bank.ContractAddress)
+	require.NoError(r, err, "Call ERC20ZRC20.BalanceOf")
+	require.Equal(r, uint64(500), bankZRC20Balance.Uint64(), "bank ERC20ZRC20 balance should be 500")
+
+	// Try to withdraw 500 ERC20ZRC20 tokens. Should pass.
+	tx, err = bankContract.Withdraw(r.ZEVMAuth, r.ERC20ZRC20Addr, depositAmount)
+	require.NoError(r, err, "Error calling bank.withdraw()")
+	receipt = utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+	utils.RequireTxSuccessful(r, receipt, "Withdraw correct amount should pass")
+
+	// Check the withdraw event.
+	eventWithdraw, err := bankContract.ParseWithdraw(*receipt.Logs[0])
+	require.NoError(r, err, "Parse Deposit event")
+	require.Equal(r, r.EVMAddress(), eventWithdraw.Zrc20Withdrawer, "Deposit event token should be r.EVMAddress()")
+	require.Equal(r, r.ERC20ZRC20Addr, eventWithdraw.Zrc20Token, "Deposit event token should be ERC20ZRC20Addr")
+	require.Equal(r, depositAmount, eventWithdraw.Amount, "Deposit event amount should be 500")
+
+	// Spender: cosmos coin balance should be 0 at this point.
+	cosmosBalance, err = bankContract.BalanceOf(&bind.CallOpts{Context: r.Ctx}, r.ERC20ZRC20Addr, spender)
+	require.NoError(r, err, "Call bank.BalanceOf()")
+	require.Equal(r, uint64(0), cosmosBalance.Uint64(), "spender cosmos coin balance should be 0")
+
+	// Spender: ERC20ZRC20 balance should be 1000 at this point.
+	zrc20Balance, err := r.ERC20ZRC20.BalanceOf(&bind.CallOpts{Context: r.Ctx}, spender)
+	require.NoError(r, err, "Call bank.BalanceOf()")
+	require.Equal(r, uint64(1000), zrc20Balance.Uint64(), "spender ERC20ZRC20 balance should be 1000")
+
+	// Bank: ERC20ZRC20 balance should be 0 tokens locked.
+	bankZRC20Balance, err = r.ERC20ZRC20.BalanceOf(&bind.CallOpts{Context: r.Ctx}, bank.ContractAddress)
+	require.NoError(r, err, "Call ERC20ZRC20.BalanceOf")
+	require.Equal(r, uint64(0), bankZRC20Balance.Uint64(), "bank ERC20ZRC20 balance should be 0")
+}
+
+func TestPrecompilesBankNonZRC20(r *runner.E2ERunner, args []string) {
+	require.Len(r, args, 0, "No arguments expected")
+
+	// Increase the gasLimit. It's required because of the gas consumed by precompiled functions.
+	previousGasLimit := r.ZEVMAuth.GasLimit
+	r.ZEVMAuth.GasLimit = 10_000_000
+	defer func() {
+		r.ZEVMAuth.GasLimit = previousGasLimit
+	}()
+
+	spender, bankAddr := r.EVMAddress(), bank.ContractAddress
+
+	// Create a bank contract caller.
+	bankContract, err := bank.NewIBank(bank.ContractAddress, r.ZEVMClient)
+	require.NoError(r, err, "Failed to create bank contract caller")
+
+	// Deposit and approve 50 WZETA for the test.
+	approveAmount := big.NewInt(0).Mul(big.NewInt(1e18), big.NewInt(50))
+	r.DepositAndApproveWZeta(approveAmount)
+
+	// Non ZRC20 balanceOf check should fail.
+	_, err = bankContract.BalanceOf(&bind.CallOpts{Context: r.Ctx}, r.WZetaAddr, spender)
+	require.Error(r, err, "bank.balanceOf() should error out when checking for non ZRC20 balance")
+	require.Contains(
+		r,
+		err.Error(),
+		"invalid token 0x5F0b1a82749cb4E2278EC87F8BF6B618dC71a8bf: token is not a whitelisted ZRC20",
+		"Error should be 'token is not a whitelisted ZRC20'",
+	)
+
+	// Allow the bank contract to spend 25 WZeta tokens.
+	tx, err := r.WZeta.Approve(r.ZEVMAuth, bankAddr, big.NewInt(25))
+	require.NoError(r, err, "Error approving allowance for bank contract")
+	receipt := utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+	require.EqualValues(r, uint64(1), receipt.Status, "approve allowance tx failed")
+
+	// Check the allowance of the bank in WZeta tokens. Should be 25.
+	allowance, err := r.WZeta.Allowance(&bind.CallOpts{Context: r.Ctx}, spender, bankAddr)
+	require.NoError(r, err, "Error retrieving bank allowance")
+	require.EqualValues(r, uint64(25), allowance.Uint64(), "Error allowance for bank contract")
+
+	// Call Deposit with 25 Non ZRC20 tokens. Should fail.
+	tx, err = bankContract.Deposit(r.ZEVMAuth, r.WZetaAddr, big.NewInt(25))
+	require.NoError(r, err, "Error calling bank.deposit()")
+	receipt = utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+	require.Equal(r, uint64(0), receipt.Status, "Non ZRC20 deposit should fail")
+
+	// Call Withdraw with 25 on ZRC20 tokens. Should fail.
+	tx, err = bankContract.Withdraw(r.ZEVMAuth, r.WZetaAddr, big.NewInt(25))
+	require.NoError(r, err, "Error calling bank.withdraw()")
+	receipt = utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+	require.Equal(r, uint64(0), receipt.Status, "Non ZRC20 withdraw should fail")
+}

e2e/e2etests/test_rate_limiter.go

@@ -122,7 +122,7 @@ func createAndWaitWithdraws(r *runner.E2ERunner, withdrawType withdrawType, with
 		return err
 	}
 
-	duration := time.Now().Sub(startTime).Seconds()
+	duration := time.Since(startTime).Seconds()
 	block, err := r.ZEVMClient.BlockNumber(r.Ctx)
 	if err != nil {
 		return fmt.Errorf("error getting block number: %w", err)
@@ -155,7 +155,7 @@ func waitForWithdrawMined(
 	}
 
 	// record the time for completion
-	duration := time.Now().Sub(startTime).Seconds()
+	duration := time.Since(startTime).Seconds()
 	block, err := r.ZEVMClient.BlockNumber(ctx)
 	if err != nil {
 		return err

e2e/e2etests/test_stress_btc_deposit.go

@@ -53,7 +53,7 @@ func monitorBTCDeposit(r *runner.E2ERunner, hash *chainhash.Hash, index int, sta
 			cctx.Index,
 		)
 	}
-	timeToComplete := time.Now().Sub(startTime)
+	timeToComplete := time.Since(startTime)
 	r.Logger.Print("index %d: deposit cctx success in %s", index, timeToComplete.String())
 
 	return nil

e2e/e2etests/test_stress_btc_withdraw.go

@@ -66,7 +66,7 @@ func monitorBTCWithdraw(r *runner.E2ERunner, tx *ethtypes.Transaction, index int
 			cctx.Index,
 		)
 	}
-	timeToComplete := time.Now().Sub(startTime)
+	timeToComplete := time.Since(startTime)
 	r.Logger.Print("index %d: withdraw cctx success in %s", index, timeToComplete.String())
 
 	return nil

e2e/e2etests/test_stress_eth_deposit.go

@@ -52,7 +52,7 @@ func monitorEtherDeposit(r *runner.E2ERunner, hash ethcommon.Hash, index int, st
 			cctx.Index,
 		)
 	}
-	timeToComplete := time.Now().Sub(startTime)
+	timeToComplete := time.Since(startTime)
 	r.Logger.Print("index %d: deposit cctx success in %s", index, timeToComplete.String())
 
 	return nil

e2e/e2etests/test_stress_eth_withdraw.go

@@ -70,7 +70,7 @@ func monitorEtherWithdraw(r *runner.E2ERunner, tx *ethtypes.Transaction, index i
 			cctx.Index,
 		)
 	}
-	timeToComplete := time.Now().Sub(startTime)
+	timeToComplete := time.Since(startTime)
 	r.Logger.Print("index %d: withdraw cctx success in %s", index, timeToComplete.String())
 
 	return nil

e2e/utils/require.go

@@ -43,5 +43,9 @@ func errSuffix(msgAndArgs ...any) string {
 
 	template := "; " + msgAndArgs[0].(string)
 
+	if len(msgAndArgs) == 1 {
+		return template
+	}
+
 	return fmt.Sprintf(template, msgAndArgs[1:])
 }