@zktx.io/sui-mcp 0.5.0

package/dist/core/read/deepbookUsdcChartService.js

@@ -0,0 +1,342 @@
+import { DEFAULT_DEEPBOOK_OFFICIAL_INDEXER_INTERVAL, DEEPBOOK_OFFICIAL_INDEXER_INTERVALS, DeepbookOfficialIndexerSource, DeepbookOfficialIndexerSourceError, parseDeepbookOfficialIndexerInterval, selectDeepbookOfficialIndexerCanonicalUsdcPools } from "./deepbookOfficialIndexerSource.js";
+import { deepbookUsdcPriceHistoryPairFromOfficialPool, deepbookUsdcPriceHistoryQuantitySemantics, deepbookUsdcPriceHistoryResponseSummary } from "./deepbookReadHelpers.js";
+import { curateUsdcChartPools } from "./deepbookRegistry.js";
+import { DEEPBOOK_USDC_PRICE_HISTORY_UNSUPPORTED_CLAIMS } from "./readServiceTypes.js";
+export const DEEPBOOK_USDC_CHART_DEFAULT_LIMIT = 500;
+export const DEEPBOOK_USDC_CHART_MAX_CANDLES = 10_000;
+export const DEEPBOOK_USDC_CHART_CACHE_TTL_MS = 5 * 60 * 1000;
+export const DEEPBOOK_USDC_CHART_CANDLE_CACHE_SIZE = 256;
+const ALLOWED_CANDLE_QUERY_FIELDS = new Set(["poolName", "interval", "startTimeMs", "endTimeMs", "limit"]);
+export function createDeepbookUsdcChartService(options = {}) {
+    const source = options.source ?? new DeepbookOfficialIndexerSource();
+    const now = options.now ?? (() => new Date());
+    const cacheTtlMs = options.cacheTtlMs ?? DEEPBOOK_USDC_CHART_CACHE_TTL_MS;
+    const maxCandleCacheEntries = options.maxCandleCacheEntries ?? DEEPBOOK_USDC_CHART_CANDLE_CACHE_SIZE;
+    let poolCache;
+    const candleCache = new Map();
+    async function getPools(searchParams = new URLSearchParams()) {
+        const unsupportedField = firstUnsupportedField(searchParams, new Set());
+        if (unsupportedField) {
+            return {
+                status: "unsupported_input",
+                reason: "unsupported_query_field",
+                field: unsupportedField,
+                ...chartCommonFields()
+            };
+        }
+        let poolResult;
+        try {
+            poolResult = await fetchPoolsCached();
+        }
+        catch (error) {
+            return {
+                status: "source_unavailable",
+                reason: chartSourceUnavailableReason(error),
+                ...chartCommonFields()
+            };
+        }
+        // Curate to the hand-picked allowlist of meaningful pairs (SUI/USDC, DEEP/USDC,
+        // …), in display order; the indexer's dead/dust pools never appear.
+        const pools = curateUsdcChartPools(selectDeepbookOfficialIndexerCanonicalUsdcPools(poolResult.pools).map(deepbookUsdcPriceHistoryPairFromOfficialPool));
+        return {
+            status: "ok",
+            poolCount: pools.length,
+            pools,
+            intervals: DEEPBOOK_OFFICIAL_INDEXER_INTERVALS,
+            defaultInterval: DEFAULT_DEEPBOOK_OFFICIAL_INDEXER_INTERVAL,
+            defaultLimit: DEEPBOOK_USDC_CHART_DEFAULT_LIMIT,
+            maxCandles: DEEPBOOK_USDC_CHART_MAX_CANDLES,
+            source: poolResult.source,
+            ...chartCommonFields()
+        };
+    }
+    async function getCandles(searchParams) {
+        const parsed = parseCandlesQuery(searchParams);
+        if (parsed.status !== "ok") {
+            return parsed.body;
+        }
+        let poolResult;
+        try {
+            poolResult = await fetchPoolsCached();
+        }
+        catch (error) {
+            return {
+                status: "source_unavailable",
+                reason: chartSourceUnavailableReason(error),
+                query: parsed.query,
+                ...chartCommonFields()
+            };
+        }
+        const pools = selectDeepbookOfficialIndexerCanonicalUsdcPools(poolResult.pools);
+        const pool = pools.find((candidate) => candidate.pool_name === parsed.query.poolName);
+        if (pool === undefined) {
+            return {
+                status: "unsupported_pool",
+                reason: "pool_not_in_official_usdc_pools",
+                query: parsed.query,
+                availablePoolNames: pools.map((candidate) => candidate.pool_name),
+                source: poolResult.source,
+                ...chartCommonFields()
+            };
+        }
+        const pair = deepbookUsdcPriceHistoryPairFromOfficialPool(pool);
+        let candleResult;
+        try {
+            candleResult = await fetchCandlesCached(parsed.query);
+        }
+        catch (error) {
+            return {
+                status: "source_unavailable",
+                reason: chartSourceUnavailableReason(error),
+                query: parsed.query,
+                pair,
+                source: poolResult.source,
+                ...chartCommonFields()
+            };
+        }
+        if (candleResult.candles.length === 0) {
+            return {
+                status: "empty_result",
+                query: parsed.query,
+                pair,
+                candleCount: 0,
+                candles: [],
+                source: candleResult.source,
+                ...chartCommonFields()
+            };
+        }
+        return {
+            status: "ok",
+            query: parsed.query,
+            pair,
+            candleCount: candleResult.candles.length,
+            candles: candleResult.candles,
+            source: candleResult.source,
+            ...chartCommonFields()
+        };
+    }
+    async function fetchPoolsCached() {
+        const currentTime = now().getTime();
+        if (poolCache !== undefined && poolCache.expiresAtMs > currentTime) {
+            return poolCache.value;
+        }
+        const value = await source.fetchPools();
+        options.assertCurrent?.();
+        poolCache = { expiresAtMs: currentTime + cacheTtlMs, value };
+        return value;
+    }
+    async function fetchCandlesCached(query) {
+        const key = JSON.stringify(query);
+        const currentTime = now().getTime();
+        const cached = candleCache.get(key);
+        if (cached !== undefined && cached.expiresAtMs > currentTime) {
+            candleCache.delete(key);
+            options.assertCurrent?.();
+            candleCache.set(key, cached);
+            return cached.value;
+        }
+        const value = await source.fetchCandles(query);
+        options.assertCurrent?.();
+        candleCache.set(key, { expiresAtMs: currentTime + cacheTtlMs, value });
+        while (candleCache.size > maxCandleCacheEntries) {
+            const oldestKey = candleCache.keys().next().value;
+            if (oldestKey === undefined) {
+                break;
+            }
+            candleCache.delete(oldestKey);
+        }
+        return value;
+    }
+    return { getPools, getCandles, clearCache: () => { poolCache = undefined; candleCache.clear(); } };
+}
+function parseCandlesQuery(searchParams) {
+    const unsupportedField = firstUnsupportedField(searchParams, ALLOWED_CANDLE_QUERY_FIELDS);
+    if (unsupportedField) {
+        return chartQueryError({
+            status: "unsupported_input",
+            reason: "unsupported_query_field",
+            field: unsupportedField,
+            ...chartCommonFields()
+        });
+    }
+    const duplicateField = firstDuplicateField(searchParams);
+    if (duplicateField) {
+        return chartQueryError({
+            status: "unsupported_input",
+            reason: "duplicate_query_field",
+            field: duplicateField,
+            ...chartCommonFields()
+        });
+    }
+    const poolName = searchParams.get("poolName");
+    if (poolName === null || poolName.trim() === "") {
+        return chartQueryError({
+            status: "unsupported_input",
+            reason: "missing_pool_name",
+            field: "poolName",
+            ...chartCommonFields()
+        });
+    }
+    let interval;
+    const intervalText = searchParams.get("interval") ?? DEFAULT_DEEPBOOK_OFFICIAL_INDEXER_INTERVAL;
+    try {
+        interval = parseDeepbookOfficialIndexerInterval(intervalText);
+    }
+    catch (error) {
+        if (error instanceof DeepbookOfficialIndexerSourceError) {
+            return chartQueryError({
+                status: "unsupported_input",
+                reason: "unsupported_interval",
+                field: "interval",
+                ...chartCommonFields()
+            });
+        }
+        throw error;
+    }
+    const startTimeMs = parseOptionalTimestamp(searchParams.get("startTimeMs"), "startTimeMs");
+    if (startTimeMs.status === "error") {
+        return chartQueryError(startTimeMs.body);
+    }
+    const endTimeMs = parseOptionalTimestamp(searchParams.get("endTimeMs"), "endTimeMs");
+    if (endTimeMs.status === "error") {
+        return chartQueryError(endTimeMs.body);
+    }
+    if (startTimeMs.value !== undefined &&
+        endTimeMs.value !== undefined &&
+        startTimeMs.value >= endTimeMs.value) {
+        return chartQueryError({
+            status: "unsupported_input",
+            reason: "invalid_timestamp_window",
+            query: { poolName, interval, startTimeMs: startTimeMs.value, endTimeMs: endTimeMs.value },
+            ...chartCommonFields()
+        });
+    }
+    const limit = parseLimit(searchParams.get("limit"));
+    if (limit.status === "error") {
+        return chartQueryError(limit.body);
+    }
+    return {
+        status: "ok",
+        query: {
+            poolName,
+            interval,
+            ...(startTimeMs.value !== undefined ? { startTimeMs: startTimeMs.value } : {}),
+            ...(endTimeMs.value !== undefined ? { endTimeMs: endTimeMs.value } : {}),
+            limit: limit.value
+        }
+    };
+}
+function parseOptionalTimestamp(value, field) {
+    if (value === null || value === "") {
+        return { status: "ok", value: undefined };
+    }
+    if (!/^(0|[1-9][0-9]*)$/.test(value)) {
+        return {
+            status: "error",
+            body: {
+                status: "unsupported_input",
+                reason: "invalid_timestamp",
+                field,
+                ...chartCommonFields()
+            }
+        };
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        return {
+            status: "error",
+            body: {
+                status: "unsupported_input",
+                reason: "invalid_timestamp",
+                field,
+                ...chartCommonFields()
+            }
+        };
+    }
+    return { status: "ok", value: parsed };
+}
+function parseLimit(value) {
+    if (value === null || value === "") {
+        return { status: "ok", value: DEEPBOOK_USDC_CHART_DEFAULT_LIMIT };
+    }
+    if (!/^[1-9][0-9]*$/.test(value)) {
+        return {
+            status: "error",
+            body: {
+                status: "unsupported_input",
+                reason: "invalid_limit",
+                field: "limit",
+                ...chartCommonFields()
+            }
+        };
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        return {
+            status: "error",
+            body: {
+                status: "unsupported_input",
+                reason: "invalid_limit",
+                field: "limit",
+                ...chartCommonFields()
+            }
+        };
+    }
+    if (parsed > DEEPBOOK_USDC_CHART_MAX_CANDLES) {
+        return {
+            status: "error",
+            body: {
+                status: "over_limit",
+                reason: "limit_exceeds_chart_cap",
+                maxCandles: DEEPBOOK_USDC_CHART_MAX_CANDLES,
+                requestedLimit: parsed,
+                ...chartCommonFields()
+            }
+        };
+    }
+    return { status: "ok", value: parsed };
+}
+function firstUnsupportedField(searchParams, allowed) {
+    for (const key of searchParams.keys()) {
+        if (!allowed.has(key)) {
+            return key;
+        }
+    }
+    return undefined;
+}
+function firstDuplicateField(searchParams) {
+    const seen = new Set();
+    for (const key of searchParams.keys()) {
+        if (seen.has(key)) {
+            return key;
+        }
+        seen.add(key);
+    }
+    return undefined;
+}
+function chartSourceUnavailableReason(error) {
+    if (error instanceof DeepbookOfficialIndexerSourceError) {
+        switch (error.reason) {
+            case "invalid_payload":
+                return "official_indexer_invalid_payload";
+            case "source_timeout":
+                return "source_timeout";
+            case "source_http_error":
+                return "source_http_error";
+            case "invalid_source_url":
+            case "source_unavailable":
+                return "source_unavailable";
+        }
+    }
+    return "source_unavailable";
+}
+function chartCommonFields() {
+    return {
+        responseSummary: deepbookUsdcPriceHistoryResponseSummary(),
+        quantitySemantics: deepbookUsdcPriceHistoryQuantitySemantics(),
+        unsupportedClaims: [...DEEPBOOK_USDC_PRICE_HISTORY_UNSUPPORTED_CLAIMS]
+    };
+}
+function chartQueryError(body) {
+    return { status: "error", body };
+}

