@bitgo/wasm-utxo 1.22.0 → 1.24.0

package/dist/esm/js/fixedScriptWallet/chains.js

@@ -0,0 +1,122 @@
+/**
+ * Chain code utilities for BitGo fixed-script wallets.
+ *
+ * Chain codes define the derivation path component for different script types
+ * and scopes (external/internal) in the format `m/0/0/{chain}/{index}`.
+ */
+import { FixedScriptWalletNamespace } from "../wasm/wasm_utxo.js";
+/** All valid chain codes as a const tuple */
+export const chainCodes = [0, 1, 10, 11, 20, 21, 30, 31, 40, 41];
+// Build static lookup tables once at module load time
+const chainCodeSet = new Set(chainCodes);
+const chainToMeta = new Map();
+const scriptTypeToChain = new Map();
+// Initialize from WASM (called once at load time)
+function assertChainCode(n) {
+    if (!chainCodeSet.has(n)) {
+        throw new Error(`Invalid chain code from WASM: ${n}`);
+    }
+    return n;
+}
+function assertScope(s) {
+    if (s !== "internal" && s !== "external") {
+        throw new Error(`Invalid scope from WASM: ${s}`);
+    }
+    return s;
+}
+for (const tuple of FixedScriptWalletNamespace.chain_code_table()) {
+    if (!Array.isArray(tuple) || tuple.length !== 3) {
+        throw new Error(`Invalid chain_code_table entry: expected [number, string, string]`);
+    }
+    const [rawCode, rawScriptType, rawScope] = tuple;
+    if (typeof rawCode !== "number") {
+        throw new Error(`Invalid chain code type: ${typeof rawCode}`);
+    }
+    if (typeof rawScriptType !== "string") {
+        throw new Error(`Invalid scriptType type: ${typeof rawScriptType}`);
+    }
+    if (typeof rawScope !== "string") {
+        throw new Error(`Invalid scope type: ${typeof rawScope}`);
+    }
+    const code = assertChainCode(rawCode);
+    const scriptType = rawScriptType;
+    const scope = assertScope(rawScope);
+    chainToMeta.set(code, { scope, scriptType });
+    let entry = scriptTypeToChain.get(scriptType);
+    if (!entry) {
+        entry = {};
+        scriptTypeToChain.set(scriptType, entry);
+    }
+    entry[scope] = code;
+}
+/**
+ * ChainCode namespace with utility functions for working with chain codes.
+ */
+export const ChainCode = {
+    /**
+     * Check if a value is a valid chain code.
+     *
+     * @example
+     * ```typescript
+     * if (ChainCode.is(maybeChain)) {
+     *   // maybeChain is now typed as ChainCode
+     *   const scope = ChainCode.scope(maybeChain);
+     * }
+     * ```
+     */
+    is(n) {
+        return typeof n === "number" && chainCodeSet.has(n);
+    },
+    /**
+     * Get the chain code for a script type and scope.
+     *
+     * @example
+     * ```typescript
+     * const externalP2wsh = ChainCode.value("p2wsh", "external"); // 20
+     * const internalP2tr = ChainCode.value("p2trLegacy", "internal"); // 31
+     * ```
+     */
+    value(scriptType, scope) {
+        // legacy alias for p2trLegacy
+        if (scriptType === "p2tr") {
+            scriptType = "p2trLegacy";
+        }
+        const entry = scriptTypeToChain.get(scriptType);
+        if (!entry) {
+            throw new Error(`Invalid scriptType: ${scriptType}`);
+        }
+        return entry[scope];
+    },
+    /**
+     * Get the scope (external/internal) for a chain code.
+     *
+     * @example
+     * ```typescript
+     * ChainCode.scope(0);  // "external"
+     * ChainCode.scope(1);  // "internal"
+     * ChainCode.scope(20); // "external"
+     * ```
+     */
+    scope(chainCode) {
+        const meta = chainToMeta.get(chainCode);
+        if (!meta)
+            throw new Error(`Invalid chainCode: ${chainCode}`);
+        return meta.scope;
+    },
+    /**
+     * Get the script type for a chain code.
+     *
+     * @example
+     * ```typescript
+     * ChainCode.scriptType(0);  // "p2sh"
+     * ChainCode.scriptType(20); // "p2wsh"
+     * ChainCode.scriptType(40); // "p2trMusig2"
+     * ```
+     */
+    scriptType(chainCode) {
+        const meta = chainToMeta.get(chainCode);
+        if (!meta)
+            throw new Error(`Invalid chainCode: ${chainCode}`);
+        return meta.scriptType;
+    },
+};

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

