@zktx.io/sui-mcp 0.5.0

package/dist/review-server/assets.js

@@ -0,0 +1,48 @@
+import { readFile } from "node:fs/promises";
+import { dirname, extname, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { sendJson } from "./http.js";
+export async function serveReviewAsset(response, assetsDir, requestPath) {
+    let decoded;
+    try {
+        decoded = decodeURIComponent(requestPath);
+    }
+    catch {
+        sendJson(response, 404, { error: "not_found" });
+        return;
+    }
+    const root = resolve(assetsDir);
+    const filePath = resolve(root, decoded);
+    if (filePath !== root && !filePath.startsWith(`${root}${sep}`)) {
+        sendJson(response, 404, { error: "not_found" });
+        return;
+    }
+    try {
+        const content = await readFile(filePath);
+        response.writeHead(200, {
+            "content-type": contentTypeForAsset(filePath),
+            // Entry assets keep stable names across rebuilds; never let the browser
+            // serve a stale bundle for a loopback dev/review surface.
+            "cache-control": "no-store"
+        });
+        response.end(content);
+    }
+    catch {
+        sendJson(response, 404, { error: "not_found" });
+    }
+}
+function contentTypeForAsset(filePath) {
+    switch (extname(filePath)) {
+        case ".js":
+            return "text/javascript; charset=utf-8";
+        case ".css":
+            return "text/css; charset=utf-8";
+        case ".svg":
+            return "image/svg+xml";
+        default:
+            return "application/octet-stream";
+    }
+}
+export function defaultReviewAssetsDir() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), "../review-app");
+}

package/dist/review-server/html.js

@@ -0,0 +1,45 @@
+// Page HTML shells served by the review server. Each page is a minimal document:
+// the shared <head> (charset, viewport, title, favicon, the page stylesheet) and
+// a mount element plus the page's module script. The shared UI module renders the
+// header, navigation, and content into the mount on the public pages it has
+// already migrated; pages not yet migrated keep their existing body. `data-theme`
+// defaults to light on <html> so there is no unstyled flash before the theme
+// helper applies the stored or preferred theme.
+function pageDocument(options) {
+    const uiLink = options.ui ? `    <link rel="stylesheet" href="/review-assets/ui.css">\n` : "";
+    return `<!doctype html>
+<html lang="en" data-theme="light">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>${options.title}</title>
+    <link rel="icon" type="image/svg+xml" href="/review-assets/favicon.svg">
+${uiLink}    <link rel="stylesheet" href="/review-assets/${options.css}">
+  </head>
+  <body>
+${options.body}
+    <script type="module" src="/review-assets/${options.js}"></script>
+  </body>
+</html>`;
+}
+export function settingsHtml(sessionId) {
+    return pageDocument({
+        title: "Sui MCP Settings",
+        css: "settings.css",
+        js: "settings.js",
+        ui: true,
+        body: `    <div id="settings-app" data-settings-session-id="${escapeHtml(sessionId)}"></div>`
+    });
+}
+function escapeHtml(value) {
+    return value.replace(/[&<>"']/g, (char) => {
+        const replacements = {
+            "&": "&amp;",
+            "<": "&lt;",
+            ">": "&gt;",
+            '"': "&quot;",
+            "'": "&#39;"
+        };
+        return replacements[char] ?? char;
+    });
+}

package/dist/review-server/http.js

@@ -0,0 +1,47 @@
+export const MAX_JSON_BODY_BYTES = 64 * 1024;
+export class HttpError extends Error {
+    status;
+    code;
+    constructor(status, code) {
+        super(code);
+        this.status = status;
+        this.code = code;
+    }
+}
+export function sendHtml(response, body, headers = {}, status = 200) {
+    response.writeHead(status, { "content-type": "text/html; charset=utf-8", ...headers });
+    response.end(body);
+}
+export function sendJson(response, status, body) {
+    response.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+    response.end(JSON.stringify(body));
+}
+export async function readJsonBody(request, maxBytes = MAX_JSON_BODY_BYTES) {
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        totalBytes += buffer.length;
+        if (totalBytes > maxBytes) {
+            throw new HttpError(413, "payload_too_large");
+        }
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0) {
+        return {};
+    }
+    const raw = Buffer.concat(chunks).toString("utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new HttpError(400, "invalid_json");
+    }
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+        ? parsed
+        : raiseHttpError(400, "invalid_body_shape");
+}
+export function raiseHttpError(status, code) {
+    throw new HttpError(status, code);
+}

