@bitgo/wasm-utxo 1.30.0 → 1.32.0

package/dist/cjs/js/descriptorWallet/DescriptorMap.d.ts

@@ -0,0 +1,12 @@
+/**
+ * DescriptorMap type and utilities.
+ * Moved from @bitgo/utxo-core.
+ */
+import { Descriptor } from "../index.js";
+/** Map from descriptor name to descriptor (TypeScript Map) */
+export type DescriptorMap = Map<string, Descriptor>;
+/** Convert an array of descriptor name-value pairs to a descriptor map */
+export declare function toDescriptorMap(descriptors: {
+    name: string;
+    value: Descriptor | string;
+}[]): DescriptorMap;

package/dist/cjs/js/descriptorWallet/DescriptorMap.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDescriptorMap = toDescriptorMap;
+/**
+ * DescriptorMap type and utilities.
+ * Moved from @bitgo/utxo-core.
+ */
+const index_js_1 = require("../index.js");
+/** Convert an array of descriptor name-value pairs to a descriptor map */
+function toDescriptorMap(descriptors) {
+    return new Map(descriptors.map((d) => [
+        d.name,
+        d.value instanceof index_js_1.Descriptor ? d.value : index_js_1.Descriptor.fromStringDetectType(d.value),
+    ]));
+}

package/dist/cjs/js/descriptorWallet/DescriptorOutput.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Descriptor output types and utilities.
+ * Moved from @bitgo/utxo-core.
+ */
+import { Descriptor } from "../index.js";
+import { MaxOutput, Output, PrevOutput } from "./Output.js";
+import { DescriptorMap } from "./DescriptorMap.js";
+export type WithDescriptor<T> = T & {
+    descriptor: Descriptor;
+};
+export type WithOptDescriptor<T> = T & {
+    descriptor?: Descriptor;
+};
+export declare function isInternalOutput<T extends object>(output: T | WithDescriptor<T>): output is WithDescriptor<T>;
+export declare function isExternalOutput<T extends object>(output: T | WithDescriptor<T>): output is T;
+/**
+ * @return the sum of the external outputs that are not 'max'
+ * @param outputs
+ */
+export declare function getExternalFixedAmount(outputs: WithOptDescriptor<Output | MaxOutput>[]): bigint;
+export type DescriptorWalletOutput = PrevOutput & {
+    descriptorName: string;
+    descriptorIndex: number | undefined;
+};
+export type DerivedDescriptorWalletOutput = WithDescriptor<PrevOutput>;
+export declare function toDerivedDescriptorWalletOutput(output: DescriptorWalletOutput, descriptorMap: DescriptorMap): DerivedDescriptorWalletOutput;

package/dist/cjs/js/descriptorWallet/DescriptorOutput.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInternalOutput = isInternalOutput;
+exports.isExternalOutput = isExternalOutput;
+exports.getExternalFixedAmount = getExternalFixedAmount;
+exports.toDerivedDescriptorWalletOutput = toDerivedDescriptorWalletOutput;
+/**
+ * Descriptor output types and utilities.
+ * Moved from @bitgo/utxo-core.
+ */
+const index_js_1 = require("../index.js");
+const Output_js_1 = require("./Output.js");
+const derive_js_1 = require("./derive.js");
+function isInternalOutput(output) {
+    return "descriptor" in output && output.descriptor !== undefined;
+}
+function isExternalOutput(output) {
+    return !isInternalOutput(output);
+}
+/**
+ * @return the sum of the external outputs that are not 'max'
+ * @param outputs
+ */
+function getExternalFixedAmount(outputs) {
+    return (0, Output_js_1.getFixedOutputSum)(outputs.filter(isExternalOutput));
+}
+function toDerivedDescriptorWalletOutput(output, descriptorMap) {
+    const descriptor = descriptorMap.get(output.descriptorName);
+    if (!descriptor) {
+        throw new Error(`Descriptor not found: ${output.descriptorName}`);
+    }
+    if (!(descriptor instanceof index_js_1.Descriptor)) {
+        throw new Error(`Expected Descriptor instance for ${output.descriptorName}`);
+    }
+    const descriptorAtIndex = (0, derive_js_1.getDescriptorAtIndexCheckScript)(descriptor, output.descriptorIndex, output.witnessUtxo.script, output.descriptorName);
+    return {
+        hash: output.hash,
+        index: output.index,
+        witnessUtxo: output.witnessUtxo,
+        descriptor: descriptorAtIndex,
+    };
+}

