@zktx.io/sui-mcp 0.5.0

package/dist/runtime/walletConnectTransport.js

@@ -0,0 +1,128 @@
+import { SignClient } from "@walletconnect/sign-client";
+import { getSdkError } from "@walletconnect/utils";
+import { z } from "zod";
+import { parseSuiAddress } from "../core/suiAddress.js";
+import { SUI_MAINNET_WALLET_CHAIN, SUI_SIGN_TRANSACTION_METHOD, WalletUserRejectedError } from "../core/session/walletConnection.js";
+import { openWalletConnectStorage } from "./walletConnectStorage.js";
+const signedResponse = z.object({ transactionBytes: z.string().min(1), signature: z.string().min(1) }).strict();
+function transportError(error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
+    return ["USER_REJECTED", "USER_REJECTED_CHAINS", "USER_REJECTED_METHODS", "USER_REJECTED_EVENTS"]
+        .some((name) => getSdkError(name).code === code)
+        ? new WalletUserRejectedError() : new Error("The wallet request could not be completed.");
+}
+function sessionValue(session) {
+    const namespace = session.namespaces.sui ?? session.namespaces[SUI_MAINNET_WALLET_CHAIN];
+    if (!namespace || !Number.isSafeInteger(session.expiry) || session.expiry * 1000 <= Date.now()) {
+        throw new Error("A live Sui mainnet wallet session is required.");
+    }
+    const accounts = namespace.accounts.filter((account) => account.startsWith(`${SUI_MAINNET_WALLET_CHAIN}:`))
+        .map((account) => parseSuiAddress(account.slice(SUI_MAINNET_WALLET_CHAIN.length + 1)));
+    if (accounts.length === 0 || accounts.some((account) => !account))
+        throw new Error("The wallet did not approve a Sui mainnet account.");
+    return { topic: session.topic, accounts: [...new Set(accounts)], methods: [...namespace.methods],
+        chain: SUI_MAINNET_WALLET_CHAIN, expiresAt: new Date(session.expiry * 1000).toISOString(), walletName: session.peer.metadata.name };
+}
+export async function createWalletConnectTransport(options) {
+    if (!/^[0-9a-f]{32}$/i.test(options.projectId))
+        throw new Error("WalletConnect project ID format is invalid.");
+    const owner = openWalletConnectStorage(options.dataDirectory);
+    // SDK log bodies can contain pairing credentials and serialized requests.
+    // Product failure stages are recorded by the caller without these values.
+    options.onSdkStart?.();
+    const client = await (options.initialize ?? SignClient.init.bind(SignClient))({ projectId: options.projectId, metadata: { ...options.metadata, icons: [] },
+        storage: owner.storage, logger: "silent", telemetryEnabled: false });
+    let stopped = false;
+    const listeners = new Set();
+    const changed = (event) => { if (!stopped)
+        for (const listener of listeners)
+            listener(event.topic); };
+    // Pinned SignClient emits session_event without changing session.namespaces.
+    // Treat active account/chain changes as invalidation, not new authorization.
+    const selectionChanged = (event) => {
+        if (!stopped && ["accountsChanged", "chainChanged"].includes(event.params.event.name)) {
+            for (const listener of listeners)
+                listener(event.topic, true);
+        }
+    };
+    client.on("session_update", changed);
+    client.on("session_delete", changed);
+    client.on("session_expire", changed);
+    client.on("session_event", selectionChanged);
+    const inspectValue = (session) => {
+        try {
+            return { topic: session.topic, status: "present", session: sessionValue(session) };
+        }
+        catch {
+            return { topic: session.topic, status: "unusable" };
+        }
+    };
+    const inspect = (topic) => {
+        if (stopped)
+            throw new Error("WalletConnect owner stopped.");
+        // A store failure is not evidence that the session disappeared.
+        const session = client.session.getAll().find((item) => item.topic === topic);
+        return session ? inspectValue(session) : { topic, status: "absent" };
+    };
+    const current = (topic) => {
+        if (stopped)
+            return undefined;
+        const observed = inspect(topic);
+        return observed.status === "present" ? observed.session : undefined;
+    };
+    const requireActive = () => { if (stopped)
+        throw new Error("WalletConnect owner stopped."); };
+    return {
+        async restore() {
+            requireActive();
+            // A pending proposal is not an approved session and must not reappear as
+            // a new approval ceremony after owner replacement.
+            for (const pairing of client.core.pairing.getPairings()) {
+                if (!pairing.active)
+                    await client.core.pairing.disconnect({ topic: pairing.topic });
+            }
+            return client.session.getAll().flatMap((session) => { const value = current(session.topic); return value ? [value] : []; });
+        },
+        async connect() {
+            requireActive();
+            const connecting = await client.connect({ requiredNamespaces: { sui: {
+                        chains: [SUI_MAINNET_WALLET_CHAIN], methods: [SUI_SIGN_TRANSACTION_METHOD], events: ["accountsChanged", "chainChanged"]
+                    } } });
+            const approval = connecting.approval().then(sessionValue).catch((error) => { throw transportError(error); });
+            // Attach a rejection handler immediately; the backend records the same
+            // promise's outcome once the private QR has been associated with its row.
+            void approval.catch(() => undefined);
+            if (!connecting.uri)
+                throw new Error("The wallet pairing could not be prepared.");
+            const topic = /^wc:([^@]+)@2\?/.exec(connecting.uri)?.[1];
+            const pairing = topic ? client.core.pairing.getPairings().find((item) => item.topic === topic) : undefined;
+            if (!pairing || !Number.isSafeInteger(pairing.expiry))
+                throw new Error("Wallet pairing expiry is unavailable.");
+            return { uri: connecting.uri, expiresAt: new Date(pairing.expiry * 1000).toISOString(), approval };
+        },
+        async disconnect(topic) { requireActive(); await client.disconnect({ topic, reason: getSdkError("USER_DISCONNECTED") }); },
+        async sign(input) {
+            requireActive();
+            const session = current(input.topic);
+            if (!session?.accounts.includes(input.account) || !session.methods.includes(SUI_SIGN_TRANSACTION_METHOD)) {
+                throw new Error("This wallet session cannot sign for the selected Sui account.");
+            }
+            return signedResponse.parse(await client.request({ topic: input.topic, chainId: SUI_MAINNET_WALLET_CHAIN,
+                request: { method: SUI_SIGN_TRANSACTION_METHOD, params: { transaction: input.transactionBytesBase64, address: input.account } } }));
+        },
+        session: current,
+        inspect,
+        inspectAll: () => { requireActive(); return client.session.getAll().map(inspectValue); },
+        onSessionChanged(listener) { listeners.add(listener); return () => { listeners.delete(listener); }; },
+        stop() {
+            stopped = true;
+            listeners.clear();
+            client.off("session_update", changed);
+            client.off("session_delete", changed);
+            client.off("session_expire", changed);
+            client.off("session_event", selectionChanged);
+            // SignClient has no supported complete in-process disposal. The runtime
+            // ends the owner process; it must not close injected storage under timers.
+        }
+    };
+}