package/dist/core/read/intentEvidenceResponseFormatting.js

@@ -0,0 +1,228 @@
+import { INTENT_EVIDENCE_QUANTITY_KIND, INTENT_EVIDENCE_TARGET_ASSET_SELECTION_SOURCES } from "./readServiceTypes.js";
+export function intentEvidenceQuantitySemantics() {
+    return {
+        kind: INTENT_EVIDENCE_QUANTITY_KIND,
+        allowedUse: "pre_transaction_evidence",
+        naturalLanguageIntentEvidence: true,
+        transactionBuildingAvailable: false,
+        signingReadinessAvailable: false,
+        routeRecommendationAvailable: false,
+        fiatUsdCashOutAvailable: false,
+        profitAndLossAvailable: false,
+        costBasisAvailable: false,
+        notFor: [
+            "transaction_building",
+            "signing_data",
+            "signing_readiness",
+            "payment_execution",
+            "best_route",
+            "route_recommendation",
+            "fiat_usd_cash_out",
+            "external_market_price_conversion",
+            "profit_or_pnl",
+            "cost_basis"
+        ]
+    };
+}
+export function isSupportedIntentEvidenceKind(intentKind) {
+    return intentKind === "cover_payment_like_amount" || intentKind === "summarize_settlement_asset_group_balance";
+}
+export function isIntentEvidenceTargetAssetSelectionSource(source) {
+    return INTENT_EVIDENCE_TARGET_ASSET_SELECTION_SOURCES.includes(source);
+}
+export function intentEvidenceSettlementAssetCoverageBoundary() {
+    return [
+        "current_wallet_coin_balance_snapshot",
+        "settlement_asset_assets_only",
+        "not_settlement_token_selection",
+        "not_route_dependent_payment_support",
+        "not_payment_execution_readiness",
+        "not_gas_readiness"
+    ];
+}
+export function intentEvidenceResponseEvidence(targetAsset, settlementAssetCoverage, candidateConversions) {
+    const settlementAssetClaims = intentEvidenceSettlementAssetResponseClaims(settlementAssetCoverage);
+    if (targetAsset === undefined || isIntentEvidenceSettlementAssetCoverageUnavailable(settlementAssetCoverage)) {
+        return {
+            mode: "settlement_asset_only",
+            primaryEvidenceFields: ["responseSummary"],
+            supportedResponseClaims: [...settlementAssetClaims, "required_user_choices", "unsupported_inferences"]
+        };
+    }
+    return {
+        mode: "selected_target_context",
+        primaryEvidenceFields: [
+            "responseSummary",
+            "selectedTarget",
+            "candidateConversions",
+            "requiredUserChoices"
+        ],
+        supportedResponseClaims: [
+            ...settlementAssetClaims,
+            "selected_target_shortfall",
+            ...(candidateConversions.some((candidate) => candidate.status === "quoted")
+                ? ["direct_pool_quote_evidence"]
+                : []),
+            "required_user_choices",
+            "unsupported_inferences"
+        ]
+    };
+}
+function intentEvidenceSettlementAssetResponseClaims(settlementAssetCoverage) {
+    if (settlementAssetCoverage.status === "balance_total_only") {
+        return ["current_settlement_asset_total"];
+    }
+    if (isIntentEvidenceSettlementAssetCoverageUnavailable(settlementAssetCoverage)) {
+        return ["settlement_asset_coverage_unavailable"];
+    }
+    return ["settlement_asset_coverage_status", "settlement_asset_shortfall"];
+}
+export function intentEvidenceSupportedClaims(settlementAssetCoverage, selectedTarget, candidateConversions) {
+    if (isIntentEvidenceSettlementAssetCoverageUnavailable(settlementAssetCoverage)) {
+        return ["settlement_asset_coverage_unavailable"];
+    }
+    const claims = [
+        "current_wallet_usd_settlement_coin_balance_snapshot",
+        "verified_display_amounts_from_pinned_or_onchain_decimals",
+        "settlement_asset_balance_total_when_common_decimals_are_available"
+    ];
+    if (settlementAssetCoverage.status !== "balance_total_only") {
+        claims.push("settlement_asset_shortfall_when_common_decimals_are_available");
+    }
+    if (selectedTarget !== undefined && candidateConversions.some((candidate) => candidate.status === "quoted")) {
+        claims.push("direct_deepbook_pool_and_quote_evidence_when_target_asset_is_selected");
+    }
+    return claims;
+}
+function intentEvidenceAnswerCompleteness(input) {
+    if (isIntentEvidenceSettlementAssetCoverageUnavailable(input.settlementAssetCoverage)) {
+        return {
+            answerCompleteFor: "settlement_asset_coverage_unavailable_answer",
+            requiredAnswerFields: [
+                "responseSummary.unavailableReason",
+                "blockedReasons",
+                "responseSummary.requiredUserChoices"
+            ],
+            notCompleteFor: [
+                "settlement_asset_balance_total",
+                "payment_coverage_status",
+                "payment_shortfall",
+                "selected_target_context",
+                "route_dependent_payment_support",
+                "payment_execution_readiness",
+                "transaction_building",
+                "signing_readiness"
+            ]
+        };
+    }
+    if (input.responseEvidenceMode === "selected_target_context") {
+        return {
+            answerCompleteFor: "selected_target_context_answer",
+            requiredAnswerFields: ["responseSummary", "selectedTarget", "candidateConversions", "requiredUserChoices"],
+            notCompleteFor: [
+                "route_dependent_payment_support",
+                "settlement_token_selection",
+                "payment_execution_readiness",
+                "transaction_building",
+                "signing_readiness"
+            ]
+        };
+    }
+    return {
+        answerCompleteFor: "settlement_asset_group_answer",
+        requiredAnswerFields: ["responseSummary"],
+        notCompleteFor: [
+            "selected_target_context",
+            "route_dependent_payment_support",
+            "settlement_token_selection",
+            "payment_execution_readiness",
+            "transaction_building",
+            "signing_readiness"
+        ]
+    };
+}
+export function isIntentEvidenceSettlementAssetCoverageUnavailable(settlementAssetCoverage) {
+    return (settlementAssetCoverage.status === "unavailable_mixed_decimals" ||
+        settlementAssetCoverage.status === "unavailable_wallet_balance_scan_incomplete");
+}
+export function intentEvidenceResponseSummary(input) {
+    const questionKind = input.intentKind === "cover_payment_like_amount" ? "payment_coverage" : "settlement_asset_group_balance_total";
+    const answerCompleteness = intentEvidenceAnswerCompleteness({
+        settlementAssetCoverage: input.settlementAssetCoverage,
+        responseEvidenceMode: input.responseEvidenceMode
+    });
+    const base = {
+        questionKind,
+        answerCompleteness,
+        doNotCallQuoteToolsForThisQuestion: true,
+        coverageBasis: "settlement_asset_wallet_balance_only",
+        assetGroupId: input.assetGroupId,
+        requiredUserChoices: input.requiredUserChoices,
+        separateQuoteOutputs: {
+            usedForPaymentAnswer: false,
+            usedForShortfallAnswer: false,
+            reason: "separate_quote_tool_outputs_are_price_estimates_only",
+            paymentAnswerField: "responseSummary"
+        },
+        doNotUseForConclusion: [
+            "separate_quote_tool_results",
+            "assets_outside_settlement_group",
+            "route_dependent_payment_support"
+        ],
+        excludedFromConclusion: [
+            "separate_quote_tool_results",
+            "candidate_conversion_quote_evidence",
+            "assets_outside_settlement_group",
+            "settlement_token_selection",
+            "route_dependent_payment_support",
+            "gas_reserve_or_fee_readiness",
+            "payment_execution_readiness",
+            "transaction_building",
+            "signing_readiness",
+            "fiat_usd_cash_out",
+            "profit_or_pnl",
+            "cost_basis"
+        ]
+    };
+    if (input.settlementAssetCoverage.status === "balance_total_only") {
+        return {
+            ...base,
+            conclusionKind: "current_settlement_asset_total",
+            currentDisplayAmount: input.settlementAssetCoverage.currentDisplayAmount,
+            requiredDisplayAmount: null,
+            shortfallDisplayAmount: null,
+            amountsUsedForAnswer: {
+                currentDisplayAmount: "current_wallet_balance_in_settlement_asset_group",
+                requiredDisplayAmount: null,
+                shortfallDisplayAmount: null
+            }
+        };
+    }
+    if (isIntentEvidenceSettlementAssetCoverageUnavailable(input.settlementAssetCoverage)) {
+        return {
+            ...base,
+            conclusionKind: "settlement_asset_coverage_unavailable",
+            currentDisplayAmount: null,
+            requiredDisplayAmount: input.settlementAssetCoverage.requiredDisplayAmount ?? null,
+            shortfallDisplayAmount: null,
+            unavailableReason: input.settlementAssetCoverage.reason,
+            amountsUsedForAnswer: {
+                currentDisplayAmount: null,
+                requiredDisplayAmount: input.settlementAssetCoverage.requiredDisplayAmount === undefined ? null : "amount_requested_by_user",
+                shortfallDisplayAmount: null
+            }
+        };
+    }
+    return {
+        ...base,
+        conclusionKind: input.settlementAssetCoverage.status,
+        currentDisplayAmount: input.settlementAssetCoverage.currentDisplayAmount,
+        requiredDisplayAmount: input.settlementAssetCoverage.requiredDisplayAmount,
+        shortfallDisplayAmount: input.settlementAssetCoverage.shortfallDisplayAmount,
+        amountsUsedForAnswer: {
+            currentDisplayAmount: "current_wallet_balance_in_settlement_asset_group",
+            requiredDisplayAmount: "amount_requested_by_user",
+            shortfallDisplayAmount: "required_amount_minus_current_settlement_asset_balance"
+        }
+    };
+}

