@bitgo/wasm-utxo 1.8.0 → 1.10.0

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/signAndVerifySignature.d.ts

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

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

@@ -1,268 +0,0 @@
-import assert from "node:assert";
-import * as utxolib from "@bitgo/utxo-lib";
-import { BIP32 } from "../../js/index.js";
-import { loadPsbtFixture, loadWalletKeysFromFixture, getBitGoPsbt, loadReplayProtectionKeyFromFixture, } from "./fixtureUtil.js";
-/**
- * Load xprivs from a fixture
- * @param fixture - The test fixture
- * @returns The xprivs for user, backup, and bitgo keys
- */
-function loadXprivsFromFixture(fixture) {
-    const [userXpriv, backupXpriv, bitgoXpriv] = fixture.walletKeys.map((xprv) => BIP32.fromBase58(xprv));
-    return {
-        user: userXpriv,
-        backup: backupXpriv,
-        bitgo: bitgoXpriv,
-    };
-}
-/**
- * Get expected signature state for an input based on type and signing stage
- * @param inputType - The type of input (e.g., "p2shP2pk", "p2trMusig2", "taprootKeyPathSpend")
- * @param signatureStage - The signing stage (unsigned, halfsigned, fullsigned)
- * @returns Expected signature state for replay protection OR multi-key signatures
- */
-function getExpectedSignatures(inputType, signatureStage) {
-    // p2shP2pk inputs use replay protection signature verification
-    if (inputType === "p2shP2pk") {
-        return {
-            hasReplayProtectionSignature: signatureStage === "halfsigned" || signatureStage === "fullsigned",
-        };
-    }
-    switch (signatureStage) {
-        case "unsigned":
-            return { user: false, backup: false, bitgo: false };
-        case "halfsigned":
-            // User signs first
-            return { user: true, backup: false, bitgo: false };
-        case "fullsigned":
-            // p2trMusig2 uses user + backup for 2-of-2 MuSig2
-            if (inputType === "p2trMusig2") {
-                return { user: true, backup: true, bitgo: false };
-            }
-            // Regular multisig uses user + bitgo
-            return { user: true, backup: false, bitgo: true };
-        default:
-            throw new Error(`Unknown signature stage: ${String(signatureStage)}`);
-    }
-}
-/**
- * Verify signature state for a specific input in a PSBT
- * @param bitgoPsbt - The PSBT to verify
- * @param rootWalletKeys - Wallet keys for verification
- * @param inputIndex - The input index to verify
- * @param inputType - The type of input (for replay protection handling)
- * @param expectedSignatures - Expected signature state for each key or replay protection
- */
-function verifyInputSignatures(bitgoPsbt, parsed, rootWalletKeys, replayProtectionKey, inputIndex, expectedSignatures) {
-    // Handle replay protection inputs (P2shP2pk)
-    if ("hasReplayProtectionSignature" in expectedSignatures) {
-        const hasReplaySig = bitgoPsbt.verifyReplayProtectionSignature(inputIndex, {
-            publicKeys: [replayProtectionKey],
-        });
-        assert.strictEqual(hasReplaySig, expectedSignatures.hasReplayProtectionSignature, `Input ${inputIndex} replay protection signature mismatch`);
-        return;
-    }
-    if (parsed.inputs[inputIndex].scriptType === "p2shP2pk") {
-        const hasReplaySig = bitgoPsbt.verifySignature(inputIndex, replayProtectionKey);
-        assert.ok("hasReplayProtectionSignature" in expectedSignatures, "Expected hasReplayProtectionSignature to be present");
-        assert.strictEqual(hasReplaySig, expectedSignatures.hasReplayProtectionSignature, `Input ${inputIndex} replay protection signature mismatch`);
-        return;
-    }
-    // Handle standard multisig inputs
-    const hasUserSig = bitgoPsbt.verifySignature(inputIndex, rootWalletKeys.userKey());
-    const hasBackupSig = bitgoPsbt.verifySignature(inputIndex, rootWalletKeys.backupKey());
-    const hasBitGoSig = bitgoPsbt.verifySignature(inputIndex, rootWalletKeys.bitgoKey());
-    const scriptType = parsed.inputs[inputIndex].scriptType;
-    assert.strictEqual(hasUserSig, expectedSignatures.user, `Input ${inputIndex} user key signature mismatch type=${scriptType}`);
-    assert.strictEqual(hasBackupSig, expectedSignatures.backup, `Input ${inputIndex} backup key signature mismatch type=${scriptType}`);
-    assert.strictEqual(hasBitGoSig, expectedSignatures.bitgo, `Input ${inputIndex} BitGo key signature mismatch type=${scriptType}`);
-}
-/**
- * Helper to verify signatures for all inputs in a PSBT
- * @param bitgoPsbt - The PSBT to verify
- * @param fixture - The test fixture containing input metadata
- * @param rootWalletKeys - Wallet keys for verification
- * @param replayProtectionKey - Key for replay protection inputs
- * @param signatureStage - The signing stage (unsigned, halfsigned, fullsigned)
- */
-function verifyAllInputSignatures(bitgoPsbt, fixture, rootWalletKeys, replayProtectionKey, signatureStage) {
-    const parsed = bitgoPsbt.parseTransactionWithWalletKeys(rootWalletKeys, {
-        publicKeys: [replayProtectionKey],
-    });
-    fixture.psbtInputs.forEach((input, index) => {
-        verifyInputSignatures(bitgoPsbt, parsed, rootWalletKeys, replayProtectionKey, index, getExpectedSignatures(input.type, signatureStage));
-    });
-}
-function signInputAndVerify(bitgoPsbt, index, key, keyName, inputType) {
-    bitgoPsbt.sign(index, key);
-    assert.strictEqual(bitgoPsbt.verifySignature(index, key), true, `Input ${index} signature mismatch key=${keyName} type=${inputType}`);
-}
-/**
- * Sign all inputs in a PSBT according to the signature stage
- * @param bitgoPsbt - The PSBT to sign
- * @param rootWalletKeys - Wallet keys for parsing the transaction
- * @param xprivs - The xprivs to use for signing
- * @param replayProtectionKey - The ECPair for signing replay protection (p2shP2pk) inputs
- */
-function signAllInputs(bitgoPsbt, rootWalletKeys, xprivs, replayProtectionKey) {
-    // Parse transaction to get input types
-    const parsed = bitgoPsbt.parseTransactionWithWalletKeys(rootWalletKeys, {
-        publicKeys: [replayProtectionKey],
-    });
-    // Generate MuSig2 nonces for user and backup keys (MuSig2 uses 2-of-2 with user+backup)
-    bitgoPsbt.generateMusig2Nonces(xprivs.user);
-    bitgoPsbt.generateMusig2Nonces(xprivs.bitgo);
-    // First pass: sign with user key (skip p2shP2pk inputs)
-    parsed.inputs.forEach((input, index) => {
-        switch (input.scriptType) {
-            case "p2shP2pk":
-                break;
-            default:
-                signInputAndVerify(bitgoPsbt, index, xprivs.user, "user", input.scriptType);
-                break;
-        }
-    });
-    // Second pass: sign with appropriate second key
-    parsed.inputs.forEach((input, index) => {
-        switch (input.scriptType) {
-            case "p2shP2pk":
-                signInputAndVerify(bitgoPsbt, index, replayProtectionKey, "replayProtection", input.scriptType);
-                break;
-            case "p2trMusig2ScriptPath":
-                // MuSig2 script path inputs use backup key for second signature
-                signInputAndVerify(bitgoPsbt, index, xprivs.backup, "backup", input.scriptType);
-                break;
-            default:
-                // Regular multisig uses bitgo key
-                signInputAndVerify(bitgoPsbt, index, xprivs.bitgo, "bitgo", input.scriptType);
-                break;
-        }
-    });
-}
-/**
- * Run tests for a fixture: load PSBT, verify, sign, and verify again
- * @param fixture - The test fixture
- * @param networkName - The network name for deserializing the PSBT
- * @param rootWalletKeys - Wallet keys for verification
- * @param replayProtectionKey - Key for replay protection inputs
- * @param xprivs - The xprivs to use for signing
- * @param signatureStage - The current signing stage
- */
-function runTestsForFixture(fixture, networkName, rootWalletKeys, replayProtectionKey, xprivs, signatureStage) {
-    // Load PSBT from fixture
-    const bitgoPsbt = getBitGoPsbt(fixture, networkName);
-    // Verify current state
-    verifyAllInputSignatures(bitgoPsbt, fixture, rootWalletKeys, replayProtectionKey, signatureStage);
-    // Sign inputs (if not already fully signed)
-    if (signatureStage !== "unsigned") {
-        signAllInputs(bitgoPsbt, rootWalletKeys, xprivs, replayProtectionKey);
-    }
-}
-describe("verifySignature", 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 rootWalletKeys;
-            let replayProtectionKey;
-            let xprivs;
-            let unsignedFixture;
-            let halfsignedFixture;
-            let fullsignedFixture;
-            before(function () {
-                unsignedFixture = loadPsbtFixture(networkName, "unsigned");
-                halfsignedFixture = loadPsbtFixture(networkName, "halfsigned");
-                fullsignedFixture = loadPsbtFixture(networkName, "fullsigned");
-                rootWalletKeys = loadWalletKeysFromFixture(fullsignedFixture);
-                replayProtectionKey = loadReplayProtectionKeyFromFixture(fullsignedFixture);
-                xprivs = loadXprivsFromFixture(fullsignedFixture);
-            });
-            describe("unsigned PSBT", function () {
-                it("should return false for unsigned inputs, then sign and verify", function () {
-                    runTestsForFixture(unsignedFixture, networkName, rootWalletKeys, replayProtectionKey, xprivs, "unsigned");
-                });
-            });
-            describe("half-signed PSBT", function () {
-                it("should return true for signed xpubs and false for unsigned, then sign and verify", function () {
-                    runTestsForFixture(halfsignedFixture, networkName, rootWalletKeys, replayProtectionKey, xprivs, "halfsigned");
-                });
-            });
-            describe("fully signed PSBT", function () {
-                it("should have 2 signatures (2-of-3 multisig)", function () {
-                    runTestsForFixture(fullsignedFixture, networkName, rootWalletKeys, replayProtectionKey, xprivs, "fullsigned");
-                });
-            });
-            describe("error handling", function () {
-                it("should throw error for out of bounds input index", function () {
-                    const psbt = getBitGoPsbt(fullsignedFixture, networkName);
-                    assert.throws(() => {
-                        psbt.verifySignature(999, rootWalletKeys.userKey());
-                    }, (error) => {
-                        return error.message.includes("Input index 999 out of bounds");
-                    }, "Should throw error for out of bounds input index");
-                });
-                it("should throw error for invalid xpub", function () {
-                    const psbt = getBitGoPsbt(fullsignedFixture, networkName);
-                    assert.throws(() => {
-                        psbt.verifySignature(0, "invalid-xpub");
-                    }, (error) => {
-                        return error.message.includes("Invalid");
-                    }, "Should throw error for invalid xpub");
-                });
-                it("should return false for xpub not in derivation path", function () {
-                    const psbt = getBitGoPsbt(fullsignedFixture, networkName);
-                    // Create a different xpub that's not in the wallet
-                    // Use a proper 32-byte seed (256 bits)
-                    const differentSeed = Buffer.alloc(32, 0xaa); // 32 bytes filled with 0xaa
-                    const differentKey = BIP32.fromSeed(differentSeed);
-                    const differentXpub = differentKey.neutered();
-                    const result = psbt.verifySignature(0, differentXpub);
-                    assert.strictEqual(result, false, "Should return false for xpub not in PSBT derivation paths");
-                });
-                it("should verify signature with raw public key (Uint8Array)", function () {
-                    const psbt = getBitGoPsbt(fullsignedFixture, networkName);
-                    // Verify that xpub-based verification works
-                    const userKey = rootWalletKeys.userKey();
-                    const hasXpubSig = psbt.verifySignature(0, userKey);
-                    // This test specifically checks that raw public key verification works
-                    // We test the underlying WASM API by ensuring both xpub and raw pubkey
-                    // calls reach the correct methods
-                    // Use a random public key that's not in the PSBT to test the API works
-                    const randomSeed = Buffer.alloc(32, 0xcc);
-                    const randomKey = BIP32.fromSeed(randomSeed);
-                    const randomPubkey = randomKey.publicKey;
-                    // This should return false (no signature for this key)
-                    const result = psbt.verifySignature(0, randomPubkey);
-                    assert.strictEqual(result, false, "Should return false for public key not in PSBT");
-                    // Verify the xpub check still works (regression test)
-                    assert.strictEqual(hasXpubSig, true, "Should still verify with xpub");
-                });
-                it("should return false for raw public key with no signature", function () {
-                    const psbt = getBitGoPsbt(fullsignedFixture, networkName);
-                    // Create a random public key that's not in the PSBT
-                    const randomSeed = Buffer.alloc(32, 0xbb);
-                    const randomKey = BIP32.fromSeed(randomSeed);
-                    const randomPubkey = randomKey.publicKey;
-                    const result = psbt.verifySignature(0, randomPubkey);
-                    assert.strictEqual(result, false, "Should return false for public key not in PSBT signatures");
-                });
-                it("should throw error for invalid key length", function () {
-                    const psbt = getBitGoPsbt(fullsignedFixture, networkName);
-                    const invalidKey = Buffer.alloc(31); // Invalid length (should be 32 for private key or 33 for public key)
-                    assert.throws(() => {
-                        psbt.verifySignature(0, invalidKey);
-                    }, (error) => {
-                        return error.message.includes("Invalid key length");
-                    }, "Should throw error for invalid key length");
-                });
-            });
-        });
-    });
-});

