@lightninglabs/wavelength-core 0.1.0

package/dist/requests.js

@@ -0,0 +1,5 @@
+// Request types stay hand-authored: they carry semantics the wire shape does not
+// (e.g. a plain password the client base64-encodes into the Go []byte field), so
+// core's facade module keeps explicit request mappers for them.
+/** Exact acknowledgement required to start a unilateral unroll. */
+export const FORCE_UNROLL_ACK = 'I_KNOW_WHAT_I_AM_DOING';

package/dist/response-normalization.d.ts

@@ -0,0 +1,5 @@
+import type { FacadeMethod } from './facade.ts';
+import type { Entry } from './generated.ts';
+export declare function normalizeEntry(raw: unknown): Entry;
+export declare function normalizeFacadeResult<T = unknown>(method: FacadeMethod, raw: unknown): T;
+//# sourceMappingURL=response-normalization.d.ts.map

package/dist/response-normalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-normalization.d.ts","sourceRoot":"","sources":["../src/response-normalization.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAiC5C,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,KAAK,CASlD;AAED,wBAAgB,qBAAqB,CAAC,CAAC,GAAG,OAAO,EAC/C,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,OAAO,GACX,CAAC,CAiEH"}

package/dist/response-normalization.js

@@ -0,0 +1,101 @@
+import { camelizeKeys } from "./casing.js";
+import { normalizeInfo } from "./state.js";
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function nilPointer(value) {
+    return value === null ? undefined : value;
+}
+function nilSlice(value) {
+    return value === null ? [] : value;
+}
+function mapEntries(value) {
+    const entries = nilSlice(value);
+    return Array.isArray(entries) ? entries.map(normalizeEntry) : entries;
+}
+function normalizeOptionalObject(value, transform) {
+    if (value === null)
+        return undefined;
+    const record = object(value);
+    return record ? transform(record) : value;
+}
+export function normalizeEntry(raw) {
+    const camel = camelizeKeys(raw);
+    const entry = object(camel);
+    if (!entry)
+        return camel;
+    return {
+        ...entry,
+        progress: nilPointer(entry.progress),
+        request: nilPointer(entry.request),
+    };
+}
+export function normalizeFacadeResult(method, raw) {
+    const camel = camelizeKeys(raw);
+    if (method === 'getInfo')
+        return normalizeInfo(camel);
+    const result = object(camel);
+    if (!result)
+        return camel;
+    switch (method) {
+        case 'createWallet':
+        case 'openWalletFromPasskey':
+            return { ...result, mnemonic: nilSlice(result.mnemonic) };
+        case 'prepareSend':
+            return {
+                ...result,
+                selectedOutpoints: nilSlice(result.selectedOutpoints),
+                creditPreview: nilPointer(result.creditPreview),
+            };
+        case 'list': {
+            const normalized = { ...result };
+            if (Object.hasOwn(result, 'activity')) {
+                normalized.activity = normalizeOptionalObject(result.activity, (activity) => ({
+                    ...activity,
+                    entries: mapEntries(activity.entries),
+                }));
+            }
+            if (Object.hasOwn(result, 'vtxos')) {
+                normalized.vtxos = normalizeOptionalObject(result.vtxos, (inventory) => ({
+                    ...inventory,
+                    vtxos: nilSlice(inventory.vtxos),
+                }));
+            }
+            if (Object.hasOwn(result, 'onchain')) {
+                normalized.onchain = normalizeOptionalObject(result.onchain, (history) => ({
+                    ...history,
+                    txs: nilSlice(history.txs),
+                }));
+            }
+            return normalized;
+        }
+        case 'exit':
+            return { ...result, queuedOutpoints: nilSlice(result.queuedOutpoints) };
+        case 'exitStatus':
+            return {
+                ...result,
+                progress: nilPointer(result.progress),
+                cSV: nilPointer(result.cSV),
+                fees: nilPointer(result.fees),
+            };
+        case 'exitSummary':
+            return { ...result, exits: nilSlice(result.exits) };
+        case 'getExitPlan':
+            return { ...result, plans: nilSlice(result.plans) };
+        case 'sweepWallet':
+            return { ...result, inputs: nilSlice(result.inputs) };
+        case 'deposit':
+        case 'receive':
+        case 'sendPrepared':
+            return {
+                ...result,
+                entry: result.entry === undefined
+                    ? undefined
+                    : normalizeEntry(result.entry),
+            };
+        default:
+            return result;
+    }
+}

