@bitgo/wasm-utxo 1.8.0 → 1.10.0

package/dist/esm/test/descriptorUtil.js

@@ -1,52 +0,0 @@
-import * as assert from "node:assert";
-import * as fs from "fs/promises";
-import * as utxolib from "@bitgo/utxo-lib";
-import { formatNode } from "../js/ast/index.js";
-async function assertEqualJSON(path, value) {
-    try {
-        const data = JSON.parse(await fs.readFile(path, "utf8"));
-        assert.deepStrictEqual(data, value);
-    }
-    catch (e) {
-        if (typeof e === "object" && e !== null && "code" in e && e.code === "ENOENT") {
-            await fs.writeFile(path, JSON.stringify(value, null, 2));
-            throw new Error("Expected file not found, wrote it instead");
-        }
-        throw e;
-    }
-}
-export async function assertEqualFixture(path, content) {
-    await assertEqualJSON(path, content);
-}
-/** Expand a template with the given root wallet keys and chain code */
-function expand(rootWalletKeys, keyIndex, chainCode) {
-    if (keyIndex !== 0 && keyIndex !== 1 && keyIndex !== 2) {
-        throw new Error("Invalid key index");
-    }
-    const xpub = rootWalletKeys.triple[keyIndex].neutered().toBase58();
-    const prefix = rootWalletKeys.derivationPrefixes[keyIndex];
-    return xpub + "/" + prefix + "/" + chainCode + "/*";
-}
-/**
- * Get a standard output descriptor that corresponds to the proprietary HD wallet setup
- * used in BitGo wallets.
- * Only supports a subset of script types.
- */
-export function getDescriptorForScriptType(rootWalletKeys, scriptType, scope) {
-    const chain = scope === "external"
-        ? utxolib.bitgo.getExternalChainCode(scriptType)
-        : utxolib.bitgo.getInternalChainCode(scriptType);
-    const multi = {
-        multi: [2, ...rootWalletKeys.triple.map((_, i) => expand(rootWalletKeys, i, chain))],
-    };
-    switch (scriptType) {
-        case "p2sh":
-            return formatNode({ sh: multi });
-        case "p2shP2wsh":
-            return formatNode({ sh: { wsh: multi } });
-        case "p2wsh":
-            return formatNode({ wsh: multi });
-        default:
-            throw new Error(`Unsupported script type ${scriptType}`);
-    }
-}

package/dist/esm/test/ecpair.d.ts

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

package/dist/esm/test/ecpair.js