package/dist/review-server/middleware/hostOrigin.js

@@ -0,0 +1,48 @@
+export function validateHostOrigin(request, policy) {
+    const hostHeader = request.headers.host;
+    const host = parseHost(hostHeader);
+    if (!host || !policy.allowedHostnames.includes(host.hostname)) {
+        return { ok: false, status: 400, reason: "invalid_host" };
+    }
+    const originHeader = request.headers.origin;
+    if (!originHeader) {
+        return { ok: true };
+    }
+    try {
+        const origin = new URL(originHeader);
+        if (origin.username || origin.password || origin.pathname !== "/" || origin.search || origin.hash) {
+            return { ok: false, status: 403, reason: "invalid_origin" };
+        }
+        if (origin.protocol !== "http:" && origin.protocol !== "https:") {
+            return { ok: false, status: 403, reason: "invalid_origin" };
+        }
+        if (!policy.allowedHostnames.includes(origin.hostname)) {
+            return { ok: false, status: 403, reason: "invalid_origin" };
+        }
+        if (originPort(origin) !== host.port) {
+            return { ok: false, status: 403, reason: "origin_port_mismatch" };
+        }
+    }
+    catch {
+        return { ok: false, status: 403, reason: "invalid_origin" };
+    }
+    return { ok: true };
+}
+function parseHost(hostHeader) {
+    if (!hostHeader) {
+        return undefined;
+    }
+    try {
+        const url = new URL(`http://${hostHeader}`);
+        if (url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+            return undefined;
+        }
+        return { hostname: url.hostname, port: url.port || "80" };
+    }
+    catch {
+        return undefined;
+    }
+}
+function originPort(origin) {
+    return origin.port || (origin.protocol === "https:" ? "443" : "80");
+}

package/dist/review-server/middleware/reviewToken.js

@@ -0,0 +1,7 @@
+export function readReviewToken(headers) {
+    const headerValue = headers["x-sui-mcp-token"];
+    if (typeof headerValue === "string" && headerValue.length > 0) {
+        return headerValue;
+    }
+    return undefined;
+}

package/dist/review-server/reviewServerPolicy.js

@@ -0,0 +1 @@
+export const ALLOWED_HOSTNAMES = ["127.0.0.1", "localhost"];

package/dist/review-server/server.js

