@bitgo/wasm-utxo 1.8.0 → 1.9.0

package/dist/esm/test/opdrop.js

@@ -1,85 +0,0 @@
-import * as assert from "assert";
-import * as utxolib from "@bitgo/utxo-lib";
-import { Descriptor } from "../js/index.js";
-import { finalizePsbt, updateInputWithDescriptor } from "./psbt.util.js";
-import { getFixture } from "./fixtures.js";
-const rootWalletKeys = new utxolib.bitgo.RootWalletKeys(utxolib.testutil.getKeyTriple("wasm"));
-function getDescriptorOpDropP2ms(locktime, keys) {
-    const xpubs = keys.map((key) => key.toBase58() + "/*");
-    // the `r:` prefix is a custom BitGo modification of miniscript to allow OP_DROP
-    return `wsh(and_v(r:after(${locktime}),multi(2,${xpubs.join(",")})))`;
-}
-describe("CLV with OP_DROP", function () {
-    const locktime = 1024;
-    const descriptor = Descriptor.fromString(getDescriptorOpDropP2ms(locktime, rootWalletKeys.triple), "derivable");
-    it("has expected AST", () => {
-        assert.deepStrictEqual(descriptor.node(), {
-            Wsh: {
-                Ms: {
-                    AndV: [
-                        {
-                            Drop: {
-                                After: {
-                                    absLockTime: 1024,
-                                },
-                            },
-                        },
-                        {
-                            Multi: [
-                                2,
-                                {
-                                    XPub: "xpub661MyMwAqRbcFNusVUbSN3nbanHMtJjLgZGrs1wxH6f77kKQd6Vq4HfkZQNPC1vSbN6RTiBWJJV6FwJtCfBon2SgaT2J3MSkydukstKjwbJ/*",
-                                },
-                                {
-                                    XPub: "xpub661MyMwAqRbcFo3t7PUqvbgvAcEuuoeVib5aapsg52inrG6KGF5aNtR5ey1FNCt1zJpMQiNec5XpofQmLNRhHvQRbhkc8UsWwwMwsXW6ogU/*",
-                                },
-                                {
-                                    XPub: "xpub661MyMwAqRbcGg7f22Kcg2gy1F4jBjWR3xQTECVeJPHmxvhg5gUAZC6EYFtnyi6aMDQir1kV8HzCqC2FzTowGgEZqRh7rinqUCDeNDdmYzH/*",
-                                },
-                            ],
-                        },
-                    ],
-                },
-            },
-        });
-    });
-    it("has expected asm", () => {
-        assert.deepStrictEqual(descriptor.atDerivationIndex(0).toAsmString().split(" "), [
-            "OP_PUSHBYTES_2",
-            "0004",
-            "OP_CLTV",
-            "OP_DROP",
-            "OP_PUSHNUM_2",
-            "OP_PUSHBYTES_33",
-            "02ae7c3c0ebc315a33151a1985ebb1fdcae72b3b91c38e3193c40ebabfffe9c343",
-            "OP_PUSHBYTES_33",
-            "0260ba2407f7c75d525db9f171e9b2f3cf5ba3f0d7fc6067b20d4b91585432f974",
-            "OP_PUSHBYTES_33",
-            "03eadd6e4300dac62f1d4cf1131a06c5e140911f04245c64934c27510e93dbe843",
-            "OP_PUSHNUM_3",
-            "OP_CHECKMULTISIG",
-        ]);
-    });
-    it("can be signed", async function () {
-        const psbt = Object.assign(new utxolib.Psbt({ network: utxolib.networks.bitcoin }), {
-            locktime,
-        });
-        const signers = rootWalletKeys.triple.slice(0, 2);
-        const descriptorAt0 = descriptor.atDerivationIndex(0);
-        const script = Buffer.from(descriptorAt0.scriptPubkey());
-        psbt.addInput({
-            hash: Buffer.alloc(32),
-            index: 0,
-            sequence: 0xfffffffe,
-            witnessUtxo: { script, value: BigInt(1e8) },
-        });
-        psbt.addOutput({ script, value: BigInt(1e8) });
-        updateInputWithDescriptor(psbt, 0, descriptorAt0);
-        for (const signer of signers) {
-            psbt.signAllInputsHD(signer);
-        }
-        finalizePsbt(psbt);
-        const signedTx = psbt.extractTransaction().toBuffer();
-        assert.strictEqual(signedTx.toString("hex"), await getFixture("test/fixtures/opdrop.json", signedTx.toString("hex")));
-    });
-});

