@zktx.io/sui-mcp 0.5.0

package/dist/core/read/deepbookReadHelpers.js

@@ -0,0 +1,321 @@
+import { formatRawAmount, normalizeCoinType, parseDisplayAmountToRaw } from "./coinMetadata.js";
+import { MAX_RAW_U64, parseRawU64 } from "../numeric/rawU64.js";
+import { parseSuiAddress } from "../suiAddress.js";
+import { DEEPBOOK_OFFICIAL_INDEXER_CANONICAL_USDC_COIN_TYPE, DEEPBOOK_OFFICIAL_INDEXER_PRICE_CONVENTION } from "./deepbookOfficialIndexerSource.js";
+import { DEEPBOOK_OFFICIAL_INDEXER_CANDLE_USE, DEEPBOOK_OFFICIAL_INDEXER_RESPONSE_TEXT, DEEPBOOK_SDK_SIMULATION_SOURCE_BASE } from "./deepbookSourceOwners.js";
+import { DEEPBOOK_ACCOUNT_QUANTITY_KIND, DEEPBOOK_MID_PRICE_SEMANTICS_KIND, DEEPBOOK_QUOTE_QUANTITY_KIND, DEEPBOOK_USDC_PRICE_HISTORY_QUANTITY_KIND, DEEPBOOK_USDC_PRICE_HISTORY_UNSUPPORTED_CLAIMS, ReadServiceInputError } from "./readServiceTypes.js";
+export const MAX_DEEPBOOK_QUOTE_RAW_AMOUNT = MAX_RAW_U64;
+export function parseDeepbookRawU64(value, field, options = {}) {
+    return parseRawU64(value, field, options);
+}
+export function deepbookDisplayQuantitySemantics() {
+    return {
+        kind: DEEPBOOK_ACCOUNT_QUANTITY_KIND,
+        rawAmountAvailable: false,
+        notFor: ["signing", "funding", "route_liquidity", "withdrawal_readiness", "transaction_building"]
+    };
+}
+export function deepbookMidPriceSemantics() {
+    return {
+        kind: DEEPBOOK_MID_PRICE_SEMANTICS_KIND,
+        allowedUse: "deepbook_pool_mid_price_snapshot",
+        globalMarketPriceAvailable: false,
+        fiatUsdCashOutAvailable: false,
+        externalMarketPriceConversionAvailable: false,
+        externalMarketLookupAvailable: false,
+        usdPegAssumptionAvailable: false,
+        bankCashOutEstimateAvailable: false,
+        quoteComparisonAvailable: false,
+        priceImpactAvailable: false,
+        venueComparisonAvailable: false,
+        routeRecommendationAvailable: false,
+        profitAndLossAvailable: false,
+        costBasisAvailable: false,
+        notFor: [
+            "global_market_price",
+            "fiat_usd_cash_out",
+            "external_market_price_conversion",
+            "external_market_lookup",
+            "usd_peg_assumption",
+            "bank_cash_out_estimate",
+            "price_impact",
+            "mid_price_slippage",
+            "quote_vs_mid_slippage",
+            "effective_quote_price",
+            "venue_comparison",
+            "best_route",
+            "route_recommendation",
+            "transaction_building",
+            "signing_data",
+            "signing_readiness",
+            "profit_or_pnl",
+            "cost_basis"
+        ]
+    };
+}
+export function deepbookQuoteQuantitySemantics(inputAmountKind) {
+    return {
+        kind: DEEPBOOK_QUOTE_QUANTITY_KIND,
+        inputAmountKind,
+        allowedUse: "indicative_deepbook_pool_quote",
+        rawAmountAvailable: true,
+        rawEvidenceField: "rawQuote",
+        paymentCoverageAvailable: false,
+        shortfallContributionAvailable: false,
+        routeDependentPaymentSupportAvailable: false,
+        requiresIntentEvidenceForCoverage: true,
+        canUseForPaymentAnswer: false,
+        canUseForShortfallAnswer: false,
+        doNotCombineWithPaymentAnswer: true,
+        requiredPaymentAnswerTool: "read.preview_intent_evidence",
+        paymentAnswerUseBlockedReason: "quote_output_is_price_reference_not_payment_answer",
+        requiredPaymentAnswerField: "responseSummary",
+        fiatUsdCashOutAvailable: false,
+        externalMarketPriceConversionAvailable: false,
+        externalMarketLookupAvailable: false,
+        usdPegAssumptionAvailable: false,
+        bankCashOutEstimateAvailable: false,
+        profitAndLossAvailable: false,
+        costBasisAvailable: false,
+        priceImpactAvailable: false,
+        midPriceSlippageAvailable: false,
+        venueComparisonAvailable: false,
+        routeRecommendationAvailable: false,
+        notFor: [
+            "signing",
+            "funding",
+            "payment_coverage",
+            "shortfall_contribution",
+            "route_dependent_payment_support",
+            "route_liquidity",
+            "min_out",
+            "liquidity_verdict",
+            "price_impact",
+            "mid_price_slippage",
+            "quote_vs_mid_slippage",
+            "effective_price",
+            "venue_comparison",
+            "best_route",
+            "route_recommendation",
+            "transaction_building",
+            "fiat_usd_cash_out",
+            "external_market_price_conversion",
+            "external_market_lookup",
+            "usd_peg_assumption",
+            "bank_cash_out_estimate",
+            "profit_or_pnl",
+            "cost_basis"
+        ]
+    };
+}
+export function deepbookUsdcPriceHistoryQuantitySemantics() {
+    return {
+        kind: DEEPBOOK_USDC_PRICE_HISTORY_QUANTITY_KIND,
+        ...DEEPBOOK_OFFICIAL_INDEXER_CANDLE_USE,
+        liveQuoteAvailable: false,
+        historicalMidPriceAvailable: false,
+        globalMarketPriceAvailable: false,
+        fiatUsdCashOutAvailable: false,
+        routeRecommendationAvailable: false,
+        transactionBuildingAvailable: false,
+        signingReadinessAvailable: false,
+        profitAndLossAvailable: false,
+        costBasisAvailable: false,
+        notFor: [
+            "fiat_usd_cash_out",
+            "usd_peg_assumption",
+            "global_market_price",
+            "historical_mid_price",
+            "live_quote",
+            "route_recommendation",
+            "best_route",
+            "transaction_building",
+            "signing_data",
+            "signing_readiness",
+            "profit_or_pnl",
+            "cost_basis"
+        ]
+    };
+}
+export function deepbookUsdcPriceHistoryResponseSummary() {
+    return {
+        questionKind: "deepbook_usdc_price_history",
+        evidenceKind: "official_deepbook_indexer_candles",
+        sourceStatement: DEEPBOOK_OFFICIAL_INDEXER_RESPONSE_TEXT.sourceStatement,
+        usdcDisclaimer: DEEPBOOK_OFFICIAL_INDEXER_RESPONSE_TEXT.usdcDisclaimer,
+        candleMeaning: "Each candle is returned by the DeepBookV3 official Indexer for the requested interval.",
+        excludedFromConclusion: [...DEEPBOOK_USDC_PRICE_HISTORY_UNSUPPORTED_CLAIMS]
+    };
+}
+export function deepbookUsdcPriceHistoryPairFromOfficialPool(pool) {
+    return {
+        poolName: pool.pool_name,
+        poolId: pool.pool_id,
+        baseAsset: {
+            symbol: pool.base_asset_symbol,
+            coinType: normalizeCoinType(pool.base_asset_id),
+            decimals: pool.base_asset_decimals
+        },
+        quoteAsset: {
+            symbol: "USDC",
+            coinType: normalizeCoinType(DEEPBOOK_OFFICIAL_INDEXER_CANONICAL_USDC_COIN_TYPE),
+            decimals: pool.quote_asset_decimals
+        },
+        priceConvention: DEEPBOOK_OFFICIAL_INDEXER_PRICE_CONVENTION
+    };
+}
+export function deepbookAccountInventorySource(methods) {
+    return {
+        ...DEEPBOOK_SDK_SIMULATION_SOURCE_BASE,
+        methods
+    };
+}
+export function normalizeOptionalManagerAddress(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const normalized = parseSuiAddress(value);
+    if (normalized === undefined) {
+        throw new ReadServiceInputError("input_invalid", "managerAddress must be a valid Sui address", {
+            field: "managerAddress",
+            value
+        });
+    }
+    return normalized;
+}
+export function normalizeManagerAddresses(values) {
+    return values.map((value) => {
+        const normalized = parseSuiAddress(value);
+        if (normalized === undefined) {
+            throw new Error("DeepBook BalanceManager ID was not a valid Sui address");
+        }
+        return normalized;
+    });
+}
+// Account inventory v1 exposes only ledger and rebate balances; governance,
+// stake, volume, and AccountInfo.open_orders need separate review before export.
+export function toDeepbookAccountSummary(accountInfo) {
+    return {
+        epoch: accountInfo.epoch,
+        settledBalances: assertDeepbookDisplayBalances(accountInfo.settled_balances, "accountSummary.settledBalances"),
+        owedBalances: assertDeepbookDisplayBalances(accountInfo.owed_balances, "accountSummary.owedBalances"),
+        unclaimedRebates: assertDeepbookDisplayBalances(accountInfo.unclaimed_rebates, "accountSummary.unclaimedRebates")
+    };
+}
+export function assertDeepbookDisplayBalances(balances, field) {
+    assertDeepbookDisplayNumber(balances.base, `${field}.base`);
+    assertDeepbookDisplayNumber(balances.quote, `${field}.quote`);
+    assertDeepbookDisplayNumber(balances.deep, `${field}.deep`);
+    return balances;
+}
+export function parseQuoteDisplayAmount(displayAmount, decimals) {
+    let rawAmount;
+    try {
+        rawAmount = parseDisplayAmountToRaw(displayAmount, decimals);
+    }
+    catch (error) {
+        throw new ReadServiceInputError("input_invalid", "amountDisplay must be a positive unsigned decimal string within verified decimals", {
+            field: "amountDisplay",
+            value: displayAmount,
+            decimals,
+            reason: error instanceof Error ? error.message : "unknown"
+        });
+    }
+    if (!/^[1-9]\d*$/.test(rawAmount)) {
+        throw new ReadServiceInputError("input_invalid", "amountDisplay must convert to a positive raw integer amount", {
+            field: "amountDisplay",
+            value: displayAmount,
+            decimals,
+            rawAmount
+        });
+    }
+    if (BigInt(rawAmount) > MAX_DEEPBOOK_QUOTE_RAW_AMOUNT) {
+        throw new ReadServiceInputError("input_invalid", "amountDisplay must convert to a raw integer amount that fits the DeepBook u64 quote input", {
+            field: "amountDisplay",
+            value: displayAmount,
+            decimals,
+            rawAmount,
+            maxRawAmount: MAX_DEEPBOOK_QUOTE_RAW_AMOUNT.toString()
+        });
+    }
+    return rawAmount;
+}
+export function parseRawAmount(value) {
+    try {
+        return parseDeepbookRawU64(value, "amountRaw", { positive: true });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "amountRaw is invalid";
+        if (reason === "amountRaw must fit u64") {
+            throw new ReadServiceInputError("input_invalid", "amountRaw must fit the DeepBook u64 quote input", {
+                field: "amountRaw",
+                value,
+                maxRawAmount: MAX_DEEPBOOK_QUOTE_RAW_AMOUNT.toString()
+            });
+        }
+        throw new ReadServiceInputError("input_invalid", "amountRaw must be a positive integer string", {
+            field: "amountRaw",
+            value
+        });
+    }
+}
+export function assertValidDeepbookMidPrice(poolKey, midPrice) {
+    if (!Number.isFinite(midPrice) || midPrice <= 0) {
+        throw new ReadServiceInputError("quote_unavailable", "DeepBook mid price is unavailable for this pool", {
+            poolKey,
+            source: "midPrice"
+        });
+    }
+    return midPrice;
+}
+export function assertValidDeepbookQuote(poolKey, direction, quote) {
+    for (const [field, value] of Object.entries(quote)) {
+        if (typeof value !== "string" || !/^\d+(?:\.\d+)?$/.test(value)) {
+            throw new ReadServiceInputError("quote_unavailable", "DeepBook quote display amount is unavailable", {
+                poolKey,
+                direction,
+                field
+            });
+        }
+    }
+    return quote;
+}
+export function toDeepbookDisplayQuoteFromRaw(quote, units) {
+    return {
+        baseOut: rawToDeepbookDisplayAmount(quote.baseOutRaw, units.baseDecimals),
+        quoteOut: rawToDeepbookDisplayAmount(quote.quoteOutRaw, units.quoteDecimals),
+        deepRequired: rawToDeepbookDisplayAmount(quote.deepRequiredRaw, units.deepDecimals)
+    };
+}
+export function assertPositiveInteger(value, field, max) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new ReadServiceInputError("input_invalid", `${field} must be a positive integer`, {
+            field,
+            value
+        });
+    }
+    if (max !== undefined && value > max) {
+        throw new ReadServiceInputError("input_invalid", `${field} must be less than or equal to ${max}`, {
+            field,
+            value,
+            max
+        });
+    }
+}
+function assertDeepbookDisplayNumber(value, field) {
+    if (!Number.isFinite(value)) {
+        throw new Error(`DeepBook account inventory display number is unavailable for ${field}`);
+    }
+}
+function rawToDeepbookDisplayAmount(raw, decimals) {
+    try {
+        return formatRawAmount(raw, decimals);
+    }
+    catch (error) {
+        throw new ReadServiceInputError("quote_unavailable", "DeepBook raw quote return value cannot be displayed", {
+            raw,
+            decimals,
+            reason: error instanceof Error ? error.message : "unknown"
+        });
+    }
+}