package/dist/results.d.ts

@@ -0,0 +1,49 @@
+import type { OpenWalletResult, SendResult as SendResultWire } from './generated.ts';
+/**
+ * The result of opening a wallet from a passkey, re-exported verbatim under the
+ * SDK's public name.
+ */
+export type OpenWalletFromPasskeyResult = OpenWalletResult;
+/**
+ * Augments the wire send shape with `paymentHash`, the canonical place to read
+ * a Lightning payment hash for a send. The daemon returns it from prepareSend
+ * (not sendPrepared), so the client folds it into `send()`'s result. Prefer this
+ * field over digging into `entry.progress` / `entry.request`, and note that
+ * `entry.id` is an activity id, not a payment hash.
+ */
+export type SendResult = SendResultWire & {
+    /** The Lightning payment hash, when the send produced one. */
+    paymentHash?: string;
+};
+/**
+ * Result types re-exported verbatim from the generated daemon facade types. They
+ * keep their generated names as part of the SDK's public surface.
+ */
+export type { Balance, CreateWalletResult, DepositResult, ExitResult, ExitStatusResult, GetExitPlanResult, ListResult, ReceiveResult, SweepWalletResult, UnlockWalletResult, } from './generated.ts';
+/**
+ * Detailed exit-status sub-shapes re-exported verbatim from the generated
+ * daemon facade types. They populate {@link ExitStatusResult} when its request
+ * sets `detailed`.
+ */
+export type { ExitProgress, ExitCSV, ExitFees } from './generated.ts';
+/**
+ * Exit portfolio types re-exported verbatim from the generated daemon facade
+ * types: the wallet-wide summary and its per-exit entry.
+ */
+export type { ExitSummaryResult, ExitSummaryEntry } from './generated.ts';
+/**
+ * Plan- and sweep-input types re-exported verbatim from the generated daemon
+ * facade types. `ExitInfeasibilityReason` explains why an {@link ExitPlanEntry}
+ * cannot start.
+ */
+export type { ExitPlanEntry, ExitInfeasibilityReason, WalletSweepInput, } from './generated.ts';
+/**
+ * Activity and entry types re-exported verbatim from the generated daemon facade
+ * types. These describe the wallet activity stream and its list/preview shapes.
+ */
+export type { ActivityList, CreditPreview, Entry, EntryFailureCode, EntryKind, EntryPhase, EntryProgress, EntryRequest, EntryRequestType, EntryStatus, ExitJobStatus, ExitPath, ListView, OnchainHistory, OnchainTx, PrepareSendResult, SendRail, SendQuoteStatus, VTXOInventory, WalletVTXO, } from './generated.ts';
+/**
+ * Generated string-enum constants for public result and activity shapes.
+ */
+export { SendRailUnspecified, SendRailOffchainUnknown, SendRailInArk, SendRailLightning, SendRailOnchain, SendRailCredit, SendRailMixed, SendQuoteStatusUnspecified, SendQuoteStatusComplete, SendQuoteStatusLocalOnly, ListViewActivity, ListViewVTXOs, ListViewOnchain, ExitPathCooperative, ExitPathUnilateral, ExitPathUnilateralFallback, ExitJobStatusUnspecified, ExitJobStatusPending, ExitJobStatusMaterializing, ExitJobStatusCSVPending, ExitJobStatusSweeping, ExitJobStatusCompleted, ExitJobStatusFailed, ExitInfeasibilityReasonUnspecified, ExitInfeasibilityReasonSweepBelowDust, ExitInfeasibilityReasonUneconomical, ExitInfeasibilityReasonWalletUnderfunded, ExitInfeasibilityReasonWalletTooFewInputs, EntryKindSend, EntryKindReceive, EntryKindDeposit, EntryKindExit, EntryStatusPending, EntryStatusComplete, EntryStatusFailed, EntryPhaseUnspecified, EntryPhaseRequestCreated, EntryPhaseWaitingForPayment, EntryPhasePaymentDetected, EntryPhaseSettling, EntryPhaseConfirmed, EntryPhaseRefunding, EntryPhaseRefunded, EntryPhaseFailed, EntryPhaseWaitingForConfirmation, EntryRequestTypeLightning, EntryRequestTypeOnchain, EntryRequestTypeArk, EntryFailureCodeTimedOut, EntryFailureCodeExpired, EntryFailureCodeRefunded, EntryFailureCodeNeedsIntervention, EntryFailureCodeFailed, } from './generated.ts';
+//# sourceMappingURL=results.d.ts.map