package/dist/esm/test/psbt.util.d.ts

@@ -1,8 +0,0 @@
-import * as utxolib from "@bitgo/utxo-lib";
-import { Descriptor, Psbt } from "../js/index.js";
-export declare function toWrappedPsbt(psbt: utxolib.bitgo.UtxoPsbt | utxolib.Psbt | Buffer | Uint8Array): Psbt;
-export declare function toUtxoPsbt(psbt: Psbt | Buffer | Uint8Array): utxolib.bitgo.UtxoPsbt<utxolib.bitgo.UtxoTransaction<bigint>>;
-export declare function updateInputWithDescriptor(psbt: utxolib.Psbt, inputIndex: number, descriptor: Descriptor): void;
-export declare function updateOutputWithDescriptor(psbt: utxolib.Psbt, outputIndex: number, descriptor: Descriptor): void;
-export declare function finalizePsbt(psbt: utxolib.Psbt): void;
-export declare function assertEqualPsbt(a: utxolib.Psbt, b: utxolib.Psbt): void;

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

@@ -1,113 +0,0 @@
-import * as assert from "node:assert";
-import * as utxolib from "@bitgo/utxo-lib";
-import { Psbt } from "../js/index.js";
-export function toWrappedPsbt(psbt) {
-    if (psbt instanceof utxolib.bitgo.UtxoPsbt || psbt instanceof utxolib.Psbt) {
-        psbt = psbt.toBuffer();
-    }
-    if (psbt instanceof Buffer || psbt instanceof Uint8Array) {
-        return Psbt.deserialize(psbt);
-    }
-    throw new Error("Invalid input");
-}
-export function toUtxoPsbt(psbt) {
-    if (psbt instanceof Psbt) {
-        psbt = psbt.serialize();
-    }
-    if (psbt instanceof Buffer || psbt instanceof Uint8Array) {
-        return utxolib.bitgo.UtxoPsbt.fromBuffer(Buffer.from(psbt), {
-            network: utxolib.networks.bitcoin,
-        });
-    }
-    throw new Error("Invalid input");
-}
-export function updateInputWithDescriptor(psbt, inputIndex, descriptor) {
-    const wrappedPsbt = toWrappedPsbt(psbt);
-    wrappedPsbt.updateInputWithDescriptor(inputIndex, descriptor);
-    psbt.data.inputs[inputIndex] = toUtxoPsbt(wrappedPsbt).data.inputs[inputIndex];
-}
-export function updateOutputWithDescriptor(psbt, outputIndex, descriptor) {
-    const wrappedPsbt = toWrappedPsbt(psbt);
-    wrappedPsbt.updateOutputWithDescriptor(outputIndex, descriptor);
-    psbt.data.outputs[outputIndex] = toUtxoPsbt(wrappedPsbt).data.outputs[outputIndex];
-}
-export function finalizePsbt(psbt) {
-    const wrappedPsbt = toWrappedPsbt(psbt);
-    wrappedPsbt.finalize();
-    const unwrappedPsbt = toUtxoPsbt(wrappedPsbt);
-    for (let i = 0; i < psbt.data.inputs.length; i++) {
-        psbt.data.inputs[i] = unwrappedPsbt.data.inputs[i];
-    }
-}
-function toEntries(k, v, path) {
-    if (matchPath(path, ["data", "inputs", any, "sighashType"])) {
-        return [];
-    }
-    if (matchPath(path.slice(-1), ["unknownKeyVals"])) {
-        if (Array.isArray(v) && v.length === 0) {
-            return [];
-        }
-    }
-    return [[k, toPlainObject(v, path)]];
-}
-const any = Symbol("any");
-function matchPath(path, pattern) {
-    if (path.length !== pattern.length) {
-        return false;
-    }
-    for (let i = 0; i < path.length; i++) {
-        if (pattern[i] !== any && path[i] !== pattern[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-function normalizeBip32Derivation(v) {
-    if (!Array.isArray(v)) {
-        throw new Error("Expected bip32Derivation to be an array");
-    }
-    return v
-        .map((e) => {
-        let { path } = e;
-        if (path.startsWith("m/")) {
-            path = path.slice(2);
-        }
-        return {
-            ...e,
-            path,
-        };
-    })
-        .sort((a, b) => a.masterFingerprint.toString().localeCompare(b.masterFingerprint.toString()));
-}
-function toPlainObject(v, path) {
-    // psbts have fun getters and other types of irregular properties that we mash into shape here
-    if (v === null || v === undefined) {
-        return v;
-    }
-    if (matchPath(path, ["data", "inputs", any, "bip32Derivation"]) ||
-        matchPath(path, ["data", "outputs", any, "bip32Derivation"])) {
-        v = normalizeBip32Derivation(v);
-    }
-    switch (typeof v) {
-        case "number":
-        case "bigint":
-        case "string":
-        case "boolean":
-            return v;
-        case "object":
-            if (v instanceof Buffer || v instanceof Uint8Array) {
-                return v.toString("hex");
-            }
-            if (Array.isArray(v)) {
-                return v.map((v, i) => toPlainObject(v, [...path, i]));
-            }
-            return Object.fromEntries(Object.entries(v)
-                .flatMap(([k, v]) => toEntries(k, v, [...path, k]))
-                .sort(([a], [b]) => a.localeCompare(b)));
-        default:
-            throw new Error(`Unsupported type: ${typeof v}`);
-    }
-}
-export function assertEqualPsbt(a, b) {
-    assert.deepStrictEqual(toPlainObject(a, []), toPlainObject(b, []));
-}

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

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

package/dist/esm/test/psbtFixedScriptCompat.js

@@ -1,116 +0,0 @@
-import * as utxolib from "@bitgo/utxo-lib";
-import * as assert from "node:assert";
-import { getPsbtFixtures } from "./psbtFixedScriptCompatFixtures.js";
-import { Descriptor } from "../js/index.js";
-import { getDescriptorForScriptType } from "./descriptorUtil.js";
-import { assertEqualPsbt, toUtxoPsbt, toWrappedPsbt, updateInputWithDescriptor, } from "./psbt.util.js";
-import { getKey } from "@bitgo/utxo-lib/dist/src/testutil";
-const rootWalletKeys = new utxolib.bitgo.RootWalletKeys(utxolib.testutil.getKeyTriple("wasm"));
-function assertEqualBuffer(a, b, message) {
-    assert.strictEqual(Buffer.from(a).toString("hex"), Buffer.from(b).toString("hex"), message);
-}
-const fixtures = getPsbtFixtures(rootWalletKeys);
-function describeUpdateInputWithDescriptor(psbt, scriptType) {
-    function getFixtureAtStage(stage) {
-        const f = fixtures.find((f) => f.scriptType === scriptType && f.stage === stage);
-        if (!f) {
-            throw new Error(`Could not find fixture for scriptType ${scriptType} and stage ${stage}`);
-        }
-        return f;
-    }
-    const descriptorStr = getDescriptorForScriptType(rootWalletKeys, scriptType, "internal");
-    const index = 0;
-    const descriptor = Descriptor.fromString(descriptorStr, "derivable");
-    function getWrappedPsbt() {
-        return toWrappedPsbt(psbt);
-    }
-    function getWrappedPsbtWithDescriptorInfo() {
-        const wrappedPsbt = getWrappedPsbt();
-        const descriptorAtDerivation = descriptor.atDerivationIndex(index);
-        wrappedPsbt.updateInputWithDescriptor(0, descriptorAtDerivation);
-        wrappedPsbt.updateOutputWithDescriptor(0, descriptorAtDerivation);
-        return wrappedPsbt;
-    }
-    describe("Wrapped PSBT updateInputWithDescriptor", function () {
-        it("should update the input with the descriptor", function () {
-            const wrappedPsbt = getWrappedPsbtWithDescriptorInfo();
-            const updatedPsbt = toUtxoPsbt(wrappedPsbt);
-            assertEqualPsbt(updatedPsbt, getFixtureAtStage("unsigned").psbt);
-            updatedPsbt.signAllInputsHD(rootWalletKeys.triple[0]);
-            updatedPsbt.signAllInputsHD(rootWalletKeys.triple[2]);
-            const wrappedSignedPsbt = toWrappedPsbt(updatedPsbt);
-            updatedPsbt.finalizeAllInputs();
-            wrappedSignedPsbt.finalize();
-            assertEqualBuffer(updatedPsbt.toBuffer(), wrappedSignedPsbt.serialize());
-            assertEqualBuffer(getFixtureAtStage("fullsigned")
-                .psbt.clone()
-                .finalizeAllInputs()
-                .extractTransaction()
-                .toBuffer(), updatedPsbt.extractTransaction().toBuffer());
-        });
-    });
-    describe("updateInputWithDescriptor util", function () {
-        it("should update the input with the descriptor", function () {
-            const cloned = psbt.clone();
-            updateInputWithDescriptor(cloned, 0, descriptor.atDerivationIndex(index));
-            cloned.signAllInputsHD(rootWalletKeys.triple[0]);
-            cloned.signAllInputsHD(rootWalletKeys.triple[2]);
-            cloned.finalizeAllInputs();
-            assertEqualBuffer(getFixtureAtStage("fullsigned")
-                .psbt.clone()
-                .finalizeAllInputs()
-                .extractTransaction()
-                .toBuffer(), cloned.extractTransaction().toBuffer());
-        });
-    });
-    describe("psbt signWithXprv", function () {
-        function signWithKey(keys, { checkFinalized = false } = {}) {
-            it(`signs the input with keys ${keys.join(", ")}`, function () {
-                const psbt = getWrappedPsbtWithDescriptorInfo();
-                keys.forEach((keyName) => {
-                    const key = keyName === "unrelated" ? getKey(keyName) : rootWalletKeys[keyName];
-                    const derivationPaths = toUtxoPsbt(psbt).data.inputs[0].bip32Derivation.map((d) => d.path);
-                    assert.ok(derivationPaths.every((p) => p === derivationPaths[0]));
-                    const derived = key.derivePath(derivationPaths[0]);
-                    assert.deepStrictEqual(psbt.signWithXprv(key.toBase58()), {
-                        // map: input index -> pubkey array
-                        0: { Ecdsa: keyName === "unrelated" ? [] : [derived.publicKey.toString("hex")] },
-                    });
-                });
-                if (checkFinalized) {
-                    psbt.finalize();
-                    assertEqualBuffer(toUtxoPsbt(psbt).extractTransaction().toBuffer(), getFixtureAtStage("fullsigned")
-                        .psbt.finalizeAllInputs()
-                        .extractTransaction()
-                        .toBuffer());
-                }
-            });
-        }
-        signWithKey(["user"]);
-        signWithKey(["backup"]);
-        signWithKey(["bitgo"]);
-        signWithKey(["unrelated"]);
-        signWithKey(["user", "bitgo"], { checkFinalized: true });
-    });
-}
-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);
-            }
-        });
-    });
-});

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

