feat: Store btcstaking events in kv store and send IBC packet (#235)

proto/babylon/btcstaking/v1/packet.proto

@@ -43,8 +43,8 @@ message NewFinalityProvider {
   // commission defines the commission rate of the finality provider.
   // It forms as a string converted from "cosmossdk.io/math.LegacyDec"
   string commission = 2;
-  // babylon_pk is the Babylon secp256k1 PK of this finality provider
-  cosmos.crypto.secp256k1.PubKey babylon_pk = 3;
+  // addr is the bech32 address identifier of the finality provider.
+  string addr = 3;
   // btc_pk_hex is the Bitcoin secp256k1 PK of this finality provider
   // the PK follows encoding in BIP-340 spec in hex format
   string btc_pk_hex = 4;
@@ -53,24 +53,22 @@ message NewFinalityProvider {
   // master_pub_rand is the master public randomness of the finality provider
   // encoded as a base58 string
   string master_pub_rand = 6;
-  // registered_epoch is the epoch when this finality provider is registered
-  uint64 registered_epoch = 7;
   // slashed_babylon_height indicates the Babylon height when
   // the finality provider is slashed.
   // if it's 0 then the finality provider is not slashed
-  uint64 slashed_babylon_height = 8;
+  uint64 slashed_babylon_height = 7;
   // slashed_btc_height indicates the BTC height when
   // the finality provider is slashed.
   // if it's 0 then the finality provider is not slashed
-  uint64 slashed_btc_height = 9;
+  uint64 slashed_btc_height = 8;
   // consumer_id is the ID of the consumer the finality provider is operating on.
   // If it's missing / empty, it's assumed the finality provider is operating in Babylon.
-  string consumer_id = 10;
+  string consumer_id = 9;
 }
 
 // ActiveBTCDelegation is an IBC packet sent from Babylon to consumer
 // upon a BTC delegation newly receives covenant signatures and thus becomes active
-message ActiveBTCDelegation { 
+message ActiveBTCDelegation {
   // btc_pk_hex is the Bitcoin secp256k1 PK of this BTC delegation
   // the PK follows encoding in BIP-340 spec in hex format
   string btc_pk_hex = 1;
@@ -157,3 +155,20 @@ message UnbondedBTCDelegation {
   // It proves that the BTC delegator wants to unbond
   bytes unbonding_tx_sig = 2;
 }
+
+// BTCStakingConsumerEvent defines the structure for storing BTC staking events
+// which will be later sent to consumer chains as IBC packets.
+message BTCStakingConsumerEvent {
+  // oneof event represents a mutually exclusive choice among different event types.
+  // Only one event type can be set within each BTCStakingEvent message instance.
+  oneof event {
+    // NewFinalityProvider represents the event of a new finality provider being created.
+    NewFinalityProvider new_fp = 1;
+    // ActiveBTCDelegation represents the event of an active BTC delegation.
+    ActiveBTCDelegation active_del = 2;
+    // SlashedBTCDelegation represents the event of a slashed BTC delegation.
+    SlashedBTCDelegation slashed_del = 3;
+    // UnbondedBTCDelegation represents the event of an unbonded BTC delegation.
+    UnbondedBTCDelegation unbonded_del = 4;
+  }
+}

test/e2e/btc_staking_e2e_test.go

@@ -79,7 +79,22 @@ func (s *BTCStakingTestSuite) Test1CreateFinalityProviderAndDelegation() {
 	nonValidatorNode, err := chainA.GetNodeAtIndex(2)
 	s.NoError(err)
 
-	cacheFP = s.CreateNodeFP(nonValidatorNode)
+	//cacheFP = s.CreateNodeFP(nonValidatorNode)
+	/*
+		create a random finality provider on Babylon
+	*/
+	// NOTE: we use the node's secret key as Babylon secret key for the finality provider
+	fp, err := datagen.GenRandomCustomFinalityProvider(r, fpBTCSK, nonValidatorNode.SecretKey, "")
+	s.NoError(err)
+	nonValidatorNode.CreateFinalityProvider("val", fp.BtcPk, fp.Pop, fp.Description.Moniker, fp.Description.Identity, fp.Description.Website, fp.Description.SecurityContact, fp.Description.Details, fp.Commission)
+
+	// wait for a block so that above txs take effect
+	nonValidatorNode.WaitForNextBlock()
+
+	// query the existence of finality provider and assert equivalence
+	actualFps := nonValidatorNode.QueryFinalityProviders()
+	s.Len(actualFps, 1)
+	s.equalFinalityProviderResp(fp, actualFps[0])
 
 	/*
 		create a random BTC delegation under this finality provider
@@ -854,7 +869,7 @@ func (s *BTCStakingTestSuite) CreateNodeFP(node *chain.NodeConfig) (newFP *bstyp
 	nodeAddr, err := sdk.AccAddressFromBech32(node.PublicAddress)
 	s.NoError(err)
 
-	newFP, err = datagen.GenRandomFinalityProviderWithBTCBabylonSKs(r, fpBTCSK, nodeAddr)
+	newFP, err = datagen.GenRandomFinalityProviderWithBTCBabylonSKs(r, fpBTCSK, nodeAddr, "")
 	s.NoError(err)
 	node.CreateFinalityProvider(newFP.Addr, newFP.BtcPk, newFP.Pop, newFP.Description.Moniker, newFP.Description.Identity, newFP.Description.Website, newFP.Description.SecurityContact, newFP.Description.Details, newFP.Commission)
 

test/e2e/btc_staking_integration_e2e_test.go

@@ -1,12 +1,8 @@
 package e2e
 
 import (
-	"errors"
-	"fmt"
 	"math"
-	"time"
 
-	"github.com/babylonchain/babylon/crypto/eots"
 	"github.com/babylonchain/babylon/test/e2e/configurer"
 	"github.com/babylonchain/babylon/test/e2e/configurer/chain"
 	"github.com/babylonchain/babylon/test/e2e/initialization"
@@ -15,7 +11,6 @@ import (
 	btcctypes "github.com/babylonchain/babylon/x/btccheckpoint/types"
 	bstypes "github.com/babylonchain/babylon/x/btcstaking/types"
 	bsctypes "github.com/babylonchain/babylon/x/btcstkconsumer/types"
-	ckpttypes "github.com/babylonchain/babylon/x/checkpointing/types"
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/wire"
@@ -144,12 +139,10 @@ func (s *BTCStakingIntegrationTestSuite) createVerifyConsumerFP(babylonNode *cha
 	*/
 	// NOTE: we use the node's secret key as Babylon secret key for the finality provider
 	czFpBTCSK, _, _ := datagen.GenRandomBTCKeyPair(r)
-	sr, _, err := eots.NewMasterRandPair(r)
-	s.NoError(err)
-	czFp, err := datagen.GenRandomCustomFinalityProvider(r, czFpBTCSK, babylonNode.SecretKey, sr)
+	czFp, err := datagen.GenRandomCustomFinalityProvider(r, czFpBTCSK, babylonNode.SecretKey, consumerId)
 	s.NoError(err)
 	babylonNode.CreateConsumerFinalityProvider(
-		czFp.BabylonPk, czFp.BtcPk, czFp.Pop, czFp.MasterPubRand, consumerId, czFp.Description.Moniker,
+		czFp.BabylonPk, czFp.BtcPk, czFp.Pop, consumerId, czFp.Description.Moniker,
 		czFp.Description.Identity, czFp.Description.Website, czFp.Description.SecurityContact,
 		czFp.Description.Details, czFp.Commission,
 	)
@@ -177,11 +170,9 @@ func (s *BTCStakingIntegrationTestSuite) createVerifyBabylonFP(babylonNode *chai
 	*/
 	// NOTE: we use the node's secret key as Babylon secret key for the finality provider
 	babylonFpBTCSK, _, _ := datagen.GenRandomBTCKeyPair(r)
-	sr, _, err := eots.NewMasterRandPair(r)
-	s.NoError(err)
-	babylonFp, err := datagen.GenRandomCustomFinalityProvider(r, babylonFpBTCSK, babylonNode.SecretKey, sr)
+	babylonFp, err := datagen.GenRandomCustomFinalityProvider(r, babylonFpBTCSK, babylonNode.SecretKey, "")
 	s.NoError(err)
-	babylonNode.CreateFinalityProvider(babylonFp.BabylonPk, babylonFp.BtcPk, babylonFp.Pop, babylonFp.MasterPubRand, babylonFp.Description.Moniker, babylonFp.Description.Identity, babylonFp.Description.Website, babylonFp.Description.SecurityContact, babylonFp.Description.Details, babylonFp.Commission)
+	babylonNode.CreateFinalityProvider(babylonFp.BabylonPk, babylonFp.BtcPk, babylonFp.Pop, babylonFp.Description.Moniker, babylonFp.Description.Identity, babylonFp.Description.Website, babylonFp.Description.SecurityContact, babylonFp.Description.Details, babylonFp.Commission)
 
 	// wait for a block so that above txs take effect
 	babylonNode.WaitForNextBlock()
@@ -202,32 +193,6 @@ func (s *BTCStakingIntegrationTestSuite) createVerifyBabylonFP(babylonNode *chai
 
 // helper function: create a Babylon delegation and restake to Babylon and consumer finality providers
 func (s *BTCStakingIntegrationTestSuite) createBabylonDelegation(nonValidatorNode *chain.NodeConfig, babylonFp *bstypes.FinalityProviderResponse, consumerFp *bsctypes.FinalityProviderResponse) (*btcec.PublicKey, string) {
-	// finalise epochs until the registered epoch of the finality provider
-	// so that the finality provider can receive BTC delegations
-	// TODO: it is assumed here that babylonFp is registered after consumerFp so
-	//  if we finalize registered epoch of babylonFp the other would also get finalized
-	//  ideally we should get registered epoch of each restaked fp and finalize it.
-	var (
-		startEpoch = uint64(1)
-		endEpoch   = babylonFp.RegisteredEpoch
-	)
-	// wait until the end epoch is sealed
-	s.Eventually(func() bool {
-		ch, _ := nonValidatorNode.QueryCurrentHeight()
-		ce, _ := nonValidatorNode.QueryCurrentEpoch()
-		fmt.Println("current height", ch)
-		fmt.Println("current epoch", ce)
-		resp, err := nonValidatorNode.QueryRawCheckpoint(endEpoch)
-		if err != nil {
-			if !errors.Is(err, ckpttypes.ErrCkptDoesNotExist) {
-				return false
-			}
-		}
-		return resp.Status == ckpttypes.Sealed
-	}, time.Minute, time.Second*5)
-	// finalise these epochs
-	nonValidatorNode.FinalizeSealedEpochs(startEpoch, endEpoch)
-
 	/*
 		create a random BTC delegation restaking to Babylon and consumer finality providers
 	*/

test/e2e/configurer/chain/commands_btcstaking_integration.go

@@ -21,7 +21,7 @@ func (n *NodeConfig) RegisterConsumer(consumerId, consumerName, consumerDesc str
 	n.LogActionF("successfully registered consumer on babylon")
 }
 
-func (n *NodeConfig) CreateConsumerFinalityProvider(babylonPK *secp256k1.PubKey, btcPK *bbn.BIP340PubKey, pop *bstypes.ProofOfPossession, masterPubRand, consumerId, moniker, identity, website, securityContract, details string, commission *sdkmath.LegacyDec) {
+func (n *NodeConfig) CreateConsumerFinalityProvider(babylonPK *secp256k1.PubKey, btcPK *bbn.BIP340PubKey, pop *bstypes.ProofOfPossession, consumerId, moniker, identity, website, securityContract, details string, commission *sdkmath.LegacyDec) {
 	n.LogActionF("creating consumer finality provider")
 
 	// get babylon PK hex
@@ -35,7 +35,7 @@ func (n *NodeConfig) CreateConsumerFinalityProvider(babylonPK *secp256k1.PubKey,
 	require.NoError(n.t, err)
 
 	cmd := []string{
-		"babylond", "tx", "btcstaking", "create-finality-provider", babylonPKHex, btcPKHex, popHex, masterPubRand, "--from=val", "--consumer-id", consumerId, "--moniker", moniker, "--identity", identity, "--website", website, "--security-contact", securityContract, "--details", details, "--commission-rate", commission.String(),
+		"babylond", "tx", "btcstaking", "create-finality-provider", babylonPKHex, btcPKHex, popHex, "--from=val", "--consumer-id", consumerId, "--moniker", moniker, "--identity", identity, "--website", website, "--security-contact", securityContract, "--details", details, "--commission-rate", commission.String(),
 	}
 	_, _, err = n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
 	require.NoError(n.t, err)

testutil/datagen/btcstaking.go

@@ -1,6 +1,7 @@
 package datagen
 
 import (
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
 	"math/rand"
 	"testing"
 
@@ -26,12 +27,12 @@ const (
 )
 
 func GenRandomFinalityProvider(r *rand.Rand) (*bstypes.FinalityProvider, error) {
-	// key pairs
+	// BTC key pairs
 	btcSK, _, err := GenRandomBTCKeyPair(r)
 	if err != nil {
 		return nil, err
 	}
-	return GenRandomFinalityProviderWithBTCSK(r, btcSK)
+	return GenRandomFinalityProviderWithBTCSK(r, btcSK, "")
 }
 
 func CreateNFinalityProviders(r *rand.Rand, t *testing.T, n int) []*bstypes.FinalityProvider {
@@ -44,8 +45,8 @@ func CreateNFinalityProviders(r *rand.Rand, t *testing.T, n int) []*bstypes.Fina
 	return fps
 }
 
-func GenRandomFinalityProviderWithBTCSK(r *rand.Rand, btcSK *btcec.PrivateKey) (*bstypes.FinalityProvider, error) {
-	return GenRandomFinalityProviderWithBTCBabylonSKs(r, btcSK, GenRandomAccount().GetAddress())
+func GenRandomFinalityProviderWithBTCSK(r *rand.Rand, btcSK *btcec.PrivateKey, consumerID string) (*bstypes.FinalityProvider, error) {
+	return GenRandomFinalityProviderWithBTCBabylonSKs(r, btcSK, GenRandomAccount().GetAddress(), consumerID)
 }
 
 func GenRandomCommission(r *rand.Rand) sdkmath.LegacyDec {
@@ -56,7 +57,7 @@ func GenRandomDescription(r *rand.Rand) *stakingtypes.Description {
 	return &stakingtypes.Description{Moniker: GenRandomHexStr(r, 10)}
 }
 
-func GenRandomFinalityProviderWithBTCBabylonSKs(r *rand.Rand, btcSK *btcec.PrivateKey, fpAddr sdk.AccAddress) (*bstypes.FinalityProvider, error) {
+func GenRandomFinalityProviderWithBTCBabylonSKs(r *rand.Rand, btcSK *btcec.PrivateKey, fpAddr sdk.AccAddress, consumerID string) (*bstypes.FinalityProvider, error) {
 	// commission
 	commission := GenRandomCommission(r)
 	// description
@@ -75,10 +76,15 @@ func GenRandomFinalityProviderWithBTCBabylonSKs(r *rand.Rand, btcSK *btcec.Priva
 		BtcPk:       bip340PK,
 		Addr:        fpAddr.String(),
 		Pop:         pop,
-		ConsumerId:  "", // TODO: parameterise
+		ConsumerId:  consumerID,
 	}, nil
 }
 
+func GenRandomCustomFinalityProvider(r *rand.Rand, btcSK *btcec.PrivateKey, bbnSK cryptotypes.PrivKey, consumerID string) (*bstypes.FinalityProvider, error) {
+	fpAddr := sdk.MustAccAddressFromBech32(bbnSK.PubKey().Address().String())
+	return GenRandomFinalityProviderWithBTCBabylonSKs(r, btcSK, fpAddr, consumerID)
+}
+
 // TODO: accomodate presign unbonding flow
 func GenRandomBTCDelegation(
 	r *rand.Rand,

x/btcstaking/keeper/btc_consumer_delegations.go

@@ -92,6 +92,27 @@ func (k Keeper) GetBTCConsumerDelegatorDelegationsResponses(
 	return btcDels, pageRes, nil
 }
 
+// SetConsumerFinalityProvider checks conditions and sets a new finality provider for a consumer.
+func (k Keeper) SetConsumerFinalityProvider(ctx context.Context, fp *bstypes.FinalityProvider, consumerID string) error {
+	// check if the finality provider already exists to prevent duplicates
+	if k.bscKeeper.HasConsumerFinalityProvider(ctx, fp.BtcPk) {
+		return bstypes.ErrFpRegistered
+	}
+	// verify that the consumer is registered within the btcstkconsumer module
+	if !k.bscKeeper.IsConsumerRegistered(ctx, consumerID) {
+		return bstypes.ErrConsumerIDNotRegistered
+	}
+	// set the finality provider in btcstkconsumer module
+	k.bscKeeper.SetConsumerFinalityProvider(ctx, fp)
+
+	// record the event in btc staking consumer event store
+	if err := k.AddBTCStakingConsumerEvent(ctx, consumerID, bstypes.CreateNewFinalityProviderEvent(fp)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // getBTCConsumerDelegatorDelegationIndex gets the BTC delegation index with a given BTC PK under a given finality provider
 func (k Keeper) getBTCConsumerDelegatorDelegationIndex(ctx context.Context, fpBTCPK *bbn.BIP340PubKey, delBTCPK *bbn.BIP340PubKey) *bstypes.BTCDelegatorDelegationIndex {
 	// ensure the finality provider exists

x/btcstaking/keeper/btc_delegations.go

@@ -108,6 +108,21 @@ func (k Keeper) addCovenantSigsToBTCDelegation(
 		activeEvent := types.NewEventPowerDistUpdateWithBTCDel(event)
 		btcTip := k.btclcKeeper.GetTipInfo(ctx)
 		k.addPowerDistUpdateEvent(ctx, btcTip.Height, activeEvent)
+
+		// get consumer ids of only non-Babylon finality providers
+		restakedFPConsumerIDs, err := k.restakedFPConsumerIDs(ctx, btcDel.FpBtcPkList)
+		if err != nil {
+			panic(fmt.Errorf("failed to get consumer ids for the restaked BTC delegation: %w", err))
+		}
+		consumerEvent, err := types.CreateActiveBTCDelegationEvent(btcDel)
+		if err != nil {
+			panic(fmt.Errorf("failed to create active BTC delegation event: %w", err))
+		}
+		for _, consumerID := range restakedFPConsumerIDs {
+			if err := k.AddBTCStakingConsumerEvent(ctx, consumerID, consumerEvent); err != nil {
+				panic(fmt.Errorf("failed to add active BTC delegation event: %w", err))
+			}
+		}
 	}
 }
 
@@ -137,6 +152,22 @@ func (k Keeper) btcUndelegate(
 	unbondedEvent := types.NewEventPowerDistUpdateWithBTCDel(event)
 	btcTip := k.btclcKeeper.GetTipInfo(ctx)
 	k.addPowerDistUpdateEvent(ctx, btcTip.Height, unbondedEvent)
+
+	// get consumer ids of only non-Babylon finality providers
+	restakedFPConsumerIDs, err := k.restakedFPConsumerIDs(ctx, btcDel.FpBtcPkList)
+	if err != nil {
+		panic(fmt.Errorf("failed to get consumer ids for the restaked BTC delegation: %w", err))
+	}
+	// create consumer event for unbonded BTC delegation and add it to the consumer's event store
+	consumerEvent, err := types.CreateUnbondedBTCDelegationEvent(btcDel)
+	if err != nil {
+		panic(fmt.Errorf("failed to create unbonded BTC delegation event: %w", err))
+	}
+	for _, consumerID := range restakedFPConsumerIDs {
+		if err = k.AddBTCStakingConsumerEvent(ctx, consumerID, consumerEvent); err != nil {
+			panic(fmt.Errorf("failed to add active BTC delegation event: %w", err))
+		}
+	}
 }
 
 func (k Keeper) setBTCDelegation(ctx context.Context, btcDel *types.BTCDelegation) {
@@ -150,10 +181,8 @@ func (k Keeper) setBTCDelegation(ctx context.Context, btcDel *types.BTCDelegatio
 // one of them is a Babylon finality provider. It also checks whether the BTC stake is
 // restaked to FPs of consumer chains
 func (k Keeper) validateRestakedFPs(ctx context.Context, fpBTCPKs []bbn.BIP340PubKey) (bool, error) {
-	var (
-		restakedToBabylon   = false
-		restakedToConsumers = false
-	)
+	restakedToBabylon := false
+	restakedToConsumers := false
 
 	for _, fpBTCPK := range fpBTCPKs {
 		// find the fp and determine whether it's Babylon fp or consumer chain fp
@@ -162,7 +191,6 @@ func (k Keeper) validateRestakedFPs(ctx context.Context, fpBTCPKs []bbn.BIP340Pu
 			if fp.IsSlashed() {
 				return false, types.ErrFpAlreadySlashed
 			}
-			// ensure the finality provider's registered epoch is finalised
 			restakedToBabylon = true
 			continue
 		} else if consumerID, err := k.bscKeeper.GetConsumerOfFinalityProvider(ctx, &fpBTCPK); err == nil {
@@ -174,7 +202,6 @@ func (k Keeper) validateRestakedFPs(ctx context.Context, fpBTCPKs []bbn.BIP340Pu
 			if fp.IsSlashed() {
 				return false, types.ErrFpAlreadySlashed
 			}
-			// ensure the finality provider's registered epoch is finalised
 			restakedToConsumers = true
 			continue
 		} else {
@@ -188,6 +215,23 @@ func (k Keeper) validateRestakedFPs(ctx context.Context, fpBTCPKs []bbn.BIP340Pu
 	return restakedToConsumers, nil
 }
 
+// restakedFPConsumerIDs returns the consumer IDs of non-Babylon finality providers
+func (k Keeper) restakedFPConsumerIDs(ctx context.Context, fpBTCPKs []bbn.BIP340PubKey) ([]string, error) {
+	var consumerIDs []string
+
+	for _, fpBTCPK := range fpBTCPKs {
+		if _, err := k.GetFinalityProvider(ctx, fpBTCPK); err == nil {
+			continue
+		} else if consumerID, err := k.bscKeeper.GetConsumerOfFinalityProvider(ctx, &fpBTCPK); err == nil {
+			consumerIDs = append(consumerIDs, consumerID)
+		} else {
+			return nil, types.ErrFpNotFound.Wrapf("finality provider pk %s is not found", fpBTCPK.MarshalHex())
+		}
+	}
+
+	return consumerIDs, nil
+}
+
 // GetBTCDelegation gets the BTC delegation with a given staking tx hash
 func (k Keeper) GetBTCDelegation(ctx context.Context, stakingTxHashStr string) (*types.BTCDelegation, error) {
 	// decode staking tx hash string