@lightninglabs/wavelength-core 0.1.0

package/dist/exit.d.ts

@@ -0,0 +1,93 @@
+import type { WavelengthClient } from './client.ts';
+import type { ExitInfeasibilityReason, ExitResult, GetExitPlanResult } from './results.ts';
+/**
+ * Options for {@link exitBatch}, a discriminated union on `mode`. A cooperative
+ * batch queues each outpoint into the next round to an optional on-chain
+ * `destination`. A unilateral batch forces each outpoint on-chain, funding the
+ * recovery from the backing wallet, and previews funding with `getExitPlan`
+ * before each start.
+ */
+export type ExitBatchOptions = {
+    mode: 'cooperative';
+    outpoints: string[];
+    destination?: string;
+} | {
+    mode: 'unilateral';
+    outpoints: string[];
+    confTarget?: number;
+};
+/**
+ * A progress event emitted by {@link exitBatch} as it works through a batch.
+ * `planned` carries the latest unilateral funding plan; `starting` fires before
+ * each exit call; `started` fires after one succeeds; `stopped` fires once when
+ * the batch halts early.
+ */
+export type ExitBatchEvent = {
+    type: 'planned';
+    plan: GetExitPlanResult;
+} | {
+    type: 'starting';
+    outpoint: string;
+} | {
+    type: 'started';
+    outpoint: string;
+    result: ExitResult;
+} | {
+    type: 'stopped';
+    stoppedBy: ExitBatchStop;
+    remaining: string[];
+};
+/**
+ * Why an {@link exitBatch} stopped before finishing. `infeasible` means a
+ * re-plan reported the backing wallet can no longer fund the remaining exits;
+ * `rejected` means an individual `exit` call was rejected by the daemon.
+ */
+export type ExitBatchStop = {
+    reason: 'infeasible';
+    plan: GetExitPlanResult;
+} | {
+    reason: 'rejected';
+    outpoint: string;
+    error: Error;
+};
+/**
+ * The outcome of {@link exitBatch}. `started` lists the exits that were
+ * successfully started (each still runs for hours or days afterward on the
+ * unilateral path); `skipped` lists outpoints already running an exit;
+ * `remaining` lists outpoints never started; `stoppedBy` is present when the
+ * batch halted early.
+ */
+export type ExitBatchResult = {
+    started: {
+        outpoint: string;
+        result: ExitResult;
+    }[];
+    skipped: string[];
+    remaining: string[];
+    stoppedBy?: ExitBatchStop;
+};
+/**
+ * Distinguishes a fixable exit-infeasibility (the backing wallet needs more
+ * confirmed funds or inputs) from a structural one (the VTXO cannot be exited
+ * economically at all). Use it to decide whether to show a "fund your wallet"
+ * affordance or a terminal "cannot exit this VTXO" message. Mirrors the
+ * daemon's own `ExitInfeasibility.Impossible()` split.
+ */
+export declare function isExitInfeasibilityFundable(reason: ExitInfeasibilityReason): boolean;
+/**
+ * Starts a batch of exits, one outpoint per daemon call, and reports which
+ * started, which were skipped, and which never started. It resolves once every
+ * exit has been STARTED, not completed: a unilateral exit continues to run for
+ * hours or days after this resolves. On the unilateral path it previews funding
+ * with `getExitPlan`, skips outpoints already running an exit, refuses to start
+ * anything if the wallet cannot fund the batch, and re-plans between starts;
+ * because fee inputs are leased only at broadcast time, it also treats a
+ * mid-batch `exit` rejection as a clean stop. On the cooperative path it queues
+ * each outpoint into the next round.
+ */
+export declare function exitBatch(opts: ExitBatchOptions & {
+    client: WavelengthClient;
+    signal?: AbortSignal;
+    onEvent?: (event: ExitBatchEvent) => void;
+}): Promise<ExitBatchResult>;
+//# sourceMappingURL=exit.d.ts.map