package/dist/cjs/js/descriptorWallet/Output.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Output types and utilities for descriptor wallets.
+ * Moved from @bitgo/utxo-core.
+ */
+export type Output<TValue = bigint> = {
+    script: Uint8Array;
+    value: TValue;
+};
+export type MaxOutput = Output<"max">;
+type ValueBigInt = {
+    value: bigint;
+};
+type ValueMax = {
+    value: "max";
+};
+/**
+ * @return true if the output is a max output
+ */
+export declare function isMaxOutput<A extends ValueBigInt, B extends ValueMax>(output: A | B): output is B;
+/**
+ * @return the max output if there is one
+ * @throws if there are multiple max outputs
+ */
+export declare function getMaxOutput<A extends ValueBigInt, B extends ValueMax>(outputs: (A | B)[]): B | undefined;
+/**
+ * @return the sum of the outputs
+ */
+export declare function getOutputSum(outputs: ValueBigInt[]): bigint;
+/**
+ * @return the sum of the outputs that are not 'max'
+ */
+export declare function getFixedOutputSum(outputs: (ValueBigInt | ValueMax)[]): bigint;
+/**
+ * @param outputs
+ * @param params
+ * @return the outputs with the 'max' output replaced with the max amount
+ */
+export declare function toFixedOutputs<A extends ValueBigInt, B extends ValueMax>(outputs: (A | B)[], params: {
+    maxAmount: bigint;
+}): A[];
+export type PrevOutput = {
+    hash: string;
+    index: number;
+    witnessUtxo: Output;
+};
+export {};

package/dist/cjs/js/descriptorWallet/Output.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Output types and utilities for descriptor wallets.
+ * Moved from @bitgo/utxo-core.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMaxOutput = isMaxOutput;
+exports.getMaxOutput = getMaxOutput;
+exports.getOutputSum = getOutputSum;
+exports.getFixedOutputSum = getFixedOutputSum;
+exports.toFixedOutputs = toFixedOutputs;
+/**
+ * @return true if the output is a max output
+ */
+function isMaxOutput(output) {
+    return output.value === "max";
+}
+/**
+ * @return the max output if there is one
+ * @throws if there are multiple max outputs
+ */
+function getMaxOutput(outputs) {
+    const max = outputs.filter((isMaxOutput));
+    if (max.length === 0) {
+        return undefined;
+    }
+    if (max.length > 1) {
+        throw new Error("Multiple max outputs");
+    }
+    return max[0];
+}
+/**
+ * @return the sum of the outputs
+ */
+function getOutputSum(outputs) {
+    return outputs.reduce((sum, output) => sum + output.value, 0n);
+}
+/**
+ * @return the sum of the outputs that are not 'max'
+ */
+function getFixedOutputSum(outputs) {
+    return getOutputSum(outputs.filter((o) => !isMaxOutput(o)));
+}
+/**
+ * @param outputs
+ * @param params
+ * @return the outputs with the 'max' output replaced with the max amount
+ */
+function toFixedOutputs(outputs, params) {
+    // assert that there is at most one max output
+    const maxOutput = getMaxOutput(outputs);
+    return outputs.map((output) => {
+        if (isMaxOutput(output)) {
+            if (output !== maxOutput) {
+                throw new Error("illegal state");
+            }
+            return { ...output, value: params.maxAmount };
+        }
+        else {
+            return output;
+        }
+    });
+}

package/dist/cjs/js/descriptorWallet/VirtualSize.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Virtual size estimation for descriptor wallets.
+ * Moved from @bitgo/utxo-core.
+ */
+import { Descriptor, Psbt } from "../index.js";
+import { DescriptorMap } from "./DescriptorMap.js";
+export declare function getInputVSizesForDescriptors(descriptors: DescriptorMap): Record<string, number>;
+export declare function getChangeOutputVSizesForDescriptor(d: Descriptor): {
+    inputVSize: number;
+    outputVSize: number;
+};
+type InputWithDescriptorName = {
+    descriptorName: string;
+};
+type OutputWithScript = {
+    script: Uint8Array;
+};
+type Tx<TInput> = {
+    inputs: TInput[];
+    outputs: OutputWithScript[];
+};
+export declare function getVirtualSize(tx: Tx<Descriptor>): number;
+export declare function getVirtualSize(tx: Tx<InputWithDescriptorName>, descriptors: DescriptorMap): number;
+export declare function getVirtualSizeEstimateForPsbt(psbt: Psbt, descriptorMap: DescriptorMap): number;
+export {};