@@ -0,0 +1,72 @@
+import { createServer } from "node:http";
+import { validateHostOrigin } from "./middleware/hostOrigin.js";
+import { defaultReviewAssetsDir, serveReviewAsset } from "./assets.js";
+import { settingsHtml } from "./html.js";
+import { HttpError, sendHtml, sendJson } from "./http.js";
+import { ALLOWED_HOSTNAMES } from "./reviewServerPolicy.js";
+import { routeSettingsApi } from "./settingsApi.js";
+export function createReviewRequestHandler(options) {
+    return async (request, response) => {
+        try {
+            const source = validateHostOrigin(request, { allowedHostnames: ALLOWED_HOSTNAMES });
+            if (!source.ok) {
+                sendJson(response, source.status, { error: source.reason });
+                return;
+            }
+            const url = new URL(request.url ?? "/", "http://localhost");
+            if (url.searchParams.has("token")) {
+                sendJson(response, 400, { error: "token_query_not_supported" });
+                return;
+            }
+            const settings = /^\/settings\/([^/]+)$/.exec(url.pathname);
+            if (request.method === "GET" && settings?.[1]) {
+                sendHtml(response, settingsHtml(settings[1]), { "content-security-policy": [
+                        "default-src 'none'", "base-uri 'none'", "connect-src 'self'", "script-src 'self'",
+                        "style-src 'self'", "img-src 'self' data:", "form-action 'none'"
+                    ].join("; ") });
+                return;
+            }
+            const asset = /^\/review-assets\/(.+)$/.exec(url.pathname);
+            if (request.method === "GET" && asset?.[1]) {
+                await serveReviewAsset(response, options.reviewAssetsDir ?? defaultReviewAssetsDir(), asset[1]);
+                return;
+            }
+            const route = /^\/api\/settings\/([^/]+)(?:\/(.*))?$/.exec(url.pathname);
+            if (route?.[1]) {
+                const routes = {
+                    "": "status", "clear-active-account": "clearActiveAccount", "sui-grpc-url": "setSuiGrpcUrl",
+                    "sui-grpc-url/restore-default": "restoreDefaultSuiGrpcUrl", "sui-graphql-url": "setSuiGraphqlUrl",
+                    "sui-graphql-url/restore-default": "restoreDefaultSuiGraphqlUrl", "local-data/export": "exportLocalData",
+                    "local-data/import/preview": "previewImport", "local-data/import": "importLocalData", "local-data/reset": "resetLocalData"
+                };
+                const match = routes[route[2] ?? ""];
+                if (match) {
+                    await routeSettingsApi(request, response, options, url, { [match]: route[1] });
+                    return;
+                }
+            }
+            sendJson(response, 404, { error: "not_found" });
+        }
+        catch (error) {
+            if (error instanceof HttpError) {
+                sendJson(response, error.status, { error: error.code });
+                return;
+            }
+            options.logger.error("settings request failed", { stage: "settings_http" });
+            sendJson(response, 500, { error: "internal_error" });
+        }
+    };
+}
+export function createReviewHttpServer(options) {
+    const handler = createReviewRequestHandler(options);
+    const server = createServer((request, response) => { void handler(request, response); });
+    return {
+        start(port) {
+            return new Promise((resolve, reject) => {
+                server.once("error", reject);
+                server.listen(port, options.host, () => resolve({ host: options.host, port: server.address().port,
+                    close: () => new Promise((done, failed) => { server.close((error) => error ? failed(error) : done()); }) }));
+            });
+        }
+    };
+}

package/dist/review-server/settingsApi.js