@@ -1,10 +0,0 @@
-import * as utxolib from "@bitgo/utxo-lib";
-import { RootWalletKeys } from "@bitgo/utxo-lib/dist/src/bitgo";
-export type PsbtStage = "bare" | "unsigned" | "halfsigned" | "fullsigned";
-export declare function toPsbtWithPrevOutOnly(psbt: utxolib.bitgo.UtxoPsbt): utxolib.bitgo.UtxoPsbt<utxolib.bitgo.UtxoTransaction<bigint>>;
-export type PsbtFixture = {
-    psbt: utxolib.bitgo.UtxoPsbt;
-    scriptType: utxolib.bitgo.outputScripts.ScriptType2Of3;
-    stage: PsbtStage;
-};
-export declare function getPsbtFixtures(keys: RootWalletKeys): PsbtFixture[];

package/dist/esm/test/psbtFixedScriptCompatFixtures.js

@@ -1,53 +0,0 @@
-import * as utxolib from "@bitgo/utxo-lib";
-export function toPsbtWithPrevOutOnly(psbt) {
-    const psbtCopy = utxolib.bitgo.UtxoPsbt.createPsbt({
-        network: utxolib.networks.bitcoin,
-    });
-    psbtCopy.setVersion(psbt.version);
-    psbtCopy.setLocktime(psbt.locktime);
-    psbt.txInputs.forEach((input, vin) => {
-        const { witnessUtxo, nonWitnessUtxo } = psbt.data.inputs[vin];
-        psbtCopy.addInput({
-            hash: input.hash,
-            index: input.index,
-            sequence: input.sequence,
-            ...(witnessUtxo ? { witnessUtxo } : { nonWitnessUtxo }),
-        });
-    });
-    psbt.txOutputs.forEach((output) => {
-        psbtCopy.addOutput(output);
-    });
-    return psbtCopy;
-}
-function getPsbtWithScriptTypeAndStage(keys, scriptType, stage) {
-    if (stage === "bare") {
-        const psbt = getPsbtWithScriptTypeAndStage(keys, scriptType, "unsigned");
-        return toPsbtWithPrevOutOnly(psbt);
-    }
-    return utxolib.testutil.constructPsbt([
-        {
-            scriptType,
-            value: BigInt(1e8),
-        },
-    ], [
-        {
-            value: BigInt(1e8 - 1000),
-            scriptType,
-            isInternalAddress: true,
-        },
-    ], utxolib.networks.bitcoin, keys, stage);
-}
-export function getPsbtFixtures(keys) {
-    const testMatrixScriptTypes = ["p2sh", "p2shP2wsh", "p2wsh"];
-    const testMatrixStages = ["bare", "unsigned", "halfsigned", "fullsigned"];
-    return testMatrixStages.flatMap((stage) => {
-        return testMatrixScriptTypes.map((scriptType) => {
-            return {
-                psbt: getPsbtWithScriptTypeAndStage(keys, scriptType, stage),
-                name: `${scriptType}-${stage}`,
-                scriptType,
-                stage,
-            };
-        });
-    });
-}

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

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

