@xian-tech/wallet-core 0.1.0

package/dist/controller.js

@@ -0,0 +1,1082 @@
+import { Ed25519Signer, XianClient } from "@xian-tech/client";
+import { ProviderChainMismatchError, ProviderUnauthorizedError, ProviderUnsupportedMethodError } from "@xian-tech/provider";
+import { approvalKindFromMethod, buildApprovalView } from "./approvals";
+import { DEFAULT_NETWORK_PRESETS, DEFAULT_DASHBOARD_URL, DEFAULT_RPC_URL, LOCAL_NETWORK_PRESET_NAME, DEFAULT_WALLET_CAPABILITIES, LOCAL_NETWORK_PRESET_ID } from "./constants";
+import { createWalletSecret, decryptMnemonic, decryptPrivateKey, encryptMnemonic, encryptPrivateKey, isUnsafeMessageToSign } from "./crypto";
+function firstParamObject(params) {
+    if (Array.isArray(params)) {
+        return (params[0] ?? {});
+    }
+    return (params ?? {});
+}
+function parseIntentNumber(value, fieldName) {
+    if (value == null) {
+        return undefined;
+    }
+    if (typeof value === "bigint") {
+        if (value < 0n) {
+            throw new TypeError(`${fieldName} must be a non-negative integer`);
+        }
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isInteger(value) || value < 0) {
+            throw new TypeError(`${fieldName} must be a non-negative integer`);
+        }
+        return value;
+    }
+    if (typeof value === "string" && /^\d+$/.test(value)) {
+        const parsed = BigInt(value);
+        return parsed <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : parsed;
+    }
+    throw new TypeError(`${fieldName} must be a non-negative integer`);
+}
+function trimOptionalString(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function createLocalNetworkPreset() {
+    const preset = DEFAULT_NETWORK_PRESETS[0];
+    if (preset) {
+        return {
+            ...preset
+        };
+    }
+    return {
+        id: LOCAL_NETWORK_PRESET_ID,
+        name: LOCAL_NETWORK_PRESET_NAME,
+        rpcUrl: DEFAULT_RPC_URL,
+        dashboardUrl: DEFAULT_DASHBOARD_URL,
+        builtin: true
+    };
+}
+function normalizePresetInputValue(preset, fallback) {
+    return {
+        id: trimOptionalString(preset.id) ?? fallback.id,
+        name: trimOptionalString(preset.name) ?? fallback.name,
+        chainId: trimOptionalString(preset.chainId),
+        rpcUrl: trimOptionalString(preset.rpcUrl) ?? fallback.rpcUrl,
+        dashboardUrl: trimOptionalString(preset.dashboardUrl) ??
+            trimOptionalString(fallback.dashboardUrl),
+        builtin: preset.builtin ?? fallback.builtin
+    };
+}
+function normalizeStoredWalletNetworks(state) {
+    const localPreset = createLocalNetworkPreset();
+    const rawPresets = Array.isArray(state.networkPresets) ? state.networkPresets : [];
+    if (rawPresets.length === 0) {
+        const rpcUrl = trimOptionalString(state.rpcUrl) ?? DEFAULT_RPC_URL;
+        const dashboardUrl = trimOptionalString(state.dashboardUrl) ?? DEFAULT_DASHBOARD_URL;
+        const isLocalDefault = rpcUrl === localPreset.rpcUrl &&
+            (dashboardUrl ?? "") === (localPreset.dashboardUrl ?? "");
+        if (isLocalDefault) {
+            return {
+                ...state,
+                rpcUrl: localPreset.rpcUrl,
+                dashboardUrl: localPreset.dashboardUrl,
+                activeNetworkId: localPreset.id,
+                networkPresets: [localPreset]
+            };
+        }
+        const customPreset = normalizePresetInputValue({
+            id: "custom-network",
+            name: "Custom network",
+            rpcUrl,
+            dashboardUrl
+        }, {
+            id: "custom-network",
+            name: "Custom network",
+            rpcUrl,
+            dashboardUrl
+        });
+        return {
+            ...state,
+            rpcUrl: customPreset.rpcUrl,
+            dashboardUrl: customPreset.dashboardUrl,
+            activeNetworkId: customPreset.id,
+            networkPresets: [localPreset, customPreset]
+        };
+    }
+    const presets = new Map();
+    for (const rawPreset of rawPresets) {
+        const preset = normalizePresetInputValue(rawPreset, {
+            id: trimOptionalString(rawPreset.id) ?? "network",
+            name: trimOptionalString(rawPreset.name) ?? "Network",
+            rpcUrl: trimOptionalString(rawPreset.rpcUrl) ?? DEFAULT_RPC_URL,
+            dashboardUrl: trimOptionalString(rawPreset.dashboardUrl),
+            builtin: rawPreset.builtin
+        });
+        presets.set(preset.id, preset);
+    }
+    if (!presets.has(LOCAL_NETWORK_PRESET_ID)) {
+        presets.set(LOCAL_NETWORK_PRESET_ID, localPreset);
+    }
+    const activeNetworkId = trimOptionalString(state.activeNetworkId) &&
+        presets.has(trimOptionalString(state.activeNetworkId))
+        ? trimOptionalString(state.activeNetworkId)
+        : presets.values().next().value.id;
+    const activePreset = presets.get(activeNetworkId) ?? localPreset;
+    return {
+        ...state,
+        rpcUrl: activePreset.rpcUrl,
+        dashboardUrl: activePreset.dashboardUrl,
+        activeNetworkId,
+        networkPresets: [...presets.values()]
+    };
+}
+function hydrateError(error) {
+    const hydrated = new Error(error.message);
+    hydrated.name = error.name ?? "Error";
+    hydrated.code = error.code;
+    hydrated.data = error.data;
+    return hydrated;
+}
+export class WalletController {
+    options;
+    requestWaiters = new Map();
+    unlockedPrivateKey = null;
+    unlockedSigner = null;
+    constructor(options) {
+        this.options = options;
+    }
+    get store() {
+        return this.options.store;
+    }
+    providerCapabilities() {
+        return { ...DEFAULT_WALLET_CAPABILITIES };
+    }
+    createId() {
+        return this.options.createId?.() ?? globalThis.crypto.randomUUID();
+    }
+    now() {
+        return this.options.now?.() ?? Date.now();
+    }
+    serializeError(error) {
+        if (typeof error === "object" && error != null) {
+            const candidate = error;
+            return {
+                name: typeof candidate.name === "string" ? candidate.name : "Error",
+                message: typeof candidate.message === "string"
+                    ? candidate.message
+                    : String(error),
+                code: typeof candidate.code === "number" ? candidate.code : undefined,
+                data: candidate.data
+            };
+        }
+        return {
+            name: "Error",
+            message: String(error)
+        };
+    }
+    getUnlockedSigner() {
+        if (!this.unlockedPrivateKey) {
+            throw new ProviderUnauthorizedError("wallet is locked");
+        }
+        if (!this.unlockedSigner) {
+            this.unlockedSigner = new Ed25519Signer(this.unlockedPrivateKey);
+        }
+        return this.unlockedSigner;
+    }
+    currentClient(state) {
+        if (this.options.createClient) {
+            return this.options.createClient(state);
+        }
+        return new XianClient({
+            rpcUrl: state.rpcUrl,
+            dashboardUrl: state.dashboardUrl
+        });
+    }
+    requireStoredWallet(state) {
+        if (!state) {
+            throw new ProviderUnauthorizedError("wallet is not configured");
+        }
+        return normalizeStoredWalletNetworks(state);
+    }
+    activeNetworkPreset(state) {
+        const normalized = normalizeStoredWalletNetworks(state);
+        return (normalized.networkPresets.find((preset) => preset.id === normalized.activeNetworkId) ??
+            normalized.networkPresets[0] ??
+            createLocalNetworkPreset());
+    }
+    async loadWalletState() {
+        const state = await this.store.loadState();
+        if (!state) {
+            return null;
+        }
+        const normalized = normalizeStoredWalletNetworks(state);
+        if (JSON.stringify(normalized) !== JSON.stringify(state)) {
+            await this.store.saveState(normalized);
+        }
+        return normalized;
+    }
+    displayChainId(preset, resolvedChainId) {
+        return resolvedChainId ?? preset.chainId;
+    }
+    networkStatus(preset, resolvedChainId) {
+        if (!resolvedChainId) {
+            return "unreachable";
+        }
+        if (preset.chainId && preset.chainId !== resolvedChainId) {
+            return "mismatch";
+        }
+        return "ready";
+    }
+    async emitChainChangedForConnectedOrigins(state, previousChainId) {
+        if (state.connectedOrigins.length === 0) {
+            return;
+        }
+        const preset = this.activeNetworkPreset(state);
+        const nextChainId = this.displayChainId(preset, await this.safeGetChainId(state));
+        if (!nextChainId || nextChainId === previousChainId) {
+            return;
+        }
+        await Promise.all(state.connectedOrigins.map((origin) => this.broadcastProviderEvent("chainChanged", [nextChainId], origin)));
+    }
+    applyActivePreset(state, presetId) {
+        const normalized = normalizeStoredWalletNetworks(state);
+        const preset = normalized.networkPresets.find((entry) => entry.id === presetId);
+        if (!preset) {
+            throw new Error("network preset not found");
+        }
+        return {
+            ...normalized,
+            activeNetworkId: preset.id,
+            rpcUrl: preset.rpcUrl,
+            dashboardUrl: preset.dashboardUrl
+        };
+    }
+    requireConnectedOrigin(state, origin) {
+        if (!state.connectedOrigins.includes(origin)) {
+            throw new ProviderUnauthorizedError("site is not connected to this wallet");
+        }
+    }
+    async safeGetChainId(state) {
+        if (!state) {
+            return undefined;
+        }
+        try {
+            return await this.currentClient(state).getChainId();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async buildWalletInfo(state, origin) {
+        if (!state) {
+            return {
+                accounts: [],
+                connected: false,
+                locked: true,
+                capabilities: this.providerCapabilities(),
+                wallet: this.options.wallet
+            };
+        }
+        const connected = state.connectedOrigins.includes(origin);
+        const unlocked = this.unlockedPrivateKey != null;
+        const preset = this.activeNetworkPreset(state);
+        const resolvedChainId = await this.safeGetChainId(state);
+        return {
+            accounts: connected && unlocked ? [state.publicKey] : [],
+            selectedAccount: connected && unlocked ? state.publicKey : undefined,
+            chainId: this.displayChainId(preset, resolvedChainId),
+            connected,
+            locked: !unlocked,
+            capabilities: this.providerCapabilities(),
+            wallet: this.options.wallet
+        };
+    }
+    async persistWalletState(state) {
+        await this.store.saveState(normalizeStoredWalletNetworks(state));
+        return this.getPopupState();
+    }
+    async updateConnectedOrigin(origin, connected) {
+        const state = this.requireStoredWallet(await this.loadWalletState());
+        const nextOrigins = new Set(state.connectedOrigins);
+        if (connected) {
+            nextOrigins.add(origin);
+        }
+        else {
+            nextOrigins.delete(origin);
+        }
+        const nextState = {
+            ...state,
+            connectedOrigins: [...nextOrigins]
+        };
+        await this.store.saveState(nextState);
+        return nextState;
+    }
+    async updateWatchedAssets(updater) {
+        const state = this.requireStoredWallet(await this.loadWalletState());
+        await this.store.saveState({
+            ...state,
+            watchedAssets: updater(state.watchedAssets)
+        });
+    }
+    sanitizeNetworkPresetInput(input) {
+        const name = input.name.trim();
+        const rpcUrl = input.rpcUrl.trim();
+        if (!name) {
+            throw new TypeError("network preset name is required");
+        }
+        if (!rpcUrl) {
+            throw new TypeError("network preset rpcUrl is required");
+        }
+        return {
+            ...input,
+            id: trimOptionalString(input.id),
+            name,
+            chainId: trimOptionalString(input.chainId),
+            rpcUrl,
+            dashboardUrl: trimOptionalString(input.dashboardUrl),
+            makeActive: input.makeActive ?? false
+        };
+    }
+    upsertNetworkPresetInState(state, input) {
+        const normalized = normalizeStoredWalletNetworks(state);
+        const sanitized = this.sanitizeNetworkPresetInput(input);
+        const presetId = sanitized.id ?? this.createId();
+        const existingPreset = normalized.networkPresets.find((preset) => preset.id === presetId);
+        if (existingPreset?.builtin) {
+            throw new Error("built-in network presets cannot be edited");
+        }
+        const nextPreset = normalizePresetInputValue({
+            id: presetId,
+            name: sanitized.name,
+            chainId: sanitized.chainId,
+            rpcUrl: sanitized.rpcUrl,
+            dashboardUrl: sanitized.dashboardUrl,
+            builtin: false
+        }, {
+            id: presetId,
+            name: sanitized.name,
+            rpcUrl: sanitized.rpcUrl,
+            dashboardUrl: sanitized.dashboardUrl,
+            builtin: false
+        });
+        const nextPresets = normalized.networkPresets.filter((preset) => preset.id !== presetId);
+        nextPresets.push(nextPreset);
+        const nextActiveNetworkId = sanitized.makeActive || normalized.activeNetworkId === presetId
+            ? presetId
+            : normalized.activeNetworkId;
+        return this.applyActivePreset({
+            ...normalized,
+            networkPresets: nextPresets
+        }, nextActiveNetworkId);
+    }
+    async broadcastProviderEvent(event, args, targetOrigin) {
+        await this.options.onProviderEvent?.(event, args, targetOrigin);
+    }
+    async emitConnectionLifecycle(origin, chainId, publicKey) {
+        await this.broadcastProviderEvent("connect", [{ chainId }], origin);
+        await this.broadcastProviderEvent("accountsChanged", [[publicKey]], origin);
+        await this.broadcastProviderEvent("chainChanged", [chainId], origin);
+    }
+    async emitDisconnectLifecycle(origin) {
+        await this.broadcastProviderEvent("accountsChanged", [[]], origin);
+        await this.broadcastProviderEvent("disconnect", [{ code: 4100, message: "wallet disconnected" }], origin);
+    }
+    async prepareTransaction(state, intent) {
+        const signer = this.getUnlockedSigner();
+        const client = this.currentClient(state);
+        const activeChainId = await client.getChainId();
+        if (intent.chainId && intent.chainId !== activeChainId) {
+            throw new ProviderChainMismatchError("wallet is connected to a different chain");
+        }
+        return client.buildTx({
+            sender: signer.address,
+            contract: intent.contract,
+            function: intent.function,
+            kwargs: intent.kwargs,
+            chainId: activeChainId,
+            stamps: parseIntentNumber(intent.stamps, "stamps"),
+            stampsSupplied: parseIntentNumber(intent.stampsSupplied, "stampsSupplied")
+        });
+    }
+    async signPreparedTransaction(state, tx) {
+        const signer = this.getUnlockedSigner();
+        const activeChainId = await this.currentClient(state).getChainId();
+        if (tx.payload.sender !== signer.address) {
+            throw new ProviderUnauthorizedError("transaction sender does not match the active wallet");
+        }
+        if (tx.payload.chain_id !== activeChainId) {
+            throw new ProviderChainMismatchError("transaction chain does not match the active wallet chain");
+        }
+        return this.currentClient(state).signTx(tx, signer);
+    }
+    async sendPreparedTransaction(state, tx, options) {
+        const signedTx = await this.signPreparedTransaction(state, tx);
+        return this.currentClient(state).broadcastTx(signedTx, options);
+    }
+    async executeApprovedRequest(origin, request) {
+        const state = this.requireStoredWallet(await this.loadWalletState());
+        switch (request.method) {
+            case "xian_requestAccounts": {
+                this.getUnlockedSigner();
+                const chainId = this.displayChainId(this.activeNetworkPreset(state), await this.safeGetChainId(state));
+                const nextState = await this.updateConnectedOrigin(origin, true);
+                await this.emitConnectionLifecycle(origin, chainId ?? "unknown", nextState.publicKey);
+                return [nextState.publicKey];
+            }
+            case "xian_watchAsset": {
+                this.requireConnectedOrigin(state, origin);
+                this.getUnlockedSigner();
+                const assetRequest = firstParamObject(request.params);
+                const asset = assetRequest.options;
+                await this.updateWatchedAssets((assets) => {
+                    const next = assets.filter((entry) => entry.contract !== asset.contract);
+                    next.push(asset);
+                    return next;
+                });
+                return true;
+            }
+            case "xian_signMessage": {
+                this.requireConnectedOrigin(state, origin);
+                const signer = this.getUnlockedSigner();
+                const { message } = firstParamObject(request.params);
+                if (typeof message !== "string") {
+                    throw new TypeError("xian_signMessage requires a message string");
+                }
+                if (isUnsafeMessageToSign(message)) {
+                    throw new Error("refusing to sign a transaction-like payload as a plain message");
+                }
+                return signer.signMessage(message);
+            }
+            case "xian_signTransaction": {
+                this.requireConnectedOrigin(state, origin);
+                this.getUnlockedSigner();
+                const { tx } = firstParamObject(request.params);
+                return this.signPreparedTransaction(state, tx);
+            }
+            case "xian_sendTransaction": {
+                this.requireConnectedOrigin(state, origin);
+                this.getUnlockedSigner();
+                const { tx, mode, waitForTx, timeoutMs, pollIntervalMs } = firstParamObject(request.params);
+                return this.sendPreparedTransaction(state, tx, {
+                    mode: mode,
+                    waitForTx: waitForTx,
+                    timeoutMs: timeoutMs,
+                    pollIntervalMs: pollIntervalMs
+                });
+            }
+            case "xian_sendCall": {
+                this.requireConnectedOrigin(state, origin);
+                this.getUnlockedSigner();
+                const { intent, mode, waitForTx, timeoutMs, pollIntervalMs } = firstParamObject(request.params);
+                const tx = await this.prepareTransaction(state, intent);
+                return this.sendPreparedTransaction(state, tx, {
+                    mode: mode,
+                    waitForTx: waitForTx,
+                    timeoutMs: timeoutMs,
+                    pollIntervalMs: pollIntervalMs
+                });
+            }
+            default:
+                throw new ProviderUnsupportedMethodError(request.method);
+        }
+    }
+    async fulfillRequest(requestState, result) {
+        const nextState = {
+            ...requestState,
+            updatedAt: this.now(),
+            status: "fulfilled",
+            result,
+            error: undefined
+        };
+        await this.store.saveRequestState(nextState);
+        const waiter = this.requestWaiters.get(requestState.requestId);
+        if (waiter) {
+            this.requestWaiters.delete(requestState.requestId);
+            waiter.resolve(result);
+        }
+        return {
+            status: "fulfilled",
+            result
+        };
+    }
+    async rejectRequest(requestState, error) {
+        const serialized = this.serializeError(error);
+        const nextState = {
+            ...requestState,
+            updatedAt: this.now(),
+            status: "rejected",
+            result: undefined,
+            error: serialized
+        };
+        await this.store.saveRequestState(nextState);
+        const waiter = this.requestWaiters.get(requestState.requestId);
+        if (waiter) {
+            this.requestWaiters.delete(requestState.requestId);
+            waiter.reject(hydrateError(serialized));
+        }
+        return {
+            status: "rejected",
+            error: serialized
+        };
+    }
+    async createApprovalRequest(requestState, account, chainId) {
+        const record = {
+            id: this.createId(),
+            origin: requestState.origin,
+            kind: approvalKindFromMethod(requestState.request.method),
+            request: requestState.request,
+            createdAt: this.now()
+        };
+        const view = buildApprovalView(record, { account, chainId });
+        const approval = {
+            id: record.id,
+            requestId: requestState.requestId,
+            record,
+            view
+        };
+        await this.store.saveApprovalState(approval);
+        await this.store.saveRequestState({
+            ...requestState,
+            updatedAt: this.now(),
+            status: "pending",
+            approvalId: record.id
+        });
+        try {
+            await this.options.onApprovalRequested?.(record.id, view);
+            return {
+                status: "pending",
+                approvalId: record.id
+            };
+        }
+        catch (error) {
+            await this.store.deleteApprovalState(record.id);
+            const rejected = await this.rejectRequest({
+                ...requestState,
+                approvalId: record.id
+            }, error);
+            if (rejected.status !== "rejected") {
+                throw new Error("approval request rejection did not settle correctly");
+            }
+            return rejected;
+        }
+    }
+    async executeImmediateRequest(state, origin, request) {
+        switch (request.method) {
+            case "xian_getWalletInfo":
+                return {
+                    kind: "result",
+                    value: await this.buildWalletInfo(state, origin)
+                };
+            case "xian_requestAccounts": {
+                const walletState = this.requireStoredWallet(state);
+                this.getUnlockedSigner();
+                const approvalChainId = this.displayChainId(this.activeNetworkPreset(walletState), await this.safeGetChainId(walletState));
+                if (walletState.connectedOrigins.includes(origin)) {
+                    return {
+                        kind: "result",
+                        value: [walletState.publicKey]
+                    };
+                }
+                return {
+                    kind: "approval",
+                    account: walletState.publicKey,
+                    chainId: approvalChainId
+                };
+            }
+            case "xian_disconnect": {
+                if (!state) {
+                    return {
+                        kind: "result",
+                        value: null
+                    };
+                }
+                await this.updateConnectedOrigin(origin, false);
+                await this.emitDisconnectLifecycle(origin);
+                return {
+                    kind: "result",
+                    value: null
+                };
+            }
+            case "xian_accounts":
+                if (!state ||
+                    this.unlockedPrivateKey == null ||
+                    !state.connectedOrigins.includes(origin)) {
+                    return {
+                        kind: "result",
+                        value: []
+                    };
+                }
+                return {
+                    kind: "result",
+                    value: [state.publicKey]
+                };
+            case "xian_chainId":
+                {
+                    const walletState = this.requireStoredWallet(state);
+                    return {
+                        kind: "result",
+                        value: this.displayChainId(this.activeNetworkPreset(walletState), await this.safeGetChainId(walletState)) ?? null
+                    };
+                }
+            case "xian_switchChain": {
+                const walletState = this.requireStoredWallet(state);
+                const { chainId } = firstParamObject(request.params);
+                if (typeof chainId !== "string" || chainId.length === 0) {
+                    throw new TypeError("xian_switchChain requires a chainId string");
+                }
+                const previousChainId = this.displayChainId(this.activeNetworkPreset(walletState), await this.safeGetChainId(walletState));
+                if (previousChainId === chainId) {
+                    return {
+                        kind: "result",
+                        value: null
+                    };
+                }
+                const targetPreset = walletState.networkPresets.find((preset) => preset.chainId === chainId);
+                if (!targetPreset) {
+                    throw new ProviderChainMismatchError("wallet has no configured network preset for the requested chain");
+                }
+                const nextState = this.applyActivePreset(walletState, targetPreset.id);
+                await this.store.saveState(nextState);
+                await this.emitChainChangedForConnectedOrigins(nextState, previousChainId);
+                return {
+                    kind: "result",
+                    value: null
+                };
+            }
+            case "xian_watchAsset": {
+                const walletState = this.requireStoredWallet(state);
+                this.requireConnectedOrigin(walletState, origin);
+                this.getUnlockedSigner();
+                return {
+                    kind: "approval",
+                    account: walletState.publicKey,
+                    chainId: this.displayChainId(this.activeNetworkPreset(walletState), await this.safeGetChainId(walletState))
+                };
+            }
+            case "xian_signMessage": {
+                const walletState = this.requireStoredWallet(state);
+                this.requireConnectedOrigin(walletState, origin);
+                this.getUnlockedSigner();
+                return {
+                    kind: "approval",
+                    account: walletState.publicKey,
+                    chainId: this.displayChainId(this.activeNetworkPreset(walletState), await this.safeGetChainId(walletState))
+                };
+            }
+            case "xian_prepareTransaction": {
+                const walletState = this.requireStoredWallet(state);
+                this.requireConnectedOrigin(walletState, origin);
+                this.getUnlockedSigner();
+                const { intent } = firstParamObject(request.params);
+                return {
+                    kind: "result",
+                    value: await this.prepareTransaction(walletState, intent)
+                };
+            }
+            case "xian_signTransaction":
+            case "xian_sendTransaction":
+            case "xian_sendCall": {
+                const walletState = this.requireStoredWallet(state);
+                this.requireConnectedOrigin(walletState, origin);
+                this.getUnlockedSigner();
+                return {
+                    kind: "approval",
+                    account: walletState.publicKey,
+                    chainId: this.displayChainId(this.activeNetworkPreset(walletState), await this.safeGetChainId(walletState))
+                };
+            }
+            default:
+                throw new ProviderUnsupportedMethodError(request.method);
+        }
+    }
+    async getPopupState() {
+        const state = await this.loadWalletState();
+        const approvals = await this.store.listApprovalStates();
+        const pendingApprovals = approvals
+            .map((approval) => approval.view)
+            .sort((left, right) => right.createdAt - left.createdAt);
+        const activePreset = state ? this.activeNetworkPreset(state) : undefined;
+        const resolvedChainId = await this.safeGetChainId(state);
+        return {
+            hasWallet: state != null,
+            unlocked: this.unlockedPrivateKey != null,
+            publicKey: state?.publicKey,
+            rpcUrl: state?.rpcUrl ?? DEFAULT_RPC_URL,
+            dashboardUrl: state?.dashboardUrl ?? DEFAULT_DASHBOARD_URL,
+            chainId: activePreset
+                ? this.displayChainId(activePreset, resolvedChainId)
+                : undefined,
+            resolvedChainId,
+            configuredChainId: activePreset?.chainId,
+            networkStatus: activePreset
+                ? this.networkStatus(activePreset, resolvedChainId)
+                : "unreachable",
+            activeNetworkId: activePreset?.id,
+            activeNetworkName: activePreset?.name,
+            networkPresets: state?.networkPresets ?? DEFAULT_NETWORK_PRESETS,
+            watchedAssets: state?.watchedAssets ?? [],
+            connectedOrigins: state?.connectedOrigins ?? [],
+            pendingApprovalCount: pendingApprovals.length,
+            pendingApprovals,
+            hasRecoveryPhrase: Boolean(state?.encryptedMnemonic),
+            seedSource: state?.seedSource,
+            mnemonicWordCount: state?.mnemonicWordCount,
+            version: this.options.version
+        };
+    }
+    async createOrImportWallet(input) {
+        const secret = await createWalletSecret({
+            privateKey: input.privateKey,
+            mnemonic: input.mnemonic,
+            createWithMnemonic: input.createWithMnemonic
+        });
+        const signer = new Ed25519Signer(secret.privateKey);
+        const encryptedPrivateKey = await encryptPrivateKey(secret.privateKey, input.password);
+        const encryptedMnemonic = secret.mnemonic
+            ? await encryptMnemonic(secret.mnemonic, input.password)
+            : undefined;
+        this.unlockedPrivateKey = secret.privateKey;
+        this.unlockedSigner = signer;
+        const waiters = [...this.requestWaiters.values()];
+        this.requestWaiters.clear();
+        for (const waiter of waiters) {
+            waiter.reject(new ProviderUnauthorizedError("wallet was replaced"));
+        }
+        for (const requestState of await this.store.listRequestStates()) {
+            await this.store.deleteRequestState(requestState.requestId);
+        }
+        for (const approval of await this.store.listApprovalStates()) {
+            await this.store.deleteApprovalState(approval.id);
+        }
+        const setupRpcUrl = trimOptionalString(input.rpcUrl) ?? DEFAULT_RPC_URL;
+        const setupDashboardUrl = trimOptionalString(input.dashboardUrl) ?? DEFAULT_DASHBOARD_URL;
+        const localPreset = createLocalNetworkPreset();
+        const useLocalPreset = setupRpcUrl === localPreset.rpcUrl &&
+            (setupDashboardUrl ?? "") === (localPreset.dashboardUrl ?? "");
+        const customPresetId = useLocalPreset ? undefined : this.createId();
+        const activePreset = useLocalPreset
+            ? localPreset
+            : normalizePresetInputValue({
+                id: customPresetId,
+                name: trimOptionalString(input.networkName) ?? "Custom network",
+                chainId: trimOptionalString(input.expectedChainId),
+                rpcUrl: setupRpcUrl,
+                dashboardUrl: setupDashboardUrl,
+                builtin: false
+            }, {
+                id: customPresetId ?? "custom-network",
+                name: trimOptionalString(input.networkName) ?? "Custom network",
+                rpcUrl: setupRpcUrl,
+                dashboardUrl: setupDashboardUrl,
+                builtin: false
+            });
+        const networkPresets = useLocalPreset
+            ? [localPreset]
+            : [localPreset, activePreset];
+        const popupState = await this.persistWalletState({
+            publicKey: signer.address,
+            encryptedPrivateKey,
+            encryptedMnemonic,
+            seedSource: secret.seedSource,
+            mnemonicWordCount: secret.mnemonicWordCount,
+            rpcUrl: activePreset.rpcUrl,
+            dashboardUrl: activePreset.dashboardUrl,
+            activeNetworkId: activePreset.id,
+            networkPresets,
+            watchedAssets: [
+                {
+                    contract: "currency",
+                    name: "Xian",
+                    symbol: "XIAN"
+                }
+            ],
+            connectedOrigins: [],
+            createdAt: new Date().toISOString()
+        });
+        return {
+            popupState,
+            generatedMnemonic: secret.generatedMnemonic,
+            importedSeedSource: secret.seedSource
+        };
+    }
+    async unlockWallet(password) {
+        const state = this.requireStoredWallet(await this.loadWalletState());
+        const privateKey = await decryptPrivateKey(state.encryptedPrivateKey, password);
+        const signer = new Ed25519Signer(privateKey);
+        if (signer.address !== state.publicKey) {
+            throw new Error("decrypted private key does not match stored wallet");
+        }
+        this.unlockedPrivateKey = privateKey;
+        this.unlockedSigner = signer;
+        const chainId = this.displayChainId(this.activeNetworkPreset(state), await this.safeGetChainId(state));
+        await Promise.all(state.connectedOrigins.map((origin) => this.emitConnectionLifecycle(origin, chainId ?? "unknown", state.publicKey)));
+        return this.getPopupState();
+    }
+    async revealMnemonic(password) {
+        const state = this.requireStoredWallet(await this.loadWalletState());
+        if (!state.encryptedMnemonic) {
+            throw new Error("wallet does not have a recovery phrase");
+        }
+        return decryptMnemonic(state.encryptedMnemonic, password);
+    }
+    async lockWallet() {
+        const state = await this.loadWalletState();
+        this.unlockedPrivateKey = null;
+        this.unlockedSigner = null;
+        if (state) {
+            await Promise.all(state.connectedOrigins.map((origin) => this.emitDisconnectLifecycle(origin)));
+        }
+        return this.getPopupState();
+    }
+    async updateSettings(input) {
+        const state = this.requireStoredWallet(await this.loadWalletState());
+        const activePreset = this.activeNetworkPreset(state);
+        const previousChainId = this.displayChainId(activePreset, await this.safeGetChainId(state));
+        const nextState = this.upsertNetworkPresetInState(state, {
+            id: activePreset.builtin ? undefined : activePreset.id,
+            name: trimOptionalString(input.networkName) ??
+                (activePreset.builtin ? "Custom network" : activePreset.name),
+            chainId: trimOptionalString(input.expectedChainId) ?? activePreset.chainId,
+            rpcUrl: input.rpcUrl.trim() || DEFAULT_RPC_URL,
+            dashboardUrl: input.dashboardUrl?.trim() || DEFAULT_DASHBOARD_URL,
+            makeActive: true
+        });
+        await this.store.saveState(nextState);
+        await this.emitChainChangedForConnectedOrigins(nextState, previousChainId);
+        return this.getPopupState();
+    }
+    async disconnectOrigin(origin) {
+        const state = await this.loadWalletState();
+        if (!state || !state.connectedOrigins.includes(origin)) {
+            return this.getPopupState();
+        }
+        await this.updateConnectedOrigin(origin, false);
+        await this.emitDisconnectLifecycle(origin);
+        return this.getPopupState();
+    }
+    async disconnectAllOrigins() {
+        const state = await this.loadWalletState();
+        if (!state || state.connectedOrigins.length === 0) {
+            return this.getPopupState();
+        }
+        const nextState = {
+            ...state,
+            connectedOrigins: []
+        };
+        await this.store.saveState(nextState);
+        await Promise.all(state.connectedOrigins.map((origin) => this.emitDisconnectLifecycle(origin)));
+        return this.getPopupState();
+    }
+    async removeWatchedAsset(contract) {
+        const trimmed = contract.trim();
+        if (trimmed.length === 0) {
+            throw new TypeError("asset contract is required");
+        }
+        const state = this.requireStoredWallet(await this.loadWalletState());
+        if (!state.watchedAssets.some((asset) => asset.contract === trimmed)) {
+            return this.getPopupState();
+        }
+        if (trimmed === "currency") {
+            throw new Error("the native XIAN asset is pinned in the wallet");
+        }
+        return this.persistWalletState({
+            ...state,
+            watchedAssets: state.watchedAssets.filter((asset) => asset.contract !== trimmed)
+        });
+    }
+    async saveNetworkPreset(input) {
+        const state = this.requireStoredWallet(await this.loadWalletState());
+        const previousChainId = this.displayChainId(this.activeNetworkPreset(state), await this.safeGetChainId(state));
+        const nextState = this.upsertNetworkPresetInState(state, input);
+        await this.store.saveState(nextState);
+        await this.emitChainChangedForConnectedOrigins(nextState, previousChainId);
+        return this.getPopupState();
+    }
+    async switchNetwork(presetId) {
+        const state = this.requireStoredWallet(await this.loadWalletState());
+        const normalizedPresetId = presetId.trim();
+        if (!normalizedPresetId) {
+            throw new TypeError("network preset id is required");
+        }
+        const previousChainId = this.displayChainId(this.activeNetworkPreset(state), await this.safeGetChainId(state));
+        const nextState = this.applyActivePreset(state, normalizedPresetId);
+        await this.store.saveState(nextState);
+        await this.emitChainChangedForConnectedOrigins(nextState, previousChainId);
+        return this.getPopupState();
+    }
+    async removeNetworkPreset(presetId) {
+        const state = this.requireStoredWallet(await this.loadWalletState());
+        const normalizedPresetId = presetId.trim();
+        if (!normalizedPresetId) {
+            throw new TypeError("network preset id is required");
+        }
+        const preset = state.networkPresets.find((entry) => entry.id === normalizedPresetId);
+        if (!preset) {
+            return this.getPopupState();
+        }
+        if (preset.builtin) {
+            throw new Error("built-in network presets cannot be deleted");
+        }
+        const previousChainId = this.displayChainId(this.activeNetworkPreset(state), await this.safeGetChainId(state));
+        const nextPresets = state.networkPresets.filter((entry) => entry.id !== normalizedPresetId);
+        const nextActiveNetworkId = state.activeNetworkId === normalizedPresetId
+            ? createLocalNetworkPreset().id
+            : state.activeNetworkId;
+        const nextState = this.applyActivePreset({
+            ...state,
+            networkPresets: nextPresets
+        }, nextActiveNetworkId);
+        await this.store.saveState(nextState);
+        await this.emitChainChangedForConnectedOrigins(nextState, previousChainId);
+        return this.getPopupState();
+    }
+    async startProviderRequest(requestId, origin, request) {
+        const existing = await this.store.loadRequestState(requestId);
+        if (existing) {
+            if (existing.status === "pending") {
+                return {
+                    status: "pending",
+                    approvalId: existing.approvalId ?? ""
+                };
+            }
+            if (existing.status === "fulfilled") {
+                return {
+                    status: "fulfilled",
+                    result: existing.result
+                };
+            }
+            return {
+                status: "rejected",
+                error: existing.error ?? {
+                    name: "Error",
+                    message: "request failed"
+                }
+            };
+        }
+        const requestState = {
+            requestId,
+            origin,
+            request,
+            createdAt: this.now(),
+            updatedAt: this.now(),
+            status: "pending"
+        };
+        await this.store.saveRequestState(requestState);
+        try {
+            const immediate = await this.executeImmediateRequest(await this.loadWalletState(), origin, request);
+            if (immediate.kind === "result") {
+                const fulfilled = await this.fulfillRequest(requestState, immediate.value);
+                if (fulfilled.status !== "fulfilled") {
+                    throw new Error("immediate request did not settle correctly");
+                }
+                return fulfilled;
+            }
+            return this.createApprovalRequest(requestState, immediate.account, immediate.chainId);
+        }
+        catch (error) {
+            const rejected = await this.rejectRequest(requestState, error);
+            if (rejected.status !== "rejected") {
+                throw new Error("request rejection did not settle correctly");
+            }
+            return rejected;
+        }
+    }
+    async getProviderRequestStatus(requestId, options) {
+        const state = await this.store.loadRequestState(requestId);
+        if (!state) {
+            return {
+                status: "not_found"
+            };
+        }
+        if (state.status === "pending") {
+            return {
+                status: "pending",
+                approvalId: state.approvalId
+            };
+        }
+        if (options?.consume) {
+            await this.store.deleteRequestState(requestId);
+        }
+        if (state.status === "fulfilled") {
+            return {
+                status: "fulfilled",
+                result: state.result
+            };
+        }
+        return {
+            status: "rejected",
+            error: state.error ?? {
+                name: "Error",
+                message: "request failed"
+            }
+        };
+    }
+    async getApprovalView(approvalId) {
+        const approval = await this.store.loadApprovalState(approvalId);
+        if (!approval) {
+            throw new Error("approval request not found");
+        }
+        return approval.view;
+    }
+    async listApprovalStates() {
+        return this.store.listApprovalStates();
+    }
+    async attachApprovalWindow(approvalId, windowId) {
+        const approval = await this.store.loadApprovalState(approvalId);
+        if (!approval) {
+            return;
+        }
+        await this.store.saveApprovalState({
+            ...approval,
+            windowId
+        });
+    }
+    async resolveApproval(approvalId, approved) {
+        const approval = await this.store.loadApprovalState(approvalId);
+        if (!approval) {
+            throw new Error("approval request not found");
+        }
+        const requestState = await this.store.loadRequestState(approval.requestId);
+        if (!requestState) {
+            await this.store.deleteApprovalState(approval.id);
+            throw new Error("approval request is no longer active");
+        }
+        await this.store.deleteApprovalState(approvalId);
+        if (!approved) {
+            await this.rejectRequest(requestState, new ProviderUnauthorizedError("user rejected the request"));
+            return null;
+        }
+        try {
+            const result = await this.executeApprovedRequest(approval.record.origin, approval.record.request);
+            await this.fulfillRequest(requestState, result);
+            return null;
+        }
+        catch (error) {
+            await this.rejectRequest(requestState, error);
+            return null;
+        }
+    }
+    async dismissApproval(approvalId, reason = new ProviderUnauthorizedError("approval dismissed")) {
+        const approval = await this.store.loadApprovalState(approvalId);
+        if (!approval) {
+            return false;
+        }
+        const requestState = await this.store.loadRequestState(approval.requestId);
+        await this.store.deleteApprovalState(approvalId);
+        if (requestState) {
+            await this.rejectRequest(requestState, reason);
+        }
+        return true;
+    }
+    async handleProviderRequest(origin, request) {
+        const requestId = this.createId();
+        const start = await this.startProviderRequest(requestId, origin, request);
+        if (start.status === "fulfilled") {
+            return start.result;
+        }
+        if (start.status === "rejected") {
+            throw hydrateError(start.error);
+        }
+        return new Promise((resolve, reject) => {
+            this.requestWaiters.set(requestId, { resolve, reject });
+        });
+    }
+}
+export function errorFromSerializedWalletError(error) {
+    return hydrateError(error);
+}
+//# sourceMappingURL=controller.js.map