@bitgo/wasm-utxo 1.22.0 → 1.24.0

package/dist/cjs/js/fixedScriptWallet/Dimensions.d.ts

@@ -1,5 +1,6 @@
 import type { BitGoPsbt, InputScriptType, SignPath } from "./BitGoPsbt.js";
 import type { CoinName } from "../coinName.js";
+import type { OutputScriptType } from "./scriptType.js";
 type FromInputParams = {
     chain: number;
     signPath?: SignPath;
@@ -43,10 +44,26 @@ export declare class Dimensions {
      * Create dimensions for a single output from an address
      */
     static fromOutput(address: string, network: CoinName): Dimensions;
+    /**
+     * Create dimensions for a single output from script length only
+     */
+    static fromOutput(params: {
+        length: number;
+    }): Dimensions;
+    /**
+     * Create dimensions for a single output from script type
+     */
+    static fromOutput(params: {
+        scriptType: OutputScriptType;
+    }): Dimensions;
     /**
      * Combine with another Dimensions instance
      */
     plus(other: Dimensions): Dimensions;
+    /**
+     * Multiply dimensions by a scalar
+     */
+    times(n: number): Dimensions;
     /**
      * Whether any inputs are segwit (affects overhead calculation)
      */
@@ -61,5 +78,23 @@ export declare class Dimensions {
      * @param size - "min" or "max", defaults to "max"
      */
     getVSize(size?: "min" | "max"): number;
+    /**
+     * Get input weight only (min or max)
+     * @param size - "min" or "max", defaults to "max"
+     */
+    getInputWeight(size?: "min" | "max"): number;
+    /**
+     * Get input virtual size (min or max)
+     * @param size - "min" or "max", defaults to "max"
+     */
+    getInputVSize(size?: "min" | "max"): number;
+    /**
+     * Get output weight
+     */
+    getOutputWeight(): number;
+    /**
+     * Get output virtual size
+     */
+    getOutputVSize(): number;
 }
 export {};

package/dist/cjs/js/fixedScriptWallet/Dimensions.js

@@ -43,15 +43,19 @@ class Dimensions {
         }
         return new Dimensions(wasm_utxo_js_1.WasmDimensions.from_input(params.chain, params.signPath?.signer, params.signPath?.cosigner));
     }
-    static fromOutput(scriptOrAddress, network) {
-        if (typeof scriptOrAddress === "string") {
+    static fromOutput(params, network) {
+        if (typeof params === "string") {
             if (network === undefined) {
                 throw new Error("network is required when passing an address string");
             }
-            const script = (0, address_js_1.toOutputScriptWithCoin)(scriptOrAddress, network);
-            return new Dimensions(wasm_utxo_js_1.WasmDimensions.from_output_script(script));
+            const script = (0, address_js_1.toOutputScriptWithCoin)(params, network);
+            return new Dimensions(wasm_utxo_js_1.WasmDimensions.from_output_script_length(script.length));
         }
-        return new Dimensions(wasm_utxo_js_1.WasmDimensions.from_output_script(scriptOrAddress));
+        if (typeof params === "object" && "scriptType" in params) {
+            return new Dimensions(wasm_utxo_js_1.WasmDimensions.from_output_script_type(params.scriptType));
+        }
+        // Both Uint8Array and { length: number } have .length
+        return new Dimensions(wasm_utxo_js_1.WasmDimensions.from_output_script_length(params.length));
     }
     /**
      * Combine with another Dimensions instance
@@ -59,6 +63,12 @@ class Dimensions {
     plus(other) {
         return new Dimensions(this._wasm.plus(other._wasm));
     }
+    /**
+     * Multiply dimensions by a scalar
+     */
+    times(n) {
+        return new Dimensions(this._wasm.times(n));
+    }
     /**
      * Whether any inputs are segwit (affects overhead calculation)
      */
@@ -79,5 +89,31 @@ class Dimensions {
     getVSize(size = "max") {
         return this._wasm.get_vsize(size);
     }
+    /**
+     * Get input weight only (min or max)
+     * @param size - "min" or "max", defaults to "max"
+     */
+    getInputWeight(size = "max") {
+        return this._wasm.get_input_weight(size);
+    }
+    /**
+     * Get input virtual size (min or max)
+     * @param size - "min" or "max", defaults to "max"
+     */
+    getInputVSize(size = "max") {
+        return this._wasm.get_input_vsize(size);
+    }
+    /**
+     * Get output weight
+     */
+    getOutputWeight() {
+        return this._wasm.get_output_weight();
+    }
+    /**
+     * Get output virtual size
+     */
+    getOutputVSize() {
+        return this._wasm.get_output_vsize();
+    }
 }
 exports.Dimensions = Dimensions;

package/dist/cjs/js/fixedScriptWallet/chains.d.ts

@@ -0,0 +1,56 @@
+import type { OutputScriptType } from "./scriptType.js";
+/** All valid chain codes as a const tuple */
+export declare const chainCodes: readonly [0, 1, 10, 11, 20, 21, 30, 31, 40, 41];
+/** A valid chain code value */
+export type ChainCode = (typeof chainCodes)[number];
+/** Whether a chain is for receiving (external) or change (internal) addresses */
+export type Scope = "internal" | "external";
+/**
+ * ChainCode namespace with utility functions for working with chain codes.
+ */
+export declare 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: unknown): n is ChainCode;
+    /**
+     * 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: OutputScriptType | "p2tr", scope: Scope): ChainCode;
+    /**
+     * 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: ChainCode): 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: ChainCode): OutputScriptType;
+};

package/dist/cjs/js/fixedScriptWallet/chains.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainCode = exports.chainCodes = void 0;
+/**
+ * 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}`.
+ */
+const wasm_utxo_js_1 = require("../wasm/wasm_utxo.js");
+/** All valid chain codes as a const tuple */
+exports.chainCodes = [0, 1, 10, 11, 20, 21, 30, 31, 40, 41];
+// Build static lookup tables once at module load time
+const chainCodeSet = new Set(exports.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 wasm_utxo_js_1.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.
+ */
+exports.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/cjs/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/cjs/js/fixedScriptWallet/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZcashBitGoPsbt = exports.BitGoPsbt = exports.Dimensions = exports.address = exports.outputScript = exports.ReplayProtection = exports.RootWalletKeys = void 0;
+exports.ZcashBitGoPsbt = exports.BitGoPsbt = exports.chainCodes = exports.ChainCode = exports.Dimensions = exports.address = exports.outputScript = exports.ReplayProtection = exports.RootWalletKeys = void 0;
 exports.supportsScriptType = supportsScriptType;
 const wasm_utxo_js_1 = require("../wasm/wasm_utxo.js");
 var RootWalletKeys_js_1 = require("./RootWalletKeys.js");
@@ -12,6 +12,9 @@ Object.defineProperty(exports, "outputScript", { enumerable: true, get: function
 Object.defineProperty(exports, "address", { enumerable: true, get: function () { return address_js_1.address; } });
 var Dimensions_js_1 = require("./Dimensions.js");
 Object.defineProperty(exports, "Dimensions", { enumerable: true, get: function () { return Dimensions_js_1.Dimensions; } });
+var chains_js_1 = require("./chains.js");
+Object.defineProperty(exports, "ChainCode", { enumerable: true, get: function () { return chains_js_1.ChainCode; } });
+Object.defineProperty(exports, "chainCodes", { enumerable: true, get: function () { return chains_js_1.chainCodes; } });
 // Bitcoin-like PSBT (for all non-Zcash networks)
 var BitGoPsbt_js_1 = require("./BitGoPsbt.js");
 Object.defineProperty(exports, "BitGoPsbt", { enumerable: true, get: function () { return BitGoPsbt_js_1.BitGoPsbt; } });

package/dist/cjs/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/cjs/js/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZcashTransaction = exports.Transaction = exports.DashTransaction = exports.Psbt = exports.Miniscript = exports.Descriptor = exports.Dimensions = exports.BIP32 = exports.ECPair = exports.ecpair = exports.bip32 = exports.fixedScriptWallet = exports.utxolibCompat = exports.bip322 = exports.ast = exports.address = void 0;
+exports.ZcashTransaction = exports.Transaction = exports.DashTransaction = exports.Psbt = exports.Miniscript = exports.Descriptor = exports.Dimensions = exports.BIP32 = exports.ECPair = exports.ecpair = exports.bip32 = exports.fixedScriptWallet = exports.utxolibCompat = exports.inscriptions = exports.bip322 = exports.ast = exports.address = void 0;
 const wasm = __importStar(require("./wasm/wasm_utxo.js"));
 // we need to access the wasm module here, otherwise webpack gets all weird
 // and forgets to include it in the bundle
@@ -43,6 +43,7 @@ void wasm;
 exports.address = __importStar(require("./address.js"));
 exports.ast = __importStar(require("./ast/index.js"));
 exports.bip322 = __importStar(require("./bip322/index.js"));
+exports.inscriptions = __importStar(require("./inscriptions.js"));
 exports.utxolibCompat = __importStar(require("./utxolibCompat.js"));
 exports.fixedScriptWallet = __importStar(require("./fixedScriptWallet/index.js"));
 exports.bip32 = __importStar(require("./bip32.js"));

package/dist/cjs/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/cjs/js/inscriptions.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInscriptionRevealData = createInscriptionRevealData;
+exports.signRevealTransaction = signRevealTransaction;
+const wasm_utxo_js_1 = require("./wasm/wasm_utxo.js");
+const ecpair_js_1 = require("./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}`);
+ * ```
+ */
+function createInscriptionRevealData(key, contentType, inscriptionData) {
+    // Convert to ECPair and extract x-only public key (strip parity byte from compressed pubkey)
+    const ecpair = ecpair_js_1.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 wasm_utxo_js_1.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
+ * );
+ * ```
+ */
+function signRevealTransaction(key, tapLeafScript, commitTx, commitOutputScript, recipientOutputScript, outputValueSats) {
+    // Convert to ECPair to get private key bytes
+    const ecpair = ecpair_js_1.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 wasm_utxo_js_1.InscriptionsNamespace.sign_reveal_transaction(privateKey, tapLeafScript, commitTx.wasm, commitOutputScript, recipientOutputScript, outputValueSats);
+}

package/dist/cjs/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
    *