@@ -1,137 +0,0 @@
-import * as assert from "assert";
-import { ECPair } from "../js/ecpair.js";
-describe("WasmECPair", () => {
-    const testPrivateKey = Buffer.from("1111111111111111111111111111111111111111111111111111111111111111", "hex");
-    const testWifMainnet = "KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn";
-    const testWifTestnet = "cMahea7zqjxrtgAbB7LSGbcQUr1uX1ojuat9jZodMN87JcbXMTcA";
-    it("should create from private key", () => {
-        const key = ECPair.fromPrivateKey(testPrivateKey);
-        assert.ok(key.privateKey instanceof Uint8Array);
-        assert.ok(key.publicKey instanceof Uint8Array);
-        assert.strictEqual(key.privateKey.length, 32);
-        assert.strictEqual(key.publicKey.length, 33); // Always compressed
-    });
-    it("should create from public key", () => {
-        const tempKey = ECPair.fromPrivateKey(testPrivateKey);
-        const publicKey = tempKey.publicKey;
-        const key = ECPair.fromPublicKey(publicKey);
-        assert.strictEqual(key.privateKey, undefined);
-        assert.ok(key.publicKey instanceof Uint8Array);
-        assert.strictEqual(key.publicKey.length, 33);
-    });
-    it("should create from mainnet WIF", () => {
-        const key = ECPair.fromWIF(testWifMainnet);
-        assert.ok(key.privateKey instanceof Uint8Array);
-        assert.ok(key.publicKey instanceof Uint8Array);
-        assert.strictEqual(key.privateKey.length, 32);
-    });
-    it("should create from testnet WIF", () => {
-        const key = ECPair.fromWIF(testWifTestnet);
-        assert.ok(key.privateKey instanceof Uint8Array);
-        assert.ok(key.publicKey instanceof Uint8Array);
-        assert.strictEqual(key.privateKey.length, 32);
-    });
-    it("should create from mainnet WIF using fromWIFMainnet", () => {
-        const key = ECPair.fromWIFMainnet(testWifMainnet);
-        assert.ok(key.privateKey instanceof Uint8Array);
-        assert.ok(key.publicKey instanceof Uint8Array);
-    });
-    it("should create from testnet WIF using fromWIFTestnet", () => {
-        const key = ECPair.fromWIFTestnet(testWifTestnet);
-        assert.ok(key.privateKey instanceof Uint8Array);
-        assert.ok(key.publicKey instanceof Uint8Array);
-    });
-    it("should fail when using wrong network WIF method", () => {
-        assert.throws(() => {
-            ECPair.fromWIFMainnet(testWifTestnet);
-        });
-        assert.throws(() => {
-            ECPair.fromWIFTestnet(testWifMainnet);
-        });
-    });
-    it("should export to WIF mainnet", () => {
-        const key = ECPair.fromPrivateKey(testPrivateKey);
-        const wif = key.toWIF();
-        assert.ok(typeof wif === "string");
-        assert.ok(wif.length > 0);
-        assert.ok(wif.startsWith("K") || wif.startsWith("L")); // Mainnet compressed
-    });
-    it("should export to WIF testnet", () => {
-        const key = ECPair.fromPrivateKey(testPrivateKey);
-        const wif = key.toWIFTestnet();
-        assert.ok(typeof wif === "string");
-        assert.ok(wif.length > 0);
-        assert.ok(wif.startsWith("c")); // Testnet compressed
-    });
-    it("should roundtrip WIF mainnet", () => {
-        const key1 = ECPair.fromPrivateKey(testPrivateKey);
-        const wif = key1.toWIF();
-        const key2 = ECPair.fromWIF(wif);
-        assert.deepStrictEqual(key1.privateKey, key2.privateKey);
-        assert.deepStrictEqual(key1.publicKey, key2.publicKey);
-    });
-    it("should roundtrip WIF testnet", () => {
-        const key1 = ECPair.fromPrivateKey(testPrivateKey);
-        const wif = key1.toWIFTestnet();
-        const key2 = ECPair.fromWIF(wif);
-        assert.deepStrictEqual(key1.privateKey, key2.privateKey);
-        assert.deepStrictEqual(key1.publicKey, key2.publicKey);
-    });
-    it("should fail to export WIF from public key", () => {
-        const tempKey = ECPair.fromPrivateKey(testPrivateKey);
-        const publicKey = tempKey.publicKey;
-        const key = ECPair.fromPublicKey(publicKey);
-        assert.throws(() => {
-            key.toWIF();
-        });
-        assert.throws(() => {
-            key.toWIFMainnet();
-        });
-        assert.throws(() => {
-            key.toWIFTestnet();
-        });
-    });
-    it("should reject invalid private keys", () => {
-        // All zeros
-        assert.throws(() => {
-            ECPair.fromPrivateKey(new Uint8Array(32));
-        });
-        // Wrong length
-        assert.throws(() => {
-            ECPair.fromPrivateKey(new Uint8Array(31));
-        });
-        assert.throws(() => {
-            ECPair.fromPrivateKey(new Uint8Array(33));
-        });
-    });
-    it("should reject invalid public keys", () => {
-        // Wrong length
-        assert.throws(() => {
-            ECPair.fromPublicKey(new Uint8Array(32));
-        });
-        assert.throws(() => {
-            ECPair.fromPublicKey(new Uint8Array(34));
-        });
-        // Invalid format
-        assert.throws(() => {
-            const invalidPubkey = new Uint8Array(33);
-            invalidPubkey[0] = 0x01; // Invalid prefix
-            ECPair.fromPublicKey(invalidPubkey);
-        });
-    });
-    it("should always produce compressed public keys", () => {
-        const key1 = ECPair.fromPrivateKey(testPrivateKey);
-        const key2 = ECPair.fromWIF(testWifMainnet);
-        // All public keys should be 33 bytes (compressed)
-        assert.strictEqual(key1.publicKey.length, 33);
-        assert.strictEqual(key2.publicKey.length, 33);
-        // All should start with 0x02 or 0x03 (compressed format)
-        assert.ok(key1.publicKey[0] === 0x02 || key1.publicKey[0] === 0x03);
-        assert.ok(key2.publicKey[0] === 0x02 || key2.publicKey[0] === 0x03);
-    });
-    it("should derive same public key from same private key", () => {
-        const key1 = ECPair.fromPrivateKey(testPrivateKey);
-        const key2 = ECPair.fromPrivateKey(testPrivateKey);
-        assert.deepStrictEqual(key1.publicKey, key2.publicKey);
-    });
-});

