@bitgo/utxo-staking 1.25.0 → 1.27.0

package/dist/esm/babylon/stakingManager.js

@@ -0,0 +1,83 @@
+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, } 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, stakingParams, btcProvider, 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, stakerBtcAddress, sigType) {
+        if (!bech32Address.startsWith('bbn1')) {
+            throw new Error('invalid bech32 babylon address, must start with bbn1');
+        }
+        const signedBabylonAddress = await this.btcProvider.signMessage(bech32Address, sigType === BTCSigType.BIP322 ? 'bip322-simple' : 'ecdsa');
+        let btcSig;
+        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 channel - The channel for which the proof of possession is created.
+     * @param bech32Address - The staker's bech32 address on the babylon network.
+     * @param stakerBtcAddress
+     * @returns The proof of possession.
+     */
+    async createProofOfPossession(channel, bech32Address, stakerBtcAddress) {
+        // force the ECDSA signature type
+        return this.createProofOfPossessionWithSigType(bech32Address, stakerBtcAddress, BTCSigType.ECDSA);
+    }
+}
+export const mockBabylonProvider = {
+    signTransaction() {
+        throw new Error('Function not implemented.');
+    },
+};
+export function createStakingManager(network, btcProvider, stakingParams, babylonProvider = mockBabylonProvider) {
+    if (utxolib.isValidNetwork(network)) {
+        switch (network) {
+            case utxolib.networks.bitcoin:
+                network = bitcoinjslib.networks.bitcoin;
+                break;
+            case utxolib.networks.testnet:
+            case utxolib.networks.bitcoinTestnet4:
+                throw new Error('Unsupported bitcoin testnet network - only signet is supported');
+            case utxolib.networks.bitcoinPublicSignet:
+                network = bitcoinjslib.networks.testnet;
+                break;
+            default:
+                throw new Error('Unsupported network');
+        }
+    }
+    return new BitGoStakingManager(network, stakingParams ?? getStakingParams(network), btcProvider, babylonProvider);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stakingManager.js","sourceRoot":"","sources":["../../../src/babylon/stakingManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,MAAM,MAAM,sCAAsC,CAAC;AAC/D,OAAO,EACL,SAAS,EACT,UAAU,GAEX,MAAM,2EAA2E,CAAC;AAEnF,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;GAGG;AACH,MAAM,mBAAoB,SAAQ,MAAM,CAAC,wBAAwB;IAC/D,YACE,OAA6B,EAC7B,aAA8C,EAC9C,WAA+B,EAC/B,eAAuC;QAEvC,KAAK,CAAC,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,eAAe,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,kCAAkC,CACtC,aAAqB,EACrB,gBAAwB,EACxB,OAAmB;QAEnB,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QAC1E,CAAC;QACD,MAAM,oBAAoB,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAC7D,aAAa,EACb,OAAO,KAAK,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,OAAO,CAC1D,CAAC;QAEF,IAAI,MAAkB,CAAC;QACvB,IAAI,OAAO,KAAK,UAAU,CAAC,MAAM,EAAE,CAAC;YAClC,MAAM,SAAS,GAAG,SAAS,CAAC,WAAW,CAAC;gBACtC,OAAO,EAAE,gBAAgB;gBACzB,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAC;aACjD,CAAC,CAAC;YACH,qDAAqD;YACrD,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC;QAChD,CAAC;aAAM,CAAC;YACN,6CAA6C;YAC7C,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAC,CAAC;QACvD,CAAC;QAED,OAAO;YACL,UAAU,EAAE,OAAO;YACnB,MAAM;SACP,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACM,KAAK,CAAC,uBAAuB,CACpC,OAAoD,EACpD,aAAqB,EACrB,gBAAwB;QAExB,iCAAiC;QACjC,OAAO,IAAI,CAAC,kCAAkC,CAAC,aAAa,EAAE,gBAAgB,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;IACpG,CAAC;CACF;AAED,MAAM,CAAC,MAAM,mBAAmB,GAA2B;IACzD,eAAe;QACb,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;IAC/C,CAAC;CACF,CAAC;AAEF,MAAM,UAAU,oBAAoB,CAClC,OAA+C,EAC/C,WAA+B,EAC/B,aAA+C,EAC/C,eAAe,GAAG,mBAAmB;IAErC,IAAI,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC;QACpC,QAAQ,OAAO,EAAE,CAAC;YAChB,KAAK,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAC3B,OAAO,GAAG,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC;gBACxC,MAAM;YACR,KAAK,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;YAC9B,KAAK,OAAO,CAAC,QAAQ,CAAC,eAAe;gBACnC,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;YACpF,KAAK,OAAO,CAAC,QAAQ,CAAC,mBAAmB;gBACvC,OAAO,GAAG,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC;gBACxC,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IACD,OAAO,IAAI,mBAAmB,CAAC,OAAO,EAAE,aAAa,IAAI,gBAAgB,CAAC,OAAO,CAAC,EAAE,WAAW,EAAE,eAAe,CAAC,CAAC;AACpH,CAAC","sourcesContent":["import * as bitcoinjslib from 'bitcoinjs-lib';\nimport * as utxolib from '@bitgo/utxo-lib';\nimport * as vendor from '@bitgo/babylonlabs-io-btc-staking-ts';\nimport {\n  BIP322Sig,\n  BTCSigType,\n  ProofOfPossessionBTC,\n} from '@babylonlabs-io/babylon-proto-ts/dist/generated/babylon/btcstaking/v1/pop';\n\nimport { getStakingParams } from './stakingParams';\n\n/**\n * Subclass of BabylonBtcStakingManager with the sole purpose of forcing\n * a ECDSA signature.\n */\nclass BitGoStakingManager extends vendor.BabylonBtcStakingManager {\n  constructor(\n    network: bitcoinjslib.Network,\n    stakingParams: vendor.VersionedStakingParams[],\n    btcProvider: vendor.BtcProvider,\n    babylonProvider: vendor.BabylonProvider\n  ) {\n    super(network, stakingParams, btcProvider, babylonProvider);\n  }\n\n  /**\n   * Creates a proof of possession for the staker based on ECDSA signature.\n   *\n   * This is a parameterized version of the superclass method which infers\n   * the signature type from the stakerBtcAddress.\n   *\n   * @param bech32Address - The staker's bech32 address on the babylon network.\n   * @param stakerBtcAddress - The staker's BTC address.\n   * @param sigType - The signature type (BIP322 or ECDSA).\n   * @returns The proof of possession.\n   */\n  async createProofOfPossessionWithSigType(\n    bech32Address: string,\n    stakerBtcAddress: string,\n    sigType: BTCSigType\n  ): Promise<ProofOfPossessionBTC> {\n    if (!bech32Address.startsWith('bbn1')) {\n      throw new Error('invalid bech32 babylon address, must start with bbn1');\n    }\n    const signedBabylonAddress = await this.btcProvider.signMessage(\n      bech32Address,\n      sigType === BTCSigType.BIP322 ? 'bip322-simple' : 'ecdsa'\n    );\n\n    let btcSig: Uint8Array;\n    if (sigType === BTCSigType.BIP322) {\n      const bip322Sig = BIP322Sig.fromPartial({\n        address: stakerBtcAddress,\n        sig: Buffer.from(signedBabylonAddress, 'base64'),\n      });\n      // Encode the BIP322 protobuf message to a Uint8Array\n      btcSig = BIP322Sig.encode(bip322Sig).finish();\n    } else {\n      // Encode the ECDSA signature to a Uint8Array\n      btcSig = Buffer.from(signedBabylonAddress, 'base64');\n    }\n\n    return {\n      btcSigType: sigType,\n      btcSig,\n    };\n  }\n\n  /**\n   * Creates a proof of possession for the staker based on ECDSA signature.\n   * @param channel - The channel for which the proof of possession is created.\n   * @param bech32Address - The staker's bech32 address on the babylon network.\n   * @param stakerBtcAddress\n   * @returns The proof of possession.\n   */\n  override async createProofOfPossession(\n    channel: 'delegation:create' | 'delegation:register',\n    bech32Address: string,\n    stakerBtcAddress: string\n  ): Promise<ProofOfPossessionBTC> {\n    // force the ECDSA signature type\n    return this.createProofOfPossessionWithSigType(bech32Address, stakerBtcAddress, BTCSigType.ECDSA);\n  }\n}\n\nexport const mockBabylonProvider: vendor.BabylonProvider = {\n  signTransaction(): Promise<Uint8Array> {\n    throw new Error('Function not implemented.');\n  },\n};\n\nexport function createStakingManager(\n  network: bitcoinjslib.Network | utxolib.Network,\n  btcProvider: vendor.BtcProvider,\n  stakingParams?: vendor.VersionedStakingParams[],\n  babylonProvider = mockBabylonProvider\n): vendor.BabylonBtcStakingManager {\n  if (utxolib.isValidNetwork(network)) {\n    switch (network) {\n      case utxolib.networks.bitcoin:\n        network = bitcoinjslib.networks.bitcoin;\n        break;\n      case utxolib.networks.testnet:\n      case utxolib.networks.bitcoinTestnet4:\n        throw new Error('Unsupported bitcoin testnet network - only signet is supported');\n      case utxolib.networks.bitcoinPublicSignet:\n        network = bitcoinjslib.networks.testnet;\n        break;\n      default:\n        throw new Error('Unsupported network');\n    }\n  }\n  return new BitGoStakingManager(network, stakingParams ?? getStakingParams(network), btcProvider, babylonProvider);\n}\n"]}

package/dist/esm/babylon/stakingParams.d.ts

@@ -0,0 +1,40 @@
+import * as t from 'io-ts';
+import * as tt from 'io-ts-types';
+import * as utxolib from '@bitgo/utxo-lib';
+import { StakerInfo, StakingInputs, StakingParams, VersionedStakingParams } from '@bitgo/babylonlabs-io-btc-staking-ts';
+export { getBabylonParamByVersion, getBabylonParamByBtcHeight } from '@bitgo/babylonlabs-io-btc-staking-ts';
+import { BabylonDescriptorBuilder } from './descriptor';
+import { BabylonNetworkLike } from './network';
+/** @see https://docs.babylonlabs.io/api/babylon-gRPC/params/ */
+declare const BabylonParamsJSON: t.TypeC<{
+    covenant_pks: t.ArrayC<t.StringC>;
+    covenant_quorum: t.NumberC;
+    min_staking_value_sat: tt.NumberFromStringC;
+    max_staking_value_sat: tt.NumberFromStringC;
+    min_staking_time_blocks: t.NumberC;
+    max_staking_time_blocks: t.NumberC;
+    slashing_pk_script: t.StringC;
+    min_slashing_tx_fee_sat: tt.NumberFromStringC;
+    slashing_rate: t.StringC;
+    unbonding_time_blocks: t.NumberC;
+    unbonding_fee_sat: tt.NumberFromStringC;
+    min_commission_rate: tt.NumberFromStringC;
+    delegation_creation_base_gas_fee: tt.NumberFromStringC;
+    allow_list_expiration_height: tt.NumberFromStringC;
+    btc_activation_height: t.NumberC;
+}>;
+type BabylonParamsJSON = t.TypeOf<typeof BabylonParamsJSON>;
+export declare function toVersionedParams(ps: BabylonParamsJSON[]): VersionedStakingParams[];
+export declare const mainnetStakingParams: readonly VersionedStakingParams[];
+export declare const testnetStakingParams: readonly VersionedStakingParams[];
+export declare function getStakingParams(network: BabylonNetworkLike): VersionedStakingParams[];
+export declare const testnetFinalityProvider0: Buffer<ArrayBuffer>;
+type DescriptorStakingParams = Pick<StakingParams, 'covenantNoCoordPks' | 'covenantQuorum' | 'minStakingTimeBlocks' | 'unbondingTime'>;
+export declare function getDescriptorBuilderForParams(userKey: utxolib.BIP32Interface | utxolib.ECPairInterface | Buffer, finalityProviderKeys: Buffer[], stakingTimelock: number, params: DescriptorStakingParams): BabylonDescriptorBuilder;
+export declare function getDescriptorProviderForStakingParams(stakerBtcInfo: Pick<StakerInfo, 'publicKeyNoCoordHex'>, stakingInput: StakingInputs, stakingParams: DescriptorStakingParams): BabylonDescriptorBuilder;
+export declare function getTestnetDescriptorBuilder(userKey: utxolib.BIP32Interface | utxolib.ECPairInterface | Buffer, { finalityProviderKeys, params, stakingTimelock, }?: {
+    finalityProviderKeys?: Buffer[];
+    params?: StakingParams;
+    stakingTimelock?: number;
+}): BabylonDescriptorBuilder;
+//# sourceMappingURL=stakingParams.d.ts.map

package/dist/esm/babylon/stakingParams.js

@@ -0,0 +1,86 @@
+import * as t from 'io-ts';
+import * as tt from 'io-ts-types';
+import { isLeft } from 'fp-ts/Either';
+import { PathReporter } from 'io-ts/lib/PathReporter';
+import { getBabylonParamByVersion, } from '@bitgo/babylonlabs-io-btc-staking-ts';
+export { getBabylonParamByVersion, getBabylonParamByBtcHeight } from '@bitgo/babylonlabs-io-btc-staking-ts';
+import { BabylonDescriptorBuilder } from './descriptor';
+import jsonMainnetParams from './params.mainnet.json';
+import jsonTestnetParams from './params.testnet.json';
+import { toBabylonNetwork } from './network';
+/** @see https://docs.babylonlabs.io/api/babylon-gRPC/params/ */
+const BabylonParamsJSON = t.type({
+    covenant_pks: t.array(t.string),
+    covenant_quorum: t.number,
+    min_staking_value_sat: tt.NumberFromString,
+    max_staking_value_sat: tt.NumberFromString,
+    min_staking_time_blocks: t.number,
+    max_staking_time_blocks: t.number,
+    slashing_pk_script: t.string,
+    min_slashing_tx_fee_sat: tt.NumberFromString,
+    slashing_rate: t.string,
+    unbonding_time_blocks: t.number,
+    unbonding_fee_sat: tt.NumberFromString,
+    min_commission_rate: tt.NumberFromString,
+    delegation_creation_base_gas_fee: tt.NumberFromString,
+    allow_list_expiration_height: tt.NumberFromString,
+    btc_activation_height: t.number,
+});
+export function toVersionedParams(ps) {
+    return ps.map((p, version) => ({
+        version,
+        btcActivationHeight: p.btc_activation_height,
+        covenantNoCoordPks: p.covenant_pks,
+        covenantQuorum: p.covenant_quorum,
+        unbondingTime: p.unbonding_time_blocks,
+        unbondingFeeSat: p.unbonding_fee_sat,
+        maxStakingAmountSat: p.max_staking_value_sat,
+        minStakingAmountSat: p.min_staking_value_sat,
+        maxStakingTimeBlocks: p.max_staking_time_blocks,
+        minStakingTimeBlocks: p.min_staking_time_blocks,
+        slashing: {
+            slashingPkScriptHex: Buffer.from(p.slashing_pk_script, 'base64').toString('hex'),
+            slashingRate: parseFloat(p.slashing_rate),
+            minSlashingTxFeeSat: p.min_slashing_tx_fee_sat,
+        },
+    }));
+}
+function toVersionedParamsFromJson(jsonParams) {
+    return toVersionedParams(jsonParams.map((p) => {
+        const result = t.type({ params: BabylonParamsJSON }).decode(p);
+        if (isLeft(result)) {
+            const msg = PathReporter.report(result).join('\n');
+            throw new Error(`Invalid params: ${msg}`);
+        }
+        return result.right.params;
+    }));
+}
+export const mainnetStakingParams = Object.freeze(toVersionedParamsFromJson(jsonMainnetParams));
+export const testnetStakingParams = Object.freeze(toVersionedParamsFromJson(jsonTestnetParams));
+export function getStakingParams(network) {
+    switch (toBabylonNetwork(network)) {
+        case 'mainnet':
+            return [...mainnetStakingParams];
+        case 'testnet':
+            return [...testnetStakingParams];
+        default:
+            throw new Error('Unsupported network');
+    }
+}
+// Source: https://btcstaking.testnet.babylonlabs.io/ "Babylon Foundation 0"
+export const testnetFinalityProvider0 = Buffer.from('d23c2c25e1fcf8fd1c21b9a402c19e2e309e531e45e92fb1e9805b6056b0cc76', 'hex');
+export function getDescriptorBuilderForParams(userKey, finalityProviderKeys, stakingTimelock, params) {
+    if (!Buffer.isBuffer(userKey)) {
+        userKey = userKey.publicKey;
+    }
+    return new BabylonDescriptorBuilder(userKey, finalityProviderKeys, params.covenantNoCoordPks.map((pk) => Buffer.from(pk, 'hex')), params.covenantQuorum, stakingTimelock, params.unbondingTime);
+}
+export function getDescriptorProviderForStakingParams(stakerBtcInfo, stakingInput, stakingParams) {
+    const userKey = Buffer.from(stakerBtcInfo.publicKeyNoCoordHex, 'hex');
+    const finalityProviderKeys = stakingInput.finalityProviderPksNoCoordHex.map((pk) => Buffer.from(pk, 'hex'));
+    return getDescriptorBuilderForParams(userKey, finalityProviderKeys, stakingInput.stakingTimelock, stakingParams);
+}
+export function getTestnetDescriptorBuilder(userKey, { finalityProviderKeys = [testnetFinalityProvider0], params = getBabylonParamByVersion(5, getStakingParams('testnet')), stakingTimelock = params.minStakingTimeBlocks, } = {}) {
+    return getDescriptorBuilderForParams(userKey, finalityProviderKeys, stakingTimelock, params);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stakingParams.js","sourceRoot":"","sources":["../../../src/babylon/stakingParams.ts"],"names":[],"mappings":"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","sourcesContent":["import * as t from 'io-ts';\nimport * as tt from 'io-ts-types';\nimport { isLeft } from 'fp-ts/Either';\nimport { PathReporter } from 'io-ts/lib/PathReporter';\nimport * as utxolib from '@bitgo/utxo-lib';\nimport {\n  getBabylonParamByVersion,\n  StakerInfo,\n  StakingInputs,\n  StakingParams,\n  VersionedStakingParams,\n} from '@bitgo/babylonlabs-io-btc-staking-ts';\nexport { getBabylonParamByVersion, getBabylonParamByBtcHeight } from '@bitgo/babylonlabs-io-btc-staking-ts';\n\nimport { BabylonDescriptorBuilder } from './descriptor';\nimport jsonMainnetParams from './params.mainnet.json';\nimport jsonTestnetParams from './params.testnet.json';\nimport { BabylonNetworkLike, toBabylonNetwork } from './network';\n\n/** @see https://docs.babylonlabs.io/api/babylon-gRPC/params/ */\nconst BabylonParamsJSON = t.type({\n  covenant_pks: t.array(t.string),\n  covenant_quorum: t.number,\n  min_staking_value_sat: tt.NumberFromString,\n  max_staking_value_sat: tt.NumberFromString,\n  min_staking_time_blocks: t.number,\n  max_staking_time_blocks: t.number,\n  slashing_pk_script: t.string,\n  min_slashing_tx_fee_sat: tt.NumberFromString,\n  slashing_rate: t.string,\n  unbonding_time_blocks: t.number,\n  unbonding_fee_sat: tt.NumberFromString,\n  min_commission_rate: tt.NumberFromString,\n  delegation_creation_base_gas_fee: tt.NumberFromString,\n  allow_list_expiration_height: tt.NumberFromString,\n  btc_activation_height: t.number,\n});\n\ntype BabylonParamsJSON = t.TypeOf<typeof BabylonParamsJSON>;\n\nexport function toVersionedParams(ps: BabylonParamsJSON[]): VersionedStakingParams[] {\n  return ps.map((p, version) => ({\n    version,\n    btcActivationHeight: p.btc_activation_height,\n    covenantNoCoordPks: p.covenant_pks,\n    covenantQuorum: p.covenant_quorum,\n    unbondingTime: p.unbonding_time_blocks,\n    unbondingFeeSat: p.unbonding_fee_sat,\n    maxStakingAmountSat: p.max_staking_value_sat,\n    minStakingAmountSat: p.min_staking_value_sat,\n    maxStakingTimeBlocks: p.max_staking_time_blocks,\n    minStakingTimeBlocks: p.min_staking_time_blocks,\n    slashing: {\n      slashingPkScriptHex: Buffer.from(p.slashing_pk_script, 'base64').toString('hex'),\n      slashingRate: parseFloat(p.slashing_rate),\n      minSlashingTxFeeSat: p.min_slashing_tx_fee_sat,\n    },\n  }));\n}\n\nfunction toVersionedParamsFromJson(jsonParams: unknown[]): VersionedStakingParams[] {\n  return toVersionedParams(\n    jsonParams.map((p): BabylonParamsJSON => {\n      const result = t.type({ params: BabylonParamsJSON }).decode(p);\n      if (isLeft(result)) {\n        const msg = PathReporter.report(result).join('\\n');\n        throw new Error(`Invalid params: ${msg}`);\n      }\n      return result.right.params;\n    })\n  );\n}\n\nexport const mainnetStakingParams: readonly VersionedStakingParams[] = Object.freeze(\n  toVersionedParamsFromJson(jsonMainnetParams)\n);\n\nexport const testnetStakingParams: readonly VersionedStakingParams[] = Object.freeze(\n  toVersionedParamsFromJson(jsonTestnetParams)\n);\n\nexport function getStakingParams(network: BabylonNetworkLike): VersionedStakingParams[] {\n  switch (toBabylonNetwork(network)) {\n    case 'mainnet':\n      return [...mainnetStakingParams];\n    case 'testnet':\n      return [...testnetStakingParams];\n    default:\n      throw new Error('Unsupported network');\n  }\n}\n\n// Source: https://btcstaking.testnet.babylonlabs.io/ \"Babylon Foundation 0\"\nexport const testnetFinalityProvider0 = Buffer.from(\n  'd23c2c25e1fcf8fd1c21b9a402c19e2e309e531e45e92fb1e9805b6056b0cc76',\n  'hex'\n);\n\ntype DescriptorStakingParams = Pick<\n  StakingParams,\n  'covenantNoCoordPks' | 'covenantQuorum' | 'minStakingTimeBlocks' | 'unbondingTime'\n>;\n\nexport function getDescriptorBuilderForParams(\n  userKey: utxolib.BIP32Interface | utxolib.ECPairInterface | Buffer,\n  finalityProviderKeys: Buffer[],\n  stakingTimelock: number,\n  params: DescriptorStakingParams\n): BabylonDescriptorBuilder {\n  if (!Buffer.isBuffer(userKey)) {\n    userKey = userKey.publicKey;\n  }\n  return new BabylonDescriptorBuilder(\n    userKey,\n    finalityProviderKeys,\n    params.covenantNoCoordPks.map((pk) => Buffer.from(pk, 'hex')),\n    params.covenantQuorum,\n    stakingTimelock,\n    params.unbondingTime\n  );\n}\n\nexport function getDescriptorProviderForStakingParams(\n  stakerBtcInfo: Pick<StakerInfo, 'publicKeyNoCoordHex'>,\n  stakingInput: StakingInputs,\n  stakingParams: DescriptorStakingParams\n): BabylonDescriptorBuilder {\n  const userKey = Buffer.from(stakerBtcInfo.publicKeyNoCoordHex, 'hex');\n  const finalityProviderKeys = stakingInput.finalityProviderPksNoCoordHex.map((pk) => Buffer.from(pk, 'hex'));\n  return getDescriptorBuilderForParams(userKey, finalityProviderKeys, stakingInput.stakingTimelock, stakingParams);\n}\n\nexport function getTestnetDescriptorBuilder(\n  userKey: utxolib.BIP32Interface | utxolib.ECPairInterface | Buffer,\n  {\n    finalityProviderKeys = [testnetFinalityProvider0],\n    params = getBabylonParamByVersion(5, getStakingParams('testnet')),\n    stakingTimelock = params.minStakingTimeBlocks,\n  }: {\n    finalityProviderKeys?: Buffer[];\n    params?: StakingParams;\n    stakingTimelock?: number;\n  } = {}\n): BabylonDescriptorBuilder {\n  return getDescriptorBuilderForParams(userKey, finalityProviderKeys, stakingTimelock, params);\n}\n"]}

package/dist/esm/babylon/undelegation/UndelegationResponse.d.ts

@@ -0,0 +1,24 @@
+import * as t from 'io-ts';
+import { PartialSig } from 'bip174/src/lib/interfaces';
+/** As returned by https://babylon.nodes.guru/api#/Query/BTCDelegation */
+export declare const Signature: t.TypeC<{
+    pk: t.StringC;
+    sig: t.StringC;
+}>;
+/** As returned by https://babylon.nodes.guru/api#/Query/BTCDelegation */
+export declare const UndelegationResponse: t.TypeC<{
+    /** Network-formatted transaction hex */
+    unbonding_tx_hex: t.StringC;
+    /** List of signatures for the unbonding covenant */
+    covenant_unbonding_sig_list: t.ArrayC<t.TypeC<{
+        pk: t.StringC;
+        sig: t.StringC;
+    }>>;
+}>;
+export type UndelegationResponse = t.TypeOf<typeof UndelegationResponse>;
+/** Converts a gRPC signature to a PartialSig as used by bitcoinjs-lib and utxo-lib */
+export declare function toPartialSig(grpcSig: {
+    pk: string;
+    sig: string;
+}): PartialSig;
+//# sourceMappingURL=UndelegationResponse.d.ts.map

package/dist/esm/babylon/undelegation/UndelegationResponse.js

@@ -0,0 +1,18 @@
+import * as t from 'io-ts';
+/** As returned by https://babylon.nodes.guru/api#/Query/BTCDelegation */
+export const Signature = t.type({ pk: t.string, sig: t.string }, 'Signature');
+/** As returned by https://babylon.nodes.guru/api#/Query/BTCDelegation */
+export const UndelegationResponse = t.type({
+    /** Network-formatted transaction hex */
+    unbonding_tx_hex: t.string,
+    /** List of signatures for the unbonding covenant */
+    covenant_unbonding_sig_list: t.array(Signature),
+}, 'UndelegationResponse');
+/** Converts a gRPC signature to a PartialSig as used by bitcoinjs-lib and utxo-lib */
+export function toPartialSig(grpcSig) {
+    return {
+        pubkey: Buffer.from(grpcSig.pk, 'hex'),
+        signature: Buffer.from(grpcSig.sig, 'base64'),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/babylon/undelegation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './unbonding';
+export * from './UndelegationResponse';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/babylon/undelegation/index.js

@@ -0,0 +1,3 @@
+export * from './unbonding';
+export * from './UndelegationResponse';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYmFieWxvbi91bmRlbGVnYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdW5ib25kaW5nJztcbmV4cG9ydCAqIGZyb20gJy4vVW5kZWxlZ2F0aW9uUmVzcG9uc2UnO1xuIl19

package/dist/esm/babylon/undelegation/unbonding.d.ts

@@ -0,0 +1,16 @@
+import * as utxolib from '@bitgo/utxo-lib';
+import { PartialSig, WitnessUtxo } from 'bip174/src/lib/interfaces';
+import { Descriptor } from '@bitgo/wasm-utxo';
+/**
+ * Asserts that the provided signatures are valid for the given PSBT input.
+ */
+export declare function assertValidSignatures(psbt: utxolib.bitgo.UtxoPsbt, inputIndex: number, signatures: PartialSig[]): void;
+/**
+ * @return unsigned PSBT for an unbonding transaction
+ */
+export declare function toUnbondingPsbt(tx: utxolib.bitgo.UtxoTransaction<bigint>, witnessUtxo: WitnessUtxo, stakingDescriptor: Descriptor, network: utxolib.Network): utxolib.bitgo.UtxoPsbt;
+/**
+ * @return PSBT for an unbonding transaction with signatures
+ */
+export declare function toUnbondingPsbtWithSignatures(tx: utxolib.bitgo.UtxoTransaction<bigint>, witnessUtxo: WitnessUtxo, stakingDescriptor: Descriptor, signatures: PartialSig[], network: utxolib.Network): utxolib.bitgo.UtxoPsbt;
+//# sourceMappingURL=unbonding.d.ts.map

package/dist/esm/babylon/undelegation/unbonding.js

@@ -0,0 +1,70 @@
+import assert from 'assert';
+import * as utxolib from '@bitgo/utxo-lib';
+import { Miniscript, ast } from '@bitgo/wasm-utxo';
+import { findTapLeafScript, toUtxoPsbt, toWrappedPsbt } from '@bitgo/utxo-core/descriptor';
+import { parseStakingDescriptor } from '../parseDescriptor';
+/**
+ * Adds covenant signatures to a PSBT input.
+ */
+function addCovenantSignatures(psbt, inputIndex, signatures) {
+    const input = psbt.data.inputs[inputIndex];
+    assert(input.tapLeafScript, 'Input must have tapLeafScript');
+    assert(input.tapLeafScript.length === 1, 'Input must have exactly one tapLeafScript');
+    const [{ controlBlock, script }] = input.tapLeafScript;
+    const leafHash = utxolib.taproot.getTapleafHash(utxolib.ecc, controlBlock, script);
+    psbt.updateInput(inputIndex, { tapScriptSig: signatures.map((s) => ({ ...s, leafHash })) });
+}
+/**
+ * Asserts that the provided signatures are valid for the given PSBT input.
+ */
+export function assertValidSignatures(psbt, inputIndex, signatures) {
+    signatures.forEach((s) => {
+        assert(psbt.validateTaprootSignaturesOfInput(inputIndex, s.pubkey), `Signature validation failed for ${s.pubkey.toString('hex')}`);
+    });
+}
+function getUnbondingScript(stakingDescriptor) {
+    const parsedDescriptor = parseStakingDescriptor(stakingDescriptor);
+    assert(parsedDescriptor, 'Invalid staking descriptor');
+    return Miniscript.fromString(ast.formatNode(parsedDescriptor.unbondingMiniscriptNode), 'tap');
+}
+/**
+ * @return unsigned PSBT for an unbonding transaction
+ */
+export function toUnbondingPsbt(tx, witnessUtxo, stakingDescriptor, network) {
+    const unbondingScript = getUnbondingScript(stakingDescriptor);
+    const psbt = new utxolib.Psbt({ network });
+    psbt.setVersion(tx.version);
+    psbt.setLocktime(tx.locktime);
+    psbt.addOutputs(tx.outs.map((output) => ({
+        script: output.script,
+        value: BigInt(output.value),
+    })));
+    assert(tx.ins.length === 1);
+    const input = tx.ins[0];
+    psbt.addInput({
+        hash: input.hash,
+        index: input.index,
+        sequence: input.sequence,
+        witnessUtxo,
+    });
+    const wrappedPsbt = toWrappedPsbt(psbt);
+    wrappedPsbt.updateInputWithDescriptor(0, stakingDescriptor);
+    const unwrapped = toUtxoPsbt(wrappedPsbt, network);
+    assert(unwrapped.data.inputs.length === 1, 'Unbonding transaction must have exactly one input');
+    const unwrappedInputData = unwrapped.data.inputs[0];
+    assert(unwrappedInputData.tapLeafScript);
+    const unwrappedUnbond = findTapLeafScript(unwrappedInputData.tapLeafScript, unbondingScript);
+    unwrappedInputData.tapLeafScript = [unwrappedUnbond];
+    return unwrapped;
+}
+/**
+ * @return PSBT for an unbonding transaction with signatures
+ */
+export function toUnbondingPsbtWithSignatures(tx, witnessUtxo, stakingDescriptor, signatures, network) {
+    const psbt = toUnbondingPsbt(tx, witnessUtxo, stakingDescriptor, network);
+    assert(psbt.data.inputs.length === 1, 'Unbonding transaction must have exactly one input');
+    addCovenantSignatures(psbt, 0, signatures);
+    assertValidSignatures(psbt, 0, signatures);
+    return psbt;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unbonding.js","sourceRoot":"","sources":["../../../../src/babylon/undelegation/unbonding.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\n\nimport * as utxolib from '@bitgo/utxo-lib';\nimport { PartialSig, WitnessUtxo } from 'bip174/src/lib/interfaces';\nimport { Descriptor, Miniscript, ast } from '@bitgo/wasm-utxo';\nimport { findTapLeafScript, toUtxoPsbt, toWrappedPsbt } from '@bitgo/utxo-core/descriptor';\n\nimport { parseStakingDescriptor } from '../parseDescriptor';\n\n/**\n * Adds covenant signatures to a PSBT input.\n */\nfunction addCovenantSignatures(psbt: utxolib.bitgo.UtxoPsbt, inputIndex: number, signatures: PartialSig[]): void {\n  const input = psbt.data.inputs[inputIndex];\n  assert(input.tapLeafScript, 'Input must have tapLeafScript');\n  assert(input.tapLeafScript.length === 1, 'Input must have exactly one tapLeafScript');\n  const [{ controlBlock, script }] = input.tapLeafScript;\n  const leafHash = utxolib.taproot.getTapleafHash(utxolib.ecc, controlBlock, script);\n  psbt.updateInput(inputIndex, { tapScriptSig: signatures.map((s) => ({ ...s, leafHash })) });\n}\n\n/**\n * Asserts that the provided signatures are valid for the given PSBT input.\n */\nexport function assertValidSignatures(\n  psbt: utxolib.bitgo.UtxoPsbt,\n  inputIndex: number,\n  signatures: PartialSig[]\n): void {\n  signatures.forEach((s) => {\n    assert(\n      psbt.validateTaprootSignaturesOfInput(inputIndex, s.pubkey),\n      `Signature validation failed for ${s.pubkey.toString('hex')}`\n    );\n  });\n}\n\nfunction getUnbondingScript(stakingDescriptor: Descriptor): Miniscript {\n  const parsedDescriptor = parseStakingDescriptor(stakingDescriptor);\n  assert(parsedDescriptor, 'Invalid staking descriptor');\n  return Miniscript.fromString(ast.formatNode(parsedDescriptor.unbondingMiniscriptNode), 'tap');\n}\n\n/**\n * @return unsigned PSBT for an unbonding transaction\n */\nexport function toUnbondingPsbt(\n  tx: utxolib.bitgo.UtxoTransaction<bigint>,\n  witnessUtxo: WitnessUtxo,\n  stakingDescriptor: Descriptor,\n  network: utxolib.Network\n): utxolib.bitgo.UtxoPsbt {\n  const unbondingScript = getUnbondingScript(stakingDescriptor);\n  const psbt = new utxolib.Psbt({ network });\n  psbt.setVersion(tx.version);\n  psbt.setLocktime(tx.locktime);\n  psbt.addOutputs(\n    tx.outs.map((output) => ({\n      script: output.script,\n      value: BigInt(output.value),\n    }))\n  );\n  assert(tx.ins.length === 1);\n  const input = tx.ins[0];\n  psbt.addInput({\n    hash: input.hash,\n    index: input.index,\n    sequence: input.sequence,\n    witnessUtxo,\n  });\n  const wrappedPsbt = toWrappedPsbt(psbt);\n  wrappedPsbt.updateInputWithDescriptor(0, stakingDescriptor);\n  const unwrapped = toUtxoPsbt(wrappedPsbt, network);\n  assert(unwrapped.data.inputs.length === 1, 'Unbonding transaction must have exactly one input');\n  const unwrappedInputData = unwrapped.data.inputs[0];\n  assert(unwrappedInputData.tapLeafScript);\n  const unwrappedUnbond = findTapLeafScript(unwrappedInputData.tapLeafScript, unbondingScript);\n  unwrappedInputData.tapLeafScript = [unwrappedUnbond];\n  return unwrapped;\n}\n\n/**\n * @return PSBT for an unbonding transaction with signatures\n */\nexport function toUnbondingPsbtWithSignatures(\n  tx: utxolib.bitgo.UtxoTransaction<bigint>,\n  witnessUtxo: WitnessUtxo,\n  stakingDescriptor: Descriptor,\n  signatures: PartialSig[],\n  network: utxolib.Network\n): utxolib.bitgo.UtxoPsbt {\n  const psbt = toUnbondingPsbt(tx, witnessUtxo, stakingDescriptor, network);\n  assert(psbt.data.inputs.length === 1, 'Unbonding transaction must have exactly one input');\n  addCovenantSignatures(psbt, 0, signatures);\n  assertValidSignatures(psbt, 0, signatures);\n  return psbt;\n}\n"]}

package/dist/esm/coreDao/descriptor.d.ts

@@ -0,0 +1,18 @@
+import { BIP32Interface } from '@bitgo/utxo-lib';
+/**
+ * Script type for a descriptor.
+ *
+ * See https://docs.coredao.org/docs/Learn/products/btc-staking/design#p2shp2wsh-output
+ */
+export type ScriptType = 'sh' | 'sh-wsh' | 'wsh';
+/**
+ * Create a multi-sig descriptor to produce a coredao staking address
+ * @param scriptType segwit or legacy
+ * @param locktime locktime for CLTV
+ * @param m Total number of keys required to unlock
+ * @param orderedKeys If Bip32Interfaces, these are xprvs or xpubs and are derivable.
+ *                    If they are buffers, then they are pub/prv keys and are not derivable.
+ * @param neutered If true, neuter the keys. Default to true
+ */
+export declare function createMultiSigDescriptor(scriptType: ScriptType, locktime: number, m: number, orderedKeys: (BIP32Interface | Buffer)[], neutered?: boolean): string;
+//# sourceMappingURL=descriptor.d.ts.map

package/dist/esm/coreDao/descriptor.js

@@ -0,0 +1,35 @@
+import { ast } from '@bitgo/wasm-utxo';
+function asDescriptorKey(key, neutered) {
+    if (Buffer.isBuffer(key)) {
+        return key.toString('hex');
+    }
+    return (neutered ? key.neutered() : key).toBase58() + '/*';
+}
+/**
+ * Create a multi-sig descriptor to produce a coredao staking address
+ * @param scriptType segwit or legacy
+ * @param locktime locktime for CLTV
+ * @param m Total number of keys required to unlock
+ * @param orderedKeys If Bip32Interfaces, these are xprvs or xpubs and are derivable.
+ *                    If they are buffers, then they are pub/prv keys and are not derivable.
+ * @param neutered If true, neuter the keys. Default to true
+ */
+export function createMultiSigDescriptor(scriptType, locktime, m, orderedKeys, neutered = true) {
+    if (m > orderedKeys.length || m < 1) {
+        throw new Error(`m (${m}) must be less than or equal to the number of keys (${orderedKeys.length}) and greater than 0`);
+    }
+    if (locktime <= 0) {
+        throw new Error(`locktime (${locktime}) must be greater than 0`);
+    }
+    const keys = orderedKeys.map((key) => asDescriptorKey(key, neutered));
+    const inner = { and_v: [{ 'r:after': locktime }, { multi: [m, ...keys] }] };
+    switch (scriptType) {
+        case 'sh':
+            return ast.formatNode({ sh: inner });
+        case 'sh-wsh':
+            return ast.formatNode({ sh: { wsh: inner } });
+        case 'wsh':
+            return ast.formatNode({ wsh: inner });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/coreDao/index.d.ts

@@ -0,0 +1,4 @@
+export * from './opReturn';
+export * from './descriptor';
+export * from './transaction';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/coreDao/index.js

@@ -0,0 +1,4 @@
+export * from './opReturn';
+export * from './descriptor';
+export * from './transaction';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29yZURhby9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vb3BSZXR1cm4nO1xuZXhwb3J0ICogZnJvbSAnLi9kZXNjcmlwdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vdHJhbnNhY3Rpb24nO1xuIl19

package/dist/esm/coreDao/opReturn.d.ts

@@ -0,0 +1,41 @@
+export declare const CORE_DAO_DEVNET_CHAIN_ID: Buffer<ArrayBuffer>;
+export declare const CORE_DAO_TESTNET2_CHAIN_ID: Buffer<ArrayBuffer>;
+export declare const CORE_DAO_TESTNET_CHAIN_ID: Buffer<ArrayBuffer>;
+export declare const CORE_DAO_MAINNET_CHAIN_ID: Buffer<ArrayBuffer>;
+export declare const CORE_DAO_SATOSHI_PLUS_IDENTIFIER: Buffer<ArrayBuffer>;
+export declare function encodeTimelock(timelock: number): Buffer;
+export declare function decodeTimelock(buffer: Buffer): number;
+type BaseParams = {
+    version: number;
+    chainId: Buffer;
+    delegator: Buffer;
+    validator: Buffer;
+    fee: number;
+};
+export type OpReturnParams = BaseParams & ({
+    redeemScript: Buffer;
+} | {
+    timelock: number;
+});
+/**
+ * Create a CoreDAO OP_RETURN output script
+ *
+ * @param version Version of the OP_RETURN
+ * @param chainId Chain ID
+ * @param delegator Delegator address
+ * @param validator Validator address
+ * @param fee Fee for relayer
+ * @param redeemScript Redeem script of the staking output
+ * @param timelock Timelock for the staking output
+ * @returns Buffer OP_RETURN buffer
+ */
+export declare function createCoreDaoOpReturnOutputScript({ version, chainId, delegator, validator, fee, ...rest }: OpReturnParams): Buffer;
+/**
+ * Parse a CoreDAO OP_RETURN output script into the constituent parts
+ * @param script
+ * @returns OpReturnParams
+ */
+export declare function parseCoreDaoOpReturnOutputScript(script: Buffer): OpReturnParams;
+export declare function toString(params: OpReturnParams): string;
+export {};
+//# sourceMappingURL=opReturn.d.ts.map