feat(utxo-staking): force ECDSA signature for Babylon BTC staking

Implement BitGoStakingManager class that extends BabylonBtcStakingManager
to use ECDSA signatures instead of BIP322. This supports compatibility
with existing wallet functionality.

Issue: BTC-2079

Co-authored-by: llm-git <[email protected]>

Author: OttoAllmendinger

modules/utxo-staking/src/babylon/stakingManager.ts

@@ -1,9 +1,81 @@
 import * as bitcoinjslib from 'bitcoinjs-lib';
 import * as utxolib from '@bitgo/utxo-lib';
 import * as vendor from '@bitgo/babylonlabs-io-btc-staking-ts';
+import {
+  BIP322Sig,
+  BTCSigType,
+  ProofOfPossessionBTC,
+} from '@babylonlabs-io/babylon-proto-ts/dist/generated/babylon/btcstaking/v1/pop';
 
 import { getStakingParams } from './stakingParams';
 
+/**
+ * Subclass of BabylonBtcStakingManager with the sole purpose of forcing
+ * a ECDSA signature.
+ */
+class BitGoStakingManager extends vendor.BabylonBtcStakingManager {
+  constructor(
+    network: bitcoinjslib.Network,
+    stakingParams: vendor.VersionedStakingParams[],
+    btcProvider: vendor.BtcProvider,
+    babylonProvider: vendor.BabylonProvider
+  ) {
+    super(network, stakingParams, btcProvider, babylonProvider);
+  }
+
+  /**
+   * Creates a proof of possession for the staker based on ECDSA signature.
+   *
+   * This is a parameterized version of the superclass method which infers
+   * the signature type from the stakerBtcAddress.
+   *
+   * @param bech32Address - The staker's bech32 address on the babylon network.
+   * @param stakerBtcAddress - The staker's BTC address.
+   * @param sigType - The signature type (BIP322 or ECDSA).
+   * @returns The proof of possession.
+   */
+  async createProofOfPossessionWithSigType(
+    bech32Address: string,
+    stakerBtcAddress: string,
+    sigType: BTCSigType
+  ): Promise<ProofOfPossessionBTC> {
+    const signedBabylonAddress = await this.btcProvider.signMessage(
+      vendor.SigningStep.PROOF_OF_POSSESSION,
+      bech32Address,
+      sigType === BTCSigType.BIP322 ? 'bip322-simple' : 'ecdsa'
+    );
+
+    let btcSig: Uint8Array;
+    if (sigType === BTCSigType.BIP322) {
+      const bip322Sig = BIP322Sig.fromPartial({
+        address: stakerBtcAddress,
+        sig: Buffer.from(signedBabylonAddress, 'base64'),
+      });
+      // Encode the BIP322 protobuf message to a Uint8Array
+      btcSig = BIP322Sig.encode(bip322Sig).finish();
+    } else {
+      // Encode the ECDSA signature to a Uint8Array
+      btcSig = Buffer.from(signedBabylonAddress, 'base64');
+    }
+
+    return {
+      btcSigType: sigType,
+      btcSig,
+    };
+  }
+
+  /**
+   * Creates a proof of possession for the staker based on ECDSA signature.
+   * @param bech32Address - The staker's bech32 address on the babylon network.
+   * @param stakerBtcAddress
+   * @returns The proof of possession.
+   */
+  async createProofOfPossession(bech32Address: string, stakerBtcAddress: string): Promise<ProofOfPossessionBTC> {
+    // force the ECDSA signature type
+    return this.createProofOfPossessionWithSigType(bech32Address, stakerBtcAddress, BTCSigType.ECDSA);
+  }
+}
+
 export const mockBabylonProvider: vendor.BabylonProvider = {
   signTransaction(): Promise<Uint8Array> {
     throw new Error('Function not implemented.');
@@ -31,10 +103,5 @@ export function createStakingManager(
         throw new Error('Unsupported network');
     }
   }
-  return new vendor.BabylonBtcStakingManager(
-    network,
-    stakingParams ?? getStakingParams(network),
-    btcProvider,
-    babylonProvider
-  );
+  return new BitGoStakingManager(network, stakingParams ?? getStakingParams(network), btcProvider, babylonProvider);
 }

modules/utxo-staking/test/unit/babylon/transactions.ts

@@ -178,9 +178,16 @@ function parseScripts(scripts: unknown) {
   return Object.fromEntries(Object.entries(scripts).map(([key, value]) => [key, parseScript(key, value)]));
 }
 
-async function assertEqualsFixture(fixtureName: string, value: unknown): Promise<void> {
-  value = normalize(value);
-  assert.deepStrictEqual(await getFixture(fixtureName, value), value);
+type EqualsAssertion = typeof assert.deepStrictEqual;
+
+async function assertEqualsFixture(
+  fixtureName: string,
+  value: unknown,
+  n = normalize,
+  eq: EqualsAssertion = assert.deepStrictEqual
+): Promise<void> {
+  value = n(value);
+  eq(await getFixture(fixtureName, value), value);
 }
 
 async function assertScriptsEqualFixture(
@@ -379,7 +386,20 @@ function describeWithKeys(
               utxo,
               feeRateSatB,
               800_000
-            )
+            ),
+            normalize,
+            (a, b) => {
+              // The vendor library serializes the signature as BIP322, while
+              // our implementation serializes it as ECDSA.
+              // Strip the pop field from the MsgCreateBTCDelegation.
+              function stripPop(v: unknown) {
+                const vAny = v as any;
+                delete vAny['unsignedDelegationMsg']['value']['pop'];
+              }
+              stripPop(a);
+              stripPop(b);
+              assert.deepStrictEqual(a, b);
+            }
           );
         }
       });