@bitgo/wasm-utxo 0.0.1 → 1.0.0

package/dist/browser/js/wasm/wasm_utxo_bg.wasm.d.ts

@@ -0,0 +1,53 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_addressnamespace_free: (a: number, b: number) => void;
+export const __wbg_utxolibcompatnamespace_free: (a: number, b: number) => void;
+export const __wbg_wrapdescriptor_free: (a: number, b: number) => void;
+export const __wbg_wrapminiscript_free: (a: number, b: number) => void;
+export const addressnamespace_from_output_script_with_coin: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const addressnamespace_to_output_script_with_coin: (a: number, b: number, c: number, d: number, e: number) => void;
+export const utxolibcompatnamespace_from_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const utxolibcompatnamespace_to_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const wrapdescriptor_atDerivationIndex: (a: number, b: number, c: number) => void;
+export const wrapdescriptor_descType: (a: number, b: number) => void;
+export const wrapdescriptor_encode: (a: number, b: number) => void;
+export const wrapdescriptor_fromString: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wrapdescriptor_fromStringDetectType: (a: number, b: number, c: number) => void;
+export const wrapdescriptor_hasWildcard: (a: number) => number;
+export const wrapdescriptor_maxWeightToSatisfy: (a: number, b: number) => void;
+export const wrapdescriptor_node: (a: number, b: number) => void;
+export const wrapdescriptor_scriptPubkey: (a: number, b: number) => void;
+export const wrapdescriptor_toAsmString: (a: number, b: number) => void;
+export const wrapdescriptor_toString: (a: number, b: number) => void;
+export const wrapminiscript_encode: (a: number, b: number) => void;
+export const wrapminiscript_fromBitcoinScript: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wrapminiscript_fromString: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wrapminiscript_node: (a: number, b: number) => void;
+export const wrapminiscript_toAsmString: (a: number, b: number) => void;
+export const wrapminiscript_toString: (a: number, b: number) => void;
+export const __wbg_bitgopsbt_free: (a: number, b: number) => void;
+export const __wbg_fixedscriptwalletnamespace_free: (a: number, b: number) => void;
+export const __wbg_wrappsbt_free: (a: number, b: number) => void;
+export const bitgopsbt_from_bytes: (a: number, b: number, c: number, d: number, e: number) => void;
+export const bitgopsbt_parse_outputs_with_wallet_keys: (a: number, b: number, c: number) => void;
+export const bitgopsbt_parse_transaction_with_wallet_keys: (a: number, b: number, c: number, d: number) => void;
+export const fixedscriptwalletnamespace_address: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const fixedscriptwalletnamespace_output_script: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wrappsbt_clone: (a: number) => number;
+export const wrappsbt_deserialize: (a: number, b: number, c: number) => void;
+export const wrappsbt_finalize: (a: number, b: number) => void;
+export const wrappsbt_serialize: (a: number, b: number) => void;
+export const wrappsbt_signWithPrv: (a: number, b: number, c: number, d: number) => void;
+export const wrappsbt_signWithXprv: (a: number, b: number, c: number, d: number) => void;
+export const wrappsbt_updateInputWithDescriptor: (a: number, b: number, c: number, d: number) => void;
+export const wrappsbt_updateOutputWithDescriptor: (a: number, b: number, c: number, d: number) => void;
+export const rustsecp256k1_v0_10_0_context_create: (a: number) => number;
+export const rustsecp256k1_v0_10_0_context_destroy: (a: number) => void;
+export const rustsecp256k1_v0_10_0_default_error_callback_fn: (a: number, b: number) => void;
+export const rustsecp256k1_v0_10_0_default_illegal_callback_fn: (a: number, b: number) => void;
+export const __wbindgen_export_0: (a: number) => void;
+export const __wbindgen_export_1: (a: number, b: number) => number;
+export const __wbindgen_export_2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export_3: (a: number, b: number, c: number) => void;

package/dist/node/js/address.d.ts

@@ -0,0 +1,8 @@
+import type { CoinName } from "./coinName";
+/**
+ * Most coins only have one unambiguous address format (base58check and bech32/bech32m)
+ * For Bitcoin Cash and eCash, we can select between base58check and cashaddr.
+ */
+export type AddressFormat = "default" | "cashaddr";
+export declare function toOutputScriptWithCoin(address: string, coin: CoinName): Uint8Array;
+export declare function fromOutputScriptWithCoin(script: Uint8Array, coin: CoinName, format?: AddressFormat): string;