package/dist/cjs/js/descriptorWallet/VirtualSize.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInputVSizesForDescriptors = getInputVSizesForDescriptors;
+exports.getChangeOutputVSizesForDescriptor = getChangeOutputVSizesForDescriptor;
+exports.getVirtualSize = getVirtualSize;
+exports.getVirtualSizeEstimateForPsbt = getVirtualSizeEstimateForPsbt;
+/**
+ * Virtual size estimation for descriptor wallets.
+ * Moved from @bitgo/utxo-core.
+ */
+const index_js_1 = require("../index.js");
+const Dimensions_js_1 = require("../fixedScriptWallet/Dimensions.js");
+// Transaction overhead for segwit transactions
+// 4 (version) + 1 (marker) + 1 (flag) + 1 (input count) + 1 (output count) + 4 (locktime) = 12
+// Weight units: 4*10 + 2 = 42, vsize = ceil(42/4) = 10.5
+const TX_SEGWIT_OVERHEAD_VSIZE = 10.5;
+function getScriptPubKeyLength(descType) {
+    // See https://bitcoinops.org/en/tools/calc-size/
+    switch (descType) {
+        case "Wpkh":
+            // https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#p2wpkh
+            return 22;
+        case "Sh":
+        case "ShWsh":
+        case "ShWpkh":
+            // https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki#specification
+            return 23;
+        case "Pkh":
+            return 25;
+        case "Wsh":
+        case "Tr":
+            // P2WSH: https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#p2wsh
+            // P2TR: https://github.com/bitcoin/bips/blob/58ffd93812ff25e87d53d1f202fbb389fdfb85bb/bip-0341.mediawiki#script-validation-rules
+            // > A Taproot output is a native SegWit output (see BIP141) with version number 1, and a 32-byte witness program.
+            // 32 bytes for the hash, 1 byte for the version, 1 byte for the push opcode
+            return 34;
+        case "Bare":
+            throw new Error("cannot determine scriptPubKey length for Bare descriptor");
+        default:
+            throw new Error("unexpected descriptor type " + descType);
+    }
+}
+function getInputVSizeForDescriptor(descriptor) {
+    // FIXME(BTC-1489): this can overestimate the size of the input significantly
+    const maxWeight = descriptor.maxWeightToSatisfy();
+    const maxVSize = Math.ceil(maxWeight / 4);
+    const sizeOpPushdata1 = 1;
+    const sizeOpPushdata2 = 2;
+    return (
+    // inputId
+    32 +
+        // vOut
+        4 +
+        // nSequence
+        4 +
+        // script overhead
+        (maxVSize < 255 ? sizeOpPushdata1 : sizeOpPushdata2) +
+        // script
+        maxVSize);
+}
+function getInputVSizesForDescriptors(descriptors) {
+    return Object.fromEntries(Array.from(descriptors.entries()).map(([name, d]) => {
+        return [name, getInputVSizeForDescriptor(d)];
+    }));
+}
+function getChangeOutputVSizesForDescriptor(d) {
+    return {
+        inputVSize: getInputVSizeForDescriptor(d),
+        outputVSize: getScriptPubKeyLength(d.descType()),
+    };
+}
+function getVirtualSize(tx, descriptorMap) {
+    const lookup = descriptorMap ? getInputVSizesForDescriptors(descriptorMap) : undefined;
+    const inputVSize = tx.inputs.reduce((sum, input) => {
+        if (input instanceof index_js_1.Descriptor) {
+            return sum + getInputVSizeForDescriptor(input);
+        }
+        if ("descriptorName" in input) {
+            if (!lookup) {
+                throw new Error("missing descriptorMap");
+            }
+            const vsize = lookup[input.descriptorName];
+            if (!vsize) {
+                throw new Error(`Could not find descriptor ${input.descriptorName}`);
+            }
+            return sum + vsize;
+        }
+        throw new Error("unexpected input");
+    }, 0);
+    const outputVSize = tx.outputs.reduce((sum, o) => {
+        // Use the Dimensions class to calculate output vsize
+        return sum + Dimensions_js_1.Dimensions.fromOutput({ length: o.script.length }).getOutputVSize();
+    }, 0);
+    // we will just assume that we have at least one segwit input
+    return inputVSize + outputVSize + TX_SEGWIT_OVERHEAD_VSIZE;
+}
+function getVirtualSizeEstimateForPsbt(psbt, descriptorMap) {
+    const inputCount = psbt.inputCount();
+    const outputCount = psbt.outputCount();
+    // Calculate a rough estimate based on descriptor map
+    // For a more accurate estimation, we would need to deserialize the PSBT data
+    let totalInputVSize = 0;
+    for (const descriptor of descriptorMap.values()) {
+        totalInputVSize += getInputVSizeForDescriptor(descriptor);
+    }
+    // Average input size * input count
+    const avgInputVSize = descriptorMap.size > 0 ? totalInputVSize / descriptorMap.size : 100; // fallback
+    const inputVSize = avgInputVSize * inputCount;
+    // Assume P2WPKH outputs (34 bytes each) as a reasonable default
+    const outputVSize = outputCount * Dimensions_js_1.Dimensions.fromOutput({ length: 34 }).getOutputVSize();
+    return inputVSize + outputVSize + TX_SEGWIT_OVERHEAD_VSIZE;
+}

