@bitgo/wasm-utxo 1.34.0 → 1.36.0

package/dist/esm/js/testutils/descriptor/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./descriptors.js";
+export * from "./mockPsbt.js";

package/dist/esm/js/testutils/descriptor/index.js

@@ -0,0 +1,2 @@
+export * from "./descriptors.js";
+export * from "./mockPsbt.js";

package/dist/esm/js/testutils/descriptor/mockPsbt.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Mock PSBT utilities for descriptor wallet testing.
+ * Ported from @bitgo/utxo-core/testutil/descriptor/mock.utils.ts.
+ *
+ * Key difference from utxo-core: returns wasm-utxo Psbt instances directly
+ * instead of utxolib.bitgo.UtxoPsbt. PsbtParams does not require a network field.
+ */
+import { Descriptor, Miniscript, Psbt } from "../../index.js";
+import { PsbtParams, DerivedDescriptorTransactionInput } from "../../descriptorWallet/index.js";
+import { DescriptorTemplate } from "./descriptors.js";
+type MockOutputIdParams = {
+    hash?: string;
+    vout?: number;
+};
+type BaseMockDescriptorOutputParams = {
+    id?: MockOutputIdParams;
+    index?: number;
+    value?: bigint;
+    sequence?: number;
+    selectTapLeafScript?: Miniscript;
+};
+export declare function mockDerivedDescriptorWalletOutput(descriptor: Descriptor, outputParams?: BaseMockDescriptorOutputParams): DerivedDescriptorTransactionInput;
+type MockInput = BaseMockDescriptorOutputParams & {
+    index: number;
+    descriptor: Descriptor;
+    selectTapLeafScript?: Miniscript;
+};
+type MockOutput = {
+    descriptor: Descriptor;
+    index: number;
+    value: bigint;
+    external?: boolean;
+};
+export declare function mockPsbt(inputs: MockInput[], outputs: MockOutput[], params?: Partial<PsbtParams>): Psbt;
+export declare function mockPsbtDefault({ descriptorSelf, descriptorOther, params, }?: {
+    descriptorSelf?: Descriptor;
+    descriptorOther?: Descriptor;
+    params?: Partial<PsbtParams>;
+}): Psbt;
+export declare function mockPsbtDefaultWithDescriptorTemplate(t: DescriptorTemplate, params?: Partial<PsbtParams>): Psbt;
+export {};

package/dist/esm/js/testutils/descriptor/mockPsbt.js

@@ -0,0 +1,56 @@
+import { createPsbt, createScriptPubKeyFromDescriptor, } from "../../descriptorWallet/index.js";
+import { getDefaultXPubs, getDescriptor, getPsbtParams, } from "./descriptors.js";
+function mockOutputId(id) {
+    const hash = id?.hash ?? "0101010101010101010101010101010101010101010101010101010101010101";
+    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, undefined),
+            value,
+        },
+        descriptor,
+        selectTapLeafScript: outputParams.selectTapLeafScript,
+        sequence: outputParams.sequence,
+    };
+}
+function tryDeriveAtIndex(descriptor, index) {
+    return descriptor.hasWildcard() ? descriptor.atDerivationIndex(index) : descriptor;
+}
+export function mockPsbt(inputs, outputs, params = {}) {
+    return createPsbt(params, inputs.map((i) => mockDerivedDescriptorWalletOutput(tryDeriveAtIndex(i.descriptor, i.index), i)), outputs.map((o) => {
+        const derivedDescriptor = tryDeriveAtIndex(o.descriptor, o.index);
+        return {
+            script: createScriptPubKeyFromDescriptor(derivedDescriptor, undefined),
+            value: o.value,
+            descriptor: o.external ? undefined : derivedDescriptor,
+        };
+    }));
+}
+export function mockPsbtDefault({ descriptorSelf = getDescriptor("Wsh2Of3", getDefaultXPubs("a")), descriptorOther = getDescriptor("Wsh2Of3", getDefaultXPubs("b")), 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);
+}
+export function mockPsbtDefaultWithDescriptorTemplate(t, params = {}) {
+    return mockPsbtDefault({
+        descriptorSelf: getDescriptor(t, getDefaultXPubs("a")),
+        descriptorOther: getDescriptor(t, getDefaultXPubs("b")),
+        params: { ...getPsbtParams(t), ...params },
+    });
+}