package/dist/esm/test/fixedScript/walletKeys.util.d.ts

@@ -1,12 +0,0 @@
-import * as utxolib from "@bitgo/utxo-lib";
-import type { Triple } from "../../js/triple.js";
-/**
- * Convert utxolib BIP32 keys to WASM wallet keys format (Triple<string>)
- */
-export declare function toWasmWalletKeys(keys: [utxolib.BIP32Interface, utxolib.BIP32Interface, utxolib.BIP32Interface]): Triple<string>;
-/**
- * Get standard replay protection configuration
- */
-export declare function getStandardReplayProtection(): {
-    outputScripts: Uint8Array[];
-};

package/dist/esm/test/fixedScript/walletKeys.util.js

@@ -1,17 +0,0 @@
-/**
- * Convert utxolib BIP32 keys to WASM wallet keys format (Triple<string>)
- */
-export function toWasmWalletKeys(keys) {
-    return [
-        keys[0].neutered().toBase58(),
-        keys[1].neutered().toBase58(),
-        keys[2].neutered().toBase58(),
-    ];
-}
-/**
- * Get standard replay protection configuration
- */
-export function getStandardReplayProtection() {
-    const replayProtectionScript = Buffer.from("a91420b37094d82a513451ff0ccd9db23aba05bc5ef387", "hex");
-    return { outputScripts: [replayProtectionScript] };
-}

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

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

