@bitgo/wasm-utxo 1.6.0 → 1.8.0

package/dist/cjs/js/bip32.d.ts

@@ -0,0 +1,140 @@
+import { WasmBIP32 } from "./wasm/wasm_utxo.js";
+/**
+ * BIP32Arg represents the various forms that BIP32 keys can take
+ * before being converted to a WasmBIP32 instance
+ */
+export type BIP32Arg = 
+/** base58-encoded extended key string (xpub/xprv/tpub/tprv) */
+string
+/** BIP32 instance */
+ | BIP32
+/** WasmBIP32 instance */
+ | WasmBIP32
+/** BIP32Interface compatible object */
+ | BIP32Interface;
+/**
+ * BIP32 interface for extended key operations
+ */
+export interface BIP32Interface {
+    chainCode: Uint8Array;
+    depth: number;
+    index: number;
+    parentFingerprint: number;
+    privateKey?: Uint8Array;
+    publicKey: Uint8Array;
+    identifier: Uint8Array;
+    fingerprint: Uint8Array;
+    isNeutered(): boolean;
+    neutered(): BIP32Interface;
+    toBase58(): string;
+    toWIF(): string;
+    derive(index: number): BIP32Interface;
+    deriveHardened(index: number): BIP32Interface;
+    derivePath(path: string): BIP32Interface;
+}
+/**
+ * BIP32 wrapper class for extended key operations
+ */
+export declare class BIP32 implements BIP32Interface {
+    private _wasm;
+    private constructor();
+    /**
+     * Create a BIP32 instance from a WasmBIP32 instance (internal use)
+     * @internal
+     */
+    static fromWasm(wasm: WasmBIP32): BIP32;
+    /**
+     * Convert BIP32Arg to BIP32 instance
+     * @param key - The BIP32 key in various formats
+     * @returns BIP32 instance
+     */
+    static from(key: BIP32Arg): BIP32;
+    /**
+     * Create a BIP32 key from a base58 string (xpub/xprv/tpub/tprv)
+     * @param base58Str - The base58-encoded extended key string
+     * @returns A BIP32 instance
+     */
+    static fromBase58(base58Str: string): BIP32;
+    /**
+     * Create a BIP32 master key from a seed
+     * @param seed - The seed bytes
+     * @param network - Optional network string
+     * @returns A BIP32 instance
+     */
+    static fromSeed(seed: Uint8Array, network?: string | null): BIP32;
+    /**
+     * Get the chain code as a Uint8Array
+     */
+    get chainCode(): Uint8Array;
+    /**
+     * Get the depth
+     */
+    get depth(): number;
+    /**
+     * Get the child index
+     */
+    get index(): number;
+    /**
+     * Get the parent fingerprint
+     */
+    get parentFingerprint(): number;
+    /**
+     * Get the private key as a Uint8Array (if available)
+     */
+    get privateKey(): Uint8Array | undefined;
+    /**
+     * Get the public key as a Uint8Array
+     */
+    get publicKey(): Uint8Array;
+    /**
+     * Get the identifier as a Uint8Array
+     */
+    get identifier(): Uint8Array;
+    /**
+     * Get the fingerprint as a Uint8Array
+     */
+    get fingerprint(): Uint8Array;
+    /**
+     * Check if this is a neutered (public) key
+     * @returns True if the key is public-only (neutered)
+     */
+    isNeutered(): boolean;
+    /**
+     * Get the neutered (public) version of this key
+     * @returns A new BIP32 instance containing only the public key
+     */
+    neutered(): BIP32;
+    /**
+     * Serialize to base58 string
+     * @returns The base58-encoded extended key string
+     */
+    toBase58(): string;
+    /**
+     * Get the WIF encoding of the private key
+     * @returns The WIF-encoded private key
+     */
+    toWIF(): string;
+    /**
+     * Derive a normal (non-hardened) child key
+     * @param index - The child index
+     * @returns A new BIP32 instance for the derived key
+     */
+    derive(index: number): BIP32;
+    /**
+     * Derive a hardened child key (only works for private keys)
+     * @param index - The child index
+     * @returns A new BIP32 instance for the derived key
+     */
+    deriveHardened(index: number): BIP32;
+    /**
+     * Derive a key using a derivation path (e.g., "0/1/2" or "m/0/1/2")
+     * @param path - The derivation path string
+     * @returns A new BIP32 instance for the derived key
+     */
+    derivePath(path: string): BIP32;
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm(): WasmBIP32;
+}