package/dist/esm/test/fixedScript/address.d.ts

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

package/dist/esm/test/fixedScript/address.js

@@ -1,66 +0,0 @@
-import assert from "node:assert";
-import * as utxolib from "@bitgo/utxo-lib";
-import { fixedScriptWallet } from "../../js/index.js";
-function getAddressUtxoLib(keys, chain, index, network, addressFormat) {
-    if (!utxolib.bitgo.isChainCode(chain)) {
-        throw new Error(`Invalid chain code: ${chain}`);
-    }
-    const derived = keys.deriveForChainAndIndex(chain, index);
-    const script = utxolib.bitgo.outputScripts.createOutputScript2of3(derived.publicKeys, utxolib.bitgo.outputScripts.scriptTypeForChain(chain));
-    const address = utxolib.addressFormat.fromOutputScriptWithFormat(script.scriptPubKey, addressFormat, network);
-    return address;
-}
-function runTest(network, { derivationPrefixes, addressFormat, } = {}) {
-    describe(`address for network ${utxolib.getNetworkName(network)}, derivationPrefixes=${Boolean(derivationPrefixes)}`, function () {
-        const keyTriple = utxolib.testutil.getKeyTriple("wasm");
-        const rootWalletKeys = new utxolib.bitgo.RootWalletKeys(keyTriple.map((k) => k.neutered()), derivationPrefixes);
-        const supportedChainCodes = utxolib.bitgo.chainCodes.filter((chainCode) => {
-            const scriptType = utxolib.bitgo.outputScripts.scriptTypeForChain(chainCode);
-            return utxolib.bitgo.outputScripts.isSupportedScriptType(network, scriptType);
-        });
-        it(`can recreate address from wallet keys for chain codes ${supportedChainCodes.join(", ")}`, function () {
-            for (const chainCode of supportedChainCodes) {
-                for (let index = 0; index < 2; index++) {
-                    const utxolibAddress = getAddressUtxoLib(rootWalletKeys, chainCode, index, network, addressFormat ?? "default");
-                    const wasmAddress = fixedScriptWallet.address(rootWalletKeys, chainCode, index, network, addressFormat);
-                    assert.strictEqual(utxolibAddress, wasmAddress);
-                }
-            }
-        });
-        const unsupportedChainCodes = utxolib.bitgo.chainCodes.filter((chainCode) => {
-            const scriptType = utxolib.bitgo.outputScripts.scriptTypeForChain(chainCode);
-            return !utxolib.bitgo.outputScripts.isSupportedScriptType(network, scriptType);
-        });
-        if (unsupportedChainCodes.length > 0) {
-            it(`throws error for unsupported chain codes ${unsupportedChainCodes.join(", ")}`, function () {
-                for (const chainCode of unsupportedChainCodes) {
-                    const scriptType = utxolib.bitgo.outputScripts.scriptTypeForChain(chainCode);
-                    assert.throws(() => {
-                        fixedScriptWallet.address(rootWalletKeys, chainCode, 0, network, addressFormat);
-                    }, (error) => {
-                        const errorMessage = error.message.toLowerCase();
-                        const isSegwitError = scriptType === "p2shP2wsh" || scriptType === "p2wsh";
-                        const isTaprootError = scriptType === "p2tr" || scriptType === "p2trMusig2";
-                        if (isSegwitError) {
-                            return errorMessage.includes("does not support segwit");
-                        }
-                        else if (isTaprootError) {
-                            return errorMessage.includes("does not support taproot");
-                        }
-                        return false;
-                    }, `Expected error for unsupported script type ${scriptType} on network ${utxolib.getNetworkName(network)}`);
-                }
-            });
-        }
-    });
-}
-describe("address for networks", function () {
-    utxolib.getNetworkList().forEach((network) => {
-        runTest(network);
-        runTest(network, { derivationPrefixes: ["m/1/2", "m/0/0", "m/0/0"] });
-        if (utxolib.getMainnet(network) === utxolib.networks.bitcoincash ||
-            utxolib.getMainnet(network) === utxolib.networks.ecash) {
-            runTest(network, { addressFormat: "cashaddr" });
-        }
-    });
-});