package/dist/esm/test/psbtFromDescriptor.js

@@ -1,104 +0,0 @@
-import assert from "node:assert";
-import { ECPair } from "@bitgo/utxo-lib";
-import { getKey } from "@bitgo/utxo-lib/dist/src/testutil";
-import { formatNode } from "../js/ast/index.js";
-import { mockPsbtDefault } from "./psbtFromDescriptor.util.js";
-import { Descriptor } from "../js/index.js";
-import { toWrappedPsbt } from "./psbt.util.js";
-function toKeyWithPath(k, path = "*") {
-    return k.neutered().toBase58() + "/" + path;
-}
-function toECPair(k) {
-    assert(k.privateKey);
-    return ECPair.fromPrivateKey(k.privateKey);
-}
-function toKeyPlainXOnly(k) {
-    return k.subarray(1).toString("hex");
-}
-const external = getKey("external");
-const a = getKey("a");
-const b = getKey("b");
-const c = getKey("c");
-const keys = { external, a, b, c };
-function getKeyName(k) {
-    const objKeys = Object.keys(keys);
-    return objKeys.find((key) => keys[key] === k || toECPair(keys[key]).publicKey.equals(k.publicKey));
-}
-function describeSignDescriptor(name, descriptor, { signBip32 = [], signECPair = [], }) {
-    describe(`psbt with descriptor ${name}`, function () {
-        const isTaproot = Object.keys(descriptor.node())[0] === "Tr";
-        const psbt = mockPsbtDefault({
-            descriptorSelf: descriptor,
-            descriptorOther: Descriptor.fromString(formatNode({ wpkh: toKeyWithPath(external) }), "derivable"),
-        });
-        function getSigResult(keys) {
-            return {
-                [isTaproot ? "Schnorr" : "Ecdsa"]: keys.map((key) => key.publicKey.subarray(isTaproot ? 1 : 0).toString("hex")),
-            };
-        }
-        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()), {
-                        0: getSigResult([key.derive(0)]),
-                        1: getSigResult([key.derive(1)]),
-                    });
-                });
-                wrappedPsbt.finalize();
-            });
-            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), {
-                        // NOTE: signing with a plain derived key does not work for taproot
-                        // see SingleKeySigner implementation in psbt.rs for details
-                        0: getSigResult(isTaproot ? [] : [key.derive(0)]),
-                        1: getSigResult([]),
-                    });
-                });
-            });
-        });
-        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);
-                    assert.deepStrictEqual(wrappedPsbt.signWithPrv(key.privateKey), {
-                        0: getSigResult([key]),
-                        1: getSigResult([key]),
-                    });
-                });
-                wrappedPsbt.finalize();
-            });
-        });
-    });
-}
-function fromNodes(node, type) {
-    return Descriptor.fromString(formatNode(node), type);
-}
-describeSignDescriptor("Wsh2Of3", fromNodes({
-    wsh: { multi: [2, toKeyWithPath(a), toKeyWithPath(b), toKeyWithPath(c)] },
-}, "derivable"), {
-    signBip32: [
-        [a, b],
-        [b, a],
-    ],
-});
-describeSignDescriptor("Tr1Of3", fromNodes({
-    tr: [toKeyWithPath(a), [{ pk: toKeyWithPath(b) }, { pk: toKeyWithPath(c) }]],
-}, "derivable"), { signBip32: [[a], [b], [c]] });
-describeSignDescriptor("TrWithExternalPlain", fromNodes({
-    tr: [
-        toKeyPlainXOnly(external.publicKey),
-        [
-            { pk: toKeyPlainXOnly(external.publicKey) },
-            {
-                or_b: [
-                    { pk: toKeyPlainXOnly(external.publicKey) },
-                    { "s:pk": toKeyPlainXOnly(a.publicKey) },
-                ],
-            },
-        ],
-    ],
-}, "definite"), { signECPair: [[toECPair(a)]] });