package/dist/cjs/js/bip32.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BIP32 = void 0;
+const wasm_utxo_js_1 = require("./wasm/wasm_utxo.js");
+/**
+ * BIP32 wrapper class for extended key operations
+ */
+class BIP32 {
+    _wasm;
+    constructor(_wasm) {
+        this._wasm = _wasm;
+    }
+    /**
+     * Create a BIP32 instance from a WasmBIP32 instance (internal use)
+     * @internal
+     */
+    static fromWasm(wasm) {
+        return new BIP32(wasm);
+    }
+    /**
+     * Convert BIP32Arg to BIP32 instance
+     * @param key - The BIP32 key in various formats
+     * @returns BIP32 instance
+     */
+    static from(key) {
+        // Short-circuit if already a BIP32 instance
+        if (key instanceof BIP32) {
+            return key;
+        }
+        // If it's a WasmBIP32 instance, wrap it
+        if (key instanceof wasm_utxo_js_1.WasmBIP32) {
+            return new BIP32(key);
+        }
+        // If it's a string, parse from base58
+        if (typeof key === "string") {
+            const wasm = wasm_utxo_js_1.WasmBIP32.from_base58(key);
+            return new BIP32(wasm);
+        }
+        // If it's an object (BIP32Interface), use from_bip32_interface
+        if (typeof key === "object" && key !== null) {
+            const wasm = wasm_utxo_js_1.WasmBIP32.from_bip32_interface(key);
+            return new BIP32(wasm);
+        }
+        throw new Error("Invalid BIP32Arg type");
+    }
+    /**
+     * Create a BIP32 key from a base58 string (xpub/xprv/tpub/tprv)
+     * @param base58Str - The base58-encoded extended key string
+     * @returns A BIP32 instance
+     */
+    static fromBase58(base58Str) {
+        const wasm = wasm_utxo_js_1.WasmBIP32.from_base58(base58Str);
+        return new BIP32(wasm);
+    }
+    /**
+     * Create a BIP32 master key from a seed
+     * @param seed - The seed bytes
+     * @param network - Optional network string
+     * @returns A BIP32 instance
+     */
+    static fromSeed(seed, network) {
+        const wasm = wasm_utxo_js_1.WasmBIP32.from_seed(seed, network);
+        return new BIP32(wasm);
+    }
+    /**
+     * Get the chain code as a Uint8Array
+     */
+    get chainCode() {
+        return this._wasm.chain_code;
+    }
+    /**
+     * Get the depth
+     */
+    get depth() {
+        return this._wasm.depth;
+    }
+    /**
+     * Get the child index
+     */
+    get index() {
+        return this._wasm.index;
+    }
+    /**
+     * Get the parent fingerprint
+     */
+    get parentFingerprint() {
+        return this._wasm.parent_fingerprint;
+    }
+    /**
+     * Get the private key as a Uint8Array (if available)
+     */
+    get privateKey() {
+        return this._wasm.private_key;
+    }
+    /**
+     * Get the public key as a Uint8Array
+     */
+    get publicKey() {
+        return this._wasm.public_key;
+    }
+    /**
+     * Get the identifier as a Uint8Array
+     */
+    get identifier() {
+        return this._wasm.identifier;
+    }
+    /**
+     * Get the fingerprint as a Uint8Array
+     */
+    get fingerprint() {
+        return this._wasm.fingerprint;
+    }
+    /**
+     * Check if this is a neutered (public) key
+     * @returns True if the key is public-only (neutered)
+     */
+    isNeutered() {
+        return this._wasm.is_neutered();
+    }
+    /**
+     * Get the neutered (public) version of this key
+     * @returns A new BIP32 instance containing only the public key
+     */
+    neutered() {
+        const wasm = this._wasm.neutered();
+        return new BIP32(wasm);
+    }
+    /**
+     * Serialize to base58 string
+     * @returns The base58-encoded extended key string
+     */
+    toBase58() {
+        return this._wasm.to_base58();
+    }
+    /**
+     * Get the WIF encoding of the private key
+     * @returns The WIF-encoded private key
+     */
+    toWIF() {
+        return this._wasm.to_wif();
+    }
+    /**
+     * Derive a normal (non-hardened) child key
+     * @param index - The child index
+     * @returns A new BIP32 instance for the derived key
+     */
+    derive(index) {
+        const wasm = this._wasm.derive(index);
+        return new BIP32(wasm);
+    }
+    /**
+     * Derive a hardened child key (only works for private keys)
+     * @param index - The child index
+     * @returns A new BIP32 instance for the derived key
+     */
+    deriveHardened(index) {
+        const wasm = this._wasm.derive_hardened(index);
+        return new BIP32(wasm);
+    }
+    /**
+     * Derive a key using a derivation path (e.g., "0/1/2" or "m/0/1/2")
+     * @param path - The derivation path string
+     * @returns A new BIP32 instance for the derived key
+     */
+    derivePath(path) {
+        const wasm = this._wasm.derive_path(path);
+        return new BIP32(wasm);
+    }
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm() {
+        return this._wasm;
+    }
+}
+exports.BIP32 = BIP32;

