@bitgo-beta/utxo-staking 1.1.1-beta.91 → 1.1.1-beta.911

package/dist/cjs/scripts/babylon-sync.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=babylon-sync.d.ts.map

package/dist/cjs/scripts/babylon-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babylon-sync.d.ts","sourceRoot":"","sources":["../../../scripts/babylon-sync.ts"],"names":[],"mappings":""}

package/dist/cjs/scripts/babylon-sync.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const fs = __importStar(require("fs/promises"));
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+function getBaseUrl(network) {
+    if (network === 'mainnet') {
+        return 'https://babylon.nodes.guru/api';
+    }
+    return 'https://babylon-testnet-api.nodes.guru';
+}
+function unwrapJson(r) {
+    if (r.ok) {
+        return r.json();
+    }
+    return r.text().then((text) => {
+        throw new Error(`Fetch failed: ${r.status} ${r.statusText} - ${text}`);
+    });
+}
+async function getAllParams(network) {
+    const url = `${getBaseUrl(network)}/babylon/btcstaking/v1/params_versions`;
+    const result = await unwrapJson(await fetch(url));
+    (0, node_assert_1.default)(result && typeof result === 'object', `Invalid response from ${url}`);
+    (0, node_assert_1.default)('params' in result, `Response from ${url} does not contain 'params'`);
+    (0, node_assert_1.default)(Array.isArray(result.params), `Response from ${url} 'params' is not an array`);
+    return result.params;
+}
+async function syncParams(network) {
+    if (network === undefined) {
+        await syncParams('testnet');
+        await syncParams('mainnet');
+        return;
+    }
+    const allParams = await getAllParams(network);
+    const filename = __dirname + `/../src/babylon/params.${network}.json`;
+    await fs.writeFile(filename, JSON.stringify(allParams, null, 2) + '\n');
+    console.log(`Wrote ${allParams.length} params to ${filename}`);
+}
+async function syncDelegationResponse(network, txid) {
+    if (network === undefined && txid === undefined) {
+        console.log('Syncing delegation with default params');
+        return syncDelegationResponse('testnet', '5d277e1b29e5589074aea95ac8c8230fd911c2ec3c58774aafdef915619b772c');
+    }
+    if (network === undefined || txid === undefined) {
+        throw new Error('Network must be specified when syncing delegation response');
+    }
+    const url = `${getBaseUrl(network)}/babylon/btcstaking/v1/btc_delegation/${txid}`;
+    const result = await unwrapJson(await fetch(url));
+    (0, node_assert_1.default)(result && typeof result === 'object', `Invalid response from ${url}`);
+    const filename = __dirname + `/../test/fixtures/babylon/rpc/btc_delegation/${network}.${txid}.json`;
+    await fs.writeFile(filename, JSON.stringify(result, null, 2) + '\n');
+    console.log(`Wrote delegation response to ${filename}`);
+}
+(0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+    .command({
+    command: 'sync-babylon-params',
+    describe: 'Sync Babylon params',
+    builder(b) {
+        return b.option('network', {
+            choices: ['mainnet', 'testnet'],
+            description: 'Network',
+        });
+    },
+    async handler(argv) {
+        await syncParams(argv.network);
+    },
+})
+    .command({
+    command: 'sync-btc-delegation',
+    describe: 'Sync BTC delegation messages',
+    builder(b) {
+        return b
+            .option('network', {
+            choices: ['mainnet', 'testnet'],
+            description: 'Network',
+        })
+            .option('txid', {
+            type: 'string',
+            description: 'Transaction ID of the delegation message to sync',
+        });
+    },
+    async handler(argv) {
+        await syncDelegationResponse(argv.network, argv.txid);
+    },
+})
+    .demandCommand()
+    .help()
+    .strict().argv;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"babylon-sync.js","sourceRoot":"","sources":["../../../scripts/babylon-sync.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'node:assert';\nimport * as fs from 'fs/promises';\n\nimport yargs from 'yargs';\nimport { hideBin } from 'yargs/helpers';\n\nfunction getBaseUrl(network: 'mainnet' | 'testnet') {\n  if (network === 'mainnet') {\n    return 'https://babylon.nodes.guru/api';\n  }\n  return 'https://babylon-testnet-api.nodes.guru';\n}\n\nfunction unwrapJson(r: Response): Promise<unknown> {\n  if (r.ok) {\n    return r.json();\n  }\n  return r.text().then((text) => {\n    throw new Error(`Fetch failed: ${r.status} ${r.statusText} - ${text}`);\n  });\n}\n\ntype BabylonNetwork = 'mainnet' | 'testnet';\n\nasync function getAllParams(network: BabylonNetwork): Promise<unknown[]> {\n  const url = `${getBaseUrl(network)}/babylon/btcstaking/v1/params_versions`;\n  const result = await unwrapJson(await fetch(url));\n  assert(result && typeof result === 'object', `Invalid response from ${url}`);\n  assert('params' in result, `Response from ${url} does not contain 'params'`);\n  assert(Array.isArray(result.params), `Response from ${url} 'params' is not an array`);\n  return result.params;\n}\n\nasync function syncParams(network: BabylonNetwork | undefined): Promise<void> {\n  if (network === undefined) {\n    await syncParams('testnet');\n    await syncParams('mainnet');\n    return;\n  }\n\n  const allParams = await getAllParams(network);\n  const filename = __dirname + `/../src/babylon/params.${network}.json`;\n  await fs.writeFile(filename, JSON.stringify(allParams, null, 2) + '\\n');\n  console.log(`Wrote ${allParams.length} params to ${filename}`);\n}\n\nasync function syncDelegationResponse(network: BabylonNetwork | undefined, txid: string | undefined): Promise<void> {\n  if (network === undefined && txid === undefined) {\n    console.log('Syncing delegation with default params');\n    return syncDelegationResponse('testnet', '5d277e1b29e5589074aea95ac8c8230fd911c2ec3c58774aafdef915619b772c');\n  }\n\n  if (network === undefined || txid === undefined) {\n    throw new Error('Network must be specified when syncing delegation response');\n  }\n\n  const url = `${getBaseUrl(network)}/babylon/btcstaking/v1/btc_delegation/${txid}`;\n  const result = await unwrapJson(await fetch(url));\n  assert(result && typeof result === 'object', `Invalid response from ${url}`);\n\n  const filename = __dirname + `/../test/fixtures/babylon/rpc/btc_delegation/${network}.${txid}.json`;\n  await fs.writeFile(filename, JSON.stringify(result, null, 2) + '\\n');\n  console.log(`Wrote delegation response to ${filename}`);\n}\n\nyargs(hideBin(process.argv))\n  .command({\n    command: 'sync-babylon-params',\n    describe: 'Sync Babylon params',\n    builder(b) {\n      return b.option('network', {\n        choices: ['mainnet', 'testnet'] as const,\n        description: 'Network',\n      });\n    },\n    async handler(argv) {\n      await syncParams(argv.network);\n    },\n  })\n  .command({\n    command: 'sync-btc-delegation',\n    describe: 'Sync BTC delegation messages',\n    builder(b) {\n      return b\n        .option('network', {\n          choices: ['mainnet', 'testnet'] as const,\n          description: 'Network',\n        })\n        .option('txid', {\n          type: 'string',\n          description: 'Transaction ID of the delegation message to sync',\n        });\n    },\n    async handler(argv) {\n      await syncDelegationResponse(argv.network, argv.txid);\n    },\n  })\n  .demandCommand()\n  .help()\n  .strict().argv;\n"]}

