@bitgo/wasm-utxo 1.7.0 → 1.9.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,95 +0,0 @@
-import { RootWalletKeys } from "../../js/fixedScriptWallet/RootWalletKeys.js";
-import { ECPair } from "../../js/ecpair.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;
-/**
- * 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,55 +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";
-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");
-}
-/**
- * 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/parseTransactionWithWalletKeys.d.ts

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

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

@@ -1,168 +0,0 @@
-import assert from "node:assert";
-import * as utxolib from "@bitgo/utxo-lib";
-import { fixedScriptWallet } from "../../js/index.js";
-import { loadPsbtFixture, loadWalletKeysFromFixture, getPsbtBuffer, loadReplayProtectionKeyFromFixture, } from "./fixtureUtil.js";
-function getExpectedInputScriptType(fixtureScriptType) {
-    // Map fixture types to InputScriptType values
-    // Based on the Rust mapping in src/fixed_script_wallet/test_utils/fixtures.rs
-    switch (fixtureScriptType) {
-        case "p2shP2pk":
-        case "p2sh":
-        case "p2shP2wsh":
-        case "p2wsh":
-            return fixtureScriptType;
-        case "p2tr":
-            return "p2trLegacy";
-        case "p2trMusig2":
-            return "p2trMusig2ScriptPath";
-        case "taprootKeyPathSpend":
-            return "p2trMusig2KeyPath";
-        default:
-            throw new Error(`Unknown fixture script type: ${fixtureScriptType}`);
-    }
-}
-function getOtherWalletKeys() {
-    const otherWalletKeys = utxolib.testutil.getKeyTriple("too many secrets");
-    return new utxolib.bitgo.RootWalletKeys(otherWalletKeys);
-}
-describe("parseTransactionWithWalletKeys", 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 fullsignedPsbtBytes;
-            let bitgoPsbt;
-            let rootWalletKeys;
-            let replayProtectionKey;
-            let fixture;
-            before(function () {
-                fixture = loadPsbtFixture(networkName, "fullsigned");
-                fullsignedPsbtBytes = getPsbtBuffer(fixture);
-                bitgoPsbt = fixedScriptWallet.BitGoPsbt.fromBytes(fullsignedPsbtBytes, networkName);
-                rootWalletKeys = loadWalletKeysFromFixture(fixture);
-                replayProtectionKey = loadReplayProtectionKeyFromFixture(fixture);
-            });
-            it("should have matching unsigned transaction ID", function () {
-                const unsignedTxid = bitgoPsbt.unsignedTxid();
-                const expectedUnsignedTxid = utxolib.bitgo
-                    .createPsbtFromBuffer(fullsignedPsbtBytes, network)
-                    .getUnsignedTx()
-                    .getId();
-                assert.strictEqual(unsignedTxid, expectedUnsignedTxid);
-            });
-            it("should parse transaction and identify internal/external outputs", function () {
-                const parsed = bitgoPsbt.parseTransactionWithWalletKeys(rootWalletKeys, {
-                    publicKeys: [replayProtectionKey],
-                });
-                // Verify all inputs have addresses and values
-                parsed.inputs.forEach((input, i) => {
-                    assert.ok(input.address, `Input ${i} should have an address`);
-                    assert.ok(typeof input.value === "bigint", `Input ${i} value should be bigint`);
-                    assert.ok(input.value > 0n, `Input ${i} value should be > 0`);
-                });
-                // Validate outputs
-                assert.ok(parsed.outputs.length > 0, "Should have at least one output");
-                // Count internal outputs (scriptId is defined and not null)
-                const internalOutputs = parsed.outputs.filter((o) => o.scriptId);
-                // Count external outputs (scriptId is null or undefined)
-                const externalOutputs = parsed.outputs.filter((o) => o.scriptId === null);
-                assert.ok(externalOutputs.every((o) => o.address || o.script));
-                const nonAddressOutputs = externalOutputs.filter((o) => o.address === null);
-                assert.strictEqual(nonAddressOutputs.length, 1);
-                const [opReturnOutput] = nonAddressOutputs;
-                const expectedOpReturn = utxolib.payments.embed({
-                    data: [Buffer.from("setec astronomy")],
-                }).output;
-                assert.strictEqual(Buffer.from(opReturnOutput.script).toString("hex"), expectedOpReturn.toString("hex"));
-                // Fixtures now have 3 external outputs
-                assert.ok(internalOutputs.length > 0, "Should have internal outputs (have scriptId)");
-                assert.strictEqual(externalOutputs.length, 3, "Should have 3 external outputs in test fixture");
-                // Verify all outputs have proper structure
-                parsed.outputs.forEach((output, i) => {
-                    assert.ok(output.script instanceof Uint8Array, `Output ${i} script should be Uint8Array`);
-                    assert.ok(typeof output.value === "bigint", `Output ${i} value should be bigint`);
-                    assert.ok(output.value > 0n, `Output ${i} value should be > 0`);
-                    // Address is optional for non-standard scripts
-                });
-                // Verify spend amount (should be > 0 since there are external outputs)
-                assert.strictEqual(parsed.spendAmount, 900n * 3n);
-                // Verify miner fee calculation
-                const totalInputValue = parsed.inputs.reduce((sum, i) => sum + i.value, 0n);
-                const totalOutputValue = parsed.outputs.reduce((sum, o) => sum + o.value, 0n);
-                assert.strictEqual(parsed.minerFee, totalInputValue - totalOutputValue, "Miner fee should equal inputs minus outputs");
-                assert.ok(parsed.minerFee > 0n, "Miner fee should be > 0");
-                // Verify virtual size
-                assert.ok(typeof parsed.virtualSize === "number", "Virtual size should be a number");
-                assert.ok(parsed.virtualSize > 0, "Virtual size should be > 0");
-            });
-            it("should parse inputs with correct scriptType", function () {
-                const parsed = bitgoPsbt.parseTransactionWithWalletKeys(rootWalletKeys, {
-                    publicKeys: [replayProtectionKey],
-                });
-                // Verify all inputs have scriptType matching fixture
-                parsed.inputs.forEach((input, i) => {
-                    const fixtureInput = fixture.psbtInputs[i];
-                    const expectedScriptType = getExpectedInputScriptType(fixtureInput.type);
-                    assert.strictEqual(input.scriptType, expectedScriptType, `Input ${i} scriptType should be ${expectedScriptType}, got ${input.scriptType}`);
-                });
-            });
-            it("should fail to parse with other wallet keys", function () {
-                assert.throws(() => {
-                    bitgoPsbt.parseTransactionWithWalletKeys(getOtherWalletKeys(), {
-                        publicKeys: [replayProtectionKey],
-                    });
-                }, (error) => {
-                    return error.message.includes("Failed to parse transaction: Input 0: wallet validation failed");
-                });
-            });
-            it("should recognize output for other wallet keys", function () {
-                const parsedOutputs = bitgoPsbt.parseOutputsWithWalletKeys(getOtherWalletKeys());
-                // Should return an array of parsed outputs
-                assert.ok(Array.isArray(parsedOutputs), "Should return an array");
-                assert.ok(parsedOutputs.length > 0, "Should have at least one output");
-                // Verify all outputs have proper structure
-                parsedOutputs.forEach((output, i) => {
-                    assert.ok(output.script instanceof Uint8Array, `Output ${i} script should be Uint8Array`);
-                    assert.ok(typeof output.value === "bigint", `Output ${i} value should be bigint`);
-                    assert.ok(output.value > 0n, `Output ${i} value should be > 0`);
-                    // Address can be null for non-standard scripts
-                    assert.ok(typeof output.address === "string" || output.address === null, `Output ${i} address should be string or null`);
-                    // scriptId can be null for external outputs
-                    assert.ok(output.scriptId === null ||
-                        (typeof output.scriptId === "object" &&
-                            typeof output.scriptId.chain === "number" &&
-                            typeof output.scriptId.index === "number"), `Output ${i} scriptId should be null or an object with chain and index`);
-                });
-                // Compare with the original wallet keys to verify we get different results
-                const originalParsedOutputs = bitgoPsbt.parseOutputsWithWalletKeys(rootWalletKeys);
-                // Should have the same number of outputs
-                assert.strictEqual(parsedOutputs.length, originalParsedOutputs.length, "Should parse the same number of outputs");
-                // Find outputs that belong to the other wallet keys (scriptId !== null)
-                const otherWalletOutputs = parsedOutputs.filter((o) => o.scriptId !== null);
-                // Should have exactly one output for the other wallet keys
-                assert.strictEqual(otherWalletOutputs.length, 1, "Should have exactly one output belonging to the other wallet keys");
-                // Verify that this output is marked as external (scriptId === null) under regular wallet keys
-                const otherWalletOutputIndex = parsedOutputs.findIndex((o) => o.scriptId !== null);
-                const sameOutputWithRegularKeys = originalParsedOutputs[otherWalletOutputIndex];
-                assert.strictEqual(sameOutputWithRegularKeys.scriptId, null, "The output belonging to other wallet keys should be marked as external (scriptId === null) when parsed with regular wallet keys");
-            });
-        });
-    });
-    describe("error handling", function () {
-        it("should throw error for invalid PSBT bytes", function () {
-            const invalidBytes = new Uint8Array([0x00, 0x01, 0x02]);
-            assert.throws(() => {
-                fixedScriptWallet.BitGoPsbt.fromBytes(invalidBytes, "bitcoin");
-            }, (error) => {
-                return error.message.includes("Failed to deserialize PSBT");
-            }, "Should throw error for invalid PSBT bytes");
-        });
-    });
-});

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

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