package/dist/cjs/js/descriptorWallet/address.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Descriptor address generation utilities.
+ * Moved from @bitgo/utxo-core.
+ */
+import { Descriptor } from "../index.js";
+import type { CoinName } from "../coinName.js";
+export declare function createScriptPubKeyFromDescriptor(descriptor: Descriptor, index: number | undefined): Uint8Array;
+export declare function createAddressFromDescriptor(descriptor: Descriptor, index: number | undefined, coin: CoinName): string;

package/dist/cjs/js/descriptorWallet/address.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScriptPubKeyFromDescriptor = createScriptPubKeyFromDescriptor;
+exports.createAddressFromDescriptor = createAddressFromDescriptor;
+const address_js_1 = require("../address.js");
+function createScriptPubKeyFromDescriptor(descriptor, index) {
+    if (index === undefined) {
+        return descriptor.scriptPubkey();
+    }
+    return createScriptPubKeyFromDescriptor(descriptor.atDerivationIndex(index), undefined);
+}
+function createAddressFromDescriptor(descriptor, index, coin) {
+    return (0, address_js_1.fromOutputScriptWithCoin)(createScriptPubKeyFromDescriptor(descriptor, index), coin);
+}

package/dist/cjs/js/descriptorWallet/derive.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Descriptor derivation utilities.
+ * Moved from @bitgo/utxo-core.
+ */
+import { Descriptor } from "../index.js";
+/**
+ * Get a descriptor at a specific derivation index.
+ * For wildcard descriptors (containing '*'), the index is required and used for derivation.
+ * For definite descriptors (not containing '*'), no index should be provided.
+ * @param descriptor - The descriptor to derive from
+ * @param index - The derivation index for wildcard descriptors
+ * @returns A new descriptor at the specified index for wildcard descriptors, or the original descriptor for definite ones
+ * @throws {Error} If index is undefined for a wildcard descriptor or if index is provided for a definite descriptor
+ */
+export declare function getDescriptorAtIndex(descriptor: Descriptor, index: number | undefined): Descriptor;
+export declare function getDescriptorAtIndexCheckScript(descriptor: Descriptor, index: number | undefined, script: Uint8Array, descriptorString?: string): Descriptor;

package/dist/cjs/js/descriptorWallet/derive.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDescriptorAtIndex = getDescriptorAtIndex;
+exports.getDescriptorAtIndexCheckScript = getDescriptorAtIndexCheckScript;
+/**
+ * Descriptor derivation utilities.
+ * Moved from @bitgo/utxo-core.
+ */
+const index_js_1 = require("../index.js");
+/**
+ * Get a descriptor at a specific derivation index.
+ * For wildcard descriptors (containing '*'), the index is required and used for derivation.
+ * For definite descriptors (not containing '*'), no index should be provided.
+ * @param descriptor - The descriptor to derive from
+ * @param index - The derivation index for wildcard descriptors
+ * @returns A new descriptor at the specified index for wildcard descriptors, or the original descriptor for definite ones
+ * @throws {Error} If index is undefined for a wildcard descriptor or if index is provided for a definite descriptor
+ */
+function getDescriptorAtIndex(descriptor, index) {
+    if (!(descriptor instanceof index_js_1.Descriptor)) {
+        throw new Error("Expected Descriptor instance");
+    }
+    index_js_1.Descriptor.fromString(descriptor.toString(), "derivable");
+    descriptor = index_js_1.Descriptor.fromStringDetectType(descriptor.toString());
+    if (descriptor.hasWildcard()) {
+        if (index === undefined) {
+            throw new Error("Derivable descriptor requires an index");
+        }
+        return descriptor.atDerivationIndex(index);
+    }
+    else {
+        if (index !== undefined) {
+            throw new Error("Definite descriptor cannot be derived with index");
+        }
+        return descriptor;
+    }
+}
+function getDescriptorAtIndexCheckScript(descriptor, index, script, descriptorString = descriptor.toString()) {
+    if (!(descriptor instanceof index_js_1.Descriptor)) {
+        throw new Error("Expected Descriptor instance");
+    }
+    const descriptorAtIndex = getDescriptorAtIndex(descriptor, index);
+    const expectedScript = descriptorAtIndex.scriptPubkey();
+    if (script.length !== expectedScript.length || !script.every((b, i) => b === expectedScript[i])) {
+        throw new Error(`Script mismatch: descriptor ${descriptorString}`);
+    }
+    return descriptorAtIndex;
+}