package/dist/runtime/walletSdkChild.js

@@ -0,0 +1,3 @@
+import { createWalletConnectTransport } from "./walletConnectTransport.js";
+import { runWalletSdkChild } from "./walletSdkChildRuntime.js";
+runWalletSdkChild(({ projectId, dataDirectory, metadata }) => createWalletConnectTransport({ projectId, dataDirectory, metadata }));

package/dist/runtime/walletSdkChildRuntime.js

@@ -0,0 +1,160 @@
+import { join } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { WalletUserRejectedError } from "../core/session/walletConnection.js";
+import { acquireDataDirectoryOwner } from "./shared/ownerLease.js";
+import { walletCommandSchema, walletEventSchema } from "./walletSdkIpc.js";
+// Production and the real-SDK wire fixture run this same process lifecycle.
+// The factory is a code dependency, never a serialized command or setting.
+export function runWalletSdkChild(createTransport) {
+    let init, transport;
+    let sequence = 0, lastRequest = 0, ready = false, exiting = false;
+    let stage = "initialization_failed";
+    let ownership;
+    const sessions = new Map();
+    const send = (message) => {
+        if (!process.connected || !process.send) {
+            exit();
+            return;
+        }
+        process.send(walletEventSchema.parse(message), (error) => { if (error)
+            exit(); });
+    };
+    const envelope = () => ({ protocolVersion: 1, runId: init.runId });
+    const exit = () => { if (!exiting) {
+        exiting = true;
+        void ownership;
+        process.exit(0);
+    } };
+    const fail = (reason) => {
+        ready = false;
+        if (init && !exiting)
+            send({ ...envelope(), type: "failure", reason });
+        // Neither SDK cleanup nor a callback is a prerequisite for process exit.
+        if (!exiting) {
+            exiting = true;
+            process.exit(1);
+        }
+    };
+    process.once("disconnect", exit);
+    process.once("SIGTERM", exit);
+    process.once("SIGINT", exit);
+    process.on("uncaughtException", () => fail(stage));
+    process.on("unhandledRejection", () => fail(stage));
+    if (!process.connected) {
+        exit();
+        return;
+    }
+    const inspect = (value, changedTopic) => {
+        const prior = sessions.get(value.topic);
+        const priorValue = prior && (prior.status === "present" ? { topic: prior.topic, status: prior.status, session: prior.session } : { topic: prior.topic, status: prior.status });
+        const version = (prior?.version ?? 0) + Number(!prior || !isDeepStrictEqual(priorValue, value) || changedTopic === value.topic);
+        const next = { ...value, version };
+        sessions.set(value.topic, next);
+        return next;
+    };
+    const snapshot = (isReady, changedTopic, checkTopic) => {
+        try {
+            if (!ownership || !transport)
+                throw new Error("Wallet storage ownership is unavailable.");
+            const values = transport.inspectAll(), topics = new Set(values.map((item) => item.topic));
+            for (const topic of sessions.keys())
+                if (!topics.has(topic))
+                    values.push({ topic, status: "absent" });
+            if (checkTopic && !values.some((item) => item.topic === checkTopic))
+                values.push(transport.inspect(checkTopic));
+            const value = { runId: init.runId, sequence: ++sequence, observedAt: new Date().toISOString(),
+                sessions: values.map((item) => inspect(item, changedTopic)) };
+            send({ ...envelope(), type: "snapshot", snapshot: value, ready: isReady });
+            return value;
+        }
+        catch {
+            fail("wallet_state_unavailable");
+            throw new Error("Wallet state inspection failed.");
+        }
+    };
+    const start = async (input) => {
+        init = input;
+        // The child alone opens the SDK store; OS exit releases this separate lock.
+        ownership = acquireDataDirectoryOwner(join(input.dataDirectory, "walletconnect", "sessions.sqlite"));
+        send({ ...envelope(), type: "stage", stage: "sdk_start" });
+        transport = await createTransport(input);
+        stage = "restoration_failed";
+        send({ ...envelope(), type: "stage", stage: "session_restore" });
+        await transport.restore();
+        transport.onSessionChanged((topic, selectionChanged) => {
+            try {
+                snapshot(false, selectionChanged ? topic : undefined);
+            }
+            catch {
+                fail("wallet_state_unavailable");
+            }
+        });
+        stage = "wallet_state_unavailable";
+        snapshot(true);
+        ready = true;
+    };
+    const command = async (input) => {
+        const reply = { ...envelope(), requestId: input.requestId, operationId: input.operationId };
+        try {
+            if (!ready || !transport)
+                throw new Error("Wallet service is not ready.");
+            switch (input.type) {
+                case "connect": {
+                    const pairing = await transport.connect();
+                    send({ ...reply, type: "pairing", uri: pairing.uri, expiresAt: pairing.expiresAt });
+                    const session = await pairing.approval;
+                    snapshot(false);
+                    send({ ...reply, type: "connected", session });
+                    return;
+                }
+                case "disconnect":
+                    await transport.disconnect(input.topic);
+                    snapshot(false);
+                    send({ ...reply, type: "disconnected" });
+                    return;
+                case "check_session": {
+                    const value = snapshot(false, undefined, input.topic);
+                    send({ ...reply, type: "checked", sequence: value.sequence, observation: sessions.get(input.topic) });
+                    return;
+                }
+                case "sign": {
+                    snapshot(false, undefined, input.topic);
+                    const current = sessions.get(input.topic);
+                    if (current.status !== "present" || current.version !== input.sessionVersion ||
+                        !current.session.accounts.includes(input.account) || !current.session.methods.includes("sui_signTransaction")) {
+                        send({ ...reply, type: "error", code: "session_changed" });
+                        return;
+                    }
+                    const result = await transport.sign(input);
+                    snapshot(false, undefined, input.topic);
+                    send({ ...reply, type: "signed", ...result, sessionVersion: sessions.get(input.topic).version });
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            send({ ...reply, type: "error", code: error instanceof WalletUserRejectedError ? "rejected" : "operation_failed" });
+        }
+    };
+    process.on("message", (raw) => {
+        const parsed = walletCommandSchema.safeParse(raw);
+        if (!parsed.success) {
+            fail("wallet_state_unavailable");
+            return;
+        }
+        const input = parsed.data;
+        if (input.type === "init") {
+            if (init) {
+                fail("wallet_state_unavailable");
+                return;
+            }
+            void start(input).catch(() => fail(stage));
+            return;
+        }
+        if (!init || input.runId !== init.runId || input.requestId <= lastRequest)
+            return;
+        // Reserve before awaiting anything, including a connect approval.
+        lastRequest = input.requestId;
+        void command(input).catch(() => fail("wallet_state_unavailable"));
+    });
+}

package/dist/runtime/walletSdkIpc.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { suiAddressStringSchema } from "../core/suiAddress.js";
+import { walletRunIdSchema, walletStartStageSchema, walletSnapshotSchema, walletSessionObservationSchema, walletSessionSchema } from "../core/session/walletRuntime.js";
+import { walletUnavailableReasonSchema } from "../core/session/walletConnection.js";
+const envelope = z.object({ protocolVersion: z.literal(1), runId: walletRunIdSchema });
+const request = envelope.extend({ requestId: z.number().int().positive(), operationId: z.string().min(1) });
+export const walletCommandSchema = z.union([
+    envelope.extend({ type: z.literal("init"), dataDirectory: z.string().min(1), projectId: z.string().regex(/^[0-9a-f]{32}$/i),
+        metadata: z.object({ name: z.string(), description: z.string(), url: z.string() }).strict() }).strict(),
+    request.extend({ type: z.literal("connect") }).strict(),
+    request.extend({ type: z.enum(["disconnect", "check_session"]), topic: z.string().min(1) }).strict(),
+    request.extend({ type: z.literal("sign"), topic: z.string().min(1), account: suiAddressStringSchema,
+        transactionBytesBase64: z.string().min(1), sessionVersion: z.number().int().positive() }).strict()
+]);
+const reply = envelope.extend({ requestId: z.number().int().positive(), operationId: z.string().min(1) });
+export const walletEventSchema = z.union([
+    envelope.extend({ type: z.literal("stage"), stage: walletStartStageSchema }).strict(),
+    envelope.extend({ type: z.literal("snapshot"), snapshot: walletSnapshotSchema, ready: z.boolean() }).strict(),
+    envelope.extend({ type: z.literal("failure"), reason: walletUnavailableReasonSchema }).strict(),
+    reply.extend({ type: z.literal("pairing"), uri: z.string().startsWith("wc:"), expiresAt: z.string().datetime() }).strict(),
+    reply.extend({ type: z.literal("connected"), session: walletSessionSchema }).strict(),
+    reply.extend({ type: z.literal("disconnected") }).strict(),
+    reply.extend({ type: z.literal("checked"), observation: walletSessionObservationSchema, sequence: z.number().int().positive() }).strict(),
+    reply.extend({ type: z.literal("signed"), transactionBytes: z.string().min(1), signature: z.string().min(1), sessionVersion: z.number().int().positive() }).strict(),
+    reply.extend({ type: z.literal("error"), code: z.enum(["rejected", "session_changed", "operation_failed"]) }).strict()
+]);