@bitgo/wasm-utxo 1.43.0 → 2.0.0

package/README.md

@@ -31,6 +31,36 @@ Zcash support includes:
 - **Height-Based API**: Preferred `createEmpty()` method automatically selects correct consensus rules
 - **Parity Testing**: Validated against `zebra-chain` for accuracy across all network upgrades
 
+## Inspect Feature
+
+The `inspect` feature adds PSBT and transaction parsing into hierarchical node trees,
+useful for building tree-view UIs and CLI formatters.
+
+It is behind a Cargo feature flag because it pulls in extra dependencies (`serde`, `serde_json`,
+`num-bigint`, `hex`) that are not needed for core wallet operations.
+
+### Rust
+
+```rust
+// Cargo.toml
+wasm-utxo = { path = ".", features = ["inspect"] }
+
+// Usage
+use wasm_utxo::inspect::{parse_psbt_bytes_with_network, parse_tx_bytes_with_network, Node};
+```
+
+### TypeScript
+
+Available as a separate import path, not included in the main `@bitgo/wasm-utxo` entry:
+
+```typescript
+import { parsePsbtToNode, parseTxToNode, isInspectEnabled } from "@bitgo/wasm-utxo/inspect";
+```
+
+The published npm package includes stub implementations that return `isInspectEnabled() === false`
+and throw runtime errors from the parse functions. To get a working build, compile the WASM with
+`--features inspect` (see [`packages/webui/scripts/build-wasm.sh`](../webui/scripts/build-wasm.sh)).
+
 ## Building
 
 ### Mac

package/dist/cjs/js/fixedScriptWallet/BitGoPsbt.d.ts

@@ -1,5 +1,5 @@
 import { BitGoPsbt as WasmBitGoPsbt, type PsbtInputData, type PsbtOutputData, type PsbtOutputDataWithAddress } from "../wasm/wasm_utxo.js";
-import type { IPsbtIntrospectionWithAddress } from "../psbt.js";
+import type { IPsbtWithAddress } from "../psbt.js";
 import { type WalletKeysArg } from "./RootWalletKeys.js";
 import { type ReplayProtectionArg } from "./ReplayProtection.js";
 import { type BIP32Arg } from "../bip32.js";
