@zktx.io/sui-mcp 0.7.0 → 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

@@ -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/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;
@@ -33,15 +34,16 @@ 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,
@@ -54,7 +56,8 @@ export class RuntimeLocalSettingsService {
         });
         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/smokeMainnetRead.js

@@ -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,

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 };
             } };
     }
 }