@bitgo/wasm-utxo 1.5.0 → 1.7.0

package/dist/cjs/js/{fixedScriptWallet.d.ts → fixedScriptWallet/BitGoPsbt.d.ts}

@@ -1,44 +1,21 @@
-import type { UtxolibName, UtxolibNetwork, UtxolibRootWalletKeys } from "./utxolibCompat.js";
-import type { CoinName } from "./coinName.js";
-import { Triple } from "./triple.js";
-import { AddressFormat } from "./address.js";
+import { type WalletKeysArg } from "./RootWalletKeys.js";
+import { type ReplayProtectionArg } from "./ReplayProtection.js";
+import { type BIP32Arg } from "../bip32.js";
+import { type ECPairArg } from "../ecpair.js";
+import type { UtxolibName } from "../utxolibCompat.js";
+import type { CoinName } from "../coinName.js";
 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 InputScriptType = "p2shP2pk" | "p2sh" | "p2shP2wsh" | "p2wsh" | "p2trLegacy" | "p2trMusig2ScriptPath" | "p2trMusig2KeyPath";
 export type ParsedInput = {
     address: string;
     script: Uint8Array;
     value: bigint;
     scriptId: ScriptId | null;
+    scriptType: InputScriptType;
 };
 export type ParsedOutput = {
     address: string | null;
@@ -74,7 +51,7 @@ export declare class BitGoPsbt {
      * @param replayProtection - Scripts that are allowed as inputs without wallet validation
      * @returns Parsed transaction information
      */
-    parseTransactionWithWalletKeys(walletKeys: WalletKeys, replayProtection: ReplayProtection): ParsedTransaction;
+    parseTransactionWithWalletKeys(walletKeys: WalletKeysArg, replayProtection: ReplayProtectionArg): ParsedTransaction;
     /**
      * Parse outputs with wallet keys to identify which outputs belong to a wallet
      * with the given wallet keys.
@@ -86,23 +63,46 @@ export declare class BitGoPsbt {
      * @returns Array of parsed outputs
      * @note This method does NOT validate wallet inputs. It only parses outputs.
      */
-    parseOutputsWithWalletKeys(walletKeys: WalletKeys): ParsedOutput[];
+    parseOutputsWithWalletKeys(walletKeys: WalletKeysArg): ParsedOutput[];
     /**
-     * Verify if a valid signature exists for a given extended public key at the specified input index.
+     * Verify if a valid signature exists for a given key at the specified input index.
+     *
+     * This method can verify signatures using either:
+     * - Extended public key (xpub): Derives the public key using the derivation path from PSBT
+     * - ECPair (private key): Extracts the public key and verifies directly
      *
-     * This method derives the public key from the xpub using the derivation path found in the
-     * PSBT input, then verifies the signature. It supports:
+     * When using xpub, it supports:
      * - ECDSA signatures (for legacy/SegWit inputs)
      * - Schnorr signatures (for Taproot script path inputs)
      * - MuSig2 partial signatures (for Taproot keypath MuSig2 inputs)
      *
+     * When using ECPair, it supports:
+     * - ECDSA signatures (for legacy/SegWit inputs)
+     * - Schnorr signatures (for Taproot script path inputs)
+     * Note: MuSig2 inputs require xpubs for derivation
+     *
      * @param inputIndex - The index of the input to check (0-based)
-     * @param xpub - The extended public key as a base58-encoded string
+     * @param key - Either an extended public key (base58 string, BIP32 instance, or WasmBIP32) or an ECPair (private key Buffer, ECPair instance, or WasmECPair)
      * @returns true if a valid signature exists, false if no signature exists
-     * @throws Error if input index is out of bounds, xpub is invalid, or verification fails
+     * @throws Error if input index is out of bounds, key is invalid, or verification fails
+     *
+     * @example
+     * ```typescript
+     * // Verify wallet input signature with xpub
+     * const hasUserSig = psbt.verifySignature(0, userXpub);
+     *
+     * // Verify signature with ECPair (private key)
+     * const ecpair = ECPair.fromPrivateKey(privateKeyBuffer);
+     * const hasReplaySig = psbt.verifySignature(1, ecpair);
+     *
+     * // Or pass private key directly
+     * const hasReplaySig2 = psbt.verifySignature(1, privateKeyBuffer);
+     * ```
      */
-    verifySignature(inputIndex: number, xpub: string): boolean;
+    verifySignature(inputIndex: number, key: BIP32Arg | ECPairArg): boolean;
     /**
+     * @deprecated - use verifySignature with the replay protection key instead
+     *
      * Verify if a replay protection input has a valid signature.
      *
      * This method checks if a given input is a replay protection input (like P2shP2pk) and verifies
@@ -120,7 +120,7 @@ export declare class BitGoPsbt {
      * @returns true if the input is a replay protection input and has a valid signature, false if no valid signature
      * @throws Error if the input is not a replay protection input, index is out of bounds, or scripts are invalid
      */
-    verifyReplayProtectionSignature(inputIndex: number, replayProtection: ReplayProtection): boolean;
+    verifyReplayProtectionSignature(inputIndex: number, replayProtection: ReplayProtectionArg): boolean;
     /**
      * Serialize the PSBT to bytes
      *
@@ -141,4 +141,3 @@ export declare class BitGoPsbt {
      */
     extractTransaction(): Uint8Array;
 }
-export {};

package/dist/cjs/js/{fixedScriptWallet.js → fixedScriptWallet/BitGoPsbt.js}

@@ -1,31 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BitGoPsbt = void 0;
-exports.outputScript = outputScript;
-exports.address = address;
-const wasm_utxo_js_1 = require("./wasm/wasm_utxo.js");
-/**
- * Create the output script for a given wallet keys and chain and index
- */
-function outputScript(keys, chain, index, network) {
-    return wasm_utxo_js_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_js_1.FixedScriptWalletNamespace.address(keys, chain, index, network, addressFormat);
-}
-const wasm_utxo_js_2 = require("./wasm/wasm_utxo.js");
+const wasm_utxo_js_1 = require("../wasm/wasm_utxo.js");
+const RootWalletKeys_js_1 = require("./RootWalletKeys.js");
+const ReplayProtection_js_1 = require("./ReplayProtection.js");
+const bip32_js_1 = require("../bip32.js");
+const ecpair_js_1 = require("../ecpair.js");
 class BitGoPsbt {
     wasm;
     constructor(wasm) {
@@ -38,7 +18,7 @@ class BitGoPsbt {
      * @returns A BitGoPsbt instance
      */
     static fromBytes(bytes, network) {
-        const wasm = wasm_utxo_js_2.BitGoPsbt.from_bytes(bytes, network);
+        const wasm = wasm_utxo_js_1.BitGoPsbt.from_bytes(bytes, network);
         return new BitGoPsbt(wasm);
     }
     /**
@@ -55,7 +35,9 @@ class BitGoPsbt {
      * @returns Parsed transaction information
      */
     parseTransactionWithWalletKeys(walletKeys, replayProtection) {
-        return this.wasm.parse_transaction_with_wallet_keys(walletKeys, replayProtection);
+        const keys = RootWalletKeys_js_1.RootWalletKeys.from(walletKeys);
+        const rp = ReplayProtection_js_1.ReplayProtection.from(replayProtection, this.wasm.network());
+        return this.wasm.parse_transaction_with_wallet_keys(keys.wasm, rp.wasm);
     }
     /**
      * Parse outputs with wallet keys to identify which outputs belong to a wallet
@@ -69,26 +51,57 @@ class BitGoPsbt {
      * @note This method does NOT validate wallet inputs. It only parses outputs.
      */
     parseOutputsWithWalletKeys(walletKeys) {
-        return this.wasm.parse_outputs_with_wallet_keys(walletKeys);
+        const keys = RootWalletKeys_js_1.RootWalletKeys.from(walletKeys);
+        return this.wasm.parse_outputs_with_wallet_keys(keys.wasm);
     }
     /**
-     * Verify if a valid signature exists for a given extended public key at the specified input index.
+     * Verify if a valid signature exists for a given key at the specified input index.
+     *
+     * This method can verify signatures using either:
+     * - Extended public key (xpub): Derives the public key using the derivation path from PSBT
+     * - ECPair (private key): Extracts the public key and verifies directly
      *
-     * This method derives the public key from the xpub using the derivation path found in the
-     * PSBT input, then verifies the signature. It supports:
+     * When using xpub, it supports:
      * - ECDSA signatures (for legacy/SegWit inputs)
      * - Schnorr signatures (for Taproot script path inputs)
      * - MuSig2 partial signatures (for Taproot keypath MuSig2 inputs)
      *
+     * When using ECPair, it supports:
+     * - ECDSA signatures (for legacy/SegWit inputs)
+     * - Schnorr signatures (for Taproot script path inputs)
+     * Note: MuSig2 inputs require xpubs for derivation
+     *
      * @param inputIndex - The index of the input to check (0-based)
-     * @param xpub - The extended public key as a base58-encoded string
+     * @param key - Either an extended public key (base58 string, BIP32 instance, or WasmBIP32) or an ECPair (private key Buffer, ECPair instance, or WasmECPair)
      * @returns true if a valid signature exists, false if no signature exists
-     * @throws Error if input index is out of bounds, xpub is invalid, or verification fails
+     * @throws Error if input index is out of bounds, key is invalid, or verification fails
+     *
+     * @example
+     * ```typescript
+     * // Verify wallet input signature with xpub
+     * const hasUserSig = psbt.verifySignature(0, userXpub);
+     *
+     * // Verify signature with ECPair (private key)
+     * const ecpair = ECPair.fromPrivateKey(privateKeyBuffer);
+     * const hasReplaySig = psbt.verifySignature(1, ecpair);
+     *
+     * // Or pass private key directly
+     * const hasReplaySig2 = psbt.verifySignature(1, privateKeyBuffer);
+     * ```
      */
-    verifySignature(inputIndex, xpub) {
-        return this.wasm.verify_signature(inputIndex, xpub);
+    verifySignature(inputIndex, key) {
+        // Try to parse as BIP32Arg first (string or BIP32 instance)
+        if (typeof key === "string" || ("derive" in key && typeof key.derive === "function")) {
+            const wasmKey = bip32_js_1.BIP32.from(key).wasm;
+            return this.wasm.verify_signature_with_xpub(inputIndex, wasmKey);
+        }
+        // Otherwise it's an ECPairArg (Uint8Array, ECPair, or WasmECPair)
+        const wasmECPair = ecpair_js_1.ECPair.from(key).wasm;
+        return this.wasm.verify_signature_with_pub(inputIndex, wasmECPair);
     }
     /**
+     * @deprecated - use verifySignature with the replay protection key instead
+     *
      * Verify if a replay protection input has a valid signature.
      *
      * This method checks if a given input is a replay protection input (like P2shP2pk) and verifies
@@ -107,7 +120,8 @@ class BitGoPsbt {
      * @throws Error if the input is not a replay protection input, index is out of bounds, or scripts are invalid
      */
     verifyReplayProtectionSignature(inputIndex, replayProtection) {
-        return this.wasm.verify_replay_protection_signature(inputIndex, replayProtection);
+        const rp = ReplayProtection_js_1.ReplayProtection.from(replayProtection, this.wasm.network());
+        return this.wasm.verify_replay_protection_signature(inputIndex, rp.wasm);
     }
     /**
      * Serialize the PSBT to bytes

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

@@ -0,0 +1,58 @@
+import { WasmReplayProtection } from "../wasm/wasm_utxo.js";
+import { type ECPairArg } from "../ecpair.js";
+/**
+ * ReplayProtectionArg represents the various forms that replay protection can take
+ * before being converted to a WasmReplayProtection instance
+ */
+export type ReplayProtectionArg = ReplayProtection | WasmReplayProtection | {
+    publicKeys: ECPairArg[];
+} | {
+    /** @deprecated - use publicKeys instead */
+    outputScripts: Uint8Array[];
+} | {
+    /** @deprecated - use publicKeys instead */
+    addresses: string[];
+};
+/**
+ * ReplayProtection wrapper class for PSBT replay protection inputs
+ */
+export declare class ReplayProtection {
+    private _wasm;
+    private constructor();
+    /**
+     * Create a ReplayProtection instance from a WasmReplayProtection instance (internal use)
+     * @internal
+     */
+    static fromWasm(wasm: WasmReplayProtection): ReplayProtection;
+    /**
+     * Convert ReplayProtectionArg to ReplayProtection instance
+     * @param arg - The replay protection in various formats
+     * @param network - Optional network string (required for addresses variant)
+     * @returns ReplayProtection instance
+     */
+    static from(arg: ReplayProtectionArg, network?: string): ReplayProtection;
+    /**
+     * Create from public keys (derives P2SH-P2PK output scripts)
+     * @param publicKeys - Array of ECPair instances or arguments
+     * @returns ReplayProtection instance
+     */
+    static fromPublicKeys(publicKeys: ECPairArg[]): ReplayProtection;
+    /**
+     * Create from output scripts
+     * @param outputScripts - Array of output script buffers
+     * @returns ReplayProtection instance
+     */
+    static fromOutputScripts(outputScripts: Uint8Array[]): ReplayProtection;
+    /**
+     * Create from addresses
+     * @param addresses - Array of address strings
+     * @param network - Network string (e.g., "bitcoin", "testnet", "btc", "tbtc")
+     * @returns ReplayProtection instance
+     */
+    static fromAddresses(addresses: string[], network: string): ReplayProtection;
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm(): WasmReplayProtection;
+}

package/dist/cjs/js/fixedScriptWallet/ReplayProtection.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayProtection = void 0;
+const wasm_utxo_js_1 = require("../wasm/wasm_utxo.js");
+const ecpair_js_1 = require("../ecpair.js");
+/**
+ * ReplayProtection wrapper class for PSBT replay protection inputs
+ */
+class ReplayProtection {
+    _wasm;
+    constructor(_wasm) {
+        this._wasm = _wasm;
+    }
+    /**
+     * Create a ReplayProtection instance from a WasmReplayProtection instance (internal use)
+     * @internal
+     */
+    static fromWasm(wasm) {
+        return new ReplayProtection(wasm);
+    }
+    /**
+     * Convert ReplayProtectionArg to ReplayProtection instance
+     * @param arg - The replay protection in various formats
+     * @param network - Optional network string (required for addresses variant)
+     * @returns ReplayProtection instance
+     */
+    static from(arg, network) {
+        // Short-circuit if already a ReplayProtection instance
+        if (arg instanceof ReplayProtection) {
+            return arg;
+        }
+        // If it's a WasmReplayProtection instance, wrap it
+        if (arg instanceof wasm_utxo_js_1.WasmReplayProtection) {
+            return new ReplayProtection(arg);
+        }
+        // Handle object variants
+        if ("publicKeys" in arg) {
+            // Convert ECPairArg to public key bytes
+            const publicKeyBytes = arg.publicKeys.map((key) => ecpair_js_1.ECPair.from(key).publicKey);
+            const wasm = wasm_utxo_js_1.WasmReplayProtection.from_public_keys(publicKeyBytes);
+            return new ReplayProtection(wasm);
+        }
+        if ("outputScripts" in arg) {
+            const wasm = wasm_utxo_js_1.WasmReplayProtection.from_output_scripts(arg.outputScripts);
+            return new ReplayProtection(wasm);
+        }
+        if ("addresses" in arg) {
+            if (!network) {
+                throw new Error("Network is required when using addresses variant");
+            }
+            const wasm = wasm_utxo_js_1.WasmReplayProtection.from_addresses(arg.addresses, network);
+            return new ReplayProtection(wasm);
+        }
+        throw new Error("Invalid ReplayProtectionArg type");
+    }
+    /**
+     * Create from public keys (derives P2SH-P2PK output scripts)
+     * @param publicKeys - Array of ECPair instances or arguments
+     * @returns ReplayProtection instance
+     */
+    static fromPublicKeys(publicKeys) {
+        return ReplayProtection.from({ publicKeys });
+    }
+    /**
+     * Create from output scripts
+     * @param outputScripts - Array of output script buffers
+     * @returns ReplayProtection instance
+     */
+    static fromOutputScripts(outputScripts) {
+        return ReplayProtection.from({ outputScripts });
+    }
+    /**
+     * Create from addresses
+     * @param addresses - Array of address strings
+     * @param network - Network string (e.g., "bitcoin", "testnet", "btc", "tbtc")
+     * @returns ReplayProtection instance
+     */
+    static fromAddresses(addresses, network) {
+        return ReplayProtection.from({ addresses }, network);
+    }
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm() {
+        return this._wasm;
+    }
+}
+exports.ReplayProtection = ReplayProtection;

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

@@ -0,0 +1,66 @@
+import type { BIP32Interface } from "../bip32.js";
+import { BIP32 } from "../bip32.js";
+import { Triple } from "../triple.js";
+import { WasmRootWalletKeys } from "../wasm/wasm_utxo.js";
+/**
+ * IWalletKeys represents the various forms that wallet keys can take
+ * before being converted to a RootWalletKeys instance
+ */
+export type IWalletKeys = {
+    triple: Triple<BIP32Interface>;
+    derivationPrefixes: Triple<string>;
+};
+export type WalletKeysArg = 
+/** Just an xpub triple, will assume default derivation prefixes  */
+Triple<string>
+/** Compatible with utxolib RootWalletKeys */
+ | IWalletKeys
+/** RootWalletKeys instance */
+ | RootWalletKeys;
+/**
+ * RootWalletKeys represents a set of three extended public keys with their derivation prefixes
+ */
+export declare class RootWalletKeys {
+    private _wasm;
+    private constructor();
+    /**
+     * Create a RootWalletKeys from various input formats
+     * @param keys - Can be a triple of xpub strings, an IWalletKeys object, or another RootWalletKeys instance
+     * @returns A RootWalletKeys instance
+     */
+    static from(keys: WalletKeysArg): RootWalletKeys;
+    /**
+     * Create a RootWalletKeys from three xpub strings
+     * Uses default derivation prefix of m/0/0 for all three keys
+     * @param xpubs - Triple of xpub strings
+     * @returns A RootWalletKeys instance
+     */
+    static fromXpubs(xpubs: Triple<string>): RootWalletKeys;
+    /**
+     * Create a RootWalletKeys from three xpub strings with custom derivation prefixes
+     * @param xpubs - Triple of xpub strings
+     * @param derivationPrefixes - Triple of derivation path strings (e.g., ["0/0", "0/0", "0/0"])
+     * @returns A RootWalletKeys instance
+     */
+    static withDerivationPrefixes(xpubs: Triple<string>, derivationPrefixes: Triple<string>): RootWalletKeys;
+    /**
+     * Get the user key (first xpub)
+     * @returns The user key as a BIP32 instance
+     */
+    userKey(): BIP32;
+    /**
+     * Get the backup key (second xpub)
+     * @returns The backup key as a BIP32 instance
+     */
+    backupKey(): BIP32;
+    /**
+     * Get the BitGo key (third xpub)
+     * @returns The BitGo key as a BIP32 instance
+     */
+    bitgoKey(): BIP32;
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm(): WasmRootWalletKeys;
+}

package/dist/cjs/js/fixedScriptWallet/RootWalletKeys.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootWalletKeys = void 0;
+const bip32_js_1 = require("../bip32.js");
+const wasm_utxo_js_1 = require("../wasm/wasm_utxo.js");
+/**
+ * Convert WalletKeysArg to a triple of BIP32 instances
+ */
+function toBIP32Triple(keys) {
+    if (keys instanceof RootWalletKeys) {
+        return [keys.userKey(), keys.backupKey(), keys.bitgoKey()];
+    }
+    // Check if it's an IWalletKeys object
+    if (typeof keys === "object" && "triple" in keys) {
+        // Extract BIP32 keys from the triple
+        return keys.triple.map((key) => bip32_js_1.BIP32.from(key));
+    }
+    // Otherwise it's a triple of strings (xpubs)
+    return keys.map((xpub) => bip32_js_1.BIP32.fromWasm(wasm_utxo_js_1.WasmBIP32.from_xpub(xpub)));
+}
+/**
+ * Extract derivation prefixes from WalletKeysArg, if present
+ */
+function extractDerivationPrefixes(keys) {
+    if (typeof keys === "object" && "derivationPrefixes" in keys) {
+        return keys.derivationPrefixes;
+    }
+    return null;
+}
+/**
+ * RootWalletKeys represents a set of three extended public keys with their derivation prefixes
+ */
+class RootWalletKeys {
+    _wasm;
+    constructor(_wasm) {
+        this._wasm = _wasm;
+    }
+    /**
+     * Create a RootWalletKeys from various input formats
+     * @param keys - Can be a triple of xpub strings, an IWalletKeys object, or another RootWalletKeys instance
+     * @returns A RootWalletKeys instance
+     */
+    static from(keys) {
+        if (keys instanceof RootWalletKeys) {
+            return keys;
+        }
+        const [user, backup, bitgo] = toBIP32Triple(keys);
+        const derivationPrefixes = extractDerivationPrefixes(keys);
+        const wasm = derivationPrefixes
+            ? wasm_utxo_js_1.WasmRootWalletKeys.with_derivation_prefixes(user.wasm, backup.wasm, bitgo.wasm, derivationPrefixes[0], derivationPrefixes[1], derivationPrefixes[2])
+            : new wasm_utxo_js_1.WasmRootWalletKeys(user.wasm, backup.wasm, bitgo.wasm);
+        return new RootWalletKeys(wasm);
+    }
+    /**
+     * Create a RootWalletKeys from three xpub strings
+     * Uses default derivation prefix of m/0/0 for all three keys
+     * @param xpubs - Triple of xpub strings
+     * @returns A RootWalletKeys instance
+     */
+    static fromXpubs(xpubs) {
+        const [user, backup, bitgo] = xpubs.map((xpub) => wasm_utxo_js_1.WasmBIP32.from_xpub(xpub));
+        const wasm = new wasm_utxo_js_1.WasmRootWalletKeys(user, backup, bitgo);
+        return new RootWalletKeys(wasm);
+    }
+    /**
+     * Create a RootWalletKeys from three xpub strings with custom derivation prefixes
+     * @param xpubs - Triple of xpub strings
+     * @param derivationPrefixes - Triple of derivation path strings (e.g., ["0/0", "0/0", "0/0"])
+     * @returns A RootWalletKeys instance
+     */
+    static withDerivationPrefixes(xpubs, derivationPrefixes) {
+        const [user, backup, bitgo] = xpubs.map((xpub) => wasm_utxo_js_1.WasmBIP32.from_xpub(xpub));
+        const wasm = wasm_utxo_js_1.WasmRootWalletKeys.with_derivation_prefixes(user, backup, bitgo, derivationPrefixes[0], derivationPrefixes[1], derivationPrefixes[2]);
+        return new RootWalletKeys(wasm);
+    }
+    /**
+     * Get the user key (first xpub)
+     * @returns The user key as a BIP32 instance
+     */
+    userKey() {
+        const wasm = this._wasm.user_key();
+        return bip32_js_1.BIP32.fromWasm(wasm);
+    }
+    /**
+     * Get the backup key (second xpub)
+     * @returns The backup key as a BIP32 instance
+     */
+    backupKey() {
+        const wasm = this._wasm.backup_key();
+        return bip32_js_1.BIP32.fromWasm(wasm);
+    }
+    /**
+     * Get the BitGo key (third xpub)
+     * @returns The BitGo key as a BIP32 instance
+     */
+    bitgoKey() {
+        const wasm = this._wasm.bitgo_key();
+        return bip32_js_1.BIP32.fromWasm(wasm);
+    }
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm() {
+        return this._wasm;
+    }
+}
+exports.RootWalletKeys = RootWalletKeys;

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

@@ -0,0 +1,20 @@
+import { type WalletKeysArg } from "./RootWalletKeys.js";
+import type { UtxolibNetwork } from "../utxolibCompat.js";
+import { AddressFormat } from "../address.js";
+/**
+ * Create the output script for a given wallet keys and chain and index
+ */
+export declare function outputScript(keys: WalletKeysArg, 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: WalletKeysArg, chain: number, index: number, network: UtxolibNetwork, addressFormat?: AddressFormat): string;

package/dist/cjs/js/fixedScriptWallet/address.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputScript = outputScript;
+exports.address = address;
+const wasm_utxo_js_1 = require("../wasm/wasm_utxo.js");
+const RootWalletKeys_js_1 = require("./RootWalletKeys.js");
+/**
+ * Create the output script for a given wallet keys and chain and index
+ */
+function outputScript(keys, chain, index, network) {
+    const walletKeys = RootWalletKeys_js_1.RootWalletKeys.from(keys);
+    return wasm_utxo_js_1.FixedScriptWalletNamespace.output_script(walletKeys.wasm, 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) {
+    const walletKeys = RootWalletKeys_js_1.RootWalletKeys.from(keys);
+    return wasm_utxo_js_1.FixedScriptWalletNamespace.address(walletKeys.wasm, chain, index, network, addressFormat);
+}

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

@@ -0,0 +1,4 @@
+export { RootWalletKeys, type WalletKeysArg, type IWalletKeys } from "./RootWalletKeys.js";
+export { ReplayProtection, type ReplayProtectionArg } from "./ReplayProtection.js";
+export { outputScript, address } from "./address.js";
+export { BitGoPsbt, type NetworkName, type ScriptId, type InputScriptType, type ParsedInput, type ParsedOutput, type ParsedTransaction, } from "./BitGoPsbt.js";

package/dist/cjs/js/fixedScriptWallet/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitGoPsbt = exports.address = exports.outputScript = exports.ReplayProtection = exports.RootWalletKeys = void 0;
+var RootWalletKeys_js_1 = require("./RootWalletKeys.js");
+Object.defineProperty(exports, "RootWalletKeys", { enumerable: true, get: function () { return RootWalletKeys_js_1.RootWalletKeys; } });
+var ReplayProtection_js_1 = require("./ReplayProtection.js");
+Object.defineProperty(exports, "ReplayProtection", { enumerable: true, get: function () { return ReplayProtection_js_1.ReplayProtection; } });
+var address_js_1 = require("./address.js");
+Object.defineProperty(exports, "outputScript", { enumerable: true, get: function () { return address_js_1.outputScript; } });
+Object.defineProperty(exports, "address", { enumerable: true, get: function () { return address_js_1.address; } });
+var BitGoPsbt_js_1 = require("./BitGoPsbt.js");
+Object.defineProperty(exports, "BitGoPsbt", { enumerable: true, get: function () { return BitGoPsbt_js_1.BitGoPsbt; } });

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

@@ -1,7 +1,11 @@
 export * as address from "./address.js";
 export * as ast from "./ast/index.js";
 export * as utxolibCompat from "./utxolibCompat.js";
-export * as fixedScriptWallet from "./fixedScriptWallet.js";
+export * as fixedScriptWallet from "./fixedScriptWallet/index.js";
+export * as bip32 from "./bip32.js";
+export * as ecpair from "./ecpair.js";
+export { ECPair } from "./ecpair.js";
+export { BIP32 } from "./bip32.js";
 export type { CoinName } from "./coinName.js";
 export type { Triple } from "./triple.js";
 export type { AddressFormat } from "./address.js";