test: E2E test for the Bitcoin RBF transaction

changelog.md

@@ -53,6 +53,8 @@
 * [3831](https://github.com/zeta-chain/node/pull/3831) - e2e tests for sui fungible token withdraw and call
 * [3582](https://github.com/zeta-chain/node/pull/3852) - add solana to tss migration e2e tests
 * [3866](https://github.com/zeta-chain/node/pull/3866) - add e2e test for upgrading sui gateway package
+* [3417](https://github.com/zeta-chain/node/pull/3417) - add e2e test for the Bitcoin RBF (Replace-By-Fee) feature
+
 
 ### Refactor
 

cmd/zetae2e/local/bitcoin.go

@@ -14,6 +14,11 @@ import (
 	"github.com/zeta-chain/node/testutil"
 )
 
+const (
+	testGroupDepositName  = "btc_deposit"
+	testGroupWithdrawName = "btc_withdraw"
+)
+
 // startBitcoinTests starts Bitcoin related tests
 func startBitcoinTests(
 	eg *errgroup.Group,
@@ -58,6 +63,9 @@ func startBitcoinTests(
 		e2etests.TestBitcoinWithdrawP2WSHName,
 		e2etests.TestBitcoinWithdrawMultipleName,
 		e2etests.TestBitcoinWithdrawRestrictedName,
+		// to run RBF test, change the constant 'minTxConfirmations' to 1 in the Bitcoin observer
+		// https://github.com/zeta-chain/node/blob/5c2a8ffbc702130fd9538b1cd7640d0e04d3e4f6/zetaclient/chains/bitcoin/observer/outbound.go#L27
+		//e2etests.TestBitcoinWithdrawRBFName,
 	}
 
 	if !light {
@@ -89,7 +97,7 @@ func bitcoinTestRoutines(
 	// initialize runner for deposit tests
 	account := conf.AdditionalAccounts.UserBitcoinDeposit
 	runnerDeposit := initBitcoinRunner(
-		"btc_deposit",
+		testGroupDepositName,
 		account,
 		conf,
 		deployerRunner,
@@ -101,7 +109,7 @@ func bitcoinTestRoutines(
 	// initialize runner for withdraw tests
 	account = conf.AdditionalAccounts.UserBitcoinWithdraw
 	runnerWithdraw := initBitcoinRunner(
-		"btc_withdraw",
+		testGroupWithdrawName,
 		account,
 		conf,
 		deployerRunner,
@@ -123,8 +131,8 @@ func bitcoinTestRoutines(
 	}
 
 	// create test routines
-	routineDeposit := createBitcoinTestRoutine(runnerDeposit, depositTests)
-	routineWithdraw := createBitcoinTestRoutine(runnerWithdraw, withdrawTests)
+	routineDeposit := createBitcoinTestRoutine(runnerDeposit, depositTests, testGroupDepositName)
+	routineWithdraw := createBitcoinTestRoutine(runnerWithdraw, withdrawTests, testGroupWithdrawName)
 
 	return routineDeposit, routineWithdraw
 }
@@ -177,7 +185,8 @@ func initBitcoinRunner(
 }
 
 // createBitcoinTestRoutine creates a test routine for given test names
-func createBitcoinTestRoutine(r *runner.E2ERunner, testNames []string) func() error {
+// The 'wgDependency' argument is used to wait for dependent routine to complete
+func createBitcoinTestRoutine(r *runner.E2ERunner, testNames []string, name string) func() error {
 	return func() (err error) {
 		r.Logger.Print("🏃 starting bitcoin tests")
 		startTime := time.Now()
@@ -197,6 +206,11 @@ func createBitcoinTestRoutine(r *runner.E2ERunner, testNames []string) func() er
 
 		r.Logger.Print("🍾 bitcoin tests completed in %s", time.Since(startTime).String())
 
+		// mark deposit test group as done
+		if name == testGroupDepositName {
+			e2etests.DepdencyAllBitcoinDeposits.Done()
+		}
+
 		return err
 	}
 }

e2e/e2etests/e2etests.go

@@ -142,6 +142,7 @@ const (
 	TestBitcoinWithdrawInvalidAddressName                  = "bitcoin_withdraw_invalid"
 	TestBitcoinWithdrawRestrictedName                      = "bitcoin_withdraw_restricted"
 	TestBitcoinDepositInvalidMemoRevertName                = "bitcoin_deposit_invalid_memo_revert"
+	TestBitcoinWithdrawRBFName                             = "bitcoin_withdraw_rbf"
 
 	/*
 	 Application tests
@@ -264,6 +265,12 @@ const (
 	CountArgDescription = "count"
 )
 
+// Here are all the dependencies for the e2e tests, add more dependencies here if needed
+var (
+	// DepdencyAllBitcoinDeposits is a dependency to wait for all bitcoin deposit tests to complete
+	DepdencyAllBitcoinDeposits = runner.NewE2EDependency("all_bitcoin_deposits")
+)
+
 // AllE2ETests is an ordered list of all e2e tests
 var AllE2ETests = []runner.E2ETest{
 	/*
@@ -1165,6 +1172,16 @@ var AllE2ETests = []runner.E2ETest{
 		TestBitcoinDepositInvalidMemoRevert,
 		runner.WithMinimumVersion("v29.0.0"),
 	),
+	runner.NewE2ETest(
+		TestBitcoinWithdrawRBFName,
+		"withdraw Bitcoin from ZEVM and replace the outbound using RBF",
+		[]runner.ArgDefinition{
+			{Description: "receiver address", DefaultValue: ""},
+			{Description: "amount in btc", DefaultValue: "0.001"},
+		},
+		TestBitcoinWithdrawRBF,
+		runner.WithDependencies(DepdencyAllBitcoinDeposits),
+	),
 	/*
 	 Application tests
 	*/

e2e/e2etests/helpers.go

@@ -10,7 +10,6 @@ import (
 	"github.com/btcsuite/btcd/btcjson"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/stretchr/testify/require"
 
 	"github.com/zeta-chain/node/e2e/runner"
@@ -28,39 +27,13 @@ func randomPayload(r *runner.E2ERunner) string {
 }
 
 func withdrawBTCZRC20(r *runner.E2ERunner, to btcutil.Address, amount *big.Int) *btcjson.TxRawResult {
-	_, gasFee, err := r.BTCZRC20.WithdrawGasFee(&bind.CallOpts{})
-	require.NoError(r, err)
-	minimumAmount := new(big.Int).Add(amount, gasFee)
-	currentBalance, err := r.BTCZRC20.BalanceOf(&bind.CallOpts{}, r.ZEVMAuth.From)
-	require.NoError(r, err)
-	require.Greater(
-		r,
-		currentBalance.Int64(),
-		minimumAmount.Int64(),
-		"current balance must be greater than amount + gasFee",
-	)
-
-	tx, err := r.BTCZRC20.Approve(
-		r.ZEVMAuth,
-		r.BTCZRC20Addr,
-		big.NewInt(amount.Int64()*2),
-	) // approve more to cover withdraw fee
-	require.NoError(r, err)
-
-	receipt := utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
-	utils.RequireTxSuccessful(r, receipt)
+	// approve and withdraw on ZRC20 contract
+	receipt := r.WithdrawBTC(to, amount, true)
 
 	// mine blocks if testing on regnet
 	stop := r.MineBlocksIfLocalBitcoin()
 	defer stop()
 
-	// withdraw 'amount' of BTC from ZRC20 to BTC address
-	tx, err = r.BTCZRC20.Withdraw(r.ZEVMAuth, []byte(to.EncodeAddress()), amount)
-	require.NoError(r, err)
-
-	receipt = utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
-	utils.RequireTxSuccessful(r, receipt)
-
 	// get cctx and check status
 	cctx := utils.WaitCctxMinedByInboundHash(r.Ctx, receipt.TxHash.Hex(), r.CctxClient, r.Logger, r.CctxTimeout)
 	utils.RequireCCTXStatus(r, cctx, crosschaintypes.CctxStatus_OutboundMined)

e2e/e2etests/test_bitcoin_deposit_and_withdraw_with_dust.go

@@ -22,7 +22,6 @@ func TestBitcoinDepositAndWithdrawWithDust(r *runner.E2ERunner, args []string) {
 	require.Len(r, args, 0)
 
 	// ARRANGE
-
 	// Deploy the withdrawer contract on ZetaChain with a withdraw amount of 100 satoshis (dust amount is 1000 satoshis)
 	withdrawerAddr, tx, _, err := withdrawer.DeployWithdrawer(r.ZEVMAuth, r.ZEVMClient, big.NewInt(100))
 	require.NoError(r, err)

e2e/e2etests/test_bitcoin_withdraw_rbf.go

@@ -0,0 +1,76 @@
+package e2etests
+
+import (
+	"strconv"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/stretchr/testify/require"
+
+	"github.com/zeta-chain/node/e2e/runner"
+	"github.com/zeta-chain/node/e2e/utils"
+	crosschaintypes "github.com/zeta-chain/node/x/crosschain/types"
+)
+
+// TestBitcoinWithdrawRBF tests the RBF (Replace-By-Fee) feature in Zetaclient.
+// It needs block mining to be stopped and runs as the last test in the suite.
+//
+// IMPORTANT: the test requires to simulate a stuck tx in the Bitcoin regnet.
+// The challenge to simulate a stuck tx is to create overwhelming traffic in the local mempool.
+//
+// To work around this:
+//  1. change the 'minTxConfirmations' to 1 to not include outbound tx right away (production should use 0)
+//     here: https://github.com/zeta-chain/node/blob/5c2a8ffbc702130fd9538b1cd7640d0e04d3e4f6/zetaclient/chains/bitcoin/observer/outbound.go#L27
+//  2. stop block mining to let the pending tx sit in the mempool for longer time
+func TestBitcoinWithdrawRBF(r *runner.E2ERunner, args []string) {
+	require.Len(r, args, 2)
+
+	// parse arguments
+	defaultReceiver := r.GetBtcAddress().EncodeAddress()
+	to, amount := utils.ParseBitcoinWithdrawArgs(r, args, defaultReceiver, r.GetBitcoinChainID())
+
+	// initiate a withdraw CCTX
+	receipt := r.WithdrawBTC(to, amount, true)
+	cctx := utils.GetCCTXByInboundHash(r.Ctx, r.CctxClient, receipt.TxHash.Hex())
+
+	// wait for the 1st outbound tracker hash to come in
+	nonce := cctx.GetCurrentOutboundParam().TssNonce
+	hashes := utils.WaitOutboundTracker(r.Ctx, r.CctxClient, r.GetBitcoinChainID(), nonce, 1, r.Logger, 3*time.Minute)
+	txHash, err := chainhash.NewHashFromStr(hashes[0])
+	r.Logger.Info("got 1st tracker hash: %s", txHash)
+
+	// get original tx
+	require.NoError(r, err)
+	txResult, err := r.BtcRPCClient.GetTransaction(r.Ctx, txHash)
+	require.NoError(r, err)
+	require.Zero(r, txResult.Confirmations)
+
+	// wait for RBF tx to kick in
+	hashes = utils.WaitOutboundTracker(r.Ctx, r.CctxClient, r.GetBitcoinChainID(), nonce, 2, r.Logger, 3*time.Minute)
+	txHashRBF, err := chainhash.NewHashFromStr(hashes[1])
+	require.NoError(r, err)
+	r.Logger.Info("got 2nd tracker hash: %s", txHashRBF)
+
+	// resume block mining
+	stop := r.MineBlocksIfLocalBitcoin()
+	defer stop()
+
+	// waiting for CCTX to be mined
+	cctx = utils.WaitCctxMinedByInboundHash(r.Ctx, receipt.TxHash.Hex(), r.CctxClient, r.Logger, r.CctxTimeout)
+	utils.RequireCCTXStatus(r, cctx, crosschaintypes.CctxStatus_OutboundMined)
+
+	// ensure the original tx is dropped
+	utils.MustHaveDroppedBitcoinTx(r.Ctx, r.BtcRPCClient, txHash)
+
+	// ensure the RBF tx is mined
+	rawResult := utils.MustHaveMinedBitcoinTx(r.Ctx, r.BtcRPCClient, txHashRBF)
+
+	// ensure RBF fee rate > old rate
+	params := cctx.GetCurrentOutboundParam()
+	oldRate, err := strconv.ParseInt(params.GasPrice, 10, 64)
+	require.NoError(r, err)
+
+	_, newRate, err := r.BtcRPCClient.GetTransactionFeeAndRate(r.Ctx, rawResult)
+	require.NoError(r, err)
+	require.Greater(r, newRate, oldRate, "RBF fee rate should be higher than the original tx")
+}

e2e/runner/bitcoin.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/hex"
 	"fmt"
+	"math/big"
 	"sort"
 	"time"
 
@@ -15,6 +16,7 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/rs/zerolog/log"
 	"github.com/stretchr/testify/require"
 
@@ -182,6 +184,44 @@ func (r *E2ERunner) DepositBTC(receiver common.Address) {
 	require.Equal(r, 1, balance.Sign(), "balance should be positive")
 }
 
+// WithdrawBTC is a helper function to call 'withdraw' on BTCZRC20 contract with optional 'approve'
+func (r *E2ERunner) WithdrawBTC(to btcutil.Address, amount *big.Int, approve bool) *ethtypes.Receipt {
+	// ensure enough balance to cover the withdrawal
+	_, gasFee, err := r.BTCZRC20.WithdrawGasFee(&bind.CallOpts{})
+	require.NoError(r, err)
+	minimumAmount := new(big.Int).Add(amount, gasFee)
+	currentBalance, err := r.BTCZRC20.BalanceOf(&bind.CallOpts{}, r.ZEVMAuth.From)
+	require.NoError(r, err)
+	require.Greater(
+		r,
+		currentBalance.Int64(),
+		minimumAmount.Int64(),
+		"current balance must be greater than amount + gasFee",
+	)
+
+	// approve more to cover withdraw fee
+	if approve {
+		tx, err := r.BTCZRC20.Approve(
+			r.ZEVMAuth,
+			r.BTCZRC20Addr,
+			big.NewInt(amount.Int64()*2),
+		)
+		require.NoError(r, err)
+
+		receipt := utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+		utils.RequireTxSuccessful(r, receipt)
+	}
+
+	// withdraw 'amount' of BTC from ZRC20 to BTC address
+	tx, err := r.BTCZRC20.Withdraw(r.ZEVMAuth, []byte(to.EncodeAddress()), amount)
+	require.NoError(r, err)
+
+	receipt := utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+	utils.RequireTxSuccessful(r, receipt)
+
+	return receipt
+}
+
 func (r *E2ERunner) SendToTSSWithMemo(
 	amount float64,
 	memo []byte,

e2e/runner/e2etest.go

@@ -1,6 +1,9 @@
 package runner
 
-import "fmt"
+import (
+	"fmt"
+	"sync"
+)
 
 // E2ETestFunc is a function representing a E2E test
 // It takes a E2ERunner as an argument
@@ -16,12 +19,20 @@ func WithMinimumVersion(version string) E2ETestOpt {
 	}
 }
 
+// WithDependencies sets dependencies to the E2ETest to wait for completion
+func WithDependencies(dependencies ...E2EDependency) E2ETestOpt {
+	return func(t *E2ETest) {
+		t.Dependencies = dependencies
+	}
+}
+
 // E2ETest represents a E2E test with a name, args, description and test func
 type E2ETest struct {
 	Name           string
 	Description    string
 	Args           []string
 	ArgsDefinition []ArgDefinition
+	Dependencies   []E2EDependency
 	E2ETest        E2ETestFunc
 	MinimumVersion string
 }
@@ -46,6 +57,33 @@ func NewE2ETest(
 	return test
 }
 
+// E2EDependency defines a structure that holds a E2E test dependency
+type E2EDependency struct {
+	name      string
+	waitGroup *sync.WaitGroup
+}
+
+// NewE2EDependency creates a new instance of E2Edependency with specified parameters.
+func NewE2EDependency(name string) E2EDependency {
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	return E2EDependency{
+		name:      name,
+		waitGroup: &wg,
+	}
+}
+
+// Wait waits for the E2EDependency to complete
+func (d *E2EDependency) Wait() {
+	d.waitGroup.Wait()
+}
+
+// Done marks the E2EDependency as done
+func (d *E2EDependency) Done() {
+	d.waitGroup.Done()
+}
+
 // ArgDefinition defines a structure for holding an argument's description along with it's default value.
 type ArgDefinition struct {
 	Description  string
@@ -110,6 +148,7 @@ func (r *E2ERunner) GetE2ETestsToRunByConfig(
 			Name:           e2eTest.Name,
 			Description:    e2eTest.Description,
 			ArgsDefinition: e2eTest.ArgsDefinition,
+			Dependencies:   e2eTest.Dependencies,
 			E2ETest:        e2eTest.E2ETest,
 			MinimumVersion: e2eTest.MinimumVersion,
 		}