package/dist/cjs/src/babylon/delegationMessage.d.ts

@@ -0,0 +1,38 @@
+import * as vendor from '@bitgo-beta/babylonlabs-io-btc-staking-ts';
+import * as babylonProtobuf from '@babylonlabs-io/babylon-proto-ts';
+import * as bitcoinjslib from 'bitcoinjs-lib';
+import * as utxolib from '@bitgo-beta/utxo-lib';
+import { Descriptor } from '@bitgo/wasm-utxo';
+import { BabylonDescriptorBuilder } from './descriptor';
+import { BabylonNetworkLike } from './network';
+export type ValueWithTypeUrl<T> = {
+    typeUrl: string;
+    value: T;
+};
+export declare function getSignedPsbt(psbt: bitcoinjslib.Psbt, descriptor: Descriptor, signers: utxolib.ECPairInterface[], { finalize }: {
+    finalize?: boolean | undefined;
+}): bitcoinjslib.Psbt;
+/**
+ * Utility method to work around a bug in btc-staking-ts
+ * https://github.com/babylonlabs-io/btc-staking-ts/issues/71
+ * @param v
+ * @param network
+ */
+export declare function forceFinalizePsbt(v: Buffer | utxolib.Psbt | bitcoinjslib.Psbt, network: BabylonNetworkLike): bitcoinjslib.Psbt;
+export declare function getBtcProviderForECKey(descriptorBuilder: BabylonDescriptorBuilder, stakerKey: utxolib.ECPairInterface): vendor.BtcProvider;
+type Result = {
+    unsignedDelegationMsg: ValueWithTypeUrl<babylonProtobuf.btcstakingtx.MsgCreateBTCDelegation>;
+    stakingTx: bitcoinjslib.Transaction;
+};
+/**
+ * @param stakingKey - this is the single-sig key that is used for co-signing the staking output
+ * @param changeAddress - this is unrelated to the staking key and is used for the change output
+ */
+export declare function toStakerInfo(stakingKey: utxolib.ECPairInterface | Buffer | string, changeAddress: string): vendor.StakerInfo;
+export declare function createStaking(network: BabylonNetworkLike, blockHeight: number, stakerBtcInfo: vendor.StakerInfo, stakingInput: vendor.StakingInputs, versionedParams?: vendor.VersionedStakingParams[]): vendor.Staking;
+type TransactionLike = bitcoinjslib.Psbt | bitcoinjslib.Transaction | utxolib.Transaction | utxolib.bitgo.UtxoTransaction<bigint | number> | utxolib.Psbt | utxolib.bitgo.UtxoPsbt;
+export declare function toStakingTransaction(tx: TransactionLike): bitcoinjslib.Transaction;
+export declare function createDelegationMessageWithTransaction(channel: 'delegation:create' | 'delegation:register', manager: vendor.BabylonBtcStakingManager, staking: vendor.Staking, stakingAmountSat: number, transaction: TransactionLike, babylonAddress: string): Promise<ValueWithTypeUrl<babylonProtobuf.btcstakingtx.MsgCreateBTCDelegation>>;
+export declare function createUnsignedPreStakeRegistrationBabylonTransactionWithBtcProvider(btcProvider: vendor.BtcProvider, network: bitcoinjslib.Network, stakerBtcInfo: vendor.StakerInfo, stakingInput: vendor.StakingInputs, babylonBtcTipHeight: number, inputUTXOs: vendor.UTXO[], feeRateSatB: number, babylonAddress: string, channel: 'delegation:create' | 'delegation:register', stakingParams?: vendor.VersionedStakingParams[]): Promise<Result>;
+export {};
+//# sourceMappingURL=delegationMessage.d.ts.map