package/dist/core/read/readCardInputs.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { suiAddressStringSchema, suiTransactionDigestSchema } from "../suiAddress.js";
+import { DEEPBOOK_OFFICIAL_INDEXER_INTERVALS, DEFAULT_DEEPBOOK_OFFICIAL_INDEXER_INTERVAL } from "./deepbookOfficialIndexerSource.js";
+import { DEEPBOOK_USDC_CHART_DEFAULT_LIMIT, DEEPBOOK_USDC_CHART_MAX_CANDLES } from "./deepbookUsdcChartService.js";
+export const accountInputSchema = z.object({ account: suiAddressStringSchema }).strict();
+export const receiptInputSchema = z.object({ digest: suiTransactionDigestSchema }).strict();
+const chartInputBaseSchema = z.object({
+    poolName: z.string().min(1),
+    interval: z.enum(DEEPBOOK_OFFICIAL_INDEXER_INTERVALS).default(DEFAULT_DEEPBOOK_OFFICIAL_INDEXER_INTERVAL),
+    startTimeMs: z.number().int().nonnegative().optional(),
+    endTimeMs: z.number().int().nonnegative().optional(),
+    limit: z.number().int().min(1).max(DEEPBOOK_USDC_CHART_MAX_CANDLES).default(DEEPBOOK_USDC_CHART_DEFAULT_LIMIT)
+}).strict();
+const validWindow = (value) => value.startTimeMs === undefined || value.endTimeMs === undefined || value.startTimeMs < value.endTimeMs;
+export const chartInputSchema = chartInputBaseSchema.refine(validWindow, "Start must precede end.");
+export const chartOpenInputSchema = chartInputBaseSchema.partial().refine(validWindow, "Start must precede end.");
+export function parseCardInput(kind, input) {
+    return kind === "account" ? accountInputSchema.parse(input) : kind === "receipt" ? receiptInputSchema.parse(input) : chartInputSchema.parse(input);
+}

