@bitgo/wasm-utxo 1.5.0 → 1.7.0

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

@@ -1,14 +1,31 @@
 import assert from "node:assert";
 import * as utxolib from "@bitgo/utxo-lib";
 import { fixedScriptWallet } from "../../js/index.js";
-import { loadPsbtFixture, loadWalletKeysFromFixture, getPsbtBuffer } from "./fixtureUtil.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 () {
-    // Replay protection script that matches Rust tests
-    const replayProtectionScript = Buffer.from("a91420b37094d82a513451ff0ccd9db23aba05bc5ef387", "hex");
     const supportedNetworks = utxolib.getNetworkList().filter((network) => {
         return (utxolib.isMainnet(network) &&
             network !== utxolib.networks.bitcoincash &&
@@ -17,20 +34,20 @@ describe("parseTransactionWithWalletKeys", function () {
             network !== utxolib.networks.ecash &&
             network !== utxolib.networks.zcash);
     });
-    function hasReplayProtection(network) {
-        const mainnet = utxolib.getMainnet(network);
-        return mainnet === utxolib.networks.bitcoincash;
-    }
     supportedNetworks.forEach((network) => {
         const networkName = utxolib.getNetworkName(network);
         describe(`network: ${networkName}`, function () {
             let fullsignedPsbtBytes;
             let bitgoPsbt;
             let rootWalletKeys;
+            let replayProtectionKey;
+            let fixture;
             before(function () {
-                fullsignedPsbtBytes = getPsbtBuffer(loadPsbtFixture(networkName, "fullsigned"));
+                fixture = loadPsbtFixture(networkName, "fullsigned");
+                fullsignedPsbtBytes = getPsbtBuffer(fixture);
                 bitgoPsbt = fixedScriptWallet.BitGoPsbt.fromBytes(fullsignedPsbtBytes, networkName);
-                rootWalletKeys = loadWalletKeysFromFixture(networkName);
+                rootWalletKeys = loadWalletKeysFromFixture(fixture);
+                replayProtectionKey = loadReplayProtectionKeyFromFixture(fixture);
             });
             it("should have matching unsigned transaction ID", function () {
                 const unsignedTxid = bitgoPsbt.unsignedTxid();
@@ -42,7 +59,7 @@ describe("parseTransactionWithWalletKeys", function () {
             });
             it("should parse transaction and identify internal/external outputs", function () {
                 const parsed = bitgoPsbt.parseTransactionWithWalletKeys(rootWalletKeys, {
-                    outputScripts: [replayProtectionScript],
+                    publicKeys: [replayProtectionKey],
                 });
                 // Verify all inputs have addresses and values
                 parsed.inputs.forEach((input, i) => {
@@ -85,10 +102,21 @@ describe("parseTransactionWithWalletKeys", function () {
                 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(), {
-                        outputScripts: [replayProtectionScript],
+                        publicKeys: [replayProtectionKey],
                     });
                 }, (error) => {
                     return error.message.includes("Failed to parse transaction: Input 0: wallet validation failed");

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

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import * as utxolib from "@bitgo/utxo-lib";
-import { fixedScriptWallet } from "../../js/index.js";
-import { loadPsbtFixture, loadWalletKeysFromFixture, getPsbtBuffer, } from "./fixtureUtil.js";
+import { fixedScriptWallet, BIP32 } from "../../js/index.js";
+import { loadPsbtFixture, loadWalletKeysFromFixture, getPsbtBuffer, loadReplayProtectionKeyFromFixture, } from "./fixtureUtil.js";
 /**
  * Get expected signature state for an input based on type and signing stage
  * @param inputType - The type of input (e.g., "p2shP2pk", "p2trMusig2")
@@ -29,7 +29,7 @@ function getExpectedSignatures(inputType, signatureStage) {
             // Regular multisig uses user + bitgo
             return { user: true, backup: false, bitgo: true };
         default:
-            throw new Error(`Unknown signature stage: ${signatureStage}`);
+            throw new Error(`Unknown signature stage: ${String(signatureStage)}`);
     }
 }
 /**
@@ -40,25 +40,45 @@ function getExpectedSignatures(inputType, signatureStage) {
  * @param inputType - The type of input (for replay protection handling)
  * @param expectedSignatures - Expected signature state for each key or replay protection
  */
-function verifyInputSignatures(bitgoPsbt, rootWalletKeys, inputIndex, expectedSignatures) {
+function verifyInputSignatures(bitgoPsbt, parsed, rootWalletKeys, replayProtectionKey, inputIndex, expectedSignatures) {
     // Handle replay protection inputs (P2shP2pk)
     if ("hasReplayProtectionSignature" in expectedSignatures) {
-        const replayProtectionScript = Buffer.from("a91420b37094d82a513451ff0ccd9db23aba05bc5ef387", "hex");
         const hasReplaySig = bitgoPsbt.verifyReplayProtectionSignature(inputIndex, {
-            outputScripts: [replayProtectionScript],
+            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 xpubs = rootWalletKeys.triple;
-    const hasUserSig = bitgoPsbt.verifySignature(inputIndex, xpubs[0].toBase58());
-    const hasBackupSig = bitgoPsbt.verifySignature(inputIndex, xpubs[1].toBase58());
-    const hasBitGoSig = bitgoPsbt.verifySignature(inputIndex, xpubs[2].toBase58());
+    const hasUserSig = bitgoPsbt.verifySignature(inputIndex, rootWalletKeys.userKey());
+    const hasBackupSig = bitgoPsbt.verifySignature(inputIndex, rootWalletKeys.backupKey());
+    const hasBitGoSig = bitgoPsbt.verifySignature(inputIndex, rootWalletKeys.bitgoKey());
     assert.strictEqual(hasUserSig, expectedSignatures.user, `Input ${inputIndex} user key signature mismatch`);
     assert.strictEqual(hasBackupSig, expectedSignatures.backup, `Input ${inputIndex} backup key signature mismatch`);
     assert.strictEqual(hasBitGoSig, expectedSignatures.bitgo, `Input ${inputIndex} BitGo key signature mismatch`);
 }
+/**
+ * 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));
+    });
+}
 describe("verifySignature", function () {
     const supportedNetworks = utxolib.getNetworkList().filter((network) => {
         return (utxolib.isMainnet(network) &&
@@ -72,6 +92,7 @@ describe("verifySignature", function () {
         const networkName = utxolib.getNetworkName(network);
         describe(`network: ${networkName}`, function () {
             let rootWalletKeys;
+            let replayProtectionKey;
             let unsignedFixture;
             let halfsignedFixture;
             let fullsignedFixture;
@@ -79,42 +100,34 @@ describe("verifySignature", function () {
             let halfsignedBitgoPsbt;
             let fullsignedBitgoPsbt;
             before(function () {
-                rootWalletKeys = loadWalletKeysFromFixture(networkName);
                 unsignedFixture = loadPsbtFixture(networkName, "unsigned");
                 halfsignedFixture = loadPsbtFixture(networkName, "halfsigned");
                 fullsignedFixture = loadPsbtFixture(networkName, "fullsigned");
+                rootWalletKeys = loadWalletKeysFromFixture(fullsignedFixture);
+                replayProtectionKey = loadReplayProtectionKeyFromFixture(fullsignedFixture);
                 unsignedBitgoPsbt = fixedScriptWallet.BitGoPsbt.fromBytes(getPsbtBuffer(unsignedFixture), networkName);
                 halfsignedBitgoPsbt = fixedScriptWallet.BitGoPsbt.fromBytes(getPsbtBuffer(halfsignedFixture), networkName);
                 fullsignedBitgoPsbt = fixedScriptWallet.BitGoPsbt.fromBytes(getPsbtBuffer(fullsignedFixture), networkName);
             });
             describe("unsigned PSBT", function () {
                 it("should return false for unsigned inputs", function () {
-                    // Verify all xpubs return false for all inputs
-                    unsignedFixture.psbtInputs.forEach((input, index) => {
-                        verifyInputSignatures(unsignedBitgoPsbt, rootWalletKeys, index, getExpectedSignatures(input.type, "unsigned"));
-                    });
+                    verifyAllInputSignatures(unsignedBitgoPsbt, unsignedFixture, rootWalletKeys, replayProtectionKey, "unsigned");
                 });
             });
             describe("half-signed PSBT", function () {
                 it("should return true for signed xpubs and false for unsigned", function () {
-                    halfsignedFixture.psbtInputs.forEach((input, index) => {
-                        verifyInputSignatures(halfsignedBitgoPsbt, rootWalletKeys, index, getExpectedSignatures(input.type, "halfsigned"));
-                    });
+                    verifyAllInputSignatures(halfsignedBitgoPsbt, halfsignedFixture, rootWalletKeys, replayProtectionKey, "halfsigned");
                 });
             });
             describe("fully signed PSBT", function () {
                 it("should have 2 signatures (2-of-3 multisig)", function () {
-                    // In fullsigned fixtures, verify 2 signatures exist per multisig input
-                    fullsignedFixture.psbtInputs.forEach((input, index) => {
-                        verifyInputSignatures(fullsignedBitgoPsbt, rootWalletKeys, index, getExpectedSignatures(input.type, "fullsigned"));
-                    });
+                    verifyAllInputSignatures(fullsignedBitgoPsbt, fullsignedFixture, rootWalletKeys, replayProtectionKey, "fullsigned");
                 });
             });
             describe("error handling", function () {
                 it("should throw error for out of bounds input index", function () {
-                    const xpubs = rootWalletKeys.triple;
                     assert.throws(() => {
-                        fullsignedBitgoPsbt.verifySignature(999, xpubs[0].toBase58());
+                        fullsignedBitgoPsbt.verifySignature(999, rootWalletKeys.userKey());
                     }, (error) => {
                         return error.message.includes("Input index 999 out of bounds");
                     }, "Should throw error for out of bounds input index");
@@ -123,18 +136,51 @@ describe("verifySignature", function () {
                     assert.throws(() => {
                         fullsignedBitgoPsbt.verifySignature(0, "invalid-xpub");
                     }, (error) => {
-                        return error.message.includes("Invalid xpub");
+                        return error.message.includes("Invalid");
                     }, "Should throw error for invalid xpub");
                 });
                 it("should return false for xpub not in derivation path", function () {
                     // 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 = utxolib.bip32.fromSeed(differentSeed, network);
+                    const differentKey = BIP32.fromSeed(differentSeed);
                     const differentXpub = differentKey.neutered();
-                    const result = fullsignedBitgoPsbt.verifySignature(0, differentXpub.toBase58());
+                    const result = fullsignedBitgoPsbt.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 () {
+                    // Verify that xpub-based verification works
+                    const userKey = rootWalletKeys.userKey();
+                    const hasXpubSig = fullsignedBitgoPsbt.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 = fullsignedBitgoPsbt.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 () {
+                    // 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 = fullsignedBitgoPsbt.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 invalidKey = Buffer.alloc(31); // Invalid length (should be 32 for private key or 33 for public key)
+                    assert.throws(() => {
+                        fullsignedBitgoPsbt.verifySignature(0, invalidKey);
+                    }, (error) => {
+                        return error.message.includes("Invalid key length");
+                    }, "Should throw error for invalid key length");
+                });
             });
         });
     });

package/dist/esm/test/fixedScriptToDescriptor.js

@@ -82,10 +82,12 @@ function runTest(scriptType, index, scope) {
         });
     });
 }
-scriptTypes.forEach((scriptType) => {
-    index.forEach((index) => {
-        scope.forEach((scope) => {
-            runTest(scriptType, index, scope);
+describe("fixedScript to descriptor", function () {
+    scriptTypes.forEach((scriptType) => {
+        index.forEach((index) => {
+            scope.forEach((scope) => {
+                runTest(scriptType, index, scope);
+            });
         });
     });
 });

package/dist/esm/test/fixtures.js

@@ -4,9 +4,13 @@ export async function getFixture(path, defaultValue) {
         return JSON.parse(await fs.readFile(path, "utf8"));
     }
     catch (e) {
-        if (e.code === "ENOENT") {
+        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/psbt.util.js

@@ -1,9 +1,6 @@
 import * as assert from "node:assert";
 import * as utxolib from "@bitgo/utxo-lib";
 import { Psbt } from "../js/index.js";
-function toAddress(descriptor, network) {
-    utxolib.address.fromOutputScript(Buffer.from(descriptor.scriptPubkey()), network);
-}
 export function toWrappedPsbt(psbt) {
     if (psbt instanceof utxolib.bitgo.UtxoPsbt || psbt instanceof utxolib.Psbt) {
         psbt = psbt.toBuffer();
@@ -69,7 +66,7 @@ function normalizeBip32Derivation(v) {
     if (!Array.isArray(v)) {
         throw new Error("Expected bip32Derivation to be an array");
     }
-    return [...v]
+    return v
         .map((e) => {
         let { path } = e;
         if (path.startsWith("m/")) {

package/dist/esm/test/psbtFixedScriptCompat.js

@@ -65,7 +65,7 @@ function describeUpdateInputWithDescriptor(psbt, scriptType) {
     });
     describe("psbt signWithXprv", function () {
         function signWithKey(keys, { checkFinalized = false } = {}) {
-            it(`signs the input with keys ${keys}`, function () {
+            it(`signs the input with keys ${keys.join(", ")}`, function () {
                 const psbt = getWrappedPsbtWithDescriptorInfo();
                 keys.forEach((keyName) => {
                     const key = keyName === "unrelated" ? getKey(keyName) : rootWalletKeys[keyName];
@@ -93,22 +93,24 @@ function describeUpdateInputWithDescriptor(psbt, scriptType) {
         signWithKey(["user", "bitgo"], { checkFinalized: true });
     });
 }
-fixtures.forEach(({ psbt, scriptType, stage }) => {
-    describe(`PSBT fixture ${scriptType} ${stage}`, function () {
-        let buf;
-        let wrappedPsbt;
-        before(function () {
-            buf = psbt.toBuffer();
-            wrappedPsbt = toWrappedPsbt(buf);
-        });
-        it("should map to same hex", function () {
-            assertEqualBuffer(buf, wrappedPsbt.serialize());
-        });
-        it("should round-trip utxolib -> ms -> utxolib", function () {
-            assertEqualBuffer(buf, toUtxoPsbt(wrappedPsbt).toBuffer());
+describe("PSBT fixture", function () {
+    fixtures.forEach(({ psbt, scriptType, stage }) => {
+        describe(`PSBT fixture ${scriptType} ${stage}`, function () {
+            let buf;
+            let wrappedPsbt;
+            before(function () {
+                buf = psbt.toBuffer();
+                wrappedPsbt = toWrappedPsbt(buf);
+            });
+            it("should map to same hex", function () {
+                assertEqualBuffer(buf, wrappedPsbt.serialize());
+            });
+            it("should round-trip utxolib -> ms -> utxolib", function () {
+                assertEqualBuffer(buf, toUtxoPsbt(wrappedPsbt).toBuffer());
+            });
+            if (stage === "bare") {
+                describeUpdateInputWithDescriptor(psbt, scriptType);
+            }
         });
-        if (stage === "bare") {
-            describeUpdateInputWithDescriptor(psbt, scriptType);
-        }
     });
 });

package/dist/esm/test/psbtFixedScriptCompatFixtures.js

@@ -14,7 +14,7 @@ export function toPsbtWithPrevOutOnly(psbt) {
             ...(witnessUtxo ? { witnessUtxo } : { nonWitnessUtxo }),
         });
     });
-    psbt.txOutputs.forEach((output, vout) => {
+    psbt.txOutputs.forEach((output) => {
         psbtCopy.addOutput(output);
     });
     return psbtCopy;

package/dist/esm/test/psbtFromDescriptor.js

@@ -8,9 +8,6 @@ import { toWrappedPsbt } from "./psbt.util.js";
 function toKeyWithPath(k, path = "*") {
     return k.neutered().toBase58() + "/" + path;
 }
-function toKeyPlain(k) {
-    return k.toString("hex");
-}
 function toECPair(k) {
     assert(k.privateKey);
     return ECPair.fromPrivateKey(k.privateKey);
@@ -39,8 +36,8 @@ function describeSignDescriptor(name, descriptor, { signBip32 = [], signECPair =
                 [isTaproot ? "Schnorr" : "Ecdsa"]: keys.map((key) => key.publicKey.subarray(isTaproot ? 1 : 0).toString("hex")),
             };
         }
-        signBip32.forEach((signSeq, i) => {
-            it(`should sign ${signSeq.map((k) => getKeyName(k))} xprv`, function () {
+        signBip32.forEach((signSeq) => {
+            it(`should sign ${signSeq.map((k) => getKeyName(k)).join(", ")} xprv`, function () {
                 const wrappedPsbt = toWrappedPsbt(psbt);
                 signSeq.forEach((key) => {
                     assert.deepStrictEqual(wrappedPsbt.signWithXprv(key.toBase58()), {
@@ -50,7 +47,7 @@ function describeSignDescriptor(name, descriptor, { signBip32 = [], signECPair =
                 });
                 wrappedPsbt.finalize();
             });
-            it(`should sign ${signSeq.map((k) => getKeyName(k))} prv buffer`, function () {
+            it(`should sign ${signSeq.map((k) => getKeyName(k)).join(", ")} prv buffer`, function () {
                 const wrappedPsbt = toWrappedPsbt(psbt);
                 signSeq.forEach((key) => {
                     assert.deepStrictEqual(wrappedPsbt.signWithPrv(key.derive(0).privateKey), {
@@ -62,8 +59,8 @@ function describeSignDescriptor(name, descriptor, { signBip32 = [], signECPair =
                 });
             });
         });
-        signECPair.forEach((signSeq, i) => {
-            it(`should sign ${signSeq.map((k) => getKeyName(k))} ec pair`, function () {
+        signECPair.forEach((signSeq) => {
+            it(`should sign ${signSeq.map((k) => getKeyName(k)).join(", ")} ec pair`, function () {
                 const wrappedPsbt = toWrappedPsbt(psbt);
                 signSeq.forEach((key) => {
                     assert(key.privateKey);

package/dist/esm/test/psbtFromDescriptor.util.js

@@ -10,7 +10,7 @@ export function toDerivedDescriptorWalletOutput(output, descriptor) {
     const derivedDescriptor = descriptor.atDerivationIndex(output.descriptorIndex);
     const script = createScriptPubKeyFromDescriptor(derivedDescriptor);
     if (!script.equals(output.witnessUtxo.script)) {
-        throw new Error(`Script mismatch: descriptor ${output.descriptorName} ${descriptor.toString()} script=${script}`);
+        throw new Error(`Script mismatch: descriptor ${output.descriptorName} ${descriptor.toString()} script=${script.toString("hex")}`);
     }
     return {
         hash: output.hash,
@@ -33,7 +33,7 @@ function updateInputsWithDescriptors(psbt, descriptors) {
         wrappedPsbt.updateInputWithDescriptor(inputIndex, descriptor);
     }
     const unwrappedPsbt = toUtxoPsbt(wrappedPsbt);
-    for (const inputIndex in psbt.txInputs) {
+    for (let inputIndex = 0; inputIndex < psbt.txInputs.length; inputIndex++) {
         psbt.data.inputs[inputIndex] = unwrappedPsbt.data.inputs[inputIndex];
     }
 }
@@ -45,7 +45,7 @@ function updateOutputsWithDescriptors(psbt, descriptors) {
         }
     }
     const unwrappedPsbt = toUtxoPsbt(wrappedPsbt);
-    for (const outputIndex in psbt.txOutputs) {
+    for (let outputIndex = 0; outputIndex < psbt.txOutputs.length; outputIndex++) {
         psbt.data.outputs[outputIndex] = unwrappedPsbt.data.outputs[outputIndex];
     }
 }

package/dist/esm/test/test.js

@@ -86,7 +86,7 @@ describe("Descriptor fixtures", function () {
                 }
                 assert.strictEqual(descriptorString, fixture.descriptor);
             });
-            it("should parse (pkType derivable)", async function () {
+            it("should parse (pkType derivable)", function () {
                 const descriptor = Descriptor.fromString(fixture.descriptor, "derivable");
                 if (isDerivable(i)) {
                     assert.doesNotThrow(() => Descriptor.fromString(fixture.descriptor, "derivable").atDerivationIndex(0));
@@ -95,8 +95,9 @@ describe("Descriptor fixtures", function () {
                     }
                     const scriptPubKey = Buffer.from(descriptor.atDerivationIndex(fixture.index ?? 0).scriptPubkey());
                     assert.strictEqual(scriptPubKey.toString("hex"), fixture.script);
-                    if (descriptor.descType() !== "Bare") {
-                        assert.strictEqual(scriptPubKey.length, getScriptPubKeyLength(descriptor.descType()), `Unexpected scriptPubKey length for descriptor ${descriptor.descType()}: ${scriptPubKey.length}`);
+                    const descType = descriptor.descType();
+                    if (descType !== "Bare") {
+                        assert.strictEqual(scriptPubKey.length, getScriptPubKeyLength(descType), `Unexpected scriptPubKey length for descriptor ${descType}: ${scriptPubKey.length}`);
                     }
                 }
                 else {
@@ -106,7 +107,7 @@ describe("Descriptor fixtures", function () {
                 assert.ok(Number.isInteger(descriptor.maxWeightToSatisfy()));
                 assertKnownDescriptorType(descriptor);
             });
-            it("can round-trip with formatNode(toWasmNode(.))", async function () {
+            it("can round-trip with formatNode(toWasmNode(.))", function () {
                 const ast = fromDescriptor(descriptor);
                 assert.strictEqual(formatNode(ast), removeChecksum(descriptor.toString()));
             });