package/dist/cjs/src/babylon/delegationMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegationMessage.d.ts","sourceRoot":"","sources":["../../../../src/babylon/delegationMessage.ts"],"names":[],"mappings":"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"}

package/dist/cjs/src/babylon/delegationMessage.js

@@ -0,0 +1,285 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSignedPsbt = getSignedPsbt;
+exports.forceFinalizePsbt = forceFinalizePsbt;
+exports.getBtcProviderForECKey = getBtcProviderForECKey;
+exports.toStakerInfo = toStakerInfo;
+exports.createStaking = createStaking;
+exports.toStakingTransaction = toStakingTransaction;
+exports.createDelegationMessageWithTransaction = createDelegationMessageWithTransaction;
+exports.createUnsignedPreStakeRegistrationBabylonTransactionWithBtcProvider = createUnsignedPreStakeRegistrationBabylonTransactionWithBtcProvider;
+/**
+ * https://github.com/babylonlabs-io/babylon/blob/v1.99.0-snapshot.250211/x/btcstaking/types/validate_parsed_message.go
+ */
+const assert_1 = __importDefault(require("assert"));
+const bip322_js_1 = require("bip322-js");
+const vendor = __importStar(require("@bitgo-beta/babylonlabs-io-btc-staking-ts"));
+const bitcoinjslib = __importStar(require("bitcoinjs-lib"));
+const utxolib = __importStar(require("@bitgo-beta/utxo-lib"));
+const utxo_core_1 = require("@bitgo-beta/utxo-core");
+const descriptor_1 = require("@bitgo-beta/utxo-core/descriptor");
+const stakingManager_1 = require("./stakingManager");
+const stakingParams_1 = require("./stakingParams");
+const network_1 = require("./network");
+/**
+ * Decode a hex or base64 encoded string and check if the length is valid.
+ * @param v
+ * @param encoding
+ */
+function decodeCheck(v, encoding) {
+    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) {
+    if (typeof v === 'string') {
+        for (const encoding of ['base64', 'hex']) {
+            try {
+                return toBase64(decodeCheck(v, encoding));
+            }
+            catch (e) {
+                // try next
+            }
+        }
+        throw new Error(`Invalid base64 or hex encoding: ${v}`);
+    }
+    return v.toString('base64');
+}
+function getSignedPsbt(psbt, descriptor, signers, { finalize = false }) {
+    const wrappedPsbt = (0, descriptor_1.toWrappedPsbt)(psbt.toBuffer());
+    const signedInputs = psbt.data.inputs.flatMap((input, i) => {
+        (0, assert_1.default)(input.witnessUtxo);
+        if (Buffer.from(descriptor.scriptPubkey()).equals(input.witnessUtxo.script)) {
+            wrappedPsbt.updateInputWithDescriptor(i, descriptor);
+            const signResults = signers.map((signer) => {
+                (0, assert_1.default)(signer.privateKey);
+                return wrappedPsbt.signWithPrv(signer.privateKey);
+            });
+            return [[i, signResults]];
+        }
+        return [];
+    });
+    (0, assert_1.default)(signedInputs.length > 0);
+    if (finalize) {
+        wrappedPsbt.finalize();
+    }
+    return bitcoinjslib.Psbt.fromBuffer(Buffer.from(wrappedPsbt.serialize()));
+}
+/**
+ * Utility method to work around a bug in btc-staking-ts
+ * https://github.com/babylonlabs-io/btc-staking-ts/issues/71
+ * @param v
+ * @param network
+ */
+function forceFinalizePsbt(v, network) {
+    if (v instanceof utxolib.Psbt) {
+        v = v.toBuffer();
+    }
+    if (v instanceof bitcoinjslib.Psbt) {
+        v = v.toBuffer();
+    }
+    const psbt = bitcoinjslib.Psbt.fromBuffer(v, { network: (0, network_1.toBitcoinJsNetwork)(network) });
+    // this only works with certain bitcoinjslib versions
+    psbt.finalizeAllInputs();
+    return psbt;
+}
+function getBtcProviderForECKey(descriptorBuilder, stakerKey) {
+    function signWithDescriptor(psbt, descriptor, key) {
+        psbt = getSignedPsbt(psbt, descriptor, [key], { finalize: false });
+        // BUG: we need to blindly finalize here even though we have not fully signed
+        psbt.finalizeAllInputs();
+        return psbt;
+    }
+    function signBip322Simple(message) {
+        // Get the script public key from the staking descriptor
+        const scriptPubKey = Buffer.from(descriptorBuilder.getStakingDescriptor().scriptPubkey());
+        const toSpendTx = bip322_js_1.BIP322.buildToSpendTx(message, scriptPubKey);
+        // Get the to_spend txid
+        const toSpendTxId = toSpendTx.getId();
+        // Create PSBT object for constructing the transaction
+        const toSignPsbt = new bitcoinjslib.Psbt();
+        toSignPsbt.setVersion(2); // nVersion = 0
+        toSignPsbt.setLocktime(0); // nLockTime = 0
+        toSignPsbt.addInput({
+            hash: toSpendTxId,
+            index: 0,
+            sequence: descriptorBuilder.stakingTimeLock,
+            witnessUtxo: {
+                script: scriptPubKey,
+                value: 0,
+            },
+        });
+        // Sign the PSBT with the staker key
+        const wrappedPsbt = (0, descriptor_1.toWrappedPsbt)(toSignPsbt.toBuffer());
+        wrappedPsbt.updateInputWithDescriptor(0, descriptorBuilder.getStakingDescriptor());
+        (0, descriptor_1.signWithKey)(wrappedPsbt, stakerKey);
+        wrappedPsbt.finalize();
+        // Encode the witness data and return
+        return bip322_js_1.BIP322.encodeWitness(bitcoinjslib.Psbt.fromBuffer(Buffer.from(wrappedPsbt.serialize())));
+    }
+    return {
+        /**
+         * @param message
+         * @param type
+         * @returns Base64 encoded string
+         */
+        async signMessage(message, type) {
+            switch (type) {
+                case 'ecdsa':
+                    return toBase64(stakerKey.sign(Buffer.from(message, 'hex')));
+                case 'bip322-simple':
+                    return toBase64(signBip322Simple(message));
+                default:
+                    throw new Error(`unexpected type: ${type}`);
+            }
+        },
+        async signPsbt(psbtHex, options) {
+            const psbt = bitcoinjslib.Psbt.fromHex(psbtHex);
+            switch (options.action.name) {
+                case 'sign-btc-slashing-transaction':
+                    return signWithDescriptor(psbt, descriptorBuilder.getStakingDescriptor(), stakerKey).toHex();
+                case 'sign-btc-unbonding-slashing-transaction':
+                    return signWithDescriptor(psbt, descriptorBuilder.getUnbondingDescriptor(), stakerKey).toHex();
+                default:
+                    throw new Error(`unexpected signing step: ${options.action.name}`);
+            }
+        },
+        /**
+         * This function is only used by btc-staking-ts to create a staking expansion registration
+         * transaction, which we do not currently support.
+         */
+        async getTransactionHex(txid) {
+            throw new Error(`Unsupported operation getTransactionHex (txid=${txid})`);
+        },
+    };
+}
+/**
+ * @param stakingKey - this is the single-sig key that is used for co-signing the staking output
+ * @param changeAddress - this is unrelated to the staking key and is used for the change output
+ */
+function toStakerInfo(stakingKey, changeAddress) {
+    if (typeof stakingKey === 'object' && 'publicKey' in stakingKey) {
+        stakingKey = stakingKey.publicKey;
+    }
+    if (typeof stakingKey === 'string') {
+        stakingKey = Buffer.from(stakingKey, 'hex');
+    }
+    return {
+        publicKeyNoCoordHex: (0, utxo_core_1.toXOnlyPublicKey)(stakingKey).toString('hex'),
+        address: changeAddress,
+    };
+}
+function createStaking(network, blockHeight, stakerBtcInfo, stakingInput, versionedParams = (0, stakingParams_1.getStakingParams)(network)) {
+    if (blockHeight === 0) {
+        throw new Error('Babylon BTC tip height cannot be 0');
+    }
+    // Get the Babylon params based on the BTC tip height from Babylon chain
+    const params = vendor.getBabylonParamByBtcHeight(blockHeight, versionedParams);
+    return new vendor.Staking((0, network_1.toBitcoinJsNetwork)(network), stakerBtcInfo, params, stakingInput.finalityProviderPksNoCoordHex, stakingInput.stakingTimelock);
+}
+function toStakingTransactionFromPsbt(psbt) {
+    if (!(psbt instanceof utxolib.bitgo.UtxoPsbt)) {
+        psbt = utxolib.bitgo.createPsbtFromBuffer(psbt.toBuffer(), utxolib.networks.bitcoin);
+    }
+    if (psbt instanceof utxolib.bitgo.UtxoPsbt) {
+        // only utxolib.bitgo.UtxoPsbt has the getUnsignedTx method
+        return bitcoinjslib.Transaction.fromHex(psbt.getUnsignedTx().toHex());
+    }
+    throw new Error('illegal state');
+}
+function toStakingTransaction(tx) {
+    if (tx instanceof bitcoinjslib.Psbt || tx instanceof utxolib.Psbt) {
+        return toStakingTransactionFromPsbt(tx);
+    }
+    return bitcoinjslib.Transaction.fromHex(tx.toHex());
+}
+/**
+ * As of babylonlabs-io/btc-staking-ts v1.5.7, the BTC delegation message creation functions support two message types:
+ * - MsgCreateBTCDelegation
+ * - MsgBtcStakeExpand
+ *
+ * BitGo still only supports MsgCreateBTCDelegation, so we need to check the message type here.
+ *
+ * @param msg - the message to check
+ * @return `true` if the message is of type MsgCreateBTCDelegation
+ */
+function isMsgBtcStakeExpand(msg) {
+    return 'previousStakingTxHash' in msg;
+}
+/*
+ * This is mostly lifted from
+ * https://github.com/babylonlabs-io/btc-staking-ts/blob/v0.4.0-rc.2/src/staking/manager.ts#L100-L172
+ *
+ * The difference is that here we are returning an _unsigned_ delegation message.
+ */
+async function createDelegationMessageWithTransaction(channel, manager, staking, stakingAmountSat, transaction, babylonAddress) {
+    if (!vendor.isValidBabylonAddress(babylonAddress)) {
+        throw new Error('Invalid Babylon address');
+    }
+    // Create delegation message without including inclusion proof
+    const msg = await manager.createBtcDelegationMsg(channel, staking, {
+        stakingTimelock: staking.stakingTimelock,
+        finalityProviderPksNoCoordHex: staking.finalityProviderPksNoCoordHex,
+        stakingAmountSat,
+    }, toStakingTransaction(transaction), babylonAddress, staking.stakerInfo, staking.params);
+    // It shouldn't be possible for us to create a MsgBtcStakeExpand here because that only gets created when
+    // we pass channel = delegation:expand into createBtcDelegationMsg, which we cannot do.
+    if (isMsgBtcStakeExpand(msg.value)) {
+        throw new Error('MsgBtcStakeExpand is not supported');
+    }
+    return { ...msg, value: msg.value };
+}
+async function createUnsignedPreStakeRegistrationBabylonTransactionWithBtcProvider(btcProvider, network, stakerBtcInfo, stakingInput, babylonBtcTipHeight, inputUTXOs, feeRateSatB, babylonAddress, channel, stakingParams = (0, stakingParams_1.getStakingParams)(network)) {
+    if (inputUTXOs.length === 0) {
+        throw new Error('No input UTXOs provided');
+    }
+    const manager = (0, stakingManager_1.createStakingManager)(network, btcProvider, stakingParams);
+    const staking = createStaking(network, babylonBtcTipHeight, stakerBtcInfo, stakingInput, stakingParams);
+    // Create unsigned staking transaction
+    const { transaction } = staking.createStakingTransaction(stakingInput.stakingAmountSat, inputUTXOs, feeRateSatB);
+    const unsignedDelegationMsg = await createDelegationMessageWithTransaction(channel, manager, staking, stakingInput.stakingAmountSat, transaction, babylonAddress);
+    return { unsignedDelegationMsg, stakingTx: transaction };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"delegationMessage.js","sourceRoot":"","sources":["../../../../src/babylon/delegationMessage.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * https://github.com/babylonlabs-io/babylon/blob/v1.99.0-snapshot.250211/x/btcstaking/types/validate_parsed_message.go\n */\nimport assert from 'assert';\n\nimport { BIP322 } from 'bip322-js';\nimport * as vendor from '@bitgo-beta/babylonlabs-io-btc-staking-ts';\nimport * as babylonProtobuf from '@babylonlabs-io/babylon-proto-ts';\nimport * as bitcoinjslib from 'bitcoinjs-lib';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\nimport { Descriptor } from '@bitgo/wasm-utxo';\nimport { toXOnlyPublicKey } from '@bitgo-beta/utxo-core';\nimport { signWithKey, toWrappedPsbt } from '@bitgo-beta/utxo-core/descriptor';\n\nimport { BabylonDescriptorBuilder } from './descriptor';\nimport { createStakingManager } from './stakingManager';\nimport { getStakingParams } from './stakingParams';\nimport { BabylonNetworkLike, toBitcoinJsNetwork } from './network';\n\nexport type ValueWithTypeUrl<T> = { typeUrl: string; value: T };\n\n/**\n * Decode a hex or base64 encoded string and check if the length is valid.\n * @param v\n * @param encoding\n */\nfunction decodeCheck(v: string, encoding: 'hex' | 'base64') {\n  const result = Buffer.from(v, encoding);\n  if (result.toString(encoding).length !== v.length) {\n    throw new Error(`Invalid ${encoding} encoding`);\n  }\n  return result;\n}\n\n/**\n * Convert a Buffer or string to a base64 encoded string.\n * @param v\n */\nfunction toBase64(v: Buffer | string) {\n  if (typeof v === 'string') {\n    for (const encoding of ['base64', 'hex'] as const) {\n      try {\n        return toBase64(decodeCheck(v, encoding));\n      } catch (e) {\n        // try next\n      }\n    }\n    throw new Error(`Invalid base64 or hex encoding: ${v}`);\n  }\n\n  return v.toString('base64');\n}\n\nexport function getSignedPsbt(\n  psbt: bitcoinjslib.Psbt,\n  descriptor: Descriptor,\n  signers: utxolib.ECPairInterface[],\n  { finalize = false }\n): bitcoinjslib.Psbt {\n  const wrappedPsbt = toWrappedPsbt(psbt.toBuffer());\n  const signedInputs = psbt.data.inputs.flatMap((input, i) => {\n    assert(input.witnessUtxo);\n    if (Buffer.from(descriptor.scriptPubkey()).equals(input.witnessUtxo.script)) {\n      wrappedPsbt.updateInputWithDescriptor(i, descriptor);\n      const signResults = signers.map((signer) => {\n        assert(signer.privateKey);\n        return wrappedPsbt.signWithPrv(signer.privateKey);\n      });\n      return [[i, signResults]];\n    }\n    return [];\n  });\n  assert(signedInputs.length > 0);\n  if (finalize) {\n    wrappedPsbt.finalize();\n  }\n  return bitcoinjslib.Psbt.fromBuffer(Buffer.from(wrappedPsbt.serialize()));\n}\n\n/**\n * Utility method to work around a bug in btc-staking-ts\n * https://github.com/babylonlabs-io/btc-staking-ts/issues/71\n * @param v\n * @param network\n */\nexport function forceFinalizePsbt(\n  v: Buffer | utxolib.Psbt | bitcoinjslib.Psbt,\n  network: BabylonNetworkLike\n): bitcoinjslib.Psbt {\n  if (v instanceof utxolib.Psbt) {\n    v = v.toBuffer();\n  }\n  if (v instanceof bitcoinjslib.Psbt) {\n    v = v.toBuffer();\n  }\n  const psbt = bitcoinjslib.Psbt.fromBuffer(v, { network: toBitcoinJsNetwork(network) });\n  // this only works with certain bitcoinjslib versions\n  psbt.finalizeAllInputs();\n  return psbt;\n}\n\nexport function getBtcProviderForECKey(\n  descriptorBuilder: BabylonDescriptorBuilder,\n  stakerKey: utxolib.ECPairInterface\n): vendor.BtcProvider {\n  function signWithDescriptor(\n    psbt: bitcoinjslib.Psbt,\n    descriptor: Descriptor,\n    key: utxolib.ECPairInterface\n  ): bitcoinjslib.Psbt {\n    psbt = getSignedPsbt(psbt, descriptor, [key], { finalize: false });\n    // BUG: we need to blindly finalize here even though we have not fully signed\n    psbt.finalizeAllInputs();\n    return psbt;\n  }\n\n  function signBip322Simple(message: string): string {\n    // Get the script public key from the staking descriptor\n    const scriptPubKey = Buffer.from(descriptorBuilder.getStakingDescriptor().scriptPubkey());\n    const toSpendTx = BIP322.buildToSpendTx(message, scriptPubKey);\n\n    // Get the to_spend txid\n    const toSpendTxId = toSpendTx.getId();\n\n    // Create PSBT object for constructing the transaction\n    const toSignPsbt = new bitcoinjslib.Psbt();\n    toSignPsbt.setVersion(2); // nVersion = 0\n    toSignPsbt.setLocktime(0); // nLockTime = 0\n    toSignPsbt.addInput({\n      hash: toSpendTxId,\n      index: 0,\n      sequence: descriptorBuilder.stakingTimeLock,\n      witnessUtxo: {\n        script: scriptPubKey,\n        value: 0,\n      },\n    });\n\n    // Sign the PSBT with the staker key\n    const wrappedPsbt = toWrappedPsbt(toSignPsbt.toBuffer());\n    wrappedPsbt.updateInputWithDescriptor(0, descriptorBuilder.getStakingDescriptor());\n    signWithKey(wrappedPsbt, stakerKey);\n    wrappedPsbt.finalize();\n\n    // Encode the witness data and return\n    return BIP322.encodeWitness(bitcoinjslib.Psbt.fromBuffer(Buffer.from(wrappedPsbt.serialize())));\n  }\n\n  return {\n    /**\n     * @param message\n     * @param type\n     * @returns Base64 encoded string\n     */\n    async signMessage(message: string, type: 'ecdsa' | 'bip322-simple'): Promise<string> {\n      switch (type) {\n        case 'ecdsa':\n          return toBase64(stakerKey.sign(Buffer.from(message, 'hex')));\n        case 'bip322-simple':\n          return toBase64(signBip322Simple(message));\n        default:\n          throw new Error(`unexpected type: ${type}`);\n      }\n    },\n\n    async signPsbt(psbtHex: string, options: vendor.SignPsbtOptions): Promise<string> {\n      const psbt = bitcoinjslib.Psbt.fromHex(psbtHex);\n      switch (options.action.name) {\n        case 'sign-btc-slashing-transaction':\n          return signWithDescriptor(psbt, descriptorBuilder.getStakingDescriptor(), stakerKey).toHex();\n        case 'sign-btc-unbonding-slashing-transaction':\n          return signWithDescriptor(psbt, descriptorBuilder.getUnbondingDescriptor(), stakerKey).toHex();\n        default:\n          throw new Error(`unexpected signing step: ${options.action.name}`);\n      }\n    },\n\n    /**\n     * This function is only used by btc-staking-ts to create a staking expansion registration\n     * transaction, which we do not currently support.\n     */\n    async getTransactionHex(txid: string): Promise<string> {\n      throw new Error(`Unsupported operation getTransactionHex (txid=${txid})`);\n    },\n  };\n}\ntype Result = {\n  unsignedDelegationMsg: ValueWithTypeUrl<babylonProtobuf.btcstakingtx.MsgCreateBTCDelegation>;\n  stakingTx: bitcoinjslib.Transaction;\n};\n\n/**\n * @param stakingKey - this is the single-sig key that is used for co-signing the staking output\n * @param changeAddress - this is unrelated to the staking key and is used for the change output\n */\nexport function toStakerInfo(\n  stakingKey: utxolib.ECPairInterface | Buffer | string,\n  changeAddress: string\n): vendor.StakerInfo {\n  if (typeof stakingKey === 'object' && 'publicKey' in stakingKey) {\n    stakingKey = stakingKey.publicKey;\n  }\n  if (typeof stakingKey === 'string') {\n    stakingKey = Buffer.from(stakingKey, 'hex');\n  }\n  return {\n    publicKeyNoCoordHex: toXOnlyPublicKey(stakingKey).toString('hex'),\n    address: changeAddress,\n  };\n}\n\nexport function createStaking(\n  network: BabylonNetworkLike,\n  blockHeight: number,\n  stakerBtcInfo: vendor.StakerInfo,\n  stakingInput: vendor.StakingInputs,\n  versionedParams: vendor.VersionedStakingParams[] = getStakingParams(network)\n): vendor.Staking {\n  if (blockHeight === 0) {\n    throw new Error('Babylon BTC tip height cannot be 0');\n  }\n\n  // Get the Babylon params based on the BTC tip height from Babylon chain\n  const params = vendor.getBabylonParamByBtcHeight(blockHeight, versionedParams);\n\n  return new vendor.Staking(\n    toBitcoinJsNetwork(network),\n    stakerBtcInfo,\n    params,\n    stakingInput.finalityProviderPksNoCoordHex,\n    stakingInput.stakingTimelock\n  );\n}\n\ntype TransactionLike =\n  | bitcoinjslib.Psbt\n  | bitcoinjslib.Transaction\n  | utxolib.Transaction\n  | utxolib.bitgo.UtxoTransaction<bigint | number>\n  | utxolib.Psbt\n  | utxolib.bitgo.UtxoPsbt;\n\nfunction toStakingTransactionFromPsbt(\n  psbt: bitcoinjslib.Psbt | utxolib.Psbt | utxolib.bitgo.UtxoPsbt\n): bitcoinjslib.Transaction {\n  if (!(psbt instanceof utxolib.bitgo.UtxoPsbt)) {\n    psbt = utxolib.bitgo.createPsbtFromBuffer(psbt.toBuffer(), utxolib.networks.bitcoin);\n  }\n  if (psbt instanceof utxolib.bitgo.UtxoPsbt) {\n    // only utxolib.bitgo.UtxoPsbt has the getUnsignedTx method\n    return bitcoinjslib.Transaction.fromHex(psbt.getUnsignedTx().toHex());\n  }\n  throw new Error('illegal state');\n}\n\nexport function toStakingTransaction(tx: TransactionLike): bitcoinjslib.Transaction {\n  if (tx instanceof bitcoinjslib.Psbt || tx instanceof utxolib.Psbt) {\n    return toStakingTransactionFromPsbt(tx);\n  }\n  return bitcoinjslib.Transaction.fromHex(tx.toHex());\n}\n\n/**\n * As of babylonlabs-io/btc-staking-ts v1.5.7, the BTC delegation message creation functions support two message types:\n * - MsgCreateBTCDelegation\n * - MsgBtcStakeExpand\n *\n * BitGo still only supports MsgCreateBTCDelegation, so we need to check the message type here.\n *\n * @param msg - the message to check\n * @return `true` if the message is of type MsgCreateBTCDelegation\n */\nfunction isMsgBtcStakeExpand(\n  msg: babylonProtobuf.btcstakingtx.MsgCreateBTCDelegation | babylonProtobuf.btcstakingtx.MsgBtcStakeExpand\n) {\n  return 'previousStakingTxHash' in msg;\n}\n\n/*\n * This is mostly lifted from\n * https://github.com/babylonlabs-io/btc-staking-ts/blob/v0.4.0-rc.2/src/staking/manager.ts#L100-L172\n *\n * The difference is that here we are returning an _unsigned_ delegation message.\n */\nexport async function createDelegationMessageWithTransaction(\n  channel: 'delegation:create' | 'delegation:register',\n  manager: vendor.BabylonBtcStakingManager,\n  staking: vendor.Staking,\n  stakingAmountSat: number,\n  transaction: TransactionLike,\n  babylonAddress: string\n): Promise<ValueWithTypeUrl<babylonProtobuf.btcstakingtx.MsgCreateBTCDelegation>> {\n  if (!vendor.isValidBabylonAddress(babylonAddress)) {\n    throw new Error('Invalid Babylon address');\n  }\n  // Create delegation message without including inclusion proof\n  const msg = await manager.createBtcDelegationMsg(\n    channel,\n    staking,\n    {\n      stakingTimelock: staking.stakingTimelock,\n      finalityProviderPksNoCoordHex: staking.finalityProviderPksNoCoordHex,\n      stakingAmountSat,\n    },\n    toStakingTransaction(transaction),\n    babylonAddress,\n    staking.stakerInfo,\n    staking.params\n  );\n\n  // It shouldn't be possible for us to create a MsgBtcStakeExpand here because that only gets created when\n  // we pass channel = delegation:expand into createBtcDelegationMsg, which we cannot do.\n  if (isMsgBtcStakeExpand(msg.value)) {\n    throw new Error('MsgBtcStakeExpand is not supported');\n  }\n\n  return { ...msg, value: msg.value as babylonProtobuf.btcstakingtx.MsgCreateBTCDelegation };\n}\n\nexport async function createUnsignedPreStakeRegistrationBabylonTransactionWithBtcProvider(\n  btcProvider: vendor.BtcProvider,\n  network: bitcoinjslib.Network,\n  stakerBtcInfo: vendor.StakerInfo,\n  stakingInput: vendor.StakingInputs,\n  babylonBtcTipHeight: number,\n  inputUTXOs: vendor.UTXO[],\n  feeRateSatB: number,\n  babylonAddress: string,\n  channel: 'delegation:create' | 'delegation:register',\n  stakingParams: vendor.VersionedStakingParams[] = getStakingParams(network)\n): Promise<Result> {\n  if (inputUTXOs.length === 0) {\n    throw new Error('No input UTXOs provided');\n  }\n  const manager = createStakingManager(network, btcProvider, stakingParams);\n  const staking = createStaking(network, babylonBtcTipHeight, stakerBtcInfo, stakingInput, stakingParams);\n  // Create unsigned staking transaction\n  const { transaction } = staking.createStakingTransaction(stakingInput.stakingAmountSat, inputUTXOs, feeRateSatB);\n  const unsignedDelegationMsg = await createDelegationMessageWithTransaction(\n    channel,\n    manager,\n    staking,\n    stakingInput.stakingAmountSat,\n    transaction,\n    babylonAddress\n  );\n  return { unsignedDelegationMsg, stakingTx: transaction };\n}\n"]}