package/dist/node/js/address.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOutputScriptWithCoin = toOutputScriptWithCoin;
+exports.fromOutputScriptWithCoin = fromOutputScriptWithCoin;
+const wasm_utxo_1 = require("./wasm/wasm_utxo");
+function toOutputScriptWithCoin(address, coin) {
+    return wasm_utxo_1.AddressNamespace.to_output_script_with_coin(address, coin);
+}
+function fromOutputScriptWithCoin(script, coin, format) {
+    return wasm_utxo_1.AddressNamespace.from_output_script_with_coin(script, coin, format);
+}

package/dist/node/js/ast/formatNode.d.ts

@@ -0,0 +1,88 @@
+type Key = string;
+type Identities = "a" | "s" | "c" | "t" | "d" | "v" | "j" | "n" | "l" | "u" | "r";
+type PrefixWith<T, P extends string> = {
+    [K in keyof T & string as `${P}:${K}`]: T[K];
+};
+type PrefixIdUnion<T> = {
+    [P in Identities]: PrefixWith<T, P>;
+}[Identities];
+type Wrap<T> = T | PrefixIdUnion<T>;
+type Miniscript = Wrap<{
+    pk: Key;
+}> | Wrap<{
+    pkh: Key;
+}> | Wrap<{
+    wpkh: Key;
+}> | Wrap<{
+    multi: [number, ...Key[]];
+}> | Wrap<{
+    sortedmulti: [number, ...Key[]];
+}> | Wrap<{
+    multi_a: [number, ...Key[]];
+}> | Wrap<{
+    sortedmulti_a: [number, ...Key[]];
+}> | Wrap<{
+    tr: Key | [Key, Miniscript];
+}> | Wrap<{
+    sh: Miniscript;
+}> | Wrap<{
+    wsh: Miniscript;
+}> | Wrap<{
+    and_v: [Miniscript, Miniscript];
+}> | Wrap<{
+    and_b: [Miniscript, Miniscript];
+}> | Wrap<{
+    andor: [Miniscript, Miniscript, Miniscript];
+}> | Wrap<{
+    or_b: [Miniscript, Miniscript];
+}> | Wrap<{
+    or_c: [Miniscript, Miniscript];
+}> | Wrap<{
+    or_d: [Miniscript, Miniscript];
+}> | Wrap<{
+    or_i: [Miniscript, Miniscript];
+}> | Wrap<{
+    thresh: [number, ...Miniscript[]];
+}> | Wrap<{
+    sha256: string;
+}> | Wrap<{
+    ripemd160: string;
+}> | Wrap<{
+    hash256: string;
+}> | Wrap<{
+    hash160: string;
+}> | Wrap<{
+    older: number;
+}> | Wrap<{
+    after: number;
+}>;
+type TapTree = [TapTree, TapTree] | Miniscript;
+type Descriptor = {
+    sh: Miniscript | {
+        wsh: Miniscript;
+    };
+} | {
+    wsh: Miniscript;
+} | {
+    pk: Key;
+} | {
+    pkh: Key;
+} | {
+    wpkh: Key;
+} | {
+    combo: Key;
+} | {
+    tr: [Key, TapTree];
+} | {
+    addr: string;
+} | {
+    raw: string;
+} | {
+    rawtr: string;
+};
+export type TapTreeNode = TapTree;
+export type MiniscriptNode = Miniscript;
+export type DescriptorNode = Descriptor;
+/** Format a Miniscript or Descriptor node as a descriptor string (without checksum) */
+export declare function formatNode(n: MiniscriptNode | DescriptorNode): string;
+export {};

