@zktx.io/sui-mcp 0.5.0

package/dist/runtime/smokeMainnetReadAssertions.js

@@ -0,0 +1,306 @@
+export class SmokeResponseShapeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SmokeResponseShapeError";
+    }
+}
+export function assertSmokeOkStatus(payload, toolName) {
+    const data = objectValue(payload.data);
+    if (payload.ok !== true || data?.status !== "ok") {
+        throw new SmokeResponseShapeError(`Tool ${toolName} did not return ok status: ${JSON.stringify(payload)}`);
+    }
+}
+export function summarizeActivitySmokePayload(payload, toolName, options) {
+    assertSmokeOkStatus(payload, toolName);
+    const data = requiredObject(payload.data, `${toolName}.data`);
+    const source = requiredObject(data.source, `${toolName}.data.source`);
+    const persistence = requiredObject(data.persistence, `${toolName}.data.persistence`);
+    const requestedAccount = requiredObject(data.requestedAccount, `${toolName}.data.requestedAccount`);
+    const transactions = requiredArray(data.transactions, `${toolName}.data.transactions`);
+    const account = requiredString(data.account, `${toolName}.data.account`);
+    const accountSource = requiredAccountSource(data.accountSource, `${toolName}.data.accountSource`);
+    const relationship = requiredRelationship(data.relationship, `${toolName}.data.relationship`);
+    const functionTarget = options.requireFunction
+        ? requiredString(data.function, `${toolName}.data.function`)
+        : undefined;
+    const sourceTransport = requiredLiteral(source.transport, "graphql", `${toolName}.data.source.transport`);
+    const sourceMethod = requiredLiteral(source.method, "Query.transactions", `${toolName}.data.source.method`);
+    const hasMore = requiredBoolean(data.hasMore, `${toolName}.data.hasMore`);
+    const windowComplete = requiredBooleanOrNull(data.windowComplete, `${toolName}.data.windowComplete`);
+    const orderingVerified = requiredBoolean(data.orderingVerified, `${toolName}.data.orderingVerified`);
+    const persistenceStored = requiredBoolean(persistence.stored, `${toolName}.data.persistence.stored`);
+    const requestedAccountBalanceChangeCompleteness = requiredBalanceChangeCompleteness(requestedAccount.balanceChangeCompleteness, `${toolName}.data.requestedAccount.balanceChangeCompleteness`);
+    const requestedAccountCoinFlows = requiredArray(requestedAccount.coinFlows, `${toolName}.data.requestedAccount.coinFlows`);
+    const requestedAccountSentCount = requiredNonnegativeInteger(requestedAccount.sentCount, `${toolName}.data.requestedAccount.sentCount`);
+    const requestedAccountAffectedOnlyCount = requiredNonnegativeInteger(requestedAccount.affectedOnlyCount, `${toolName}.data.requestedAccount.affectedOnlyCount`);
+    const requestedAccountTransactionFacts = requiredArray(data.requestedAccountTransactionFacts, `${toolName}.data.requestedAccountTransactionFacts`);
+    const accountFactSummary = summarizeRequestedAccountTransactionFacts(requestedAccountTransactionFacts, transactions.length, toolName);
+    const compactSummary = summarizeCompactResponseSupport(transactions, toolName);
+    let analysisLimitationCount;
+    let analysisCoinFlowCount;
+    if (accountSource !== options.expectedAccountSource) {
+        throw new SmokeResponseShapeError(`${toolName}.data.accountSource expected ${options.expectedAccountSource}, got ${accountSource}`);
+    }
+    if (options.expectedRelationship !== undefined && relationship !== options.expectedRelationship) {
+        throw new SmokeResponseShapeError(`${toolName}.data.relationship expected ${options.expectedRelationship}, got ${relationship}`);
+    }
+    if (options.requireAnalysis) {
+        const analysis = requiredObject(data.analysis, `${toolName}.data.analysis`);
+        const overview = requiredObject(analysis.overview, `${toolName}.data.analysis.overview`);
+        const limitations = requiredArray(analysis.limitations, `${toolName}.data.analysis.limitations`);
+        const coinFlows = requiredArray(analysis.coinFlows, `${toolName}.data.analysis.coinFlows`);
+        const analysisTransactionCount = requiredNonnegativeInteger(overview.transactionCount, `${toolName}.data.analysis.overview.transactionCount`);
+        if (analysisTransactionCount !== transactions.length) {
+            throw new SmokeResponseShapeError(`${toolName}.data.analysis.overview.transactionCount does not match transactions.length`);
+        }
+        analysisLimitationCount = limitations.length;
+        analysisCoinFlowCount = coinFlows.length;
+    }
+    if (options.expectNoDetails === true && compactSummary.fullDetailsReturned) {
+        throw new SmokeResponseShapeError(`${toolName}.data.transactions must not include full details`);
+    }
+    if (options.expectNoDetails === true && compactSummary.compactReturned) {
+        throw new SmokeResponseShapeError(`${toolName}.data.transactions must not include compact transaction aggregates`);
+    }
+    return {
+        status: transactions.length === 0 ? "empty_page" : "ok",
+        rowCount: transactions.length,
+        emptyAccepted: transactions.length === 0,
+        transactionCount: transactions.length,
+        account,
+        accountSource,
+        relationship,
+        ...(functionTarget === undefined ? {} : { functionTargetPresent: true }),
+        sourceTransport,
+        sourceMethod,
+        hasMore,
+        windowComplete,
+        orderingVerified,
+        persistenceStored,
+        requestedAccountBalanceChangeCompleteness,
+        requestedAccountCoinFlowCount: requestedAccountCoinFlows.length,
+        requestedAccountSentCount,
+        requestedAccountAffectedOnlyCount,
+        ...accountFactSummary,
+        ...compactSummary,
+        ...(analysisLimitationCount === undefined ? {} : { analysisLimitationCount }),
+        ...(analysisCoinFlowCount === undefined ? {} : { analysisCoinFlowCount })
+    };
+}
+function summarizeRequestedAccountTransactionFacts(facts, transactionCount, toolName) {
+    if (facts.length !== transactionCount) {
+        throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts length does not match transactions.length`);
+    }
+    let balanceChangeRows = 0;
+    facts.forEach((factValue, factIndex) => {
+        const fact = requiredObject(factValue, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}]`);
+        const requestedAccountEffect = requiredObject(fact.requestedAccountEffect, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].requestedAccountEffect`);
+        const evidence = requiredAccountBalanceChangeEvidence(fact.accountBalanceChangeEvidence, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].accountBalanceChangeEvidence`);
+        const inferencePolicy = requiredAccountBalanceChangeInferencePolicy(fact.accountBalanceChangeInferencePolicy, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].accountBalanceChangeInferencePolicy`);
+        const completeness = requiredBalanceChangeCompleteness(fact.accountBalanceChangeCompleteness, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].accountBalanceChangeCompleteness`);
+        requiredLiteral(requestedAccountEffect.scope, "requested_account", `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].requestedAccountEffect.scope`);
+        const balanceChanges = requiredArray(fact.accountBalanceChanges, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].accountBalanceChanges`);
+        balanceChangeRows += balanceChanges.length;
+        const nestedBalanceChanges = requiredArray(requestedAccountEffect.balanceChanges, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].requestedAccountEffect.balanceChanges`);
+        if (nestedBalanceChanges.length !== balanceChanges.length) {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}] accountBalanceChanges length must match requestedAccountEffect.balanceChanges length`);
+        }
+        if (completeness === "truncated" && evidence !== "incomplete_account_balance_changes") {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}] truncated account evidence must be incomplete_account_balance_changes`);
+        }
+        if (completeness === "unavailable" && evidence !== "account_balance_changes_unavailable") {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}] unavailable account evidence must be account_balance_changes_unavailable`);
+        }
+        if (completeness === "complete" && balanceChanges.length === 0 && evidence !== "no_account_balance_changes_returned") {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}] empty complete account evidence must be no_account_balance_changes_returned`);
+        }
+        if (completeness === "complete" && balanceChanges.length > 0 && evidence !== "account_balance_changes_returned") {
+            throw new SmokeResponseShapeError(`${toolName} complete account rows require account_balance_changes_returned`);
+        }
+        if (requestedAccountEffect.balanceChangeEvidence !== evidence || requestedAccountEffect.balanceChangeCompleteness !== completeness) {
+            throw new SmokeResponseShapeError(`${toolName} nested account evidence and completeness must match flat fields`);
+        }
+        const expectedInferencePolicy = expectedAccountBalanceChangeInferencePolicy(evidence);
+        if (inferencePolicy !== expectedInferencePolicy) {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}].accountBalanceChangeInferencePolicy is inconsistent with account evidence`);
+        }
+        if (requestedAccountEffect.accountBalanceChangeInferencePolicy !== inferencePolicy) {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}].requestedAccountEffect.accountBalanceChangeInferencePolicy does not match flat field`);
+        }
+        const transactionContext = objectValue(fact.transactionContext);
+        if (transactionContext !== undefined && Object.hasOwn(transactionContext, "balanceChanges")) {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}].transactionContext must not include transaction-wide balanceChanges`);
+        }
+    });
+    return {
+        requestedAccountTransactionFactCount: facts.length,
+        requestedAccountTransactionFactBalanceChangeRowCount: balanceChangeRows
+    };
+}
+function summarizeCompactResponseSupport(transactions, toolName) {
+    let fullDetailsReturned = false;
+    let compactReturned = false;
+    let compactBalanceChangeRowCount = 0;
+    let compactAggregatedBalanceChangeRowCount = 0;
+    let transactionContextCount = 0;
+    let requestedAccountEffectBalanceChangeRowCount = 0;
+    let requestedAccountEffectTruncatedTransactionCount = 0;
+    transactions.forEach((transactionValue, transactionIndex) => {
+        const transaction = requiredObject(transactionValue, `${toolName}.data.transactions[${transactionIndex}]`);
+        if (Object.hasOwn(transaction, "details")) {
+            fullDetailsReturned = true;
+        }
+        const transactionContext = objectValue(transaction.transactionContext);
+        if (transactionContext !== undefined) {
+            transactionContextCount += 1;
+            if (transactionContext.factScope !== "transaction") {
+                throw new Error(`${toolName}.data.transactions[${transactionIndex}].transactionContext.factScope must be "transaction"`);
+            }
+            if (transactionContext.requestedAccountScoped !== false) {
+                throw new Error(`${toolName}.data.transactions[${transactionIndex}].transactionContext.requestedAccountScoped must be false`);
+            }
+            if (Object.hasOwn(transactionContext, "balanceChanges")) {
+                throw new SmokeResponseShapeError(`${toolName}.data.transactions[${transactionIndex}].transactionContext must not include transaction-wide balanceChanges`);
+            }
+        }
+        const requestedAccountEffect = objectValue(transaction.requestedAccountEffect);
+        if (requestedAccountEffect !== undefined) {
+            requiredLiteral(requestedAccountEffect.scope, "requested_account", `${toolName}.data.transactions[${transactionIndex}].requestedAccountEffect.scope`);
+            const completeness = requiredBalanceChangeCompleteness(requestedAccountEffect.balanceChangeCompleteness, `${toolName}.data.transactions[${transactionIndex}].requestedAccountEffect.balanceChangeCompleteness`);
+            if (completeness === "truncated") {
+                requestedAccountEffectTruncatedTransactionCount += 1;
+            }
+            requestedAccountEffectBalanceChangeRowCount += requiredArray(requestedAccountEffect.balanceChanges, `${toolName}.data.transactions[${transactionIndex}].requestedAccountEffect.balanceChanges`).length;
+        }
+        const compact = objectValue(transaction.compact);
+        if (compact === undefined) {
+            return;
+        }
+        compactReturned = true;
+        if (compact.factScope !== "transaction") {
+            throw new Error(`${toolName}.data.transactions[${transactionIndex}].compact.factScope must be "transaction"`);
+        }
+        if (compact.requestedAccountScoped !== false) {
+            throw new Error(`${toolName}.data.transactions[${transactionIndex}].compact.requestedAccountScoped must be false`);
+        }
+        const balanceChanges = requiredArray(compact.balanceChanges, `${toolName}.data.transactions[${transactionIndex}].compact.balanceChanges`);
+        compactBalanceChangeRowCount += balanceChanges.length;
+        balanceChanges.forEach((changeValue, changeIndex) => {
+            const change = requiredObject(changeValue, `${toolName}.data.transactions[${transactionIndex}].compact.balanceChanges[${changeIndex}]`);
+            if (change.count === undefined) {
+                return;
+            }
+            const count = requiredPositiveInteger(change.count, `${toolName}.data.transactions[${transactionIndex}].compact.balanceChanges[${changeIndex}].count`);
+            if (count > 1) {
+                compactAggregatedBalanceChangeRowCount += 1;
+            }
+        });
+    });
+    return {
+        fullDetailsReturned,
+        compactReturned,
+        compactBalanceChangeRowCount,
+        compactAggregatedBalanceChangeRowCount,
+        transactionContextCount,
+        requestedAccountEffectBalanceChangeRowCount,
+        requestedAccountEffectTruncatedTransactionCount
+    };
+}
+function requiredObject(value, path) {
+    const object = objectValue(value);
+    if (object === undefined) {
+        throw new SmokeResponseShapeError(`${path} must be an object`);
+    }
+    return object;
+}
+function objectValue(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function requiredArray(value, path) {
+    if (!Array.isArray(value)) {
+        throw new SmokeResponseShapeError(`${path} must be an array`);
+    }
+    return value;
+}
+function requiredString(value, path) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new SmokeResponseShapeError(`${path} must be a non-empty string`);
+    }
+    return value;
+}
+function requiredBoolean(value, path) {
+    if (typeof value !== "boolean") {
+        throw new SmokeResponseShapeError(`${path} must be a boolean`);
+    }
+    return value;
+}
+function requiredBooleanOrNull(value, path) {
+    if (typeof value !== "boolean" && value !== null) {
+        throw new SmokeResponseShapeError(`${path} must be a boolean or null`);
+    }
+    return value;
+}
+function requiredNonnegativeInteger(value, path) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+        throw new SmokeResponseShapeError(`${path} must be a nonnegative integer`);
+    }
+    return value;
+}
+function requiredPositiveInteger(value, path) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+        throw new SmokeResponseShapeError(`${path} must be a positive integer`);
+    }
+    return value;
+}
+function requiredAccountSource(value, path) {
+    if (value === "active_account_context" || value === "explicit_filter") {
+        return value;
+    }
+    throw new SmokeResponseShapeError(`${path} must be active_account_context or explicit_filter`);
+}
+function requiredRelationship(value, path) {
+    if (value === "affected" || value === "sent") {
+        return value;
+    }
+    throw new SmokeResponseShapeError(`${path} must be affected or sent`);
+}
+function requiredBalanceChangeCompleteness(value, path) {
+    if (value === "complete" || value === "truncated" || value === "unavailable") {
+        return value;
+    }
+    throw new SmokeResponseShapeError(`${path} must be complete, truncated, or unavailable`);
+}
+function requiredAccountBalanceChangeEvidence(value, path) {
+    if (value === "account_balance_changes_returned" ||
+        value === "no_account_balance_changes_returned" ||
+        value === "incomplete_account_balance_changes" ||
+        value === "account_balance_changes_unavailable") {
+        return value;
+    }
+    throw new SmokeResponseShapeError(`${path} must be a valid account balance-change evidence marker`);
+}
+function requiredAccountBalanceChangeInferencePolicy(value, path) {
+    if (value === "use_returned_account_balance_changes" ||
+        value === "no_account_balance_changes_in_complete_details" ||
+        value === "do_not_infer_from_transaction_context") {
+        return value;
+    }
+    throw new SmokeResponseShapeError(`${path} must be a valid account balance-change inference policy`);
+}
+function expectedAccountBalanceChangeInferencePolicy(evidence) {
+    if (evidence === "account_balance_changes_returned") {
+        return "use_returned_account_balance_changes";
+    }
+    if (evidence === "no_account_balance_changes_returned") {
+        return "no_account_balance_changes_in_complete_details";
+    }
+    return "do_not_infer_from_transaction_context";
+}
+function requiredLiteral(value, expected, path) {
+    if (value === expected) {
+        return expected;
+    }
+    throw new SmokeResponseShapeError(`${path} must be ${expected}`);
+}

package/dist/runtime/smokeReview.js

@@ -0,0 +1,40 @@
+import { INTENT_PLAN_FACTORIES, resolveIntentPlanFactory, swapIntentInputSchema } from "../adapters/intentPlanFactories.js";
+import { computeReviewStateWithPrivateArtifacts } from "../core/review/reviewComputation.js";
+export class SmokeReviewConfigError extends Error {
+}
+const requiredSwapInputs = ["SMOKE_SWAP_PROTOCOL", "SMOKE_SWAP_FROM_SYMBOL", "SMOKE_SWAP_TO_SYMBOL", "SMOKE_SWAP_AMOUNT_DISPLAY"];
+/** Optional read-only review computation. This never establishes a wallet
+ * connection; the caller owns the explicit temporary read-account fixture. */
+export async function computeSmokeReview(options) {
+    const { env, sessions, computation, account } = options;
+    const rawSlippage = env.SMOKE_SWAP_MAX_SLIPPAGE_BPS;
+    if (rawSlippage !== undefined && (!Number.isInteger(Number(rawSlippage)) || Number(rawSlippage) < 1)) {
+        throw new SmokeReviewConfigError("SMOKE_SWAP_MAX_SLIPPAGE_BPS must be a positive integer.");
+    }
+    const missing = requiredSwapInputs.filter((name) => env[name] === undefined);
+    if (missing.length === requiredSwapInputs.length)
+        return { status: "not_run", notRunReason: "missing_env", requiredEnv: [...requiredSwapInputs] };
+    if (missing.length)
+        throw new SmokeReviewConfigError(`Partial account-bound swap smoke configuration; missing: ${missing.join(", ")}`);
+    // Preserve the utility's existing 50 bps CLI default; it is not a product
+    // recommendation or a silently selected protocol/settlement asset.
+    const parsed = swapIntentInputSchema.safeParse({ type: "swap", protocol: env.SMOKE_SWAP_PROTOCOL,
+        from: { symbol: env.SMOKE_SWAP_FROM_SYMBOL, amount: env.SMOKE_SWAP_AMOUNT_DISPLAY },
+        to: { symbol: env.SMOKE_SWAP_TO_SYMBOL }, maxSlippageBps: Number(env.SMOKE_SWAP_MAX_SLIPPAGE_BPS ?? "50") });
+    if (!parsed.success)
+        throw new SmokeReviewConfigError("The optional swap smoke inputs are invalid.");
+    const { protocol, ...intent } = parsed.data;
+    const resolution = resolveIntentPlanFactory(INTENT_PLAN_FACTORIES, "swap", protocol);
+    if (resolution.status !== "resolved")
+        throw new SmokeReviewConfigError("SMOKE_SWAP_PROTOCOL must select a supported swap adapter.");
+    const now = options.now ?? new Date(), plan = resolution.factory.createPlan(intent, now);
+    const created = await sessions.createReviewSession([plan], now);
+    await sessions.recordWalletConnected(created.session.id, account, now);
+    const computed = await computeReviewStateWithPrivateArtifacts({ reviewSessionId: created.session.id, plan, account, now }, computation);
+    await sessions.recordReviewStateWithArtifacts(created.session.id, computed.state, computed.privateArtifacts, now);
+    return { status: "ok", reviewStatus: computed.state.status, blockedReason: computed.state.blockedReason,
+        completedStageCount: computed.state.adapterLifecycle?.completedStages.length ?? 0,
+        missingStages: computed.state.adapterLifecycle?.missingStages ?? [],
+        reviewDataEmitted: computed.state.transactionReviewData !== undefined,
+        failedCheckIds: computed.state.checks.filter((check) => check.status === "fail").map((check) => check.id) };
+}

package/dist/runtime/start.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadBootConfig } from "./config.js";
+import { createRuntimeApplication } from "./application.js";
+import { createStderrLogger, flushStderr } from "./logger.js";
+import { startOrDeferReviewServer } from "./reviewServerAcquire.js";
+import { loadControlIdentity } from "./shared/control.js";
+import { probeAuthenticatedServer } from "./shared/authenticatedFetch.js";
+import { startSharedServer } from "./shared/server.js";
+import { startSharedStdio } from "./shared/stdio.js";
+import { RuntimeTermination } from "./runtimeTermination.js";
+import { WALLETCONNECT_PROJECT_ID } from "./walletConnectConfig.js";
+async function main() {
+    const logger = createStderrLogger("runtime");
+    let shared;
+    let bridge;
+    let ready, failed;
+    const backendReady = new Promise((resolve, reject) => { ready = resolve; failed = reject; });
+    void backendReady.catch(() => { });
+    const termination = new RuntimeTermination({ logger, flush: flushStderr, exit: (code) => process.exit(code),
+        close: async () => {
+            failed(new Error("Runtime closed before startup completed."));
+            const results = await Promise.allSettled([bridge?.close(), shared?.close()]);
+            const failure = results.find((result) => result.status === "rejected");
+            if (failure?.status === "rejected")
+                throw failure.reason;
+        }
+    });
+    let stage = "configuration";
+    const stdio = new StdioServerTransport();
+    const closeForClient = () => { void termination.request({ kind: "client" }); };
+    process.stdin.once("end", closeForClient);
+    process.stdin.once("close", closeForClient);
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+        process.once(signal, () => { void termination.request({ kind: "signal", code: signal === "SIGINT" ? 130 : 143 }); });
+    }
+    try {
+        const bootConfig = loadBootConfig();
+        stage = "control_identity";
+        const controlReady = loadControlIdentity(bootConfig.activityDatabasePath, {
+            network: bootConfig.network, chainIdentifier: bootConfig.expectedChainIdentifier,
+            walletConnectProjectId: WALLETCONNECT_PROJECT_ID,
+            grpcOverride: process.env.SUI_GRPC_URL ?? null, graphqlOverride: process.env.SUI_GRAPHQL_URL ?? null
+        });
+        void controlReady.catch(() => { });
+        // The SDK owns stdin from the start, including fragmented initialization
+        // and EOF while backend startup is pending. No second reader buffers bytes.
+        stage = "stdio_start";
+        bridge = await startSharedStdio({ stdio, port: bootConfig.reviewPort, control: controlReady, ready: backendReady,
+            onError: (error) => logger.error("MCP transport failed", { error: error.message }) });
+        const protocolClosed = stdio.onclose;
+        stdio.onclose = () => { protocolClosed?.(); closeForClient(); };
+        if (termination.requested) {
+            await bridge.close();
+            return;
+        }
+        stage = "control_identity";
+        const control = await controlReady;
+        if (termination.requested)
+            return;
+        stage = "shared_server_start";
+        shared = await startOrDeferReviewServer((port) => startSharedServer({
+            port, control,
+            createApplication: (instanceId) => createRuntimeApplication(bootConfig, logger, instanceId),
+            onError: (error) => logger.error("shared server request failed", { error: error instanceof Error ? error.message : "unknown error" })
+        }), bootConfig.reviewPort, {
+            probeIdentity: async (port) => {
+                try {
+                    return await probeAuthenticatedServer(port, control);
+                }
+                catch {
+                    return null;
+                }
+            },
+            delay: (ms) => new Promise((resolve) => { const timer = setTimeout(resolve, ms); timer.unref(); }),
+            currentPid: process.pid, serviceName: "sui-mcp", logger,
+            onFailure: (error) => { void termination.request({ kind: "failure", stage: "owner_acquisition", error }); }
+        });
+        if (termination.requested) {
+            await shared.close();
+            return;
+        }
+        ready();
+    }
+    catch (error) {
+        failed(error);
+        await termination.request({ kind: "failure", stage, error });
+    }
+}
+void main();

package/dist/runtime/suiEndpoint.js

@@ -0,0 +1,97 @@
+import { SuiGrpcClient } from "@mysten/sui/grpc";
+import { SuiGraphQLClient } from "@mysten/sui/graphql";
+import { MAX_SUI_GRAPHQL_URL_LENGTH, MAX_SUI_GRPC_URL_LENGTH, SuiEndpointError, parseGraphqlUrl, parseGrpcUrl } from "../core/suiEndpoint.js";
+export { MAX_SUI_GRAPHQL_URL_LENGTH, MAX_SUI_GRPC_URL_LENGTH, SuiEndpointError, parseGraphqlUrl, parseGrpcUrl };
+export const SUI_MAINNET_CHAIN_IDENTIFIER = "4btiuiMPvEENsttpZC7CZ53DruC3MAgfznDbASZ7DR6S";
+export const DEFAULT_SUI_GRPC_URL = "https://fullnode.mainnet.sui.io:443";
+export const DEFAULT_SUI_GRAPHQL_URL = "https://graphql.mainnet.sui.io/graphql";
+export const DEFAULT_SUI_GRPC_ENDPOINT_VERIFY_TIMEOUT_MS = 10_000;
+export const DEFAULT_SUI_GRAPHQL_ENDPOINT_VERIFY_TIMEOUT_MS = 10_000;
+export async function verifyMainnetGrpcEndpoint(input) {
+    const url = parseGrpcUrl(input.url);
+    const expectedChainIdentifier = input.expectedChainIdentifier ?? SUI_MAINNET_CHAIN_IDENTIFIER;
+    const timeoutMs = input.timeoutMs ?? DEFAULT_SUI_GRPC_ENDPOINT_VERIFY_TIMEOUT_MS;
+    const client = new SuiGrpcClient({
+        baseUrl: url,
+        network: "mainnet"
+    });
+    let timeout;
+    try {
+        const chainIdentifier = await Promise.race([
+            client.core.getChainIdentifier().then((result) => result.chainIdentifier),
+            new Promise((_, reject) => {
+                timeout = setTimeout(() => {
+                    reject(new SuiEndpointError("endpoint_timeout", `Sui gRPC endpoint verification timed out after ${timeoutMs}ms`, { timeoutMs, url }));
+                }, timeoutMs);
+            })
+        ]);
+        if (chainIdentifier !== expectedChainIdentifier) {
+            throw new SuiEndpointError("chain_identifier_mismatch", `Sui chain identifier mismatch: expected mainnet, got ${chainIdentifier}`, { expectedChainIdentifier, chainIdentifier, url });
+        }
+        return { client, chainIdentifier };
+    }
+    catch (error) {
+        if (error instanceof SuiEndpointError) {
+            throw error;
+        }
+        throw new SuiEndpointError("endpoint_unreachable", "Could not verify Sui mainnet gRPC endpoint", {
+            error: error instanceof Error ? error.message : String(error),
+            url
+        });
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}
+export async function verifyMainnetGraphqlEndpoint(input) {
+    const url = parseGraphqlUrl(input.url);
+    const expectedChainIdentifier = input.expectedChainIdentifier ?? SUI_MAINNET_CHAIN_IDENTIFIER;
+    const timeoutMs = input.timeoutMs ?? DEFAULT_SUI_GRAPHQL_ENDPOINT_VERIFY_TIMEOUT_MS;
+    const client = new SuiGraphQLClient({
+        url,
+        network: "mainnet",
+        ...(input.fetch ? { fetch: input.fetch } : {})
+    });
+    let timeout;
+    try {
+        const chainIdentifier = await Promise.race([
+            client.query({
+                query: "query SuiMcpChainIdentifier { chainIdentifier }",
+                variables: {}
+            }).then((result) => {
+                const value = result.data?.chainIdentifier;
+                if (typeof value !== "string" || value.length === 0) {
+                    throw new SuiEndpointError("endpoint_unreachable", "Sui GraphQL endpoint did not return chainIdentifier", {
+                        url
+                    });
+                }
+                return value;
+            }),
+            new Promise((_, reject) => {
+                timeout = setTimeout(() => {
+                    reject(new SuiEndpointError("endpoint_timeout", `Sui GraphQL endpoint verification timed out after ${timeoutMs}ms`, { timeoutMs, url }));
+                }, timeoutMs);
+            })
+        ]);
+        if (chainIdentifier !== expectedChainIdentifier) {
+            throw new SuiEndpointError("chain_identifier_mismatch", `Sui chain identifier mismatch: expected mainnet, got ${chainIdentifier}`, { expectedChainIdentifier, chainIdentifier, url });
+        }
+        return { client, chainIdentifier };
+    }
+    catch (error) {
+        if (error instanceof SuiEndpointError) {
+            throw error;
+        }
+        throw new SuiEndpointError("endpoint_unreachable", "Could not verify Sui mainnet GraphQL endpoint", {
+            error: error instanceof Error ? error.message : String(error),
+            url
+        });
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}