package/dist/exit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit.d.ts","sourceRoot":"","sources":["../src/exit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,KAAK,EACV,uBAAuB,EACvB,UAAU,EACV,iBAAiB,EAClB,MAAM,cAAc,CAAC;AAEtB;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAClE;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAErE;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEvE;;;;GAIG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GACjD;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAE3D;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,CAAA;KAAE,EAAE,CAAC;IACpD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAIT;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,gBAAgB,GAAG;IACvB,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;CAC3C,GACA,OAAO,CAAC,eAAe,CAAC,CAwE1B"}

package/dist/exit.js

@@ -0,0 +1,86 @@
+import { FORCE_UNROLL_ACK } from "./requests.js";
+/**
+ * Distinguishes a fixable exit-infeasibility (the backing wallet needs more
+ * confirmed funds or inputs) from a structural one (the VTXO cannot be exited
+ * economically at all). Use it to decide whether to show a "fund your wallet"
+ * affordance or a terminal "cannot exit this VTXO" message. Mirrors the
+ * daemon's own `ExitInfeasibility.Impossible()` split.
+ */
+export function isExitInfeasibilityFundable(reason) {
+    return (reason === 'wallet_underfunded' || reason === 'wallet_too_few_inputs');
+}
+/**
+ * Starts a batch of exits, one outpoint per daemon call, and reports which
+ * started, which were skipped, and which never started. It resolves once every
+ * exit has been STARTED, not completed: a unilateral exit continues to run for
+ * hours or days after this resolves. On the unilateral path it previews funding
+ * with `getExitPlan`, skips outpoints already running an exit, refuses to start
+ * anything if the wallet cannot fund the batch, and re-plans between starts;
+ * because fee inputs are leased only at broadcast time, it also treats a
+ * mid-batch `exit` rejection as a clean stop. On the cooperative path it queues
+ * each outpoint into the next round.
+ */
+export async function exitBatch(opts) {
+    const { client, signal, onEvent } = opts;
+    const started = [];
+    const skipped = [];
+    let remaining = [...opts.outpoints];
+    while (remaining.length > 0) {
+        signal?.throwIfAborted();
+        if (opts.mode === 'unilateral') {
+            const currentPlan = await client.getExitPlan({
+                outpoints: remaining,
+                confTarget: opts.confTarget,
+            });
+            onEvent?.({ type: 'planned', plan: currentPlan });
+            // Drop outpoints the daemon already runs an exit for: it rejects a
+            // second exit for one outpoint, and the plan already flags them.
+            const running = new Set(currentPlan.plans.filter((p) => p.exitJobFound).map((p) => p.outpoint));
+            if (running.size > 0) {
+                const newlySkipped = remaining.filter((o) => running.has(o) && !skipped.includes(o));
+                for (const o of newlySkipped)
+                    skipped.push(o);
+                remaining = remaining.filter((o) => !running.has(o));
+                if (remaining.length === 0)
+                    break;
+                if (newlySkipped.length > 0) {
+                    // Re-plan against the reduced set before gating on canStart: the
+                    // plan we just read still counted the now-skipped (already-running)
+                    // outpoints, whose leased fee inputs can make the aggregate
+                    // canStart false.
+                    continue;
+                }
+            }
+            // Funding is never reserved, so re-planning each round is the only way
+            // to notice an earlier start consumed the inputs a later one needs.
+            if (!currentPlan.canStart) {
+                const stoppedBy = {
+                    reason: 'infeasible',
+                    plan: currentPlan,
+                };
+                onEvent?.({ type: 'stopped', stoppedBy, remaining });
+                return { started, skipped, remaining, stoppedBy };
+            }
+        }
+        const outpoint = remaining[0];
+        onEvent?.({ type: 'starting', outpoint });
+        try {
+            const result = await client.exit(opts.mode === 'unilateral'
+                ? { outpoint, forceUnrollAck: FORCE_UNROLL_ACK }
+                : { outpoint, destination: opts.destination });
+            started.push({ outpoint, result });
+            remaining = remaining.slice(1);
+            onEvent?.({ type: 'started', outpoint, result });
+        }
+        catch (error) {
+            const stoppedBy = {
+                reason: 'rejected',
+                outpoint,
+                error: error,
+            };
+            onEvent?.({ type: 'stopped', stoppedBy, remaining });
+            return { started, skipped, remaining, stoppedBy };
+        }
+    }
+    return { started, skipped, remaining: [] };
+}