package/dist/node/js/ast/formatNode.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatNode = formatNode;
+/**
+ * Format a TapTree as a string
+ * If the argument is an array, descend recursively with formatTr and wrap result in curly braces
+ * Otherwise, format the node with formatN
+ */
+function formatTr(tree) {
+    return Array.isArray(tree) ? `{` + tree.map(formatTr).join(",") + `}` : formatN(tree);
+}
+function formatN(n) {
+    if (typeof n === "string") {
+        return n;
+    }
+    if (typeof n === "number") {
+        return String(n);
+    }
+    if (Array.isArray(n)) {
+        return n.map(formatN).join(",");
+    }
+    if (n && typeof n === "object") {
+        const entries = Object.entries(n);
+        if (entries.length !== 1) {
+            throw new Error(`Invalid node: ${n}`);
+        }
+        const [name, value] = entries[0];
+        if (name === "tr" && Array.isArray(value)) {
+            const [key, tree] = value;
+            return formatN({ tr: formatN([key, formatTr(tree)]) });
+        }
+        return `${name}(${formatN(value)})`;
+    }
+    throw new Error(`Invalid node: ${n}`);
+}
+/** Format a Miniscript or Descriptor node as a descriptor string (without checksum) */
+function formatNode(n) {
+    return formatN(n);
+}

package/dist/node/js/ast/fromWasmNode.d.ts

@@ -0,0 +1,4 @@
+import { DescriptorNode, MiniscriptNode } from "./formatNode";
+import { Descriptor, Miniscript } from "../index";
+export declare function fromDescriptor(d: Descriptor): DescriptorNode;
+export declare function fromMiniscript(m: Miniscript): MiniscriptNode;

package/dist/node/js/ast/fromWasmNode.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromDescriptor = fromDescriptor;
+exports.fromMiniscript = fromMiniscript;
+function getSingleEntry(v) {
+    if (typeof v === "object" && v) {
+        const entries = Object.entries(v);
+        if (entries.length === 1) {
+            return entries[0];
+        }
+    }
+    throw new Error("Expected single entry object");
+}
+function node(type, value) {
+    return { [type]: fromUnknown(value) };
+}
+function wrap(type, value) {
+    const n = fromWasmNode(value);
+    const [name, inner] = getSingleEntry(n);
+    return { [`${type}:${name}`]: inner };
+}
+function fromUnknown(v) {
+    if (typeof v === "number" || typeof v === "string") {
+        return v;
+    }
+    if (Array.isArray(v)) {
+        return v.map(fromUnknown);
+    }
+    if (typeof v === "object" && v) {
+        const [type, value] = getSingleEntry(v);
+        switch (type) {
+            case "Bare":
+            case "Single":
+            case "Ms":
+            case "XPub":
+            case "relLockTime":
+            case "absLockTime":
+                return fromUnknown(value);
+            case "Sh":
+            case "Wsh":
+            case "Tr":
+            case "Pk":
+            case "Pkh":
+            case "PkH":
+            case "Wpkh":
+            case "Combo":
+            case "SortedMulti":
+            case "Addr":
+            case "Raw":
+            case "RawTr":
+            case "After":
+            case "Older":
+            case "Sha256":
+            case "Hash256":
+            case "Ripemd160":
+            case "Hash160":
+                return node(type.toLocaleLowerCase(), value);
+            case "PkK":
+                return node("pk", value);
+            case "RawPkH":
+                return node("raw_pkh", value);
+            // Wrappers
+            case "Alt":
+                return wrap("a", value);
+            case "Swap":
+                return wrap("s", value);
+            case "Check":
+                return fromUnknown(value);
+            case "DupIf":
+                return wrap("d", value);
+            case "Verify":
+                return wrap("v", value);
+            case "ZeroNotEqual":
+                return wrap("n", value);
+            case "Drop":
+                return wrap("r", value);
+            // Conjunctions
+            case "AndV":
+                return node("and_v", value);
+            case "AndB":
+                return node("and_b", value);
+            case "AndOr":
+                if (!Array.isArray(value)) {
+                    throw new Error(`Invalid AndOr node: ${JSON.stringify(value)}`);
+                }
+                const [cond, success, failure] = value;
+                if (failure === false) {
+                    return node("and_n", [cond, success]);
+                }
+                return node("andor", [cond, success, failure]);
+            // Disjunctions
+            case "OrB":
+                return node("or_b", value);
+            case "OrD":
+                return node("or_d", value);
+            case "OrC":
+                return node("or_c", value);
+            case "OrI":
+                return node("or_i", value);
+            // Thresholds
+            case "Thresh":
+                return node("thresh", value);
+            case "Multi":
+                return node("multi", value);
+            case "MultiA":
+                return node("multi_a", value);
+            case "Tree":
+                if (!Array.isArray(value) || value.length !== 2) {
+                    throw new Error(`Invalid Tree node: ${JSON.stringify(value)}`);
+                }
+                return [fromUnknown(value[0]), fromUnknown(value[1])];
+        }
+    }
+    throw new Error(`Unknown node ${JSON.stringify(v)}`);
+}
+function fromWasmNode(v) {
+    return fromUnknown(v);
+}
+function fromDescriptor(d) {
+    return fromWasmNode(d.node());
+}
+function fromMiniscript(m) {
+    return fromWasmNode(m.node());
+}

