@zktx.io/sui-mcp 0.6.2 → 0.8.0

package/dist/mcp-ui/contracts.js

@@ -7,6 +7,7 @@ export const CARD_RESOURCE_URIS = {
     receipt: "ui://sui-mcp/receipt.html",
     chart: "ui://sui-mcp/chart.html",
     connect: "ui://sui-mcp/connect.html",
+    disconnect: "ui://sui-mcp/disconnect.html",
     review: "ui://sui-mcp/review.html",
     settings: "ui://sui-mcp/settings.html"
 };
@@ -20,6 +21,7 @@ export const cardInputRequiredSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("receipt"), status: z.literal("input_required"), field: z.literal("digest"), message: z.string().min(1) }).strict()
 ]);
 export const cardReferenceSchema = z.object({ cardId: z.string().min(1), permission: z.string().min(1) }).strict();
+export const cardReadReferenceSchema = cardReferenceSchema;
 export const cardSubmissionSchema = cardReferenceSchema.extend({
     revision: z.number().int().nonnegative(), input: z.record(z.string(), z.unknown())
 }).strict();
@@ -27,7 +29,7 @@ export const cardReceiptDisplaySchema = receiptDisplaySchema.extend({
     cardId: z.string().min(1), revision: z.number().int().nonnegative(), attemptId: z.string().min(1).optional()
 });
 export const cardWalletDisplaySchema = walletDisplaySchema.extend({ cardId: z.string().min(1), revision: z.number().int().nonnegative() });