package/dist/cjs/js/ecpair.d.ts

@@ -0,0 +1,96 @@
+import { WasmECPair } from "./wasm/wasm_utxo.js";
+/**
+ * ECPairArg represents the various forms that ECPair keys can take
+ * before being converted to a WasmECPair instance
+ */
+export type ECPairArg = 
+/** Private key (32 bytes) or compressed public key (33 bytes) as Buffer/Uint8Array */
+Uint8Array
+/** ECPair instance */
+ | ECPair
+/** WasmECPair instance */
+ | WasmECPair;
+/**
+ * ECPair interface for elliptic curve key pair operations
+ */
+export interface ECPairInterface {
+    publicKey: Uint8Array;
+    privateKey?: Uint8Array;
+    toWIF(): string;
+}
+/**
+ * ECPair wrapper class for elliptic curve key pair operations
+ */
+export declare class ECPair implements ECPairInterface {
+    private _wasm;
+    private constructor();
+    /**
+     * Create an ECPair instance from a WasmECPair instance (internal use)
+     * @internal
+     */
+    static fromWasm(wasm: WasmECPair): ECPair;
+    /**
+     * Convert ECPairArg to ECPair instance
+     * @param key - The ECPair key in various formats
+     * @returns ECPair instance
+     */
+    static from(key: ECPairArg): ECPair;
+    /**
+     * Create an ECPair from a private key (always uses compressed keys)
+     * @param buffer - The 32-byte private key
+     * @returns An ECPair instance
+     */
+    static fromPrivateKey(buffer: Uint8Array): ECPair;
+    /**
+     * Create an ECPair from a compressed public key
+     * @param buffer - The compressed public key bytes (33 bytes)
+     * @returns An ECPair instance
+     */
+    static fromPublicKey(buffer: Uint8Array): ECPair;
+    /**
+     * Create an ECPair from a WIF string (auto-detects network from WIF)
+     * @param wifString - The WIF-encoded private key string
+     * @returns An ECPair instance
+     */
+    static fromWIF(wifString: string): ECPair;
+    /**
+     * Create an ECPair from a mainnet WIF string
+     * @param wifString - The WIF-encoded private key string
+     * @returns An ECPair instance
+     */
+    static fromWIFMainnet(wifString: string): ECPair;
+    /**
+     * Create an ECPair from a testnet WIF string
+     * @param wifString - The WIF-encoded private key string
+     * @returns An ECPair instance
+     */
+    static fromWIFTestnet(wifString: string): ECPair;
+    /**
+     * Get the private key as a Uint8Array (if available)
+     */
+    get privateKey(): Uint8Array | undefined;
+    /**
+     * Get the public key as a Uint8Array
+     */
+    get publicKey(): Uint8Array;
+    /**
+     * Convert to WIF string (mainnet)
+     * @returns The WIF-encoded private key
+     */
+    toWIF(): string;
+    /**
+     * Convert to mainnet WIF string
+     * @returns The WIF-encoded private key
+     */
+    toWIFMainnet(): string;
+    /**
+     * Convert to testnet WIF string
+     * @returns The WIF-encoded private key
+     */
+    toWIFTestnet(): string;
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm(): WasmECPair;
+}