package/dist/node/js/ast/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./formatNode";
+export * from "./fromWasmNode";

package/dist/node/js/ast/index.js

@@ -0,0 +1,18 @@
+"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 __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 });
+__exportStar(require("./formatNode"), exports);
+__exportStar(require("./fromWasmNode"), exports);

package/dist/node/js/coinName.d.ts

@@ -0,0 +1 @@
+export type CoinName = "btc" | "tbtc" | "tbtc4" | "tbtcsig" | "tbtcbgsig" | "bch" | "tbch" | "bcha" | "tbcha" | "btg" | "tbtg" | "bsv" | "tbsv" | "dash" | "tdash" | "doge" | "tdoge" | "ltc" | "tltc" | "zec" | "tzec";

package/dist/node/js/coinName.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/node/js/fixedScriptWallet.d.ts

@@ -0,0 +1,86 @@
+import type { UtxolibName, UtxolibNetwork, UtxolibRootWalletKeys } from "./utxolibCompat";
+import type { CoinName } from "./coinName";
+import { Triple } from "./triple";
+import { AddressFormat } from "./address";
+export type NetworkName = UtxolibName | CoinName;
+export type WalletKeys = 
+/** Just an xpub triple, will assume default derivation prefixes  */
+Triple<string>
+/** Compatible with utxolib RootWalletKeys */
+ | UtxolibRootWalletKeys;
+/**
+ * Create the output script for a given wallet keys and chain and index
+ */
+export declare function outputScript(keys: WalletKeys, chain: number, index: number, network: UtxolibNetwork): Uint8Array;
+/**
+ * Create the address for a given wallet keys and chain and index and network.
+ * Wrapper for outputScript that also encodes the script to an address.
+ * @param keys - The wallet keys to use.
+ * @param chain - The chain to use.
+ * @param index - The index to use.
+ * @param network - The network to use.
+ * @param addressFormat - The address format to use.
+ *   Only relevant for Bitcoin Cash and eCash networks, where:
+ *   - "default" means base58check,
+ *   - "cashaddr" means cashaddr.
+ */
+export declare function address(keys: WalletKeys, chain: number, index: number, network: UtxolibNetwork, addressFormat?: AddressFormat): string;
+type ReplayProtection = {
+    outputScripts: Uint8Array[];
+} | {
+    addresses: string[];
+};
+export type ScriptId = {
+    chain: number;
+    index: number;
+};
+export type ParsedInput = {
+    address: string;
+    script: Uint8Array;
+    value: bigint;
+    scriptId: ScriptId | null;
+};
+export type ParsedOutput = {
+    address: string | null;
+    script: Uint8Array;
+    value: bigint;
+    scriptId: ScriptId | null;
+};
+export type ParsedTransaction = {
+    inputs: ParsedInput[];
+    outputs: ParsedOutput[];
+    spendAmount: bigint;
+    minerFee: bigint;
+    virtualSize: number;
+};
+export declare class BitGoPsbt {
+    private wasm;
+    private constructor();
+    /**
+     * Deserialize a PSBT from bytes
+     * @param bytes - The PSBT bytes
+     * @param network - The network to use for deserialization (either utxolib name like "bitcoin" or coin name like "btc")
+     * @returns A BitGoPsbt instance
+     */
+    static fromBytes(bytes: Uint8Array, network: NetworkName): BitGoPsbt;
+    /**
+     * Parse transaction with wallet keys to identify wallet inputs/outputs
+     * @param walletKeys - The wallet keys to use for identification
+     * @param replayProtection - Scripts that are allowed as inputs without wallet validation
+     * @returns Parsed transaction information
+     */
+    parseTransactionWithWalletKeys(walletKeys: WalletKeys, replayProtection: ReplayProtection): ParsedTransaction;
+    /**
+     * Parse outputs with wallet keys to identify which outputs belong to a wallet
+     * with the given wallet keys.
+     *
+     * This is useful in cases where we want to identify outputs that belong to a different
+     * wallet than the inputs.
+     *
+     * @param walletKeys - The wallet keys to use for identification
+     * @returns Array of parsed outputs
+     * @note This method does NOT validate wallet inputs. It only parses outputs.
+     */
+    parseOutputsWithWalletKeys(walletKeys: WalletKeys): ParsedOutput[];
+}
+export {};