package/dist/esm/js/testutils/fixtures.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Return fixture described in `path`.
+ *
+ * If the file does not exist and `defaultValue` is provided,
+ * writes defaultValue to `path` and throws an error prompting
+ * the developer to inspect and re-run.
+ *
+ * @param path - Path to the fixture file (.json, .hex, or .txt)
+ * @param defaultValue - Default value to write if fixture is missing
+ * @returns The fixture content
+ */
+export declare function getFixture<T>(path: string, defaultValue?: T | (() => Promise<T>)): Promise<T>;
+/**
+ * JSON round-trip normalization.
+ * Converts a value to JSON and back, stripping non-serializable properties
+ * and normalizing types (e.g. undefined -> null in arrays).
+ */
+export declare function jsonNormalize<T>(v: T): T;
+export type ToPlainObjectOpts = {
+    propertyDescriptors?: boolean;
+    skipUndefinedValues?: boolean;
+    ignorePaths?: string[] | ((path: PathElement[]) => boolean);
+    apply?: (v: unknown, path: PathElement[]) => unknown;
+};
+export type PathElement = string | number;
+export declare function matchPath(a: PathElement[], b: PathElement[]): boolean;
+/**
+ * Recursively convert a value to a plain JSON-serializable object.
+ * Handles Uint8Array (to hex), bigint (to string), Buffer, and more.
+ *
+ * @param v - The value to convert
+ * @param opts - Options for customizing the conversion
+ * @param path - Current property path (used for ignorePaths)
+ */
+export declare function toPlainObject(v: unknown, opts?: ToPlainObjectOpts, path?: PathElement[]): unknown;

package/dist/esm/js/testutils/fixtures.js