package/dist/esm/test/fixedScript/finalizeExtract.d.ts

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

package/dist/esm/test/fixedScript/finalizeExtract.js

@@ -1,66 +0,0 @@
-import assert from "node:assert";
-import * as utxolib from "@bitgo/utxo-lib";
-import { fixedScriptWallet } from "../../js/index.js";
-import { loadPsbtFixture, getPsbtBuffer, getExtractedTransactionHex, } from "./fixtureUtil.js";
-describe("finalize and extract transaction", function () {
-    const supportedNetworks = utxolib.getNetworkList().filter((network) => {
-        return (utxolib.isMainnet(network) &&
-            network !== utxolib.networks.bitcoincash &&
-            network !== utxolib.networks.bitcoingold &&
-            network !== utxolib.networks.bitcoinsv &&
-            network !== utxolib.networks.ecash &&
-            network !== utxolib.networks.zcash);
-    });
-    supportedNetworks.forEach((network) => {
-        const networkName = utxolib.getNetworkName(network);
-        describe(`network: ${networkName}`, function () {
-            let fullsignedFixture;
-            let fullsignedPsbtBuffer;
-            let fullsignedBitgoPsbt;
-            before(function () {
-                fullsignedFixture = loadPsbtFixture(networkName, "fullsigned");
-                fullsignedPsbtBuffer = getPsbtBuffer(fullsignedFixture);
-                fullsignedBitgoPsbt = fixedScriptWallet.BitGoPsbt.fromBytes(fullsignedPsbtBuffer, networkName);
-            });
-            it("should serialize and deserialize PSBT (round-trip)", function () {
-                const serialized = fullsignedBitgoPsbt.serialize();
-                // Verify we can deserialize what we serialized (functional round-trip)
-                const deserialized = fixedScriptWallet.BitGoPsbt.fromBytes(serialized, networkName);
-                // Verify the deserialized PSBT has the same unsigned txid
-                assert.strictEqual(deserialized.unsignedTxid(), fullsignedBitgoPsbt.unsignedTxid(), "Deserialized PSBT should have same unsigned txid after round-trip");
-                // Verify the re-deserialized PSBT can be serialized back to bytes
-                const reserialized = deserialized.serialize();
-                // Verify functional equivalence by deserializing again and checking txid
-                const redeserialized = fixedScriptWallet.BitGoPsbt.fromBytes(reserialized, networkName);
-                assert.strictEqual(redeserialized.unsignedTxid(), fullsignedBitgoPsbt.unsignedTxid(), "PSBT should maintain consistency through multiple serialize/deserialize cycles");
-            });
-            it("should finalize all inputs and be extractable", function () {
-                // Create a fresh instance for finalization
-                const psbt = fixedScriptWallet.BitGoPsbt.fromBytes(fullsignedPsbtBuffer, networkName);
-                // Finalize all inputs
-                psbt.finalizeAllInputs();
-                // Serialize the finalized PSBT
-                const serialized = psbt.serialize();
-                // Verify we can deserialize the finalized PSBT
-                const deserialized = fixedScriptWallet.BitGoPsbt.fromBytes(serialized, networkName);
-                // Verify it can be extracted (which confirms finalization worked)
-                const extractedTx = deserialized.extractTransaction();
-                const extractedTxHex = Buffer.from(extractedTx).toString("hex");
-                const expectedTxHex = getExtractedTransactionHex(fullsignedFixture);
-                assert.strictEqual(extractedTxHex, expectedTxHex, "Extracted transaction from finalized PSBT should match expected transaction");
-            });
-            it("should extract transaction from finalized PSBT", function () {
-                // Create a fresh instance for extraction
-                const psbt = fixedScriptWallet.BitGoPsbt.fromBytes(fullsignedPsbtBuffer, networkName);
-                // Finalize all inputs
-                psbt.finalizeAllInputs();
-                // Extract transaction
-                const extractedTx = psbt.extractTransaction();
-                const extractedTxHex = Buffer.from(extractedTx).toString("hex");
-                // Get expected transaction hex from fixture
-                const expectedTxHex = getExtractedTransactionHex(fullsignedFixture);
-                assert.strictEqual(extractedTxHex, expectedTxHex, "Extracted transaction should match expected transaction");
-            });
-        });
-    });
-});