-export const settingsFileDisplaySchema = z.object({ attemptId: z.string().uuid().optional(), cardId: z.string().min(1), operationId: z.string().uuid(), fileId: z.string().uuid(),
+export const settingsFileDisplaySchema = z.object({ attemptId: z.string().uuid(), cardId: z.string().min(1), operationId: z.string().uuid(), fileId: z.string().uuid(),
     offset: z.number().int().nonnegative().safe(), totalSize: z.number().int().nonnegative().safe(), sha256: z.string().regex(/^[a-f0-9]{64}$/),
     chunkBase64: z.string() }).strict();
 export const CARD_TOOLS = {

package/dist/mcp-ui/tools.js

@@ -10,7 +10,7 @@ import { z } from "zod";
 import { okToolResult, errorToolResult } from "../mcp/result.js";
 import { CardError } from "../core/session/cardSessionStore.js";
 import { resolveExplicitOrActiveAccount } from "../mcp/tools/read/readToolHelpers.js";
-import { CARD_METADATA_KEY, CARD_DISPLAY_METADATA_KEY, WALLET_DISPLAY_METADATA_KEY, SETTINGS_FILE_METADATA_KEY, CARD_RESOURCE_PREFIX, CARD_RESOURCE_URIS, CARD_TOOLS, cardReceiptDisplaySchema, cardWalletDisplaySchema, cardReferenceSchema, cardSubmissionSchema, cardInputRequiredSchema } from "./contracts.js";
+import { CARD_METADATA_KEY, CARD_DISPLAY_METADATA_KEY, WALLET_DISPLAY_METADATA_KEY, SETTINGS_FILE_METADATA_KEY, CARD_RESOURCE_PREFIX, CARD_RESOURCE_URIS, CARD_TOOLS, cardReceiptDisplaySchema, cardWalletDisplaySchema, cardReferenceSchema, cardReadReferenceSchema, cardSubmissionSchema, cardInputRequiredSchema } from "./contracts.js";
 const cardActionSchema = cardReferenceSchema.extend({ revision: z.number().int().nonnegative().safe(), input: z.union([workflowActionSchema, settingsActionSchema]) }).strict();
 export const cardMetadata = (kind) => ({
     ui: { resourceUri: CARD_RESOURCE_URIS[kind], visibility: ["model"] },
@@ -108,7 +108,7 @@ export function registerReadCards(server, deps) {
         inputSchema: chartOpenInputSchema, annotations: { readOnlyHint: true, openWorldHint: true }, _meta: cardMetadata("chart")
     }, (input) => create("chart", input));
     const actions = [
-        { name: CARD_TOOLS.read, schema: cardReferenceSchema, run: (input) => deps.cards.store.read(cardReferenceSchema.parse(input)) },
+        { name: CARD_TOOLS.read, schema: cardReadReferenceSchema, run: (input) => deps.cards.store.read(cardReadReferenceSchema.parse(input)) },
         { name: CARD_TOOLS.submit, schema: cardSubmissionSchema, run: (input) => deps.cards.store.submit(cardSubmissionSchema.parse(input)) },
         { name: CARD_TOOLS.act, schema: cardActionSchema, run: (input) => deps.cards.store.act(cardActionSchema.parse(input)) }
     ];
@@ -134,7 +134,7 @@ export function registerReadCards(server, deps) {
             }
         });
     }
-    const fileInput = cardReferenceSchema.extend({ attemptId: z.string().uuid().optional(), operationId: z.string().uuid(), fileId: z.string().uuid(), offset: z.number().int().nonnegative().safe(),
+    const fileInput = cardReferenceSchema.extend({ attemptId: z.string().uuid(), operationId: z.string().uuid(), fileId: z.string().uuid(), offset: z.number().int().nonnegative().safe(),
         limit: z.number().int().positive().safe().optional() }).strict();
     registerAppTool(server, CARD_TOOLS.readSettingsFile, { description: "Read a verified backup file for its current download attempt.", inputSchema: fileInput,
         _meta: { ui: { visibility: ["app"] } }, annotations: { readOnlyHint: true, openWorldHint: false }
@@ -143,7 +143,7 @@ export function registerReadCards(server, deps) {
             if (!deps.cards)
                 throw new CardError("Card service is unavailable.");
             const base = okToolResult({ status: "read", fileId: input.fileId, offset: input.offset, rangeSize: Number.MAX_SAFE_INTEGER });
-            const metadata = { ...(input.attemptId ? { attemptId: input.attemptId } : {}), cardId: input.cardId, operationId: input.operationId, fileId: input.fileId, offset: input.offset, totalSize: Number.MAX_SAFE_INTEGER,
+            const metadata = { attemptId: input.attemptId, cardId: input.cardId, operationId: input.operationId, fileId: input.fileId, offset: input.offset, totalSize: Number.MAX_SAFE_INTEGER,
                 sha256: "0".repeat(64), chunkBase64: "" };
             base._meta = { [SETTINGS_FILE_METADATA_KEY]: metadata };
             const budget = settingsRawChunkBudget({ jsonrpc: "2.0", id: extra.mcpReq.id, result: base });

package/dist/runtime/application.js

@@ -17,7 +17,7 @@ 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 { PRODUCT_DISPLAY_NAME, 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";
@@ -130,7 +130,7 @@ export async function createRuntimeApplication(bootConfig, logger, ownerId = ran
             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 } } : {}) });
+            ...(metadata ? { metadata: { name: PRODUCT_DISPLAY_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,
@@ -152,7 +152,7 @@ export async function createRuntimeApplication(bootConfig, logger, ownerId = ran
                 const observedAt = context.walletObservation?.observedAt;
                 return { server: { name: SERVER_NAME, version: SERVER_VERSION, network: SERVER_NETWORK },
                     localSettings: localSettings.getLocalSettingsSync((key) => preferencesRepository.getLocalSettingSync(key)),
-                    ...(account ? { readAddress: account.address } : {}),
+                    ...(account ? { readAddress: account.address, readConnectionId: account.connectionId } : {}),
                     assetReadAccount: context.assetReadAccount, walletAvailability: context.walletAvailability,
                     ...(context.connectionReconciliationRequired ? { connectionReconciliationRequired: true } : {}),
                     ...(observedAt ? { observedAt } : {}), counts: localData.getDataCountsSync() };

package/dist/runtime/config.js

@@ -2,13 +2,10 @@ import { resolveActivityDatabasePath } from "../core/activity/sqliteActivityStor
 import { DEFAULT_SUI_GRAPHQL_URL, DEFAULT_SUI_GRPC_URL, SUI_MAINNET_CHAIN_IDENTIFIER, parseGraphqlUrl, parseGrpcUrl } from "./suiEndpoint.js";
 import { SETTINGS_APPLIES_AFTER_RESTART } from "../core/preferences/preferencesStore.js";
 export function loadBootConfig(env = process.env) {
-    const network = env.SUI_NETWORK ?? "mainnet";
+    const network = env.SUI_MCP_NETWORK ?? "mainnet";
     if (network !== "mainnet") {
         throw new Error("Sui MCP product runtime only supports mainnet");
     }
-    if (env.SUI_RPC_URL) {
-        throw new Error("Sui JSON-RPC endpoint configuration is not supported; use local settings, SUI_GRPC_URL for gRPC, or SUI_GRAPHQL_URL for GraphQL");
-    }
     return {
         network: "mainnet",
         expectedChainIdentifier: SUI_MAINNET_CHAIN_IDENTIFIER,
@@ -34,8 +31,8 @@ export function composeRuntimeConfig(input) {
     const defaultSuiGraphqlUrl = parseGraphqlUrl(input.defaultSuiGraphqlUrl ?? DEFAULT_SUI_GRAPHQL_URL);
     const storedValue = parseGrpcUrl(input.storedSuiGrpcUrl ?? defaultSuiGrpcUrl);
     const storedGraphqlValue = parseGraphqlUrl(input.storedSuiGraphqlUrl ?? defaultSuiGraphqlUrl);
-    const envValue = env.SUI_GRPC_URL === undefined ? undefined : parseGrpcUrl(env.SUI_GRPC_URL);
-    const envGraphqlValue = env.SUI_GRAPHQL_URL === undefined ? undefined : parseGraphqlUrl(env.SUI_GRAPHQL_URL);
+    const envValue = env.SUI_MCP_GRPC_URL === undefined ? undefined : parseGrpcUrl(env.SUI_MCP_GRPC_URL);
+    const envGraphqlValue = env.SUI_MCP_GRAPHQL_URL === undefined ? undefined : parseGraphqlUrl(env.SUI_MCP_GRAPHQL_URL);
     const suiGrpcUrl = resolveSuiGrpcUrlView({
         defaultSuiGrpcUrl,
         storedValue,

package/dist/runtime/localSettingsService.js

@@ -1,6 +1,7 @@
 import { SETTINGS_APPLIES_AFTER_RESTART, LocalSettingsError } from "../core/preferences/preferencesStore.js";
 import { DEFAULT_SUI_GRAPHQL_ENDPOINT_VERIFY_TIMEOUT_MS, DEFAULT_SUI_GRAPHQL_URL, DEFAULT_SUI_GRPC_ENDPOINT_VERIFY_TIMEOUT_MS, DEFAULT_SUI_GRPC_URL, SUI_MAINNET_CHAIN_IDENTIFIER, SuiEndpointError, parseGraphqlUrl, parseGrpcUrl, verifyMainnetGraphqlEndpoint, verifyMainnetGrpcEndpoint } from "./suiEndpoint.js";
 import { resolveSuiGraphqlUrlView, resolveSuiGrpcUrlView } from "./config.js";
+import { DEFAULT_WALLET_CHAINS, walletChainsSchema } from "../core/session/chainAccounts.js";
 export class RuntimeLocalSettingsService {
     options;
     env;
@@ -19,12 +20,12 @@ export class RuntimeLocalSettingsService {
         this.bootSuiGrpcUrl = normalizeBootSuiGrpcUrlView(options.bootSuiGrpcUrl ??
             resolveSuiGrpcUrlView({
                 defaultSuiGrpcUrl: this.defaultSuiGrpcUrl,
-                envValue: this.env.SUI_GRPC_URL
+                envValue: this.env.SUI_MCP_GRPC_URL
             }));
         this.bootSuiGraphqlUrl = normalizeBootSuiGraphqlUrlView(options.bootSuiGraphqlUrl ??
             resolveSuiGraphqlUrlView({
                 defaultSuiGraphqlUrl: this.defaultSuiGraphqlUrl,
-                envValue: this.env.SUI_GRAPHQL_URL
+                envValue: this.env.SUI_MCP_GRAPHQL_URL
             }));
         this.verifyGrpcEndpoint = options.verifyGrpcEndpoint ?? defaultGrpcEndpointVerifier;
         this.verifyGraphqlEndpoint = options.verifyGraphqlEndpoint ?? defaultGraphqlEndpointVerifier;
@@ -33,28 +34,30 @@ export class RuntimeLocalSettingsService {
     async getLocalSettings() {
         const stored = await this.options.preferencesRepository.getSuiGrpcUrl();
         const storedGraphql = await this.options.preferencesRepository.getSuiGraphqlUrl();
-        return this.settingsFromStored(stored?.value, storedGraphql?.value);
+        const networks = await this.options.preferencesRepository.getLocalSetting("walletConnectionChains");
+        return this.settingsFromStored(stored?.value, storedGraphql?.value, networks?.value);
     }
     getLocalSettingsSync(read) {
         const grpc = read("suiGrpcUrl"), graphql = read("suiGraphqlUrl");
         if (grpc && typeof grpc.value !== "string" || graphql && typeof graphql.value !== "string")
             throw new LocalSettingsError("internal_error", "Stored endpoints are invalid.");
-        return this.settingsFromStored(grpc?.value, graphql?.value);
+        return this.settingsFromStored(grpc?.value, graphql?.value, read("walletConnectionChains")?.value);
     }
-    settingsFromStored(stored, storedGraphql) {
+    settingsFromStored(stored, storedGraphql, networks) {
         const currentStoredView = resolveSuiGrpcUrlView({
             defaultSuiGrpcUrl: this.defaultSuiGrpcUrl,
             storedValue: stored,
-            envValue: this.env.SUI_GRPC_URL
+            envValue: this.env.SUI_MCP_GRPC_URL
         });
         const currentStoredGraphqlView = resolveSuiGraphqlUrlView({
             defaultSuiGraphqlUrl: this.defaultSuiGraphqlUrl,
             storedValue: storedGraphql,
-            envValue: this.env.SUI_GRAPHQL_URL
+            envValue: this.env.SUI_MCP_GRAPHQL_URL
         });
         return {
             suiGrpcUrl: withBootEffectiveEndpoint(currentStoredView, this.bootSuiGrpcUrl),
-            suiGraphqlUrl: withBootEffectiveEndpoint(currentStoredGraphqlView, this.bootSuiGraphqlUrl)
+            suiGraphqlUrl: withBootEffectiveEndpoint(currentStoredGraphqlView, this.bootSuiGraphqlUrl),
+            walletConnectionChains: walletChainsSchema.parse(networks ?? DEFAULT_WALLET_CHAINS)
         };
     }
     resolveEndpointChange(input) {

package/dist/runtime/shared/control.js

@@ -3,8 +3,8 @@ import { link, lstat, mkdir, readFile, realpath, unlink, writeFile } from "node:
 import { basename, dirname, join } from "node:path";
 import { z } from "zod";
 import { SERVER_VERSION } from "../../mcp/serverInfo.js";
-export const IDENTITY_PATH = "/__runtime/identity";
-export const INTERNAL_MCP_PATH = "/__runtime/mcp";
+export const IDENTITY_PATH = "/runtime/identity";
+export const INTERNAL_MCP_PATH = "/runtime/mcp";
 export const IDENTITY_CHALLENGE_HEADER = "x-sui-mcp-identity-challenge";
 export const SERVER_INSTANCE_HEADER = "x-sui-mcp-server-instance";
 export const IDENTITY_TIMEOUT_MS = 1000;

package/dist/runtime/smokeMainnetRead.js

@@ -22,7 +22,7 @@ import { SmokeResponseShapeError, assertSmokeOkStatus, summarizeActivitySmokePay
 import { SuiEndpointError, verifyMainnetGraphqlEndpoint, verifyMainnetGrpcEndpoint } from "./suiEndpoint.js";
 import { GraphqlSuiTransactionActivitySource } from "./suiTransactionGraphqlSource.js";
 const startedAt = new Date();
-const smokeFunctionTarget = process.env.SMOKE_FUNCTION_TARGET;
+const smokeFunctionTarget = process.env.SUI_MCP_SMOKE_FUNCTION_TARGET;
 const plannedTools = [
     TOOL_NAMES.readSummarizeWalletAssets,
     TOOL_NAMES.readInspectDeepbookOrderbook,
@@ -65,11 +65,11 @@ class SmokeMainnetError extends Error {
 async function main() {
     const logger = createStderrLogger("smoke-mainnet");
     const bootConfig = loadSmokeBootConfig();
-    const smokeAddress = parseSuiAddress(requiredEnv("SMOKE_SUI_ADDRESS")) ?? fail("config_error", "SMOKE_SUI_ADDRESS must be a Sui address.");
-    const poolKey = requiredEnv("SMOKE_DEEPBOOK_POOL_KEY");
-    const quoteAmount = requiredEnv("SMOKE_QUOTE_AMOUNT");
-    const inspectDigest = process.env.SMOKE_INSPECT_DIGEST;
-    const inspectRandomLatest = truthyEnv("SMOKE_INSPECT_RANDOM_LATEST");
+    const smokeAddress = parseSuiAddress(requiredEnv("SUI_MCP_SMOKE_ADDRESS")) ?? fail("config_error", "SUI_MCP_SMOKE_ADDRESS must be a Sui address.");
+    const poolKey = requiredEnv("SUI_MCP_SMOKE_DEEPBOOK_POOL_KEY");
+    const quoteAmount = requiredEnv("SUI_MCP_SMOKE_QUOTE_AMOUNT");
+    const inspectDigest = process.env.SUI_MCP_SMOKE_INSPECT_DIGEST;
+    const inspectRandomLatest = truthyEnv("SUI_MCP_SMOKE_INSPECT_RANDOM_LATEST");
     const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
     const client = new Client({ name: "sui-mcp-smoke", version: "0.0.0" });
     let smokeDbDir;
@@ -125,7 +125,7 @@ async function main() {
         });
         const reviewDependencies = createRuntimeReviewDependencies({ client: suiClient, chainIdentifier,
             expectedChainIdentifier: config.expectedChainIdentifier, materialStore: transactionMaterialStore, readService });
-        await activityStore.setActiveAccount(smokeAddress, "wallet_connection", new Date(), { name: "Explicit smoke read fixture" });
+        await activityStore.upsertAccount(smokeAddress, "review_execution");
         server = createMcpServer({
             sessions,
             activityStore,
@@ -159,7 +159,7 @@ async function main() {
             limit: ACTIVITY_SMOKE_LIMIT
         });
         const activitySummary = await callSmokeTool(client, TOOL_NAMES.readSummarizeSuiActivityScan, {
-            limit: ACTIVITY_SMOKE_LIMIT
+            account: smokeAddress, limit: ACTIVITY_SMOKE_LIMIT
         });
         assertSmokeOkStatus(wallet, TOOL_NAMES.readSummarizeWalletAssets);
         markCompleted(TOOL_NAMES.readSummarizeWalletAssets);
@@ -174,7 +174,7 @@ async function main() {
         });
         markCompleted(TOOL_NAMES.readScanSuiAccountActivity);
         activitySmoke.summary = summarizeActivitySmokePayload(activitySummary, TOOL_NAMES.readSummarizeSuiActivityScan, {
-            expectedAccountSource: "active_account_context",
+            expectedAccountSource: "explicit_filter",
             requireAnalysis: true,
             expectNoDetails: true
         });
@@ -187,6 +187,7 @@ async function main() {
             });
             const functionActivitySummary = await callSmokeTool(client, TOOL_NAMES.readSummarizeSuiFunctionActivityScan, {
                 function: smokeFunctionTarget,
+                account: smokeAddress,
                 limit: ACTIVITY_SMOKE_LIMIT
             });
             functionActivitySmoke.scan = summarizeActivitySmokePayload(functionActivityScan, TOOL_NAMES.readScanSuiFunctionActivity, {
@@ -198,7 +199,7 @@ async function main() {
             });
             markCompleted(TOOL_NAMES.readScanSuiFunctionActivity);
             functionActivitySmoke.summary = summarizeActivitySmokePayload(functionActivitySummary, TOOL_NAMES.readSummarizeSuiFunctionActivityScan, {
-                expectedAccountSource: "active_account_context",
+                expectedAccountSource: "explicit_filter",
                 expectedRelationship: "sent",
                 requireFunction: true,
                 requireAnalysis: true,
@@ -329,18 +330,18 @@ function fail(category, message) {
 }
 function smokeEnvPresence() {
     return {
-        SUI_GRPC_URL: process.env.SUI_GRPC_URL !== undefined,
-        SUI_GRAPHQL_URL: process.env.SUI_GRAPHQL_URL !== undefined,
-        SMOKE_SUI_ADDRESS: process.env.SMOKE_SUI_ADDRESS !== undefined,
-        SMOKE_DEEPBOOK_POOL_KEY: process.env.SMOKE_DEEPBOOK_POOL_KEY !== undefined,
-        SMOKE_QUOTE_AMOUNT: process.env.SMOKE_QUOTE_AMOUNT !== undefined,
-        SMOKE_INSPECT_DIGEST: process.env.SMOKE_INSPECT_DIGEST !== undefined,
-        SMOKE_INSPECT_RANDOM_LATEST: process.env.SMOKE_INSPECT_RANDOM_LATEST !== undefined,
-        SMOKE_FUNCTION_TARGET: process.env.SMOKE_FUNCTION_TARGET !== undefined,
-        SMOKE_SWAP_PROTOCOL: process.env.SMOKE_SWAP_PROTOCOL !== undefined,
-        SMOKE_SWAP_FROM_SYMBOL: process.env.SMOKE_SWAP_FROM_SYMBOL !== undefined,
-        SMOKE_SWAP_TO_SYMBOL: process.env.SMOKE_SWAP_TO_SYMBOL !== undefined,
-        SMOKE_SWAP_AMOUNT_DISPLAY: process.env.SMOKE_SWAP_AMOUNT_DISPLAY !== undefined
+        SUI_MCP_GRPC_URL: process.env.SUI_MCP_GRPC_URL !== undefined,
+        SUI_MCP_GRAPHQL_URL: process.env.SUI_MCP_GRAPHQL_URL !== undefined,
+        SUI_MCP_SMOKE_ADDRESS: process.env.SUI_MCP_SMOKE_ADDRESS !== undefined,
+        SUI_MCP_SMOKE_DEEPBOOK_POOL_KEY: process.env.SUI_MCP_SMOKE_DEEPBOOK_POOL_KEY !== undefined,
+        SUI_MCP_SMOKE_QUOTE_AMOUNT: process.env.SUI_MCP_SMOKE_QUOTE_AMOUNT !== undefined,
+        SUI_MCP_SMOKE_INSPECT_DIGEST: process.env.SUI_MCP_SMOKE_INSPECT_DIGEST !== undefined,
+        SUI_MCP_SMOKE_INSPECT_RANDOM_LATEST: process.env.SUI_MCP_SMOKE_INSPECT_RANDOM_LATEST !== undefined,
+        SUI_MCP_SMOKE_FUNCTION_TARGET: process.env.SUI_MCP_SMOKE_FUNCTION_TARGET !== undefined,
+        SUI_MCP_SMOKE_SWAP_PROTOCOL: process.env.SUI_MCP_SMOKE_SWAP_PROTOCOL !== undefined,
+        SUI_MCP_SMOKE_SWAP_FROM_SYMBOL: process.env.SUI_MCP_SMOKE_SWAP_FROM_SYMBOL !== undefined,
+        SUI_MCP_SMOKE_SWAP_TO_SYMBOL: process.env.SUI_MCP_SMOKE_SWAP_TO_SYMBOL !== undefined,
+        SUI_MCP_SMOKE_SWAP_AMOUNT_DISPLAY: process.env.SUI_MCP_SMOKE_SWAP_AMOUNT_DISPLAY !== undefined
     };
 }
 function tryWriteSmokeResult(record) {

package/dist/runtime/smokeReview.js

@@ -2,27 +2,27 @@ import { INTENT_PLAN_FACTORIES, resolveIntentPlanFactory, swapIntentInputSchema
 import { computeReviewStateWithPrivateArtifacts } from "../core/review/reviewComputation.js";
 export class SmokeReviewConfigError extends Error {
 }
-const requiredSwapInputs = ["SMOKE_SWAP_PROTOCOL", "SMOKE_SWAP_FROM_SYMBOL", "SMOKE_SWAP_TO_SYMBOL", "SMOKE_SWAP_AMOUNT_DISPLAY"];
+const requiredSwapInputs = ["SUI_MCP_SMOKE_SWAP_PROTOCOL", "SUI_MCP_SMOKE_SWAP_FROM_SYMBOL", "SUI_MCP_SMOKE_SWAP_TO_SYMBOL", "SUI_MCP_SMOKE_SWAP_AMOUNT_DISPLAY"];
 export async function computeSmokeReview(options) {
     const { env, sessions, computation, account } = options;
-    const rawSlippage = env.SMOKE_SWAP_MAX_SLIPPAGE_BPS;
+    const rawSlippage = env.SUI_MCP_SMOKE_SWAP_MAX_SLIPPAGE_BPS;
     if (rawSlippage !== undefined && (!Number.isInteger(Number(rawSlippage)) || Number(rawSlippage) < 1)) {
-        throw new SmokeReviewConfigError("SMOKE_SWAP_MAX_SLIPPAGE_BPS must be a positive integer.");
+        throw new SmokeReviewConfigError("SUI_MCP_SMOKE_SWAP_MAX_SLIPPAGE_BPS must be a positive integer.");
     }
     const missing = requiredSwapInputs.filter((name) => env[name] === undefined);
     if (missing.length === requiredSwapInputs.length)
         return { status: "not_run", notRunReason: "missing_env", requiredEnv: [...requiredSwapInputs] };
     if (missing.length)
         throw new SmokeReviewConfigError(`Partial account-bound swap smoke configuration; missing: ${missing.join(", ")}`);
-    const parsed = swapIntentInputSchema.safeParse({ type: "swap", protocol: env.SMOKE_SWAP_PROTOCOL,
-        from: { symbol: env.SMOKE_SWAP_FROM_SYMBOL, amount: env.SMOKE_SWAP_AMOUNT_DISPLAY },
-        to: { symbol: env.SMOKE_SWAP_TO_SYMBOL }, maxSlippageBps: Number(env.SMOKE_SWAP_MAX_SLIPPAGE_BPS ?? "50") });
+    const parsed = swapIntentInputSchema.safeParse({ type: "swap", protocol: env.SUI_MCP_SMOKE_SWAP_PROTOCOL,
+        from: { symbol: env.SUI_MCP_SMOKE_SWAP_FROM_SYMBOL, amount: env.SUI_MCP_SMOKE_SWAP_AMOUNT_DISPLAY },
+        to: { symbol: env.SUI_MCP_SMOKE_SWAP_TO_SYMBOL }, maxSlippageBps: Number(env.SUI_MCP_SMOKE_SWAP_MAX_SLIPPAGE_BPS ?? "50") });
     if (!parsed.success)
         throw new SmokeReviewConfigError("The optional swap smoke inputs are invalid.");
     const { protocol, ...intent } = parsed.data;
     const resolution = resolveIntentPlanFactory(INTENT_PLAN_FACTORIES, "swap", protocol);
     if (resolution.status !== "resolved")
-        throw new SmokeReviewConfigError("SMOKE_SWAP_PROTOCOL must select a supported swap adapter.");
+        throw new SmokeReviewConfigError("SUI_MCP_SMOKE_SWAP_PROTOCOL must select a supported swap adapter.");
     const now = options.now ?? new Date(), plan = resolution.factory.createPlan(intent, now);
     const created = await sessions.createReviewSession([plan], now);
     await sessions.recordWalletConnected(created.session.id, account, now);

package/dist/runtime/start.js

@@ -40,7 +40,7 @@ async function main() {
         const controlReady = loadControlIdentity(bootConfig.activityDatabasePath, {
             network: bootConfig.network, chainIdentifier: bootConfig.expectedChainIdentifier,
             walletConnectProjectId: WALLETCONNECT_PROJECT_ID,
-            grpcOverride: process.env.SUI_GRPC_URL ?? null, graphqlOverride: process.env.SUI_GRAPHQL_URL ?? null
+            grpcOverride: process.env.SUI_MCP_GRPC_URL ?? null, graphqlOverride: process.env.SUI_MCP_GRAPHQL_URL ?? null
         });
         void controlReady.catch(() => { });
         stage = "stdio_start";

package/dist/runtime/walletConnectTransport.js

@@ -1,7 +1,7 @@
 import { SignClient } from "@walletconnect/sign-client";
 import { getSdkError } from "@walletconnect/utils";
 import { z } from "zod";
-import { parseSuiAddress } from "../core/suiAddress.js";
+import { normalizeWalletGrants, walletChainsSchema, walletGrantAccount, WALLET_CHAINS } from "../core/session/chainAccounts.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();
@@ -12,16 +12,11 @@ function transportError(error) {
         ? 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.");
+    if (!Number.isSafeInteger(session.expiry) || session.expiry * 1000 <= Date.now()) {
+        throw new Error("A live 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 };
+    return { topic: session.topic, grants: normalizeWalletGrants(session.namespaces),
+        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))
@@ -37,8 +32,9 @@ export async function createWalletConnectTransport(options) {
             listener(event.topic); };
     const selectionChanged = (event) => {
         if (!stopped && ["accountsChanged", "chainChanged"].includes(event.params.event.name)) {
+            const chain = WALLET_CHAINS.find((id) => id === event.params.chainId);
             for (const listener of listeners)
-                listener(event.topic, true);
+                listener(event.topic, chain ? [chain] : WALLET_CHAINS);
         }
     };
     client.on("session_update", changed);
@@ -76,11 +72,15 @@ export async function createWalletConnectTransport(options) {
             }
             return client.session.getAll().flatMap((session) => { const value = current(session.topic); return value ? [value] : []; });
         },
-        async connect() {
+        async connect(chains) {
             requireActive();
-            const connecting = await client.connect({ requiredNamespaces: { sui: {
-                        chains: [SUI_MAINNET_WALLET_CHAIN], methods: [SUI_SIGN_TRANSACTION_METHOD], events: ["accountsChanged", "chainChanged"]
-                    } } });
+            const scope = walletChainsSchema.parse(chains);
+            if (!scope.length)
+                throw new Error("Choose wallet networks in Settings before connecting.");
+            const optionalNamespaces = Object.fromEntries(scope.map((chain) => [chain.split(":")[0], { chains: [chain],
+                    methods: chain === SUI_MAINNET_WALLET_CHAIN ? [SUI_SIGN_TRANSACTION_METHOD] : [],
+                    events: chain === SUI_MAINNET_WALLET_CHAIN ? ["accountsChanged", "chainChanged"] : [] }]));
+            const connecting = await client.connect({ requiredNamespaces: {}, optionalNamespaces });
             const approval = connecting.approval().then(sessionValue).catch((error) => { throw transportError(error); });
             void approval.catch(() => undefined);
             if (!connecting.uri)
@@ -95,7 +95,7 @@ export async function createWalletConnectTransport(options) {
         async sign(input) {
             requireActive();
             const session = current(input.topic);
-            if (!session?.accounts.includes(input.account) || !session.methods.includes(SUI_SIGN_TRANSACTION_METHOD)) {
+            if (!session || !walletGrantAccount(session.grants, SUI_MAINNET_WALLET_CHAIN, input.account)?.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,

package/dist/runtime/walletSdkChildRuntime.js

@@ -4,6 +4,7 @@ import { isDeepStrictEqual } from "node:util";
 import { WalletUserRejectedError } from "../core/session/walletConnection.js";
 import { acquireDataDirectoryOwner } from "./shared/ownerLease.js";
 import { walletCommandSchema, walletEventSchema } from "./walletSdkIpc.js";
+import { WALLET_CHAINS, comparableGrantScope, initialGrantRevisions, walletGrantAccount } from "../core/session/chainAccounts.js";
 export function runWalletSdkChild(createTransport) {
     let init, transport;
     let sequence = 0, lastRequest = 0, ready = false, exiting = false;
@@ -42,15 +43,23 @@ export function runWalletSdkChild(createTransport) {
         exit();
         return;
     }
-    const inspect = (value, changedTopic) => {
+    const inspect = (value, change) => {
         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 };
+        const lifecycleChanged = !prior || prior.status !== value.status;
+        const lifecycleRevision = (prior?.lifecycleRevision ?? 0) + Number(lifecycleChanged);
+        const grantRevisions = { ...(prior?.grantRevisions ?? initialGrantRevisions()) };
+        for (const chain of WALLET_CHAINS) {
+            const before = prior?.status === "present" ? prior.session.grants.find((grant) => grant.chainId === chain) : undefined;
+            const after = value.status === "present" ? value.session.grants.find((grant) => grant.chainId === chain) : undefined;
+            if (lifecycleChanged || !isDeepStrictEqual(comparableGrantScope(before), comparableGrantScope(after)) ||
+                change?.topic === value.topic && change.chains.includes(chain))
+                grantRevisions[chain]++;
+        }
+        const next = { ...value, lifecycleRevision, grantRevisions };
         sessions.set(value.topic, next);
         return next;
     };
-    const snapshot = (isReady, changedTopic, checkTopic) => {
+    const snapshot = (isReady, change, checkTopic) => {
         try {
             if (!ownership || !transport)
                 throw new Error("Wallet storage ownership is unavailable.");
@@ -61,7 +70,7 @@ export function runWalletSdkChild(createTransport) {
             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)) };
+                sessions: values.map((item) => inspect(item, change)) };
             send({ ...envelope(), type: "snapshot", snapshot: value, ready: isReady });
             return value;
         }
@@ -78,9 +87,9 @@ export function runWalletSdkChild(createTransport) {
         stage = "restoration_failed";
         send({ ...envelope(), type: "stage", stage: "session_restore" });
         await transport.restore();
-        transport.onSessionChanged((topic, selectionChanged) => {
+        transport.onSessionChanged((topic, chains) => {
             try {
-                snapshot(false, selectionChanged ? topic : undefined);
+                snapshot(false, chains ? { topic, chains } : undefined);
             }
             catch {
                 fail("wallet_state_unavailable");
@@ -97,7 +106,7 @@ export function runWalletSdkChild(createTransport) {
                 throw new Error("Wallet service is not ready.");
             switch (input.type) {
                 case "connect": {
-                    const pairing = await transport.connect();
+                    const pairing = await transport.connect(input.chains);
                     send({ ...reply, type: "pairing", uri: pairing.uri, expiresAt: pairing.expiresAt });
                     const session = await pairing.approval;
                     snapshot(false);
@@ -117,14 +126,22 @@ export function runWalletSdkChild(createTransport) {
                 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")) {
+                    if (current.status !== "present" || current.lifecycleRevision !== input.lifecycleRevision ||
+                        current.grantRevisions[input.chainId] !== input.grantRevision ||
+                        !walletGrantAccount(current.session.grants, input.chainId, input.account)?.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 });
+                    const after = sessions.get(input.topic);
+                    if (after.status !== "present" || after.lifecycleRevision !== input.lifecycleRevision ||
+                        after.grantRevisions[input.chainId] !== input.grantRevision) {
+                        send({ ...reply, type: "error", code: "session_changed" });
+                        return;
+                    }
+                    send({ ...reply, type: "signed", ...result, chainId: input.chainId,
+                        lifecycleRevision: after.lifecycleRevision, grantRevision: after.grantRevisions[input.chainId] });
                     return;
                 }
             }

package/dist/runtime/walletSdkIpc.js

@@ -1,17 +1,18 @@
 import { SERVER_VERSION } from "../mcp/serverInfo.js";
 import { z } from "zod";
 import { suiAddressStringSchema } from "../core/suiAddress.js";
-import { walletRunIdSchema, walletStartStageSchema, walletSnapshotSchema, walletSessionObservationSchema, walletSessionSchema } from "../core/session/walletRuntime.js";
+import { walletRunIdSchema, walletStartStageSchema, walletSnapshotSchema, walletSessionObservationSchema, walletSessionSchema, suiWalletRevisionSchema } from "../core/session/walletRuntime.js";
+import { walletChainsSchema } from "../core/session/chainAccounts.js";
 import { walletUnavailableReasonSchema } from "../core/session/walletConnection.js";
 const envelope = z.object({ packageVersion: z.literal(SERVER_VERSION), 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.literal("connect"), chains: walletChainsSchema }).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()
+        transactionBytesBase64: z.string().min(1), ...suiWalletRevisionSchema.shape }).strict()
 ]);
 const reply = envelope.extend({ requestId: z.number().int().positive(), operationId: z.string().min(1) });
 export const walletEventSchema = z.union([
@@ -22,6 +23,6 @@ export const walletEventSchema = z.union([
     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("signed"), transactionBytes: z.string().min(1), signature: z.string().min(1), ...suiWalletRevisionSchema.shape }).strict(),
     reply.extend({ type: z.literal("error"), code: z.enum(["rejected", "session_changed", "operation_failed"]) }).strict()
 ]);

package/dist/runtime/walletSdkProcess.js

@@ -4,6 +4,7 @@ import { randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { walletUnavailable, WalletUnavailableError, WalletUserRejectedError } from "../core/session/walletConnection.js";
 import { WalletRunInterruptedError, WalletReplacementFailedError } from "../core/session/walletRuntime.js";
+import { WALLET_CHAINS, comparableGrantScope } from "../core/session/chainAccounts.js";
 import { walletCommandSchema, walletEventSchema } from "./walletSdkIpc.js";
 export class WalletSdkProcess {
     options;
@@ -137,11 +138,19 @@ export class WalletSdkProcess {
                 }
                 topics.add(session.topic);
                 const prior = run.snapshot?.sessions.find((entry) => entry.topic === session.topic);
-                if (prior && (session.version < prior.version || session.version === prior.version && !isDeepStrictEqual(session, prior))) {
+                if (prior && (session.lifecycleRevision < prior.lifecycleRevision ||
+                    session.lifecycleRevision === prior.lifecycleRevision && session.status !== prior.status || WALLET_CHAINS.some((chain) => session.grantRevisions[chain] < prior.grantRevisions[chain] ||
+                    session.lifecycleRevision !== prior.lifecycleRevision && session.grantRevisions[chain] === prior.grantRevisions[chain] ||
+                    session.grantRevisions[chain] === prior.grantRevisions[chain] &&
+                        !isDeepStrictEqual(comparableGrantScope(session.status === "present" ? session.session.grants.find((grant) => grant.chainId === chain) : undefined), comparableGrantScope(prior.status === "present" ? prior.session.grants.find((grant) => grant.chainId === chain) : undefined))))) {
                     this.lose(run, "wallet_state_unavailable");
                     return;
                 }
             }
+            if (run.snapshot?.sessions.some((session) => !topics.has(session.topic))) {
+                this.lose(run, "wallet_state_unavailable");
+                return;
+            }
             const previous = run.snapshot;
             run.snapshot = event.snapshot;
             if (event.ready) {
@@ -304,7 +313,7 @@ export class WalletSdkProcess {
             if (run !== this.run || run.fenced || this.closed)
                 throw new WalletRunInterruptedError(run.id);
             if (this.state.status !== "available")
-                throw new WalletUnavailableError("wallet_state_unavailable", this.state.message);
+                throw new WalletUnavailableError(this.state);
         };
         assertCurrent();
         const call = (input, operationId, approval) => {
@@ -322,32 +331,39 @@ export class WalletSdkProcess {
             });
         };
         return { runId: run.id, assertCurrent,
-            connect: async (operationId) => {
+            connect: async (chains, operationId) => {
                 let approve, rejectApproval;
                 const approval = new Promise((resolve, reject) => { approve = resolve; rejectApproval = reject; });
                 void approval.catch(() => { });
-                const reply = await call({ type: "connect" }, operationId, { approve, rejectApproval });
+                const reply = await call({ type: "connect", chains: [...chains] }, operationId, { approve, rejectApproval });
                 assertCurrent();
                 if (reply.type !== "pairing")
                     throw new Error("Wallet pairing response is unavailable.");
                 return { uri: reply.uri, expiresAt: reply.expiresAt, approval };
             },
             disconnect: async (topic, operationId) => { await call({ type: "disconnect", topic }, operationId); assertCurrent(); },
-            checkSession: async (topic, operationId) => {
+            checkSession: async (topic, operationId, chainId) => {
                 const reply = await call({ type: "check_session", topic }, operationId);
                 assertCurrent();
+                const current = run.snapshot?.sessions.find((item) => item.topic === topic);
                 if (reply.type !== "checked" || reply.observation.topic !== topic || !run.snapshot || run.snapshot.sequence < reply.sequence ||
-                    run.snapshot.sessions.find((item) => item.topic === topic)?.version !== reply.observation.version) {
+                    !current || current.lifecycleRevision !== reply.observation.lifecycleRevision ||
+                    (chainId ? current.grantRevisions[chainId] !== reply.observation.grantRevisions[chainId]
+                        : !isDeepStrictEqual(current.grantRevisions, reply.observation.grantRevisions))) {
                     throw new Error("The wallet session changed during confirmation.");
                 }
-                return reply.observation;
+                return current;
             },
             sign: async (input, operationId) => {
                 const reply = await call({ ...input, type: "sign" }, operationId);
                 assertCurrent();
                 if (reply.type !== "signed")
                     throw new Error("The wallet signature response is unavailable.");
-                return { transactionBytes: reply.transactionBytes, signature: reply.signature, sessionVersion: reply.sessionVersion };
+                if (reply.chainId !== input.chainId || reply.lifecycleRevision !== input.lifecycleRevision || reply.grantRevision !== input.grantRevision) {
+                    throw new Error("The signed response belongs to a changed wallet grant.");
+                }
+                return { transactionBytes: reply.transactionBytes, signature: reply.signature, chainId: reply.chainId,
+                    lifecycleRevision: reply.lifecycleRevision, grantRevision: reply.grantRevision };
             } };
     }
 }