Merge pull request #6027 from BitGo/BTC-2079.force-ecdsa

feat(utxo-staking): implement ECDSA support for Babylon BTC staking

Author: OttoAllmendinger

modules/babylonlabs-io-btc-staking-ts/src/staking/manager.ts

@@ -93,10 +93,10 @@ interface InclusionProof {
 }
 
 export class BabylonBtcStakingManager {
-  private stakingParams: VersionedStakingParams[];
-  private btcProvider: BtcProvider;
-  private network: networks.Network;
-  private babylonProvider: BabylonProvider;
+  protected stakingParams: VersionedStakingParams[];
+  protected btcProvider: BtcProvider;
+  protected network: networks.Network;
+  protected babylonProvider: BabylonProvider;
 
   constructor(
     network: networks.Network,
@@ -624,7 +624,8 @@ export class BabylonBtcStakingManager {
 
   /**
    * Creates a proof of possession for the staker based on ECDSA signature.
-   * @param bech32Address - The staker's bech32 address.
+   * @param bech32Address - The staker's bech32 address on the babylon chain
+   * @param stakerBtcAddress - The staker's BTC address.
    * @returns The proof of possession.
    */
   async createProofOfPossession(

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

@@ -19,6 +19,38 @@ import { BabylonNetworkLike, toBitcoinJsNetwork } from './network';
 
 export type ValueWithTypeUrl<T> = { typeUrl: string; value: T };
 
+/**
+ * Decode a hex or base64 encoded string and check if the length is valid.
+ * @param v
+ * @param encoding
+ */
+function decodeCheck(v: string, encoding: 'hex' | 'base64') {
+  const result = Buffer.from(v, encoding);
+  if (result.toString(encoding).length !== v.length) {
+    throw new Error(`Invalid ${encoding} encoding`);
+  }
+  return result;
+}
+
+/**
+ * Convert a Buffer or string to a base64 encoded string.
+ * @param v
+ */
+function toBase64(v: Buffer | string) {
+  if (typeof v === 'string') {
+    for (const encoding of ['base64', 'hex'] as const) {
+      try {
+        return toBase64(decodeCheck(v, encoding));
+      } catch (e) {
+        // try next
+      }
+    }
+    throw new Error(`Invalid base64 or hex encoding: ${v}`);
+  }
+
+  return v.toString('base64');
+}
+
 export function getSignedPsbt(
   psbt: bitcoinjslib.Psbt,
   descriptor: Descriptor,
@@ -106,6 +138,12 @@ export function getBtcProviderForECKey(
   }
 
   return {
+    /**
+     * @param signingStep
+     * @param message
+     * @param type
+     * @returns Base64 encoded string
+     */
     async signMessage(
       signingStep: vendor.SigningStep,
       message: string,
@@ -114,9 +152,9 @@ export function getBtcProviderForECKey(
       assert(signingStep === 'proof-of-possession');
       switch (type) {
         case 'ecdsa':
-          return stakerKey.sign(Buffer.from(message, 'hex')).toString('hex');
+          return toBase64(stakerKey.sign(Buffer.from(message, 'hex')));
         case 'bip322-simple':
-          return signBip322Simple(message);
+          return toBase64(signBip322Simple(message));
         default:
           throw new Error(`unexpected signing step: ${signingStep}`);
       }

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);
+            }
           );
         }
       });