package/dist/esm/test/fixedScript/fixtureUtil.d.ts

@@ -1,103 +0,0 @@
-import { RootWalletKeys } from "../../js/fixedScriptWallet/RootWalletKeys.js";
-import { ECPair } from "../../js/ecpair.js";
-import type { BitGoPsbt, NetworkName } from "../../js/fixedScriptWallet/index.js";
-export type SignatureState = "unsigned" | "halfsigned" | "fullsigned";
-export type Triple<T> = [T, T, T];
-export type Bip32Derivation = {
-    masterFingerprint: string;
-    pubkey: string;
-    path: string;
-};
-export type TapBip32Derivation = Bip32Derivation & {
-    leafHashes: string[];
-};
-export type WitnessUtxo = {
-    value: string;
-    script: string;
-};
-export type TapLeafScript = {
-    controlBlock: string;
-    script: string;
-    leafVersion: number;
-};
-export type PsbtInput = {
-    type: string;
-    sighashType: number;
-    redeemScript?: string;
-    witnessScript?: string;
-    bip32Derivation?: Bip32Derivation[];
-    tapBip32Derivation?: TapBip32Derivation[];
-    witnessUtxo?: WitnessUtxo;
-    tapLeafScript?: TapLeafScript[];
-    tapInternalKey?: string;
-    tapMerkleRoot?: string;
-    musig2Participants?: {
-        tapOutputKey: string;
-        tapInternalKey: string;
-        participantPubKeys: string[];
-    };
-    unknownKeyVals?: Array<{
-        key: string;
-        value: string;
-    }>;
-};
-export type Input = {
-    hash: string;
-    index: number;
-    sequence: number;
-};
-export type Output = {
-    script: string;
-    value: string;
-    address?: string;
-};
-export type TapTreeLeaf = {
-    depth: number;
-    leafVersion: number;
-    script: string;
-};
-export type PsbtOutput = {
-    redeemScript?: string;
-    witnessScript?: string;
-    bip32Derivation?: Bip32Derivation[];
-    tapBip32Derivation?: TapBip32Derivation[];
-    tapInternalKey?: string;
-    tapTree?: {
-        leaves: TapTreeLeaf[];
-    };
-};
-export type Fixture = {
-    walletKeys: [string, string, string];
-    psbtBase64: string;
-    psbtBase64Finalized: string | null;
-    inputs: Input[];
-    psbtInputs: PsbtInput[];
-    psbtInputsFinalized: PsbtInput[] | null;
-    outputs: Output[];
-    psbtOutputs: PsbtOutput[];
-    extractedTransaction: string | null;
-};
-/**
- * Get PSBT buffer from a fixture
- */
-export declare function getPsbtBuffer(fixture: Fixture): Buffer;
-/**
- * Get BitGoPsbt from a fixture
- * @param fixture - The test fixture
- * @param networkName - The network name for deserializing the PSBT
- * @returns A BitGoPsbt instance
- */
-export declare function getBitGoPsbt(fixture: Fixture, networkName: NetworkName): BitGoPsbt;
-/**
- * Load a PSBT fixture from JSON file
- */
-export declare function loadPsbtFixture(network: string, signatureState: string): Fixture;
-/**
- * Load wallet keys from fixture
- */
-export declare function loadWalletKeysFromFixture(fixture: Fixture): RootWalletKeys;
-export declare function loadReplayProtectionKeyFromFixture(fixture: Fixture): ECPair;
-/**
- * Get extracted transaction hex from fixture
- */
-export declare function getExtractedTransactionHex(fixture: Fixture): string;

