webycash-sdk 0.2.14 → 0.2.16

package/dist/backend-ffi.d.ts

@@ -0,0 +1,48 @@
+import type { Backend, WalletHandle } from "./backend.js";
+import type { CheckResult, NetworkMode, ParsedWebcash, RecoveryResult, WalletStats } from "./types.js";
+export declare class FfiBackend implements Backend {
+    readonly name: "ffi";
+    static create(): FfiBackend;
+    walletOpen(dbPath: string, _network: NetworkMode, seed?: Uint8Array): Promise<WalletHandle>;
+    walletClose(handle: WalletHandle): void;
+    walletBalance(handle: WalletHandle): Promise<string>;
+    walletInsert(handle: WalletHandle, webcash: string): Promise<WalletHandle>;
+    walletPay(handle: WalletHandle, amount: string, memo: string): Promise<{
+        handle: WalletHandle;
+        paymentWebcash: string;
+    }>;
+    walletCheck(handle: WalletHandle): Promise<{
+        handle: WalletHandle;
+        result: CheckResult;
+    }>;
+    walletMerge(handle: WalletHandle, maxOutputs: number): Promise<{
+        handle: WalletHandle;
+        message: string;
+    }>;
+    walletRecover(handle: WalletHandle, masterSecretHex: string, gapLimit: number): Promise<{
+        handle: WalletHandle;
+        result: RecoveryResult;
+    }>;
+    walletRecoverFromWallet(handle: WalletHandle, gapLimit: number): Promise<{
+        handle: WalletHandle;
+        result: RecoveryResult;
+    }>;
+    walletStats(handle: WalletHandle): Promise<WalletStats>;
+    walletExportSnapshot(handle: WalletHandle): Promise<string>;
+    walletImportSnapshot(handle: WalletHandle, json: string): Promise<WalletHandle>;
+    walletListWebcash(handle: WalletHandle): Promise<string[]>;
+    walletMasterSecret(handle: WalletHandle): Promise<string>;
+    walletEncryptSeed(handle: WalletHandle, password: string): Promise<void>;
+    walletEncryptWithPassword(handle: WalletHandle, password: string): Promise<string>;
+    walletDecryptWithPassword(handle: WalletHandle, encryptedJson: string, password: string): Promise<WalletHandle>;
+    version(): string;
+    amountParse(s: string): bigint;
+    amountFormat(wats: bigint): string;
+    deriveSecret(masterSecretHex: string, chainCode: number, depth: number): string;
+    generateMasterSecret(): string;
+    sha256Hex(data: string): string;
+    secretToPublic(secret: string): string;
+    parseWebcash(s: string): ParsedWebcash;
+    formatWebcash(secret: string, amountWats: bigint): string;
+    formatPublicWebcash(hashHex: string, amountWats: bigint): string;
+}

package/dist/backend-ffi.js