@@ -4,6 +4,7 @@ export { ReplayProtection, type ReplayProtectionArg } from "./ReplayProtection.j
 export { outputScript, address } from "./address.js";
 export { Dimensions } from "./Dimensions.js";
 export { type OutputScriptType, type InputScriptType, type ScriptType } from "./scriptType.js";
+export { ChainCode, chainCodes, type Scope } from "./chains.js";
 export { BitGoPsbt, type NetworkName, type ScriptId, type ParsedInput, type ParsedOutput, type ParsedTransaction, type SignPath, type CreateEmptyOptions, type AddInputOptions, type AddOutputOptions, type AddWalletInputOptions, type AddWalletOutputOptions, } from "./BitGoPsbt.js";
 export { ZcashBitGoPsbt, type ZcashNetworkName, type CreateEmptyZcashOptions, } from "./ZcashBitGoPsbt.js";
 import type { ScriptType } from "./scriptType.js";

package/dist/esm/js/fixedScriptWallet/index.js

@@ -3,6 +3,7 @@ export { RootWalletKeys } from "./RootWalletKeys.js";
 export { ReplayProtection } from "./ReplayProtection.js";
 export { outputScript, address } from "./address.js";
 export { Dimensions } from "./Dimensions.js";
+export { ChainCode, chainCodes } from "./chains.js";
 // Bitcoin-like PSBT (for all non-Zcash networks)
 export { BitGoPsbt, } from "./BitGoPsbt.js";
 // Zcash-specific PSBT subclass

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

@@ -1,6 +1,7 @@
 export * as address from "./address.js";
 export * as ast from "./ast/index.js";
 export * as bip322 from "./bip322/index.js";
+export * as inscriptions from "./inscriptions.js";
 export * as utxolibCompat from "./utxolibCompat.js";
 export * as fixedScriptWallet from "./fixedScriptWallet/index.js";
 export * as bip32 from "./bip32.js";
@@ -11,6 +12,7 @@ export { Dimensions } from "./fixedScriptWallet/Dimensions.js";
 export type { CoinName } from "./coinName.js";
 export type { Triple } from "./triple.js";
 export type { AddressFormat } from "./address.js";