package/dist/cjs/src/babylon/descriptor.d.ts

@@ -0,0 +1,48 @@
+/**
+ * https://github.com/babylonlabs-io/babylon/tree/main/docs
+ * https://github.com/babylonlabs-io/babylon/blob/main/docs/staking-script.md
+ * https://github.com/babylonlabs-io/babylon/blob/v1.99.0-snapshot.250211/btcstaking/staking.go
+ */
+import { Descriptor, ast } from '@bitgo/wasm-utxo';
+import { StakingParams } from '@bitgo-beta/babylonlabs-io-btc-staking-ts';
+export declare function getUnspendableKey(): string;
+export declare function sortedKeys(keys: Buffer[]): Buffer[];
+export declare class BabylonDescriptorBuilder {
+    stakerKey: Buffer;
+    finalityProviderKeys: Buffer[];
+    covenantKeys: Buffer[];
+    covenantThreshold: number;
+    stakingTimeLock: number;
+    unbondingTimeLock: number;
+    constructor(stakerKey: Buffer, finalityProviderKeys: Buffer[], covenantKeys: Buffer[], covenantThreshold: number, stakingTimeLock: number, unbondingTimeLock: number);
+    static fromParams(params: {
+        stakerKey: Buffer;
+        finalityProviderKeys: Buffer[];
+    } & StakingParams): BabylonDescriptorBuilder;
+    /** Spend path with the staker key and the staking timelock */
+    getStakingTimelockMiniscriptNode(): ast.MiniscriptNode;
+    /** Spend path with the staker key and the unbonding timelock */
+    getUnbondingTimelockMiniscriptNode(): ast.MiniscriptNode;
+    /** Spend path with the staker key and the covenant keys */
+    getUnbondingMiniscriptNode(): ast.MiniscriptNode;
+    /** Spend path with the finality provider keys and the covenant keys */
+    getSlashingMiniscriptNode(): ast.MiniscriptNode;
+    /**
+     * Creates a descriptor for a staking output.
+     *
+     * Three spend paths:
+     * - the slashing script,
+     * - the unbonding script,
+     * - the timelocked unstaking script.
+     */
+    getStakingDescriptor(): Descriptor;
+    /**
+     * Creates a descriptor for the timelocked unbonding script.
+     */
+    getUnbondingTimelockDescriptor(): Descriptor;
+    /**
+     * Creates a descriptor with two script paths: the slashing script and the timelocked unbonding script.
+     */
+    getUnbondingDescriptor(): Descriptor;
+}
+//# sourceMappingURL=descriptor.d.ts.map