@@ -0,0 +1,269 @@
+import { WebycashError } from "./error.js";
+import { WebycashErrorCode } from "./types.js";
+import { createHash, randomBytes } from "node:crypto";
+import { createRequire } from "node:module";
+import { accessSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const esmRequire = createRequire(import.meta.url);
+const LIB_NAME = {
+    linux: "libwebycash_sdk.so",
+    darwin: "libwebycash_sdk.dylib",
+    win32: "webycash_sdk.dll",
+};
+function findLib() {
+    const name = LIB_NAME[os.platform()];
+    if (!name)
+        throw new Error(`Unsupported platform: ${os.platform()}`);
+    const local = path.join(__dirname, "..", name);
+    try {
+        accessSync(local);
+        return local;
+    }
+    catch {
+        /* fall through */
+    }
+    return name;
+}
+function check(rc) {
+    if (rc !== 0) {
+        const msg = ffi.weby_last_error_message();
+        throw new WebycashError(rc, msg ?? `Error code ${rc}`);
+    }
+}
+function takeString(val) {
+    if (val == null)
+        return "";
+    return String(val);
+}
+/** Parse "Recovery completed! Webcash recovered: N, Total amount: X" */
+function parseRecoveryResult(s) {
+    const countMatch = s.match(/recovered:\s*(\d+)/i);
+    const amountMatch = s.match(/amount:\s*([\d.]+)/i);
+    return {
+        recoveredCount: countMatch ? parseInt(countMatch[1], 10) : 0,
+        totalAmount: amountMatch ? BigInt(Math.round(parseFloat(amountMatch[1]) * 1e8)) : 0n,
+    };
+}
+function assertFfi(handle) {
+    if (handle._tag !== "ffi")
+        throw new Error("Expected FFI handle");
+    return handle.ptr;
+}
+// Lazy-load koffi — singleton to avoid duplicate type registration
+let ffi = null;
+function loadFfi() {
+    if (ffi)
+        return ffi;
+    const koffi = esmRequire("koffi");
+    const lib = koffi.load(findLib());
+    const WebyWalletPtr = koffi.pointer("WebyWallet", koffi.opaque());
+    const bindings = {
+        // Lifecycle
+        weby_wallet_open: lib.func("int32_t weby_wallet_open(const char*, _Out_ WebyWallet**)"),
+        weby_wallet_open_with_seed: lib.func("int32_t weby_wallet_open_with_seed(const char*, const uint8_t*, size_t, _Out_ WebyWallet**)"),
+        weby_wallet_free: lib.func("void weby_wallet_free(WebyWallet*)"),
+        // Operations
+        weby_wallet_balance: lib.func("int32_t weby_wallet_balance(const WebyWallet*, _Out_ char**)"),
+        weby_wallet_insert: lib.func("int32_t weby_wallet_insert(const WebyWallet*, const char*)"),
+        weby_wallet_pay: lib.func("int32_t weby_wallet_pay(const WebyWallet*, const char*, const char*, _Out_ char**)"),
+        weby_wallet_check: lib.func("int32_t weby_wallet_check(const WebyWallet*)"),
+        weby_wallet_merge: lib.func("int32_t weby_wallet_merge(const WebyWallet*, uint32_t, _Out_ char**)"),
+        weby_wallet_recover: lib.func("int32_t weby_wallet_recover(const WebyWallet*, const char*, uint32_t, _Out_ char**)"),
+        weby_wallet_recover_from_wallet: lib.func("int32_t weby_wallet_recover_from_wallet(const WebyWallet*, uint32_t, _Out_ char**)"),
+        // Inspection
+        weby_wallet_stats: lib.func("int32_t weby_wallet_stats(const WebyWallet*, _Out_ char**)"),
+        weby_wallet_export_snapshot: lib.func("int32_t weby_wallet_export_snapshot(const WebyWallet*, _Out_ char**)"),
+        weby_wallet_import_snapshot: lib.func("int32_t weby_wallet_import_snapshot(const WebyWallet*, const char*)"),
+        weby_wallet_list_webcash: lib.func("int32_t weby_wallet_list_webcash(const WebyWallet*, _Out_ char**)"),
+        weby_wallet_master_secret: lib.func("int32_t weby_wallet_master_secret(const WebyWallet*, _Out_ char**)"),
+        // Encryption
+        weby_wallet_encrypt_seed: lib.func("int32_t weby_wallet_encrypt_seed(const WebyWallet*, const char*)"),
+        weby_wallet_encrypt_with_password: lib.func("int32_t weby_wallet_encrypt_with_password(const WebyWallet*, const char*, _Out_ char**)"),
+        weby_wallet_decrypt_with_password: lib.func("int32_t weby_wallet_decrypt_with_password(const WebyWallet*, const char*, const char*)"),
+        // Utilities
+        weby_version: lib.func("const char* weby_version()"),
+        weby_last_error_message: lib.func("const char* weby_last_error_message()"),
+        weby_amount_parse: lib.func("int32_t weby_amount_parse(const char*, _Out_ int64_t*)"),
+        weby_amount_format: lib.func("int32_t weby_amount_format(int64_t, _Out_ char**)"),
+        weby_free_string: lib.func("void weby_free_string(char*)"),
+        WebyWalletPtr,
+    };
+    ffi = bindings;
+    return bindings;
+}
+export class FfiBackend {
+    name = "ffi";
+    static create() {
+        loadFfi();
+        return new FfiBackend();
+    }
+    // ── Lifecycle ──────────────────────────────────────────────
+    async walletOpen(dbPath, _network, seed) {
+        const out = [null];
+        if (seed) {
+            if (seed.length !== 32)
+                throw new WebycashError(WebycashErrorCode.InvalidInput, "seed must be 32 bytes");
+            check(ffi.weby_wallet_open_with_seed(dbPath, Buffer.from(seed), seed.length, out));
+        }
+        else {
+            check(ffi.weby_wallet_open(dbPath, out));
+        }
+        return { _tag: "ffi", ptr: out[0] };
+    }
+    walletClose(handle) {
+        const ptr = assertFfi(handle);
+        if (ptr)
+            ffi.weby_wallet_free(ptr);
+    }
+    // ── Operations ─────────────────────────────────────────────
+    async walletBalance(handle) {
+        const out = [null];
+        check(ffi.weby_wallet_balance(assertFfi(handle), out));
+        return takeString(out[0]);
+    }
+    async walletInsert(handle, webcash) {
+        check(ffi.weby_wallet_insert(assertFfi(handle), webcash));
+        return handle;
+    }
+    async walletPay(handle, amount, memo) {
+        const out = [null];
+        check(ffi.weby_wallet_pay(assertFfi(handle), amount, memo, out));
+        return { handle, paymentWebcash: takeString(out[0]) };
+    }
+    async walletCheck(handle) {
+        // FFI check() only returns success/failure — no detailed counts available via C ABI
+        check(ffi.weby_wallet_check(assertFfi(handle)));
+        // Re-query stats to get actual counts post-check
+        const stats = await this.walletStats(handle);
+        return { handle, result: { validCount: stats.unspentWebcash, spentCount: stats.spentWebcash } };
+    }
+    async walletMerge(handle, maxOutputs) {
+        const out = [null];
+        check(ffi.weby_wallet_merge(assertFfi(handle), maxOutputs, out));
+        return { handle, message: takeString(out[0]) };
+    }
+    async walletRecover(handle, masterSecretHex, gapLimit) {
+        const out = [null];
+        check(ffi.weby_wallet_recover(assertFfi(handle), masterSecretHex, gapLimit, out));
+        return { handle, result: parseRecoveryResult(takeString(out[0])) };
+    }
+    async walletRecoverFromWallet(handle, gapLimit) {
+        const out = [null];
+        check(ffi.weby_wallet_recover_from_wallet(assertFfi(handle), gapLimit, out));
+        return { handle, result: parseRecoveryResult(takeString(out[0])) };
+    }
+    // ── Inspection ─────────────────────────────────────────────
+    async walletStats(handle) {
+        const out = [null];
+        check(ffi.weby_wallet_stats(assertFfi(handle), out));
+        const raw = JSON.parse(takeString(out[0]));
+        return {
+            totalWebcash: raw.total_webcash,
+            unspentWebcash: raw.unspent_webcash,
+            spentWebcash: raw.spent_webcash,
+            totalBalance: raw.total_balance,
+        };
+    }
+    async walletExportSnapshot(handle) {
+        const out = [null];
+        check(ffi.weby_wallet_export_snapshot(assertFfi(handle), out));
+        return takeString(out[0]);
+    }
+    async walletImportSnapshot(handle, json) {
+        check(ffi.weby_wallet_import_snapshot(assertFfi(handle), json));
+        return handle;
+    }
+    async walletListWebcash(handle) {
+        const out = [null];
+        check(ffi.weby_wallet_list_webcash(assertFfi(handle), out));
+        return JSON.parse(takeString(out[0]));
+    }
+    async walletMasterSecret(handle) {
+        const out = [null];
+        check(ffi.weby_wallet_master_secret(assertFfi(handle), out));
+        return takeString(out[0]);
+    }
+    // ── Encryption ─────────────────────────────────────────────
+    async walletEncryptSeed(handle, password) {
+        check(ffi.weby_wallet_encrypt_seed(assertFfi(handle), password));
+    }
+    async walletEncryptWithPassword(handle, password) {
+        const out = [null];
+        check(ffi.weby_wallet_encrypt_with_password(assertFfi(handle), password, out));
+        return takeString(out[0]);
+    }
+    async walletDecryptWithPassword(handle, encryptedJson, password) {
+        check(ffi.weby_wallet_decrypt_with_password(assertFfi(handle), encryptedJson, password));
+        return handle;
+    }
+    // ── Utilities ──────────────────────────────────────────────
+    version() {
+        return ffi.weby_version();
+    }
+    amountParse(s) {
+        const out = [0];
+        check(ffi.weby_amount_parse(s, out));
+        return BigInt(out[0]);
+    }
+    amountFormat(wats) {
+        const out = [null];
+        check(ffi.weby_amount_format(Number(wats), out));
+        return takeString(out[0]);
+    }
+    // ── Crypto (pure Node.js — no FFI needed) ──────────────────
+    deriveSecret(masterSecretHex, chainCode, depth) {
+        const masterBytes = Buffer.from(masterSecretHex, "hex");
+        if (masterBytes.length !== 32)
+            throw new WebycashError(WebycashErrorCode.InvalidInput, "master secret must be 32 bytes (64 hex chars)");
+        const tag = createHash("sha256").update("webcashwalletv1").digest();
+        const h = createHash("sha256");
+        h.update(tag);
+        h.update(tag);
+        h.update(masterBytes);
+        const chainBuf = Buffer.alloc(8);
+        chainBuf.writeBigUInt64BE(BigInt(chainCode));
+        h.update(chainBuf);
+        const depthBuf = Buffer.alloc(8);
+        depthBuf.writeBigUInt64BE(BigInt(depth));
+        h.update(depthBuf);
+        return h.digest("hex");
+    }
+    generateMasterSecret() {
+        return randomBytes(32).toString("hex");
+    }
+    sha256Hex(data) {
+        return createHash("sha256").update(data, "ascii").digest("hex");
+    }
+    secretToPublic(secret) {
+        return this.sha256Hex(secret);
+    }
+    // ── Webcash (pure string ops) ──────────────────────────────
+    parseWebcash(s) {
+        const trimmed = s.trim();
+        if (!trimmed.startsWith("e"))
+            throw new WebycashError(WebycashErrorCode.InvalidInput, "webcash must start with 'e'");
+        const parts = trimmed.slice(1).split(":");
+        if (parts.length < 3 || parts[1] !== "secret")
+            throw new WebycashError(WebycashErrorCode.InvalidInput, "invalid webcash format");
+        const amountWats = this.amountParse(parts[0]);
+        const secret = parts.slice(2).join(":");
+        if (secret.length !== 64)
+            throw new WebycashError(WebycashErrorCode.InvalidInput, "secret must be 64 hex characters");
+        return {
+            secret,
+            amountWats,
+            amountDisplay: this.amountFormat(amountWats),
+            publicHash: this.secretToPublic(secret),
+        };
+    }
+    formatWebcash(secret, amountWats) {
+        return `e${this.amountFormat(amountWats)}:secret:${secret}`;
+    }
+    formatPublicWebcash(hashHex, amountWats) {
+        return `e${this.amountFormat(amountWats)}:public:${hashHex}`;
+    }
+}

package/dist/backend-wasm.d.ts

@@ -0,0 +1,50 @@
+import type { Backend, WalletHandle } from "./backend.js";
+import type { CheckResult, NetworkMode, ParsedWebcash, RecoveryResult, WalletStats } from "./types.js";
+export declare class WasmBackend implements Backend {
+    readonly name: "wasm";
+    private wasm;
+    private constructor();
+    static create(): Promise<WasmBackend>;
+    walletOpen(_path: string, network: NetworkMode, seed?: Uint8Array): Promise<WalletHandle>;
+    walletClose(_handle: WalletHandle): void;
+    walletBalance(handle: WalletHandle): Promise<string>;
+    walletInsert(handle: WalletHandle, webcash: string): Promise<WalletHandle>;
+    walletPay(handle: WalletHandle, amount: string, _memo: string): Promise<{
+        handle: WalletHandle;
+        paymentWebcash: string;
+    }>;
+    walletCheck(handle: WalletHandle): Promise<{
+        handle: WalletHandle;
+        result: CheckResult;
+    }>;
+    walletMerge(handle: WalletHandle, maxOutputs: number): Promise<{
+        handle: WalletHandle;
+        message: string;
+    }>;
+    walletRecover(handle: WalletHandle, masterSecretHex: string, gapLimit: number): Promise<{
+        handle: WalletHandle;
+        result: RecoveryResult;
+    }>;
+    walletRecoverFromWallet(handle: WalletHandle, gapLimit: number): Promise<{
+        handle: WalletHandle;
+        result: RecoveryResult;
+    }>;
+    walletStats(handle: WalletHandle): Promise<WalletStats>;
+    walletExportSnapshot(handle: WalletHandle): Promise<string>;
+    walletImportSnapshot(handle: WalletHandle, json: string): Promise<WalletHandle>;
+    walletListWebcash(handle: WalletHandle): Promise<string[]>;
+    walletMasterSecret(handle: WalletHandle): Promise<string>;
+    walletEncryptSeed(_handle: WalletHandle, _password: string): Promise<void>;
+    walletEncryptWithPassword(handle: WalletHandle, password: string): Promise<string>;
+    walletDecryptWithPassword(handle: WalletHandle, encryptedJson: string, password: string): Promise<WalletHandle>;
+    version(): string;
+    amountParse(s: string): bigint;
+    amountFormat(wats: bigint): string;
+    deriveSecret(masterSecretHex: string, chainCode: number, depth: number): string;
+    generateMasterSecret(): string;
+    sha256Hex(data: string): string;
+    secretToPublic(secret: string): string;
+    parseWebcash(s: string): ParsedWebcash;
+    formatWebcash(secret: string, amountWats: bigint): string;
+    formatPublicWebcash(hashHex: string, amountWats: bigint): string;
+}

package/dist/backend-wasm.js

@@ -0,0 +1,275 @@
+import { WebycashError } from "./error.js";
+import { WebycashErrorCode } from "./types.js";
+function assertWasm(handle) {
+    if (handle._tag !== "wasm")
+        throw new Error("Expected WASM handle");
+    return handle;
+}
+function wrapError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new WebycashError(WebycashErrorCode.Unknown, msg);
+}
+export class WasmBackend {
+    name = "wasm";
+    wasm;
+    constructor(wasm) {
+        this.wasm = wasm;
+    }
+    static async create() {
+        // Dynamic import for the WASM module
+        let wasm;
+        try {
+            wasm = await import("../wasm/webycash_sdk_wasm.js");
+        }
+        catch {
+            throw new WebycashError(WebycashErrorCode.NotSupported, "WASM module not found. Ensure the WASM package is built (scripts/build-wasm.sh)");
+        }
+        // Initialize WASM (loads the .wasm binary)
+        if (typeof wasm.default === "function") {
+            // In Node.js, read the .wasm file from disk
+            if (typeof process !== "undefined" && process.versions?.node) {
+                const { readFile } = await import("node:fs/promises");
+                const { fileURLToPath } = await import("node:url");
+                const path = await import("node:path");
+                const wasmDir = path.dirname(fileURLToPath(import.meta.url));
+                const wasmPath = path.join(wasmDir, "..", "wasm", "webycash_sdk_wasm_bg.wasm");
+                const wasmBytes = await readFile(wasmPath);
+                await wasm.default(wasmBytes);
+            }
+            else {
+                // Browser — let wasm-bindgen handle fetch
+                await wasm.default();
+            }
+        }
+        return new WasmBackend(wasm);
+    }
+    // ── Lifecycle ──────────────────────────────────────────────
+    async walletOpen(_path, network, seed) {
+        try {
+            let stateJson;
+            if (seed) {
+                if (seed.length !== 32)
+                    throw new WebycashError(WebycashErrorCode.InvalidInput, "seed must be 32 bytes");
+                const hex = Array.from(seed, (b) => b.toString(16).padStart(2, "0")).join("");
+                stateJson = await this.wasm.wallet_create_with_secret(network, hex);
+            }
+            else {
+                stateJson = this.wasm.wallet_create(network);
+            }
+            return { _tag: "wasm", stateJson, network };
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    walletClose(_handle) {
+        // WASM wallets are GC'd — no-op
+    }
+    // ── Operations ─────────────────────────────────────────────
+    async walletBalance(handle) {
+        try {
+            const { stateJson, network } = assertWasm(handle);
+            const wats = this.wasm.wallet_balance(stateJson, network);
+            return this.wasm.format_amount(wats);
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    async walletInsert(handle, webcash) {
+        try {
+            const { stateJson, network } = assertWasm(handle);
+            const newState = await this.wasm.wallet_insert(stateJson, network, webcash);
+            return { _tag: "wasm", stateJson: newState, network };
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    async walletPay(handle, amount, _memo) {
+        try {
+            const { stateJson, network } = assertWasm(handle);
+            const amountWats = this.wasm.parse_amount(amount);
+            const resultJson = await this.wasm.wallet_pay(stateJson, network, amountWats);
+            const result = JSON.parse(resultJson);
+            return {
+                handle: { _tag: "wasm", stateJson: result.state, network },
+                paymentWebcash: result.payment_webcash,
+            };
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    async walletCheck(handle) {
+        try {
+            const { stateJson, network } = assertWasm(handle);
+            const resultJson = await this.wasm.wallet_check(stateJson, network);
+            const result = JSON.parse(resultJson);
+            return {
+                handle: { _tag: "wasm", stateJson: result.state, network },
+                result: { validCount: result.valid_count, spentCount: result.spent_count },
+            };
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    async walletMerge(handle, maxOutputs) {
+        try {
+            const { stateJson, network } = assertWasm(handle);
+            const resultJson = await this.wasm.wallet_merge(stateJson, network, maxOutputs);
+            const result = JSON.parse(resultJson);
+            return {
+                handle: { _tag: "wasm", stateJson: result.state, network },
+                message: result.message,
+            };
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    async walletRecover(handle, masterSecretHex, gapLimit) {
+        try {
+            const { stateJson, network } = assertWasm(handle);
+            const resultJson = await this.wasm.wallet_recover(stateJson, network, masterSecretHex, gapLimit);
+            const result = JSON.parse(resultJson);
+            return {
+                handle: { _tag: "wasm", stateJson: result.state, network },
+                result: { recoveredCount: result.recovered_count, totalAmount: BigInt(result.total_amount) },
+            };
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    async walletRecoverFromWallet(handle, gapLimit) {
+        try {
+            const { stateJson, network } = assertWasm(handle);
+            const resultJson = await this.wasm.wallet_recover_from_wallet(stateJson, network, gapLimit);
+            const result = JSON.parse(resultJson);
+            return {
+                handle: { _tag: "wasm", stateJson: result.state, network },
+                result: { recoveredCount: result.recovered_count, totalAmount: BigInt(result.total_amount) },
+            };
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    // ── Inspection ─────────────────────────────────────────────
+    async walletStats(handle) {
+        try {
+            const { stateJson, network } = assertWasm(handle);
+            const raw = JSON.parse(this.wasm.wallet_stats(stateJson, network));
+            return {
+                totalWebcash: raw.total_webcash,
+                unspentWebcash: raw.unspent_webcash,
+                spentWebcash: raw.spent_webcash,
+                totalBalance: this.wasm.format_amount(BigInt(raw.total_balance)),
+            };
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    async walletExportSnapshot(handle) {
+        try {
+            const { stateJson, network } = assertWasm(handle);
+            return this.wasm.wallet_export_snapshot(stateJson, network);
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    async walletImportSnapshot(handle, json) {
+        try {
+            const { network } = assertWasm(handle);
+            const newState = this.wasm.wallet_import_snapshot(json, network);
+            return { _tag: "wasm", stateJson: newState, network };
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    async walletListWebcash(handle) {
+        try {
+            const { stateJson, network } = assertWasm(handle);
+            return JSON.parse(this.wasm.wallet_list_webcash(stateJson, network));
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    async walletMasterSecret(handle) {
+        try {
+            const { stateJson, network } = assertWasm(handle);
+            return this.wasm.wallet_master_secret(stateJson, network);
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    // ── Encryption ─────────────────────────────────────────────
+    async walletEncryptSeed(_handle, _password) {
+        throw new WebycashError(WebycashErrorCode.NotSupported, "encryptSeed is only available with the FFI backend");
+    }
+    async walletEncryptWithPassword(handle, password) {
+        try {
+            const { stateJson, network } = assertWasm(handle);
+            return this.wasm.wallet_encrypt_with_password(stateJson, network, password);
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    async walletDecryptWithPassword(handle, encryptedJson, password) {
+        try {
+            const { network } = assertWasm(handle);
+            const newState = this.wasm.wallet_decrypt_with_password(encryptedJson, password, network);
+            return { _tag: "wasm", stateJson: newState, network };
+        }
+        catch (err) {
+            wrapError(err);
+        }
+    }
+    // ── Utilities ──────────────────────────────────────────────
+    version() {
+        return this.wasm.sdk_version();
+    }
+    amountParse(s) {
+        return this.wasm.parse_amount(s);
+    }
+    amountFormat(wats) {
+        return this.wasm.format_amount(wats);
+    }
+    // ── Crypto ─────────────────────────────────────────────────
+    deriveSecret(masterSecretHex, chainCode, depth) {
+        return this.wasm.derive_secret(masterSecretHex, chainCode, BigInt(depth));
+    }
+    generateMasterSecret() {
+        return this.wasm.generate_master_secret();
+    }
+    sha256Hex(data) {
+        return this.wasm.sha256_hex(data);
+    }
+    secretToPublic(secret) {
+        return this.wasm.secret_to_public(secret);
+    }
+    // ── Webcash ────────────────────────────────────────────────
+    parseWebcash(s) {
+        const raw = this.wasm.parse_webcash(s);
+        return {
+            secret: raw.secret,
+            amountWats: BigInt(raw.amount_wats),
+            amountDisplay: raw.amount_display,
+            publicHash: raw.public_hash,
+        };
+    }
+    formatWebcash(secret, amountWats) {
+        return this.wasm.format_webcash(secret, amountWats);
+    }
+    formatPublicWebcash(hashHex, amountWats) {
+        return this.wasm.format_public_webcash(hashHex, amountWats);
+    }
+}