package/dist/results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"results.d.ts","sourceRoot":"","sources":["../src/results.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,UAAU,IAAI,cAAc,EAC7B,MAAM,gBAAgB,CAAC;AAExB;;;GAGG;AACH,MAAM,MAAM,2BAA2B,GAAG,gBAAgB,CAAC;AAE3D;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG;IACxC,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;;GAGG;AACH,YAAY,EACV,OAAO,EACP,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AAExB;;;;GAIG;AACH,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEtE;;;GAGG;AACH,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAE1E;;;;GAIG;AACH,YAAY,EACV,aAAa,EACb,uBAAuB,EACvB,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAExB;;;GAGG;AACH,YAAY,EACV,YAAY,EACZ,aAAa,EACb,KAAK,EACL,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,cAAc,EACd,SAAS,EACT,iBAAiB,EACjB,QAAQ,EACR,eAAe,EACf,aAAa,EACb,UAAU,GACX,MAAM,gBAAgB,CAAC;AAExB;;GAEG;AACH,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACvB,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,aAAa,EACb,0BAA0B,EAC1B,uBAAuB,EACvB,wBAAwB,EACxB,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,0BAA0B,EAC1B,wBAAwB,EACxB,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,EACvB,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,kCAAkC,EAClC,qCAAqC,EACrC,mCAAmC,EACnC,wCAAwC,EACxC,yCAAyC,EACzC,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,wBAAwB,EACxB,2BAA2B,EAC3B,yBAAyB,EACzB,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,gCAAgC,EAChC,yBAAyB,EACzB,uBAAuB,EACvB,mBAAmB,EACnB,wBAAwB,EACxB,uBAAuB,EACvB,wBAAwB,EACxB,iCAAiC,EACjC,sBAAsB,GACvB,MAAM,gBAAgB,CAAC"}

package/dist/results.js

@@ -0,0 +1,4 @@
+/**
+ * Generated string-enum constants for public result and activity shapes.
+ */
+export { SendRailUnspecified, SendRailOffchainUnknown, SendRailInArk, SendRailLightning, SendRailOnchain, SendRailCredit, SendRailMixed, SendQuoteStatusUnspecified, SendQuoteStatusComplete, SendQuoteStatusLocalOnly, ListViewActivity, ListViewVTXOs, ListViewOnchain, ExitPathCooperative, ExitPathUnilateral, ExitPathUnilateralFallback, ExitJobStatusUnspecified, ExitJobStatusPending, ExitJobStatusMaterializing, ExitJobStatusCSVPending, ExitJobStatusSweeping, ExitJobStatusCompleted, ExitJobStatusFailed, ExitInfeasibilityReasonUnspecified, ExitInfeasibilityReasonSweepBelowDust, ExitInfeasibilityReasonUneconomical, ExitInfeasibilityReasonWalletUnderfunded, ExitInfeasibilityReasonWalletTooFewInputs, EntryKindSend, EntryKindReceive, EntryKindDeposit, EntryKindExit, EntryStatusPending, EntryStatusComplete, EntryStatusFailed, EntryPhaseUnspecified, EntryPhaseRequestCreated, EntryPhaseWaitingForPayment, EntryPhasePaymentDetected, EntryPhaseSettling, EntryPhaseConfirmed, EntryPhaseRefunding, EntryPhaseRefunded, EntryPhaseFailed, EntryPhaseWaitingForConfirmation, EntryRequestTypeLightning, EntryRequestTypeOnchain, EntryRequestTypeArk, EntryFailureCodeTimedOut, EntryFailureCodeExpired, EntryFailureCodeRefunded, EntryFailureCodeNeedsIntervention, EntryFailureCodeFailed, } from "./generated.js";