package/dist/esm/test/fixedScript/fixtureUtil.js

@@ -1,65 +0,0 @@
-import assert from "node:assert";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { dirname } from "node:path";
-import { BIP32 } from "../../js/bip32.js";
-import { RootWalletKeys } from "../../js/fixedScriptWallet/RootWalletKeys.js";
-import { ECPair } from "../../js/ecpair.js";
-import { fixedScriptWallet } from "../../js/index.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-/**
- * Get PSBT buffer from a fixture
- */
-export function getPsbtBuffer(fixture) {
-    return Buffer.from(fixture.psbtBase64, "base64");
-}
-/**
- * Get BitGoPsbt from a fixture
- * @param fixture - The test fixture
- * @param networkName - The network name for deserializing the PSBT
- * @returns A BitGoPsbt instance
- */
-export function getBitGoPsbt(fixture, networkName) {
-    return fixedScriptWallet.BitGoPsbt.fromBytes(getPsbtBuffer(fixture), networkName);
-}
-/**
- * Load a PSBT fixture from JSON file
- */
-export function loadPsbtFixture(network, signatureState) {
-    const fixturePath = path.join(__dirname, "..", "fixtures", "fixed-script", `psbt-lite.${network}.${signatureState}.json`);
-    const fixtureContent = fs.readFileSync(fixturePath, "utf-8");
-    return JSON.parse(fixtureContent);
-}
-/**
- * Load wallet keys from fixture
- */
-export function loadWalletKeysFromFixture(fixture) {
-    // Parse xprvs and convert to xpubs
-    const xpubs = fixture.walletKeys.map((xprv) => {
-        const key = BIP32.fromBase58(xprv);
-        return key.neutered();
-    });
-    const walletKeysLike = {
-        triple: xpubs,
-        derivationPrefixes: ["0/0", "0/0", "0/0"],
-    };
-    return RootWalletKeys.from(walletKeysLike);
-}
-export function loadReplayProtectionKeyFromFixture(fixture) {
-    // underived user key
-    const userBip32 = BIP32.fromBase58(fixture.walletKeys[0]);
-    assert(userBip32.privateKey);
-    const userECPair = ECPair.fromPrivateKey(Buffer.from(userBip32.privateKey));
-    return userECPair;
-}
-/**
- * Get extracted transaction hex from fixture
- */
-export function getExtractedTransactionHex(fixture) {
-    if (fixture.extractedTransaction === null) {
-        throw new Error("Fixture does not have an extracted transaction");
-    }
-    return fixture.extractedTransaction;
-}

package/dist/esm/test/fixedScript/musig2Nonces.d.ts

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

package/dist/esm/test/fixedScript/musig2Nonces.js