@@ -98,7 +98,7 @@ export type ParseTransactionOptions = {
 export type ParseOutputsOptions = {
     payGoPubkeys?: ECPairArg[];
 };
-export declare class BitGoPsbt implements IPsbtIntrospectionWithAddress {
+export declare class BitGoPsbt implements IPsbtWithAddress {
     protected _wasm: WasmBitGoPsbt;
     protected constructor(_wasm: WasmBitGoPsbt);
     /**
@@ -155,6 +155,8 @@ export declare class BitGoPsbt implements IPsbtIntrospectionWithAddress {
      * }, outputScript);
      * ```
      */
+    addInputAtIndex(index: number, txid: string, vout: number, value: bigint, script: Uint8Array, sequence?: number): number;
+    addInputAtIndex(index: number, options: AddInputOptions, script: Uint8Array): number;
     addInput(options: AddInputOptions, script: Uint8Array): number;
     /**
      * Add an output to the PSBT
@@ -168,41 +170,11 @@ export declare class BitGoPsbt implements IPsbtIntrospectionWithAddress {
      * const outputIndex = psbt.addOutput(outputScript, 50000n);
      * ```
      */
+    addOutputAtIndex(index: number, script: Uint8Array, value: bigint): number;
+    addOutputAtIndex(index: number, address: string, value: bigint): number;
+    addOutputAtIndex(index: number, options: AddOutputOptions): number;
     addOutput(script: Uint8Array, value: bigint): number;
-    /**
-     * Add an output to the PSBT by address
-     *
-     * @param address - The destination address
-     * @param value - Value in satoshis
-     * @returns The index of the newly added output
-     *
-     * @example
-     * ```typescript
-     * const outputIndex = psbt.addOutput("bc1q...", 50000n);
-     * ```
-     */
     addOutput(address: string, value: bigint): number;
-    /**
-     * Add an output to the PSBT
-     *
-     * @param options - Output options (script or address, and value)
-     * @returns The index of the newly added output
-     *
-     * @example
-     * ```typescript
-     * // Using script
-     * const outputIndex = psbt.addOutput({
-     *   script: outputScript,
-     *   value: 50000n,
-     * });
-     *
-     * // Using address
-     * const outputIndex = psbt.addOutput({
-     *   address: "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4",
-     *   value: 50000n,
-     * });
-     * ```
-     */
     addOutput(options: AddOutputOptions): number;
     /**
      * Add a wallet input with full PSBT metadata
@@ -243,6 +215,7 @@ export declare class BitGoPsbt implements IPsbtIntrospectionWithAddress {
      * );
      * ```
      */
+    addWalletInputAtIndex(index: number, inputOptions: AddInputOptions, walletKeys: WalletKeysArg, walletOptions: AddWalletInputOptions): number;
     addWalletInput(inputOptions: AddInputOptions, walletKeys: WalletKeysArg, walletOptions: AddWalletInputOptions): number;
     /**
      * Add a wallet output with full PSBT metadata
@@ -274,6 +247,7 @@ export declare class BitGoPsbt implements IPsbtIntrospectionWithAddress {
      * });
      * ```
      */
+    addWalletOutputAtIndex(index: number, walletKeys: WalletKeysArg, options: AddWalletOutputOptions): number;
     addWalletOutput(walletKeys: WalletKeysArg, options: AddWalletOutputOptions): number;
     /**
      * Add a replay protection input to the PSBT
@@ -294,22 +268,21 @@ export declare class BitGoPsbt implements IPsbtIntrospectionWithAddress {
      * );
      * ```
      */
+    addReplayProtectionInputAtIndex(index: number, inputOptions: AddInputOptions, key: ECPairArg): number;
     addReplayProtectionInput(inputOptions: AddInputOptions, key: ECPairArg): number;
+    removeInput(index: number): void;
+    removeOutput(index: number): void;
     /**
      * Get the unsigned transaction ID
      * @returns The unsigned transaction ID
      */
-    unsignedTxid(): string;
+    unsignedTxId(): string;
     /**
      * Get the transaction version
      * @returns The transaction version number
      */
-    get version(): number;
-    /**
-     * Get the transaction lock time
-     * @returns The transaction lock time
-     */
-    get lockTime(): number;
+    version(): number;
+    lockTime(): number;
     /**
      * Parse transaction with wallet keys to identify wallet inputs/outputs
      * @param walletKeys - The wallet keys to use for identification
@@ -584,12 +557,8 @@ export declare class BitGoPsbt implements IPsbtIntrospectionWithAddress {
      * Get the number of inputs in the PSBT
      * @returns The number of inputs
      */
-    get inputCount(): number;
-    /**
-     * Get the number of outputs in the PSBT
-     * @returns The number of outputs
-     */
-    get outputCount(): number;
+    inputCount(): number;
+    outputCount(): number;
     /**
      * Get all PSBT inputs as an array
      *

package/dist/cjs/js/fixedScriptWallet/BitGoPsbt.js

@@ -56,28 +56,35 @@ class BitGoPsbt {
         const wasm = wasm_utxo_js_1.BitGoPsbt.from_bytes(bytes, network);
         return new BitGoPsbt(wasm);
     }
-    /**
-     * Add an input to the PSBT
-     *
-     * This adds a transaction input and corresponding PSBT input metadata.
-     * The witness_utxo is automatically populated for modern signing compatibility.
-     *
-     * @param options - Input options (txid, vout, value, sequence)
-     * @param script - Output script of the UTXO being spent
-     * @returns The index of the newly added input
-     *
-     * @example
-     * ```typescript
-     * const inputIndex = psbt.addInput({
-     *   txid: "abc123...",
-     *   vout: 0,
-     *   value: 100000n,
-     * }, outputScript);
-     * ```
-     */
+    addInputAtIndex(index, txidOrOptions, voutOrScript, value, script, sequence) {
+        if (typeof txidOrOptions === "string") {
+            return this._wasm.add_input_at_index(index, txidOrOptions, voutOrScript, value, script, sequence);
+        }
+        const options = txidOrOptions;
+        return this._wasm.add_input_at_index(index, options.txid, options.vout, options.value, voutOrScript, options.sequence, options.prevTx);
+    }
     addInput(options, script) {
         return this._wasm.add_input(options.txid, options.vout, options.value, script, options.sequence, options.prevTx);
     }
+    addOutputAtIndex(index, scriptOrOptions, value) {
+        if (scriptOrOptions instanceof Uint8Array || typeof scriptOrOptions === "string") {
+            if (value === undefined) {
+                throw new Error("Value is required when passing a script or address");
+            }
+            if (scriptOrOptions instanceof Uint8Array) {
+                return this._wasm.add_output_at_index(index, scriptOrOptions, value);
+            }
+            return this._wasm.add_output_with_address_at_index(index, scriptOrOptions, value);
+        }
+        const options = scriptOrOptions;
+        if ("script" in options) {
+            return this._wasm.add_output_at_index(index, options.script, options.value);
+        }
+        if ("address" in options) {
+            return this._wasm.add_output_with_address_at_index(index, options.address, options.value);
+        }
+        throw new Error("Invalid output options");
+    }
     addOutput(scriptOrOptions, value) {
         if (scriptOrOptions instanceof Uint8Array || typeof scriptOrOptions === "string") {
             if (value === undefined) {
@@ -136,6 +143,10 @@ class BitGoPsbt {
      * );
      * ```
      */
+    addWalletInputAtIndex(index, inputOptions, walletKeys, walletOptions) {
+        const keys = RootWalletKeys_js_1.RootWalletKeys.from(walletKeys);
+        return this._wasm.add_wallet_input_at_index(index, inputOptions.txid, inputOptions.vout, inputOptions.value, keys.wasm, walletOptions.scriptId.chain, walletOptions.scriptId.index, walletOptions.signPath?.signer, walletOptions.signPath?.cosigner, inputOptions.sequence, inputOptions.prevTx);
+    }
     addWalletInput(inputOptions, walletKeys, walletOptions) {
         const keys = RootWalletKeys_js_1.RootWalletKeys.from(walletKeys);
         return this._wasm.add_wallet_input(inputOptions.txid, inputOptions.vout, inputOptions.value, keys.wasm, walletOptions.scriptId.chain, walletOptions.scriptId.index, walletOptions.signPath?.signer, walletOptions.signPath?.cosigner, inputOptions.sequence, inputOptions.prevTx);
@@ -170,6 +181,10 @@ class BitGoPsbt {
      * });
      * ```
      */
+    addWalletOutputAtIndex(index, walletKeys, options) {
+        const keys = RootWalletKeys_js_1.RootWalletKeys.from(walletKeys);
+        return this._wasm.add_wallet_output_at_index(index, options.chain, options.index, options.value, keys.wasm);
+    }
     addWalletOutput(walletKeys, options) {
         const keys = RootWalletKeys_js_1.RootWalletKeys.from(walletKeys);
         return this._wasm.add_wallet_output(options.chain, options.index, options.value, keys.wasm);
@@ -193,29 +208,35 @@ class BitGoPsbt {
      * );
      * ```
      */
+    addReplayProtectionInputAtIndex(index, inputOptions, key) {
+        const ecpair = ecpair_js_1.ECPair.from(key);
+        return this._wasm.add_replay_protection_input_at_index(index, ecpair.wasm, inputOptions.txid, inputOptions.vout, inputOptions.value, inputOptions.sequence, inputOptions.prevTx);
+    }
     addReplayProtectionInput(inputOptions, key) {
         const ecpair = ecpair_js_1.ECPair.from(key);
         return this._wasm.add_replay_protection_input(ecpair.wasm, inputOptions.txid, inputOptions.vout, inputOptions.value, inputOptions.sequence, inputOptions.prevTx);
     }
+    removeInput(index) {
+        this._wasm.remove_input(index);
+    }
+    removeOutput(index) {
+        this._wasm.remove_output(index);
+    }
     /**
      * Get the unsigned transaction ID
      * @returns The unsigned transaction ID
      */
-    unsignedTxid() {
+    unsignedTxId() {
         return this._wasm.unsigned_txid();
     }
     /**
      * Get the transaction version
      * @returns The transaction version number
      */
-    get version() {
+    version() {
         return this._wasm.version();
     }
-    /**
-     * Get the transaction lock time
-     * @returns The transaction lock time
-     */
-    get lockTime() {
+    lockTime() {
         return this._wasm.lock_time();
     }
     /**
@@ -541,14 +562,10 @@ class BitGoPsbt {
      * Get the number of inputs in the PSBT
      * @returns The number of inputs
      */
-    get inputCount() {
+    inputCount() {
         return this._wasm.input_count();
     }
-    /**
-     * Get the number of outputs in the PSBT
-     * @returns The number of outputs
-     */
-    get outputCount() {
+    outputCount() {
         return this._wasm.output_count();
     }
     /**

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

@@ -82,6 +82,10 @@ declare module "./wasm/wasm_utxo.js" {
         validateSignatureAtInput(inputIndex: number, pubkey: Uint8Array): boolean;
         verifySignatureWithKey(inputIndex: number, key: WasmBIP32): boolean;
         extractTransaction(): WasmTransaction;
+        addInputAtIndex(index: number, txid: string, vout: number, value: bigint, script: Uint8Array, sequence?: number): number;
+        addOutputAtIndex(index: number, script: Uint8Array, value: bigint): number;
+        removeInput(index: number): void;
+        removeOutput(index: number): void;
         unsignedTxId(): string;
         lockTime(): number;
         version(): number;
@@ -91,4 +95,4 @@ export { WrapDescriptor as Descriptor } from "./wasm/wasm_utxo.js";
 export { WrapMiniscript as Miniscript } from "./wasm/wasm_utxo.js";
 export { WrapPsbt as Psbt } from "./wasm/wasm_utxo.js";
 export { DashTransaction, Transaction, ZcashTransaction } from "./transaction.js";
-export { hasPsbtMagic, type IPsbtIntrospection, type IPsbtIntrospectionWithAddress, } from "./psbt.js";
+export { hasPsbtMagic, type IPsbt, type IPsbtWithAddress } from "./psbt.js";

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

@@ -0,0 +1,105 @@
+/**
+ * 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 type { CoinName } from "../coinName.js";
+/** Re-export CoinName for convenience */
+export type { CoinName };
+/** All supported networks in order of parsing priority */
+export declare const allNetworks: CoinName[];
+/**
+ * Primitive value types that can appear in a Node.
+ * Buffer values are hex-encoded strings, Integer is a decimal string for BigInt support.
+ */
+export type PrimitiveType = "String" | "Buffer" | "Integer" | "U8" | "U16" | "U32" | "U64" | "I8" | "I16" | "I32" | "I64" | "Boolean" | "None";
+/**
+ * A tagged union representing primitive values in the parse tree.
+ */
+export interface Primitive {
+    type: PrimitiveType;
+    value?: string | number | boolean;
+}
+/**
+ * A node in the parse tree representing a PSBT or transaction element.
+ */
+export interface Node {
+    label: string;
+    value: Primitive;
+    children: Node[];
+}
+/**
+ * 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 declare function parsePsbtToNode(psbtBytes: Uint8Array, network: CoinName): Node;
+/**
+ * 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 declare function parseTxToNode(txBytes: Uint8Array, network: CoinName): Node;
+/**
+ * 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 declare function tryParsePsbt(psbtBytes: Uint8Array, networks?: CoinName[]): {
+    node: Node;
+    network: CoinName;
+} | 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 declare function tryParseTx(txBytes: Uint8Array, networks?: CoinName[]): {
+    node: Node;
+    network: CoinName;
+} | 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 declare function parsePsbtRawToNode(psbtBytes: Uint8Array, network: CoinName): Node;
+/**
+ * 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 declare function tryParsePsbtRaw(psbtBytes: Uint8Array, networks?: CoinName[]): {
+    node: Node;
+    network: CoinName;
+} | null;
+/**
+ * Check if the inspect feature is enabled in the WASM build.
+ *
+ * @returns true if the feature is enabled, false otherwise
+ */
+export declare function isInspectEnabled(): boolean;

package/dist/cjs/js/inspect/index.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * 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"`
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allNetworks = void 0;
+exports.parsePsbtToNode = parsePsbtToNode;
+exports.parseTxToNode = parseTxToNode;
+exports.tryParsePsbt = tryParsePsbt;
+exports.tryParseTx = tryParseTx;
+exports.parsePsbtRawToNode = parsePsbtRawToNode;
+exports.tryParsePsbtRaw = tryParsePsbtRaw;
+exports.isInspectEnabled = isInspectEnabled;
+const wasm_utxo_js_1 = require("../wasm/wasm_utxo.js");
+/** All supported networks in order of parsing priority */
+exports.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
+ */
+function parsePsbtToNode(psbtBytes, network) {
+    const json = (0, wasm_utxo_js_1.parsePsbtToJson)(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
+ */
+function parseTxToNode(txBytes, network) {
+    const json = (0, wasm_utxo_js_1.parseTxToJson)(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
+ */
+function tryParsePsbt(psbtBytes, networks = exports.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
+ */
+function tryParseTx(txBytes, networks = exports.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
+ */
+function parsePsbtRawToNode(psbtBytes, network) {
+    const json = (0, wasm_utxo_js_1.parsePsbtRawToJson)(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
+ */
+function tryParsePsbtRaw(psbtBytes, networks = exports.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
+ */
+function isInspectEnabled() {
+    return (0, wasm_utxo_js_1.isInspectEnabled)();
+}

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

@@ -1,13 +1,20 @@
 import type { PsbtInputData, PsbtOutputData, PsbtOutputDataWithAddress } from "./wasm/wasm_utxo.js";
-/** Common interface for PSBT introspection methods */
-export interface IPsbtIntrospection {
-    readonly inputCount: number;
-    readonly outputCount: number;
+/** Common interface for PSBT types */
+export interface IPsbt {
+    inputCount(): number;
+    outputCount(): number;
     getInputs(): PsbtInputData[];
     getOutputs(): PsbtOutputData[];
+    version(): number;
+    lockTime(): number;
+    unsignedTxId(): string;
+    addInputAtIndex(index: number, txid: string, vout: number, value: bigint, script: Uint8Array, sequence?: number): number;
+    addOutputAtIndex(index: number, script: Uint8Array, value: bigint): number;
+    removeInput(index: number): void;
+    removeOutput(index: number): void;
 }
-/** Extended introspection with address resolution (no coin parameter needed) */
-export interface IPsbtIntrospectionWithAddress extends IPsbtIntrospection {
+/** Extended PSBT with address resolution (no coin parameter needed) */
+export interface IPsbtWithAddress extends IPsbt {
     getOutputsWithAddress(): PsbtOutputDataWithAddress[];
 }
 /**

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

@@ -30,13 +30,9 @@ export declare class Transaction implements ITransaction {
      * @param sequence - Optional sequence number (default: 0xFFFFFFFF)
      * @returns The index of the newly added input
      */
+    addInputAtIndex(index: number, txid: string, vout: number, sequence?: number): number;
     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
-     */
+    addOutputAtIndex(index: number, script: Uint8Array, value: bigint): number;
     addOutput(script: Uint8Array, value: bigint): number;
     toBytes(): Uint8Array;
     /**

package/dist/cjs/js/transaction.js

@@ -34,15 +34,15 @@ class Transaction {
      * @param sequence - Optional sequence number (default: 0xFFFFFFFF)
      * @returns The index of the newly added input
      */
+    addInputAtIndex(index, txid, vout, sequence) {
+        return this._wasm.add_input_at_index(index, txid, vout, sequence);
+    }
     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
-     */
+    addOutputAtIndex(index, script, value) {
+        return this._wasm.add_output_at_index(index, script, value);
+    }
     addOutput(script, value) {
         return this._wasm.add_output(script, value);
     }