package/dist/facade.d.ts

@@ -0,0 +1,88 @@
+import type { RuntimeConfig } from './config.ts';
+import type { CreateWalletRequest, UnlockWalletRequest } from './requests.ts';
+/** Portable mobile and WASM facade methods available through `callFacade()`. */
+export declare const FACADE_METHODS: readonly ["start", "stop", "getInfo", "status", "balance", "createWallet", "unlockWallet", "openWalletFromPasskey", "deposit", "receive", "prepareSend", "sendPrepared", "list", "exit", "exitStatus", "exitSummary", "getExitPlan", "sweepWallet", "confirmedBalanceSat", "pendingInboundSat", "walletReady", "isRunning"];
+/** One portable daemon facade method accepted by `callFacade()`. */
+export type FacadeMethod = (typeof FACADE_METHODS)[number];
+export declare function assertFacadeMethod(method: unknown): asserts method is FacadeMethod;
+/**
+ * Selects how the embedded daemon dials the Ark operator and swap server. The
+ * browser transport must use 'rest' (a browser cannot speak native gRPC over
+ * the wire), while native transports use 'grpc'. The choice also changes what
+ * the address fields mean: with 'rest', the Ark and swap server addresses are
+ * gateway URLs; with 'grpc', they are host:port gRPC addresses.
+ */
+export type ServerTransport = 'rest' | 'grpc';
+/**
+ * The flat, snake_case config the wavewalletdk mobile facade's `start` verb
+ * decodes (sdk/wavewalletdk/mobile.mobileConfig). Every transport forwards it
+ * verbatim to the facade's Start.
+ */
+export type MobileConfig = {
+    data_dir?: string;
+    network?: string;
+    debug_level?: string;
+    allow_mainnet?: boolean;
+    server_address?: string;
+    server_tls_cert_path?: string;
+    server_transport?: ServerTransport;
+    server_insecure?: boolean;
+    wallet_type?: 'lwwallet' | 'btcwallet';
+    wallet_esplora_url?: string;
+    wallet_password_file?: string;
+    wallet_poll_interval_seconds?: number;
+    wallet_recovery_window?: number;
+    wallet_fee_url?: string;
+    wallet_block_headers_source?: string;
+    wallet_filter_headers_source?: string;
+    swap_server_address?: string;
+    swap_server_tls_cert_path?: string;
+    swap_server_transport?: ServerTransport;
+    swap_server_insecure?: boolean;
+    swap_database_file_name?: string;
+    max_operator_fee_sat?: number;
+    signing_workers?: number;
+    buffer_size?: number;
+};
+/**
+ * Maps the public RuntimeConfig onto the flat config the mobile facade
+ * expects.
+ *
+ * Mailbox addressing: the facade's MobileConfig has a single server_address
+ * (and swap_server_address) per service. Mailbox traffic shares that edge, so
+ * RuntimeConfig deliberately does not expose separate mailbox gateway fields.
+ * If a future facade version splits the mailbox onto its own address, add the
+ * field to RuntimeConfig and thread it through here.
+ *
+ * @param config - The public runtime configuration.
+ * @param serverTransport - How this transport's daemon dials the servers; see
+ * {@link ServerTransport}.
+ */
+export declare function toMobileConfig(config: RuntimeConfig, serverTransport: ServerTransport): MobileConfig;
+/**
+ * Encodes a string as base64 of its UTF-8 bytes, matching how Go's
+ * encoding/json represents a []byte field. Implemented without btoa or
+ * TextEncoder so it behaves identically in the browser, a worker, and Hermes.
+ */
+export declare function base64FromUtf8(value: string): string;
+/**
+ * Maps the TS-convention {@link CreateWalletRequest} (with a string password
+ * field) to the Go JSON shape the facade expects. Go's encoding/json uses
+ * struct field names verbatim and represents []byte as base64, so
+ * WalletPassword and SeedPassphrase must arrive as base64.
+ */
+export declare function toGoCreateWalletReq(req: CreateWalletRequest): {
+    WalletPassword: string | undefined;
+    Mnemonic: string[] | undefined;
+    SeedPassphrase: string | undefined;
+    RecoverState: boolean | undefined;
+    RecoveryWindow: number | undefined;
+};
+/**
+ * Maps the TS-convention {@link UnlockWalletRequest} to the Go JSON shape,
+ * base64-encoding the password string for the []byte field.
+ */
+export declare function toGoUnlockWalletReq(req: UnlockWalletRequest): {
+    WalletPassword: string | undefined;
+};
+//# sourceMappingURL=facade.d.ts.map