package/dist/cjs/js/descriptorWallet/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Descriptor wallet utilities.
+ * Moved from @bitgo/utxo-core.
+ *
+ * This module provides descriptor wallet functionality using wasm-utxo directly,
+ * eliminating the need for utxo-lib in descriptor wallet code paths.
+ *
+ * ## Migration from utxo-core
+ *
+ * If you were previously importing from `@bitgo/utxo-core/descriptor`, you should
+ * now import from `@bitgo/wasm-utxo`:
+ *
+ * ```typescript
+ * // Before (deprecated)
+ * import { DescriptorMap, createPsbt } from '@bitgo/utxo-core/descriptor';
+ *
+ * // After
+ * import { descriptorWallet } from '@bitgo/wasm-utxo';
+ * const { DescriptorMap, createPsbt } = descriptorWallet;
+ * ```
+ *
+ * @see {@link ./MIGRATION.md} for detailed migration instructions.
+ *
+ * @remarks
+ * The following imports from `@bitgo/utxo-core/descriptor` are now deprecated
+ * and should use this module instead:
+ * - DescriptorMap, toDescriptorMap
+ * - createPsbt, parse, findDescriptorForInput, findDescriptorForOutput
+ * - getDescriptorAtIndex, getDescriptorAtIndexCheckScript
+ * - createScriptPubKeyFromDescriptor, createAddressFromDescriptor
+ * - getVirtualSize, getVirtualSizeEstimateForPsbt
+ * - signWithKey, getNewSignatureCount
+ * - assertSatisfiable, getRequiredLocktime
+ * - PatternMatcher
+ */
+export * from "./Output.js";
+export * from "./DescriptorMap.js";
+export * from "./derive.js";
+export * from "./DescriptorOutput.js";
+export * from "./address.js";
+export * from "./VirtualSize.js";
+export * from "./psbt/index.js";
+export * from "./parse/PatternMatcher.js";

package/dist/cjs/js/descriptorWallet/index.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Descriptor wallet utilities.
+ * Moved from @bitgo/utxo-core.
+ *
+ * This module provides descriptor wallet functionality using wasm-utxo directly,
+ * eliminating the need for utxo-lib in descriptor wallet code paths.
+ *
+ * ## Migration from utxo-core
+ *
+ * If you were previously importing from `@bitgo/utxo-core/descriptor`, you should
+ * now import from `@bitgo/wasm-utxo`:
+ *
+ * ```typescript
+ * // Before (deprecated)
+ * import { DescriptorMap, createPsbt } from '@bitgo/utxo-core/descriptor';
+ *
+ * // After
+ * import { descriptorWallet } from '@bitgo/wasm-utxo';
+ * const { DescriptorMap, createPsbt } = descriptorWallet;
+ * ```
+ *
+ * @see {@link ./MIGRATION.md} for detailed migration instructions.
+ *
+ * @remarks
+ * The following imports from `@bitgo/utxo-core/descriptor` are now deprecated
+ * and should use this module instead:
+ * - DescriptorMap, toDescriptorMap
+ * - createPsbt, parse, findDescriptorForInput, findDescriptorForOutput
+ * - getDescriptorAtIndex, getDescriptorAtIndexCheckScript
+ * - createScriptPubKeyFromDescriptor, createAddressFromDescriptor
+ * - getVirtualSize, getVirtualSizeEstimateForPsbt
+ * - signWithKey, getNewSignatureCount
+ * - assertSatisfiable, getRequiredLocktime
+ * - PatternMatcher
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Core types and utilities
+__exportStar(require("./Output.js"), exports);
+__exportStar(require("./DescriptorMap.js"), exports);
+__exportStar(require("./derive.js"), exports);
+__exportStar(require("./DescriptorOutput.js"), exports);
+__exportStar(require("./address.js"), exports);
+__exportStar(require("./VirtualSize.js"), exports);
+// PSBT utilities
+__exportStar(require("./psbt/index.js"), exports);
+// Pattern matching
+__exportStar(require("./parse/PatternMatcher.js"), exports);