package/dist/node/js/fixedScriptWallet.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitGoPsbt = void 0;
+exports.outputScript = outputScript;
+exports.address = address;
+const wasm_utxo_1 = require("./wasm/wasm_utxo");
+/**
+ * Create the output script for a given wallet keys and chain and index
+ */
+function outputScript(keys, chain, index, network) {
+    return wasm_utxo_1.FixedScriptWalletNamespace.output_script(keys, chain, index, network);
+}
+/**
+ * Create the address for a given wallet keys and chain and index and network.
+ * Wrapper for outputScript that also encodes the script to an address.
+ * @param keys - The wallet keys to use.
+ * @param chain - The chain to use.
+ * @param index - The index to use.
+ * @param network - The network to use.
+ * @param addressFormat - The address format to use.
+ *   Only relevant for Bitcoin Cash and eCash networks, where:
+ *   - "default" means base58check,
+ *   - "cashaddr" means cashaddr.
+ */
+function address(keys, chain, index, network, addressFormat) {
+    return wasm_utxo_1.FixedScriptWalletNamespace.address(keys, chain, index, network, addressFormat);
+}
+const wasm_utxo_2 = require("./wasm/wasm_utxo");
+class BitGoPsbt {
+    wasm;
+    constructor(wasm) {
+        this.wasm = wasm;
+    }
+    /**
+     * Deserialize a PSBT from bytes
+     * @param bytes - The PSBT bytes
+     * @param network - The network to use for deserialization (either utxolib name like "bitcoin" or coin name like "btc")
+     * @returns A BitGoPsbt instance
+     */
+    static fromBytes(bytes, network) {
+        const wasm = wasm_utxo_2.BitGoPsbt.from_bytes(bytes, network);
+        return new BitGoPsbt(wasm);
+    }
+    /**
+     * Parse transaction with wallet keys to identify wallet inputs/outputs
+     * @param walletKeys - The wallet keys to use for identification
+     * @param replayProtection - Scripts that are allowed as inputs without wallet validation
+     * @returns Parsed transaction information
+     */
+    parseTransactionWithWalletKeys(walletKeys, replayProtection) {
+        return this.wasm.parse_transaction_with_wallet_keys(walletKeys, replayProtection);
+    }
+    /**
+     * Parse outputs with wallet keys to identify which outputs belong to a wallet
+     * with the given wallet keys.
+     *
+     * This is useful in cases where we want to identify outputs that belong to a different
+     * wallet than the inputs.
+     *
+     * @param walletKeys - The wallet keys to use for identification
+     * @returns Array of parsed outputs
+     * @note This method does NOT validate wallet inputs. It only parses outputs.
+     */
+    parseOutputsWithWalletKeys(walletKeys) {
+        return this.wasm.parse_outputs_with_wallet_keys(walletKeys);
+    }
+}
+exports.BitGoPsbt = BitGoPsbt;

package/dist/node/js/index.d.ts

@@ -0,0 +1,37 @@
+export * as address from "./address";
+export * as ast from "./ast";
+export * as utxolibCompat from "./utxolibCompat";
+export * as fixedScriptWallet from "./fixedScriptWallet";
+export type { CoinName } from "./coinName";
+export type { Triple } from "./triple";
+export type { AddressFormat } from "./address";
+export type DescriptorPkType = "derivable" | "definite" | "string";
+export type ScriptContext = "tap" | "segwitv0" | "legacy";
+export type SignPsbtResult = {
+    [inputIndex: number]: [pubkey: string][];
+};
+declare module "./wasm/wasm_utxo" {
+    interface WrapDescriptor {
+        /** These are not the same types of nodes as in the ast module */
+        node(): unknown;
+    }
+    namespace WrapDescriptor {
+        function fromString(descriptor: string, pkType: DescriptorPkType): WrapDescriptor;
+        function fromStringDetectType(descriptor: string): WrapDescriptor;
+    }
+    interface WrapMiniscript {
+        /** These are not the same types of nodes as in the ast module */
+        node(): unknown;
+    }
+    namespace WrapMiniscript {
+        function fromString(miniscript: string, ctx: ScriptContext): WrapMiniscript;
+        function fromBitcoinScript(script: Uint8Array, ctx: ScriptContext): WrapMiniscript;
+    }
+    interface WrapPsbt {
+        signWithXprv(this: WrapPsbt, xprv: string): SignPsbtResult;
+        signWithPrv(this: WrapPsbt, prv: Uint8Array): SignPsbtResult;
+    }
+}
+export { WrapDescriptor as Descriptor } from "./wasm/wasm_utxo";
+export { WrapMiniscript as Miniscript } from "./wasm/wasm_utxo";
+export { WrapPsbt as Psbt } from "./wasm/wasm_utxo";