package/dist/state.d.ts

@@ -0,0 +1,87 @@
+import type { Info, Status } from './generated.ts';
+/**
+ * The wallet lifecycle, exposed as a lowercase string union to match the SDK's
+ * other enums (EntryKind, SendRail, ...). The daemon sends the proto's numeric
+ * enum; the client maps it to these strings at the response boundary via
+ * {@link walletStateFromProto}.
+ */
+export declare const WalletState: {
+    /** No wallet exists yet; one must be created. */
+    readonly None: "none";
+    /** A wallet exists but is locked and must be unlocked. */
+    readonly Locked: "locked";
+    /** The wallet is unlocked and ready to use. */
+    readonly Ready: "ready";
+    /** The wallet is unlocked and catching up with the chain. */
+    readonly Syncing: "syncing";
+};
+/**
+ * The wallet lifecycle value type: one of the {@link WalletState} string values.
+ */
+export type WalletState = (typeof WalletState)[keyof typeof WalletState];
+/**
+ * Normalizes a raw daemon walletState (a proto number) to the SDK string union.
+ * Already-string values pass through unchanged.
+ *
+ * @param value - The raw walletState as a proto number, an SDK string, or undefined.
+ * @returns The normalized {@link WalletState} string.
+ */
+export declare function walletStateFromProto(value: number | WalletState | undefined): WalletState;
+export type { ServerInfo } from './generated.ts';
+/**
+ * The daemon's Info with walletState normalized to the string union and the
+ * walletReady predicate backfilled (the facade exposes it as a Go method, so it
+ * is absent from the JSON). The client always returns this complete shape from
+ * `getInfo()`/`start()`; the engine snapshot holds it as `WalletInfo | null`.
+ */
+export type WalletInfo = Omit<Info, 'walletState'> & {
+    /** The wallet lifecycle as the SDK string union. */
+    walletState: WalletState;
+    /** True iff the wallet is unlocked and ready (mirrors the Go Info.WalletReady() method). */
+    walletReady: boolean;
+};
+/**
+ * Maps a raw daemon Info (numeric walletState, no walletReady) onto the public
+ * {@link WalletInfo}: it converts walletState to the string union and backfills
+ * walletReady (ready iff walletState === 'ready'), mirroring the Go
+ * Info.WalletReady() method. Shared facade normalization applies this after
+ * the transport returns getInfo.
+ *
+ * @param raw - The raw daemon Info payload (untrusted shape).
+ * @returns The normalized {@link WalletInfo}.
+ */
+export declare function normalizeInfo(raw: unknown): WalletInfo;
+/**
+ * The lifecycle a UI renders. The runtime phases
+ * (loading/runtimeReady/starting/stopping/stopped/error) are owned by the host's
+ * start/stop flow; the wallet phases (needsWallet/locked/syncing/ready) are
+ * derived from {@link WalletInfo} by {@link phaseFromInfo}. It lives in core so
+ * non-React and React Native consumers share one vocabulary. 'restoring'
+ * means a background restore is bringing a fresh wallet up; the engine owns it
+ * (like 'starting'), it is never returned by phaseFromInfo.
+ */
+export type RuntimePhase = 'loading' | 'runtimeReady' | 'starting' | 'needsWallet' | 'locked' | 'syncing' | 'restoring' | 'ready' | 'stopping' | 'stopped' | 'error';
+/**
+ * The subset of {@link RuntimePhase} derivable from wallet info: the phases
+ * {@link phaseFromInfo} can return. The runtime-owned phases (loading,
+ * runtimeReady, starting, restoring, stopping, stopped, error) are not
+ * representable here.
+ */
+export type WalletPhase = 'needsWallet' | 'locked' | 'syncing' | 'ready';
+/**
+ * Derives the wallet-state phase from a {@link WalletInfo}. Runtime phases are
+ * not represented here; the caller owns those.
+ *
+ * @param info - The wallet state and readiness to derive the phase from.
+ * @returns The wallet-state {@link WalletPhase}.
+ */
+export declare function phaseFromInfo(info: {
+    walletState?: WalletState;
+    walletReady?: boolean;
+}): WalletPhase;
+/**
+ * The daemon's runtime status snapshot, re-exported verbatim under the SDK's
+ * public name.
+ */
+export type WalletStatus = Status;
+//# sourceMappingURL=state.d.ts.map