package/dist/esm/test/psbtFromDescriptor.util.d.ts

@@ -1,63 +0,0 @@
-import * as utxolib from "@bitgo/utxo-lib";
-import { Descriptor } from "../js/index.js";
-export declare function createScriptPubKeyFromDescriptor(descriptor: Descriptor, index?: number): Buffer;
-export type Output = {
-    script: Buffer;
-    value: bigint;
-};
-export type WithDescriptor<T> = T & {
-    descriptor: Descriptor;
-};
-export type PrevOutput = {
-    hash: string;
-    index: number;
-    witnessUtxo: Output;
-};
-export type DescriptorWalletOutput = PrevOutput & {
-    descriptorName: string;
-    descriptorIndex: number;
-};
-export type DerivedDescriptorWalletOutput = WithDescriptor<PrevOutput>;
-export declare function toDerivedDescriptorWalletOutput(output: DescriptorWalletOutput, descriptor: Descriptor): DerivedDescriptorWalletOutput;
-/**
- * Non-Final (Replaceable)
- * Reference: https://github.com/bitcoin/bitcoin/blob/v25.1/src/rpc/rawtransaction_util.cpp#L49
- * */
-export declare const MAX_BIP125_RBF_SEQUENCE: number;
-type WithOptDescriptor<T> = T & {
-    descriptor?: Descriptor;
-};
-export declare function createPsbt(params: PsbtParams, inputs: DerivedDescriptorWalletOutput[], outputs: WithOptDescriptor<Output>[]): utxolib.bitgo.UtxoPsbt;
-type MockOutputIdParams = {
-    hash?: string;
-    vout?: number;
-};
-type BaseMockDescriptorOutputParams = {
-    id?: MockOutputIdParams;
-    index?: number;
-    value?: bigint;
-};
-export declare function mockDerivedDescriptorWalletOutput(descriptor: Descriptor, outputParams?: BaseMockDescriptorOutputParams): DerivedDescriptorWalletOutput;
-type MockInput = BaseMockDescriptorOutputParams & {
-    index: number;
-    descriptor: Descriptor;
-};
-type MockOutput = {
-    descriptor: Descriptor;
-    index: number;
-    value: bigint;
-    external?: boolean;
-};
-export declare function mockPsbt(inputs: MockInput[], outputs: MockOutput[], params?: Partial<PsbtParams>): utxolib.bitgo.UtxoPsbt;
-export type PsbtParams = {
-    network: utxolib.Network;
-    version?: number;
-    locktime?: number;
-    sequence?: number;
-};
-export declare function mockPsbtDefault({ descriptorSelf, descriptorOther, params, }: {
-    descriptorSelf: Descriptor;
-    descriptorOther: Descriptor;
-    params?: Partial<PsbtParams>;
-}): utxolib.bitgo.UtxoPsbt;
-export {};

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