package/dist/core/read/readCardResult.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { assertNoForbiddenMcpFields } from "../action/forbiddenFields.js";
+import { suiTransactionDigestSchema } from "../suiAddress.js";
+import { receiptDisplaySchema } from "../session/cardSession.js";
+const receiptInput = z.object({
+    index: z.number().int().nonnegative(),
+    kind: z.enum(["object", "shared_object", "receiving", "pure", "withdrawal", "unknown"]),
+    objectId: z.string().optional(), bytes: z.string().optional()
+}).strict();
+const foundReceipt = z.object({ status: z.literal("found"), receipt: z.object({
+        txDigest: suiTransactionDigestSchema,
+        inputs: z.array(receiptInput).refine((items) => new Set(items.map((item) => item.index)).size === items.length),
+        ptbGraph: receiptDisplaySchema.shape.ptbGraph
+    }).passthrough() }).strict();
+// Partition the same source result before persistence. Never weaken the public
+// forbidden-field check or turn arbitrary fields into private metadata.
+export function projectReadCardResult(kind, input, source) {
+    if (kind !== "receipt" || !source || typeof source !== "object" || !("status" in source) || source.status !== "found") {
+        assertNoForbiddenMcpFields(source);
+        return { data: source };
+    }
+    const result = foundReceipt.parse(source);
+    if (result.receipt.txDigest !== input.digest)
+        throw new Error("Receipt digest differs from the selected transaction.");
+    const { inputs, ptbGraph, ...facts } = result.receipt;
+    const pureInputs = [];
+    const publicInputs = inputs.map(({ bytes, ...item }) => {
+        if (bytes !== undefined) {
+            if (item.kind !== "pure")
+                throw new Error("Only a Pure input may contain a display value.");
+            pureInputs.push({ index: item.index, bytes });
+        }
+        return item;
+    });
+    const receiptDisplay = receiptDisplaySchema.parse({ transactionDigest: facts.txDigest, pureInputs, ptbGraph });
+    const data = { status: "found", receipt: { ...facts, inputs: publicInputs },
+        uiDetails: { inputValues: "ui_only", ptbGraph: "ui_only" } };
+    assertNoForbiddenMcpFields(data);
+    return { data, receiptDisplay };
+}