@zktx.io/sui-mcp 0.6.2 → 0.8.0

package/dist/core/activity/sqliteActivityStore.js

@@ -1,5 +1,7 @@
+import { readStoredTransactionRequest } from "../session/sqliteTransactionRequest.js";
+import { publicConnectionOperation } from "../session/walletConnectionOperations.js";
 import { decideReviewEvaluation, needsReviewMaterial } from "../session/reviewValidity.js";
-import { workflowEligibility } from "../session/workflowState.js";
+import { fixedReviewTarget, workflowEligibility } from "../session/workflowState.js";
 import { SessionStoreError } from "../session/sessionErrors.js";
 import { z } from "zod";
 import { TRANSACTION_REQUEST_STATUSES, transactionRequestStatusSchema } from "../session/transactionRequest.js";
@@ -8,11 +10,14 @@ import { chmodSync, existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
 import Database from "better-sqlite3";
-import { SqliteWalletWorkflowStore, readStoredTransactionRequest } from "../session/sqliteWalletWorkflowStore.js";
+import { SqliteWalletWorkflowStore } from "../session/sqliteWalletWorkflowStore.js";
 import { assertNoForbiddenMcpFields } from "../action/forbiddenFields.js";
 import { parseLifecycleValidatedReviewState } from "../action/reviewStateValidation.js";
 import { actionPlanSchema } from "../action/schemas.js";
 import { parseSuiAddress } from "../suiAddress.js";
+import { SqliteAccountStore } from "./sqliteAccountStore.js";
+import { SUI_MAINNET_WALLET_CHAIN, fixedChainAccount } from "../session/chainAccounts.js";
+import { walletConnectionSchema } from "../session/walletConnection.js";
 import { SqlitePreferencesRepository } from "../preferences/sqlitePreferencesRepository.js";
 import { SqliteTransactionMaterialStore } from "../session/sqliteTransactionMaterialStore.js";
 import { SqliteCardRecordStore } from "../session/sqliteCardStore.js";
@@ -25,9 +30,8 @@ import { buildExternalActivityTransactionStreamResult, canonicalExternalActivity
 import { ActivityStoreReadError, EXTERNAL_ACTIVITY_COVERAGE_SCAN_MAX_RECORDS, REVIEW_ACTIVITY_DETAIL_MAX_ITEMS, REVIEW_ACTIVITY_LOW_SAMPLE_THRESHOLD } from "./activityStore.js";
 import { assertCurrentDatabaseFormat, configureDatabase, initializeDatabase } from "./sqliteActivityStoreSchema.js";
 import { ActivityStoreError } from "./sqliteActivityStoreTypes.js";
-import { EXTERNAL_ACTIVITY_RELATIONSHIPS, EXTERNAL_ACTIVITY_STATUSES, INTERNAL_SESSION_STATUSES, REVIEW_STATE_STATUSES, asAccountSource, asInternalSessionStatus, asReviewTransitionEvent, asString, assertDateRange, coinMetadataCacheRecordFromRow, countMap, emptyExternalActivitySummaryStats, emptyReviewFunnelSummary, externalActivityScanFromRow, externalActivitySummaryResult, externalActivityTransactionFromRow, extractRequestedIntent, normalizeExternalActivityLimit, normalizeListLimit, nullableSeconds, parseActionPlanEvidence, parseEvidenceJson, parseIsoTimestamp, parseOptionalIsoTimestamp, reasonForReviewState, reviewActivityListResult, reviewActivityRowFromStorage, reviewFunnelResult, reviewSessionWhere, serializeExternalActivityTransactionDetail, serializeJson, serializeOptionalJson } from "./sqliteActivityStoreRows.js";
+import { EXTERNAL_ACTIVITY_RELATIONSHIPS, EXTERNAL_ACTIVITY_STATUSES, INTERNAL_SESSION_STATUSES, REVIEW_STATE_STATUSES, asInternalSessionStatus, asReviewTransitionEvent, assertDateRange, coinMetadataCacheRecordFromRow, countMap, emptyExternalActivitySummaryStats, emptyReviewFunnelSummary, externalActivityScanFromRow, externalActivitySummaryResult, externalActivityTransactionFromRow, extractRequestedIntent, normalizeExternalActivityLimit, normalizeListLimit, nullableSeconds, parseActionPlanEvidence, parseEvidenceJson, parseIsoTimestamp, parseOptionalIsoTimestamp, reasonForReviewState, reviewActivityListResult, reviewActivityRowFromStorage, reviewFunnelResult, reviewSessionWhere, serializeExternalActivityTransactionDetail, serializeJson, serializeOptionalJson } from "./sqliteActivityStoreRows.js";
 export { ActivityStoreError };
-const ACTIVE_ACCOUNT_SINGLETON_ID = 1;
 export const DATA_DIR_ENV = "SUI_MCP_DATA_DIR";
 export const ACTIVITY_DATABASE_FILENAME = "sui-mcp.sqlite";
 function restrictPathPermissions(path, mode) {
@@ -39,6 +43,7 @@ function restrictPathPermissions(path, mode) {
 }
 export class SqliteActivityStore {
     db;
+    chainAccounts;
     validateAdapterLifecycle;
     constructor(options) {
         this.validateAdapterLifecycle = options.validateAdapterLifecycle;
@@ -60,6 +65,7 @@ export class SqliteActivityStore {
         }
         const database = new Database(options.databasePath);
         this.db = options.guardDatabase?.(database) ?? database;
+        this.chainAccounts = new SqliteAccountStore(this.db);
         try {
             initializeDatabase(this.db);
             configureDatabase(this.db);
@@ -81,47 +87,7 @@ export class SqliteActivityStore {
         }
         return this.getAccountByAddressSync(normalized);
     }
-    async setActiveAccount(address, source, now = new Date(), wallet) {
-        return this.setActiveAccountSync(address, source, now, wallet);
-    }
-    setActiveAccountSync(address, source, now, wallet) {
-        const timestamp = now.toISOString();
-        return this.db.transaction(() => {
-            const account = this.upsertAccountSync(address, source, timestamp);
-            this.db
-                .prepare(`INSERT INTO active_account_context (id, account_id, source, set_at, wallet_name, wallet_id)
-           VALUES (?, ?, ?, ?, ?, ?)
-           ON CONFLICT(id) DO UPDATE SET
-             account_id = excluded.account_id,
-             source = excluded.source,
-             set_at = excluded.set_at,
-             wallet_name = excluded.wallet_name,
-             wallet_id = excluded.wallet_id`)
-                .run(ACTIVE_ACCOUNT_SINGLETON_ID, account.id, source, timestamp, wallet?.name ?? null, wallet?.id ?? null);
-            return {
-                accountId: account.id,
-                address: account.address,
-                source,
-                setAt: timestamp,
-                ...(wallet?.name ? { walletName: wallet.name } : {}),
-                ...(wallet?.id ? { walletId: wallet.id } : {})
-            };
-        })();
-    }
-    async getActiveAccount() {
-        return this.getActiveAccountSync();
-    }
-    async clearActiveAccount(now = new Date()) { this.clearActiveAccountSync(now); }
-    clearActiveAccountSync(now = new Date()) {
-        this.db
-            .prepare(`INSERT INTO active_account_context (id, account_id, source, set_at)
-         VALUES (?, NULL, 'cleared', ?)
-         ON CONFLICT(id) DO UPDATE SET
-           account_id = NULL,
-           source = 'cleared',
-           set_at = excluded.set_at`)
-            .run(ACTIVE_ACCOUNT_SINGLETON_ID, now.toISOString());
-    }
+    async getActiveAccount() { return this.getActiveAccountSync(); }
     async recordReviewSession(input) {
         const plan = parseActionPlanEvidence(input.plan);
         const planJson = serializeJson(plan);
@@ -188,9 +154,6 @@ export class SqliteActivityStore {
                 : null;
             if (accountId !== null) {
                 this.assertReviewSessionAccount(input.reviewSessionId, accountId);
-                if (input.event === "wallet_connected") {
-                    this.assertActiveAccountSync(accountId, input.reviewSessionId);
-                }
             }
             this.insertReviewTransition({ ...input, accountId });
             this.db
@@ -240,12 +203,16 @@ export class SqliteActivityStore {
                 const { material: checked, clock } = live.publication;
                 const at = clock(), handle = checked.artifacts.transactionMaterial;
                 const material = handle && this.createTransactionMaterialStore().getTransactionMaterial(handle, at);
-                const connection = live.expected?.walletConnectionId ? this.db.prepare("SELECT revision,status,owner_id,connection_json FROM live_wallet_connections WHERE id=?")
-                    .get(live.expected.walletConnectionId) : undefined;
+                const connection = live.expected?.walletConnectionId ? this.db.prepare(`SELECT c.status,c.owner_id,c.run_id,c.connection_json,r.preparation_run_id FROM live_wallet_connections c
+          JOIN live_review_sessions r ON r.wallet_connection_id=c.id WHERE c.id=? AND r.id=? AND c.current_slot=1 AND c.data_epoch=(SELECT data_epoch FROM settings_control WHERE id=1)`)
+                    .get(live.expected.walletConnectionId, live.expected.id) : undefined;
+                const wallet = connection && walletConnectionSchema.parse(JSON.parse(connection.connection_json));
                 if (Date.parse(live.next.expiresAt) <= at.getTime() || !handle || !material || !sameHandle(material, handle) ||
                     !Buffer.from(material.transactionBytes).equals(checked.transactionBytes) || !connection || connection.status !== "connected" ||
-                    connection.owner_id !== live.expected?.ownerId || connection.revision !== live.expected?.walletConnectionRevision ||
-                    Date.parse(JSON.parse(connection.connection_json).expiresAt) <= at.getTime()) {
+                    connection.owner_id !== live.expected?.ownerId || !connection.run_id || connection.run_id !== connection.preparation_run_id || !wallet ||
+                    wallet.grantRevisions[SUI_MAINNET_WALLET_CHAIN] !== live.expected?.walletGrantRevision ||
+                    fixedChainAccount(wallet, SUI_MAINNET_WALLET_CHAIN) !== parsedState.account ||
+                    Date.parse(wallet.expiresAt) <= at.getTime()) {
                     throw new SessionStoreError("invalid_session_transition", "Review material or wallet selection changed before publication.");
                 }
             }
@@ -290,12 +257,12 @@ export class SqliteActivityStore {
             where += " AND e.status=?";
             params.push(z.enum(["success", "failure"]).parse(filter.executionStatus));
         }
-        const joins = `FROM review_sessions rs JOIN accounts a ON a.id=rs.account_id
+        const joins = `FROM review_sessions rs JOIN accounts a ON a.chain_id='${SUI_MAINNET_WALLET_CHAIN}' AND a.id=rs.account_id
       LEFT JOIN review_requests r ON r.attempt_id=rs.current_attempt_id AND r.review_session_id=rs.id AND r.account_id=rs.account_id
       LEFT JOIN review_executions e ON e.attempt_id=r.attempt_id`;
         const count = this.db.prepare(`SELECT COUNT(*) AS count ${joins} ${where}`).get(...params).count;
         const rows = this.db.prepare(`SELECT rs.id AS review_session_id, rs.plan_id, rs.action_kind, rs.adapter_id, rs.protocol,
-      rs.current_status, rs.current_attempt_id, a.sui_address AS account, rs.created_at, rs.updated_at,
+      rs.current_status, rs.current_attempt_id, a.address AS account, rs.created_at, rs.updated_at,
       e.status AS execution_status, e.tx_digest,
       (SELECT COUNT(*) FROM review_state_snapshots s WHERE s.review_session_id=rs.id) AS snapshot_count,
       (SELECT COUNT(*) FROM review_status_transitions t WHERE t.review_session_id=rs.id) AS transition_count
@@ -355,8 +322,8 @@ export class SqliteActivityStore {
        (r.request_status!='completed' OR e.tx_digest!=r.transaction_digest OR json_valid(e.result_json)=0))) LIMIT 1`).get(...params);
         if (inconsistent)
             throw new ActivityStoreReadError("internal_error", "Stored review request evidence is inconsistent.", { reason: "invalid_stored_evidence" });
-        for (const row of this.db.prepare(`SELECT rs.id,rs.current_attempt_id,a.sui_address AS account
-      FROM review_sessions rs JOIN accounts a ON a.id=rs.account_id ${where} AND rs.current_attempt_id IS NOT NULL`)
+        for (const row of this.db.prepare(`SELECT rs.id,rs.current_attempt_id,a.address AS account
+      FROM review_sessions rs JOIN accounts a ON a.chain_id='${SUI_MAINNET_WALLET_CHAIN}' AND a.id=rs.account_id ${where} AND rs.current_attempt_id IS NOT NULL`)
             .all(...params)) {
             this.readRequestEvidence(row.current_attempt_id, row.id, row.account);
         }
@@ -375,15 +342,15 @@ export class SqliteActivityStore {
     }
     async getReviewSessionDetail(input) {
         const scope = this.resolveReviewActivityScope({ account: input.account });
-        const row = scope.accountId === undefined ? undefined : this.db.prepare(`SELECT rs.*, a.sui_address AS account
-      FROM review_sessions rs JOIN accounts a ON a.id=rs.account_id WHERE rs.id=? AND rs.account_id=?`)
+        const row = scope.accountId === undefined ? undefined : this.db.prepare(`SELECT rs.*, a.address AS account
+      FROM review_sessions rs JOIN accounts a ON a.chain_id='${SUI_MAINNET_WALLET_CHAIN}' AND a.id=rs.account_id WHERE rs.id=? AND rs.account_id=?`)
             .get(input.reviewSessionId, scope.accountId);
         if (!row)
             throw new ActivityStoreReadError("session_not_found", "Review session not found", { reviewSessionId: input.reviewSessionId });
-        const snapshots = this.db.prepare(`SELECT s.*,a.sui_address AS account FROM review_state_snapshots s JOIN accounts a ON a.id=s.account_id
+        const snapshots = this.db.prepare(`SELECT s.*,a.address AS account FROM review_state_snapshots s JOIN accounts a ON a.chain_id='${SUI_MAINNET_WALLET_CHAIN}' AND a.id=s.account_id
       WHERE s.review_session_id=? AND s.account_id=? ORDER BY s.recorded_at,s.id LIMIT ?`)
             .all(input.reviewSessionId, scope.accountId, REVIEW_ACTIVITY_DETAIL_MAX_ITEMS + 1);
-        const transitions = this.db.prepare(`SELECT t.*,a.sui_address AS account FROM review_status_transitions t LEFT JOIN accounts a ON a.id=t.account_id
+        const transitions = this.db.prepare(`SELECT t.*,a.address AS account FROM review_status_transitions t LEFT JOIN accounts a ON a.chain_id='${SUI_MAINNET_WALLET_CHAIN}' AND a.id=t.account_id
       WHERE t.review_session_id=? AND (t.account_id IS NULL OR t.account_id=?) ORDER BY t.transitioned_at,t.id LIMIT ?`)
             .all(input.reviewSessionId, scope.accountId, REVIEW_ACTIVITY_DETAIL_MAX_ITEMS + 1);
         const requestIds = this.db.prepare(`SELECT attempt_id FROM review_requests WHERE review_session_id=? AND account_id=? ORDER BY created_at,attempt_id LIMIT ?`)
@@ -510,13 +477,13 @@ export class SqliteActivityStore {
             .prepare(`SELECT COUNT(*) AS count FROM external_activity_scans eas ${scanWhereSql}`)
             .get(...scanParams).count;
         const scanRows = this.db
-            .prepare(`SELECT eas.scan_id, eas.kind, eas.account_id, a.sui_address AS account, eas.relationship,
+            .prepare(`SELECT eas.scan_id, eas.kind, eas.account_id, a.address AS account, eas.relationship,
                 eas.input_digest, eas.from_checkpoint, eas.to_checkpoint, eas.from_timestamp,
                 eas.to_timestamp, eas.limit_count, eas.request_cursor, eas.response_cursor,
                 eas.endpoint_host, eas.chain_identifier, eas.fetched_at, eas.stored_count,
                 eas.skipped_count, eas.has_more, eas.window_complete, eas.incomplete_reason
          FROM external_activity_scans eas
-         JOIN accounts a ON a.id = eas.account_id
+         JOIN accounts a ON a.chain_id='${SUI_MAINNET_WALLET_CHAIN}' AND a.id = eas.account_id
          ${scanWhereSql}
          ORDER BY eas.fetched_at DESC, eas.scan_id DESC
          LIMIT ?`)
@@ -606,13 +573,13 @@ export class SqliteActivityStore {
          ${whereSql}`)
             .get(...params);
         const rows = this.db
-            .prepare(`SELECT eat.account_id, a.sui_address AS account, eat.digest, eat.relationship,
+            .prepare(`SELECT eat.account_id, a.address AS account, eat.digest, eat.relationship,
                 eat.checkpoint, eat.timestamp, eat.status, eat.known_sender_account_id,
                 eat.first_scan_id, eat.last_scan_id, eat.first_fetched_at, eat.last_fetched_at,
                 last_scan.incomplete_reason AS last_scan_incomplete_reason,
                 eat.detail_json
          FROM external_activity_transactions eat
-         JOIN accounts a ON a.id = eat.account_id
+         JOIN accounts a ON a.chain_id='${SUI_MAINNET_WALLET_CHAIN}' AND a.id = eat.account_id
          LEFT JOIN external_activity_scans last_scan ON last_scan.scan_id = eat.last_scan_id
          ${whereSql}
          ORDER BY
@@ -658,7 +625,7 @@ export class SqliteActivityStore {
         return new SqlitePrivateReviewArtifactStore(this.db);
     }
     createWalletWorkflowStore(ownerId, clock = () => new Date(), readSdkSnapshot = () => undefined) {
-        const records = new SqliteWalletWorkflowStore(this.db, ownerId, (address, id, name, now) => this.setActiveAccountSync(address, "wallet_connection", now, { id, name }), clock, this.createTransactionMaterialStore(), (input, at) => this.reconcileWorkflowState(input, records, ownerId, at === undefined ? clock : () => at), () => this.getActiveAccountSync(), readSdkSnapshot);
+        const records = new SqliteWalletWorkflowStore(this.db, ownerId, this.chainAccounts, clock, this.createTransactionMaterialStore(), (input, at) => this.reconcileWorkflowState(input, records, ownerId, at === undefined ? clock : () => at), readSdkSnapshot);
         return records;
     }
     finalizeReviewEvaluation(candidate, clock) {
@@ -701,7 +668,7 @@ export class SqliteActivityStore {
             const cards = this.createCardRecordStore();
             let record = input.expectedCard && records.currentCard(input.expectedCard);
             const reviewId = input.purpose === "review" ? input.reviewSessionId : undefined;
-            if (record && (input.purpose === "review" ? record.state.kind !== "review" || record.state.input.reviewSessionId !== reviewId : record.state.kind !== "connect")) {
+            if (record && (input.purpose === "review" ? record.state.kind !== "review" || record.state.input.reviewSessionId !== reviewId : !["connect", "disconnect"].includes(record.state.kind))) {
                 throw new SessionStoreError("session_mismatch", "The workflow target does not match this card.");
             }
             const target = reviewId ? records.reviewReadTarget(reviewId, record) : undefined;
@@ -724,20 +691,35 @@ export class SqliteActivityStore {
             else
                 records.advanceRequestDeadlines(now, target.attemptId);
             if (record)
-                record = cards.evaluate(record, () => now).record;
+                record = records.expireCard(record, now);
             const session = evaluated?.session;
             const request = target?.attemptId ? records.request(target.attemptId) : undefined;
             const authority = request && records.authority(request.attemptId);
             const details = request?.execution && records.executionDetails(request.attemptId);
-            const connection = record?.state.kind === "connect" && record.operationId ? records.connection(record.operationId) : undefined;
-            const connectionFacts = records.readConnectionFacts(now), targetAccount = session?.account ?? connectionFacts.activeAccount;
+            const operationRecord = ["connect", "disconnect"].includes(record?.scope ?? "") && record ? records.cardOperation(record) : undefined;
+            const operation = operationRecord && publicConnectionOperation(operationRecord);
+            const connectionFacts = records.readConnectionFacts(now), reviewTarget = session ? fixedReviewTarget(session, record?.state.input) : undefined;
+            const targetAccount = reviewTarget?.account;
+            if (record?.scope === "connect" || record?.scope === "disconnect")
+                record = records.reconcileWalletCard(record, connectionFacts);
+            if (record?.scope === "review" && record.state.state === "ready") {
+                const expired = session?.status === "expired" || !!session && Date.parse(session.expiresAt) <= now.getTime();
+                const targetReplaced = !!reviewTarget && !!connectionFacts.connection && connectionFacts.connection.connectionId !== reviewTarget.connectionId;
+                const targetAbsent = !!reviewTarget && connectionFacts.connection?.connectionId === reviewTarget.connectionId && connectionFacts.connectionPresence.confirmed &&
+                    connectionFacts.connectionPresence.observation?.status === "absent";
+                if (expired || targetAbsent || targetReplaced) {
+                    const error = expired ? undefined : targetAbsent
+                        ? "The wallet session for this review was confirmed absent. Ask in chat for a new transaction review; connect a wallet first if needed."
+                        : "The original wallet connection is no longer current. Ask in chat for a new transaction review.";
+                    record = records.endCard(record, expired ? "expired" : "failed", now, error);
+                }
+            }
             const facts = { ...connectionFacts, ownerId, record, session, request, authority,
                 hasReviewInput: !!session && session.status !== "expired" && Date.parse(session.expiresAt) > now.getTime() &&
                     cards.hasReviewInput(session.id, ownerId, now),
                 walletAvailability: input.walletAvailability,
-                runtimeRecovery: record && records.walletRecovery(record),
+                operation,
                 walletDependent: !target || target.walletDependent,
-                connection: connection ? records.connectionView(connection.connection) : undefined,
                 boundReview: request && (record?.operationId || record?.scope === "review_manage") ? records.requestReview(request.attemptId) : undefined,
                 busyForAccount: !!targetAccount && records.busyForAccount(targetAccount, now),
                 receipt: details ? details.data : undefined, receiptDisplay: details ? details.receiptDisplay : undefined };
@@ -809,33 +791,7 @@ export class SqliteActivityStore {
             .get(id);
     }
     upsertAccountSync(address, source, timestamp) {
-        const normalized = parseSuiAddress(address);
-        if (!normalized) {
-            throw new ActivityStoreError("Invalid Sui account address");
-        }
-        this.db
-            .prepare(`INSERT INTO accounts (sui_address, first_seen_at, last_used_at, first_source, last_source)
-         VALUES (?, ?, ?, ?, ?)
-         ON CONFLICT(sui_address) DO UPDATE SET
-           last_used_at = excluded.last_used_at,
-           last_source = excluded.last_source`)
-            .run(normalized, timestamp, timestamp, source, source);
-        const row = this.db
-            .prepare(`SELECT id, sui_address, first_seen_at, last_used_at, first_source, last_source
-         FROM accounts
-         WHERE sui_address = ?`)
-            .get(normalized);
-        if (!row) {
-            throw new ActivityStoreError(`Account was not recorded: ${normalized}`);
-        }
-        return {
-            id: row.id,
-            address: asString(row.sui_address),
-            firstSeenAt: asString(row.first_seen_at),
-            lastUsedAt: asString(row.last_used_at),
-            firstSource: asAccountSource(row.first_source),
-            lastSource: asAccountSource(row.last_source)
-        };
+        return this.chainAccounts.upsert(SUI_MAINNET_WALLET_CHAIN, address, source, timestamp);
     }
     parseReviewStateEvidenceJson(value, reviewSessionId, evidenceField) {
         const parsed = parseEvidenceJson(value, reviewSessionId, evidenceField);
@@ -850,48 +806,34 @@ export class SqliteActivityStore {
         }
     }
     getAccountByAddressSync(address) {
-        const row = this.db
-            .prepare(`SELECT id, sui_address, first_seen_at, last_used_at, first_source, last_source
-         FROM accounts
-         WHERE sui_address = ?`)
-            .get(address);
-        return row
-            ? {
-                id: row.id,
-                address: asString(row.sui_address),
-                firstSeenAt: asString(row.first_seen_at),
-                lastUsedAt: asString(row.last_used_at),
-                firstSource: asAccountSource(row.first_source),
-                lastSource: asAccountSource(row.last_source)
-            }
-            : undefined;
+        return this.chainAccounts.get(SUI_MAINNET_WALLET_CHAIN, address);
     }
     accountIdExists(accountId) {
-        const row = this.db.prepare("SELECT id FROM accounts WHERE id = ?").get(accountId);
+        const row = this.db.prepare("SELECT id FROM accounts WHERE id = ? AND chain_id=?").get(accountId, SUI_MAINNET_WALLET_CHAIN);
         return row !== undefined;
     }
     externalActivityScanById(scanId) {
         const row = this.db
-            .prepare(`SELECT eas.scan_id, eas.kind, eas.account_id, a.sui_address AS account, eas.relationship,
+            .prepare(`SELECT eas.scan_id, eas.kind, eas.account_id, a.address AS account, eas.relationship,
                 eas.input_digest, eas.from_checkpoint, eas.to_checkpoint, eas.from_timestamp,
                 eas.to_timestamp, eas.limit_count, eas.request_cursor, eas.response_cursor,
                 eas.endpoint_host, eas.chain_identifier, eas.fetched_at, eas.stored_count,
                 eas.skipped_count, eas.has_more, eas.window_complete, eas.incomplete_reason
          FROM external_activity_scans eas
-         JOIN accounts a ON a.id = eas.account_id
+         JOIN accounts a ON a.chain_id='${SUI_MAINNET_WALLET_CHAIN}' AND a.id = eas.account_id
          WHERE eas.scan_id = ?`)
             .get(scanId);
         return row ? externalActivityScanFromRow(row) : undefined;
     }
     externalActivityTransactions(whereSql, params) {
         const rows = this.db
-            .prepare(`SELECT eat.account_id, a.sui_address AS account, eat.digest, eat.relationship,
+            .prepare(`SELECT eat.account_id, a.address AS account, eat.digest, eat.relationship,
                 eat.checkpoint, eat.timestamp, eat.status, eat.known_sender_account_id,
                 eat.first_scan_id, eat.last_scan_id, eat.first_fetched_at, eat.last_fetched_at,
                 last_scan.incomplete_reason AS last_scan_incomplete_reason,
                 eat.detail_json
          FROM external_activity_transactions eat
-         JOIN accounts a ON a.id = eat.account_id
+         JOIN accounts a ON a.chain_id='${SUI_MAINNET_WALLET_CHAIN}' AND a.id = eat.account_id
          LEFT JOIN external_activity_scans last_scan ON last_scan.scan_id = eat.last_scan_id
          ${whereSql}
          ORDER BY
@@ -916,8 +858,8 @@ export class SqliteActivityStore {
                 throw new ActivityStoreReadError("input_invalid", "Invalid account filter", { field: "account" });
             }
             const row = this.db
-                .prepare("SELECT id FROM accounts WHERE sui_address = ?")
-                .get(normalized);
+                .prepare("SELECT id FROM accounts WHERE chain_id=? AND address=?")
+                .get(SUI_MAINNET_WALLET_CHAIN, normalized);
             return {
                 account: normalized,
                 accountId: row?.id,
@@ -926,8 +868,8 @@ export class SqliteActivityStore {
         }
         const active = this.getActiveAccountSync();
         if (!active) {
-            throw new ActivityStoreReadError("active_account_not_set", "Active account read context is not set", {
-                action: "connect_wallet_connection"
+            throw new ActivityStoreReadError("active_account_not_set", "No saved read address is set. Provide an explicit Sui account for this read.", {
+                action: "provide_account"
             });
         }
         return {
@@ -937,23 +879,7 @@ export class SqliteActivityStore {
         };
     }
     getActiveAccountSync() {
-        const row = this.db
-            .prepare(`SELECT a.id AS account_id, a.sui_address AS address, c.source AS source, c.set_at AS set_at,
-                c.wallet_name AS wallet_name, c.wallet_id AS wallet_id
-         FROM active_account_context c
-         JOIN accounts a ON a.id = c.account_id
-         WHERE c.id = ? AND c.account_id IS NOT NULL`)
-            .get(ACTIVE_ACCOUNT_SINGLETON_ID);
-        return row
-            ? {
-                accountId: row.account_id,
-                address: asString(row.address),
-                source: "wallet_connection",
-                setAt: asString(row.set_at),
-                ...(row.wallet_name ? { walletName: row.wallet_name } : {}),
-                ...(row.wallet_id ? { walletId: row.wallet_id } : {})
-            }
-            : undefined;
+        return this.chainAccounts.currentReadAccount(SUI_MAINNET_WALLET_CHAIN);
     }
     assertReviewSessionAccount(reviewSessionId, accountId) {
         const row = this.db
@@ -966,14 +892,6 @@ export class SqliteActivityStore {
             throw new ActivityStoreError(`Review session already belongs to a different account: ${reviewSessionId}`);
         }
     }
-    assertActiveAccountSync(accountId, reviewSessionId) {
-        const row = this.db
-            .prepare("SELECT account_id FROM active_account_context WHERE id = ? AND source = 'wallet_connection'")
-            .get(ACTIVE_ACCOUNT_SINGLETON_ID);
-        if (!row || row.account_id !== accountId) {
-            throw new ActivityStoreError(`Review session active account changed before commit: ${reviewSessionId}`);
-        }
-    }
 }
 function assertNonEmptyHalfOpenRange(from, to) {
     if (from >= to) {

package/dist/core/activity/sqliteActivityStoreSchema.js

@@ -2,30 +2,21 @@ import Database from "better-sqlite3";
 import { EXTERNAL_ACTIVITY_SCAN_MAX_LIMIT } from "./activityStore.js";
 import { ActivityStoreError } from "./sqliteActivityStoreTypes.js";
 import { SETTINGS_RESET_PREPARATION_SQL } from "../session/settingsPreparationSql.js";
+import { WALLET_CHAINS } from "../session/chainAccounts.js";
 import { LIVE_REVIEW_SESSION_INSERT_TRIGGER, LIVE_REVIEW_SESSION_UPDATE_TRIGGER, LIVE_REVIEW_SESSION_WRITE_CONTRACT_VERSION } from "../session/liveReviewSessionContract.js";
 const EXTERNAL_ACTIVITY_SCAN_INDEX_SQL = `CREATE INDEX IF NOT EXISTS idx_external_activity_scans_account_fetched
   ON external_activity_scans(account_id, fetched_at)`;
+const WALLET_CHAIN_SQL = WALLET_CHAINS.map((chain) => `'${chain}'`).join(",");
 const CURRENT_SCHEMA_SQL = `
     CREATE TABLE IF NOT EXISTS accounts (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
-      sui_address TEXT NOT NULL UNIQUE,
+      chain_id TEXT NOT NULL CHECK (chain_id IN (${WALLET_CHAIN_SQL})),
+      address TEXT NOT NULL,
       first_seen_at TEXT NOT NULL,
       last_used_at TEXT NOT NULL,
       first_source TEXT NOT NULL CHECK (first_source IN ('wallet_connection', 'review_execution')),
-      last_source TEXT NOT NULL CHECK (last_source IN ('wallet_connection', 'review_execution'))
-    );
-
-    CREATE TABLE IF NOT EXISTS active_account_context (
-      id INTEGER PRIMARY KEY CHECK (id = 1),
-      account_id INTEGER REFERENCES accounts(id) ON DELETE SET NULL,
-      source TEXT NOT NULL CHECK (source IN ('wallet_connection', 'cleared')),
-      set_at TEXT NOT NULL,
-      wallet_name TEXT,
-      wallet_id TEXT,
-      CHECK (
-        (source = 'cleared' AND account_id IS NULL)
-        OR (source = 'wallet_connection' AND account_id IS NOT NULL)
-      )
+      last_source TEXT NOT NULL CHECK (last_source IN ('wallet_connection', 'review_execution')),
+      UNIQUE (chain_id,address)
     );
 
     CREATE TABLE IF NOT EXISTS review_sessions (
@@ -136,15 +127,38 @@ const CURRENT_SCHEMA_SQL = `
       status TEXT NOT NULL,
       revision INTEGER NOT NULL CHECK (revision >= 0),
       topic TEXT UNIQUE,
-      sdk_pending INTEGER NOT NULL CHECK (sdk_pending IN (0,1)),
+      current_slot INTEGER UNIQUE CHECK (current_slot IS NULL OR current_slot=1),
+      data_epoch INTEGER NOT NULL CHECK (data_epoch >= 0),
+      read_address_cleared INTEGER NOT NULL DEFAULT 0 CHECK (read_address_cleared IN (0,1)),
       connection_json TEXT NOT NULL
     );
+    CREATE TABLE IF NOT EXISTS wallet_connection_operations (
+      operation_id TEXT PRIMARY KEY,
+      card_id TEXT NOT NULL UNIQUE,
+      owner_id TEXT NOT NULL,
+      run_id TEXT NOT NULL,
+      data_epoch INTEGER NOT NULL CHECK (data_epoch >= 0),
+      action TEXT NOT NULL CHECK (action IN ('connect','disconnect')),
+      connection_id TEXT NOT NULL REFERENCES live_wallet_connections(id) ON DELETE RESTRICT,
+      status TEXT NOT NULL CHECK (status IN ('running','completed','failed','stopped')),
+      input_json TEXT NOT NULL,
+      result_json TEXT,
+      sdk_pending INTEGER NOT NULL CHECK (sdk_pending IN (0,1)),
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      expires_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_wallet_connection_pending ON wallet_connection_operations(connection_id,sdk_pending);
+    CREATE TRIGGER IF NOT EXISTS wallet_connection_result_immutable
+    BEFORE UPDATE ON wallet_connection_operations WHEN OLD.result_json IS NOT NULL AND NEW.result_json IS NOT OLD.result_json
+    BEGIN SELECT RAISE(ABORT,'Account management results are immutable'); END;
     CREATE TABLE IF NOT EXISTS live_request_authority (
       attempt_id TEXT PRIMARY KEY REFERENCES review_requests(attempt_id) ON DELETE RESTRICT,
       owner_id TEXT NOT NULL,
       run_id TEXT,
       connection_id TEXT NOT NULL REFERENCES live_wallet_connections(id) ON DELETE RESTRICT,
-      connection_revision INTEGER NOT NULL,
+      grant_revision INTEGER NOT NULL,
       can_submit INTEGER NOT NULL CHECK (can_submit IN (0,1)),
       sdk_pending INTEGER NOT NULL CHECK (sdk_pending IN (0,1)),
       submit_pending INTEGER NOT NULL CHECK (submit_pending IN (0,1)),
@@ -225,7 +239,7 @@ const CURRENT_SCHEMA_SQL = `
       preparation_run_id TEXT,
       preparation_error TEXT,
       wallet_connection_id TEXT,
-      wallet_connection_revision INTEGER,
+      wallet_grant_revision INTEGER,
       current_attempt_id TEXT,
       plans_json TEXT NOT NULL,
       review_state_json TEXT,
@@ -246,7 +260,7 @@ const CURRENT_SCHEMA_SQL = `
       id TEXT PRIMARY KEY,
       owner_id TEXT NOT NULL,
       token_hash TEXT NOT NULL,
-      kind TEXT NOT NULL CHECK (kind IN ('account', 'receipt', 'chart', 'connect', 'review', 'settings')),
+      kind TEXT NOT NULL CHECK (kind IN ('account', 'receipt', 'chart', 'connect', 'disconnect', 'review', 'settings')),
       state TEXT NOT NULL CHECK (state IN ('ready', 'running', 'closed')),
       reason TEXT CHECK (reason IN ('completed', 'expired', 'failed', 'server_restarted', 'cancelled')),
       error TEXT,
@@ -254,7 +268,7 @@ const CURRENT_SCHEMA_SQL = `
       created_at TEXT NOT NULL,
       expires_at TEXT NOT NULL,
       input_json TEXT NOT NULL,
-      scope TEXT NOT NULL DEFAULT 'read' CHECK (scope IN ('read', 'connect', 'review', 'review_manage', 'settings')),
+      scope TEXT NOT NULL DEFAULT 'read' CHECK (scope IN ('read', 'connect', 'disconnect', 'review', 'review_manage', 'settings')),
       operation_id TEXT,
       accepted_input_json TEXT,
       result_json TEXT,
@@ -294,7 +308,6 @@ const CURRENT_SCHEMA_SQL = `
       next_run_id TEXT,
       supersedes_operation_id TEXT,
       superseded_by_operation_id TEXT,
-      checkpoint TEXT,
       CHECK ((phase='terminal' AND result_json IS NOT NULL) OR (phase!='terminal' AND result_json IS NULL))
     );
     CREATE TRIGGER IF NOT EXISTS settings_immutable_result
@@ -320,6 +333,10 @@ const CURRENT_SCHEMA_SQL = `
     CREATE TRIGGER IF NOT EXISTS live_read_cards_insert_revision
     BEFORE INSERT ON live_read_cards WHEN NEW.revision != 0
     BEGIN SELECT RAISE(ABORT, 'card insert requires revision zero'); END;
+    CREATE TRIGGER IF NOT EXISTS live_card_terminal_immutable
+    BEFORE UPDATE ON live_read_cards WHEN OLD.state='closed'
+    BEGIN SELECT RAISE(ABORT, 'Closed card results and permissions are immutable'); END;
+
     CREATE TRIGGER IF NOT EXISTS live_read_cards_update_revision
     BEFORE UPDATE ON live_read_cards WHEN NEW.revision != OLD.revision + 1
     BEGIN SELECT RAISE(ABORT, 'card update requires the next revision'); END;
@@ -413,13 +430,13 @@ function externalActivityScansTableSql() {
   )`;
 }
 function settingsRevisionTriggers() {
-    const userTables = ["accounts", "active_account_context", "review_sessions", "review_state_snapshots",
+    const userTables = ["accounts", "review_sessions", "review_state_snapshots",
         "review_status_transitions", "review_executions", "review_requests", "external_activity_scans",
         "external_activity_transactions", "local_settings"];
-    const walletTables = ["live_wallet_connections", "live_review_sessions", "live_request_authority"];
+    const walletTables = ["live_wallet_connections", "wallet_connection_operations", "live_review_sessions", "live_request_authority"];
     const invalidate = (condition) => `
     UPDATE live_read_cards SET revision=revision+1
-      WHERE id IN (SELECT card_id FROM settings_operations WHERE phase='prepared' AND (${condition}));
+      WHERE state!='closed' AND id IN (SELECT card_id FROM settings_operations WHERE phase='prepared' AND (${condition}));
     ${SETTINGS_RESET_PREPARATION_SQL}
       WHERE phase='prepared' AND (${condition});`;
     return [...new Set([...userTables, ...walletTables])].flatMap((table) => ["INSERT", "UPDATE", "DELETE"].map((event) => `
@@ -428,7 +445,6 @@ function settingsRevisionTriggers() {
         ${userTables.includes(table) ? "UPDATE settings_control SET user_data_revision=user_data_revision+1 WHERE id=1;" : ""}
         ${invalidate([...(userTables.includes(table) ? ["kind IN ('import_local_data','reset_local_data')"] : []),
         ...(walletTables.includes(table) || table === "review_requests" ? ["kind='restart_wallet_service'"] : []),
-        ...(table === "local_settings" ? ["kind IN ('set_endpoint','restore_endpoint')"] : []),
-        ...(table === "active_account_context" ? ["kind='clear_read_address'"] : [])].join(" OR ") || "0")}
+        ...(table === "local_settings" ? ["kind IN ('set_endpoint','restore_endpoint')", `kind='set_wallet_networks' AND ${event === "DELETE" ? "OLD" : "NEW"}.key='walletConnectionChains'`] : [])].join(" OR ") || "0")}
       END;`)).join("\n");
 }

package/dist/core/activity/transactionActivityService.js

@@ -280,8 +280,8 @@ export class TransactionActivityService {
     async resolveActiveAccount() {
         const active = await this.options.activityStore.getActiveAccount();
         if (!active) {
-            throw new TransactionActivityError("active_account_not_set", "Active account read context is not set", {
-                action: "connect_wallet_connection"
+            throw new TransactionActivityError("active_account_not_set", "No saved read address is set. Provide an explicit Sui account for this read.", {
+                action: "provide_account"
             });
         }
         return { account: active.address, accountSource: "active_account_context" };

package/dist/core/preferences/preferencesStore.js

@@ -1,4 +1,4 @@
-export const LOCAL_SETTING_KEYS = ["suiGrpcUrl", "suiGraphqlUrl"];
+export const LOCAL_SETTING_KEYS = ["suiGrpcUrl", "suiGraphqlUrl", "walletConnectionChains"];
 export const SETTINGS_APPLIES_AFTER_RESTART = "mcp_server_restart";
 export class PreferencesStoreError extends Error {
     kind;
@@ -19,7 +19,7 @@ export class LocalSettingsError extends Error {
     }
 }
 export function assertLocalSettingKey(key) {
-    if (key === "suiGrpcUrl" || key === "suiGraphqlUrl") {
+    if (key === "suiGrpcUrl" || key === "suiGraphqlUrl" || key === "walletConnectionChains") {
         return key;
     }
     throw new PreferencesStoreError("unknown_key", "Unknown local setting key", { key });

package/dist/core/preferences/sqlitePreferencesRepository.js

@@ -1,5 +1,6 @@
 import { PreferencesStoreError, assertLocalSettingKey } from "./preferencesStore.js";
 import { parseGraphqlUrl, parseGrpcUrl } from "../suiEndpoint.js";
+import { DEFAULT_WALLET_CHAINS, parseWalletChains } from "../session/chainAccounts.js";
 export class SqlitePreferencesRepository {
     db;
     constructor(db) {
@@ -11,6 +12,11 @@ export class SqlitePreferencesRepository {
        ON CONFLICT(key) DO NOTHING`);
         insert.run("suiGrpcUrl", encodeSettingValue("suiGrpcUrl", defaults.suiGrpcUrl), now.toISOString());
         insert.run("suiGraphqlUrl", encodeSettingValue("suiGraphqlUrl", defaults.suiGraphqlUrl), now.toISOString());
+        insert.run("walletConnectionChains", encodeSettingValue("walletConnectionChains", DEFAULT_WALLET_CHAINS), now.toISOString());
+    }
+    getWalletConnectionChainsSync() {
+        const record = this.getLocalSettingSync("walletConnectionChains");
+        return record ? parseWalletChains(record.value) : [...DEFAULT_WALLET_CHAINS];
     }
     async getSuiGrpcUrl() {
         const record = await this.getLocalSetting("suiGrpcUrl");
@@ -92,6 +98,8 @@ function rowToLocalSetting(row) {
     };
 }
 function encodeSettingValue(key, value) {
+    if (key === "walletConnectionChains")
+        return JSON.stringify(parseWalletChains(value));
     if (key === "suiGrpcUrl") {
         if (typeof value !== "string") {
             throw new PreferencesStoreError("invalid_value", "suiGrpcUrl setting value must be a string", { key });
@@ -114,6 +122,8 @@ function decodeSettingValue(key, valueJson) {
     catch {
         throw new PreferencesStoreError("malformed_json", "Malformed local setting JSON", { key });
     }
+    if (key === "walletConnectionChains")
+        return parseWalletChains(parsed);
     if (key === "suiGrpcUrl") {
         return asSuiGrpcUrlValue(parsed);
     }

package/dist/core/read/deepbookReadHelpers.js

@@ -67,7 +67,7 @@ export function deepbookQuoteQuantitySemantics(inputAmountKind) {
         canUseForPaymentAnswer: false,
         canUseForShortfallAnswer: false,
         doNotCombineWithPaymentAnswer: true,
-        requiredPaymentAnswerTool: "read.preview_intent_evidence",
+        requiredPaymentAnswerTool: "read_preview_intent_evidence",
         paymentAnswerUseBlockedReason: "quote_output_is_price_reference_not_payment_answer",
         requiredPaymentAnswerField: "responseSummary",
         fiatUsdCashOutAvailable: false,