@@ -1,101 +0,0 @@
-import * as utxolib from "@bitgo/utxo-lib";
-import { toUtxoPsbt, toWrappedPsbt } from "./psbt.util.js";
-export function createScriptPubKeyFromDescriptor(descriptor, index) {
-    if (index === undefined) {
-        return Buffer.from(descriptor.scriptPubkey());
-    }
-    return createScriptPubKeyFromDescriptor(descriptor.atDerivationIndex(index));
-}
-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.toString("hex")}`);
-    }
-    return {
-        hash: output.hash,
-        index: output.index,
-        witnessUtxo: output.witnessUtxo,
-        descriptor: descriptor.atDerivationIndex(output.descriptorIndex),
-    };
-}
-/**
- * Non-Final (Replaceable)
- * Reference: https://github.com/bitcoin/bitcoin/blob/v25.1/src/rpc/rawtransaction_util.cpp#L49
- * */
-export const MAX_BIP125_RBF_SEQUENCE = 0xffffffff - 2;
-function updateInputsWithDescriptors(psbt, descriptors) {
-    if (psbt.txInputs.length !== descriptors.length) {
-        throw new Error(`Input count mismatch (psbt=${psbt.txInputs.length}, descriptors=${descriptors.length})`);
-    }
-    const wrappedPsbt = toWrappedPsbt(psbt);
-    for (const [inputIndex, descriptor] of descriptors.entries()) {
-        wrappedPsbt.updateInputWithDescriptor(inputIndex, descriptor);
-    }
-    const unwrappedPsbt = toUtxoPsbt(wrappedPsbt);
-    for (let inputIndex = 0; inputIndex < psbt.txInputs.length; inputIndex++) {
-        psbt.data.inputs[inputIndex] = unwrappedPsbt.data.inputs[inputIndex];
-    }
-}
-function updateOutputsWithDescriptors(psbt, descriptors) {
-    const wrappedPsbt = toWrappedPsbt(psbt);
-    for (const [outputIndex, { descriptor }] of descriptors.entries()) {
-        if (descriptor) {
-            wrappedPsbt.updateOutputWithDescriptor(outputIndex, descriptor);
-        }
-    }
-    const unwrappedPsbt = toUtxoPsbt(wrappedPsbt);
-    for (let outputIndex = 0; outputIndex < psbt.txOutputs.length; outputIndex++) {
-        psbt.data.outputs[outputIndex] = unwrappedPsbt.data.outputs[outputIndex];
-    }
-}
-export function createPsbt(params, inputs, outputs) {
-    const psbt = utxolib.bitgo.UtxoPsbt.createPsbt({ network: params.network });
-    psbt.setVersion(params.version ?? 2);
-    psbt.setLocktime(params.locktime ?? 0);
-    psbt.addInputs(inputs.map((i) => ({ ...i, sequence: params.sequence ?? MAX_BIP125_RBF_SEQUENCE })));
-    psbt.addOutputs(outputs);
-    updateInputsWithDescriptors(psbt, inputs.map((i) => i.descriptor));
-    updateOutputsWithDescriptors(psbt, outputs);
-    return psbt;
-}
-function mockOutputId(id) {
-    const hash = id?.hash ?? Buffer.alloc(32, 1).toString("hex");
-    const vout = id?.vout ?? 0;
-    return { hash, vout };
-}
-export function mockDerivedDescriptorWalletOutput(descriptor, outputParams = {}) {
-    const { value = BigInt(1e6) } = outputParams;
-    const { hash, vout } = mockOutputId(outputParams.id);
-    return {
-        hash,
-        index: vout,
-        witnessUtxo: {
-            script: createScriptPubKeyFromDescriptor(descriptor),
-            value,
-        },
-        descriptor,
-    };
-}
-function deriveIfWildcard(descriptor, index) {
-    return descriptor.hasWildcard() ? descriptor.atDerivationIndex(index) : descriptor;
-}
-export function mockPsbt(inputs, outputs, params = {}) {
-    return createPsbt({ ...params, network: params.network ?? utxolib.networks.bitcoin }, inputs.map((i) => mockDerivedDescriptorWalletOutput(deriveIfWildcard(i.descriptor, i.index), i)), outputs.map((o) => {
-        const derivedDescriptor = deriveIfWildcard(o.descriptor, o.index);
-        return {
-            script: createScriptPubKeyFromDescriptor(derivedDescriptor),
-            value: o.value,
-            descriptor: o.external ? undefined : derivedDescriptor,
-        };
-    }));
-}
-export function mockPsbtDefault({ descriptorSelf, descriptorOther, params = {}, }) {
-    return mockPsbt([
-        { descriptor: descriptorSelf, index: 0 },
-        { descriptor: descriptorSelf, index: 1, id: { vout: 1 } },
-    ], [
-        { descriptor: descriptorOther, index: 0, value: BigInt(4e5), external: true },
-        { descriptor: descriptorSelf, index: 0, value: BigInt(4e5) },
-    ], params);
-}

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

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