chore: removed check cov key must be signer of previous stk tx (#128)

* chore: removed check where the covenant key doesn't need to have signed the previous staking tx

* chore: add #128 to cl

* fix: unit test

Author: RafilxTenfen

CHANGELOG.md

@@ -41,6 +41,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 * [#125](https://github.com/babylonlabs-io/covenant-emulator/pull/125) Update config defaults for gas adjustment and cov batch sigs.
 * [#127](https://github.com/babylonlabs-io/covenant-emulator/pull/127) Add Stake Expansion support
+* [#128](https://github.com/babylonlabs-io/covenant-emulator/pull/128) Removed check where the covenant needs to have signed the
+previous staking transaction to sign the stake expansion tx.
 
 ## v0.15.1
 

covenant/covenant.go

@@ -612,7 +612,7 @@ func AcceptDelegationToSign(
 	}
 	// 3. For stake expansion, verify if the covenant is in the committee of the previous active delegation
 	if del.IsStakeExpansion() {
-		valid, err := validateStakeExpansion(paramCache, covenantSerializedPk, del, prevDel)
+		valid, err := ValidateStakeExpansion(paramCache, covenantSerializedPk, del, prevDel)
 		if err != nil {
 			return false, err
 		}
@@ -625,9 +625,9 @@ func AcceptDelegationToSign(
 	return true, nil
 }
 
-// validateStakeExpansion validates that a stake expansion delegation is properly configured
+// ValidateStakeExpansion validates that a stake expansion delegation is properly configured
 // and that the covenant was in the committee for the previous delegation.
-func validateStakeExpansion(
+func ValidateStakeExpansion(
 	paramCache ParamsGetter,
 	covenantSerializedPk []byte,
 	del *types.Delegation,
@@ -649,8 +649,7 @@ func validateStakeExpansion(
 			del.StakeExpansion.PreviousStakingTxHashHex, prevStakingTxHash)
 	}
 
-	// Verifications on the previous delegation
-	// 1. Verify that the current covenant was in the committee for the previous delegation
+	// Verify that the current covenant was in the committee for the previous delegation
 	isInCommittee, err := IsKeyInCommittee(paramCache, covenantSerializedPk, prevDel)
 	if err != nil {
 		return false, fmt.Errorf("unable to verify if covenant key is in committee: %w", err)
@@ -659,12 +658,6 @@ func validateStakeExpansion(
 		return false, nil
 	}
 
-	// 2. The previous delegation should already have a covenant signature
-	if !CovenantAlreadySigned(covenantSerializedPk, prevDel) {
-		return false, fmt.Errorf("covenant %s did not sign the previous delegation %s of a stake expansion",
-			hex.EncodeToString(covenantSerializedPk), del.StakeExpansion.PreviousStakingTxHashHex)
-	}
-
 	return true, nil
 }
 

covenant/covenant_test.go

@@ -350,7 +350,6 @@ func TestIsKeyInCommittee(t *testing.T) {
 		ParamsVersion: pVersionWithCovenant,
 	}
 
-	// simple mock with the parameter versions
 	paramsGet := NewMockParam(map[uint32]*types.StakingParams{
 		pVersionWithoutCovenant: paramsWithoutCovenant,
 		pVersionWithCovenant:    paramsWithCovenant,
@@ -411,3 +410,134 @@ func NewMockParamError(err error) *MockParamError {
 func (m *MockParamError) Get(version uint32) (*types.StakingParams, error) {
 	return nil, m.err
 }
+
+func TestValidateStakeExpansion(t *testing.T) {
+	r := rand.New(rand.NewSource(time.Now().Unix()))
+
+	covenantConfig := covcfg.DefaultConfig()
+	covenantConfig.BabylonConfig.KeyDirectory = t.TempDir()
+
+	covKeyPairInCommittee, err := keyring.CreateCovenantKey(
+		covenantConfig.BabylonConfig.KeyDirectory,
+		covenantConfig.BabylonConfig.ChainID,
+		covenantConfig.BabylonConfig.Key,
+		covenantConfig.BabylonConfig.KeyringBackend,
+		passphrase,
+		hdPath,
+	)
+	require.NoError(t, err)
+
+	covKeyInCommittee := schnorr.SerializePubKey(covKeyPairInCommittee.PublicKey)
+	pubKeyFromSchnorr, err := schnorr.ParsePubKey(covKeyInCommittee)
+	require.NoError(t, err)
+
+	badCovKey, err := keyring.CreateCovenantKey(
+		covenantConfig.BabylonConfig.KeyDirectory,
+		covenantConfig.BabylonConfig.ChainID,
+		"other-covenant-key",
+		covenantConfig.BabylonConfig.KeyringBackend,
+		passphrase,
+		hdPath,
+	)
+	require.NoError(t, err)
+	covKeyNotInCommittee := schnorr.SerializePubKey(badCovKey.PublicKey)
+
+	pVersionWithoutCovenant := uint32(datagen.RandomInRange(r, 1, 10))
+	pVersionWithCovenant := pVersionWithoutCovenant + 1
+
+	paramsWithoutCovenant := testutil.GenRandomParams(r, t)
+	paramsWithCovenant := testutil.GenRandomParams(r, t)
+	paramsWithCovenant.CovenantPks = append(paramsWithCovenant.CovenantPks, covKeyPairInCommittee.PublicKey)
+
+	paramsGet := NewMockParam(map[uint32]*types.StakingParams{
+		pVersionWithoutCovenant: paramsWithoutCovenant,
+		pVersionWithCovenant:    paramsWithCovenant,
+	})
+
+	stkTxHex := "02000000012c1ca601b81bf5bdd97081d1bf17241d4d688f51ccbe8be3d3f3174d0e4e4aa40100000000ffffffff0250c3000000000000225120d0d55103aa70a12162f733805c3a2f5ff8e857d5fc92381c3d6f22a791165ac115400f00000000002251206f5ec73002ee8b5b2bb942f26e169354821e6ec06f9b3a1d3cf355d6f276c5d800000000"
+	stakingMsgTx, _, err := bbntypes.NewBTCTxFromHex(stkTxHex)
+	require.NoError(t, err)
+
+	prevStakingTxHashHex := stakingMsgTx.TxHash().String()
+	prevStk := types.Delegation{
+		StakingTxHex:  stkTxHex,
+		ParamsVersion: pVersionWithCovenant,
+		CovenantSigs:  []*types.CovenantAdaptorSigInfo{},
+	}
+	stkExp := types.Delegation{
+		StakingTxHex:  testutil.GenRandomHexStr(r, 100),
+		ParamsVersion: pVersionWithCovenant,
+		CovenantSigs:  []*types.CovenantAdaptorSigInfo{},
+		StakeExpansion: &types.DelegationStakeExpansion{
+			PreviousStakingTxHashHex: prevStakingTxHashHex,
+		},
+	}
+
+	t.Run("successful validation - covenant in previous committee and didn't sign", func(t *testing.T) {
+		valid, err := covenant.ValidateStakeExpansion(paramsGet, covKeyInCommittee, &stkExp, &prevStk)
+		require.NoError(t, err)
+		require.True(t, valid, "should be valid when covenant was in previous committee, even if it didn't sign")
+	})
+
+	t.Run("successful validation - covenant in previous committee and signed old del", func(t *testing.T) {
+		prevDel := prevStk
+		prevDel.CovenantSigs = append(prevDel.CovenantSigs, &types.CovenantAdaptorSigInfo{
+			Pk: pubKeyFromSchnorr,
+		})
+
+		valid, err := covenant.ValidateStakeExpansion(paramsGet, covKeyInCommittee, &stkExp, &prevDel)
+		require.NoError(t, err)
+		require.True(t, valid, "should be valid when covenant was in previous committee even if it did sign the previous")
+	})
+
+	t.Run("fails when param cache returns error", func(t *testing.T) {
+		cacheErr := fmt.Errorf("param cache connection error")
+		errorParamCache := NewMockParamError(cacheErr)
+
+		valid, errParamCache := covenant.ValidateStakeExpansion(errorParamCache, covKeyInCommittee, &stkExp, &prevStk)
+		require.False(t, valid)
+		require.EqualError(t, errParamCache, fmt.Sprintf("unable to verify if covenant key is in committee: unable to get the param version: %d, reason: %s", prevStk.ParamsVersion, cacheErr.Error()))
+	})
+
+	t.Run("fails when covenant never in previous committee", func(t *testing.T) {
+		valid, err := covenant.ValidateStakeExpansion(paramsGet, covKeyNotInCommittee, &stkExp, &prevStk)
+		require.NoError(t, err)
+		require.False(t, valid, "should fail when covenant was never in previous committee")
+	})
+
+	t.Run("fails when covenant not in previous committee", func(t *testing.T) {
+		prevDelWithoutCov := prevStk
+		prevDelWithoutCov.ParamsVersion = pVersionWithoutCovenant
+		valid, err := covenant.ValidateStakeExpansion(paramsGet, covKeyInCommittee, &stkExp, &prevDelWithoutCov)
+		require.NoError(t, err)
+		require.False(t, valid, "should fail when covenant was not in previous committee")
+	})
+
+	t.Run("fails when previous delegation is nil", func(t *testing.T) {
+		valid, err := covenant.ValidateStakeExpansion(paramsGet, covKeyInCommittee, &stkExp, nil)
+		require.False(t, valid)
+		require.EqualError(t, err, fmt.Sprintf("previous delegation is nil for stake expansion delegation: %s", prevStakingTxHashHex))
+	})
+
+	t.Run("fails when transaction hash mismatch", func(t *testing.T) {
+		wrongHash := datagen.GenRandomHexStr(r, 10)
+		mismatchedStkExp := stkExp
+		mismatchedStkExp.StakeExpansion.PreviousStakingTxHashHex = wrongHash
+
+		valid, err := covenant.ValidateStakeExpansion(paramsGet, covKeyInCommittee, &mismatchedStkExp, &prevStk)
+		require.False(t, valid)
+		require.EqualError(t, err, fmt.Sprintf("previous delegation staking tx hash mismatch: expected %s, got %s", wrongHash, prevStakingTxHashHex))
+	})
+
+	t.Run("fails when previous delegation has invalid staking tx", func(t *testing.T) {
+		invalidPrevDel := &types.Delegation{
+			StakingTxHex:  "invalid-hex-string",
+			ParamsVersion: pVersionWithCovenant,
+		}
+
+		valid, err := covenant.ValidateStakeExpansion(paramsGet, covKeyInCommittee, &stkExp, invalidPrevDel)
+		require.False(t, valid)
+		require.EqualError(t, err, "failed to decode previous delegation staking tx: encoding/hex: invalid byte: U+0069 'i'")
+	})
+
+}