@zktx.io/sui-mcp 0.6.0 → 0.6.1

package/dist/core/session/sqliteSettingsWorkflowStore.js

@@ -4,8 +4,6 @@ import { SqliteCardRecordStore } from "./sqliteCardStore.js";
 import { SettingsConflict, settingsDownload, storedSettingsDownloadSchema, settingsDraftSchema, settingsResultSchema, retainedBackupRejection } from "./settingsOperation.js";
 import { isSettingsDownloadFile, settingsBackupPath, SETTINGS_FILE_CLEANUP_SQL } from "./settingsFileIdentity.js";
 import { SETTINGS_REUSABLE_UPLOAD_SQL, SETTINGS_RESET_PREPARATION_SQL } from "./settingsPreparationSql.js";
-/** Settings transitions share the activity owner's SQLite connection and card CAS.
- * Network and filesystem work must remain outside these transactions. */
 export class SqliteSettingsWorkflowStore {
     db;
     ownerId;
@@ -118,7 +116,6 @@ export class SqliteSettingsWorkflowStore {
         const control = this.control();
         return this.fileIOAvailable(control) && (control.active_operation_id === null || control.active_operation_id === operationId);
     }
-    // Read-only eligibility check shared by preparation and final admission.
     requireFinalSlot(replaceId) {
         const control = this.control();
         if (!this.fileIOAvailable(control) || control.active_operation_id !== (replaceId ?? null)) {
@@ -145,8 +142,6 @@ export class SqliteSettingsWorkflowStore {
             return next;
         });
     }
-    // Pure admission checks let deadline reconciliation commit an expected refusal
-    // without claiming a final slot or consuming input. Admission uses the same rule.
     requireAdmission(expected, input, currentFingerprint, replaceOperationId, now = this.now()) {
         const result = this.requireInput(expected, input.operationId, now), operation = result.operation;
         if (operation.phase !== "prepared" || !operation.draft || operation.preparationId !== input.preparationId ||
@@ -212,8 +207,6 @@ export class SqliteSettingsWorkflowStore {
             if (!isDeepStrictEqual(this.get(expected.operationId), expected) || expected.draft?.kind !== "download_backup") {
                 throw new SettingsConflict("The download state changed before it could be saved.");
             }
-            // A terminal result is immutable serialized evidence. Updating delivery
-            // state must not reserialize it, even with semantically identical keys.
             this.db.prepare("UPDATE settings_operations SET preparation_json=? WHERE operation_id=?")
                 .run(JSON.stringify({ download }), expected.operationId);
             if (!this.cards.replace(card, { ...card, state: { ...card.state, revision: card.state.revision + 1 } })) {
@@ -259,7 +252,6 @@ export class SqliteSettingsWorkflowStore {
     }
     continueDownload(expected, input) {
         return this.transaction(() => {
-            // Validate the caller's scope before any target reads or expiry writes.
             this.downloadContext(expected, input.operationId, input.fileId);
             this.expireDownloads(input.operationId);
             const { card, operation, file, download } = this.downloadContext(expected, input.operationId, input.fileId);
@@ -454,8 +446,6 @@ export class SqliteSettingsWorkflowStore {
         }
     }
 }
-// The input is already a strict typed action. Sort object keys recursively so
-// JSON-RPC ids and object insertion order never change business idempotency.
 export function settingsIdentity(value) {
     const canonical = (input) => Array.isArray(input) ? input.map(canonical) : input !== null && typeof input === "object"
         ? Object.fromEntries(Object.entries(input).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, canonical(item)])) : input;

package/dist/core/session/sqliteTransactionMaterialStore.js

@@ -1,13 +1,4 @@
 import { buildTransactionMaterialRecord, sameHandle, toMaterialHandle } from "./transactionMaterialStore.js";
-/**
- * SQLite-backed transaction material store. Holds the same synchronous contract as
- * InMemoryLocalTransactionMaterialStore so producers and the wallet handoff path are
- * unchanged, but persists records (including the unsigned transaction BLOB) to the
- * shared local database so any review-server process can read them. Validation,
- * handle identity, and expiry semantics are shared via transactionMaterialStore.ts,
- * so the two backends never drift. The unsigned bytes are protected at rest by the
- * data directory (0700) and database file (0600) permissions set in SqliteActivityStore.
- */
 export class SqliteTransactionMaterialStore {
     db;
     constructor(db) {
@@ -44,8 +35,6 @@ export class SqliteTransactionMaterialStore {
         this.db.prepare(`DELETE FROM live_transaction_materials WHERE review_session_id = ?`).run(reviewSessionId);
     }
 }
-// Each read rebuilds a fresh record (new Uint8Array from the BLOB, parsed
-// diagnostics) so a caller mutating the result never touches the stored row.
 function recordFromRow(row) {
     return {
         materialId: row.material_id,

package/dist/core/session/sqliteWalletWorkflowStore.js

@@ -34,8 +34,6 @@ const preparationInterruptionReasons = {
     wallet_service_restarted: "The wallet service was restarted. Update this review before requesting approval.",
     wallet_service_lost: "The wallet service stopped. Restore the wallet connection and update this review before requesting approval."
 };
-/** Purpose-specific mutations on the activity owner's connection. Each method
- * commits card, request and public history together; no network work runs here. */
 export class SqliteWalletWorkflowStore {
     db;
     ownerId;
@@ -103,8 +101,6 @@ export class SqliteWalletWorkflowStore {
         return recovery;
     }
     recordWalletFailure(input) {
-        // Retried by the workflow until revocation is durably recorded. The SDK
-        // run is already fenced, so a failed write cannot preserve usable authority.
         this.invalidateWalletRun("wallet_service_lost", new Date(input.observedAt), input.runId);
     }
     publishWalletState() { this.publishAvailableWallets(); }
@@ -115,8 +111,6 @@ export class SqliteWalletWorkflowStore {
                     continue;
                 const observed = snapshot.sessions.find((item) => item.topic === record.topic);
                 if (record.connection.status !== "connected") {
-                    // Startup can transfer management ownership; ordinary observations
-                    // update the current run's facts without restoring terminal authority.
                     if ((ready || record.ownerId === this.ownerId && record.runId === snapshot.runId) &&
                         observed?.status === "present" && !record.sdkPending &&
                         !this.pendingDisconnect(record.connection.connectionId, record.ownerId)) {
@@ -208,8 +202,6 @@ export class SqliteWalletWorkflowStore {
         return { confirmed: true, connections, unrecorded, pendingConnectionIds };
     }
     readConnectionFacts(now) {
-        // A deferred read transaction reuses an outer admission transaction when
-        // present. It never repairs callbacks, advances deadlines or reserves I/O.
         return this.db.transaction(() => {
             const records = this.connections(), snapshot = this.readSdkSnapshot(), account = this.readActiveAccount();
             return { evaluatedAt: now.toISOString(), activeAccount: account?.address, activeAccountConnectionId: account?.walletId,
@@ -239,9 +231,6 @@ export class SqliteWalletWorkflowStore {
             if (!card || card.ownerId !== this.ownerId || card.operationId !== id || card.acceptedInput?.action !== source.action ||
                 card.acceptedInput.walletRunId !== source.runId)
                 return;
-            // A connection may progress from pairing to one admitted disconnect.
-            // That later operation owns sdk_pending even if its result is already
-            // visible and the original pairing's failed cleanup write arrives late.
             const disconnect = this.db.prepare(`SELECT id FROM live_read_cards WHERE owner_id=? AND scope='connect' AND operation_id=?
         AND json_extract(accepted_input_json,'$.action')='disconnect'`).get(this.ownerId, id);
             if (source.action === "connect" && disconnect && disconnect.id !== source.cardId)
@@ -314,8 +303,6 @@ export class SqliteWalletWorkflowStore {
         if (card.state.kind === "review" && !session)
             throw new WorkflowConflict("The saved review is unavailable.");
         const connection = card.state.kind === "connect" && card.operationId ? this.connection(card.operationId)?.connection : undefined;
-        // Wallet-dependent commands already passed the workflow availability guard.
-        // This store checks DB eligibility; it does not measure SDK health.
         const connectionFacts = this.readConnectionFacts(now), targetAccount = session?.account ?? connectionFacts.activeAccount;
         const facts = { ...connectionFacts, ownerId: this.ownerId, record: card, session, request,
             authority: request ? this.authority(request.attemptId) : undefined, connection,
@@ -380,8 +367,6 @@ export class SqliteWalletWorkflowStore {
       WHERE operation_id=@id`).run({ terminal: terminal ? 1 : 0, id: operationId });
     }
     publishConnection(connectionId, status) {
-        // Connection updates are not completion of every operation referencing it.
-        // In particular, session_update(connected) must not finish a pending disconnect.
         const outcome = this.connection(connectionId)?.connection;
         this.db.prepare(`UPDATE live_read_cards SET revision=revision+1,
       result_json=CASE WHEN state='running' AND json_extract(accepted_input_json,'$.action')='disconnect'
@@ -447,8 +432,6 @@ export class SqliteWalletWorkflowStore {
             this.db.prepare("INSERT INTO live_wallet_connections (id,owner_id,status,revision,topic,sdk_pending,connection_json,run_id) VALUES (?,?,?,?,?,?,?,?)")
                 .run(connection.connectionId, this.ownerId, connection.status, 0, null, 1, JSON.stringify(connection), this.runId ?? null);
             this.consume(card, input, connection.connectionId);
-            // Every other live input observes the admitted connection before the SDK
-            // responds, so an older selection cannot bypass the one-connection rule.
             this.publishAvailableWallets();
             return this.connection(connection.connectionId);
         }).immediate();
@@ -494,7 +477,6 @@ export class SqliteWalletWorkflowStore {
       owner_id=excluded.owner_id, status=excluded.status, revision=excluded.revision, topic=excluded.topic,
       sdk_pending=0, connection_json=excluded.connection_json,run_id=excluded.run_id`).run(id, this.ownerId, next.status, next.revision, session.topic, 0, JSON.stringify(next), this.runId ?? null);
         this.publishConnection(id, next.status);
-        // Restoring the SDK session never restores a cleared read-account context.
         return this.connection(id);
     }
     useAccount(expected, input, connectionId, account) {
@@ -532,7 +514,6 @@ export class SqliteWalletWorkflowStore {
     finishDisconnect(cardId, connectionId, succeeded, now) {
         this.db.transaction(() => {
             const pending = this.pendingDisconnect(connectionId);
-            // A session deletion event may have already completed this operation.
             if (pending?.state.cardId !== cardId)
                 return;
             this.updateConnection(connectionId, succeeded ? { status: "disconnected" } : {
@@ -587,8 +568,6 @@ export class SqliteWalletWorkflowStore {
             const artifacts = new SqlitePrivateReviewArtifactStore(this.db).get(material.reviewSessionId);
             const stored = this.materialStore.getTransactionMaterial(material.transactionMaterial, now);
             if (!current || !materialStillMatches(material, current, sessions.revision(current.id), artifacts, stored, now)) {
-                // Expected expiry commits its normal cleanup, but no request authority.
-                // A changed candidate is a conflict and must not invalidate newer data.
                 const evaluated = this.evaluateState({ purpose: "review", reviewSessionId: material.reviewSessionId,
                     readTarget: this.reviewReadTarget(material.reviewSessionId, card), expectedCard: card, candidate: { session: material.review, rowRevision: material.rowRevision,
                         artifacts: material.artifacts, material }, walletAvailability: { status: "available", walletRunId } }, now);
@@ -709,8 +688,6 @@ export class SqliteWalletWorkflowStore {
             if (old.requestStatus === "awaiting_signature" && next !== old.requestStatus)
                 this.publishAvailableWallets();
             if (["stopped", "request_failed", "outcome_unknown", "completed"].includes(next)) {
-                // A historical attempt may finish while a newer review is preparing.
-                // Clean only the material still owned by this admitted revision.
                 for (const table of ["live_transaction_materials", "live_private_review_artifacts"]) {
                     this.db.prepare(`DELETE FROM ${table} WHERE review_session_id=? AND EXISTS
             (SELECT 1 FROM live_review_sessions WHERE id=? AND review_revision=? AND preparation_id IS NULL)`)
@@ -741,8 +718,6 @@ export class SqliteWalletWorkflowStore {
         this.db.transaction(() => {
             const now = this.clock();
             this.advanceRequestDeadlines(now, id);
-            // Observation may have finished, or its window may have closed, while
-            // submit was pending. A late response cannot reopen either outcome.
             if (this.request(id)?.requestStatus === "submitting")
                 this.transitionRequest(id, "awaiting_chain_result", now);
         }).immediate();
@@ -757,8 +732,6 @@ export class SqliteWalletWorkflowStore {
                 return request;
             if (request.requestStatus === "awaiting_signature")
                 return this.transitionRequest(id, cause === "wallet_service_lost" ? "request_failed" : "stopped", now, { reason: interruptionReasons[cause] });
-            // Once submitted, connection changes cannot revoke a transaction or the
-            // independent lookup of its digest. Only explicit user stopping ends observation.
             if (cause === "user_stop" && authority.observation_stopped === 0 &&
                 ["submitting", "awaiting_chain_result", "outcome_unknown"].includes(request.requestStatus)) {
                 this.db.prepare("UPDATE live_request_authority SET observation_stopped=1 WHERE attempt_id=?").run(id);
@@ -778,8 +751,6 @@ export class SqliteWalletWorkflowStore {
                 .all(connectionId, this.ownerId, runId ?? null, runId ?? null);
             for (const row of rows) {
                 const state = row.review_state_json ? JSON.parse(row.review_state_json) : undefined;
-                // Later session observations cannot rewrite why an already interrupted
-                // preparation ended. A new admitted preparation clears this error.
                 if (!row.preparation_id && row.preparation_error && !state?.transactionReviewData)
                     continue;
                 if (state) {

package/dist/core/session/status.js

@@ -32,8 +32,6 @@ export function isInteractionPendingReviewStatus(status) {
     return executionStatusCategory(status) !== "final";
 }
 export function isReviewInteractionPending({ hasReviewInput, request, progress }) {
-    // Historical preparation state is not proof that a live input remains.
-    // Consumed input, in turn, does not end its admitted request or observation.
     return hasReviewInput || progress.status !== "idle" || !!request && isRequestWaiting(request.requestStatus);
 }
 export function executionPollingHint() {

package/dist/core/session/transactionMaterialStore.js

@@ -115,9 +115,6 @@ export class LocalTransactionMaterialStoreError extends Error {
         super(message);
     }
 }
-// Validate the store input and build the stored record (with cloned bytes). Shared
-// by every LocalTransactionMaterialStore implementation so validation never drifts
-// between the in-memory and SQLite backends.
 export function buildTransactionMaterialRecord(input, now = new Date()) {
     const account = parseSuiAddress(input.account);
     if (!account) {
@@ -158,7 +155,6 @@ export function buildTransactionMaterialRecord(input, now = new Date()) {
             : { redactedDiagnostics: structuredClone(input.redactedDiagnostics) })
     };
 }
-// Project the public (redacted) handle out of a stored record.
 export function toMaterialHandle(record) {
     return {
         materialId: record.materialId,

package/dist/core/session/transactionRequest.js

@@ -6,14 +6,10 @@ export const TRANSACTION_REQUEST_STATUSES = [
     "request_failed", "outcome_unknown", "completed"
 ];
 export const transactionRequestStatusSchema = z.enum(TRANSACTION_REQUEST_STATUSES);
-// The submission was admitted durably before external I/O. A failed follow-up
-// write must not remove its initial observation window or replacement guard.
 export const INITIAL_CHAIN_OBSERVATION_STATUSES = ["submitting", "awaiting_chain_result"];
 export function isInitialChainObservation(status) {
     return INITIAL_CHAIN_OBSERVATION_STATUSES.some((value) => value === status);
 }
-// This is the existing signing surface's local wait, independent of protocol
-// request expiry, card input expiry and the chain observation window.
 export const SIGNATURE_WAIT_MS = 90_000;
 export const CHAIN_RECEIPT_LOOKUP_MAX_AGE_MS = 10 * 60 * 1000;
 export const transactionExecutionSummarySchema = z.object({

package/dist/core/session/walletConnection.js

@@ -46,7 +46,6 @@ export function workflowProgress(waiting, requiresWallet, availability) {
 export const walletConnectionStatusSchema = z.enum([
     "awaiting_approval", "connected", "rejected", "failed", "expired", "stopped", "disconnected"
 ]);
-// Recorded recovery facts, not proof of a currently usable wallet connection.
 export const walletRecoveryImpactSchema = z.object({
     runId: z.string().uuid(),
     connections: z.array(z.object({ connectionId: z.string().min(1), revision: z.number().int().nonnegative(),
@@ -104,8 +103,6 @@ export function walletConnectionSelection(connections, at, presence, stored) {
 export class WalletUserRejectedError extends Error {
     constructor() { super("The wallet request was rejected by the user."); }
 }
-// Shared recorded connection facts only. Each operation checks its own expiry,
-// account, method and revision requirements at its decision boundary.
 export function isOwnedConnectedWallet(record, ownerId, disconnectPending) {
     return !!record && record.ownerId === ownerId && record.connection.status === "connected" && !disconnectPending;
 }

package/dist/core/session/walletWorkflow.js

@@ -19,8 +19,6 @@ export class WalletWorkflow {
     observing = new Map();
     preparing = new Set();
     pendingWrites = new Map();
-    // Child exit ends child I/O, not verification or submit work already running
-    // in this parent. The owning signature continuation alone ends that work.
     parentSignatureWork = new Set();
     eventListener;
     settingsRecovery;
@@ -47,7 +45,7 @@ export class WalletWorkflow {
     report(stage) { try {
         this.options.logger.error("Wallet operation failed", { stage });
     }
-    catch { /* SQLite owns outcomes. */ } }
+    catch { } }
     async start() {
         this.assertCurrent();
         if (this.started)
@@ -130,7 +128,6 @@ export class WalletWorkflow {
         this.retainWrite(completion);
     }
     retainWrite(completion) {
-        // An old data generation cannot add repair work to the replacement data.
         try {
             this.assertCurrent();
         }
@@ -173,8 +170,6 @@ export class WalletWorkflow {
                 failure = error;
             }
         }
-        // A completed callback's pending flag is housekeeping, not authority to
-        // read recorded facts. Retain failed repairs for the next applicable read.
         if (failure && walletDependent)
             throw failure;
         if (walletDependent)
@@ -210,14 +205,10 @@ export class WalletWorkflow {
             walletObservation: state.walletObservation, manageableConnectionIds: state.manageableConnectionIds,
             connectionReconciliationRequired: state.connectionReconciliationRequired, assetReadAccount: state.assetReadAccount ?? { status: "address_required" } };
     }
-    // Diagnostic facts are collected without maintenance. Reconciliation and
-    // admission own durable transitions and cannot use this snapshot as authority.
     currentConnectionContext() {
         this.assertCurrent();
         const facts = this.options.records.readConnectionFacts(this.now()), availability = this.walletAvailability();
         const { selection: _selection, ...eligibility } = workflowConnectionEligibility({ ...facts, walletAvailability: availability });
-        // The shared projection gates qualification on published availability;
-        // a memory snapshot alone does not prove its journal/result has committed.
         return { connections: facts.connections, walletAvailability: availability, walletObservation: facts.walletObservation,
             connectionConflict: eligibility.connectionConflict, manageableConnectionIds: eligibility.manageableConnectionIds,
             connectionReconciliationRequired: eligibility.connectionReconciliationRequired,
@@ -231,7 +222,6 @@ export class WalletWorkflow {
             const pending = this.options.records.pendingDisconnect(record.connection.connectionId);
             if (!pending)
                 continue;
-            // Disabled transports also return undefined; that is not session absence.
             const absent = available && !!record.topic && this.observed(record.topic)?.status === "absent";
             this.options.records.recoverDisconnect(pending.state.cardId, record.connection.connectionId, record.connection.revision, absent);
         }
@@ -263,8 +253,6 @@ export class WalletWorkflow {
             if (explicitResult) {
                 await this.observing.get(state.request.attemptId);
                 this.assertCurrent();
-                // An awaited receipt may have committed new facts. Return one freshly
-                // evaluated snapshot; ordinary status reads do not await external I/O.
                 state = await this.evaluateReview(id, undefined, false, state.request.attemptId);
             }
         }
@@ -447,8 +435,6 @@ export class WalletWorkflow {
             catch (error) {
                 displayFailure = error;
             }
-            // The approval remains pending even if setup/QR recording fails or the
-            // wallet dependency is disabled. Settle only after that promise ends.
             const session = await result.approval;
             if (displayFailure)
                 throw displayFailure;
@@ -552,8 +538,6 @@ export class WalletWorkflow {
                 return;
         }
         catch (error) {
-            // SDK verification can itself depend on a remote source. An exception is
-            // not proof of a mismatched transaction or signer.
             if (!this.stopped)
                 this.options.records.transitionRequest(request.attemptId, "request_failed", this.now(), {
                     reason: this.walletAvailability().status !== "available" ? "Wallet operations became unavailable before submission. The returned signature will not be submitted."
@@ -564,7 +548,7 @@ export class WalletWorkflow {
         try {
             await this.options.submitTransaction(bytes, response.signature);
         }
-        catch { /* A lost submit response is not proof of failure. Observe the same digest. */ }
+        catch { }
         finally {
             this.completeCallback({ kind: "request", id: request.attemptId, field: "submit_pending" });
         }
@@ -585,8 +569,6 @@ export class WalletWorkflow {
         const current = this.options.records.request(id);
         if (!current || !(isInitialChainObservation(current.requestStatus) || explicit && current.requestStatus === "outcome_unknown"))
             return;
-        // Starting another lookup needs its own previous callback to be settled.
-        // Stored terminal facts above never depend on this write succeeding.
         for (const [key, write] of this.pendingWrites)
             if (write.kind === "request" && write.id === id && write.field === "lookup_pending") {
                 this.settlePendingWrite(key, write);
@@ -607,7 +589,7 @@ export class WalletWorkflow {
                             if (receipt.status === "found")
                                 details = projectReadCardResult("receipt", { digest: request.transactionDigest }, receipt);
                         }
-                        catch { /* Keep verified chain facts if the additional display read is unavailable. */ }
+                        catch { }
                     }
                     this.assertCurrent();
                     this.options.records.transitionRequest(id, "completed", this.now(), { execution: {

package/dist/core/session/workflowState.js

@@ -2,8 +2,6 @@ import { walletConnectionSelection } from "./walletConnection.js";
 import { isInitialChainObservation } from "./transactionRequest.js";
 export const workflowActions = ["connect", "disconnect", "use_account", "stop_connection", "prepare_review",
     "request_signature", "cancel", "stop_waiting", "read_result"];
-// Read context may change; an existing review's account binding may not.
-// Both evaluated choices and admission consume this relation with current facts.
 export function reviewPreparationAccount(boundAccount, activeAccount, selectedAccount = activeAccount) {
     if (!activeAccount)
         return { allowed: false, message: "No account from a connected wallet is selected for this review." };
@@ -23,18 +21,12 @@ export function workflowConnectionEligibility(facts) {
         : usableConnectionId ? selection.assetReadAccount : { status: "address_required" };
     return { selection, usableConnectionId, assetReadAccount, connectionConflict: selection.conflict,
         manageableConnectionIds: available ? selection.manageableConnectionIds : [],
-        // A pending memory snapshot is not a published SDK observation. Startup
-        // and state-sync failures retain their own result and neutral diagnosis.
         connectionReconciliationRequired: available && dependent ? selection.connectionReconciliationRequired : undefined };
 }
-// Shared domain eligibility. The DB supplies current facts at its decision
-// boundary. Returned choices are advisory; admission still binds concrete input.
 export function workflowEligibility(facts) {
     const { record, session, request, authority, walletAvailability } = facts;
     const at = Date.parse(facts.evaluatedAt);
     const cardRemaining = record?.ownerId === facts.ownerId ? Math.max(0, Date.parse(record.state.expiresAt) - at) : 0;
-    // A later-created input card cannot extend its review session. Admitted
-    // requests and management cards retain their separate observation authority.
     const remaining = record?.scope === "review" && session && !request
         ? Math.min(cardRemaining, Math.max(0, Date.parse(session.expiresAt) - at)) : cardRemaining;
     const inputAvailable = remaining > 0 && record?.state.state === "ready" && record.acceptedInput === undefined;

package/dist/core/session/workflowView.js

@@ -9,7 +9,6 @@ import { reviewProgress, EXECUTION_POLLING_INTERVAL_SECONDS } from "./status.js"
 import { walletRunIdSchema, walletRecoverySchema, walletObservationSchema } from "./walletRuntime.js";
 export const CONNECT_BOUNDARY = "A wallet connection provides account context; it is not a transaction approval or proof of address ownership.";
 export const REVIEW_BOUNDARY = "Review evidence is not a safety guarantee. Only an explicit card action and wallet approval may authorize this exact transaction.";
-// A projection of an admitted card operation, not a new wallet connection state.
 export const connectionViewSchema = walletConnectionSchema.extend({ pendingAction: z.literal("disconnect").optional() });
 export { assetReadAccountSchema } from "./walletConnection.js";
 export const pendingConnectionStatusSchema = z.enum(["input_required", "awaiting_approval", "disconnect_pending"]);
@@ -80,8 +79,6 @@ export const workflowViewSchema = z.object({
         context.addIssue({ code: "custom", path: ["assetReadAccount"], message: "The default address must belong to the usable connection and stored selection." });
     }
 });
-// Automatic preparation uses the same current selection and typed admission as
-// a deliberate retry. A failed computation is not a reason to compute in a loop.
 function automaticReviewAction(input) {
     const { record, session, request } = input;
     if (!session || record?.scope !== "review" || request || session.preparationError ||
@@ -98,7 +95,6 @@ function automaticReviewAction(input) {
     return { action: "prepare_review", walletRunId: input.walletAvailability.walletRunId, connectionId: candidates[0].connectionId,
         account, reviewRevision: session.reviewRevision };
 }
-// Method support filters wallet choices; it does not authorize a signature.
 export function reviewWalletChoices(selection, account, requireSigningMethod = false) {
     return selection.connections.filter((item) => item.connectionId === selection.usableConnectionId && item.accounts.includes(account) &&
         (!requireSigningMethod || item.methods.includes("sui_signTransaction")));
@@ -112,8 +108,6 @@ function nextStateRead(input) {
         .filter((value) => value !== undefined && value > 0);
     return delays.length ? Math.min(...delays) : undefined;
 }
-// These projections do not read clocks, storage, or admission rules. The
-// evaluated facts and choices were collected together by the database owner.
 export function projectConnectionView(input) {
     const { walletAvailability } = input;
     const stored = input.record?.state.data;

package/dist/core/suiAddress.js

@@ -1,13 +1,8 @@
 import { isValidSuiAddress, isValidTransactionDigest, normalizeSuiAddress } from "@mysten/sui/utils";
 import { z } from "zod";
-// Use the string-only schema at MCP/HTTP output boundaries because zod transforms
-// cannot be represented in MCP JSON Schema. Use the normalized schema for values
-// before storing them as local session state.
 export const suiAddressStringSchema = z
     .string()
     .refine(isValidSuiAddress, "Expected a 32-byte Sui address");
-// Shared Sui transaction digest schema (pinned SDK source of truth). Used at
-// MCP/HTTP boundaries and by the signable-adapter commitment fields.
 export const suiTransactionDigestSchema = z
     .string()
     .refine(isValidTransactionDigest, "Expected a Sui transaction digest");

package/dist/core/suiEndpoint.js

@@ -35,9 +35,6 @@ export function parseGrpcUrl(value) {
     }
     return `${parsed.protocol}//${authority}`;
 }
-// GraphQL endpoints commonly include a path such as /graphql and may omit an
-// explicit port. gRPC endpoints stay stricter because the pinned gRPC client
-// runtime expects only scheme, host, and explicit port.
 export function parseGraphqlUrl(value) {
     let parsed;
     if (value.length > MAX_SUI_GRAPHQL_URL_LENGTH) {

package/dist/mcp/prompts.js

@@ -24,9 +24,6 @@ export const MCP_PROMPTS = [
         ].join("\n")
     }
 ];
-// Platform-owned boundary language appended to every adapter prompt surface.
-// Adapters contribute copy about their own action only; they cannot weaken
-// or omit these lines.
 const PLATFORM_PROMPT_BOUNDARY_LINES = [
     "Present the internal Review card and summarize the returned review checks.",
     "This MCP response never contains signing data, transaction bytes, or signing readiness; only an explicit UI action and wallet approval authorize the backend request; request status is separate from server-verified chain execution facts."
@@ -76,18 +73,9 @@ export function registerMcpPrompts(server, surfaces = []) {
             ]
         }));
     }
-    // Adapter prompt surfaces: action-first names (`swap-deep`) with one
-    // free-text intent argument so clients can pass the whole request in one
-    // line (Claude Code: /mcp__sui-mcp__swap-deep 10 sui to usdc;
-    // Claude Desktop shows a single input field). The model parses the
-    // intent; this server never does.
     for (const surface of surfaces) {
         registerSurfacePrompt(server, promptNameFor(surface), surface, surface.description);
     }
-    // Bare action prompts are always registered. One protocol: straight to it.
-    // Several protocols: an optional `protocol` argument (completion suggests
-    // the slugs) and explicit instructions to ask the user - the venue is the
-    // user's choice, never the server's.
     for (const [action, group] of actionGroups(surfaces)) {
         registerBareActionPrompt(server, action, group);
     }

package/dist/mcp/schemas.js

@@ -1,7 +1,4 @@
 import { z } from "zod";
-// No-parameter tools. The `.optional()` is load-bearing: it lets the tool be called with
-// no arguments at all (undefined args validate). A bare `{}`/`z.object({})` would instead
-// REQUIRE an (empty) object and reject an argument-less call, so this is not a no-op.
 export const noParamsInputSchema = z.object({}).optional();
 export function successOutputSchema(dataShape) {
     return {

package/dist/mcp/tools/action/prepareSuiActionReview.js

@@ -32,12 +32,6 @@ export function registerActionTools(server, deps) {
         if (!supportsCards(server))
             return errorToolResult({ kind: "ui_unavailable", details: { reason: "An internal review card is required." } });
         const now = new Date();
-        // A swap review is account-bound: its evidence (balances, transaction
-        // material, digest, simulation) is computed for a specific sender, and
-        // no transaction can be built without that account. Refuse here when no
-        // wallet account is connected instead of creating a hollow proposal that
-        // can never be computed or signed. Connect first via
-        // session.create_wallet_connection.
         let activeAccount;
         try {
             activeAccount = await deps.activityStore.getActiveAccount();

package/dist/mcp/tools/read/serverStatusTools.js

@@ -5,7 +5,6 @@ import { MCP_PROMPTS } from "../../prompts.js";
 import { MCP_RESOURCES } from "../../resources.js";
 import { EVIDENCE_POLICY, FAIL_CLOSED_TOOLS, IMPLEMENTED_TOOLS, PACKAGE_NAME, SERVER_LIMITATIONS, SERVER_NAME, SERVER_NETWORK, SERVER_RUNTIME, SERVER_TRANSPORT, SERVER_VERSION } from "../../serverInfo.js";
 import { TOOL_NAMES } from "../../toolNames.js";
-// Executable swap adapters precede protocol-notes-only entries.
 export const SUPPORTED_PROTOCOLS = [
     { id: "deepbook-v3", status: "mainnet", support: "read_and_local_review" },
     { id: "deepbook-margin", status: "mainnet", support: "protocol_notes_only" }

package/dist/mcp/tools/session/shared.js

@@ -27,8 +27,6 @@ export function latest(items) {
     const sorted = [...items].sort((left, right) => right.lastActivityAt.localeCompare(left.lastActivityAt));
     return { limit: INTERACTION_STATUS_LIMIT, items: sorted.slice(0, INTERACTION_STATUS_LIMIT), truncated: sorted.length > INTERACTION_STATUS_LIMIT };
 }
-// Runtime workflows own reconciliation/observation. A server without a wallet
-// workflow can still expose ordinary preparation facts, with explicit absence.
 export async function readCurrentReview(deps, id, explicitResult = false) {
     if (deps.workflow)
         return deps.workflow.readReview(id, explicitResult);

package/dist/mcp/tools/session/statusTools.js

@@ -34,8 +34,6 @@ export function registerSessionStatusTools(server, deps) {
             return activityStoreToolError(error, deps.logger);
         }
         try {
-            // Connection reconciliation can invalidate reviews and interrupt requests.
-            // Complete that maintenance before projecting its dependent review facts.
             const context = deps.workflow?.reconcileConnectionContext() ?? { connections: [], manageableConnectionIds: [],
                 assetReadAccount: { status: "address_required" }, walletAvailability: walletUnavailable("initialization_failed") };
             const connections = deps.workflow?.pendingConnections() ?? [];