@@ -0,0 +1,158 @@
+import { LocalDataError } from "../core/activity/localDataService.js";
+import { LocalSettingsError } from "../core/preferences/preferencesStore.js";
+import { readReviewToken } from "./middleware/reviewToken.js";
+import { HttpError, MAX_JSON_BODY_BYTES, readJsonBody, sendJson } from "./http.js";
+const MAX_SETTINGS_BODY_BYTES = MAX_JSON_BODY_BYTES;
+const MAX_IMPORT_BODY_BYTES = 16 * 1024 * 1024;
+export async function routeSettingsApi(request, response, options, _url, matches) {
+    // Host/Origin and a query token are rejected once by the global guards in
+    // routeRequest before this handler runs (see the "validate once" guards
+    // there), so this handler does not re-check them.
+    const settings = requireSettingsDeps(options);
+    const sessionId = matches.status ??
+        matches.clearActiveAccount ??
+        matches.setSuiGrpcUrl ??
+        matches.restoreDefaultSuiGrpcUrl ??
+        matches.setSuiGraphqlUrl ??
+        matches.restoreDefaultSuiGraphqlUrl ??
+        matches.exportLocalData ??
+        matches.previewImport ??
+        matches.importLocalData ??
+        matches.resetLocalData;
+    if (!sessionId) {
+        throw new HttpError(404, "not_found");
+    }
+    const token = readReviewToken(request.headers);
+    if (!token || !(await options.store.validateSettingsToken(sessionId, token))) {
+        sendJson(response, 401, { error: "invalid_settings_token" });
+        return;
+    }
+    if (request.method === "GET" && matches.status) {
+        const [localSettings, activeAccount, dataCounts] = await Promise.all([
+            mapLocalSettingsError(() => settings.localSettings.getLocalSettings()),
+            settings.activityStore.getActiveAccount(),
+            settings.localData.getDataCounts()
+        ]);
+        sendJson(response, 200, {
+            settingsSessionId: sessionId,
+            server: settings.serverInfo,
+            localSettings,
+            activeAccount: activeAccount
+                ? {
+                    account: activeAccount.address,
+                    source: activeAccount.source,
+                    setAt: activeAccount.setAt
+                }
+                : undefined,
+            dataCounts,
+            restartRequired: localSettings.suiGrpcUrl.appliesAfter === "mcp_server_restart" ||
+                localSettings.suiGraphqlUrl.appliesAfter === "mcp_server_restart"
+        });
+        return;
+    }
+    if (request.method === "POST" && matches.clearActiveAccount) {
+        await readJsonBody(request, MAX_SETTINGS_BODY_BYTES);
+        await settings.activityStore.clearActiveAccount();
+        sendJson(response, 200, { status: "cleared" });
+        return;
+    }
+    if (request.method === "POST" && matches.setSuiGrpcUrl) {
+        const body = await readJsonBody(request, MAX_SETTINGS_BODY_BYTES);
+        const urlValue = typeof body.url === "string" ? body.url : undefined;
+        if (!urlValue) {
+            sendJson(response, 400, { error: "input_invalid" });
+            return;
+        }
+        const result = await mapLocalSettingsError(() => settings.localSettings.setSuiGrpcUrl(urlValue));
+        sendJson(response, 200, result);
+        return;
+    }
+    if (request.method === "POST" && matches.restoreDefaultSuiGrpcUrl) {
+        await readJsonBody(request, MAX_SETTINGS_BODY_BYTES);
+        const result = await mapLocalSettingsError(() => settings.localSettings.resetSuiGrpcUrl());
+        sendJson(response, 200, result);
+        return;
+    }
+    if (request.method === "POST" && matches.setSuiGraphqlUrl) {
+        const body = await readJsonBody(request, MAX_SETTINGS_BODY_BYTES);
+        const urlValue = typeof body.url === "string" ? body.url : undefined;
+        if (!urlValue) {
+            sendJson(response, 400, { error: "input_invalid" });
+            return;
+        }
+        const result = await mapLocalSettingsError(() => settings.localSettings.setSuiGraphqlUrl(urlValue));
+        sendJson(response, 200, result);
+        return;
+    }
+    if (request.method === "POST" && matches.restoreDefaultSuiGraphqlUrl) {
+        await readJsonBody(request, MAX_SETTINGS_BODY_BYTES);
+        const result = await mapLocalSettingsError(() => settings.localSettings.resetSuiGraphqlUrl());
+        sendJson(response, 200, result);
+        return;
+    }
+    if (request.method === "GET" && matches.exportLocalData) {
+        const envelope = await mapLocalDataError(() => settings.localData.exportLocalData());
+        sendJson(response, 200, envelope);
+        return;
+    }
+    if (request.method === "POST" && matches.previewImport) {
+        const body = await readJsonBody(request, MAX_IMPORT_BODY_BYTES);
+        const preview = await mapLocalDataError(() => settings.localData.previewImportLocalData(body));
+        sendJson(response, 200, preview);
+        return;
+    }
+    if (request.method === "POST" && matches.importLocalData) {
+        const body = await readJsonBody(request, MAX_IMPORT_BODY_BYTES);
+        const result = await mapLocalDataError(() => settings.localData.importLocalDataReplace(body));
+        sendJson(response, 200, result);
+        return;
+    }
+    if (request.method === "POST" && matches.resetLocalData) {
+        await readJsonBody(request, MAX_SETTINGS_BODY_BYTES);
+        const result = await mapLocalDataError(() => settings.localData.resetLocalData());
+        sendJson(response, 200, result);
+        return;
+    }
+    sendJson(response, 404, { error: "not_found" });
+}
+function requireSettingsDeps(options) {
+    if (!options.activityStore || !options.localSettings || !options.localData || !options.serverInfo) {
+        throw new HttpError(404, "not_found");
+    }
+    return {
+        activityStore: options.activityStore,
+        localSettings: options.localSettings,
+        localData: options.localData,
+        serverInfo: options.serverInfo
+    };
+}
+async function mapLocalSettingsError(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error instanceof LocalSettingsError) {
+            throw new HttpError(statusForLocalSettingsError(error), error.kind);
+        }
+        throw error;
+    }
+}
+function statusForLocalSettingsError(error) {
+    return error.kind === "input_invalid" ? 400 : 500;
+}
+async function mapLocalDataError(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error instanceof LocalDataError) {
+            if (error.details.reason === "wallet_request_unsettled")
+                throw new HttpError(409, "wallet_request_unsettled");
+            throw new HttpError(statusForLocalDataError(error), error.kind);
+        }
+        throw error;
+    }
+}
+function statusForLocalDataError(error) {
+    return error.kind === "input_invalid" ? 400 : 500;
+}

