feat: ADR-23 Update staking parameters structure (#45)

ref: babylonlabs-io/pm#19
Implement ADR-23 to make babylon chain parameters compatible with
[phase-1](https://github.com/babylonlabs-io/pm/blob/main/adr/adr-023-update-btcstaking-params.md)

app/upgrades/signetlaunch/btcstaking_params.go

@@ -0,0 +1,26 @@
+package signetlaunch
+
+// TODO Some default parameters. Consider how to switch those depending on network:
+// mainnet, testnet, devnet etc.
+const BtcStakingParamStr = `
+	{
+  "covenant_pks": [
+    "43311589af63c2adda04fcd7792c038a05c12a4fe40351b3eb1612ff6b2e5a0e",
+    "d415b187c6e7ce9da46ac888d20df20737d6f16a41639e68ea055311e1535dd9",
+    "d27cd27dbff481bc6fc4aa39dd19405eb6010237784ecba13bab130a4a62df5d",
+    "a3e107fee8879f5cf901161dbf4ff61c252ba5fec6f6407fe81b9453d244c02c",
+    "c45753e856ad0abb06f68947604f11476c157d13b7efd54499eaa0f6918cf716"
+  ],
+  "covenant_quorum": 3,
+  "min_staking_value_sat": "1000",
+  "max_staking_value_sat": "10000000000",
+  "min_staking_time_blocks": 10,
+  "max_staking_time_blocks": 65535,
+  "slashing_pk_script": "dqkUAQEBAQEBAQEBAQEBAQEBAQEBAQGIrA==",
+  "min_slashing_tx_fee_sat": "1000",
+  "slashing_rate": "0.100000000000000000",
+  "min_unbonding_time_blocks": 0,
+  "unbonding_fee_sat": "1000",
+  "min_commission_rate": "0.03",
+  "max_active_finality_providers": 100
+}`

app/upgrades/signetlaunch/btcstaking_params_test.go

@@ -0,0 +1,16 @@
+package signetlaunch_test
+
+import (
+	"testing"
+
+	"github.com/babylonlabs-io/babylon/app"
+	v1 "github.com/babylonlabs-io/babylon/app/upgrades/signetlaunch"
+	"github.com/stretchr/testify/require"
+)
+
+func TestHardCodedParamsAreValid(t *testing.T) {
+	bbnApp := app.NewTmpBabylonApp()
+	loadedParamas, err := v1.LoadBtcStakingParamsFromData(bbnApp.AppCodec())
+	require.NoError(t, err)
+	require.NoError(t, loadedParamas.Validate())
+}

app/upgrades/signetlaunch/upgrades.go

@@ -53,6 +53,11 @@ func CreateUpgradeHandler(
 			return nil, err
 		}
 
+		// Upgrade the staking parameters as first, as other upgrades depend on it.
+		if err := upgradeBtcStakingParameters(ctx, keepers.EncCfg, &keepers.BTCStakingKeeper); err != nil {
+			panic(err)
+		}
+
 		if err := propLaunch(ctx, keepers.EncCfg, &keepers.BTCLightClientKeeper, &keepers.BTCStakingKeeper); err != nil {
 			panic(err)
 		}
@@ -61,6 +66,37 @@ func CreateUpgradeHandler(
 	}
 }
 
+func LoadBtcStakingParamsFromData(cdc codec.Codec) (btcstktypes.Params, error) {
+	buff := bytes.NewBufferString(BtcStakingParamStr)
+
+	var params btcstktypes.Params
+	err := cdc.UnmarshalJSON(buff.Bytes(), &params)
+	if err != nil {
+		return btcstktypes.Params{}, err
+	}
+
+	return params, nil
+}
+
+func upgradeBtcStakingParameters(
+	ctx sdk.Context,
+	e *appparams.EncodingConfig,
+	k *btcstkkeeper.Keeper,
+) error {
+
+	cdc := e.Codec
+
+	params, err := LoadBtcStakingParamsFromData(cdc)
+
+	if err != nil {
+		return err
+	}
+
+	// We are overwriting the params at version 0, as the upgrade is happening from
+	// TGE chain so there should be only one version of the params
+	return k.OverwriteParamsAtVersion(ctx, 0, params)
+}
+
 // propLaunch runs the proposal of launch that is meant to insert new BTC Headers.
 func propLaunch(
 	ctx sdk.Context,

app/upgrades/signetlaunch/upgrades_test.go

@@ -73,6 +73,12 @@ func (s *UpgradeTestSuite) TestUpgrade() {
 				resp, err := s.app.BTCStakingKeeper.FinalityProviders(s.ctx, &types.QueryFinalityProvidersRequest{})
 				s.NoError(err)
 				oldFPsLen = len(resp.FinalityProviders)
+
+				// Before upgrade, the params should be different
+				paramsFromUpgrade, err := v1.LoadBtcStakingParamsFromData(s.app.AppCodec())
+				s.NoError(err)
+				moduleParams := s.app.BTCStakingKeeper.GetParams(s.ctx)
+				s.NotEqualValues(moduleParams, paramsFromUpgrade)
 			},
 			func() {
 				// inject upgrade plan
@@ -128,6 +134,12 @@ func (s *UpgradeTestSuite) TestUpgrade() {
 					s.EqualValues(fpFromKeeper.Commission.String(), fpInserted.Commission.String())
 					s.EqualValues(fpFromKeeper.Pop.String(), fpInserted.Pop.String())
 				}
+
+				// Afer upgrade, the params should be the same
+				paramsFromUpgrade, err := v1.LoadBtcStakingParamsFromData(s.app.AppCodec())
+				s.NoError(err)
+				moduleParams := s.app.BTCStakingKeeper.GetParams(s.ctx)
+				s.EqualValues(moduleParams, paramsFromUpgrade)
 			},
 		},
 	}