package/dist/cjs/js/descriptorWallet/parse/PatternMatcher.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Pattern matching utilities for descriptor ASTs.
+ * Moved from @bitgo/utxo-core.
+ */
+export type PatternVar = {
+    $var: string;
+};
+export type Pattern = PatternVar | string | number | {
+    [key: string]: Pattern | Pattern[];
+} | Pattern[];
+export type ExtractedVars = Record<string, unknown>;
+export declare class PatternMatcher {
+    match(node: unknown, pattern: Pattern): ExtractedVars | null;
+    private matchNode;
+    private isPatternVar;
+    private deepEqual;
+}

package/dist/cjs/js/descriptorWallet/parse/PatternMatcher.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Pattern matching utilities for descriptor ASTs.
+ * Moved from @bitgo/utxo-core.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternMatcher = void 0;
+class PatternMatcher {
+    match(node, pattern) {
+        const vars = {};
+        return this.matchNode(node, pattern, vars) ? vars : null;
+    }
+    matchNode(node, pattern, vars) {
+        // Variable placeholder
+        if (this.isPatternVar(pattern)) {
+            const varName = pattern.$var;
+            if (varName in vars) {
+                return this.deepEqual(vars[varName], node);
+            }
+            vars[varName] = node;
+            return true;
+        }
+        // Primitive values
+        if (typeof node !== typeof pattern)
+            return false;
+        if (typeof node === "string" || typeof node === "number") {
+            return node === pattern;
+        }
+        // Arrays
+        if (Array.isArray(node) && Array.isArray(pattern)) {
+            return (node.length === pattern.length &&
+                node.every((item, i) => this.matchNode(item, pattern[i], vars)));
+        }
+        // Objects
+        if (typeof node === "object" &&
+            typeof pattern === "object" &&
+            node !== null &&
+            pattern !== null) {
+            const nodeKeys = Object.keys(node);
+            const patternKeys = Object.keys(pattern);
+            return (nodeKeys.length === patternKeys.length &&
+                nodeKeys.every((key) => patternKeys.includes(key) &&
+                    this.matchNode(node[key], pattern[key], vars)));
+        }
+        return false;
+    }
+    isPatternVar(value) {
+        return value !== null && typeof value === "object" && "$var" in value;
+    }
+    deepEqual(a, b) {
+        if (a === b)
+            return true;
+        if (typeof a !== typeof b)
+            return false;
+        if (Array.isArray(a) && Array.isArray(b)) {
+            return a.length === b.length && a.every((item, i) => this.deepEqual(item, b[i]));
+        }
+        if (typeof a === "object" && a !== null && typeof b === "object" && b !== null) {
+            const keysA = Object.keys(a);
+            const keysB = Object.keys(b);
+            return (keysA.length === keysB.length &&
+                keysA.every((key) => this.deepEqual(a[key], b[key])));
+        }
+        return false;
+    }
+}
+exports.PatternMatcher = PatternMatcher;

package/dist/cjs/js/descriptorWallet/psbt/assertSatisfiable.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Helpers for testing satisfiability of descriptors in PSBTs.
+ *
+ * They are mostly a debugging aid - if an input cannot be satisified, the `finalizePsbt()` method will fail, but
+ * the error message is pretty vague.
+ *
+ * The methods here have the goal of catching certain cases earlier and with a better error message.
+ *
+ * The goal is not an exhaustive check, but to catch common mistakes.
+ *
+ * Moved from @bitgo/utxo-core.
+ */
+import { Descriptor, Psbt } from "../../index.js";
+export declare const FINAL_SEQUENCE = 4294967295;
+/**
+ * Get the required locktime for a descriptor.
+ * @param descriptor
+ */
+export declare function getRequiredLocktime(descriptor: unknown): number | undefined;
+export declare function assertSatisfiable(psbt: Psbt, _inputIndex: number, descriptor: Descriptor): void;