package/dist/core/read/deepbookRegistry.js

@@ -0,0 +1,157 @@
+import { mainnetCoins, mainnetPools } from "@mysten/deepbook-v3";
+import { DEEPBOOK_SCALAR_UNIT_SOURCE, decimalsFromScalar, normalizeCoinType } from "./coinMetadata.js";
+import { ReadServiceInputError } from "./readServiceTypes.js";
+export const PINNED_DEEPBOOK_COINS = mainnetCoins;
+// Curated DeepBook USDC chart pairs: the meaningful Sui-ecosystem base tokens worth
+// featuring against USDC, in display order. This is a deliberate editorial allowlist
+// — NOT a dynamic volume cut — so the chart shows a stable, hand-picked set and never
+// surfaces the dead/dust pools the indexer also lists (stable-vs-stable, wrapped
+// duplicates, single-trade listings). Each entry is a token judged worth registering
+// on its own merits:
+//   SUI  — Sui L1 gas / native token
+//   DEEP — DeepBook protocol token (this venue's own token)
+//   WAL  — Walrus decentralized storage (Mysten)
+//   NS   — SuiNS name service
+//   IKA  — Ika MPC / dWallet network
+//   XBTC — Bitcoin on Sui
+//   USDT — Tether USD stablecoin
+// Edit this list to change which pairs the chart offers; order here is display order.
+const CURATED_USDC_CHART_BASE_ORDER = new Map(["SUI", "DEEP", "WAL", "NS", "IKA", "XBTC", "USDT"].map((symbol, index) => [symbol, index]));
+// Filter the chart pool list to the curated base tokens (by symbol) in curated
+// display order. Matching is by base SYMBOL because the indexer's pool name can
+// differ from the SDK pool key (e.g. BWETH_USDC vs BETH_USDC).
+export function curateUsdcChartPools(pools) {
+    return pools
+        .filter((pool) => CURATED_USDC_CHART_BASE_ORDER.has(pool.baseAsset.symbol))
+        .sort((left, right) => (CURATED_USDC_CHART_BASE_ORDER.get(left.baseAsset.symbol) ?? 0) -
+        (CURATED_USDC_CHART_BASE_ORDER.get(right.baseAsset.symbol) ?? 0));
+}
+export function listDeepbookTokenRegistry(coins = PINNED_DEEPBOOK_COINS) {
+    assertDeepbookScalars(coins);
+    const poolKeysBySymbol = new Map();
+    for (const [poolKey, pool] of Object.entries(mainnetPools)) {
+        for (const symbol of [pool.baseCoin, pool.quoteCoin]) {
+            const current = poolKeysBySymbol.get(symbol) ?? [];
+            current.push(poolKey);
+            poolKeysBySymbol.set(symbol, current);
+        }
+    }
+    return Object.entries(coins)
+        .map(([symbol, coin]) => toDeepbookTokenRegistryEntry(symbol, coin, (poolKeysBySymbol.get(symbol) ?? []).sort()))
+        .sort((left, right) => left.symbol.localeCompare(right.symbol));
+}
+export function deepbookUnitForCoinType(coinType, coins) {
+    const entry = findDeepbookCoinEntry(coinType, coins);
+    if (!entry) {
+        return undefined;
+    }
+    const decimals = decimalsFromScalar(entry.coin.scalar);
+    if (decimals === undefined) {
+        throw invalidDeepbookScalar(entry.symbol, entry.coin.scalar);
+    }
+    return { decimals, symbol: entry.symbol, name: entry.symbol };
+}
+export function findDeepbookCoinEntry(normalizedCoinType, coins) {
+    // Validate the whole pinned token unit registry before using any DeepBook
+    // coin match so one bad scalar cannot make the registry look partially trustworthy.
+    assertDeepbookScalars(coins);
+    for (const [symbol, coin] of Object.entries(coins)) {
+        if (normalizeCoinType(coin.type) === normalizedCoinType) {
+            return { symbol, coin };
+        }
+    }
+    return undefined;
+}
+export function getDeepbookCoinEntryBySymbol(symbol, coins) {
+    assertDeepbookScalars(coins);
+    const coin = coins[symbol];
+    if (!coin) {
+        throw new ReadServiceInputError("registry_miss", "DeepBook pool coin is missing from the pinned token registry", {
+            symbol
+        });
+    }
+    return { symbol, coin };
+}
+export function canonicalDeepbookSymbol(symbol, coins = PINNED_DEEPBOOK_COINS) {
+    const trimmed = symbol.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const matches = Object.keys(coins).filter((candidate) => candidate.toLowerCase() === trimmed.toLowerCase());
+    return matches.length === 1 ? matches[0] : undefined;
+}
+export function getKnownPool(poolKey) {
+    const pool = mainnetPools[poolKey];
+    if (!pool) {
+        throw new ReadServiceInputError("registry_miss", "Unknown DeepBook mainnet pool key", { poolKey });
+    }
+    return pool;
+}
+export function resolveDeepbookPoolForSymbols(input) {
+    const matches = [];
+    for (const [poolKey, pool] of Object.entries(mainnetPools)) {
+        if (pool.baseCoin === input.sourceSymbol && pool.quoteCoin === input.targetSymbol) {
+            matches.push({
+                poolKey,
+                pool,
+                direction: "base_to_quote",
+                sourceSymbol: input.sourceSymbol,
+                targetSymbol: input.targetSymbol
+            });
+        }
+        if (pool.quoteCoin === input.sourceSymbol && pool.baseCoin === input.targetSymbol) {
+            matches.push({
+                poolKey,
+                pool,
+                direction: "quote_to_base",
+                sourceSymbol: input.sourceSymbol,
+                targetSymbol: input.targetSymbol
+            });
+        }
+    }
+    if (matches.length === 1) {
+        return matches[0];
+    }
+    if (matches.length > 1) {
+        throw new ReadServiceInputError("registry_miss", "DeepBook symbol pair resolves to multiple mainnet pools", {
+            sourceSymbol: input.sourceSymbol,
+            targetSymbol: input.targetSymbol,
+            poolKeys: matches.map((match) => match.poolKey)
+        });
+    }
+    throw new ReadServiceInputError("registry_miss", "DeepBook symbol pair is not a known direct mainnet pool", {
+        sourceSymbol: input.sourceSymbol,
+        targetSymbol: input.targetSymbol
+    });
+}
+export function invalidDeepbookScalar(symbol, scalar) {
+    return new ReadServiceInputError("registry_miss", "DeepBook token scalar is not a power of ten", {
+        symbol,
+        scalar
+    });
+}
+function toDeepbookTokenRegistryEntry(symbol, coin, poolKeys) {
+    const decimals = decimalsFromScalar(coin.scalar);
+    if (decimals === undefined) {
+        throw invalidDeepbookScalar(symbol, coin.scalar);
+    }
+    return {
+        symbol,
+        address: coin.address,
+        type: coin.type,
+        scalar: coin.scalar,
+        decimals,
+        unitSource: DEEPBOOK_SCALAR_UNIT_SOURCE,
+        ...(coin.feed === undefined ? {} : { feed: coin.feed }),
+        ...(coin.currencyId === undefined ? {} : { currencyId: coin.currencyId }),
+        ...(coin.priceInfoObjectId === undefined ? {} : { priceInfoObjectId: coin.priceInfoObjectId }),
+        poolKeys
+    };
+}
+function assertDeepbookScalars(coins) {
+    for (const [symbol, coin] of Object.entries(coins)) {
+        if (decimalsFromScalar(coin.scalar) === undefined) {
+            throw invalidDeepbookScalar(symbol, coin.scalar);
+        }
+    }
+}

