@bitgo-beta/utxo-descriptors 0.0.1-beta.21 → 0.0.1-beta.211

package/dist/esm/sbtc/parseDescriptor.d.ts

@@ -0,0 +1,55 @@
+import { Descriptor, ast } from '@bitgo/wasm-utxo';
+/**
+ * Parsed components of an sBTC peg-in deposit descriptor.
+ *
+ * The parser returns both the high-level
+ * fields callers usually need (keys, lockTime, fee, recipient) and the raw
+ * miniscript AST nodes so the leaves can be re-compiled into a
+ * `Miniscript` via `ast.formatNode` + `Miniscript.fromString`.
+ */
+export type ParsedSbtcDepositDescriptor = {
+    /** 32-byte x-only signers aggregate key from the deposit leaf. */
+    signersAggregateKey: Buffer;
+    /** Max signer fee parsed from the first 8 bytes of the payload_drop value. */
+    maxFee: bigint;
+    /** 22-byte Stacks recipient parsed from the trailing bytes of the payload. */
+    stacksRecipient: Buffer;
+    /** Reclaim-leaf relative timelock (number of Bitcoin blocks, OP_CSV argument). */
+    lockTime: number;
+    /**
+     * The three concrete x-only reclaim keys from the reclaim-leaf `multi_a`,
+     * in the order they appear inside the leaf (descriptor library sorts by hex).
+     * Only present when the descriptor is in its derived/definite form — for
+     * derivable descriptors the multi_a entries are xpub strings (e.g.
+     * `xpub.../*`), which can't be turned into 32-byte buffers without picking
+     * a derivation index. Callers that need raw key bytes MUST pass the
+     * derived descriptor (see `deriveReclaimKeys` for derivable inputs).
+     */
+    reclaimKeys: [Buffer, Buffer, Buffer] | undefined;
+    /** Raw miniscript AST for the deposit leaf (first tap-tree leaf). */
+    depositMiniscriptNode: ast.MiniscriptNode;
+    /** Raw miniscript AST for the reclaim leaf (second tap-tree leaf). */
+    reclaimMiniscriptNode: ast.MiniscriptNode;
+    /**
+     * The three raw `multi_a` key entries from the reclaim leaf, exactly as
+     * they appear in the descriptor — `xpub.../*` for derivable descriptors and
+     * 64-hex-char x-only keys for definite descriptors. Useful for callers that
+     * need the original xpub form (e.g. to round-trip back to a descriptor
+     * builder) and don't want the resolved `reclaimKeys` buffers.
+     */
+    reclaimKeyStrings: [string, string, string];
+};
+/**
+ * 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`
+ */
+export declare function parseSbtcDepositDescriptor(descriptor: Descriptor | ast.DescriptorNode): ParsedSbtcDepositDescriptor | null;
+//# sourceMappingURL=parseDescriptor.d.ts.map

package/dist/esm/sbtc/parseDescriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseDescriptor.d.ts","sourceRoot":"","sources":["../../../src/sbtc/parseDescriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,UAAU,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAK1D;;;;;;;GAOG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC,kEAAkE;IAClE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,eAAe,EAAE,MAAM,CAAC;IACxB,kFAAkF;IAClF,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;;OAQG;IACH,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAClD,qEAAqE;IACrE,qBAAqB,EAAE,GAAG,CAAC,cAAc,CAAC;IAC1C,sEAAsE;IACtE,qBAAqB,EAAE,GAAG,CAAC,cAAc,CAAC;IAC1C;;;;;;OAMG;IACH,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7C,CAAC;AAwJF;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,UAAU,GAAG,GAAG,CAAC,cAAc,GAC1C,2BAA2B,GAAG,IAAI,CA8CpC"}

package/dist/esm/sbtc/parseDescriptor.js

@@ -0,0 +1,182 @@
+import { BIP32, Descriptor, ast } from '@bitgo/wasm-utxo';
+import { PatternMatcher } from '@bitgo-beta/utxo-core/descriptor';
+import { MAX_FEE_BYTE_LENGTH, STACKS_RECIPIENT_BYTE_LENGTH, UNSPENDABLE_INTERNAL_KEY } from './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 = MAX_FEE_BYTE_LENGTH + 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(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 = 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`
+ */
+export function parseSbtcDepositDescriptor(descriptor) {
+    const pattern = {
+        tr: [UNSPENDABLE_INTERNAL_KEY, [{ $var: 'depositLeaf' }, { $var: 'reclaimLeaf' }]],
+    };
+    const matcher = new PatternMatcher();
+    const descriptorNode = descriptor instanceof Descriptor ? 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":"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","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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitgo-beta/utxo-descriptors",
-  "version": "0.0.1-beta.21",
+  "version": "0.0.1-beta.211",
   "description": "BitGo SDK for building UTXO descriptors",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/index.js",
@@ -59,8 +59,8 @@
     ]
   },
   "dependencies": {
-    "@bitgo-beta/utxo-core": "1.8.1-beta.883",
-    "@bitgo/wasm-utxo": "^4.11.0"
+    "@bitgo-beta/utxo-core": "1.8.1-beta.1078",
+    "@bitgo/wasm-utxo": "^4.27.0"
   },
-  "gitHead": "a63eded1d5855ca7d3b074ef1ffdaa441cac8d31"
+  "gitHead": "8cab40f61d0969c828bf8cbc7badcb7714995e9a"
 }