@bitgo/wasm-utxo 0.0.2 → 1.1.0

package/dist/browser/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/browser/js/address.js

@@ -0,0 +1,7 @@
+import { AddressNamespace } from "./wasm/wasm_utxo";
+export function toOutputScriptWithCoin(address, coin) {
+    return AddressNamespace.to_output_script_with_coin(address, coin);
+}
+export function fromOutputScriptWithCoin(script, coin, format) {
+    return AddressNamespace.from_output_script_with_coin(script, coin, format);
+}

package/dist/browser/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/browser/js/coinName.js

@@ -0,0 +1 @@
+export {};

package/dist/browser/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/browser/js/fixedScriptWallet.js

@@ -0,0 +1,61 @@
+import { FixedScriptWalletNamespace } from "./wasm/wasm_utxo";
+/**
+ * Create the output script for a given wallet keys and chain and index
+ */
+export function outputScript(keys, chain, index, network) {
+    return 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.
+ */
+export function address(keys, chain, index, network, addressFormat) {
+    return FixedScriptWalletNamespace.address(keys, chain, index, network, addressFormat);
+}
+import { BitGoPsbt as WasmBitGoPsbt } from "./wasm/wasm_utxo";
+export class BitGoPsbt {
+    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 = WasmBitGoPsbt.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);
+    }
+}

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

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

package/dist/browser/js/triple.js

@@ -0,0 +1 @@
+export {};

package/dist/browser/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/browser/js/utxolibCompat.js

@@ -0,0 +1,7 @@
+import { UtxolibCompatNamespace } from "./wasm/wasm_utxo";
+export function fromOutputScript(script, network, format) {
+    return UtxolibCompatNamespace.from_output_script(script, network, format);
+}
+export function toOutputScript(address, network, format) {
+    return UtxolibCompatNamespace.to_output_script(address, network, format);
+}

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

@@ -7,6 +7,25 @@ export class AddressNamespace {
   static to_output_script_with_coin(address: string, coin: string): Uint8Array;
   static from_output_script_with_coin(script: Uint8Array, coin: string, format?: string | null): string;
 }
+export class BitGoPsbt {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Deserialize a PSBT from bytes with network-specific logic
+   */
+  static from_bytes(bytes: Uint8Array, network: string): BitGoPsbt;
+  /**
+   * Parse outputs with wallet keys to identify which outputs belong to a wallet
+   *
+   * Note: This method does NOT validate wallet inputs. It only parses outputs.
+   */
+  parse_outputs_with_wallet_keys(wallet_keys: any): any;
+  /**
+   * Parse transaction with wallet keys to identify wallet inputs/outputs
+   */
+  parse_transaction_with_wallet_keys(wallet_keys: any, replay_protection: any): any;
+}
 export class FixedScriptWalletNamespace {
   private constructor();
   free(): void;

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

@@ -239,6 +239,102 @@ export class AddressNamespace {
 }
 if (Symbol.dispose) AddressNamespace.prototype[Symbol.dispose] = AddressNamespace.prototype.free;
 
+const BitGoPsbtFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bitgopsbt_free(ptr >>> 0, 1));
+
+export class BitGoPsbt {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(BitGoPsbt.prototype);
+        obj.__wbg_ptr = ptr;
+        BitGoPsbtFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BitGoPsbtFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bitgopsbt_free(ptr, 0);
+    }
+    /**
+     * Deserialize a PSBT from bytes with network-specific logic
+     * @param {Uint8Array} bytes
+     * @param {string} network
+     * @returns {BitGoPsbt}
+     */
+    static from_bytes(bytes, network) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(network, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.bitgopsbt_from_bytes(retptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return BitGoPsbt.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Parse outputs with wallet keys to identify which outputs belong to a wallet
+     *
+     * Note: This method does NOT validate wallet inputs. It only parses outputs.
+     * @param {any} wallet_keys
+     * @returns {any}
+     */
+    parse_outputs_with_wallet_keys(wallet_keys) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bitgopsbt_parse_outputs_with_wallet_keys(retptr, this.__wbg_ptr, addHeapObject(wallet_keys));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Parse transaction with wallet keys to identify wallet inputs/outputs
+     * @param {any} wallet_keys
+     * @param {any} replay_protection
+     * @returns {any}
+     */
+    parse_transaction_with_wallet_keys(wallet_keys, replay_protection) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bitgopsbt_parse_transaction_with_wallet_keys(retptr, this.__wbg_ptr, addHeapObject(wallet_keys), addHeapObject(replay_protection));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) BitGoPsbt.prototype[Symbol.dispose] = BitGoPsbt.prototype.free;
+
 const FixedScriptWalletNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fixedscriptwalletnamespace_free(ptr >>> 0, 1));