package/dist/core/read/deepbookSourceOwners.js

@@ -0,0 +1,159 @@
+import { DEEPBOOK_OFFICIAL_INDEXER_PRICE_CONVENTION, DEEPBOOK_OFFICIAL_INDEXER_SOURCE_STATEMENT } from "./deepbookOfficialIndexerSource.js";
+import { DEEPBOOK_SCALAR_UNIT_SOURCE } from "./coinMetadata.js";
+export const DEEPBOOK_SOURCE_OWNER_GROUPS = {
+    pinnedSdkMetadata: {
+        label: "pinned DeepBook SDK metadata",
+        owns: ["token metadata", "pool metadata", "scalar metadata", "symbol metadata", "package metadata"]
+    },
+    sdkSimulation: {
+        label: "DeepBook SDK simulation through Sui gRPC",
+        owns: ["orderbook snapshots", "mid-price snapshots", "raw quote evidence", "display quote evidence", "account inventory"]
+    },
+    directSuiGrpcAndLocalMaterial: {
+        label: "direct Sui gRPC plus local material stores",
+        owns: ["wallet balances", "object facts", "transaction material", "review-time simulation", "receipt reads"]
+    },
+    officialIndexerRest: {
+        label: "DeepBookV3 official Indexer REST",
+        owns: ["USDC-quoted candle history", "price-at-time candles", "chart candles", "account-timeline USDC candle references"]
+    },
+    localTransactionActivity: {
+        label: "local SQLite transaction activity plus local protocol rules",
+        owns: ["account net-flow bars", "protocolMatches"]
+    },
+    guidanceOnly: {
+        label: "guidance and test enforcement only",
+        owns: ["runtime source wording", "unsupported-use wording", "source-policy tests"]
+    }
+};
+export const DEEPBOOK_ANSWER_USE = {
+    officialUsdcCandleHistory: "official_deepbook_usdc_candle_history",
+    officialCandleAvailabilityForRequestedUtcRange: "official_candle_availability_for_the_requested_utc_range",
+    officialUsdcCandleForRequestedTime: "official_deepbook_usdc_candle_for_requested_time",
+    representativeClosePriceForMatchedCandle: "representative_close_price_for_the_matched_candle"
+};
+export const DEEPBOOK_SOURCE_FIELD_VALUES = {
+    officialIndexer: "deepbook_v3_official_indexer",
+    sdkMainnetPackageId: "deepbook_v3_sdk_mainnet_package_id",
+    pinnedSdkWhenTargetAssetSelected: "pinned_deepbook_sdk_when_target_asset_selected"
+};
+export const DEEPBOOK_SDK_SIMULATION_SOURCE_BASE = {
+    sdk: "@mysten/deepbook-v3",
+    transport: "grpc",
+    simulation: "client.core.simulateTransaction"
+};
+export const DEEPBOOK_PINNED_SDK_METADATA_SOURCE = {
+    sdk: "@mysten/deepbook-v3",
+    registry: ["mainnetCoins", "mainnetPools"],
+    network: "mainnet",
+    unitSource: DEEPBOOK_SCALAR_UNIT_SOURCE
+};
+export const DEEPBOOK_OFFICIAL_INDEXER_SOURCE_BASE = {
+    kind: DEEPBOOK_SOURCE_FIELD_VALUES.officialIndexer,
+    chainRecomputedBySuiMcp: false
+};
+export const DEEPBOOK_OFFICIAL_INDEXER_USDC_REFERENCE = {
+    quoteAsset: "USDC",
+    priceConvention: DEEPBOOK_OFFICIAL_INDEXER_PRICE_CONVENTION,
+    usdcIsFiatUsd: false,
+    usdPegGuaranteeAvailable: false
+};
+export const DEEPBOOK_OFFICIAL_INDEXER_CANDLE_USE = {
+    allowedUse: DEEPBOOK_ANSWER_USE.officialUsdcCandleHistory,
+    source: DEEPBOOK_OFFICIAL_INDEXER_SOURCE_BASE.kind,
+    ...DEEPBOOK_OFFICIAL_INDEXER_USDC_REFERENCE,
+    chainRecomputedBySuiMcp: DEEPBOOK_OFFICIAL_INDEXER_SOURCE_BASE.chainRecomputedBySuiMcp
+};
+export const DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING = {
+    officialIndexerCandleData: "DeepBookV3 official Indexer candle data",
+    officialIndexerCandleReferences: "DeepBookV3 official Indexer candle references",
+    officialIndexerUsdcDenominatedCandles: "DeepBookV3 official Indexer USDC-denominated candles",
+    pinnedSdkSnapshots: "pinned-SDK snapshots",
+    usdcNotFiatUsdAndNotPeg: "not fiat USD and not a USDC/USD peg guarantee"
+};
+export const DEEPBOOK_OFFICIAL_INDEXER_RESPONSE_TEXT = {
+    sourceStatement: DEEPBOOK_OFFICIAL_INDEXER_SOURCE_STATEMENT,
+    usdcDisclaimer: `USDC is a token-denominated reference asset here, ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.usdcNotFiatUsdAndNotPeg}.`
+};
+export const DEEPBOOK_READ_RESPONSE_UNSUPPORTED = {
+    orderbook: [
+        "live_orderbook_stream",
+        "global_market_price",
+        "indicative_quote_for_a_source_amount",
+        "payment_coverage_or_shortfall",
+        "liquidity_verdict",
+        "price_impact",
+        "venue_comparison",
+        "route_recommendation",
+        "transaction_building",
+        "signing_data_or_readiness",
+        "profit_or_pnl"
+    ],
+    midPrice: [
+        "global_market_price",
+        "fiat_usd_cash_out",
+        "external_market_price_conversion",
+        "usd_peg_assumption",
+        "payment_coverage_or_shortfall",
+        "price_impact",
+        "quote_slippage",
+        "venue_comparison",
+        "route_recommendation",
+        "transaction_building",
+        "signing_data_or_readiness",
+        "profit_or_pnl",
+        "cost_basis"
+    ],
+    officialUsdcCandles: [
+        "fiat_usd_cash_out",
+        "usd_peg_assumption",
+        "global_market_price",
+        "historical_mid_price",
+        "live_quote",
+        "route_recommendation",
+        "best_route",
+        "transaction_building",
+        "signing_data_or_readiness",
+        "profit_or_pnl",
+        "cost_basis"
+    ],
+    quote: [
+        "payment_coverage",
+        "payment_shortfall",
+        "funding_source",
+        "route_dependent_payment_support",
+        "final_min_out",
+        "liquidity_verdict",
+        "price_impact",
+        "quote_vs_mid_slippage",
+        "effective_price",
+        "venue_comparison",
+        "route_recommendation",
+        "fiat_usd_cash_out",
+        "external_market_price_conversion",
+        "usd_peg_assumption",
+        "transaction_building",
+        "signing_data_or_readiness",
+        "profit_or_pnl",
+        "cost_basis"
+    ],
+    accountInventory: [
+        "current_wallet_coin_balance",
+        "wallet_transaction_history",
+        "funding_source",
+        "route_liquidity",
+        "withdrawal_readiness",
+        "payment_coverage_or_shortfall",
+        "transaction_building",
+        "signing_data_or_readiness",
+        "profit_or_pnl",
+        "cost_basis"
+    ],
+    protocolMatches: [
+        "market_data",
+        "route_support",
+        "inventory_evidence",
+        "signing_readiness",
+        "official_indexer_replacement_evidence"
+    ]
+};