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

@@ -93,6 +93,7 @@ import (
 	"github.com/zeta-chain/node/docs/openapi"
 	zetamempool "github.com/zeta-chain/node/pkg/mempool"
 	"github.com/zeta-chain/node/precompiles"
+	bankprecompile "github.com/zeta-chain/node/precompiles/bank"
 	srvflags "github.com/zeta-chain/node/server/flags"
 	authoritymodule "github.com/zeta-chain/node/x/authority"
 	authoritykeeper "github.com/zeta-chain/node/x/authority/keeper"
@@ -570,6 +571,7 @@ func New(
 		precompiles.StatefulContracts(
 			&app.FungibleKeeper,
 			app.StakingKeeper,
+			app.BankKeeper,
 			appCodec,
 			storetypes.TransientGasConfig(),
 		),
@@ -1064,6 +1066,11 @@ func (app *App) BlockedAddrs() map[string]bool {
 	// Each enabled precompiled stateful contract should be added as a BlockedAddrs.
 	// That way it's marked as non payable by the bank keeper.
 	for addr, enabled := range precompiles.EnabledStatefulContracts {
+		// bank precompile has to be able to receive funds.
+		if addr == bankprecompile.ContractAddress {
+			continue
+		}
+
 		if enabled {
 			blockList[addr.String()] = enabled
 		}

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
 
 ### Refactor
 

cmd/zetae2e/config/localnet.yml

@@ -61,6 +61,10 @@ additional_accounts:
     bech32_address: "zeta1nry9yeg6njhjrp2ctppa8558vqxal9fxk69zxg"
     evm_address: "0x98c852651A9CAF2185585843d3D287600Ddf9526"
     private_key: "bf9456c679bb5a952a9a137fcfc920e0413efdb97c36de1e57455763084230cb"
+  user_bank_precompile:
+    bech32_address: "zeta1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqr84sgapz"
+    evm_address: "0x0000000000000000000000000000000000000067"
+    private_key: ""
 policy_accounts:
   emergency_policy_account:
     bech32_address: "zeta16m2cnrdwtgweq4njc6t470vl325gw4kp6s7tap"

cmd/zetae2e/local/local.go

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

codecov.yml

@@ -82,3 +82,4 @@ ignore:
   - "precompiles/**/*.sol"
   - "precompiles/prototype/IPrototype.go"
   - "precompiles/staking/IStaking.go"
+  - "precompiles/bank/IBank.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')

contrib/localnet/scripts/start-zetacored.sh

@@ -269,6 +269,9 @@ then
 # v2 erc20 revert tester
   address=$(yq -r '.additional_accounts.user_v2_erc20_revert.bech32_address' /root/config.yml)
   zetacored add-genesis-account "$address" 100000000000000000000000000azeta
+# bank precompile user
+  address=$(yq -r '.additional_accounts.user_bank_precompile.bech32_address' /root/config.yml)
+  zetacored add-genesis-account "$address" 100000000000000000000000000azeta
 
 # 3. Copy the genesis.json to all the nodes .And use it to create a gentx for every node
   zetacored gentx operator 1000000000000000000000azeta --chain-id=$CHAINID --keyring-backend=$KEYRING --gas-prices 20000000000azeta

e2e/e2etests/e2etests.go

@@ -159,6 +159,8 @@ const (
 	TestPrecompilesPrototypeThroughContractName = "precompile_contracts_prototype_through_contract"
 	TestPrecompilesStakingName                  = "precompile_contracts_staking"
 	TestPrecompilesStakingThroughContractName   = "precompile_contracts_staking_through_contract"
+	TestPrecompilesBankName                     = "precompile_contracts_bank"
+	TestPrecompilesBankThroughContractName      = "precompile_contracts_bank_through_contract"
 )
 
 // AllE2ETests is an ordered list of all e2e tests
@@ -877,4 +879,10 @@ var AllE2ETests = []runner.E2ETest{
 		[]runner.ArgDefinition{},
 		TestPrecompilesStakingThroughContract,
 	),
+	runner.NewE2ETest(
+		TestPrecompilesBankName,
+		"test stateful precompiled contracts bank",
+		[]runner.ArgDefinition{},
+		TestPrecompilesBank,
+	),
 }

e2e/e2etests/test_precompiles_bank.go

@@ -0,0 +1,119 @@
+package e2etests
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"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
+	}()
+
+	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)
+
+	// Initial WZETA spender balance should be 50.
+	initialBalance, err := r.WZeta.BalanceOf(&bind.CallOpts{Context: r.Ctx}, spender)
+	require.NoError(r, err, "Error approving allowance for bank contract")
+	require.EqualValues(r, approveAmount, initialBalance, "spender balance should be 50")
+
+	// Initial cosmos coin spender balance should be 0.
+	retBalanceOf, err := bankContract.BalanceOf(&bind.CallOpts{Context: r.Ctx}, r.WZetaAddr, spender)
+	require.NoError(r, err, "Error calling bank.balanceOf()")
+	require.EqualValues(r, uint64(0), retBalanceOf.Uint64(), "Initial cosmos coins balance has to be 0")
+
+	// 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.
+	balance, err := r.WZeta.Allowance(&bind.CallOpts{Context: r.Ctx}, spender, bankAddr)
+	require.NoError(r, err, "Error retrieving bank allowance")
+	require.EqualValues(r, uint64(25), balance.Uint64(), "Error allowance for bank contract")
+
+	// Call Deposit with 25 coins.
+	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)
+
+	// Deposit event should be emitted.
+	depositEvent, err := bankContract.ParseDeposit(*receipt.Logs[0])
+	require.NoError(r, err)
+	require.Equal(r, big.NewInt(25).Uint64(), depositEvent.Amount.Uint64())
+	require.Equal(r, common.BytesToAddress(spender.Bytes()), depositEvent.Zrc20Depositor)
+	require.Equal(r, r.WZetaAddr, depositEvent.Zrc20Token)
+
+	// After deposit, cosmos coin spender balance should be 25.
+	retBalanceOf, err = bankContract.BalanceOf(&bind.CallOpts{Context: r.Ctx}, r.WZetaAddr, spender)
+	require.NoError(r, err, "Error calling bank.balanceOf()")
+	require.EqualValues(r, uint64(25), retBalanceOf.Uint64(), "balanceOf result has to be 25")
+
+	// After deposit, WZeta spender balance should be 25 less than initial.
+	finalBalance, err := r.WZeta.BalanceOf(&bind.CallOpts{Context: r.Ctx}, spender)
+	require.NoError(r, err, "Error retrieving final owner balance")
+	require.EqualValues(
+		r,
+		initialBalance.Uint64()-25, // expected
+		finalBalance.Uint64(),      // actual
+		"Final balance should be initial - 25",
+	)
+
+	// After deposit, WZeta bank balance should be 25.
+	balance, err = r.WZeta.BalanceOf(&bind.CallOpts{Context: r.Ctx}, bankAddr)
+	require.NoError(r, err, "Error retrieving bank's balance")
+	require.EqualValues(r, uint64(25), balance.Uint64(), "Wrong locked WZeta amount in bank contract")
+
+	// Withdraw 15 coins to spender.
+	tx, err = bankContract.Withdraw(r.ZEVMAuth, r.WZetaAddr, big.NewInt(15))
+	require.NoError(r, err, "Error calling bank.withdraw()")
+	receipt = utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+
+	// Withdraw event should be emitted.
+	withdrawEvent, err := bankContract.ParseWithdraw(*receipt.Logs[0])
+	require.NoError(r, err)
+	require.Equal(r, big.NewInt(15).Uint64(), withdrawEvent.Amount.Uint64())
+	require.Equal(r, common.BytesToAddress(spender.Bytes()), withdrawEvent.Zrc20Withdrawer)
+	require.Equal(r, r.WZetaAddr, withdrawEvent.Zrc20Token)
+
+	// After withdraw, WZeta spender balance should be only 10 less than initial. (25 - 15 = 10e2e/e2etests/test_precompiles_bank.go )
+	afterWithdraw, err := r.WZeta.BalanceOf(&bind.CallOpts{Context: r.Ctx}, spender)
+	require.NoError(r, err, "Error retrieving final owner balance")
+	require.EqualValues(
+		r,
+		initialBalance.Uint64()-10, // expected
+		afterWithdraw.Uint64(),     // actual
+		"Balance after withdraw should be initial - 10",
+	)
+
+	// After withdraw, cosmos coin spender balance should be 10.
+	retBalanceOf, err = bankContract.BalanceOf(&bind.CallOpts{Context: r.Ctx}, r.WZetaAddr, spender)
+	require.NoError(r, err, "Error calling bank.balanceOf()")
+	require.EqualValues(r, uint64(10), retBalanceOf.Uint64(), "balanceOf result has to be 10")
+
+	// Final WZETA bank balance should be 10.
+	balance, err = r.WZeta.BalanceOf(&bind.CallOpts{Context: r.Ctx}, bankAddr)
+	require.NoError(r, err, "Error retrieving bank's allowance")
+	require.EqualValues(r, uint64(10), balance.Uint64(), "Wrong locked WZeta amount in bank contract")
+}

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