@bitgo-beta/utxo-descriptors 0.0.1-beta.3 → 0.0.1-beta.300

package/dist/cjs/src/sbtc/parseDescriptor.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSbtcDepositDescriptor = parseSbtcDepositDescriptor;
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const descriptor_1 = require("@bitgo-beta/utxo-core/descriptor");
+const constants_1 = require("./constants");
+function asString(v, field) {
+    if (typeof v !== 'string') {
+        throw new Error(`${field} must be a string`);
+    }
+    return v;
+}
+function asNumber(v, field) {
+    if (typeof v !== 'number') {
+        throw new Error(`${field} must be a number`);
+    }
+    return v;
+}
+/**
+ * Pull `[threshold, ...keys]` out of a `multi_a` AST node value, validating
+ * each element. The descriptor's `multi_a` is rendered with keys either as
+ * concrete hex (definite descriptor) or as xpub strings ending in `/*`
+ * (derivable descriptor) — both are strings here, so we don't try to convert
+ * to Buffer at this level.
+ */
+function parseMulti(multi) {
+    if (!Array.isArray(multi) || multi.length < 1) {
+        throw new Error('Invalid multi_a structure: not an array or empty');
+    }
+    const [threshold, ...keys] = multi;
+    if (typeof threshold !== 'number') {
+        throw new Error('Invalid multi_a structure: threshold is not a number');
+    }
+    if (!keys.every((k) => typeof k === 'string')) {
+        throw new Error('Invalid multi_a structure: not all keys are strings');
+    }
+    return [threshold, keys];
+}
+function parseDepositLeaf(depositNode, matcher) {
+    const depositPattern = {
+        and_v: [{ payload_drop: { $var: 'payloadHex' } }, { pk: { $var: 'signersKey' } }],
+    };
+    const match = matcher.match(depositNode, depositPattern);
+    if (!match) {
+        throw new Error('Deposit leaf does not match expected pattern');
+    }
+    const payloadHex = asString(match.payloadHex, 'payload_drop value');
+    const signersKeyHex = asString(match.signersKey, 'pk_k key');
+    const expectedPayloadLength = constants_1.MAX_FEE_BYTE_LENGTH + constants_1.STACKS_RECIPIENT_BYTE_LENGTH;
+    const payload = Buffer.from(payloadHex, 'hex');
+    if (payload.length !== expectedPayloadLength) {
+        throw new Error(`payload_drop value must be ${expectedPayloadLength} bytes (${expectedPayloadLength * 2} hex chars), got ${payload.length} bytes`);
+    }
+    const maxFee = payload.readBigUInt64BE(0);
+    const stacksRecipient = payload.subarray(constants_1.MAX_FEE_BYTE_LENGTH);
+    const signersAggregateKey = Buffer.from(signersKeyHex, 'hex');
+    if (signersAggregateKey.length !== 32) {
+        throw new Error(`signersAggregateKey must be 32 bytes x-only, got ${signersAggregateKey.length}`);
+    }
+    return { signersAggregateKey, maxFee, stacksRecipient };
+}
+function parseReclaimLeaf(reclaimNode, matcher) {
+    // and_v(r:older(<lockTime>), multi_a(2, k1, k2, k3))
+    const reclaimPattern = {
+        and_v: [{ 'r:older': { $var: 'lockTime' } }, { multi_a: { $var: 'reclaimMulti' } }],
+    };
+    const match = matcher.match(reclaimNode, reclaimPattern);
+    if (!match) {
+        throw new Error('Reclaim leaf does not match expected pattern');
+    }
+    const lockTime = asNumber(match.lockTime, 'r:older argument');
+    if (lockTime <= 0) {
+        throw new Error(`reclaim lockTime must be > 0, got ${lockTime}`);
+    }
+    const [threshold, reclaimKeyStrings] = parseMulti(match.reclaimMulti);
+    if (threshold !== 2) {
+        throw new Error(`reclaim multi_a threshold must be 2, got ${threshold}`);
+    }
+    if (reclaimKeyStrings.length !== 3) {
+        throw new Error(`reclaim multi_a must have exactly 3 keys, got ${reclaimKeyStrings.length}`);
+    }
+    return { lockTime, reclaimKeyStrings };
+}
+const HEX_X_ONLY_KEY = /^[0-9a-fA-F]{64}$/;
+const XPUB_WITH_INDEX = /^([1-9A-HJ-NP-Za-km-z]+)\/(\d+)$/;
+/**
+ * Resolve a single `multi_a` key entry to a 32-byte x-only public key.
+ *
+ * Accepts:
+ *   - 64-hex-char string → returned as-is (already x-only)
+ *   - `xpub.../<index>` → BIP32-derive at that index and drop the prefix byte
+ *
+ * Returns null for any other shape (e.g. wildcard `xpub.../*`, malformed input).
+ */
+function resolveReclaimKey(s) {
+    if (HEX_X_ONLY_KEY.test(s)) {
+        return Buffer.from(s, 'hex');
+    }
+    const m = s.match(XPUB_WITH_INDEX);
+    if (!m) {
+        return null;
+    }
+    const [, xpub, indexStr] = m;
+    const index = Number.parseInt(indexStr, 10);
+    if (!Number.isFinite(index) || index < 0) {
+        return null;
+    }
+    let node;
+    try {
+        node = wasm_utxo_1.BIP32.fromBase58(xpub);
+    }
+    catch {
+        return null;
+    }
+    // BIP32 public key is 33 bytes (1 prefix + 32 x-only). Drop the prefix.
+    return Buffer.from(node.derive(index).publicKey.subarray(1));
+}
+/**
+ * Convert reclaim-leaf key strings into 32-byte x-only buffers. Accepts both
+ * the definite/derived form (concrete 64-hex-char x-only keys) and the form
+ * produced by `Descriptor.atDerivationIndex(n)` (`xpub.../<n>`). Returns
+ * undefined if any entry is still wildcard (`xpub.../*`) or otherwise
+ * unresolvable.
+ */
+function reclaimKeysFromStrings(keyStrings) {
+    const resolved = keyStrings.map(resolveReclaimKey);
+    if (resolved.some((b) => b === null) || resolved.length !== 3) {
+        return undefined;
+    }
+    return [resolved[0], resolved[1], resolved[2]];
+}
+/**
+ * Parse an sBTC peg-in deposit descriptor and return its components.
+ *
+ * Returns `null` if the descriptor does not match the expected
+ * `tr(<UNSPENDABLE>, {<depositLeaf>, <reclaimLeaf>})` shape — same convention
+ * as babylon's `parseStakingDescriptor`. Throws if the shape matches but a
+ * sub-field is malformed (e.g. signers key isn't 32 bytes, payload isn't 30
+ * bytes, threshold isn't 2).
+ *
+ * Accepts both the `Descriptor` WASM object (definite or derivable) and a
+ * pre-extracted `ast.DescriptorNode`
+ */
+function parseSbtcDepositDescriptor(descriptor) {
+    const pattern = {
+        tr: [constants_1.UNSPENDABLE_INTERNAL_KEY, [{ $var: 'depositLeaf' }, { $var: 'reclaimLeaf' }]],
+    };
+    const matcher = new descriptor_1.PatternMatcher();
+    const descriptorNode = descriptor instanceof wasm_utxo_1.Descriptor ? wasm_utxo_1.ast.fromDescriptor(descriptor) : descriptor;
+    const result = matcher.match(descriptorNode, pattern);
+    if (!result) {
+        return null;
+    }
+    const depositMiniscriptNode = result.depositLeaf;
+    let reclaimMiniscriptNode = result.reclaimLeaf;
+    const { signersAggregateKey, maxFee, stacksRecipient } = parseDepositLeaf(depositMiniscriptNode, matcher);
+    const { lockTime, reclaimKeyStrings } = parseReclaimLeaf(reclaimMiniscriptNode, matcher);
+    const reclaimKeyStringsTuple = [
+        reclaimKeyStrings[0],
+        reclaimKeyStrings[1],
+        reclaimKeyStrings[2],
+    ];
+    const reclaimKeys = reclaimKeysFromStrings(reclaimKeyStrings);
+    if (reclaimKeys) {
+        // Rewrite the reclaim leaf with concrete hex keys when we can resolve
+        // them — `Miniscript.fromString(..., 'tap')` only accepts x-only hex in
+        // `multi_a`, not xpub-form strings. With this rewrite the formatted
+        // leaf is directly compilable; without it callers must do the
+        // resolution themselves.
+        reclaimMiniscriptNode = {
+            and_v: [{ 'r:older': lockTime }, { multi_a: [2, ...reclaimKeys.map((k) => k.toString('hex'))] }],
+        };
+    }
+    return {
+        signersAggregateKey,
+        maxFee,
+        stacksRecipient,
+        lockTime,
+        reclaimKeys,
+        reclaimKeyStrings: reclaimKeyStringsTuple,
+        depositMiniscriptNode,
+        reclaimMiniscriptNode,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parseDescriptor.js","sourceRoot":"","sources":["../../../../src/sbtc/parseDescriptor.ts"],"names":[],"mappings":";;AAgNA,gEAgDC;AAhQD,gDAA0D;AAC1D,iEAA2E;AAE3E,2CAA0G;AA2C1G,SAAS,QAAQ,CAAC,CAAU,EAAE,KAAa;IACzC,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,mBAAmB,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED,SAAS,QAAQ,CAAC,CAAU,EAAE,KAAa;IACzC,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,mBAAmB,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;;;;GAMG;AACH,SAAS,UAAU,CAAC,KAAc;IAChC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC9C,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IACD,MAAM,CAAC,SAAS,EAAE,GAAG,IAAI,CAAC,GAAG,KAAK,CAAC;IACnC,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IACD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC;QAC9C,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AAC3B,CAAC;AAED,SAAS,gBAAgB,CACvB,WAA+B,EAC/B,OAAuB;IAEvB,MAAM,cAAc,GAAY;QAC9B,KAAK,EAAE,CAAC,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,CAAC;KAClF,CAAC;IACF,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;IACzD,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;IAClE,CAAC;IAED,MAAM,UAAU,GAAG,QAAQ,CAAC,KAAK,CAAC,UAAU,EAAE,oBAAoB,CAAC,CAAC;IACpE,MAAM,aAAa,GAAG,QAAQ,CAAC,KAAK,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IAE7D,MAAM,qBAAqB,GAAG,+BAAmB,GAAG,wCAA4B,CAAC;IACjF,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IAC/C,IAAI,OAAO,CAAC,MAAM,KAAK,qBAAqB,EAAE,CAAC;QAC7C,MAAM,IAAI,KAAK,CACb,8BAA8B,qBAAqB,WAAW,qBAAqB,GAAG,CAAC,oBACrF,OAAO,CAAC,MACV,QAAQ,CACT,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IAC1C,MAAM,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC,+BAAmB,CAAC,CAAC;IAE9D,MAAM,mBAAmB,GAAG,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IAC9D,IAAI,mBAAmB,CAAC,MAAM,KAAK,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,oDAAoD,mBAAmB,CAAC,MAAM,EAAE,CAAC,CAAC;IACpG,CAAC;IAED,OAAO,EAAE,mBAAmB,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC;AAC1D,CAAC;AAED,SAAS,gBAAgB,CACvB,WAA+B,EAC/B,OAAuB;IAEvB,qDAAqD;IACrD,MAAM,cAAc,GAAY;QAC9B,KAAK,EAAE,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE,CAAC;KACpF,CAAC;IACF,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;IACzD,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;IAClE,CAAC;IAED,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,kBAAkB,CAAC,CAAC;IAC9D,IAAI,QAAQ,IAAI,CAAC,EAAE,CAAC;QAClB,MAAM,IAAI,KAAK,CAAC,qCAAqC,QAAQ,EAAE,CAAC,CAAC;IACnE,CAAC;IAED,MAAM,CAAC,SAAS,EAAE,iBAAiB,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IACtE,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,4CAA4C,SAAS,EAAE,CAAC,CAAC;IAC3E,CAAC;IACD,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,iDAAiD,iBAAiB,CAAC,MAAM,EAAE,CAAC,CAAC;IAC/F,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,CAAC;AACzC,CAAC;AAED,MAAM,cAAc,GAAG,mBAAmB,CAAC;AAC3C,MAAM,eAAe,GAAG,kCAAkC,CAAC;AAE3D;;;;;;;;GAQG;AACH,SAAS,iBAAiB,CAAC,CAAS;IAClC,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3B,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IAC/B,CAAC;IACD,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IACnC,IAAI,CAAC,CAAC,EAAE,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;IAC7B,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IAC5C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACzC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,IAAI,CAAC;IACT,IAAI,CAAC;QACH,IAAI,GAAG,iBAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;IACD,wEAAwE;IACxE,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;GAMG;AACH,SAAS,sBAAsB,CAAC,UAAoB;IAClD,MAAM,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IACnD,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9D,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAW,EAAE,QAAQ,CAAC,CAAC,CAAW,EAAE,QAAQ,CAAC,CAAC,CAAW,CAAC,CAAC;AAC/E,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,0BAA0B,CACxC,UAA2C;IAE3C,MAAM,OAAO,GAAY;QACvB,EAAE,EAAE,CAAC,oCAAwB,EAAE,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CAAC;KACnF,CAAC;IAEF,MAAM,OAAO,GAAG,IAAI,2BAAc,EAAE,CAAC;IACrC,MAAM,cAAc,GAAG,UAAU,YAAY,sBAAU,CAAC,CAAC,CAAC,eAAG,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;IACtG,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;IAEtD,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,qBAAqB,GAAG,MAAM,CAAC,WAAiC,CAAC;IACvE,IAAI,qBAAqB,GAAG,MAAM,CAAC,WAAiC,CAAC;IAErE,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,eAAe,EAAE,GAAG,gBAAgB,CAAC,qBAAqB,EAAE,OAAO,CAAC,CAAC;IAC1G,MAAM,EAAE,QAAQ,EAAE,iBAAiB,EAAE,GAAG,gBAAgB,CAAC,qBAAqB,EAAE,OAAO,CAAC,CAAC;IACzF,MAAM,sBAAsB,GAA6B;QACvD,iBAAiB,CAAC,CAAC,CAAC;QACpB,iBAAiB,CAAC,CAAC,CAAC;QACpB,iBAAiB,CAAC,CAAC,CAAC;KACrB,CAAC;IAEF,MAAM,WAAW,GAAG,sBAAsB,CAAC,iBAAiB,CAAC,CAAC;IAC9D,IAAI,WAAW,EAAE,CAAC;QAChB,sEAAsE;QACtE,wEAAwE;QACxE,oEAAoE;QACpE,8DAA8D;QAC9D,yBAAyB;QACzB,qBAAqB,GAAG;YACtB,KAAK,EAAE,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;SACjG,CAAC;IACJ,CAAC;IAED,OAAO;QACL,mBAAmB;QACnB,MAAM;QACN,eAAe;QACf,QAAQ;QACR,WAAW;QACX,iBAAiB,EAAE,sBAAsB;QACzC,qBAAqB;QACrB,qBAAqB;KACtB,CAAC;AACJ,CAAC","sourcesContent":["import { BIP32, Descriptor, ast } from '@bitgo/wasm-utxo';\nimport { PatternMatcher, Pattern } from '@bitgo-beta/utxo-core/descriptor';\n\nimport { MAX_FEE_BYTE_LENGTH, STACKS_RECIPIENT_BYTE_LENGTH, UNSPENDABLE_INTERNAL_KEY } from './constants';\n\n/**\n * Parsed components of an sBTC peg-in deposit descriptor.\n *\n * The parser returns both the high-level\n * fields callers usually need (keys, lockTime, fee, recipient) and the raw\n * miniscript AST nodes so the leaves can be re-compiled into a\n * `Miniscript` via `ast.formatNode` + `Miniscript.fromString`.\n */\nexport type ParsedSbtcDepositDescriptor = {\n  /** 32-byte x-only signers aggregate key from the deposit leaf. */\n  signersAggregateKey: Buffer;\n  /** Max signer fee parsed from the first 8 bytes of the payload_drop value. */\n  maxFee: bigint;\n  /** 22-byte Stacks recipient parsed from the trailing bytes of the payload. */\n  stacksRecipient: Buffer;\n  /** Reclaim-leaf relative timelock (number of Bitcoin blocks, OP_CSV argument). */\n  lockTime: number;\n  /**\n   * The three concrete x-only reclaim keys from the reclaim-leaf `multi_a`,\n   * in the order they appear inside the leaf (descriptor library sorts by hex).\n   * Only present when the descriptor is in its derived/definite form — for\n   * derivable descriptors the multi_a entries are xpub strings (e.g.\n   * `xpub.../*`), which can't be turned into 32-byte buffers without picking\n   * a derivation index. Callers that need raw key bytes MUST pass the\n   * derived descriptor (see `deriveReclaimKeys` for derivable inputs).\n   */\n  reclaimKeys: [Buffer, Buffer, Buffer] | undefined;\n  /** Raw miniscript AST for the deposit leaf (first tap-tree leaf). */\n  depositMiniscriptNode: ast.MiniscriptNode;\n  /** Raw miniscript AST for the reclaim leaf (second tap-tree leaf). */\n  reclaimMiniscriptNode: ast.MiniscriptNode;\n  /**\n   * The three raw `multi_a` key entries from the reclaim leaf, exactly as\n   * they appear in the descriptor — `xpub.../*` for derivable descriptors and\n   * 64-hex-char x-only keys for definite descriptors. Useful for callers that\n   * need the original xpub form (e.g. to round-trip back to a descriptor\n   * builder) and don't want the resolved `reclaimKeys` buffers.\n   */\n  reclaimKeyStrings: [string, string, string];\n};\n\nfunction asString(v: unknown, field: string): string {\n  if (typeof v !== 'string') {\n    throw new Error(`${field} must be a string`);\n  }\n  return v;\n}\n\nfunction asNumber(v: unknown, field: string): number {\n  if (typeof v !== 'number') {\n    throw new Error(`${field} must be a number`);\n  }\n  return v;\n}\n\n/**\n * Pull `[threshold, ...keys]` out of a `multi_a` AST node value, validating\n * each element. The descriptor's `multi_a` is rendered with keys either as\n * concrete hex (definite descriptor) or as xpub strings ending in `/*`\n * (derivable descriptor) — both are strings here, so we don't try to convert\n * to Buffer at this level.\n */\nfunction parseMulti(multi: unknown): [number, string[]] {\n  if (!Array.isArray(multi) || multi.length < 1) {\n    throw new Error('Invalid multi_a structure: not an array or empty');\n  }\n  const [threshold, ...keys] = multi;\n  if (typeof threshold !== 'number') {\n    throw new Error('Invalid multi_a structure: threshold is not a number');\n  }\n  if (!keys.every((k) => typeof k === 'string')) {\n    throw new Error('Invalid multi_a structure: not all keys are strings');\n  }\n  return [threshold, keys];\n}\n\nfunction parseDepositLeaf(\n  depositNode: ast.MiniscriptNode,\n  matcher: PatternMatcher\n): { signersAggregateKey: Buffer; maxFee: bigint; stacksRecipient: Buffer } {\n  const depositPattern: Pattern = {\n    and_v: [{ payload_drop: { $var: 'payloadHex' } }, { pk: { $var: 'signersKey' } }],\n  };\n  const match = matcher.match(depositNode, depositPattern);\n  if (!match) {\n    throw new Error('Deposit leaf does not match expected pattern');\n  }\n\n  const payloadHex = asString(match.payloadHex, 'payload_drop value');\n  const signersKeyHex = asString(match.signersKey, 'pk_k key');\n\n  const expectedPayloadLength = MAX_FEE_BYTE_LENGTH + STACKS_RECIPIENT_BYTE_LENGTH;\n  const payload = Buffer.from(payloadHex, 'hex');\n  if (payload.length !== expectedPayloadLength) {\n    throw new Error(\n      `payload_drop value must be ${expectedPayloadLength} bytes (${expectedPayloadLength * 2} hex chars), got ${\n        payload.length\n      } bytes`\n    );\n  }\n\n  const maxFee = payload.readBigUInt64BE(0);\n  const stacksRecipient = payload.subarray(MAX_FEE_BYTE_LENGTH);\n\n  const signersAggregateKey = Buffer.from(signersKeyHex, 'hex');\n  if (signersAggregateKey.length !== 32) {\n    throw new Error(`signersAggregateKey must be 32 bytes x-only, got ${signersAggregateKey.length}`);\n  }\n\n  return { signersAggregateKey, maxFee, stacksRecipient };\n}\n\nfunction parseReclaimLeaf(\n  reclaimNode: ast.MiniscriptNode,\n  matcher: PatternMatcher\n): { lockTime: number; reclaimKeyStrings: string[] } {\n  // and_v(r:older(<lockTime>), multi_a(2, k1, k2, k3))\n  const reclaimPattern: Pattern = {\n    and_v: [{ 'r:older': { $var: 'lockTime' } }, { multi_a: { $var: 'reclaimMulti' } }],\n  };\n  const match = matcher.match(reclaimNode, reclaimPattern);\n  if (!match) {\n    throw new Error('Reclaim leaf does not match expected pattern');\n  }\n\n  const lockTime = asNumber(match.lockTime, 'r:older argument');\n  if (lockTime <= 0) {\n    throw new Error(`reclaim lockTime must be > 0, got ${lockTime}`);\n  }\n\n  const [threshold, reclaimKeyStrings] = parseMulti(match.reclaimMulti);\n  if (threshold !== 2) {\n    throw new Error(`reclaim multi_a threshold must be 2, got ${threshold}`);\n  }\n  if (reclaimKeyStrings.length !== 3) {\n    throw new Error(`reclaim multi_a must have exactly 3 keys, got ${reclaimKeyStrings.length}`);\n  }\n\n  return { lockTime, reclaimKeyStrings };\n}\n\nconst HEX_X_ONLY_KEY = /^[0-9a-fA-F]{64}$/;\nconst XPUB_WITH_INDEX = /^([1-9A-HJ-NP-Za-km-z]+)\\/(\\d+)$/;\n\n/**\n * Resolve a single `multi_a` key entry to a 32-byte x-only public key.\n *\n * Accepts:\n *   - 64-hex-char string → returned as-is (already x-only)\n *   - `xpub.../<index>` → BIP32-derive at that index and drop the prefix byte\n *\n * Returns null for any other shape (e.g. wildcard `xpub.../*`, malformed input).\n */\nfunction resolveReclaimKey(s: string): Buffer | null {\n  if (HEX_X_ONLY_KEY.test(s)) {\n    return Buffer.from(s, 'hex');\n  }\n  const m = s.match(XPUB_WITH_INDEX);\n  if (!m) {\n    return null;\n  }\n  const [, xpub, indexStr] = m;\n  const index = Number.parseInt(indexStr, 10);\n  if (!Number.isFinite(index) || index < 0) {\n    return null;\n  }\n  let node;\n  try {\n    node = BIP32.fromBase58(xpub);\n  } catch {\n    return null;\n  }\n  // BIP32 public key is 33 bytes (1 prefix + 32 x-only). Drop the prefix.\n  return Buffer.from(node.derive(index).publicKey.subarray(1));\n}\n\n/**\n * Convert reclaim-leaf key strings into 32-byte x-only buffers. Accepts both\n * the definite/derived form (concrete 64-hex-char x-only keys) and the form\n * produced by `Descriptor.atDerivationIndex(n)` (`xpub.../<n>`). Returns\n * undefined if any entry is still wildcard (`xpub.../*`) or otherwise\n * unresolvable.\n */\nfunction reclaimKeysFromStrings(keyStrings: string[]): [Buffer, Buffer, Buffer] | undefined {\n  const resolved = keyStrings.map(resolveReclaimKey);\n  if (resolved.some((b) => b === null) || resolved.length !== 3) {\n    return undefined;\n  }\n  return [resolved[0] as Buffer, resolved[1] as Buffer, resolved[2] as Buffer];\n}\n\n/**\n * Parse an sBTC peg-in deposit descriptor and return its components.\n *\n * Returns `null` if the descriptor does not match the expected\n * `tr(<UNSPENDABLE>, {<depositLeaf>, <reclaimLeaf>})` shape — same convention\n * as babylon's `parseStakingDescriptor`. Throws if the shape matches but a\n * sub-field is malformed (e.g. signers key isn't 32 bytes, payload isn't 30\n * bytes, threshold isn't 2).\n *\n * Accepts both the `Descriptor` WASM object (definite or derivable) and a\n * pre-extracted `ast.DescriptorNode`\n */\nexport function parseSbtcDepositDescriptor(\n  descriptor: Descriptor | ast.DescriptorNode\n): ParsedSbtcDepositDescriptor | null {\n  const pattern: Pattern = {\n    tr: [UNSPENDABLE_INTERNAL_KEY, [{ $var: 'depositLeaf' }, { $var: 'reclaimLeaf' }]],\n  };\n\n  const matcher = new PatternMatcher();\n  const descriptorNode = descriptor instanceof Descriptor ? ast.fromDescriptor(descriptor) : descriptor;\n  const result = matcher.match(descriptorNode, pattern);\n\n  if (!result) {\n    return null;\n  }\n\n  const depositMiniscriptNode = result.depositLeaf as ast.MiniscriptNode;\n  let reclaimMiniscriptNode = result.reclaimLeaf as ast.MiniscriptNode;\n\n  const { signersAggregateKey, maxFee, stacksRecipient } = parseDepositLeaf(depositMiniscriptNode, matcher);\n  const { lockTime, reclaimKeyStrings } = parseReclaimLeaf(reclaimMiniscriptNode, matcher);\n  const reclaimKeyStringsTuple: [string, string, string] = [\n    reclaimKeyStrings[0],\n    reclaimKeyStrings[1],\n    reclaimKeyStrings[2],\n  ];\n\n  const reclaimKeys = reclaimKeysFromStrings(reclaimKeyStrings);\n  if (reclaimKeys) {\n    // Rewrite the reclaim leaf with concrete hex keys when we can resolve\n    // them — `Miniscript.fromString(..., 'tap')` only accepts x-only hex in\n    // `multi_a`, not xpub-form strings. With this rewrite the formatted\n    // leaf is directly compilable; without it callers must do the\n    // resolution themselves.\n    reclaimMiniscriptNode = {\n      and_v: [{ 'r:older': lockTime }, { multi_a: [2, ...reclaimKeys.map((k) => k.toString('hex'))] }],\n    };\n  }\n\n  return {\n    signersAggregateKey,\n    maxFee,\n    stacksRecipient,\n    lockTime,\n    reclaimKeys,\n    reclaimKeyStrings: reclaimKeyStringsTuple,\n    depositMiniscriptNode,\n    reclaimMiniscriptNode,\n  };\n}\n"]}

package/dist/cjs/test/unit/pox5/descriptor.d.ts

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

package/dist/cjs/test/unit/pox5/descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor.d.ts","sourceRoot":"","sources":["../../../../../test/unit/pox5/descriptor.ts"],"names":[],"mappings":""}

package/dist/cjs/test/unit/pox5/descriptor.js

@@ -0,0 +1,157 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const crypto_1 = require("crypto");
+const bitcoin_staking_1 = require("@stacks/bitcoin-staking");
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const testutils_1 = require("@bitgo/wasm-utxo/testutils");
+const pox5_1 = require("../../../src/pox5");
+const OPCODES = {
+    OP_0: 0x00,
+    OP_IF: 0x63,
+    OP_ELSE: 0x67,
+    OP_ENDIF: 0x68,
+    OP_VERIFY: 0x69,
+    OP_SIZE: 0x82,
+    OP_EQUAL: 0x87,
+    OP_EQUALVERIFY: 0x88,
+    OP_SHA256: 0xa8,
+    OP_CHECKSIG: 0xac,
+    OP_CHECKMULTISIG: 0xae,
+    OP_CLTV: 0xb1,
+};
+function getBip32Triple() {
+    const [user, backup, bitgo] = (0, testutils_1.getKeyTriple)('default');
+    return [user, backup, bitgo];
+}
+function sha256(value) {
+    return (0, crypto_1.createHash)('sha256').update(value).digest();
+}
+function params(overrides = {}) {
+    const stakerKeys = getBip32Triple();
+    const earlyExitKey = Buffer.from(stakerKeys[0].derive(9).publicKey);
+    return {
+        unlockHeight: 840000,
+        stakerCommitment: sha256((0, bitcoin_staking_1.computeRegisterPreimage)('SP000000000000000000002Q6VF78')),
+        earlyExitKey,
+        stakerKeys,
+        ...overrides,
+    };
+}
+function asmToScript(asm) {
+    const tokens = asm.split(' ');
+    const chunks = [];
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
+        const push = token.match(/^OP_PUSHBYTES_(\d+)$/);
+        if (push) {
+            const bytes = Buffer.from(tokens[++index], 'hex');
+            assert.strictEqual(bytes.length, Number(push[1]));
+            chunks.push(Buffer.of(bytes.length), bytes);
+            continue;
+        }
+        const number = token.match(/^OP_PUSHNUM_(\d+)$/);
+        if (number) {
+            chunks.push(Buffer.of(0x50 + Number(number[1])));
+            continue;
+        }
+        const opcode = OPCODES[token];
+        assert.notStrictEqual(opcode, undefined, `unsupported ASM token ${token}`);
+        chunks.push(Buffer.of(opcode));
+    }
+    return Buffer.concat(chunks);
+}
+function encodeTwoOfThreeUnlock(keys) {
+    return Buffer.concat([Buffer.of(0x52), ...keys.flatMap((key) => [Buffer.of(33), key]), Buffer.of(0x53, 0xae)]);
+}
+describe('PoX-5 lockup descriptors', function () {
+    it('renders the required byte-identical canonical script and P2WSH output', function () {
+        const derivable = params();
+        const stakerKeys = (0, pox5_1.derivePox5StakerKeys)(derivable.stakerKeys, 0);
+        const definite = { ...derivable, stakerKeys };
+        const descriptor = (0, pox5_1.createPox5LockupDescriptor)(definite);
+        const localWitnessScript = asmToScript(descriptor.toAsmString());
+        const unlockBytes = encodeTwoOfThreeUnlock(stakerKeys);
+        const earlyUnlockBytes = (0, bitcoin_staking_1.buildUnlockScript)(definite.earlyExitKey);
+        const sdkWitnessScript = Buffer.from((0, bitcoin_staking_1.buildLockScript)({
+            stxAddress: 'SP000000000000000000002Q6VF78',
+            unlockHeight: definite.unlockHeight,
+            unlockBytes,
+            earlyUnlockBytes,
+            validateEarlyUnlockBytes: false,
+        }));
+        assert.deepStrictEqual(localWitnessScript, sdkWitnessScript);
+        assert.ok(descriptor.toAsmString().includes('OP_SHA256 OP_PUSHBYTES_32'));
+        assert.ok(descriptor.toAsmString().includes('OP_EQUALVERIFY OP_PUSHBYTES_33'));
+        const localScriptPubKey = (0, pox5_1.createPox5LockupScriptPubKey)(definite);
+        const sdkScriptPubKey = Buffer.from((0, bitcoin_staking_1.buildLockOutputScript)({
+            stxAddress: 'SP000000000000000000002Q6VF78',
+            unlockHeight: definite.unlockHeight,
+            unlockBytes,
+            earlyUnlockBytes,
+        }));
+        assert.deepStrictEqual(localScriptPubKey, sdkScriptPubKey);
+        assert.strictEqual(wasm_utxo_1.address.fromOutputScriptWithCoin(localScriptPubKey, 'btc'), (0, bitcoin_staking_1.buildLockAddress)({
+            stxAddress: 'SP000000000000000000002Q6VF78',
+            unlockHeight: definite.unlockHeight,
+            unlockBytes,
+            earlyUnlockBytes,
+            network: 'mainnet',
+            validateEarlyUnlockBytes: false,
+        }));
+    });
+    it('supports derivation and preserves wildcard keys until an index is selected', function () {
+        const value = params();
+        const descriptor = (0, pox5_1.createPox5LockupDescriptor)(value);
+        const wildcard = (0, pox5_1.parsePox5LockupDescriptor)(descriptor);
+        const derived = (0, pox5_1.parsePox5LockupDescriptor)(descriptor.atDerivationIndex(4));
+        assert.ok(wildcard);
+        assert.strictEqual(wildcard.stakerKeys, undefined);
+        assert.ok(wildcard.stakerKeyStrings.every((key) => key.endsWith('/*')));
+        assert.ok(derived?.stakerKeys);
+        assert.deepStrictEqual(derived?.stakerKeys, (0, pox5_1.derivePox5StakerKeys)(value.stakerKeys, 4));
+    });
+    it('rejects noncanonical parameter values and descriptor templates', function () {
+        assert.throws(() => (0, pox5_1.createPox5LockupDescriptor)(params({ unlockHeight: 0 })));
+        assert.throws(() => (0, pox5_1.createPox5LockupDescriptor)(params({ unlockHeight: 500000000 })));
+        assert.throws(() => (0, pox5_1.createPox5LockupDescriptor)(params({ stakerCommitment: Buffer.alloc(31) })));
+        assert.throws(() => (0, pox5_1.createPox5LockupDescriptor)(params({ earlyExitKey: Buffer.alloc(32) })));
+        assert.throws(() => (0, pox5_1.createPox5LockupDescriptor)(params({ stakerKeys: [getBip32Triple()[0], Buffer.alloc(33, 2), Buffer.alloc(33, 2)] })));
+        const validKey = params().earlyExitKey.toString('hex');
+        assert.strictEqual((0, pox5_1.parsePox5LockupDescriptor)(wasm_utxo_1.Descriptor.fromString(`wsh(pk(${validKey}))`, 'definite')), undefined);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"descriptor.js","sourceRoot":"","sources":["../../../../../test/unit/pox5/descriptor.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport { createHash } from 'crypto';\n\nimport {\n  buildLockAddress,\n  buildLockOutputScript,\n  buildLockScript,\n  buildUnlockScript,\n  computeRegisterPreimage,\n} from '@stacks/bitcoin-staking';\nimport { address, bip32, Descriptor } from '@bitgo/wasm-utxo';\nimport { getKeyTriple } from '@bitgo/wasm-utxo/testutils';\n\nimport {\n  createPox5LockupDescriptor,\n  createPox5LockupScriptPubKey,\n  derivePox5StakerKeys,\n  parsePox5LockupDescriptor,\n  Pox5LockupDescriptorParams,\n} from '../../../src/pox5';\n\ntype BIP32Interface = bip32.BIP32Interface;\n\nconst OPCODES: Record<string, number> = {\n  OP_0: 0x00,\n  OP_IF: 0x63,\n  OP_ELSE: 0x67,\n  OP_ENDIF: 0x68,\n  OP_VERIFY: 0x69,\n  OP_SIZE: 0x82,\n  OP_EQUAL: 0x87,\n  OP_EQUALVERIFY: 0x88,\n  OP_SHA256: 0xa8,\n  OP_CHECKSIG: 0xac,\n  OP_CHECKMULTISIG: 0xae,\n  OP_CLTV: 0xb1,\n};\n\nfunction getBip32Triple(): [BIP32Interface, BIP32Interface, BIP32Interface] {\n  const [user, backup, bitgo] = getKeyTriple('default');\n  return [user, backup, bitgo];\n}\n\nfunction sha256(value: Uint8Array): Buffer {\n  return createHash('sha256').update(value).digest();\n}\n\nfunction params(overrides: Partial<Pox5LockupDescriptorParams> = {}): Pox5LockupDescriptorParams {\n  const stakerKeys = getBip32Triple();\n  const earlyExitKey = Buffer.from(stakerKeys[0].derive(9).publicKey);\n  return {\n    unlockHeight: 840_000,\n    stakerCommitment: sha256(computeRegisterPreimage('SP000000000000000000002Q6VF78')),\n    earlyExitKey,\n    stakerKeys,\n    ...overrides,\n  };\n}\n\nfunction asmToScript(asm: string): Buffer {\n  const tokens = asm.split(' ');\n  const chunks: Buffer[] = [];\n  for (let index = 0; index < tokens.length; index++) {\n    const token = tokens[index];\n    const push = token.match(/^OP_PUSHBYTES_(\\d+)$/);\n    if (push) {\n      const bytes = Buffer.from(tokens[++index], 'hex');\n      assert.strictEqual(bytes.length, Number(push[1]));\n      chunks.push(Buffer.of(bytes.length), bytes);\n      continue;\n    }\n    const number = token.match(/^OP_PUSHNUM_(\\d+)$/);\n    if (number) {\n      chunks.push(Buffer.of(0x50 + Number(number[1])));\n      continue;\n    }\n    const opcode = OPCODES[token];\n    assert.notStrictEqual(opcode, undefined, `unsupported ASM token ${token}`);\n    chunks.push(Buffer.of(opcode));\n  }\n  return Buffer.concat(chunks);\n}\n\nfunction encodeTwoOfThreeUnlock(keys: [Buffer, Buffer, Buffer]): Buffer {\n  return Buffer.concat([Buffer.of(0x52), ...keys.flatMap((key) => [Buffer.of(33), key]), Buffer.of(0x53, 0xae)]);\n}\n\ndescribe('PoX-5 lockup descriptors', function () {\n  it('renders the required byte-identical canonical script and P2WSH output', function () {\n    const derivable = params();\n    const stakerKeys = derivePox5StakerKeys(\n      derivable.stakerKeys as [BIP32Interface, BIP32Interface, BIP32Interface],\n      0\n    );\n    const definite = { ...derivable, stakerKeys };\n    const descriptor = createPox5LockupDescriptor(definite);\n    const localWitnessScript = asmToScript(descriptor.toAsmString());\n    const unlockBytes = encodeTwoOfThreeUnlock(stakerKeys);\n    const earlyUnlockBytes = buildUnlockScript(definite.earlyExitKey);\n    const sdkWitnessScript = Buffer.from(\n      buildLockScript({\n        stxAddress: 'SP000000000000000000002Q6VF78',\n        unlockHeight: definite.unlockHeight,\n        unlockBytes,\n        earlyUnlockBytes,\n        validateEarlyUnlockBytes: false,\n      })\n    );\n\n    assert.deepStrictEqual(localWitnessScript, sdkWitnessScript);\n    assert.ok(descriptor.toAsmString().includes('OP_SHA256 OP_PUSHBYTES_32'));\n    assert.ok(descriptor.toAsmString().includes('OP_EQUALVERIFY OP_PUSHBYTES_33'));\n\n    const localScriptPubKey = createPox5LockupScriptPubKey(definite);\n    const sdkScriptPubKey = Buffer.from(\n      buildLockOutputScript({\n        stxAddress: 'SP000000000000000000002Q6VF78',\n        unlockHeight: definite.unlockHeight,\n        unlockBytes,\n        earlyUnlockBytes,\n      })\n    );\n    assert.deepStrictEqual(localScriptPubKey, sdkScriptPubKey);\n    assert.strictEqual(\n      address.fromOutputScriptWithCoin(localScriptPubKey, 'btc'),\n      buildLockAddress({\n        stxAddress: 'SP000000000000000000002Q6VF78',\n        unlockHeight: definite.unlockHeight,\n        unlockBytes,\n        earlyUnlockBytes,\n        network: 'mainnet',\n        validateEarlyUnlockBytes: false,\n      })\n    );\n  });\n\n  it('supports derivation and preserves wildcard keys until an index is selected', function () {\n    const value = params();\n    const descriptor = createPox5LockupDescriptor(value);\n    const wildcard = parsePox5LockupDescriptor(descriptor);\n    const derived = parsePox5LockupDescriptor(descriptor.atDerivationIndex(4));\n\n    assert.ok(wildcard);\n    assert.strictEqual(wildcard.stakerKeys, undefined);\n    assert.ok(wildcard.stakerKeyStrings.every((key) => key.endsWith('/*')));\n    assert.ok(derived?.stakerKeys);\n    assert.deepStrictEqual(\n      derived?.stakerKeys,\n      derivePox5StakerKeys(value.stakerKeys as [BIP32Interface, BIP32Interface, BIP32Interface], 4)\n    );\n  });\n\n  it('rejects noncanonical parameter values and descriptor templates', function () {\n    assert.throws(() => createPox5LockupDescriptor(params({ unlockHeight: 0 })));\n    assert.throws(() => createPox5LockupDescriptor(params({ unlockHeight: 500_000_000 })));\n    assert.throws(() => createPox5LockupDescriptor(params({ stakerCommitment: Buffer.alloc(31) })));\n    assert.throws(() => createPox5LockupDescriptor(params({ earlyExitKey: Buffer.alloc(32) })));\n    assert.throws(() =>\n      createPox5LockupDescriptor(\n        params({ stakerKeys: [getBip32Triple()[0], Buffer.alloc(33, 2), Buffer.alloc(33, 2)] })\n      )\n    );\n    const validKey = params().earlyExitKey.toString('hex');\n    assert.strictEqual(parsePox5LockupDescriptor(Descriptor.fromString(`wsh(pk(${validKey}))`, 'definite')), undefined);\n  });\n});\n"]}

package/dist/cjs/test/unit/pox5/input.d.ts

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

package/dist/cjs/test/unit/pox5/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../../../../test/unit/pox5/input.ts"],"names":[],"mappings":""}

package/dist/cjs/test/unit/pox5/input.js

@@ -0,0 +1,113 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const crypto_1 = require("crypto");
+const wasm_utxo_1 = require("@bitgo/wasm-utxo");
+const testutils_1 = require("@bitgo/wasm-utxo/testutils");
+const pox5_1 = require("../../../src/pox5");
+const UNLOCK_HEIGHT = 840000;
+function sha256(value) {
+    return (0, crypto_1.createHash)('sha256').update(value).digest();
+}
+function getParams() {
+    const stakerKeys = (0, testutils_1.getKeyTriple)('utxo-descriptors-pox5');
+    return {
+        unlockHeight: UNLOCK_HEIGHT,
+        stakerCommitment: sha256(Buffer.alloc(32, 0x42)),
+        earlyExitKey: Buffer.from(stakerKeys[0].derive(9).publicKey),
+        stakerKeys,
+    };
+}
+function createInputPsbt(descriptor) {
+    return wasm_utxo_1.descriptorWallet.createPsbt({ version: 2, locktime: 0 }, [
+        {
+            hash: '01'.repeat(32),
+            index: 0,
+            witnessUtxo: { script: descriptor.scriptPubkey(), value: 100000n },
+            descriptor,
+        },
+    ], []);
+}
+describe('PoX-5 input resolution', function () {
+    it('matches a definite descriptor without derivation metadata', function () {
+        const descriptor = (0, pox5_1.createPox5LockupDescriptor)({
+            ...getParams(),
+            stakerKeys: (0, pox5_1.derivePox5StakerKeys)(getParams().stakerKeys, 0),
+        });
+        const psbt = wasm_utxo_1.Psbt.create(2, 0);
+        psbt.addInput('01'.repeat(32), 0, 100000n, descriptor.scriptPubkey());
+        const match = (0, pox5_1.matchPox5Input)(psbt, 0, new Map([['lockup', descriptor]]));
+        assert.ok(match);
+        assert.strictEqual(match.index, undefined);
+        assert.strictEqual(match.descriptor.toString(), descriptor.toString());
+        assert.deepStrictEqual(match.info.stakerKeys, (0, pox5_1.derivePox5StakerKeys)(getParams().stakerKeys, 0));
+    });
+    it('matches a derived descriptor while ignoring foreign root derivations', function () {
+        const params = getParams();
+        const descriptor = (0, pox5_1.createPox5LockupDescriptor)(params);
+        const concreteDescriptor = descriptor.atDerivationIndex(4);
+        const psbt = createInputPsbt(concreteDescriptor);
+        const match = (0, pox5_1.matchPox5Input)(psbt, 0, new Map([['lockup', descriptor]]));
+        assert.ok(match);
+        assert.strictEqual(match.index, 4);
+        assert.strictEqual(match.descriptor.toString(), concreteDescriptor.toString());
+        assert.deepStrictEqual(match.info.stakerKeys, (0, pox5_1.derivePox5StakerKeys)(params.stakerKeys, 4));
+        assert.ok(psbt.getInputs()[0]?.bip32Derivation.some((derivation) => derivation.path === ''));
+    });
+    it('returns no match when the input has no usable derivation metadata', function () {
+        const params = getParams();
+        const descriptor = (0, pox5_1.createPox5LockupDescriptor)(params);
+        const concreteDescriptor = descriptor.atDerivationIndex(4);
+        const input = {
+            witnessUtxo: { script: concreteDescriptor.scriptPubkey(), value: 100000n },
+            bip32Derivation: [],
+            tapBip32Derivation: [],
+        };
+        assert.strictEqual((0, pox5_1.findPox5DescriptorForInput)(input, new Map([['lockup', descriptor]])), undefined);
+    });
+    it('returns no match for a noncanonical descriptor', function () {
+        const params = getParams();
+        const pox5Descriptor = (0, pox5_1.createPox5LockupDescriptor)(params);
+        const psbt = wasm_utxo_1.Psbt.create(2, 0);
+        psbt.addInput('01'.repeat(32), 0, 100000n, pox5Descriptor.atDerivationIndex(0).scriptPubkey());
+        const nonPox5Descriptor = (0, pox5_1.createPox5LockupDescriptor)({
+            ...params,
+            unlockHeight: UNLOCK_HEIGHT + 1,
+        }).atDerivationIndex(0);
+        assert.strictEqual((0, pox5_1.matchPox5Input)(psbt, 0, new Map([['other', nonPox5Descriptor]])), undefined);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input.js","sourceRoot":"","sources":["../../../../../test/unit/pox5/input.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport { createHash } from 'crypto';\n\nimport { bip32, descriptorWallet, Psbt } from '@bitgo/wasm-utxo';\nimport { getKeyTriple } from '@bitgo/wasm-utxo/testutils';\n\nimport {\n  createPox5LockupDescriptor,\n  derivePox5StakerKeys,\n  findPox5DescriptorForInput,\n  matchPox5Input,\n  Pox5LockupDescriptorParams,\n} from '../../../src/pox5';\n\nconst UNLOCK_HEIGHT = 840_000;\ntype BIP32Interface = bip32.BIP32Interface;\ntype Pox5Bip32Params = Omit<Pox5LockupDescriptorParams, 'stakerKeys'> & {\n  stakerKeys: [BIP32Interface, BIP32Interface, BIP32Interface];\n};\n\nfunction sha256(value: Uint8Array): Buffer {\n  return createHash('sha256').update(value).digest();\n}\n\nfunction getParams(): Pox5Bip32Params {\n  const stakerKeys = getKeyTriple('utxo-descriptors-pox5');\n  return {\n    unlockHeight: UNLOCK_HEIGHT,\n    stakerCommitment: sha256(Buffer.alloc(32, 0x42)),\n    earlyExitKey: Buffer.from(stakerKeys[0].derive(9).publicKey),\n    stakerKeys,\n  };\n}\n\nfunction createInputPsbt(descriptor: ReturnType<typeof createPox5LockupDescriptor>): Psbt {\n  return descriptorWallet.createPsbt(\n    { version: 2, locktime: 0 },\n    [\n      {\n        hash: '01'.repeat(32),\n        index: 0,\n        witnessUtxo: { script: descriptor.scriptPubkey(), value: 100_000n },\n        descriptor,\n      },\n    ],\n    []\n  );\n}\n\ndescribe('PoX-5 input resolution', function () {\n  it('matches a definite descriptor without derivation metadata', function () {\n    const descriptor = createPox5LockupDescriptor({\n      ...getParams(),\n      stakerKeys: derivePox5StakerKeys(getParams().stakerKeys, 0),\n    });\n    const psbt = Psbt.create(2, 0);\n    psbt.addInput('01'.repeat(32), 0, 100_000n, descriptor.scriptPubkey());\n    const match = matchPox5Input(psbt, 0, new Map([['lockup', descriptor]]));\n\n    assert.ok(match);\n    assert.strictEqual(match.index, undefined);\n    assert.strictEqual(match.descriptor.toString(), descriptor.toString());\n    assert.deepStrictEqual(match.info.stakerKeys, derivePox5StakerKeys(getParams().stakerKeys, 0));\n  });\n\n  it('matches a derived descriptor while ignoring foreign root derivations', function () {\n    const params = getParams();\n    const descriptor = createPox5LockupDescriptor(params);\n    const concreteDescriptor = descriptor.atDerivationIndex(4);\n    const psbt = createInputPsbt(concreteDescriptor);\n    const match = matchPox5Input(psbt, 0, new Map([['lockup', descriptor]]));\n\n    assert.ok(match);\n    assert.strictEqual(match.index, 4);\n    assert.strictEqual(match.descriptor.toString(), concreteDescriptor.toString());\n    assert.deepStrictEqual(match.info.stakerKeys, derivePox5StakerKeys(params.stakerKeys, 4));\n    assert.ok(psbt.getInputs()[0]?.bip32Derivation.some((derivation) => derivation.path === ''));\n  });\n\n  it('returns no match when the input has no usable derivation metadata', function () {\n    const params = getParams();\n    const descriptor = createPox5LockupDescriptor(params);\n    const concreteDescriptor = descriptor.atDerivationIndex(4);\n    const input = {\n      witnessUtxo: { script: concreteDescriptor.scriptPubkey(), value: 100_000n },\n      bip32Derivation: [],\n      tapBip32Derivation: [],\n    };\n\n    assert.strictEqual(findPox5DescriptorForInput(input, new Map([['lockup', descriptor]])), undefined);\n  });\n\n  it('returns no match for a noncanonical descriptor', function () {\n    const params = getParams();\n    const pox5Descriptor = createPox5LockupDescriptor(params);\n    const psbt = Psbt.create(2, 0);\n    psbt.addInput('01'.repeat(32), 0, 100_000n, pox5Descriptor.atDerivationIndex(0).scriptPubkey());\n    const nonPox5Descriptor = createPox5LockupDescriptor({\n      ...params,\n      unlockHeight: UNLOCK_HEIGHT + 1,\n    }).atDerivationIndex(0);\n\n    assert.strictEqual(matchPox5Input(psbt, 0, new Map([['other', nonPox5Descriptor]])), undefined);\n  });\n});\n"]}

package/dist/cjs/test/unit/pox5/validation.d.ts

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

package/dist/cjs/test/unit/pox5/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../../test/unit/pox5/validation.ts"],"names":[],"mappings":""}