+export type { TapLeafScript, PreparedInscriptionRevealData } from "./inscriptions.js";
 export type DescriptorPkType = "derivable" | "definite" | "string";
 export type ScriptContext = "tap" | "segwitv0" | "legacy";
 export type SignPsbtResult = {

package/dist/esm/js/index.js

@@ -7,6 +7,7 @@ void wasm;
 export * as address from "./address.js";
 export * as ast from "./ast/index.js";
 export * as bip322 from "./bip322/index.js";
+export * as inscriptions from "./inscriptions.js";
 export * as utxolibCompat from "./utxolibCompat.js";
 export * as fixedScriptWallet from "./fixedScriptWallet/index.js";
 export * as bip32 from "./bip32.js";

package/dist/esm/js/inscriptions.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Inscription support for Bitcoin Ordinals
+ *
+ * This module provides functionality for creating and signing inscription
+ * reveal transactions following the Ordinals protocol.
+ *
+ * @see https://docs.ordinals.com/inscriptions.html
+ */
+import { Transaction } from "./transaction.js";
+import { type ECPairArg } from "./ecpair.js";
+/**
+ * Taproot leaf script data needed for spending
+ */
+export type TapLeafScript = {
+    /** Leaf version (typically 0xc0 for TapScript) */
+    leafVersion: number;
+    /** The compiled script bytes */
+    script: Uint8Array;
+    /** Control block for script path spending */
+    controlBlock: Uint8Array;
+};
+/**
+ * Prepared data for an inscription reveal transaction
+ */
+export type PreparedInscriptionRevealData = {
+    /** The commit output script (P2TR, network-agnostic) */
+    outputScript: Uint8Array;
+    /** Estimated virtual size of the reveal transaction */
+    revealTransactionVSize: number;
+    /** Tap leaf script for spending the commit output */
+    tapLeafScript: TapLeafScript;
+};
+/**
+ * Create inscription reveal data including the commit output script and tap leaf script
+ *
+ * This function creates all the data needed to perform an inscription:
+ * 1. A P2TR output script for the commit transaction (network-agnostic)
+ * 2. The tap leaf script needed to spend from that output
+ * 3. An estimate of the reveal transaction's virtual size for fee calculation
+ *
+ * @param key - The key pair (ECPairArg: Uint8Array, ECPair, or WasmECPair). The x-only public key will be extracted.
+ * @param contentType - MIME type of the inscription (e.g., "text/plain", "image/png")
+ * @param inscriptionData - The inscription data bytes
+ * @returns PreparedInscriptionRevealData containing output script, vsize estimate, and tap leaf script
+ *
+ * @example
+ * ```typescript
+ * const revealData = createInscriptionRevealData(
+ *   ecpair,
+ *   "text/plain",
+ *   new TextEncoder().encode("Hello, Ordinals!"),
+ * );
+ * // Use address.fromOutputScriptWithCoin() to get address for a specific network
+ * console.log(`Estimated reveal vsize: ${revealData.revealTransactionVSize}`);
+ * ```
+ */
+export declare function createInscriptionRevealData(key: ECPairArg, contentType: string, inscriptionData: Uint8Array): PreparedInscriptionRevealData;
+/**
+ * Sign a reveal transaction
+ *
+ * Creates and signs the reveal transaction that spends from the commit output
+ * and sends the inscription to the recipient.
+ *
+ * @param key - The private key (ECPairArg: Uint8Array, ECPair, or WasmECPair)
+ * @param tapLeafScript - The tap leaf script from createInscriptionRevealData
+ * @param commitTx - The commit transaction
+ * @param commitOutputScript - The commit output script (P2TR)
+ * @param recipientOutputScript - Where to send the inscription (output script)
+ * @param outputValueSats - Value in satoshis for the inscription output
+ * @returns The signed PSBT as bytes
+ *
+ * @example
+ * ```typescript
+ * const psbtBytes = signRevealTransaction(
+ *   privateKey,
+ *   revealData.tapLeafScript,
+ *   commitTx,
+ *   revealData.outputScript,
+ *   recipientOutputScript,
+ *   10000n, // 10,000 sats
+ * );
+ * ```
+ */
+export declare function signRevealTransaction(key: ECPairArg, tapLeafScript: TapLeafScript, commitTx: Transaction, commitOutputScript: Uint8Array, recipientOutputScript: Uint8Array, outputValueSats: bigint): Uint8Array;

package/dist/esm/js/inscriptions.js

@@ -0,0 +1,78 @@
+/**
+ * Inscription support for Bitcoin Ordinals
+ *
+ * This module provides functionality for creating and signing inscription
+ * reveal transactions following the Ordinals protocol.
+ *
+ * @see https://docs.ordinals.com/inscriptions.html
+ */
+import { InscriptionsNamespace } from "./wasm/wasm_utxo.js";
+import { ECPair } from "./ecpair.js";
+/**
+ * Create inscription reveal data including the commit output script and tap leaf script
+ *
+ * This function creates all the data needed to perform an inscription:
+ * 1. A P2TR output script for the commit transaction (network-agnostic)
+ * 2. The tap leaf script needed to spend from that output
+ * 3. An estimate of the reveal transaction's virtual size for fee calculation
+ *
+ * @param key - The key pair (ECPairArg: Uint8Array, ECPair, or WasmECPair). The x-only public key will be extracted.
+ * @param contentType - MIME type of the inscription (e.g., "text/plain", "image/png")
+ * @param inscriptionData - The inscription data bytes
+ * @returns PreparedInscriptionRevealData containing output script, vsize estimate, and tap leaf script
+ *
+ * @example
+ * ```typescript
+ * const revealData = createInscriptionRevealData(
+ *   ecpair,
+ *   "text/plain",
+ *   new TextEncoder().encode("Hello, Ordinals!"),
+ * );
+ * // Use address.fromOutputScriptWithCoin() to get address for a specific network
+ * console.log(`Estimated reveal vsize: ${revealData.revealTransactionVSize}`);
+ * ```
+ */
+export function createInscriptionRevealData(key, contentType, inscriptionData) {
+    // Convert to ECPair and extract x-only public key (strip parity byte from compressed pubkey)
+    const ecpair = ECPair.from(key);
+    const compressedPubkey = ecpair.publicKey;
+    const xOnlyPubkey = compressedPubkey.slice(1); // Remove first byte (parity)
+    // Call snake_case WASM method (traits output camelCase)
+    return InscriptionsNamespace.create_inscription_reveal_data(xOnlyPubkey, contentType, inscriptionData);
+}
+/**
+ * Sign a reveal transaction
+ *
+ * Creates and signs the reveal transaction that spends from the commit output
+ * and sends the inscription to the recipient.
+ *
+ * @param key - The private key (ECPairArg: Uint8Array, ECPair, or WasmECPair)
+ * @param tapLeafScript - The tap leaf script from createInscriptionRevealData
+ * @param commitTx - The commit transaction
+ * @param commitOutputScript - The commit output script (P2TR)
+ * @param recipientOutputScript - Where to send the inscription (output script)
+ * @param outputValueSats - Value in satoshis for the inscription output
+ * @returns The signed PSBT as bytes
+ *
+ * @example
+ * ```typescript
+ * const psbtBytes = signRevealTransaction(
+ *   privateKey,
+ *   revealData.tapLeafScript,
+ *   commitTx,
+ *   revealData.outputScript,
+ *   recipientOutputScript,
+ *   10000n, // 10,000 sats
+ * );
+ * ```
+ */
+export function signRevealTransaction(key, tapLeafScript, commitTx, commitOutputScript, recipientOutputScript, outputValueSats) {
+    // Convert to ECPair to get private key bytes
+    const ecpair = ECPair.from(key);
+    const privateKey = ecpair.privateKey;
+    if (!privateKey) {
+        throw new Error("ECPair must have a private key for signing");
+    }
+    // Call snake_case WASM method
+    return InscriptionsNamespace.sign_reveal_transaction(privateKey, tapLeafScript, commitTx.wasm, commitOutputScript, recipientOutputScript, outputValueSats);
+}

package/dist/esm/js/wasm/wasm_utxo.d.ts

@@ -479,6 +479,15 @@ export class FixedScriptWalletNamespace {
   free(): void;
   [Symbol.dispose](): void;
   static output_script(keys: WasmRootWalletKeys, chain: number, index: number, network: any): Uint8Array;
+  /**
+   * Get all chain code metadata for building TypeScript lookup tables
+   *
+   * Returns an array of [chainCode, scriptType, scope] tuples where:
+   * - chainCode: u32 (0, 1, 10, 11, 20, 21, 30, 31, 40, 41)
+   * - scriptType: string ("p2sh", "p2shP2wsh", "p2wsh", "p2trLegacy", "p2trMusig2")
+   * - scope: string ("external" or "internal")
+   */
+  static chain_code_table(): any;
   /**
    * Check if a network supports a given fixed-script wallet script type
    *
@@ -498,6 +507,42 @@ export class FixedScriptWalletNamespace {
   static address(keys: WasmRootWalletKeys, chain: number, index: number, network: any, address_format?: string | null): string;
 }
 
+export class InscriptionsNamespace {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Sign a reveal transaction
+   *
+   * # Arguments
+   * * `private_key` - The private key (32 bytes)
+   * * `tap_leaf_script` - The tap leaf script object from `create_inscription_reveal_data`
+   * * `commit_tx` - The commit transaction
+   * * `commit_output_script` - The commit output script (P2TR)
+   * * `recipient_output_script` - Where to send the inscription (output script)
+   * * `output_value_sats` - Value in satoshis for the inscription output
+   *
+   * # Returns
+   * The signed PSBT as bytes
+   */
+  static sign_reveal_transaction(private_key: Uint8Array, tap_leaf_script: any, commit_tx: WasmTransaction, commit_output_script: Uint8Array, recipient_output_script: Uint8Array, output_value_sats: bigint): Uint8Array;
+  /**
+   * Create inscription reveal data including the commit output script and tap leaf script
+   *
+   * # Arguments
+   * * `x_only_pubkey` - The x-only public key (32 bytes)
+   * * `content_type` - MIME type of the inscription (e.g., "text/plain", "image/png")
+   * * `inscription_data` - The inscription data bytes
+   *
+   * # Returns
+   * An object containing:
+   * - `output_script`: The commit output script (P2TR, network-agnostic)
+   * - `reveal_transaction_vsize`: Estimated vsize of the reveal transaction
+   * - `tap_leaf_script`: Object with `leaf_version`, `script`, and `control_block`
+   */
+  static create_inscription_reveal_data(x_only_pubkey: Uint8Array, content_type: string, inscription_data: Uint8Array): any;
+}
+
 export class UtxolibCompatNamespace {
   private constructor();
   free(): void;
@@ -654,9 +699,27 @@ export class WasmDimensions {
    */
   has_segwit(): boolean;
   /**
-   * Create dimensions for a single output from script bytes
+   * Get input virtual size (min or max)
+   *
+   * # Arguments
+   * * `size` - "min" or "max", defaults to "max"
+   */
+  get_input_vsize(size?: string | null): number;
+  /**
+   * Get input weight only (min or max)
+   *
+   * # Arguments
+   * * `size` - "min" or "max", defaults to "max"
+   */
+  get_input_weight(size?: string | null): number;
+  /**
+   * Get output virtual size
    */
-  static from_output_script(script: Uint8Array): WasmDimensions;
+  get_output_vsize(): number;
+  /**
+   * Get output weight
+   */
+  get_output_weight(): number;
   /**
    * Create dimensions for a single input from script type string
    *
@@ -665,6 +728,17 @@ export class WasmDimensions {
    *                   "p2trMusig2KeyPath", "p2trMusig2ScriptPath", "p2shP2pk"
    */
   static from_input_script_type(script_type: string): WasmDimensions;
+  /**
+   * Create dimensions for a single output from script type string
+   *
+   * # Arguments
+   * * `script_type` - One of: "p2sh", "p2shP2wsh", "p2wsh", "p2tr"/"p2trLegacy", "p2trMusig2"
+   */
+  static from_output_script_type(script_type: string): WasmDimensions;
+  /**
+   * Create dimensions for a single output from script length
+   */
+  static from_output_script_length(length: number): WasmDimensions;
   /**
    * Combine with another Dimensions instance
    */
@@ -673,6 +747,10 @@ export class WasmDimensions {
    * Create empty dimensions (zero weight)
    */
   static empty(): WasmDimensions;
+  /**
+   * Multiply dimensions by a scalar
+   */
+  times(n: number): WasmDimensions;
   /**
    * Create dimensions from a BitGoPsbt
    *