@@ -1,77 +0,0 @@
-import assert from "assert";
-import { BIP32 } from "../../js/bip32.js";
-import { loadPsbtFixture, getBitGoPsbt } from "./fixtureUtil.js";
-describe("MuSig2 nonce management", function () {
-    describe("Bitcoin mainnet", function () {
-        const networkName = "bitcoin";
-        let fixture;
-        let userKey;
-        let backupKey;
-        let bitgoKey;
-        before(function () {
-            fixture = loadPsbtFixture(networkName, "unsigned");
-            userKey = BIP32.fromBase58(fixture.walletKeys[0]);
-            backupKey = BIP32.fromBase58(fixture.walletKeys[1]);
-            bitgoKey = BIP32.fromBase58(fixture.walletKeys[2]);
-        });
-        it("should generate nonces for MuSig2 inputs with auto-generated session ID", function () {
-            const unsignedBitgoPsbt = getBitGoPsbt(fixture, networkName);
-            // Generate nonces with auto-generated session ID (no second parameter)
-            assert.doesNotThrow(() => {
-                unsignedBitgoPsbt.generateMusig2Nonces(userKey);
-            });
-            // Verify nonces were stored by serializing and deserializing
-            const serializedWithUserNonces = unsignedBitgoPsbt.serialize();
-            assert.ok(serializedWithUserNonces.length > getBitGoPsbt(fixture, networkName).serialize().length);
-            assert.doesNotThrow(() => {
-                unsignedBitgoPsbt.generateMusig2Nonces(bitgoKey);
-            });
-            const serializedWithBitgoNonces = unsignedBitgoPsbt.serialize();
-            assert.ok(serializedWithBitgoNonces.length > serializedWithUserNonces.length);
-            assert.throws(() => {
-                unsignedBitgoPsbt.generateMusig2Nonces(backupKey);
-            }, "Should throw error when generating nonces for backup key");
-        });
-        it("implements combineMusig2Nonces", function () {
-            const unsignedBitgoPsbtWithUserNonces = getBitGoPsbt(fixture, networkName);
-            unsignedBitgoPsbtWithUserNonces.generateMusig2Nonces(userKey);
-            const unsignedBitgoPsbtWithBitgoNonces = getBitGoPsbt(fixture, networkName);
-            unsignedBitgoPsbtWithBitgoNonces.generateMusig2Nonces(bitgoKey);
-            const unsignedBitgoPsbtWithBothNonces = getBitGoPsbt(fixture, networkName);
-            unsignedBitgoPsbtWithBothNonces.combineMusig2Nonces(unsignedBitgoPsbtWithUserNonces);
-            unsignedBitgoPsbtWithBothNonces.combineMusig2Nonces(unsignedBitgoPsbtWithBitgoNonces);
-            {
-                const psbt = getBitGoPsbt(fixture, networkName);
-                psbt.combineMusig2Nonces(unsignedBitgoPsbtWithUserNonces);
-                assert.strictEqual(psbt.serialize().length, unsignedBitgoPsbtWithUserNonces.serialize().length);
-            }
-            {
-                const psbt = getBitGoPsbt(fixture, networkName);
-                psbt.combineMusig2Nonces(unsignedBitgoPsbtWithBitgoNonces);
-                assert.strictEqual(psbt.serialize().length, unsignedBitgoPsbtWithBitgoNonces.serialize().length);
-            }
-            {
-                const psbt = getBitGoPsbt(fixture, networkName);
-                psbt.combineMusig2Nonces(unsignedBitgoPsbtWithUserNonces);
-                psbt.combineMusig2Nonces(unsignedBitgoPsbtWithBitgoNonces);
-                assert.strictEqual(psbt.serialize().length, unsignedBitgoPsbtWithBothNonces.serialize().length);
-            }
-        });
-        it("should reject invalid session ID length", function () {
-            const unsignedBitgoPsbt = getBitGoPsbt(fixture, networkName);
-            // Invalid session ID (wrong length)
-            const invalidSessionId = new Uint8Array(16); // Should be 32 bytes
-            assert.throws(() => {
-                unsignedBitgoPsbt.generateMusig2Nonces(userKey, invalidSessionId);
-            }, "Should throw error for invalid session ID length");
-        });
-        it("should reject custom session ID on mainnet (security)", function () {
-            const unsignedBitgoPsbt = getBitGoPsbt(fixture, "bitcoin");
-            // Custom session ID should be rejected on mainnet for security
-            const customSessionId = new Uint8Array(32).fill(1);
-            assert.throws(() => {
-                unsignedBitgoPsbt.generateMusig2Nonces(userKey, customSessionId);
-            }, /Custom session_id is only allowed on testnets/, "Should throw error when providing custom session_id on mainnet");
-        });
-    });
-});

package/dist/esm/test/fixedScript/parseTransactionWithWalletKeys.d.ts

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