package/dist/node/js/index.js

@@ -0,0 +1,50 @@
+"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 });
+exports.Psbt = exports.Miniscript = exports.Descriptor = exports.fixedScriptWallet = exports.utxolibCompat = exports.ast = exports.address = void 0;
+const wasm = __importStar(require("./wasm/wasm_utxo"));
+// we need to access the wasm module here, otherwise webpack gets all weird
+// and forgets to include it in the bundle
+void wasm;
+exports.address = __importStar(require("./address"));
+exports.ast = __importStar(require("./ast"));
+exports.utxolibCompat = __importStar(require("./utxolibCompat"));
+exports.fixedScriptWallet = __importStar(require("./fixedScriptWallet"));
+var wasm_utxo_1 = require("./wasm/wasm_utxo");
+Object.defineProperty(exports, "Descriptor", { enumerable: true, get: function () { return wasm_utxo_1.WrapDescriptor; } });
+var wasm_utxo_2 = require("./wasm/wasm_utxo");
+Object.defineProperty(exports, "Miniscript", { enumerable: true, get: function () { return wasm_utxo_2.WrapMiniscript; } });
+var wasm_utxo_3 = require("./wasm/wasm_utxo");
+Object.defineProperty(exports, "Psbt", { enumerable: true, get: function () { return wasm_utxo_3.WrapPsbt; } });

package/dist/node/js/triple.d.ts

@@ -0,0 +1 @@
+export type Triple<T> = [T, T, T];

package/dist/node/js/triple.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/node/js/utxolibCompat.d.ts

@@ -0,0 +1,32 @@
+import type { AddressFormat } from "./address";
+import { Triple } from "./triple";
+export type UtxolibName = "bitcoin" | "testnet" | "bitcoinTestnet4" | "bitcoinPublicSignet" | "bitcoinBitGoSignet" | "bitcoincash" | "bitcoincashTestnet" | "ecash" | "ecashTest" | "bitcoingold" | "bitcoingoldTestnet" | "bitcoinsv" | "bitcoinsvTestnet" | "dash" | "dashTest" | "dogecoin" | "dogecoinTest" | "litecoin" | "litecoinTest" | "zcash" | "zcashTest";
+export type BIP32Interface = {
+    network: {
+        bip32: {
+            public: number;
+        };
+    };
+    depth: number;
+    parentFingerprint: number;
+    index: number;
+    chainCode: Uint8Array;
+    publicKey: Uint8Array;
+    toBase58?(): string;
+};
+export type UtxolibRootWalletKeys = {
+    triple: Triple<BIP32Interface>;
+    derivationPrefixes: Triple<string>;
+};
+export type UtxolibNetwork = {
+    pubKeyHash: number;
+    scriptHash: number;
+    cashAddr?: {
+        prefix: string;
+        pubKeyHash: number;
+        scriptHash: number;
+    };
+    bech32?: string;
+};
+export declare function fromOutputScript(script: Uint8Array, network: UtxolibNetwork, format?: AddressFormat): string;
+export declare function toOutputScript(address: string, network: UtxolibNetwork, format?: AddressFormat): Uint8Array;

package/dist/node/js/utxolibCompat.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromOutputScript = fromOutputScript;
+exports.toOutputScript = toOutputScript;
+const wasm_utxo_1 = require("./wasm/wasm_utxo");
+function fromOutputScript(script, network, format) {
+    return wasm_utxo_1.UtxolibCompatNamespace.from_output_script(script, network, format);
+}
+function toOutputScript(address, network, format) {
+    return wasm_utxo_1.UtxolibCompatNamespace.to_output_script(address, network, format);
+}