@zktx.io/sui-mcp 0.7.0 → 0.8.0

package/dist/core/session/status.js

@@ -44,10 +44,10 @@ export function executionPollingHint() {
         recommendedIntervalSeconds: EXECUTION_POLLING_INTERVAL_SECONDS
     };
 }
-export function reviewStatusResponse({ session, request, walletAvailability, walletObservation, progress, connectionConflict, connectionReconciliationRequired }) {
+export function reviewStatusResponse({ session, request, walletAvailability, walletObservation, progress, connectionReconciliationRequired }) {
     const pollingStatus = getExecutionPollingStatus(session, request);
     return {
-        walletAvailability, walletObservation, progress, connectionConflict, connectionReconciliationRequired,
+        walletAvailability, walletObservation, progress, connectionReconciliationRequired,
         reviewSessionId: session.id, status: session.status, reviewRevision: session.reviewRevision,
         account: session.account, plans: session.plans, reviewState: session.reviewState,
         pollingStatus, statusCategory: executionStatusCategory(pollingStatus), pollingHint: executionPollingHint(),

package/dist/core/session/wait.js

@@ -1,6 +1,5 @@
 import { EXECUTION_POLLING_INTERVAL_SECONDS, getExecutionPollingStatus, executionStatusCategory, isWaitStoppingExecutionStatus } from "./status.js";
 import { SessionStoreError } from "./sessionStore.js";
-import { workflowViewSchema } from "./workflowView.js";
 import { WALLET_CONNECTION_POLL_SECONDS } from "./walletConnection.js";
 export const DEFAULT_WAIT_TIMEOUT_MS = 45_000;
 export const MAX_WAIT_TIMEOUT_MS = 55_000;
@@ -15,20 +14,16 @@ export class WaitRequestAbortedError extends Error {
 export async function waitForWalletConnection(cards, cardId, options = {}) {
     const timeout = options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
     const started = Date.now(), sleep = options.sleep ?? sleepMs;
-    let snapshot;
     while (true) {
         assertNotAborted(options.signal);
-        snapshot = await cards.readSaved(cardId);
-        const view = workflowViewSchema.parse(snapshot.data);
-        if (snapshot.kind !== "connect")
-            throw new SessionStoreError("input_invalid", "A connection card ID is required.");
-        if (view.progress.status === "unavailable")
-            return { waitOutcome: "unavailable", snapshot };
-        if (!view.observe)
-            return { waitOutcome: "status_reached", snapshot };
+        const state = await cards.readWalletOperation(cardId), operation = state.operation;
+        if (!operation || operation.status !== "running" && !operation.settlementPending)
+            return { ...state, waitOutcome: "status_reached" };
+        if (state.walletAvailability.status !== "available")
+            return { ...state, waitOutcome: "unavailable" };
         const remaining = timeout - (Date.now() - started);
         if (remaining <= 0)
-            return { waitOutcome: "timed_out", snapshot };
+            return { ...state, waitOutcome: "timed_out" };
         await sleep(Math.min(remaining, WALLET_CONNECTION_POLL_SECONDS * 1000), options.signal);
     }
 }

package/dist/core/session/walletConnection.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { suiAddressStringSchema } from "../suiAddress.js";
+import { walletChainResultsSchema, fixedChainAccount, walletChainSchema, walletChainsSchema, walletGrantsSchema, walletGrantAccount, walletGrantRevisionsSchema, SUI_MAINNET_WALLET_CHAIN } from "./chainAccounts.js";
 import { transactionRequestStatusSchema } from "./transactionRequest.js";
-export const SUI_MAINNET_WALLET_CHAIN = "sui:mainnet";
+export { SUI_MAINNET_WALLET_CHAIN } from "./chainAccounts.js";
 export const SUI_SIGN_TRANSACTION_METHOD = "sui_signTransaction";
 export const WALLET_CONNECTION_POLL_SECONDS = 5;
 export const walletRunIdSchema = z.string().uuid();
@@ -24,10 +24,10 @@ export function walletUnavailable(reason, walletRunId) {
     return { status: "unavailable", reason, message, ...(walletRunId === undefined ? {} : { walletRunId }) };
 }
 export class WalletUnavailableError extends Error {
-    reason;
-    constructor(reason, message = walletUnavailable(reason).message) {
-        super(message);
-        this.reason = reason;
+    availability;
+    constructor(availability) {
+        super(availability.message);
+        this.availability = availability;
     }
 }
 export const workflowProgressSchema = z.discriminatedUnion("status", [
@@ -49,7 +49,7 @@ export const walletConnectionStatusSchema = z.enum([
 export const walletRecoveryImpactSchema = z.object({
     runId: z.string().uuid(),
     connections: z.array(z.object({ connectionId: z.string().min(1), revision: z.number().int().nonnegative(),
-        status: walletConnectionStatusSchema, accounts: z.array(suiAddressStringSchema), walletName: z.string().optional(),
+        status: walletConnectionStatusSchema, chainResults: walletChainResultsSchema, walletName: z.string().optional(),
         sdkPending: z.boolean(), disconnectPending: z.boolean() }).strict()),
     preparations: z.array(z.object({ id: z.string().min(1), revision: z.number().int().nonnegative(),
         review_revision: z.number().int().nonnegative(), preparation_id: z.string().nullable(), wallet_connection_id: z.string().nullable() }).strict()),
@@ -58,47 +58,72 @@ export const walletRecoveryImpactSchema = z.object({
         sdk_pending: z.number().int().min(0).max(1), submit_pending: z.number().int().min(0).max(1), lookup_pending: z.number().int().min(0).max(1) }).strict())
 }).strict();
 export const walletConnectionSchema = z.object({
-    connectionId: z.string().min(1),
-    status: walletConnectionStatusSchema,
-    revision: z.number().int().nonnegative(),
-    accounts: z.array(suiAddressStringSchema),
-    methods: z.array(z.string()),
-    chain: z.literal(SUI_MAINNET_WALLET_CHAIN),
-    createdAt: z.string().datetime(),
-    updatedAt: z.string().datetime(),
-    expiresAt: z.string().datetime(),
-    walletName: z.string().optional(),
-    reason: z.string().optional()
-}).strict();
-export const connectionConflictSchema = z.object({
-    reason: z.literal("multiple_connections"),
-    connectionIds: z.array(z.string().min(1)).min(2).refine((ids) => new Set(ids).size === ids.length)
-}).strict();
-export const CONNECTION_CONFLICT_MESSAGE = "More than one wallet connection is saved. Disconnect the connections you no longer need before continuing.";
-export const CONNECTION_RECONCILIATION_MESSAGE = "A wallet connection in the connection service is not recorded here. Remove the retained connection in your wallet app, then check its status. If needed, open Settings and use Troubleshooting to restart the connection service and inspect it again. Restarting does not approve an unrecorded connection.";
+    connectionId: z.string().min(1), status: walletConnectionStatusSchema,
+    revision: z.number().int().nonnegative(), requestedChains: walletChainsSchema,
+    chainResults: walletChainResultsSchema, approvedAt: z.string().datetime().optional(),
+    grants: walletGrantsSchema, grantRevisions: walletGrantRevisionsSchema,
+    lifecycleRevision: z.number().int().nonnegative(),
+    createdAt: z.string().datetime(), updatedAt: z.string().datetime(), expiresAt: z.string().datetime(),
+    walletName: z.string().optional(), reason: z.string().optional()
+}).strict().superRefine((connection, context) => {
+    if (connection.chainResults.some((item) => !connection.requestedChains.includes(item.chainId)) ||
+        connection.approvedAt && connection.chainResults.length !== connection.requestedChains.length ||
+        !connection.approvedAt && connection.chainResults.length) {
+        context.addIssue({ code: "custom", message: "Approval results must match the exact requested networks." });
+    }
+});
+export const connectionChainStateSchema = z.object({ chainId: walletChainSchema,
+    status: z.enum(["available", "multiple_accounts", "not_approved", "invalid_response", "unavailable"]), address: z.string().optional(),
+    suiSigningScopeApproved: z.boolean(), reason: z.string().optional() }).strict();
+export const CONNECTION_RECONCILIATION_MESSAGE = "An unexpected wallet session is retained by the connection service. Remove it in your wallet app, then check status. Only one wallet connection can be used here.";
 export const assetReadAccountSchema = z.discriminatedUnion("status", [
-    z.object({ status: z.literal("available"), account: suiAddressStringSchema }).strict(),
-    z.object({ status: z.literal("address_required") }).strict()
+    z.object({ status: z.literal("available"), account: z.string() }).strict(),
+    z.object({ status: z.literal("address_required"), reason: z.literal("read_address_cleared").optional() }).strict()
 ]);
-export function walletConnectionSelection(connections, at, presence, stored) {
-    const connected = connections.filter((item) => item.status === "connected" && Date.parse(item.expiresAt) > at);
-    const pending = presence.pendingConnectionIds.length > 0 || connections.some((item) => item.pendingAction || item.status === "awaiting_approval");
-    const presentIds = presence.connections.map((item) => item.connectionId);
-    const occupied = new Set([...connected.map((item) => item.connectionId), ...presentIds]);
-    const reconciliation = presence.confirmed && presence.unrecorded && !pending;
-    const connection = presence.confirmed && !presence.unrecorded && occupied.size === 1 && connected.length === 1 &&
-        presence.connections.some((item) => item.connectionId === connected[0].connectionId && Date.parse(item.expiresAt) > at) && !pending ? connected[0] : undefined;
-    return {
-        ...(occupied.size > 1 ? { conflict: { reason: "multiple_connections",
-                connectionIds: [...occupied].sort() } } : {}),
-        ...(reconciliation ? { connectionReconciliationRequired: true } : {}),
-        manageableConnectionIds: connections.filter((item) => !presence.pendingConnectionIds.includes(item.connectionId) && !item.pendingAction && item.status !== "awaiting_approval" &&
-            (item.status === "connected" || presence.confirmed && presentIds.includes(item.connectionId))).map((item) => item.connectionId),
-        ...(connection ? { connection } : {}),
-        pairingAllowed: presence.confirmed && !presence.unrecorded && occupied.size === 0 && !pending,
-        assetReadAccount: connection && stored?.walletId === connection.connectionId && connection.accounts.includes(stored.address)
-            ? { status: "available", account: stored.address } : { status: "address_required" }
-    };
+function connectionSessionPresence(connection, presence) {
+    if (!presence.confirmed || !presence.managed)
+        return "unconfirmed";
+    if (presence.hasRecordedSession)
+        return presence.observation?.status ?? "unconfirmed";
+    return !connection?.approvedAt && !presence.pending && !presence.unrecorded ? "absent" : "unconfirmed";
+}
+export function usableWalletConnection(connection, at, presence, connectionId, chainId, address) {
+    if (!connection || connection.connectionId !== connectionId || !presence.hasRecordedSession || !presence.confirmed || !presence.managed ||
+        !presence.dataCurrent || presence.pending || presence.observation?.status !== "present")
+        return undefined;
+    const fixed = fixedChainAccount(connection, chainId);
+    return fixed && (address === undefined || address === fixed) && connection.status === "connected" &&
+        Date.parse(connection.expiresAt) > at && Date.parse(presence.observation.expiresAt) > at &&
+        walletGrantAccount(connection.grants, chainId, fixed) ? connection : undefined;
+}
+export function walletConnectionEligibility(connection, at, presence, readAccount, readAddressCleared = false) {
+    const usable = connection && usableWalletConnection(connection, at, presence, connection.connectionId, SUI_MAINNET_WALLET_CHAIN);
+    const sessionPresence = connectionSessionPresence(connection, presence);
+    const manageable = !!(connection && !presence.pending && ["present", "unusable"].includes(sessionPresence));
+    return { ...(presence.confirmed && presence.unrecorded ? { connectionReconciliationRequired: true } : {}),
+        ...(usable ? { connection: usable } : {}), manageable,
+        pairingAllowed: presence.confirmed && presence.managed && !presence.unrecorded && !presence.pending && sessionPresence === "absent",
+        assetReadAccount: usable && readAccount && readAccount === fixedChainAccount(usable, SUI_MAINNET_WALLET_CHAIN) && !readAddressCleared ? { status: "available", account: readAccount }
+            : { status: "address_required", ...(readAddressCleared ? { reason: "read_address_cleared" } : {}) } };
+}
+export function connectionHasSuiSigningScope(connection, account) {
+    const grant = walletGrantAccount(connection.grants, SUI_MAINNET_WALLET_CHAIN, account);
+    return fixedChainAccount(connection, SUI_MAINNET_WALLET_CHAIN) === account &&
+        !!grant?.methods.includes(SUI_SIGN_TRANSACTION_METHOD) && ["accountsChanged", "chainChanged"].every((event) => grant.events.includes(event));
+}
+export function projectWalletConnection(connection, at, presence, available) {
+    const sessionPresence = available ? connectionSessionPresence(connection, presence) : "unconfirmed";
+    return connection && { ...connection, sessionPresence, chainStates: connection.chainResults.map((result) => {
+            const address = result.status === "bound" ? result.address : undefined;
+            const usable = !!(available && address && usableWalletConnection(connection, at, presence, connection.connectionId, result.chainId, address));
+            return { chainId: result.chainId, status: result.status === "bound" ? usable ? "available" : "unavailable" : result.status,
+                ...(address ? { address } : {}), suiSigningScopeApproved: result.chainId === SUI_MAINNET_WALLET_CHAIN && !!address && connectionHasSuiSigningScope(connection, address),
+                ...(!usable ? { reason: sessionPresence === "absent" ? "The wallet session is no longer present. Connect again to use this network."
+                        : result.status === "multiple_accounts" ? "The wallet returned several addresses. Disconnect and connect again with one account for this network."
+                            : result.status === "not_approved" ? "The wallet did not approve this network."
+                                : result.status === "invalid_response" ? "The wallet returned invalid account information."
+                                    : "This fixed address is not currently usable through this connection." } : {}) };
+        }) };
 }
 export class WalletUserRejectedError extends Error {
     constructor() { super("The wallet request was rejected by the user."); }

package/dist/core/session/walletConnectionOperations.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { walletChainsSchema } from "./chainAccounts.js";
+import { walletRunIdSchema } from "./walletConnection.js";
+const operationId = z.string().uuid();
+const command = { operationId, walletRunId: walletRunIdSchema };
+export const walletConnectionActionSchema = z.discriminatedUnion("action", [
+    z.object({ action: z.literal("connect"), ...command, chains: walletChainsSchema }).strict(),
+    z.object({ action: z.literal("disconnect"), ...command, connectionId: z.string().min(1), impactId: z.string().min(1) }).strict()
+]);
+export const walletConnectionCardInputSchema = z.object({}).strict();
+export const walletConnectionOperationSchema = z.object({
+    operationId, cardId: z.string().min(1), action: z.enum(["connect", "disconnect"]),
+    status: z.enum(["running", "completed", "failed", "stopped"]), connectionId: z.string().min(1),
+    createdAt: z.string().datetime(), updatedAt: z.string().datetime(), expiresAt: z.string().datetime(),
+    settlementPending: z.boolean(), message: z.string().optional(),
+    endReason: z.enum(["user_stopped", "expired", "run_ended"]).optional()
+}).strict();
+export const pendingWalletConnectionOperationSchema = walletConnectionOperationSchema.pick({
+    operationId: true, action: true, status: true, settlementPending: true
+});
+export function publicConnectionOperation(record) {
+    const { ownerId: _owner, runId: _run, dataEpoch: _epoch, input: _input, ...result } = record;
+    return result;
+}

package/dist/core/session/walletRuntime.js

@@ -1,27 +1,21 @@
 import { z } from "zod";
-import { suiAddressStringSchema } from "../suiAddress.js";
 import { SUI_MAINNET_WALLET_CHAIN, walletRunIdSchema } from "./walletConnection.js";
+import { walletGrantsSchema, walletGrantRevisionsSchema } from "./chainAccounts.js";
 export { walletRunIdSchema, walletStartStageSchema } from "./walletConnection.js";
 export const walletSessionSchema = z.object({
-    topic: z.string().min(1), accounts: z.array(suiAddressStringSchema).min(1), methods: z.array(z.string()),
-    chain: z.literal(SUI_MAINNET_WALLET_CHAIN), expiresAt: z.string().datetime(), walletName: z.string().optional()
+    topic: z.string().min(1), grants: walletGrantsSchema, expiresAt: z.string().datetime(), walletName: z.string().optional()
 }).strict();
+const observationIdentity = { topic: z.string().min(1), lifecycleRevision: z.number().int().positive(), grantRevisions: walletGrantRevisionsSchema };
 export const walletSessionObservationSchema = z.discriminatedUnion("status", [
-    z.object({ topic: z.string().min(1), version: z.number().int().positive(), status: z.literal("present"), session: walletSessionSchema }).strict(),
-    z.object({ topic: z.string().min(1), version: z.number().int().positive(), status: z.enum(["absent", "unusable"]) }).strict()
+    z.object({ ...observationIdentity, status: z.literal("present"), session: walletSessionSchema }).strict(),
+    z.object({ ...observationIdentity, status: z.enum(["absent", "unusable"]) }).strict()
 ]);
+export const suiWalletRevisionSchema = z.object({ chainId: z.literal(SUI_MAINNET_WALLET_CHAIN),
+    lifecycleRevision: z.number().int().positive(), grantRevision: z.number().int().nonnegative() });
 export const walletObservationSchema = z.object({
     runId: walletRunIdSchema, sequence: z.number().int().positive(), observedAt: z.string().datetime()
 }).strict();
 export const walletSnapshotSchema = walletObservationSchema.extend({ sessions: z.array(walletSessionObservationSchema) }).strict();
-const recoveryBase = z.object({ kind: z.literal("wallet_service_recovery"), priorRunId: walletRunIdSchema,
-    admittedAt: z.string().datetime(), updatedAt: z.string().datetime() });
-export const walletRecoverySchema = z.union([
-    recoveryBase.extend({ phase: z.literal("stopping") }).strict(),
-    recoveryBase.extend({ phase: z.literal("starting"), nextRunId: walletRunIdSchema }).strict(),
-    recoveryBase.extend({ outcome: z.enum(["available", "failed", "superseded", "server_restarted"]),
-        nextRunId: walletRunIdSchema.optional(), message: z.string().optional() }).strict()
-]);
 export class WalletRunInterruptedError extends Error {
     runId;
     constructor(runId) {