package/dist/esm/test/fixedScriptToDescriptor.js

@@ -1,93 +0,0 @@
-import * as assert from "assert";
-import * as utxolib from "@bitgo/utxo-lib";
-import { Descriptor } from "../js/index.js";
-import { getDescriptorForScriptType } from "./descriptorUtil.js";
-const rootWalletKeys = new utxolib.bitgo.RootWalletKeys(utxolib.testutil.getKeyTriple("wasm"));
-const scriptTypes = ["p2sh", "p2shP2wsh", "p2wsh"];
-const scope = ["external", "internal"];
-const index = [0, 1, 2];
-/** Get the expected max weight to satisfy the descriptor */
-function getExpectedMaxWeightToSatisfy(scriptType) {
-    switch (scriptType) {
-        case "p2sh":
-            return 256;
-        case "p2shP2wsh":
-            return 99;
-        case "p2wsh":
-            return 64;
-        default:
-            throw new Error("unexpected script type");
-    }
-}
-/** Compute the total size of the input, including overhead */
-function getTotalInputSize(vSize) {
-    const sizeOpPushData1 = 1;
-    const sizeOpPushData2 = 2;
-    return (32 /* txid */ +
-        4 /* vout */ +
-        4 /* nSequence */ +
-        (vSize < 255 ? sizeOpPushData1 : sizeOpPushData2) +
-        vSize);
-}
-/** Get the full expected vSize of the input including overhead */
-function getExpectedVSize(scriptType) {
-    // https://github.com/BitGo/BitGoJS/blob/master/modules/unspents/docs/input-costs.md
-    switch (scriptType) {
-        case "p2sh":
-            return 298;
-        case "p2shP2wsh":
-            return 140;
-        case "p2wsh":
-            return 105;
-        default:
-            throw new Error("unexpected script type");
-    }
-}
-function runTest(scriptType, index, scope) {
-    describe(`scriptType=${scriptType}, index=${index}, scope=${scope}`, function () {
-        const chainCode = scope === "external"
-            ? utxolib.bitgo.getExternalChainCode(scriptType)
-            : utxolib.bitgo.getInternalChainCode(scriptType);
-        const derivedKeys = rootWalletKeys.deriveForChainAndIndex(chainCode, index);
-        const scriptUtxolib = utxolib.bitgo.outputScripts.createOutputScript2of3(derivedKeys.publicKeys, scriptType).scriptPubKey;
-        let descriptor;
-        before(function () {
-            descriptor = Descriptor.fromString(getDescriptorForScriptType(rootWalletKeys, scriptType, scope), "derivable");
-        });
-        it("descriptor should have expected format", function () {
-            const [x1, x2, x3] = rootWalletKeys.triple.map((xpub) => xpub.neutered().toBase58());
-            if (scriptType === "p2sh" && scope === "external") {
-                // spot check
-                assert.ok(descriptor
-                    .toString()
-                    .startsWith(`sh(multi(2,${x1}/0/0/0/*,${x2}/0/0/0/*,${x3}/0/0/0/*))`));
-            }
-            if (scriptType === "p2shP2wsh" && scope === "internal") {
-                // spot check
-                assert.ok(descriptor
-                    .toString()
-                    .startsWith(`sh(wsh(multi(2,${x1}/0/0/11/*,${x2}/0/0/11/*,${x3}/0/0/11/*)))`));
-            }
-        });
-        it("address should match descriptor", function () {
-            const scriptFromDescriptor = Buffer.from(descriptor.atDerivationIndex(index).scriptPubkey());
-            assert.deepStrictEqual(scriptUtxolib.toString("hex"), scriptFromDescriptor.toString("hex"));
-        });
-        it("should have expected weights", function () {
-            assert.ok(Number.isInteger(descriptor.maxWeightToSatisfy()));
-            const vSize = Math.ceil(descriptor.maxWeightToSatisfy() / 4);
-            console.log(scriptType, "scriptLength", descriptor.atDerivationIndex(0).encode().length, "vSize", vSize);
-            assert.equal(vSize, getExpectedMaxWeightToSatisfy(scriptType));
-            assert.equal(getTotalInputSize(vSize), getExpectedVSize(scriptType));
-        });
-    });
-}
-describe("fixedScript to descriptor", function () {
-    scriptTypes.forEach((scriptType) => {
-        index.forEach((index) => {
-            scope.forEach((scope) => {
-                runTest(scriptType, index, scope);
-            });
-        });
-    });
-});

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

@@ -1 +0,0 @@
-export declare function getFixture(path: string, defaultValue: unknown): Promise<unknown>;

package/dist/esm/test/fixtures.js

@@ -1,16 +0,0 @@
-import * as fs from "fs/promises";
-export async function getFixture(path, defaultValue) {
-    try {
-        return JSON.parse(await fs.readFile(path, "utf8"));
-    }
-    catch (e) {
-        if (typeof e === "object" &&
-            e !== null &&
-            "code" in e &&
-            e.code === "ENOENT") {
-            await fs.writeFile(path, JSON.stringify(defaultValue, null, 2));
-            throw new Error(`Fixture not found at ${path}, created a new one`);
-        }
-        throw e;
-    }
-}

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

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