package/dist/facade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["../src/facade.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAG9E,gFAAgF;AAChF,eAAO,MAAM,cAAc,6TAuBjB,CAAC;AAEX,oEAAoE;AACpE,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAI3D,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,MAAM,IAAI,YAAY,CAOhC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,CAAC;AAE9C;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,gBAAgB,CAAC,EAAE,eAAe,CAAC;IACnC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,UAAU,GAAG,WAAW,CAAC;IACvC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,qBAAqB,CAAC,EAAE,eAAe,CAAC;IACxC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,EACrB,eAAe,EAAE,eAAe,GAC/B,YAAY,CAwCd;AAMD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAoCpD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,mBAAmB;;;;;;EAc3D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,mBAAmB;;EAI3D"}

package/dist/facade.js

@@ -0,0 +1,150 @@
+import { WavelengthError } from "./errors.js";
+/** Portable mobile and WASM facade methods available through `callFacade()`. */
+export const FACADE_METHODS = [
+    'start',
+    'stop',
+    'getInfo',
+    'status',
+    'balance',
+    'createWallet',
+    'unlockWallet',
+    'openWalletFromPasskey',
+    'deposit',
+    'receive',
+    'prepareSend',
+    'sendPrepared',
+    'list',
+    'exit',
+    'exitStatus',
+    'exitSummary',
+    'getExitPlan',
+    'sweepWallet',
+    'confirmedBalanceSat',
+    'pendingInboundSat',
+    'walletReady',
+    'isRunning',
+];
+const FACADE_METHOD_SET = new Set(FACADE_METHODS);
+export function assertFacadeMethod(method) {
+    if (typeof method !== 'string' || !FACADE_METHOD_SET.has(method)) {
+        throw new WavelengthError(`unsupported facade method: ${String(method)}`, 'unsupported_facade_method');
+    }
+}
+/**
+ * Maps the public RuntimeConfig onto the flat config the mobile facade
+ * expects.
+ *
+ * Mailbox addressing: the facade's MobileConfig has a single server_address
+ * (and swap_server_address) per service. Mailbox traffic shares that edge, so
+ * RuntimeConfig deliberately does not expose separate mailbox gateway fields.
+ * If a future facade version splits the mailbox onto its own address, add the
+ * field to RuntimeConfig and thread it through here.
+ *
+ * @param config - The public runtime configuration.
+ * @param serverTransport - How this transport's daemon dials the servers; see
+ * {@link ServerTransport}.
+ */
+export function toMobileConfig(config, serverTransport) {
+    const out = {
+        data_dir: config.dataDir,
+        network: config.network,
+        debug_level: config.debugLevel,
+        allow_mainnet: config.allowMainnet,
+        server_address: config.arkServerAddress,
+        server_tls_cert_path: config.arkServerTlsCertPath,
+        server_transport: serverTransport,
+        server_insecure: config.arkServerInsecure,
+        wallet_type: config.walletType ?? 'lwwallet',
+        wallet_esplora_url: config.walletEsploraUrl,
+        wallet_password_file: config.walletPasswordFile,
+        wallet_poll_interval_seconds: config.walletPollIntervalSeconds,
+        wallet_recovery_window: config.walletRecoveryWindow,
+        wallet_fee_url: config.walletFeeUrl,
+        wallet_block_headers_source: config.walletBlockHeadersSource,
+        wallet_filter_headers_source: config.walletFilterHeadersSource,
+        max_operator_fee_sat: config.maxOperatorFeeSat,
+        signing_workers: config.signingWorkers,
+        buffer_size: config.bufferSize,
+    };
+    // Leaving the swap server address unset disables the swap subsystem, so omit
+    // every swap field when the host asked to run without swaps.
+    if (!config.disableSwaps) {
+        out.swap_server_address = config.swapServerAddress;
+        out.swap_server_tls_cert_path = config.swapServerTlsCertPath;
+        out.swap_server_transport = serverTransport;
+        out.swap_server_insecure = config.swapServerInsecure;
+        out.swap_database_file_name = config.swapDatabaseFileName;
+    }
+    for (const key of Object.keys(out)) {
+        if (out[key] === undefined) {
+            delete out[key];
+        }
+    }
+    return out;
+}
+// The base64 alphabet, indexed by 6-bit value.
+const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+/**
+ * Encodes a string as base64 of its UTF-8 bytes, matching how Go's
+ * encoding/json represents a []byte field. Implemented without btoa or
+ * TextEncoder so it behaves identically in the browser, a worker, and Hermes.
+ */
+export function base64FromUtf8(value) {
+    const bytes = [];
+    for (const ch of value) {
+        const cp = ch.codePointAt(0);
+        if (cp < 0x80) {
+            bytes.push(cp);
+        }
+        else if (cp < 0x800) {
+            bytes.push(0xc0 | (cp >> 6), 0x80 | (cp & 0x3f));
+        }
+        else if (cp < 0x10000) {
+            bytes.push(0xe0 | (cp >> 12), 0x80 | ((cp >> 6) & 0x3f), 0x80 | (cp & 0x3f));
+        }
+        else {
+            bytes.push(0xf0 | (cp >> 18), 0x80 | ((cp >> 12) & 0x3f), 0x80 | ((cp >> 6) & 0x3f), 0x80 | (cp & 0x3f));
+        }
+    }
+    let out = '';
+    for (let i = 0; i < bytes.length; i += 3) {
+        const b0 = bytes[i];
+        const b1 = bytes[i + 1];
+        const b2 = bytes[i + 2];
+        out += BASE64_ALPHABET[b0 >> 2];
+        out += BASE64_ALPHABET[((b0 & 0x03) << 4) | ((b1 ?? 0) >> 4)];
+        out += b1 === undefined ? '=' : BASE64_ALPHABET[((b1 & 0x0f) << 2) | ((b2 ?? 0) >> 6)];
+        out += b2 === undefined ? '=' : BASE64_ALPHABET[b2 & 0x3f];
+    }
+    return out;
+}
+/**
+ * Maps the TS-convention {@link CreateWalletRequest} (with a string password
+ * field) to the Go JSON shape the facade expects. Go's encoding/json uses
+ * struct field names verbatim and represents []byte as base64, so
+ * WalletPassword and SeedPassphrase must arrive as base64.
+ */
+export function toGoCreateWalletReq(req) {
+    return {
+        WalletPassword: req.password ? base64FromUtf8(req.password) : undefined,
+        Mnemonic: req.mnemonic,
+        SeedPassphrase: req.seedPassphrase
+            ? base64FromUtf8(req.seedPassphrase)
+            : undefined,
+        // The Go facade struct has no json tags, so field names stay PascalCase on
+        // the wire (unlike the camelCase TS mirror in generated.ts). Pass both
+        // recovery fields straight through; JSON drops the undefined ones, letting
+        // the daemon apply its own defaults.
+        RecoverState: req.recoverState,
+        RecoveryWindow: req.recoveryWindow,
+    };
+}
+/**
+ * Maps the TS-convention {@link UnlockWalletRequest} to the Go JSON shape,
+ * base64-encoding the password string for the []byte field.
+ */
+export function toGoUnlockWalletReq(req) {
+    return {
+        WalletPassword: req.password ? base64FromUtf8(req.password) : undefined,
+    };
+}