@bitgo/wasm-utxo 1.22.0 → 1.23.0

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

@@ -47,6 +47,10 @@ export declare class 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 +65,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

@@ -59,6 +59,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 +85,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/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
    *
@@ -653,6 +662,28 @@ export class WasmDimensions {
    * Whether any inputs are segwit (affects overhead calculation)
    */
   has_segwit(): boolean;
+  /**
+   * 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
+   */
+  get_output_vsize(): number;
+  /**
+   * Get output weight
+   */
+  get_output_weight(): number;
   /**
    * Create dimensions for a single output from script bytes
    */
@@ -673,6 +704,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
    *

package/dist/cjs/js/wasm/wasm_utxo.js

@@ -1519,6 +1519,19 @@ class FixedScriptWalletNamespace {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * 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")
+     * @returns {any}
+     */
+    static chain_code_table() {
+        const ret = wasm.fixedscriptwalletnamespace_chain_code_table();
+        return takeObject(ret);
+    }
     /**
      * Check if a network supports a given fixed-script wallet script type
      *
@@ -2182,6 +2195,50 @@ class WasmDimensions {
         const ret = wasm.wasmdimensions_has_segwit(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Get input virtual size (min or max)
+     *
+     * # Arguments
+     * * `size` - "min" or "max", defaults to "max"
+     * @param {string | null} [size]
+     * @returns {number}
+     */
+    get_input_vsize(size) {
+        var ptr0 = isLikeNone(size) ? 0 : passStringToWasm0(size, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmdimensions_get_input_vsize(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * Get input weight only (min or max)
+     *
+     * # Arguments
+     * * `size` - "min" or "max", defaults to "max"
+     * @param {string | null} [size]
+     * @returns {number}
+     */
+    get_input_weight(size) {
+        var ptr0 = isLikeNone(size) ? 0 : passStringToWasm0(size, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmdimensions_get_input_weight(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * Get output virtual size
+     * @returns {number}
+     */
+    get_output_vsize() {
+        const ret = wasm.wasmdimensions_get_output_vsize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get output weight
+     * @returns {number}
+     */
+    get_output_weight() {
+        const ret = wasm.wasmdimensions_get_output_weight(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Create dimensions for a single output from script bytes
      * @param {Uint8Array} script
@@ -2237,6 +2294,15 @@ class WasmDimensions {
         const ret = wasm.wasmdimensions_empty();
         return WasmDimensions.__wrap(ret);
     }
+    /**
+     * Multiply dimensions by a scalar
+     * @param {number} n
+     * @returns {WasmDimensions}
+     */
+    times(n) {
+        const ret = wasm.wasmdimensions_times(this.__wbg_ptr, n);
+        return WasmDimensions.__wrap(ret);
+    }
     /**
      * Create dimensions from a BitGoPsbt
      *

package/dist/cjs/js/wasm/wasm_utxo_bg.wasm.d.ts

@@ -84,6 +84,7 @@ export const bitgopsbt_verify_signature_with_xpub: (a: number, b: number, c: num
 export const bitgopsbt_version: (a: number) => number;
 export const bitgopsbt_version_group_id: (a: number) => number;
 export const fixedscriptwalletnamespace_address: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const fixedscriptwalletnamespace_chain_code_table: () => number;
 export const fixedscriptwalletnamespace_output_script: (a: number, b: number, c: number, d: number, e: number) => void;
 export const fixedscriptwalletnamespace_supports_script_type: (a: number, b: number, c: number, d: number, e: number) => void;
 export const utxolibcompatnamespace_from_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
@@ -115,10 +116,15 @@ export const wasmdimensions_from_input: (a: number, b: number, c: number, d: num
 export const wasmdimensions_from_input_script_type: (a: number, b: number, c: number) => void;
 export const wasmdimensions_from_output_script: (a: number, b: number) => number;
 export const wasmdimensions_from_psbt: (a: number, b: number) => void;
+export const wasmdimensions_get_input_vsize: (a: number, b: number, c: number) => number;
+export const wasmdimensions_get_input_weight: (a: number, b: number, c: number) => number;
+export const wasmdimensions_get_output_vsize: (a: number) => number;
+export const wasmdimensions_get_output_weight: (a: number) => number;
 export const wasmdimensions_get_vsize: (a: number, b: number, c: number) => number;
 export const wasmdimensions_get_weight: (a: number, b: number, c: number) => number;
 export const wasmdimensions_has_segwit: (a: number) => number;
 export const wasmdimensions_plus: (a: number, b: number) => number;
+export const wasmdimensions_times: (a: number, b: number) => number;
 export const wasmecpair_from_private_key: (a: number, b: number, c: number) => void;
 export const wasmecpair_from_public_key: (a: number, b: number, c: number) => void;
 export const wasmecpair_from_wif: (a: number, b: number, c: number) => void;

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

@@ -47,6 +47,10 @@ export declare class 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 +65,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/esm/js/fixedScriptWallet/Dimensions.js

@@ -56,6 +56,12 @@ export 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)
      */
@@ -76,4 +82,30 @@ export 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();
+    }
 }

package/dist/esm/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/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/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
    *
@@ -653,6 +662,28 @@ export class WasmDimensions {
    * Whether any inputs are segwit (affects overhead calculation)
    */
   has_segwit(): boolean;
+  /**
+   * 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
+   */
+  get_output_vsize(): number;
+  /**
+   * Get output weight
+   */
+  get_output_weight(): number;
   /**
    * Create dimensions for a single output from script bytes
    */
@@ -673,6 +704,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
    *

package/dist/esm/js/wasm/wasm_utxo_bg.js

@@ -1525,6 +1525,19 @@ export class FixedScriptWalletNamespace {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * 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")
+     * @returns {any}
+     */
+    static chain_code_table() {
+        const ret = wasm.fixedscriptwalletnamespace_chain_code_table();
+        return takeObject(ret);
+    }
     /**
      * Check if a network supports a given fixed-script wallet script type
      *
@@ -2184,6 +2197,50 @@ export class WasmDimensions {
         const ret = wasm.wasmdimensions_has_segwit(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Get input virtual size (min or max)
+     *
+     * # Arguments
+     * * `size` - "min" or "max", defaults to "max"
+     * @param {string | null} [size]
+     * @returns {number}
+     */
+    get_input_vsize(size) {
+        var ptr0 = isLikeNone(size) ? 0 : passStringToWasm0(size, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmdimensions_get_input_vsize(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * Get input weight only (min or max)
+     *
+     * # Arguments
+     * * `size` - "min" or "max", defaults to "max"
+     * @param {string | null} [size]
+     * @returns {number}
+     */
+    get_input_weight(size) {
+        var ptr0 = isLikeNone(size) ? 0 : passStringToWasm0(size, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmdimensions_get_input_weight(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * Get output virtual size
+     * @returns {number}
+     */
+    get_output_vsize() {
+        const ret = wasm.wasmdimensions_get_output_vsize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get output weight
+     * @returns {number}
+     */
+    get_output_weight() {
+        const ret = wasm.wasmdimensions_get_output_weight(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Create dimensions for a single output from script bytes
      * @param {Uint8Array} script
@@ -2239,6 +2296,15 @@ export class WasmDimensions {
         const ret = wasm.wasmdimensions_empty();
         return WasmDimensions.__wrap(ret);
     }
+    /**
+     * Multiply dimensions by a scalar
+     * @param {number} n
+     * @returns {WasmDimensions}
+     */
+    times(n) {
+        const ret = wasm.wasmdimensions_times(this.__wbg_ptr, n);
+        return WasmDimensions.__wrap(ret);
+    }
     /**
      * Create dimensions from a BitGoPsbt
      *

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

@@ -84,6 +84,7 @@ export const bitgopsbt_verify_signature_with_xpub: (a: number, b: number, c: num
 export const bitgopsbt_version: (a: number) => number;
 export const bitgopsbt_version_group_id: (a: number) => number;
 export const fixedscriptwalletnamespace_address: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const fixedscriptwalletnamespace_chain_code_table: () => number;
 export const fixedscriptwalletnamespace_output_script: (a: number, b: number, c: number, d: number, e: number) => void;
 export const fixedscriptwalletnamespace_supports_script_type: (a: number, b: number, c: number, d: number, e: number) => void;
 export const utxolibcompatnamespace_from_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
@@ -115,10 +116,15 @@ export const wasmdimensions_from_input: (a: number, b: number, c: number, d: num
 export const wasmdimensions_from_input_script_type: (a: number, b: number, c: number) => void;
 export const wasmdimensions_from_output_script: (a: number, b: number) => number;
 export const wasmdimensions_from_psbt: (a: number, b: number) => void;
+export const wasmdimensions_get_input_vsize: (a: number, b: number, c: number) => number;
+export const wasmdimensions_get_input_weight: (a: number, b: number, c: number) => number;
+export const wasmdimensions_get_output_vsize: (a: number) => number;
+export const wasmdimensions_get_output_weight: (a: number) => number;
 export const wasmdimensions_get_vsize: (a: number, b: number, c: number) => number;
 export const wasmdimensions_get_weight: (a: number, b: number, c: number) => number;
 export const wasmdimensions_has_segwit: (a: number) => number;
 export const wasmdimensions_plus: (a: number, b: number) => number;
+export const wasmdimensions_times: (a: number, b: number) => number;
 export const wasmecpair_from_private_key: (a: number, b: number, c: number) => void;
 export const wasmecpair_from_public_key: (a: number, b: number, c: number) => void;
 export const wasmecpair_from_wif: (a: number, b: number, c: number) => void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bitgo/wasm-utxo",
   "description": "WebAssembly wrapper for rust-bitcoin (beta)",
-  "version": "1.22.0",
+  "version": "1.23.0",
   "type": "module",
   "repository": {
     "type": "git",