chore(e2e): removing btcd

.github/workflows/ci.yml

@@ -12,7 +12,9 @@ jobs:
      run-unit-tests: true
      run-integration-tests: true
      run-lint: true
-     install-dependencies-command: sudo apt-get install libzmq3-dev
+     install-dependencies-command: |
+       sudo apt-get update
+       sudo apt-get install -y libzmq3-dev
 
   docker_pipeline:
     uses: babylonlabs-io/.github/.github/workflows/[email protected]

btcclient/client.go

@@ -60,4 +60,10 @@ func (c *Client) Stop() {
 	if c.blockEventChan != nil {
 		close(c.blockEventChan)
 	}
+
+	if c.zmqClient != nil {
+		if err := c.zmqClient.Close(); err != nil {
+			c.logger.Debug(err)
+		}
+	}
 }

btcclient/client_block_subscriber.go

@@ -51,15 +51,6 @@ func NewWithBlockSubscriber(cfg *config.BTCConfig, retrySleepTime, maxRetrySleep
 			return nil, err
 		}
 
-		// ensure we are using bitcoind as Bitcoin node, as zmq is only supported by bitcoind
-		backend, err := rpcClient.BackendVersion()
-		if err != nil {
-			return nil, fmt.Errorf("failed to get BTC backend: %v", err)
-		}
-		if backend != rpcclient.BitcoindPost25 {
-			return nil, fmt.Errorf("zmq is only supported by bitcoind, but got %v", backend)
-		}
-
 		zmqClient, err := zmq.New(logger, cfg.ZmqSeqEndpoint, client.blockEventChan, rpcClient)
 		if err != nil {
 			return nil, err

btcclient/notifier.go

@@ -48,7 +48,7 @@ func DefaultBitcoindConfig() Bitcoind {
 		RPCHost:              config.DefaultRpcBtcNodeHost,
 		RPCUser:              config.DefaultBtcNodeRpcUser,
 		RPCPass:              config.DefaultBtcNodeRpcPass,
-		RPCPolling:           false,
+		RPCPolling:           true,
 		BlockPollingInterval: 30 * time.Second,
 		TxPollingInterval:    30 * time.Second,
 		EstimateMode:         config.DefaultBtcNodeEstimateMode,
@@ -81,7 +81,6 @@ func CfgToBtcNodeBackendConfig(cfg config.BTCConfig, rawCert string) *BtcNodeBac
 			ActiveNodeBackend: types.Bitcoind,
 			Bitcoind:          &defaultBitcoindCfg,
 		}
-
 	case types.Btcd:
 		return &BtcNodeBackendConfig{
 			ActiveNodeBackend: types.Btcd,

config/bitcoin.go

@@ -102,7 +102,7 @@ const (
 	DefaultBtcNodeRpcPass      = "rpcpass"
 	DefaultBtcNodeEstimateMode = "CONSERVATIVE"
 	DefaultBtcblockCacheSize   = 20 * 1024 * 1024 // 20 MB
-	DefaultZmqSeqEndpoint      = "tcp://127.0.0.1:29000"
+	DefaultZmqSeqEndpoint      = "tcp://127.0.0.1:28333"
 	DefaultZmqBlockEndpoint    = "tcp://127.0.0.1:29001"
 	DefaultZmqTxEndpoint       = "tcp://127.0.0.1:29002"
 )

e2etest/atomicslasher_e2e_test.go

@@ -4,7 +4,6 @@
 package e2etest
 
 import (
-	"encoding/hex"
 	"testing"
 	"time"
 
@@ -14,44 +13,22 @@ import (
 	"github.com/babylonlabs-io/vigilante/btcstaking-tracker/btcslasher"
 	"github.com/babylonlabs-io/vigilante/config"
 	"github.com/babylonlabs-io/vigilante/metrics"
-	"github.com/babylonlabs-io/vigilante/types"
-	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/btcsuite/btcd/rpcclient"
-	"github.com/btcsuite/btcd/wire"
 	"github.com/stretchr/testify/require"
 )
 
+// TestAtomicSlasher verifies the behavior of the atomic slasher by setting up delegations,
+// sending slashing transactions, and ensuring that slashing is detected and executed correctly.
 func TestAtomicSlasher(t *testing.T) {
 	// segwit is activated at height 300. It's needed by staking/slashing tx
 	numMatureOutputs := uint32(300)
 
-	submittedTxs := map[chainhash.Hash]struct{}{}
-	blockEventChan := make(chan *types.BlockEvent, 1000)
-	handlers := &rpcclient.NotificationHandlers{
-		OnFilteredBlockConnected: func(height int32, header *wire.BlockHeader, txs []*btcutil.Tx) {
-			log.Debugf("Block %v at height %d has been connected at time %v", header.BlockHash(), height, header.Timestamp)
-			blockEventChan <- types.NewBlockEvent(types.BlockConnected, height, header)
-		},
-		OnFilteredBlockDisconnected: func(height int32, header *wire.BlockHeader) {
-			log.Debugf("Block %v at height %d has been disconnected at time %v", header.BlockHash(), height, header.Timestamp)
-			blockEventChan <- types.NewBlockEvent(types.BlockDisconnected, height, header)
-		},
-		OnTxAccepted: func(hash *chainhash.Hash, amount btcutil.Amount) {
-			submittedTxs[*hash] = struct{}{}
-		},
-	}
-
-	tm := StartManager(t, numMatureOutputs, 2, handlers, blockEventChan)
-	// this is necessary to receive notifications about new transactions entering mempool
-	err := tm.MinerNode.Client.NotifyNewTransactions(false)
-	require.NoError(t, err)
-	err = tm.MinerNode.Client.NotifyBlocks()
-	require.NoError(t, err)
+	tm := StartManager(t, numMatureOutputs)
 	defer tm.Stop(t)
+
 	// start WebSocket connection with Babylon for subscriber services
-	err = tm.BabylonClient.Start()
+	err := tm.BabylonClient.Start()
 	require.NoError(t, err)
 	// Insert all existing BTC headers to babylon node
 	tm.CatchUpBTCLightClient(t)
@@ -61,8 +38,8 @@ func TestAtomicSlasher(t *testing.T) {
 	// TODO: our config only support btcd wallet tls, not btcd directly
 	tm.Config.BTC.DisableClientTLS = false
 	backend, err := btcclient.NewNodeBackend(
-		btcclient.CfgToBtcNodeBackendConfig(tm.Config.BTC, hex.EncodeToString(tm.MinerNode.RPCConfig().Certificates)),
-		&chaincfg.SimNetParams,
+		btcclient.CfgToBtcNodeBackendConfig(tm.Config.BTC, ""),
+		&chaincfg.RegressionNetParams,
 		&emptyHintCache,
 	)
 	require.NoError(t, err)
@@ -73,7 +50,7 @@ func TestAtomicSlasher(t *testing.T) {
 	commonCfg := config.DefaultCommonConfig()
 	bstCfg := config.DefaultBTCStakingTrackerConfig()
 	bstCfg.CheckDelegationsInterval = 1 * time.Second
-	logger, err := config.NewRootLogger("auto", "debug")
+	rootLogger, err := config.NewRootLogger("auto", "debug")
 	require.NoError(t, err)
 
 	metrics := metrics.NewBTCStakingTrackerMetrics()
@@ -84,15 +61,12 @@ func TestAtomicSlasher(t *testing.T) {
 		tm.BabylonClient,
 		&bstCfg,
 		&commonCfg,
-		logger,
+		rootLogger,
 		metrics,
 	)
 	go bsTracker.Start()
 	defer bsTracker.Stop()
 
-	// wait for bootstrapping
-	time.Sleep(5 * time.Second)
-
 	bsParamsResp, err := tm.BabylonClient.BTCStakingParams()
 	require.NoError(t, err)
 	bsParams := bsParamsResp.Params
@@ -118,18 +92,20 @@ func TestAtomicSlasher(t *testing.T) {
 	require.NoError(t, err)
 	slashingTxHash, err := tm.BTCClient.SendRawTransaction(victimSlashingTx, true)
 	require.NoError(t, err)
+
 	require.Eventually(t, func() bool {
 		_, err := tm.BTCClient.GetRawTransaction(slashingTxHash)
 		return err == nil
 	}, eventuallyWaitTimeOut, eventuallyPollTime)
+
 	// mine a block that includes slashing tx, which will trigger atomic slasher
-	tm.MineBlockWithTxs(t, tm.RetrieveTransactionFromMempool(t, []*chainhash.Hash{slashingTxHash}))
-	// ensure slashing tx will be detected on Bitcoin
 	require.Eventually(t, func() bool {
-		_, ok := submittedTxs[*slashingTxHash]
-		return ok
+		return len(tm.RetrieveTransactionFromMempool(t, []*chainhash.Hash{slashingTxHash})) == 1
 	}, eventuallyWaitTimeOut, eventuallyPollTime)
 
+	minedBlock := tm.mineBlock(t)
+	require.Equal(t, 2, len(minedBlock.Transactions))
+
 	/*
 		atomic slasher will detect the selective slashing on victim BTC delegation
 		the finality provider will get slashed on Babylon
@@ -149,49 +125,33 @@ func TestAtomicSlasher(t *testing.T) {
 	slashTx2, err := bstypes.NewBTCSlashingTxFromHex(btcDel2.SlashingTxHex)
 	require.NoError(t, err)
 	slashingTxHash2 := slashTx2.MustGetTxHash()
+
 	require.Eventually(t, func() bool {
 		_, err := tm.BTCClient.GetRawTransaction(slashingTxHash2)
 		t.Logf("err of getting slashingTxHash of the BTC delegation affected by atomic slashing: %v", err)
 		return err == nil
 	}, eventuallyWaitTimeOut, eventuallyPollTime)
+
 	// mine a block that includes slashing tx, which will trigger atomic slasher
-	tm.MineBlockWithTxs(t, tm.RetrieveTransactionFromMempool(t, []*chainhash.Hash{slashingTxHash2}))
-	// ensure slashing tx 2 will be detected on Bitcoin
 	require.Eventually(t, func() bool {
-		_, ok := submittedTxs[*slashingTxHash2]
-		return ok
+		return len(tm.RetrieveTransactionFromMempool(t, []*chainhash.Hash{slashingTxHash2})) == 1
 	}, eventuallyWaitTimeOut, eventuallyPollTime)
+
+	minedBlock = tm.mineBlock(t)
+	require.Equal(t, 2, len(minedBlock.Transactions))
 }
 
+// TestAtomicSlasher_Unbonding tests the atomic slasher's handling of unbonding BTC delegations,
+// including the creation and detection of unbonding slashing transactions.
 func TestAtomicSlasher_Unbonding(t *testing.T) {
 	// segwit is activated at height 300. It's needed by staking/slashing tx
 	numMatureOutputs := uint32(300)
 
-	submittedTxs := map[chainhash.Hash]struct{}{}
-	blockEventChan := make(chan *types.BlockEvent, 1000)
-	handlers := &rpcclient.NotificationHandlers{
-		OnFilteredBlockConnected: func(height int32, header *wire.BlockHeader, txs []*btcutil.Tx) {
-			log.Debugf("Block %v at height %d has been connected at time %v", header.BlockHash(), height, header.Timestamp)
-			blockEventChan <- types.NewBlockEvent(types.BlockConnected, height, header)
-		},
-		OnFilteredBlockDisconnected: func(height int32, header *wire.BlockHeader) {
-			log.Debugf("Block %v at height %d has been disconnected at time %v", header.BlockHash(), height, header.Timestamp)
-			blockEventChan <- types.NewBlockEvent(types.BlockDisconnected, height, header)
-		},
-		OnTxAccepted: func(hash *chainhash.Hash, amount btcutil.Amount) {
-			submittedTxs[*hash] = struct{}{}
-		},
-	}
-
-	tm := StartManager(t, numMatureOutputs, 2, handlers, blockEventChan)
-	// this is necessary to receive notifications about new transactions entering mempool
-	err := tm.MinerNode.Client.NotifyNewTransactions(false)
-	require.NoError(t, err)
-	err = tm.MinerNode.Client.NotifyBlocks()
-	require.NoError(t, err)
+	tm := StartManager(t, numMatureOutputs)
 	defer tm.Stop(t)
+
 	// start WebSocket connection with Babylon for subscriber services
-	err = tm.BabylonClient.Start()
+	err := tm.BabylonClient.Start()
 	require.NoError(t, err)
 	// Insert all existing BTC headers to babylon node
 	tm.CatchUpBTCLightClient(t)
@@ -201,8 +161,8 @@ func TestAtomicSlasher_Unbonding(t *testing.T) {
 	// TODO: our config only support btcd wallet tls, not btcd directly
 	tm.Config.BTC.DisableClientTLS = false
 	backend, err := btcclient.NewNodeBackend(
-		btcclient.CfgToBtcNodeBackendConfig(tm.Config.BTC, hex.EncodeToString(tm.MinerNode.RPCConfig().Certificates)),
-		&chaincfg.SimNetParams,
+		btcclient.CfgToBtcNodeBackendConfig(tm.Config.BTC, ""),
+		&chaincfg.RegressionNetParams,
 		&emptyHintCache,
 	)
 	require.NoError(t, err)
@@ -213,26 +173,23 @@ func TestAtomicSlasher_Unbonding(t *testing.T) {
 	commonCfg := config.DefaultCommonConfig()
 	bstCfg := config.DefaultBTCStakingTrackerConfig()
 	bstCfg.CheckDelegationsInterval = 1 * time.Second
-	logger, err := config.NewRootLogger("auto", "debug")
+	rootLogger, err := config.NewRootLogger("auto", "debug")
 	require.NoError(t, err)
 
-	metrics := metrics.NewBTCStakingTrackerMetrics()
+	stakingTrackerMetrics := metrics.NewBTCStakingTrackerMetrics()
 
 	bsTracker := bst.NewBTCSTakingTracker(
 		tm.BTCClient,
 		backend,
 		tm.BabylonClient,
 		&bstCfg,
 		&commonCfg,
-		logger,
-		metrics,
+		rootLogger,
+		stakingTrackerMetrics,
 	)
 	go bsTracker.Start()
 	defer bsTracker.Stop()
 
-	// wait for bootstrapping
-	time.Sleep(5 * time.Second)
-
 	bsParamsResp, err := tm.BabylonClient.BTCStakingParams()
 	require.NoError(t, err)
 	bsParams := bsParamsResp.Params
@@ -252,6 +209,7 @@ func TestAtomicSlasher_Unbonding(t *testing.T) {
 	btcDelsResp2, err := tm.BabylonClient.BTCDelegations(bstypes.BTCDelegationStatus_ACTIVE, nil)
 	require.NoError(t, err)
 	require.Len(t, btcDelsResp2.BtcDelegations, 2)
+
 	// NOTE: `BTCDelegations` API does not return BTC delegations in created time order
 	// thus we need to find out the 2nd BTC delegation one-by-one
 	var btcDel2 *bstypes.BTCDelegationResponse
@@ -262,6 +220,8 @@ func TestAtomicSlasher_Unbonding(t *testing.T) {
 		}
 	}
 
+	require.NotNil(t, btcDel2, "err second delegation not found")
+
 	/*
 		the victim BTC delegation unbonds
 	*/
@@ -272,6 +232,7 @@ func TestAtomicSlasher_Unbonding(t *testing.T) {
 	*/
 	victimUnbondingSlashingTx, err := btcslasher.BuildUnbondingSlashingTxWithWitness(victimBTCDel, &bsParams, netParams, fpSK)
 	require.NoError(t, err)
+
 	// send slashing tx to Bitcoin
 	// NOTE: sometimes unbonding slashing tx is not immediately spendable for some reason
 	var unbondingSlashingTxHash *chainhash.Hash
@@ -283,6 +244,7 @@ func TestAtomicSlasher_Unbonding(t *testing.T) {
 		}
 		return true
 	}, eventuallyWaitTimeOut, eventuallyPollTime)
+
 	// unbonding slashing tx is eventually queryable
 	require.Eventually(t, func() bool {
 		_, err := tm.BTCClient.GetRawTransaction(unbondingSlashingTxHash)
@@ -293,13 +255,13 @@ func TestAtomicSlasher_Unbonding(t *testing.T) {
 		return true
 	}, eventuallyWaitTimeOut, eventuallyPollTime)
 	// mine a block that includes unbonding slashing tx, which will trigger atomic slasher
-	tm.MineBlockWithTxs(t, tm.RetrieveTransactionFromMempool(t, []*chainhash.Hash{unbondingSlashingTxHash}))
-	// ensure unbonding slashing tx will be detected on Bitcoin
 	require.Eventually(t, func() bool {
-		_, ok := submittedTxs[*unbondingSlashingTxHash]
-		return ok
+		return len(tm.RetrieveTransactionFromMempool(t, []*chainhash.Hash{unbondingSlashingTxHash})) == 1
 	}, eventuallyWaitTimeOut, eventuallyPollTime)
 
+	minedBlock := tm.mineBlock(t)
+	require.Equal(t, 2, len(minedBlock.Transactions))
+
 	/*
 		atomic slasher will detect the selective slashing on victim BTC delegation
 		the finality provider will get slashed on Babylon
@@ -317,17 +279,19 @@ func TestAtomicSlasher_Unbonding(t *testing.T) {
 	*/
 	slashingTx2, err := bstypes.NewBTCSlashingTxFromHex(btcDel2.SlashingTxHex)
 	require.NoError(t, err)
+
 	slashingTxHash2 := slashingTx2.MustGetTxHash()
 	require.Eventually(t, func() bool {
 		_, err := tm.BTCClient.GetRawTransaction(slashingTxHash2)
 		t.Logf("err of getting slashingTxHash of the BTC delegation affected by atomic slashing: %v", err)
 		return err == nil
 	}, eventuallyWaitTimeOut, eventuallyPollTime)
+
 	// mine a block that includes slashing tx, which will trigger atomic slasher
-	tm.MineBlockWithTxs(t, tm.RetrieveTransactionFromMempool(t, []*chainhash.Hash{slashingTxHash2}))
-	// ensure slashing tx 2 will be detected on Bitcoin
 	require.Eventually(t, func() bool {
-		_, ok := submittedTxs[*slashingTxHash2]
-		return ok
+		return len(tm.RetrieveTransactionFromMempool(t, []*chainhash.Hash{slashingTxHash2})) == 1
 	}, eventuallyWaitTimeOut, eventuallyPollTime)
+
+	minedBlock = tm.mineBlock(t)
+	require.Equal(t, 2, len(minedBlock.Transactions))
 }

e2etest/babylon_node_handler.go

@@ -123,7 +123,7 @@ type BabylonNodeHandler struct {
 	babylonNode *babylonNode
 }
 
-func NewBabylonNodeHandler() (*BabylonNodeHandler, error) {
+func NewBabylonNodeHandler(baseHeaderHex string) (*BabylonNodeHandler, error) {
 	testDir, err := baseDirBabylondir()
 	if err != nil {
 		return nil, err
@@ -140,6 +140,7 @@ func NewBabylonNodeHandler() (*BabylonNodeHandler, error) {
 		"--btc-finalization-timeout=4",
 		"--btc-confirmation-depth=2",
 		"--additional-sender-account",
+		fmt.Sprintf("--btc-base-header=%s", baseHeaderHex),
 		"--covenant-quorum=1",
 		fmt.Sprintf("--covenant-pks=%s", bbn.NewBIP340PubKeyFromBTCPK(juryPK).MarshalHex()),
 	)