btcstaking/staking.go

@@ -36,7 +36,8 @@ import (
 func buildSlashingTxFromOutpoint(
 	stakingOutput wire.OutPoint,
 	stakingAmount, fee int64,
-	slashingAddress, changeAddress btcutil.Address,
+	slashingPkScript []byte,
+	changeAddress btcutil.Address,
 	slashingRate sdkmath.LegacyDec,
 ) (*wire.MsgTx, error) {
 	// Validate staking amount
@@ -49,6 +50,10 @@ func buildSlashingTxFromOutpoint(
 		return nil, ErrInvalidSlashingRate
 	}
 
+	if len(slashingPkScript) == 0 {
+		return nil, fmt.Errorf("slashing pk script must not be empty")
+	}
+
 	// Calculate the amount to be slashed
 	slashingRateFloat64, err := slashingRate.Float64()
 	if err != nil {
@@ -58,11 +63,6 @@ func buildSlashingTxFromOutpoint(
 	if slashingAmount <= 0 {
 		return nil, ErrInsufficientSlashingAmount
 	}
-	// Generate script for slashing address
-	slashingAddrScript, err := txscript.PayToAddrScript(slashingAddress)
-	if err != nil {
-		return nil, err
-	}
 
 	// Calculate the change amount
 	changeAmount := btcutil.Amount(stakingAmount) - slashingAmount - btcutil.Amount(fee)
@@ -81,7 +81,7 @@ func buildSlashingTxFromOutpoint(
 	// means this tx is not replacable.
 	input := wire.NewTxIn(&stakingOutput, nil, nil)
 	tx.AddTxIn(input)
-	tx.AddTxOut(wire.NewTxOut(int64(slashingAmount), slashingAddrScript))
+	tx.AddTxOut(wire.NewTxOut(int64(slashingAmount), slashingPkScript))
 	tx.AddTxOut(wire.NewTxOut(int64(changeAmount), changeAddrScript))
 
 	// Verify that the none of the outputs is a dust output.
@@ -140,7 +140,7 @@ func getPossibleStakingOutput(
 func BuildSlashingTxFromStakingTxStrict(
 	stakingTx *wire.MsgTx,
 	stakingOutputIdx uint32,
-	slashingAddress btcutil.Address,
+	slashingPkScript []byte,
 	stakerPk *btcec.PublicKey,
 	slashChangeLockTime uint16,
 	fee int64,
@@ -172,7 +172,7 @@ func BuildSlashingTxFromStakingTxStrict(
 	return buildSlashingTxFromOutpoint(
 		*stakingOutpoint,
 		stakingOutput.Value, fee,
-		slashingAddress, si.TapAddress,
+		slashingPkScript, si.TapAddress,
 		slashingRate)
 }
 
@@ -228,7 +228,7 @@ func IsSimpleTransfer(tx *wire.MsgTx) error {
 // - the min fee for slashing tx is preserved
 func validateSlashingTx(
 	slashingTx *wire.MsgTx,
-	slashingAddress btcutil.Address,
+	slashingPkScript []byte,
 	slashingRate sdkmath.LegacyDec,
 	slashingTxMinFee, stakingOutputValue int64,
 	stakerPk *btcec.PublicKey,
@@ -270,11 +270,6 @@ func validateSlashingTx(
 		return fmt.Errorf("slashing transaction must slash at least staking output value * slashing rate")
 	}
 
-	// Verify that the first output pays to the provided slashing address.
-	slashingPkScript, err := txscript.PayToAddrScript(slashingAddress)
-	if err != nil {
-		return fmt.Errorf("error creating slashing pk script: %w", err)
-	}
 	if !bytes.Equal(slashingTx.TxOut[0].PkScript, slashingPkScript) {
 		return fmt.Errorf("slashing transaction must pay to the provided slashing address")
 	}
@@ -341,7 +336,7 @@ func CheckTransactions(
 	fundingOutputIdx uint32,
 	slashingTxMinFee int64,
 	slashingRate sdkmath.LegacyDec,
-	slashingAddress btcutil.Address,
+	slashingPkScript []byte,
 	stakerPk *btcec.PublicKey,
 	slashingChangeLockTime uint16,
 	net *chaincfg.Params,
@@ -376,7 +371,7 @@ func CheckTransactions(
 	// 3. Check if slashing transaction is valid
 	if err := validateSlashingTx(
 		slashingTx,
-		slashingAddress,
+		slashingPkScript,
 		slashingRate,
 		slashingTxMinFee,
 		stakingOutput.Value,

btcstaking/staking_test.go

@@ -151,11 +151,14 @@ func testSlashingTx(
 	slashingAddress, err := genRandomBTCAddress(r)
 	require.NoError(t, err)
 
+	slashingPkScript, err := txscript.PayToAddrScript(slashingAddress)
+	require.NoError(t, err)
+
 	// Construct slashing transaction using the provided parameters
 	slashingTx, err := btcstaking.BuildSlashingTxFromStakingTxStrict(
 		stakingTx,
 		uint32(stakingOutputIdx),
-		slashingAddress,
+		slashingPkScript,
 		stakerPk,
 		slashingChangeLockTime,
 		fee,
@@ -196,7 +199,7 @@ func testSlashingTx(
 				uint32(stakingOutputIdx),
 				fee,
 				slashingRate,
-				slashingAddress,
+				slashingPkScript,
 				stakerPk,
 				slashingChangeLockTime,
 				&chaincfg.MainNetParams,
@@ -280,11 +283,14 @@ func TestSlashingTxWithOverflowMustNotAccepted(t *testing.T) {
 	slashingAddress, err := genRandomBTCAddress(r)
 	require.NoError(t, err)
 
+	slashingPkScript, err := txscript.PayToAddrScript(slashingAddress)
+	require.NoError(t, err)
+
 	// Construct slashing transaction using the provided parameters
 	slashingTx, err := btcstaking.BuildSlashingTxFromStakingTxStrict(
 		stakingTx,
 		uint32(0),
-		slashingAddress,
+		slashingPkScript,
 		sd.StakerKey,
 		slashingLockTime,
 		int64(minFee),
@@ -303,7 +309,7 @@ func TestSlashingTxWithOverflowMustNotAccepted(t *testing.T) {
 		uint32(0),
 		int64(minFee),
 		slashingRate,
-		slashingAddress,
+		slashingPkScript,
 		sd.StakerKey,
 		slashingLockTime,
 		&chaincfg.MainNetParams,

cmd/babylond/cmd/flags.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"encoding/hex"
 	"strings"
 	"time"
 
@@ -35,10 +36,14 @@ const (
 	flagVoteExtensionEnableHeight  = "vote-extension-enable-height"
 	flagCovenantPks                = "covenant-pks"
 	flagCovenantQuorum             = "covenant-quorum"
+	flagMinStakingAmtSat           = "min-staking-amount-sat"
+	flagMaxStakingAmtSat           = "max-staking-amount-sat"
+	flagMinStakingTimeBlocks       = "min-staking-time-blocks"
+	flagMaxStakingTimeBlocks       = "max-staking-time-blocks"
 	flagMaxActiveFinalityProviders = "max-active-finality-providers"
 	flagMinUnbondingTime           = "min-unbonding-time"
-	flagMinUnbondingRate           = "min-unbonding-rate"
-	flagSlashingAddress            = "slashing-address"
+	flagUnbondingFeeSat            = "unbonding-fee-sat"
+	flagSlashingPkScript           = "slashing-pk-script"
 	flagMinSlashingFee             = "min-slashing-fee-sat"
 	flagSlashingRate               = "slashing-rate"
 	flagMinCommissionRate          = "min-commission-rate"
@@ -64,12 +69,16 @@ type GenesisCLIArgs struct {
 	VoteExtensionEnableHeight    int64
 	CovenantPKs                  []string
 	CovenantQuorum               uint32
-	SlashingAddress              string
+	MinStakingAmtSat             int64
+	MaxStakingAmtSat             int64
+	MinStakingTimeBlocks         uint16
+	MaxStakingTimeBlocks         uint16
+	SlashingPkScript             string
 	MinSlashingTransactionFeeSat int64
 	SlashingRate                 math.LegacyDec
 	MaxActiveFinalityProviders   uint32
 	MinUnbondingTime             uint16
-	MinUnbondingRate             math.LegacyDec
+	UnbondingFeeSat              int64
 	MinCommissionRate            math.LegacyDec
 }
 
@@ -91,13 +100,17 @@ func addGenesisFlags(cmd *cobra.Command) {
 	// btcstaking args
 	cmd.Flags().String(flagCovenantPks, strings.Join(btcstypes.DefaultParams().CovenantPksHex(), ","), "Bitcoin staking covenant public keys, comma separated")
 	cmd.Flags().Uint32(flagCovenantQuorum, btcstypes.DefaultParams().CovenantQuorum, "Bitcoin staking covenant quorum")
-	cmd.Flags().String(flagSlashingAddress, btcstypes.DefaultParams().SlashingAddress, "Bitcoin staking slashing address")
+	cmd.Flags().Int64(flagMinStakingAmtSat, 500000, "Minimum staking amount in satoshis")
+	cmd.Flags().Int64(flagMaxStakingAmtSat, 100000000000, "Maximum staking amount in satoshis")
+	cmd.Flags().Uint16(flagMinStakingTimeBlocks, 100, "Minimum staking time in blocks")
+	cmd.Flags().Uint16(flagMaxStakingTimeBlocks, 10000, "Maximum staking time in blocks")
+	cmd.Flags().String(flagSlashingPkScript, hex.EncodeToString(btcstypes.DefaultParams().SlashingPkScript), "Bitcoin staking slashing pk script. Hex encoded.")
 	cmd.Flags().Int64(flagMinSlashingFee, 1000, "Bitcoin staking minimum slashing fee")
 	cmd.Flags().String(flagMinCommissionRate, "0", "Bitcoin staking validator minimum commission rate")
 	cmd.Flags().String(flagSlashingRate, "0.1", "Bitcoin staking slashing rate")
 	cmd.Flags().Uint32(flagMaxActiveFinalityProviders, 100, "Bitcoin staking maximum active finality providers")
 	cmd.Flags().Uint16(flagMinUnbondingTime, 0, "Min timelock on unbonding transaction in btc blocks")
-	cmd.Flags().String(flagMinUnbondingRate, "0.8", "Min amount of btc required in unbonding output expressed as a fraction of staking output")
+	cmd.Flags().Int64(flagUnbondingFeeSat, 1000, "Required fee for unbonding transaction in satoshis")
 	// inflation args
 	cmd.Flags().Float64(flagInflationRateChange, 0.13, "Inflation rate change")
 	cmd.Flags().Float64(flagInflationMax, 0.2, "Maximum inflation")
@@ -123,13 +136,17 @@ func parseGenesisFlags(cmd *cobra.Command) *GenesisCLIArgs {
 	reporterAddresses, _ := cmd.Flags().GetString(flagAllowedReporterAddresses)
 	covenantPks, _ := cmd.Flags().GetString(flagCovenantPks)
 	covenantQuorum, _ := cmd.Flags().GetUint32(flagCovenantQuorum)
-	slashingAddress, _ := cmd.Flags().GetString(flagSlashingAddress)
+	minStakingAmtSat, _ := cmd.Flags().GetInt64(flagMinStakingAmtSat)
+	maxStakingAmtSat, _ := cmd.Flags().GetInt64(flagMaxStakingAmtSat)
+	minStakingTimeBlocks, _ := cmd.Flags().GetUint16(flagMinStakingTimeBlocks)
+	maxStakingTimeBlocks, _ := cmd.Flags().GetUint16(flagMaxStakingTimeBlocks)
+	slashingPkScript, _ := cmd.Flags().GetString(flagSlashingPkScript)
 	minSlashingFee, _ := cmd.Flags().GetInt64(flagMinSlashingFee)
 	minCommissionRate, _ := cmd.Flags().GetString(flagMinCommissionRate)
 	slashingRate, _ := cmd.Flags().GetString(flagSlashingRate)
 	maxActiveFinalityProviders, _ := cmd.Flags().GetUint32(flagMaxActiveFinalityProviders)
 	minUnbondingTime, _ := cmd.Flags().GetUint16(flagMinUnbondingTime)
-	minUnbondingRate, _ := cmd.Flags().GetString(flagMinUnbondingRate)
+	unbondingFeeSat, _ := cmd.Flags().GetInt64(flagUnbondingFeeSat)
 	genesisTimeUnix, _ := cmd.Flags().GetInt64(flagGenesisTime)
 	inflationRateChange, _ := cmd.Flags().GetFloat64(flagInflationRateChange)
 	inflationMax, _ := cmd.Flags().GetFloat64(flagInflationMax)
@@ -162,13 +179,17 @@ func parseGenesisFlags(cmd *cobra.Command) *GenesisCLIArgs {
 		AllowedReporterAddresses:     allowedReporterAddresses,
 		CovenantPKs:                  strings.Split(covenantPks, ","),
 		CovenantQuorum:               covenantQuorum,
-		SlashingAddress:              slashingAddress,
+		MinStakingAmtSat:             minStakingAmtSat,
+		MaxStakingAmtSat:             maxStakingAmtSat,
+		MinStakingTimeBlocks:         minStakingTimeBlocks,
+		MaxStakingTimeBlocks:         maxStakingTimeBlocks,
+		SlashingPkScript:             slashingPkScript,
 		MinSlashingTransactionFeeSat: minSlashingFee,
 		MinCommissionRate:            math.LegacyMustNewDecFromStr(minCommissionRate),
 		SlashingRate:                 math.LegacyMustNewDecFromStr(slashingRate),
 		MaxActiveFinalityProviders:   maxActiveFinalityProviders,
 		MinUnbondingTime:             minUnbondingTime,
-		MinUnbondingRate:             math.LegacyMustNewDecFromStr(minUnbondingRate),
+		UnbondingFeeSat:              unbondingFeeSat,
 		GenesisTime:                  genesisTime,
 		InflationRateChange:          inflationRateChange,
 		InflationMax:                 inflationMax,