package/dist/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../src/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,WAAW;IACtB,iDAAiD;;IAEjD,0DAA0D;;IAE1D,+CAA+C;;IAE/C,6DAA6D;;CAErD,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC;AAczE;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,GACtC,WAAW,CAcb;AAQD,YAAY,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,GAAG;IACnD,oDAAoD;IACpD,WAAW,EAAE,WAAW,CAAC;IACzB,4FAA4F;IAC5F,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,CAWtD;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GACpB,SAAS,GACT,cAAc,GACd,UAAU,GACV,aAAa,GACb,QAAQ,GACR,SAAS,GACT,WAAW,GACX,OAAO,GACP,UAAU,GACV,SAAS,GACT,OAAO,CAAC;AAEZ;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,aAAa,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;AAEzE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,WAAW,CAgBd;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC"}

package/dist/state.js

@@ -0,0 +1,87 @@
+/**
+ * The wallet lifecycle, exposed as a lowercase string union to match the SDK's
+ * other enums (EntryKind, SendRail, ...). The daemon sends the proto's numeric
+ * enum; the client maps it to these strings at the response boundary via
+ * {@link walletStateFromProto}.
+ */
+export const WalletState = {
+    /** No wallet exists yet; one must be created. */
+    None: 'none',
+    /** A wallet exists but is locked and must be unlocked. */
+    Locked: 'locked',
+    /** The wallet is unlocked and ready to use. */
+    Ready: 'ready',
+    /** The wallet is unlocked and catching up with the chain. */
+    Syncing: 'syncing',
+};
+/**
+ * Maps the daemon's numeric WalletState enum to the SDK string. The daemon never
+ * emits 0 (Unspecified); a missing/unknown value maps to 'none', the safe
+ * non-ready state.
+ */
+const PROTO_WALLET_STATE = {
+    1: WalletState.None,
+    2: WalletState.Locked,
+    3: WalletState.Ready,
+    4: WalletState.Syncing,
+};
+/**
+ * Normalizes a raw daemon walletState (a proto number) to the SDK string union.
+ * Already-string values pass through unchanged.
+ *
+ * @param value - The raw walletState as a proto number, an SDK string, or undefined.
+ * @returns The normalized {@link WalletState} string.
+ */
+export function walletStateFromProto(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    // An absent value or the proto's 0 (Unspecified) means no wallet yet.
+    if (value === undefined || value === 0) {
+        return WalletState.None;
+    }
+    // A recognized enum maps directly. An unrecognized non-zero value (a future
+    // or garbled daemon state) maps to the conservative 'locked', not 'none', so
+    // it never drives the UI into creating a wallet over an existing one.
+    return PROTO_WALLET_STATE[value] ?? WalletState.Locked;
+}
+/**
+ * Maps a raw daemon Info (numeric walletState, no walletReady) onto the public
+ * {@link WalletInfo}: it converts walletState to the string union and backfills
+ * walletReady (ready iff walletState === 'ready'), mirroring the Go
+ * Info.WalletReady() method. Shared facade normalization applies this after
+ * the transport returns getInfo.
+ *
+ * @param raw - The raw daemon Info payload (untrusted shape).
+ * @returns The normalized {@link WalletInfo}.
+ */
+export function normalizeInfo(raw) {
+    const info = (raw ?? {});
+    const walletState = walletStateFromProto(info.walletState);
+    return {
+        ...info,
+        walletState,
+        walletReady: info.walletReady ?? walletState === WalletState.Ready,
+    };
+}
+/**
+ * Derives the wallet-state phase from a {@link WalletInfo}. Runtime phases are
+ * not represented here; the caller owns those.
+ *
+ * @param info - The wallet state and readiness to derive the phase from.
+ * @returns The wallet-state {@link WalletPhase}.
+ */
+export function phaseFromInfo(info) {
+    if (info.walletReady || info.walletState === WalletState.Ready) {
+        return 'ready';
+    }
+    switch (info.walletState) {
+        case WalletState.Locked:
+            return 'locked';
+        case WalletState.Syncing:
+            return 'syncing';
+        case WalletState.None:
+        default:
+            return 'needsWallet';
+    }
+}

