@bitgo/wasm-utxo 1.42.0 → 1.44.0

package/dist/esm/js/inspect/index.js

@@ -0,0 +1,140 @@
+/**
+ * Inspect - TypeScript bindings for PSBT and Transaction parsing
+ *
+ * Provides typed wrappers around the WASM inspect functions that return
+ * hierarchical node structures suitable for display as collapsible trees.
+ *
+ * Import via: `import { ... } from "@bitgo/wasm-utxo/inspect"`
+ */
+import { parsePsbtToJson as wasmParsePsbtToJson, parseTxToJson as wasmParseTxToJson, parsePsbtRawToJson as wasmParsePsbtRawToJson, isInspectEnabled as wasmIsInspectEnabled, } from "../wasm/wasm_utxo.js";
+/** All supported networks in order of parsing priority */
+export const allNetworks = [
+    "btc",
+    "tbtc",
+    "tbtc4",
+    "tbtcsig",
+    "tbtcbgsig",
+    "ltc",
+    "tltc",
+    "bch",
+    "tbch",
+    "bcha",
+    "tbcha",
+    "btg",
+    "tbtg",
+    "bsv",
+    "tbsv",
+    "dash",
+    "tdash",
+    "doge",
+    "tdoge",
+    "zec",
+    "tzec",
+];
+/**
+ * Parse a PSBT and return a typed node tree.
+ *
+ * @param psbtBytes - The raw PSBT bytes
+ * @param network - The network coin name (e.g., "btc", "ltc", "bch")
+ * @returns A Node tree representing the parsed PSBT structure
+ * @throws If the PSBT bytes are invalid or network is unknown
+ */
+export function parsePsbtToNode(psbtBytes, network) {
+    const json = wasmParsePsbtToJson(psbtBytes, network);
+    return JSON.parse(json);
+}
+/**
+ * Parse a transaction and return a typed node tree.
+ *
+ * @param txBytes - The raw transaction bytes
+ * @param network - The network coin name (e.g., "btc", "ltc", "bch")
+ * @returns A Node tree representing the parsed transaction structure
+ * @throws If the transaction bytes are invalid or network is unknown
+ */
+export function parseTxToNode(txBytes, network) {
+    const json = wasmParseTxToJson(txBytes, network);
+    return JSON.parse(json);
+}
+/**
+ * Try to parse a PSBT with all networks and return the first one that succeeds.
+ *
+ * @param psbtBytes - The raw PSBT bytes
+ * @param networks - Optional list of networks to try (defaults to all networks)
+ * @returns An object with the parsed Node and detected network, or null if all fail
+ */
+export function tryParsePsbt(psbtBytes, networks = allNetworks) {
+    for (const network of networks) {
+        try {
+            const node = parsePsbtToNode(psbtBytes, network);
+            return { node, network };
+        }
+        catch {
+            // Try next network
+        }
+    }
+    return null;
+}
+/**
+ * Try to parse a transaction with all networks and return the first one that succeeds.
+ *
+ * @param txBytes - The raw transaction bytes
+ * @param networks - Optional list of networks to try (defaults to all networks)
+ * @returns An object with the parsed Node and detected network, or null if all fail
+ */
+export function tryParseTx(txBytes, networks = allNetworks) {
+    for (const network of networks) {
+        try {
+            const node = parseTxToNode(txBytes, network);
+            return { node, network };
+        }
+        catch {
+            // Try next network
+        }
+    }
+    return null;
+}
+/**
+ * Parse a PSBT at the raw byte level and return a typed node tree.
+ *
+ * Unlike `parsePsbtToNode`, this function exposes the raw key-value pair
+ * structure as defined in BIP-174, showing:
+ * - Raw key type IDs and their human-readable names
+ * - Proprietary keys with their structured format
+ * - Unknown/unrecognized keys that standard parsers might skip
+ *
+ * @param psbtBytes - The raw PSBT bytes
+ * @param network - The network coin name (e.g., "btc", "ltc", "zec")
+ * @returns A Node tree representing the raw PSBT key-value structure
+ * @throws If the PSBT bytes are invalid or network is unknown
+ */
+export function parsePsbtRawToNode(psbtBytes, network) {
+    const json = wasmParsePsbtRawToJson(psbtBytes, network);
+    return JSON.parse(json);
+}
+/**
+ * Try to parse a raw PSBT with all networks and return the first one that succeeds.
+ *
+ * @param psbtBytes - The raw PSBT bytes
+ * @param networks - Optional list of networks to try (defaults to all networks)
+ * @returns An object with the parsed Node and detected network, or null if all fail
+ */
+export function tryParsePsbtRaw(psbtBytes, networks = allNetworks) {
+    for (const network of networks) {
+        try {
+            const node = parsePsbtRawToNode(psbtBytes, network);
+            return { node, network };
+        }
+        catch {
+            // Try next network
+        }
+    }
+    return null;
+}
+/**
+ * Check if the inspect feature is enabled in the WASM build.
+ *
+ * @returns true if the feature is enabled, false otherwise
+ */
+export function isInspectEnabled() {
+    return wasmIsInspectEnabled();
+}