@@ -1043,6 +1139,17 @@ export function __wbg_get_458e874b43b18b25() { return handleError(function (arg0
     return addHeapObject(ret);
 }, arguments) };
 
+export function __wbg_instanceof_Uint8Array_9a8378d955933db7(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
 export function __wbg_isArray_030cce220591fb41(arg0) {
     const ret = Array.isArray(getObject(arg0));
     return ret;
@@ -1078,6 +1185,11 @@ export function __wbg_new_da9dc54c5db29dfa(arg0, arg1) {
     return addHeapObject(ret);
 };
 
+export function __wbg_newfromslice_074c56947bd43469(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
 export function __wbg_prototypesetcall_3d4a26c1ed734349(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 };
@@ -1139,6 +1251,12 @@ export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
     return addHeapObject(ret);
 };
 
+export function __wbindgen_cast_4625c577ab2ec9ee(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
+    return addHeapObject(ret);
+};
+
 export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;

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

@@ -2,13 +2,11 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_addressnamespace_free: (a: number, b: number) => void;
-export const __wbg_fixedscriptwalletnamespace_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 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 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;
@@ -22,14 +20,20 @@ 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 __wbg_wrapminiscript_free: (a: number, b: number) => void;
-export const __wbg_wrappsbt_free: (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;

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/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/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);
+}

package/dist/node/js/wasm/wasm_utxo.d.ts

@@ -7,6 +7,25 @@ export class AddressNamespace {
   static to_output_script_with_coin(address: string, coin: string): Uint8Array;
   static from_output_script_with_coin(script: Uint8Array, coin: string, format?: string | null): string;
 }
+export class BitGoPsbt {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Deserialize a PSBT from bytes with network-specific logic
+   */
+  static from_bytes(bytes: Uint8Array, network: string): BitGoPsbt;
+  /**
+   * Parse outputs with wallet keys to identify which outputs belong to a wallet
+   *
+   * Note: This method does NOT validate wallet inputs. It only parses outputs.
+   */
+  parse_outputs_with_wallet_keys(wallet_keys: any): any;
+  /**
+   * Parse transaction with wallet keys to identify wallet inputs/outputs
+   */
+  parse_transaction_with_wallet_keys(wallet_keys: any, replay_protection: any): any;
+}
 export class FixedScriptWalletNamespace {
   private constructor();
   free(): void;

package/dist/node/js/wasm/wasm_utxo.js

@@ -231,6 +231,104 @@ if (Symbol.dispose) AddressNamespace.prototype[Symbol.dispose] = AddressNamespac
 
 exports.AddressNamespace = AddressNamespace;
 
+const BitGoPsbtFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bitgopsbt_free(ptr >>> 0, 1));
+
+class BitGoPsbt {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(BitGoPsbt.prototype);
+        obj.__wbg_ptr = ptr;
+        BitGoPsbtFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BitGoPsbtFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bitgopsbt_free(ptr, 0);
+    }
+    /**
+     * Deserialize a PSBT from bytes with network-specific logic
+     * @param {Uint8Array} bytes
+     * @param {string} network
+     * @returns {BitGoPsbt}
+     */
+    static from_bytes(bytes, network) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(network, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.bitgopsbt_from_bytes(retptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return BitGoPsbt.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Parse outputs with wallet keys to identify which outputs belong to a wallet
+     *
+     * Note: This method does NOT validate wallet inputs. It only parses outputs.
+     * @param {any} wallet_keys
+     * @returns {any}
+     */
+    parse_outputs_with_wallet_keys(wallet_keys) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bitgopsbt_parse_outputs_with_wallet_keys(retptr, this.__wbg_ptr, addHeapObject(wallet_keys));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Parse transaction with wallet keys to identify wallet inputs/outputs
+     * @param {any} wallet_keys
+     * @param {any} replay_protection
+     * @returns {any}
+     */
+    parse_transaction_with_wallet_keys(wallet_keys, replay_protection) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bitgopsbt_parse_transaction_with_wallet_keys(retptr, this.__wbg_ptr, addHeapObject(wallet_keys), addHeapObject(replay_protection));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) BitGoPsbt.prototype[Symbol.dispose] = BitGoPsbt.prototype.free;
+
+exports.BitGoPsbt = BitGoPsbt;
+
 const FixedScriptWalletNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fixedscriptwalletnamespace_free(ptr >>> 0, 1));
@@ -1045,6 +1143,17 @@ exports.__wbg_get_458e874b43b18b25 = function() { return handleError(function (a
     return addHeapObject(ret);
 }, arguments) };
 
+exports.__wbg_instanceof_Uint8Array_9a8378d955933db7 = function(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
 exports.__wbg_isArray_030cce220591fb41 = function(arg0) {
     const ret = Array.isArray(getObject(arg0));
     return ret;
@@ -1080,6 +1189,11 @@ exports.__wbg_new_da9dc54c5db29dfa = function(arg0, arg1) {
     return addHeapObject(ret);
 };
 
+exports.__wbg_newfromslice_074c56947bd43469 = function(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
 exports.__wbg_prototypesetcall_3d4a26c1ed734349 = function(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 };
@@ -1141,6 +1255,12 @@ exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
     return addHeapObject(ret);
 };
 
+exports.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
+    return addHeapObject(ret);
+};
+
 exports.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;

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

@@ -2,13 +2,11 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_addressnamespace_free: (a: number, b: number) => void;
-export const __wbg_fixedscriptwalletnamespace_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 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 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;
@@ -22,14 +20,20 @@ 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 __wbg_wrapminiscript_free: (a: number, b: number) => void;
-export const __wbg_wrappsbt_free: (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;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bitgo/wasm-utxo",
   "description": "WebAssembly wrapper for rust-bitcoin (beta)",
-  "version": "0.0.2",
+  "version": "1.1.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/BitGo/BitGoWASM"
@@ -14,10 +14,42 @@
     "dist/*/js/wasm/wasm_utxo_bg.wasm",
     "dist/*/js/wasm/wasm_utxo_bg.wasm.d.ts",
     "dist/*/js/ast/*",
-    "dist/*/js/index.*"
+    "dist/*/js/index.*",
+    "dist/*/js/address.*",
+    "dist/*/js/utxolibCompat.*",
+    "dist/*/js/fixedScriptWallet.*",
+    "dist/*/js/coinName.*",
+    "dist/*/js/triple.*"
   ],
   "main": "dist/node/js/index.js",
   "types": "dist/node/js/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/node/js/index.d.ts",
+      "browser": "./dist/browser/js/index.js",
+      "default": "./dist/node/js/index.js"
+    },
+    "./address": {
+      "types": "./dist/node/js/address.d.ts",
+      "browser": "./dist/browser/js/address.js",
+      "default": "./dist/node/js/address.js"
+    },
+    "./ast": {
+      "types": "./dist/node/js/ast/index.d.ts",
+      "browser": "./dist/browser/js/ast/index.js",
+      "default": "./dist/node/js/ast/index.js"
+    },
+    "./fixedScriptWallet": {
+      "types": "./dist/node/js/fixedScriptWallet.d.ts",
+      "browser": "./dist/browser/js/fixedScriptWallet.js",
+      "default": "./dist/node/js/fixedScriptWallet.js"
+    },
+    "./utxolibCompat": {
+      "types": "./dist/node/js/utxolibCompat.d.ts",
+      "browser": "./dist/browser/js/utxolibCompat.js",
+      "default": "./dist/node/js/utxolibCompat.js"
+    }
+  },
   "sideEffects": [
     "./dist/node/js/wasm/wasm_utxo.js",
     "./dist/browser/js/wasm/wasm_utxo.js"