package/dist/cjs/js/ecpair.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECPair = void 0;
+const wasm_utxo_js_1 = require("./wasm/wasm_utxo.js");
+/**
+ * ECPair wrapper class for elliptic curve key pair operations
+ */
+class ECPair {
+    _wasm;
+    constructor(_wasm) {
+        this._wasm = _wasm;
+    }
+    /**
+     * Create an ECPair instance from a WasmECPair instance (internal use)
+     * @internal
+     */
+    static fromWasm(wasm) {
+        return new ECPair(wasm);
+    }
+    /**
+     * Convert ECPairArg to ECPair instance
+     * @param key - The ECPair key in various formats
+     * @returns ECPair instance
+     */
+    static from(key) {
+        // Short-circuit if already an ECPair instance
+        if (key instanceof ECPair) {
+            return key;
+        }
+        // If it's a WasmECPair instance, wrap it
+        if (key instanceof wasm_utxo_js_1.WasmECPair) {
+            return new ECPair(key);
+        }
+        // Parse from Buffer/Uint8Array
+        // Check length to determine if it's a private key (32 bytes) or public key (33 bytes)
+        if (key.length === 32) {
+            const wasm = wasm_utxo_js_1.WasmECPair.from_private_key(key);
+            return new ECPair(wasm);
+        }
+        else if (key.length === 33) {
+            const wasm = wasm_utxo_js_1.WasmECPair.from_public_key(key);
+            return new ECPair(wasm);
+        }
+        else {
+            throw new Error(`Invalid key length: ${key.length}. Expected 32 bytes (private key) or 33 bytes (compressed public key)`);
+        }
+    }
+    /**
+     * Create an ECPair from a private key (always uses compressed keys)
+     * @param buffer - The 32-byte private key
+     * @returns An ECPair instance
+     */
+    static fromPrivateKey(buffer) {
+        const wasm = wasm_utxo_js_1.WasmECPair.from_private_key(buffer);
+        return new ECPair(wasm);
+    }
+    /**
+     * Create an ECPair from a compressed public key
+     * @param buffer - The compressed public key bytes (33 bytes)
+     * @returns An ECPair instance
+     */
+    static fromPublicKey(buffer) {
+        const wasm = wasm_utxo_js_1.WasmECPair.from_public_key(buffer);
+        return new ECPair(wasm);
+    }
+    /**
+     * Create an ECPair from a WIF string (auto-detects network from WIF)
+     * @param wifString - The WIF-encoded private key string
+     * @returns An ECPair instance
+     */
+    static fromWIF(wifString) {
+        const wasm = wasm_utxo_js_1.WasmECPair.from_wif(wifString);
+        return new ECPair(wasm);
+    }
+    /**
+     * Create an ECPair from a mainnet WIF string
+     * @param wifString - The WIF-encoded private key string
+     * @returns An ECPair instance
+     */
+    static fromWIFMainnet(wifString) {
+        const wasm = wasm_utxo_js_1.WasmECPair.from_wif_mainnet(wifString);
+        return new ECPair(wasm);
+    }
+    /**
+     * Create an ECPair from a testnet WIF string
+     * @param wifString - The WIF-encoded private key string
+     * @returns An ECPair instance
+     */
+    static fromWIFTestnet(wifString) {
+        const wasm = wasm_utxo_js_1.WasmECPair.from_wif_testnet(wifString);
+        return new ECPair(wasm);
+    }
+    /**
+     * Get the private key as a Uint8Array (if available)
+     */
+    get privateKey() {
+        return this._wasm.private_key;
+    }
+    /**
+     * Get the public key as a Uint8Array
+     */
+    get publicKey() {
+        return this._wasm.public_key;
+    }
+    /**
+     * Convert to WIF string (mainnet)
+     * @returns The WIF-encoded private key
+     */
+    toWIF() {
+        return this._wasm.to_wif();
+    }
+    /**
+     * Convert to mainnet WIF string
+     * @returns The WIF-encoded private key
+     */
+    toWIFMainnet() {
+        return this._wasm.to_wif_mainnet();
+    }
+    /**
+     * Convert to testnet WIF string
+     * @returns The WIF-encoded private key
+     */
+    toWIFTestnet() {
+        return this._wasm.to_wif_testnet();
+    }
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm() {
+        return this._wasm;
+    }
+}
+exports.ECPair = ECPair;