package/dist/esm/js/transaction.d.ts

@@ -14,11 +14,30 @@ export interface ITransaction {
 export declare class Transaction implements ITransaction {
     private _wasm;
     private constructor();
+    /**
+     * Create an empty transaction (version 1, locktime 0)
+     */
+    static create(): Transaction;
     static fromBytes(bytes: Uint8Array): Transaction;
     /**
      * @internal Create from WASM instance directly (avoids re-parsing bytes)
      */
     static fromWasm(wasm: WasmTransaction): Transaction;
+    /**
+     * Add an input to the transaction
+     * @param txid - Previous transaction ID (hex string)
+     * @param vout - Output index being spent
+     * @param sequence - Optional sequence number (default: 0xFFFFFFFF)
+     * @returns The index of the newly added input
+     */
+    addInput(txid: string, vout: number, sequence?: number): number;
+    /**
+     * Add an output to the transaction
+     * @param script - Output script (scriptPubKey)
+     * @param value - Value in satoshis
+     * @returns The index of the newly added output
+     */
+    addOutput(script: Uint8Array, value: bigint): number;
     toBytes(): Uint8Array;
     /**
      * Get the transaction ID (txid)

package/dist/esm/js/transaction.js

@@ -9,6 +9,12 @@ export class Transaction {
     constructor(_wasm) {
         this._wasm = _wasm;
     }
+    /**
+     * Create an empty transaction (version 1, locktime 0)
+     */
+    static create() {
+        return new Transaction(WasmTransaction.create());
+    }
     static fromBytes(bytes) {
         return new Transaction(WasmTransaction.from_bytes(bytes));
     }
@@ -18,6 +24,25 @@ export class Transaction {
     static fromWasm(wasm) {
         return new Transaction(wasm);
     }
+    /**
+     * Add an input to the transaction
+     * @param txid - Previous transaction ID (hex string)
+     * @param vout - Output index being spent
+     * @param sequence - Optional sequence number (default: 0xFFFFFFFF)
+     * @returns The index of the newly added input
+     */
+    addInput(txid, vout, sequence) {
+        return this._wasm.add_input(txid, vout, sequence);
+    }
+    /**
+     * Add an output to the transaction
+     * @param script - Output script (scriptPubKey)
+     * @param value - Value in satoshis
+     * @returns The index of the newly added output
+     */
+    addOutput(script, value) {
+        return this._wasm.add_output(script, value);
+    }
     toBytes() {
         return this._wasm.to_bytes();
     }

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

@@ -181,7 +181,7 @@ export class BitGoPsbt {
      * # Returns
      * The index of the newly added input
      */
-    add_replay_protection_input(ecpair: WasmECPair, txid: string, vout: number, value: bigint, sequence?: number | null): number;
+    add_replay_protection_input(ecpair: WasmECPair, txid: string, vout: number, value: bigint, sequence?: number | null, prev_tx?: Uint8Array | null): number;
     /**
      * Add a wallet input with full PSBT metadata
      *
@@ -756,6 +756,16 @@ export class FixedScriptWalletNamespace {
     static create_op_return_script(data?: Uint8Array | null): Uint8Array;
     static output_script(keys: WasmRootWalletKeys, chain: number, index: number, network: any): Uint8Array;
     static output_script_with_network_str(keys: WasmRootWalletKeys, chain: number, index: number, network: string): Uint8Array;
+    /**
+     * Get the P2SH-P2PK output script for a compressed public key
+     *
+     * # Arguments
+     * * `pubkey` - The compressed public key bytes (33 bytes)
+     *
+     * # Returns
+     * The P2SH-P2PK output script as bytes
+     */
+    static p2sh_p2pk_output_script(pubkey: Uint8Array): Uint8Array;
     /**
      * Check if a network supports a given fixed-script wallet script type
      *
@@ -1220,6 +1230,33 @@ export class WasmTransaction {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Add an input to the transaction
+     *
+     * # Arguments
+     * * `txid` - The transaction ID (hex string) of the output being spent
+     * * `vout` - The output index being spent
+     * * `sequence` - Optional sequence number (default: 0xFFFFFFFF)
+     *
+     * # Returns
+     * The index of the newly added input
+     */
+    add_input(txid: string, vout: number, sequence?: number | null): number;
+    /**
+     * Add an output to the transaction
+     *
+     * # Arguments
+     * * `script` - The output script (scriptPubKey)
+     * * `value` - The value in satoshis
+     *
+     * # Returns
+     * The index of the newly added output
+     */
+    add_output(script: Uint8Array, value: bigint): number;
+    /**
+     * Create an empty transaction (version 1, locktime 0)
+     */
+    static create(): WasmTransaction;
     /**
      * Deserialize a transaction from bytes
      *
@@ -1497,3 +1534,74 @@ export class WrapPsbt {
      */
     version(): number;
 }
+
+/**
+ * Check if the inspect feature is enabled.
+ *
+ * # Returns
+ * `true` if the feature is enabled, `false` otherwise
+ */
+export function isInspectEnabled(): boolean;
+
+/**
+ * Parse a PSBT at the raw byte level and return a JSON representation.
+ *
+ * Unlike `parsePsbtToJson`, this function exposes the raw key-value pair
+ * structure as defined in BIP-174, showing:
+ * - Raw key type IDs and their human-readable names
+ * - Proprietary keys with their structured format
+ * - Unknown/unrecognized keys that standard parsers might skip
+ *
+ * # Arguments
+ * * `psbt_bytes` - The raw PSBT bytes
+ * * `coin_name` - The network coin name (e.g., "btc", "ltc", "zec")
+ *
+ * # Returns
+ * A JSON string representing the raw PSBT key-value structure
+ *
+ * # Errors
+ * Returns an error if:
+ * - The `inspect` feature is not enabled
+ * - The PSBT bytes are invalid
+ * - The network name is unknown
+ */
+export function parsePsbtRawToJson(psbt_bytes: Uint8Array, coin_name: string): string;
+
+/**
+ * Parse a PSBT and return a JSON representation of its structure.
+ *
+ * This function parses the PSBT using the standard bitcoin crate parser
+ * and returns a hierarchical node structure suitable for display.
+ *
+ * # Arguments
+ * * `psbt_bytes` - The raw PSBT bytes
+ * * `coin_name` - The network coin name (e.g., "btc", "ltc", "bch")
+ *
+ * # Returns
+ * A JSON string representing the parsed PSBT structure
+ *
+ * # Errors
+ * Returns an error if:
+ * - The `inspect` feature is not enabled
+ * - The PSBT bytes are invalid
+ * - The network name is unknown
+ */
+export function parsePsbtToJson(psbt_bytes: Uint8Array, coin_name: string): string;
+
+/**
+ * Parse a transaction and return a JSON representation of its structure.
+ *
+ * # Arguments
+ * * `tx_bytes` - The raw transaction bytes
+ * * `coin_name` - The network coin name (e.g., "btc", "ltc", "bch")
+ *
+ * # Returns
+ * A JSON string representing the parsed transaction structure
+ *
+ * # Errors
+ * Returns an error if:
+ * - The `inspect` feature is not enabled
+ * - The transaction bytes are invalid
+ * - The network name is unknown
+ */
+export function parseTxToJson(tx_bytes: Uint8Array, coin_name: string): string;

package/dist/esm/js/wasm/wasm_utxo.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./wasm_utxo_bg.js";
 __wbg_set_wasm(wasm);
 
 export {
-    AddressNamespace, Bip322Namespace, BitGoPsbt, FixedScriptWalletNamespace, InscriptionsNamespace, MessageNamespace, UtxolibCompatNamespace, WasmBIP32, WasmDashTransaction, WasmDimensions, WasmECPair, WasmReplayProtection, WasmRootWalletKeys, WasmTransaction, WasmZcashTransaction, WrapDescriptor, WrapMiniscript, WrapPsbt
+    AddressNamespace, Bip322Namespace, BitGoPsbt, FixedScriptWalletNamespace, InscriptionsNamespace, MessageNamespace, UtxolibCompatNamespace, WasmBIP32, WasmDashTransaction, WasmDimensions, WasmECPair, WasmReplayProtection, WasmRootWalletKeys, WasmTransaction, WasmZcashTransaction, WrapDescriptor, WrapMiniscript, WrapPsbt, isInspectEnabled, parsePsbtRawToJson, parsePsbtToJson, parseTxToJson
 } from "./wasm_utxo_bg.js";

package/dist/esm/js/wasm/wasm_utxo_bg.js

@@ -517,15 +517,18 @@ export class BitGoPsbt {
      * @param {number} vout
      * @param {bigint} value
      * @param {number | null} [sequence]
+     * @param {Uint8Array | null} [prev_tx]
      * @returns {number}
      */
-    add_replay_protection_input(ecpair, txid, vout, value, sequence) {
+    add_replay_protection_input(ecpair, txid, vout, value, sequence, prev_tx) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(ecpair, WasmECPair);
             const ptr0 = passStringToWasm0(txid, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.bitgopsbt_add_replay_protection_input(retptr, this.__wbg_ptr, ecpair.__wbg_ptr, ptr0, len0, vout, value, isLikeNone(sequence) ? 0x100000001 : (sequence) >>> 0);
+            var ptr1 = isLikeNone(prev_tx) ? 0 : passArray8ToWasm0(prev_tx, wasm.__wbindgen_export);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.bitgopsbt_add_replay_protection_input(retptr, this.__wbg_ptr, ecpair.__wbg_ptr, ptr0, len0, vout, value, isLikeNone(sequence) ? 0x100000001 : (sequence) >>> 0, 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);
@@ -1945,6 +1948,37 @@ export class FixedScriptWalletNamespace {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Get the P2SH-P2PK output script for a compressed public key
+     *
+     * # Arguments
+     * * `pubkey` - The compressed public key bytes (33 bytes)
+     *
+     * # Returns
+     * The P2SH-P2PK output script as bytes
+     * @param {Uint8Array} pubkey
+     * @returns {Uint8Array}
+     */
+    static p2sh_p2pk_output_script(pubkey) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(pubkey, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.fixedscriptwalletnamespace_p2sh_p2pk_output_script(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Check if a network supports a given fixed-script wallet script type
      *
@@ -3463,6 +3497,65 @@ export class WasmTransaction {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmtransaction_free(ptr, 0);
     }
+    /**
+     * Add an input to the transaction
+     *
+     * # Arguments
+     * * `txid` - The transaction ID (hex string) of the output being spent
+     * * `vout` - The output index being spent
+     * * `sequence` - Optional sequence number (default: 0xFFFFFFFF)
+     *
+     * # Returns
+     * The index of the newly added input
+     * @param {string} txid
+     * @param {number} vout
+     * @param {number | null} [sequence]
+     * @returns {number}
+     */
+    add_input(txid, vout, sequence) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(txid, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmtransaction_add_input(retptr, this.__wbg_ptr, ptr0, len0, vout, isLikeNone(sequence) ? 0x100000001 : (sequence) >>> 0);
+            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 r0 >>> 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Add an output to the transaction
+     *
+     * # Arguments
+     * * `script` - The output script (scriptPubKey)
+     * * `value` - The value in satoshis
+     *
+     * # Returns
+     * The index of the newly added output
+     * @param {Uint8Array} script
+     * @param {bigint} value
+     * @returns {number}
+     */
+    add_output(script, value) {
+        const ptr0 = passArray8ToWasm0(script, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmtransaction_add_output(this.__wbg_ptr, ptr0, len0, value);
+        return ret >>> 0;
+    }
+    /**
+     * Create an empty transaction (version 1, locktime 0)
+     * @returns {WasmTransaction}
+     */
+    static create() {
+        const ret = wasm.wasmtransaction_create();
+        return WasmTransaction.__wrap(ret);
+    }
     /**
      * Deserialize a transaction from bytes
      *
@@ -4664,6 +4757,171 @@ export class WrapPsbt {
     }
 }
 if (Symbol.dispose) WrapPsbt.prototype[Symbol.dispose] = WrapPsbt.prototype.free;
+
+/**
+ * Check if the inspect feature is enabled.
+ *
+ * # Returns
+ * `true` if the feature is enabled, `false` otherwise
+ * @returns {boolean}
+ */
+export function isInspectEnabled() {
+    const ret = wasm.isInspectEnabled();
+    return ret !== 0;
+}
+
+/**
+ * Parse a PSBT at the raw byte level and return a JSON representation.
+ *
+ * Unlike `parsePsbtToJson`, this function exposes the raw key-value pair
+ * structure as defined in BIP-174, showing:
+ * - Raw key type IDs and their human-readable names
+ * - Proprietary keys with their structured format
+ * - Unknown/unrecognized keys that standard parsers might skip
+ *
+ * # Arguments
+ * * `psbt_bytes` - The raw PSBT bytes
+ * * `coin_name` - The network coin name (e.g., "btc", "ltc", "zec")
+ *
+ * # Returns
+ * A JSON string representing the raw PSBT key-value structure
+ *
+ * # Errors
+ * Returns an error if:
+ * - The `inspect` feature is not enabled
+ * - The PSBT bytes are invalid
+ * - The network name is unknown
+ * @param {Uint8Array} psbt_bytes
+ * @param {string} coin_name
+ * @returns {string}
+ */
+export function parsePsbtRawToJson(psbt_bytes, coin_name) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(psbt_bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(coin_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.parsePsbtRawToJson(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);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Parse a PSBT and return a JSON representation of its structure.
+ *
+ * This function parses the PSBT using the standard bitcoin crate parser
+ * and returns a hierarchical node structure suitable for display.
+ *
+ * # Arguments
+ * * `psbt_bytes` - The raw PSBT bytes
+ * * `coin_name` - The network coin name (e.g., "btc", "ltc", "bch")
+ *
+ * # Returns
+ * A JSON string representing the parsed PSBT structure
+ *
+ * # Errors
+ * Returns an error if:
+ * - The `inspect` feature is not enabled
+ * - The PSBT bytes are invalid
+ * - The network name is unknown
+ * @param {Uint8Array} psbt_bytes
+ * @param {string} coin_name
+ * @returns {string}
+ */
+export function parsePsbtToJson(psbt_bytes, coin_name) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(psbt_bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(coin_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.parsePsbtRawToJson(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);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Parse a transaction and return a JSON representation of its structure.
+ *
+ * # Arguments
+ * * `tx_bytes` - The raw transaction bytes
+ * * `coin_name` - The network coin name (e.g., "btc", "ltc", "bch")
+ *
+ * # Returns
+ * A JSON string representing the parsed transaction structure
+ *
+ * # Errors
+ * Returns an error if:
+ * - The `inspect` feature is not enabled
+ * - The transaction bytes are invalid
+ * - The network name is unknown
+ * @param {Uint8Array} tx_bytes
+ * @param {string} coin_name
+ * @returns {string}
+ */
+export function parseTxToJson(tx_bytes, coin_name) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(tx_bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(coin_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.parsePsbtRawToJson(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);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+    }
+}
 export function __wbg_Error_8c4e43fe74559d73(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return addHeapObject(ret);