package/dist/runtime/application.js

@@ -0,0 +1,203 @@
+import { createRuntimeReviewDependencies } from "./reviewDependencies.js";
+import { acquireDataDirectoryOwner } from "./shared/ownerLease.js";
+import { readFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { WalletSdkProcess } from "./walletSdkProcess.js";
+import { WALLETCONNECT_PROJECT_ID } from "./walletConnectConfig.js";
+import { WalletWorkflow } from "../core/session/walletWorkflow.js";
+import { randomUUID } from "node:crypto";
+import { SqliteActivityStore } from "../core/activity/sqliteActivityStore.js";
+import { validateSupportedAdapterLifecycle } from "../adapters/adapterLifecycleValidators.js";
+import { ADAPTER_PROMPT_SURFACES } from "../adapters/adapterPromptSurfaces.js";
+import { TransactionActivityService } from "../core/activity/transactionActivityService.js";
+import { createSuiReadService } from "../core/read/readService.js";
+import { verifySuiChainReceipt } from "../core/action/suiChainReceiptVerifier.js";
+import { readPublicChainReceipt } from "../core/action/suiChainReceiptReader.js";
+import { LocalSessionStore } from "../core/session/sessionStore.js";
+import { createMcpServer } from "../mcp/server.js";
+import { SERVER_NAME, SERVER_NETWORK, SERVER_VERSION } from "../mcp/serverInfo.js";
+import { createReviewRequestHandler } from "../review-server/server.js";
+import { DEFAULT_SUI_GRAPHQL_URL, DEFAULT_SUI_GRPC_URL, composeRuntimeConfig } from "./config.js";
+import { DeepbookOfficialIndexerSource } from "../core/read/deepbookOfficialIndexerSource.js";
+import { RuntimeLocalSettingsService } from "./localSettingsService.js";
+import { verifyMainnetGraphqlEndpoint, verifyMainnetGrpcEndpoint } from "./suiEndpoint.js";
+import { GraphqlSuiTransactionActivitySource } from "./suiTransactionGraphqlSource.js";
+import { createReadCardStore } from "../mcp-ui/readCards.js";
+import { createDeepbookUsdcChartService } from "../core/read/deepbookUsdcChartService.js";
+import { RuntimeDataAccess } from "./shared/dataAccess.js";
+import { createInternalMcpHandler } from "./shared/mcpHttp.js";
+export async function createRuntimeApplication(bootConfig, logger, ownerId = randomUUID()) {
+    const access = new RuntimeDataAccess();
+    const ownership = acquireDataDirectoryOwner(bootConfig.activityDatabasePath);
+    let walletRuntime;
+    let activityStore;
+    let cards;
+    let workflow;
+    let chart;
+    try {
+        const store = new SqliteActivityStore({
+            databasePath: bootConfig.activityDatabasePath,
+            guardDatabase: access.guardDatabase,
+            validateAdapterLifecycle: validateSupportedAdapterLifecycle
+        });
+        activityStore = store;
+        const preferencesRepository = store.createPreferencesRepository();
+        await preferencesRepository.ensureDefaultLocalSettings({
+            suiGrpcUrl: DEFAULT_SUI_GRPC_URL,
+            suiGraphqlUrl: DEFAULT_SUI_GRAPHQL_URL
+        });
+        const storedSuiGrpcUrl = await preferencesRepository.getSuiGrpcUrl();
+        const storedSuiGraphqlUrl = await preferencesRepository.getSuiGraphqlUrl();
+        const config = composeRuntimeConfig({
+            bootConfig,
+            env: process.env,
+            storedSuiGrpcUrl: storedSuiGrpcUrl?.value,
+            storedSuiGraphqlUrl: storedSuiGraphqlUrl?.value,
+            defaultSuiGrpcUrl: DEFAULT_SUI_GRPC_URL,
+            defaultSuiGraphqlUrl: DEFAULT_SUI_GRAPHQL_URL
+        });
+        const { client: suiClient, chainIdentifier } = await verifyMainnetGrpcEndpoint({
+            url: config.grpcUrl,
+            expectedChainIdentifier: config.expectedChainIdentifier
+        });
+        const localSettings = new RuntimeLocalSettingsService({
+            preferencesRepository,
+            env: process.env,
+            defaultSuiGrpcUrl: DEFAULT_SUI_GRPC_URL,
+            defaultSuiGraphqlUrl: DEFAULT_SUI_GRAPHQL_URL,
+            bootSuiGrpcUrl: config.suiGrpcUrl,
+            bootSuiGraphqlUrl: config.suiGraphqlUrl
+        });
+        const workflowRecords = store.createWalletWorkflowStore(ownerId);
+        const localData = store.createLocalDataService({
+            advanceRequestDeadlines: (now) => workflowRecords.advanceRequestDeadlines(now),
+            onDataReplaced: () => { access.dataReplaced(); workflow?.dataReplaced(); chart?.clearCache(); },
+            suiGrpcUrl: DEFAULT_SUI_GRPC_URL,
+            suiGraphqlUrl: DEFAULT_SUI_GRAPHQL_URL,
+            verifySuiGrpcUrl: async (url) => {
+                await verifyMainnetGrpcEndpoint({
+                    url,
+                    expectedChainIdentifier: config.expectedChainIdentifier
+                });
+            },
+            verifySuiGraphqlUrl: async (url) => {
+                await verifyMainnetGraphqlEndpoint({
+                    url,
+                    expectedChainIdentifier: config.expectedChainIdentifier
+                });
+            }
+        });
+        const transactionMaterialStore = store.createTransactionMaterialStore();
+        const sessions = new LocalSessionStore({
+            activityStore: store,
+            transactionMaterialStore,
+            logger,
+            validateAdapterLifecycle: validateSupportedAdapterLifecycle,
+            sessions: store.createSessionRecordStore(),
+            artifacts: store.createPrivateReviewArtifactStore(),
+            ownerId,
+            settingsStore: store.createSettingsRecordStore()
+        });
+        const readService = createSuiReadService({
+            client: suiClient,
+            network: config.network,
+            chainIdentifier,
+            coinMetadataCache: store.createCoinMetadataCache(),
+            deepbookOfficialIndexerSource: new DeepbookOfficialIndexerSource()
+        });
+        const chainReceiptVerifier = (input) => verifySuiChainReceipt({
+            client: suiClient,
+            network: config.network,
+            expectedChainIdentifier: config.expectedChainIdentifier
+        }, input);
+        const publicChainReceiptReader = (input) => readPublicChainReceipt({
+            client: suiClient,
+            network: config.network,
+            expectedChainIdentifier: config.expectedChainIdentifier,
+            resolveCoinUnit: (coinType) => readService.resolveCoinUnit(coinType)
+        }, input);
+        const reviewComputationDeps = createRuntimeReviewDependencies({ client: suiClient, chainIdentifier,
+            expectedChainIdentifier: config.expectedChainIdentifier, materialStore: transactionMaterialStore, readService });
+        const httpHandler = createReviewRequestHandler({ host: config.reviewHost, store: sessions, logger,
+            activityStore: store, localSettings, localData,
+            serverInfo: { name: SERVER_NAME, version: SERVER_VERSION, network: SERVER_NETWORK } });
+        const cardRecords = store.createCardRecordStore();
+        let metadata;
+        try {
+            metadata = JSON.parse(await readFile(new URL("../../package.json", import.meta.url), "utf8"));
+        }
+        catch {
+            logger.error("WalletConnect initialization unavailable", { stage: "initialization_failed" });
+        }
+        walletRuntime = new WalletSdkProcess({ projectId: WALLETCONNECT_PROJECT_ID, dataDirectory: dirname(bootConfig.activityDatabasePath),
+            ...(metadata ? { metadata: { name: metadata.name, description: metadata.description, url: metadata.homepage } } : {}) });
+        workflow = new WalletWorkflow({ records: workflowRecords, sessions, ownerId,
+            runtime: walletRuntime, computation: reviewComputationDeps, verifyReceipt: chainReceiptVerifier, readReceipt: publicChainReceiptReader, signatureClient: suiClient,
+            assertCurrent: access.assertCurrent, bindExternalEvent: (work) => access.bind(work), logger,
+            verifyNetwork: async () => {
+                const actual = await suiClient.core.getChainIdentifier();
+                if (actual.chainIdentifier !== config.expectedChainIdentifier)
+                    throw new Error("Sui mainnet verification failed.");
+            },
+            submitTransaction: (transaction, signature) => suiClient.core.executeTransaction({ transaction, signatures: [signature] })
+        });
+        await workflow.start();
+        chart = createDeepbookUsdcChartService({ assertCurrent: access.assertCurrent });
+        cards = createReadCardStore({ readService, publicChainReceiptReader, chart, records: cardRecords, ownerId, assertCurrent: access.assertCurrent, logger, workflow });
+        const transactionActivityService = new TransactionActivityService({
+            activityStore: store,
+            source: new GraphqlSuiTransactionActivitySource({
+                url: config.graphqlUrl,
+                expectedChainIdentifier: config.expectedChainIdentifier
+            })
+        });
+        const mcp = createInternalMcpHandler(() => createMcpServer({
+            cards: { store: cards },
+            workflow,
+            promptSurfaces: ADAPTER_PROMPT_SURFACES,
+            sessions,
+            activityStore: store,
+            reviewBaseUrl: `http://${config.reviewHost}:${config.reviewPort}`,
+            readService,
+            transactionActivityService,
+            localSettings,
+            logger
+        }));
+        access.ready();
+        return {
+            handleMcp: (request, response) => access.run(() => mcp.handle(request, response)),
+            handleHttp: (request, response) => access.run(() => httpHandler(request, response)),
+            async close() {
+                workflow?.stop();
+                access.close();
+                cards?.stop();
+                chart?.clearCache();
+                try {
+                    await walletRuntime.close();
+                }
+                finally {
+                    try {
+                        await mcp.close();
+                    }
+                    finally {
+                        store.close();
+                        ownership.close();
+                    }
+                }
+            }
+        };
+    }
+    catch (error) {
+        workflow?.stop();
+        access.close();
+        cards?.stop();
+        try {
+            await walletRuntime?.close();
+        }
+        finally {
+            activityStore?.close();
+            ownership.close();
+        }
+        throw error;
+    }
+}