@@ -0,0 +1,205 @@
+/// <reference types="node" />
+/**
+ * Generic test fixture and serialization utilities.
+ * Ported from @bitgo/utxo-core/testutil/fixtures.utils.ts
+ * and @bitgo/utxo-core/testutil/toPlainObject.utils.ts.
+ *
+ * NOTE: getFixture requires Node.js (fs, process.env).
+ * The toPlainObject / jsonNormalize utilities are platform-independent.
+ */
+import * as fs from "fs";
+import * as mpath from "path";
+function isNodeJsError(e) {
+    return e instanceof Error && typeof e.code === "string";
+}
+function fixtureEncoding(path) {
+    if (path.endsWith(".json")) {
+        return "json";
+    }
+    if (path.endsWith(".hex")) {
+        return "hex";
+    }
+    if (path.endsWith(".txt")) {
+        return "txt";
+    }
+    throw new Error(`unknown fixture encoding for ${path}`);
+}
+function hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    }
+    return bytes;
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function decodeFixture(raw, encoding) {
+    switch (encoding) {
+        case "json":
+            return JSON.parse(raw);
+        case "hex":
+            return hexToBytes(raw);
+        case "txt":
+            return raw;
+    }
+}
+function encodeFixture(value, encoding) {
+    switch (encoding) {
+        case "json":
+            return JSON.stringify(value, null, 2) + "\n";
+        case "hex":
+            if (!(value instanceof Uint8Array)) {
+                throw new Error(`expected Uint8Array, got ${typeof value}`);
+            }
+            return bytesToHex(value);
+        case "txt":
+            if (typeof value !== "string") {
+                throw new Error(`expected string, got ${typeof value}`);
+            }
+            return value;
+    }
+}
+/**
+ * Return fixture described in `path`.
+ *
+ * If the file does not exist and `defaultValue` is provided,
+ * writes defaultValue to `path` and throws an error prompting
+ * the developer to inspect and re-run.
+ *
+ * @param path - Path to the fixture file (.json, .hex, or .txt)
+ * @param defaultValue - Default value to write if fixture is missing
+ * @returns The fixture content
+ */
+export async function getFixture(path, defaultValue) {
+    try {
+        await fs.promises.stat(mpath.dirname(path));
+    }
+    catch (e) {
+        if (isNodeJsError(e) && e.code === "ENOENT") {
+            throw new Error(`fixture directory ${mpath.dirname(path)} not found, please create it first`);
+        }
+        throw e;
+    }
+    const encoding = fixtureEncoding(path);
+    try {
+        return decodeFixture(await fs.promises.readFile(path, "utf8"), encoding);
+    }
+    catch (e) {
+        if (isNodeJsError(e) && e.code === "ENOENT") {
+            // eslint-disable-next-line no-restricted-globals
+            if (process.env.WRITE_FIXTURES === "0") {
+                throw new Error(`fixture ${path} not found, WRITE_FIXTURES=0`);
+            }
+            if (defaultValue === undefined) {
+                throw new Error(`fixture ${path} not found and no default value given`);
+            }
+            if (typeof defaultValue === "function") {
+                defaultValue = await defaultValue();
+            }
+            await fs.promises.writeFile(path, encodeFixture(defaultValue, encoding));
+            throw new Error(`wrote default value for ${path}, please inspect and restart test`);
+        }
+        throw e;
+    }
+}
+/**
+ * JSON round-trip normalization.
+ * Converts a value to JSON and back, stripping non-serializable properties
+ * and normalizing types (e.g. undefined -> null in arrays).
+ */
+export function jsonNormalize(v) {
+    return JSON.parse(JSON.stringify(v));
+}
+export function matchPath(a, b) {
+    return a.length === b.length && a.every((e, i) => e === b[i]);
+}
+function includePath(opts, path) {
+    if (!opts.ignorePaths) {
+        return true;
+    }
+    if (typeof opts.ignorePaths === "function") {
+        return !opts.ignorePaths(path);
+    }
+    return !opts.ignorePaths.some((ignorePath) => matchPath(path, ignorePath.split(".")));
+}
+function toPlainEntries(key, value, opts, path) {
+    if (!includePath(opts, [...path, key])) {
+        return [];
+    }
+    if (value === undefined && (opts.skipUndefinedValues ?? true)) {
+        return [];
+    }
+    return [[key, toPlainObject(value, opts, [...path, key])]];
+}
+function getAllPropertyDescriptors(v) {
+    if (v === null || typeof v !== "object") {
+        return {};
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(v);
+    const proto = Object.getPrototypeOf(v);
+    if (proto) {
+        Object.assign(descriptors, getAllPropertyDescriptors(proto));
+    }
+    return descriptors;
+}
+function toPlainObjectFromPropertyDescriptors(v, opts, path) {
+    const descriptors = getAllPropertyDescriptors(v);
+    return Object.fromEntries(Object.entries(descriptors).flatMap(([key, descriptor]) => {
+        if (typeof descriptor.value === "function") {
+            return [];
+        }
+        if (descriptor.value !== undefined) {
+            return toPlainEntries(key, descriptor.value, opts, path);
+        }
+        if (typeof descriptor.get === "function") {
+            return toPlainEntries(key, descriptor.get.call(v), opts, path);
+        }
+        return [];
+    }));
+}
+/**
+ * Recursively convert a value to a plain JSON-serializable object.
+ * Handles Uint8Array (to hex), bigint (to string), Buffer, and more.
+ *
+ * @param v - The value to convert
+ * @param opts - Options for customizing the conversion
+ * @param path - Current property path (used for ignorePaths)
+ */
+export function toPlainObject(v, opts = {}, path = []) {
+    if (opts.apply) {
+        const result = opts.apply(v, path);
+        if (result !== undefined) {
+            return result;
+        }
+    }
+    switch (typeof v) {
+        case "string":
+        case "number":
+        case "boolean":
+        case "undefined":
+            return v;
+        case "bigint":
+            return v.toString();
+        case "function":
+        case "symbol":
+            return undefined;
+    }
+    if (v === null) {
+        return v;
+    }
+    if (v instanceof Uint8Array) {
+        return Array.from(v, (b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    if (Array.isArray(v)) {
+        return v.map((e, i) => toPlainObject(e, opts, [...path, i]));
+    }
+    if (typeof v === "object") {
+        const result = Object.fromEntries(Object.entries(v).flatMap(([key, value]) => toPlainEntries(key, value, opts, path)));
+        if (opts.propertyDescriptors) {
+            Object.assign(result, toPlainObjectFromPropertyDescriptors(v, opts, path));
+        }
+        return result;
+    }
+    throw new Error(`unknown v ${typeof v}`);
+}

package/dist/esm/js/testutils/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./keys.js";
 export * from "./AcidTest.js";
+export * from "./fixtures.js";
+export * as descriptor from "./descriptor/index.js";

package/dist/esm/js/testutils/index.js

@@ -1,2 +1,4 @@
 export * from "./keys.js";
 export * from "./AcidTest.js";
+export * from "./fixtures.js";
+export * as descriptor from "./descriptor/index.js";