package/dist/cjs/src/babylon/descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor.d.ts","sourceRoot":"","sources":["../../../../src/babylon/descriptor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAE1E,wBAAgB,iBAAiB,IAAI,MAAM,CAG1C;AAOD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAEnD;AAUD,qBAAa,wBAAwB;IAE1B,SAAS,EAAE,MAAM;IACjB,oBAAoB,EAAE,MAAM,EAAE;IAC9B,YAAY,EAAE,MAAM,EAAE;IACtB,iBAAiB,EAAE,MAAM;IACzB,eAAe,EAAE,MAAM;IACvB,iBAAiB,EAAE,MAAM;gBALzB,SAAS,EAAE,MAAM,EACjB,oBAAoB,EAAE,MAAM,EAAE,EAC9B,YAAY,EAAE,MAAM,EAAE,EACtB,iBAAiB,EAAE,MAAM,EACzB,eAAe,EAAE,MAAM,EACvB,iBAAiB,EAAE,MAAM;IAGlC,MAAM,CAAC,UAAU,CACf,MAAM,EAAE;QACN,SAAS,EAAE,MAAM,CAAC;QAClB,oBAAoB,EAAE,MAAM,EAAE,CAAC;KAChC,GAAG,aAAa,GAChB,wBAAwB;IAW3B,8DAA8D;IAC9D,gCAAgC,IAAI,GAAG,CAAC,cAAc;IAItD,gEAAgE;IAChE,kCAAkC,IAAI,GAAG,CAAC,cAAc;IAIxD,2DAA2D;IAC3D,0BAA0B,IAAI,GAAG,CAAC,cAAc;IAIhD,uEAAuE;IACvE,yBAAyB,IAAI,GAAG,CAAC,cAAc;IAgB/C;;;;;;;OAOG;IACH,oBAAoB,IAAI,UAAU;IAOlC;;OAEG;IACH,8BAA8B,IAAI,UAAU;IAI5C;;OAEG;IACH,sBAAsB,IAAI,UAAU;CAGrC"}