package/dist/version.d.ts

@@ -0,0 +1,18 @@
+/**
+ * RUNTIME_MANIFEST_VERSION pins the daemon build this SDK release is paired
+ * with: the generated types, the client methods, and the wasm runtime asset
+ * set (RUNTIME_ASSET_FILES in the web transport) are all produced from this
+ * one daemon revision.
+ *
+ * Hosted runtime assets live in a directory named after this value
+ * (`<assets root>/<RUNTIME_MANIFEST_VERSION>/<file>`), so every asset set gets
+ * a unique URL and a browser can never serve a stale cached runtime. Bump it
+ * together with regenerating the daemon types and publishing the matching
+ * asset set.
+ *
+ * Build tooling reads this value from the source text via
+ * scripts/runtime-version.mjs, so keep the declaration in this exact
+ * single-quoted literal form.
+ */
+export declare const RUNTIME_MANIFEST_VERSION = "v0.1.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,WAAW,CAAC"}

package/dist/version.js

@@ -0,0 +1,17 @@
+/**
+ * RUNTIME_MANIFEST_VERSION pins the daemon build this SDK release is paired
+ * with: the generated types, the client methods, and the wasm runtime asset
+ * set (RUNTIME_ASSET_FILES in the web transport) are all produced from this
+ * one daemon revision.
+ *
+ * Hosted runtime assets live in a directory named after this value
+ * (`<assets root>/<RUNTIME_MANIFEST_VERSION>/<file>`), so every asset set gets
+ * a unique URL and a browser can never serve a stale cached runtime. Bump it
+ * together with regenerating the daemon types and publishing the matching
+ * asset set.
+ *
+ * Build tooling reads this value from the source text via
+ * scripts/runtime-version.mjs, so keep the declaration in this exact
+ * single-quoted literal form.
+ */
+export const RUNTIME_MANIFEST_VERSION = 'v0.1.0';

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@lightninglabs/wavelength-core",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Transport- and framework-agnostic contract for the Wavelength self-custodial Lightning wallet SDK.",
+  "license": "MIT",
+  "homepage": "https://wavelength.lightning.engineering",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lightninglabs/wavelength-sdk.git",
+    "directory": "packages/core"
+  },
+  "bugs": "https://github.com/lightninglabs/wavelength-sdk/issues",
+  "keywords": [
+    "lightning",
+    "bitcoin",
+    "wallet",
+    "self-custodial",
+    "payments"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test"
+  }
+}