@stelis/say-ur-intent 0.0.0 → 0.0.2

package/dist/core/read/flowxQuoteClient.js

@@ -0,0 +1,117 @@
+import { AggregatorQuoter, Protocol } from "@flowx-finance/sdk";
+import { ReadServiceInputError } from "./readServiceTypes.js";
+/**
+ * Thin wrapper around the FlowX aggregator quoter, restricted to FlowX CLMM
+ * single-hop routes. Normalizes the response into plain data so the read
+ * service can validate it against the pinned registry, and so tests can
+ * inject fakes without the SDK.
+ */
+const FLOWX_QUOTER_MAX_HOPS = 1;
+export function createFlowxQuoteClient() {
+    const quoter = new AggregatorQuoter("mainnet");
+    return {
+        async getSwapRoutes(request) {
+            let result;
+            try {
+                result = await quoter.getRoutes({
+                    tokenIn: request.tokenInType,
+                    tokenOut: request.tokenOutType,
+                    amountIn: request.amountInRaw,
+                    includeSources: [Protocol.FLOWX_V3],
+                    maxHops: FLOWX_QUOTER_MAX_HOPS
+                });
+            }
+            catch (error) {
+                throw new ReadServiceInputError("quote_unavailable", "FlowX quoter request failed", {
+                    reason: error instanceof Error ? error.message : "unknown"
+                });
+            }
+            return normalizeFlowxQuoterResult(result);
+        }
+    };
+}
+/**
+ * Build-grade quote source for the FlowX review adapter: one quoter response
+ * yields both the normalized quote (validated against the pinned registry)
+ * and the SDK route entities the local transaction build consumes.
+ */
+export function createFlowxSwapReviewQuoteSource(options) {
+    const quoter = new AggregatorQuoter("mainnet");
+    const now = options?.now ?? (() => new Date());
+    return {
+        async getSwapRoutesForBuild(request) {
+            let result;
+            try {
+                result = await quoter.getRoutes({
+                    tokenIn: request.tokenInType,
+                    tokenOut: request.tokenOutType,
+                    amountIn: request.amountInRaw,
+                    includeSources: [Protocol.FLOWX_V3],
+                    maxHops: FLOWX_QUOTER_MAX_HOPS
+                });
+            }
+            catch (error) {
+                throw new ReadServiceInputError("quote_unavailable", "FlowX quoter request failed", {
+                    reason: error instanceof Error ? error.message : "unknown"
+                });
+            }
+            return {
+                normalized: normalizeFlowxQuoterResult(result),
+                sdkRoutes: result.routes,
+                fetchedAt: now().toISOString()
+            };
+        }
+    };
+}
+export function normalizeFlowxQuoterResult(result) {
+    const rawQuote = result.rawQuote;
+    if (!rawQuote || !Array.isArray(rawQuote.paths)) {
+        throw new ReadServiceInputError("quote_unavailable", "FlowX quoter response is missing raw route paths", {
+            hasRawQuote: rawQuote !== undefined
+        });
+    }
+    const amountInRaw = stringifyAmount(result.amountIn, "amountIn");
+    const amountOutRaw = stringifyAmount(result.amountOut, "amountOut");
+    const paths = rawQuote.paths.flat().map((path, index) => {
+        if (typeof path.poolId !== "string" || path.poolId.length === 0) {
+            throw new ReadServiceInputError("quote_unavailable", "FlowX quoter path is missing a pool id", { index });
+        }
+        if (typeof path.source !== "string" || path.source.length === 0) {
+            throw new ReadServiceInputError("quote_unavailable", "FlowX quoter path is missing a source label", { index });
+        }
+        return {
+            poolId: path.poolId,
+            source: path.source,
+            swapXToY: typeof path.extra?.swapXToY === "boolean" ? path.extra.swapXToY : undefined,
+            feeRate: typeof path.extra?.fee === "number" ? path.extra.fee : undefined
+        };
+    });
+    if (paths.length === 0) {
+        throw new ReadServiceInputError("quote_unavailable", "FlowX quoter returned no route paths", {});
+    }
+    return {
+        amountInRaw,
+        amountOutRaw,
+        paths,
+        protocolConfig: normalizeProtocolConfig(rawQuote.protocolConfig)
+    };
+}
+function normalizeProtocolConfig(config) {
+    const clmm = config?.flowx_clmm;
+    if (typeof clmm !== "object" || clmm === null) {
+        return undefined;
+    }
+    const record = clmm;
+    return {
+        poolRegistryObjectId: typeof record.poolRegistryObjectId === "string" ? record.poolRegistryObjectId : undefined,
+        versionedObjectId: typeof record.versionedObjectId === "string" ? record.versionedObjectId : undefined,
+        wrappedRouterPackageId: typeof record.wrappedRouterPackageId === "string" ? record.wrappedRouterPackageId : undefined
+    };
+}
+function stringifyAmount(value, field) {
+    const text = typeof value === "string" ? value : value?.toString();
+    if (text === undefined || !/^\d+$/.test(text)) {
+        throw new ReadServiceInputError("quote_unavailable", "FlowX quoter amount is not a raw integer", { field });
+    }
+    return text;
+}

package/dist/core/read/flowxReadHelpers.js

@@ -0,0 +1,145 @@
+import { FLOWX_CLMM_MAINNET, getFlowxPoolById } from "./flowxRegistry.js";
+import { FLOWX_SWAP_QUOTE_QUANTITY_KIND, ReadServiceInputError } from "./readServiceTypes.js";
+export function flowxQuoteQuantitySemantics() {
+    return {
+        kind: FLOWX_SWAP_QUOTE_QUANTITY_KIND,
+        inputAmountKind: "display_source_amount_converted_to_raw",
+        allowedUse: "indicative_flowx_route_quote",
+        rawAmountAvailable: true,
+        rawEvidenceField: "routeEvidence",
+        chainVerified: false,
+        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"
+        ]
+    };
+}
+/**
+ * Validate a normalized FlowX quoter response against the pinned registry and
+ * the requested pair. Every check fails closed: an unknown pool, a foreign
+ * route source, a multi-hop path, an amount echo mismatch, or a drifted
+ * protocol config pin stops the quote instead of being silently accepted.
+ */
+export function validateFlowxRouteQuote(input) {
+    const { pair, quote } = input;
+    if (quote.amountInRaw !== input.requestedAmountInRaw) {
+        throw new ReadServiceInputError("quote_unavailable", "FlowX quoter echoed a different input amount", {
+            requested: input.requestedAmountInRaw,
+            echoed: quote.amountInRaw
+        });
+    }
+    const pools = [];
+    for (const path of quote.paths) {
+        if (path.source !== FLOWX_CLMM_MAINNET.quoterSource) {
+            throw new ReadServiceInputError("quote_unavailable", "FlowX route includes a non-FlowX-CLMM source", {
+                poolId: path.poolId,
+                source: path.source
+            });
+        }
+        const pinned = getFlowxPoolById(path.poolId);
+        if (!pinned) {
+            throw new ReadServiceInputError("quote_unavailable", "FlowX route uses a pool that is not in the pinned registry", {
+                poolId: path.poolId,
+                action: "regenerate_flowx_registry"
+            });
+        }
+        if (path.swapXToY !== undefined && path.swapXToY !== pair.swapXToY) {
+            throw new ReadServiceInputError("quote_unavailable", "FlowX route direction disagrees with the pinned pair orientation", {
+                poolId: path.poolId,
+                routeSwapXToY: path.swapXToY,
+                pinnedSwapXToY: pair.swapXToY
+            });
+        }
+        if (path.feeRate !== undefined && path.feeRate !== pinned.feeRate) {
+            throw new ReadServiceInputError("quote_unavailable", "FlowX route fee disagrees with the pinned pool fee", {
+                poolId: path.poolId,
+                routeFeeRate: path.feeRate,
+                pinnedFeeRate: pinned.feeRate
+            });
+        }
+        pools.push({
+            poolKey: pinned.poolKey,
+            poolId: pinned.poolId,
+            feeRate: pinned.feeRate,
+            tickSpacing: pinned.tickSpacing,
+            swapXToY: pair.swapXToY
+        });
+    }
+    if (pools.length !== 1) {
+        throw new ReadServiceInputError("quote_unavailable", "FlowX route is not a single-hop path", {
+            hopCount: pools.length
+        });
+    }
+    const config = quote.protocolConfig;
+    if (!config) {
+        throw new ReadServiceInputError("quote_unavailable", "FlowX quoter response did not carry the protocol config pin", {});
+    }
+    const pinDrift = {};
+    if (config.poolRegistryObjectId !== FLOWX_CLMM_MAINNET.poolRegistry.objectId) {
+        pinDrift.poolRegistryObjectId = {
+            pinned: FLOWX_CLMM_MAINNET.poolRegistry.objectId,
+            observed: config.poolRegistryObjectId
+        };
+    }
+    if (config.versionedObjectId !== FLOWX_CLMM_MAINNET.versioned.objectId) {
+        pinDrift.versionedObjectId = {
+            pinned: FLOWX_CLMM_MAINNET.versioned.objectId,
+            observed: config.versionedObjectId
+        };
+    }
+    if (config.wrappedRouterPackageId !== FLOWX_CLMM_MAINNET.universalRouter.wrappedRouterPackageId) {
+        pinDrift.wrappedRouterPackageId = {
+            pinned: FLOWX_CLMM_MAINNET.universalRouter.wrappedRouterPackageId,
+            observed: config.wrappedRouterPackageId
+        };
+    }
+    if (Object.keys(pinDrift).length > 0) {
+        throw new ReadServiceInputError("quote_unavailable", "FlowX protocol config drifted from the pinned registry", {
+            pinDrift,
+            action: "regenerate_flowx_registry"
+        });
+    }
+    return { pools };
+}

package/dist/core/read/flowxRegistry.js

@@ -0,0 +1,174 @@
+import { normalizeCoinType } from "./coinMetadata.js";
+import { ReadServiceInputError } from "./readServiceTypes.js";
+/**
+ * Pinned FlowX CLMM mainnet registry.
+ *
+ * Values were read from Sui mainnet directly (package introspection, the
+ * shared PoolRegistry object, and its dynamic fields) on 2026-06-12 and
+ * cross-checked against @flowx-finance/sdk@2.1.0 CONFIGS and a live quoter
+ * response. `scripts/generate-flowx-registry.ts` re-verifies every value
+ * against the chain and fails loudly on drift; it never rewrites this module.
+ *
+ * Static known metadata only - not live liquidity, balances, quotes, or
+ * final execution truth.
+ */
+export const FLOWX_CLMM_PROTOCOL_ID = "flowx-clmm";
+export const FLOWX_CLMM_UNIT_SOURCE = "flowx_pinned_registry";
+export const FLOWX_CLMM_MAINNET = {
+    /** Current package storage id (upgrade version 7 at probe time). */
+    currentPackageId: "0xde2c47eb0da8c74e4d0f6a220c41619681221b9c2590518095f0f0c2d3f3c772",
+    /** Original publish id - all on-chain struct types use this address. */
+    originalPackageId: "0x25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d",
+    poolRegistry: {
+        objectId: "0x27565d24a4cd51127ac90e4074a841bbe356cca7bf5759ddc14a975be1632abc",
+        initialSharedVersion: "101644053",
+        type: "0x25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::pool_manager::PoolRegistry"
+    },
+    versioned: {
+        objectId: "0x67624a1533b5aff5d0dfcf5e598684350efd38134d2d245f475524c03a64e656",
+        initialSharedVersion: "101644053",
+        type: "0x25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::versioned::Versioned"
+    },
+    /**
+     * Universal-router surfaces used by the SDK-built swap transaction. The
+     * wrappedRouterPackageId is delivered inside quoter API responses, so the
+     * quote path re-checks it against this pin on every quote.
+     */
+    universalRouter: {
+        packageId: "0xc263060d3cbb4155057f0010f92f63ca56d5121c298d01f7a33607342ec299b0",
+        treasuryObjectId: "0x25db8128dc9ccbe5fcd15e5700fea555c6b111a8c8a1f20c426b696caac2bea4",
+        tradeIdTrackerObjectId: "0x9ab469842f85fd2a1bac9ba695d867adb1caa7d5705809737922b5cee552eb6f",
+        partnerRegistryObjectId: "0x29e6c1c2176485dc045a2e39eb8844b4ca1cf8452d964447c11202f84a76cb1a",
+        versionedObjectId: "0xada98dd9e028db64e206dd81fdecb3dbc8b4c16be08d9f175550032bfdcf56f3",
+        wrappedRouterPackageId: "0x1d200e5a0709f84736d1ec06a5e9a961f4fa86f2d43d15e3a0441ae152440ede"
+    },
+    /** Aggregator quoter source label for FlowX CLMM routes. */
+    quoterSource: "FLOWX_CLMM",
+    /** Pool fee rates use a 1_000_000 denominator (e.g. 3000 = 0.3%). */
+    feeRateDenominator: 1_000_000
+};
+export const FLOWX_PINNED_COINS = {
+    SUI: {
+        symbol: "SUI",
+        coinType: "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
+        decimals: 9
+    },
+    USDC: {
+        symbol: "USDC",
+        coinType: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+        decimals: 6
+    }
+};
+function suiUsdcPool(poolId, feeRate, tickSpacing) {
+    return {
+        poolKey: `SUI_USDC_${feeRate}`,
+        poolId,
+        symbolX: FLOWX_PINNED_COINS.SUI.symbol,
+        symbolY: FLOWX_PINNED_COINS.USDC.symbol,
+        coinTypeX: FLOWX_PINNED_COINS.SUI.coinType,
+        coinTypeY: FLOWX_PINNED_COINS.USDC.coinType,
+        decimalsX: FLOWX_PINNED_COINS.SUI.decimals,
+        decimalsY: FLOWX_PINNED_COINS.USDC.decimals,
+        feeRate,
+        tickSpacing,
+        unitSource: FLOWX_CLMM_UNIT_SOURCE
+    };
+}
+/**
+ * Every SUI/USDC pool discovered by direct PoolRegistry dynamic-field reads
+ * (2026-06-12, 1189 pools total). One pool exists per fee tier; the registry
+ * lists all of them without ranking - pool selection is never advice here.
+ */
+export const FLOWX_PINNED_POOLS = [
+    suiUsdcPool("0xf143ac1cc2c012e31df55f21a5d9f406adc8f1ac08d014f84475a3b21953dd37", 10, 1),
+    suiUsdcPool("0x9c1cc6fc3c0060b9544dcaba50c9564706a558ef7e089895e86fbca1851c3d43", 100, 2),
+    suiUsdcPool("0x6b3791da0ae8b8d94d112c21b682e9f7d49a0b177cddd5b0dd61ca3ff27bc847", 500, 10),
+    suiUsdcPool("0xd477e8830f9aa070475149d75f285a4bd0a0386d8ce12f0e88e1c112cda21dfe", 1000, 20),
+    suiUsdcPool("0x1aed0146a85e0aa58639bfaca3ae55aa7db119eaeae35d3ec4a90742ebbb3933", 2000, 40),
+    suiUsdcPool("0x325239132e2b619147c00052986461cea02815172ea9d000c58e68484f514a90", 3000, 60),
+    suiUsdcPool("0x8903db2e9aea9e76d310c52a8745cff1f1d11fe38bc120828bd7280e7497ba8c", 10000, 200)
+];
+export function listFlowxPoolRegistry() {
+    return FLOWX_PINNED_POOLS;
+}
+export function getFlowxPoolById(poolId) {
+    return FLOWX_PINNED_POOLS.find((pool) => pool.poolId === poolId);
+}
+export function canonicalFlowxSymbol(symbol) {
+    const trimmed = symbol.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const matches = Object.values(FLOWX_PINNED_COINS).filter((coin) => coin.symbol.toLowerCase() === trimmed.toLowerCase());
+    return matches.length === 1 ? matches[0] : undefined;
+}
+export function resolveFlowxSwapPair(input) {
+    const source = canonicalFlowxSymbol(input.sourceSymbol);
+    const target = canonicalFlowxSymbol(input.targetSymbol);
+    if (!source || !target) {
+        throw new ReadServiceInputError("registry_miss", "FlowX symbol is not in the pinned registry", {
+            sourceSymbol: input.sourceSymbol,
+            targetSymbol: input.targetSymbol,
+            knownSymbols: Object.keys(FLOWX_PINNED_COINS)
+        });
+    }
+    if (source.symbol === target.symbol) {
+        throw new ReadServiceInputError("input_invalid", "FlowX swap pair uses the same symbol twice", {
+            sourceSymbol: input.sourceSymbol,
+            targetSymbol: input.targetSymbol
+        });
+    }
+    const sourceType = normalizeCoinType(source.coinType);
+    const targetType = normalizeCoinType(target.coinType);
+    const xToY = FLOWX_PINNED_POOLS.filter((pool) => normalizeCoinType(pool.coinTypeX) === sourceType && normalizeCoinType(pool.coinTypeY) === targetType);
+    const yToX = FLOWX_PINNED_POOLS.filter((pool) => normalizeCoinType(pool.coinTypeX) === targetType && normalizeCoinType(pool.coinTypeY) === sourceType);
+    if (xToY.length > 0 && yToX.length > 0) {
+        throw new ReadServiceInputError("registry_miss", "FlowX pinned pools resolve the pair in both orientations", {
+            sourceSymbol: source.symbol,
+            targetSymbol: target.symbol
+        });
+    }
+    const pools = xToY.length > 0 ? xToY : yToX;
+    if (pools.length === 0) {
+        throw new ReadServiceInputError("registry_miss", "FlowX symbol pair has no pinned mainnet pools", {
+            sourceSymbol: source.symbol,
+            targetSymbol: target.symbol
+        });
+    }
+    return {
+        source,
+        target,
+        swapXToY: xToY.length > 0,
+        pools
+    };
+}
+export function assertFlowxRegistryShape() {
+    const poolKeys = new Set();
+    const poolIds = new Set();
+    for (const pool of FLOWX_PINNED_POOLS) {
+        if (poolKeys.has(pool.poolKey)) {
+            throw new ReadServiceInputError("registry_miss", "FlowX pinned registry repeats a pool key", {
+                poolKey: pool.poolKey
+            });
+        }
+        if (poolIds.has(pool.poolId)) {
+            throw new ReadServiceInputError("registry_miss", "FlowX pinned registry repeats a pool id", {
+                poolId: pool.poolId
+            });
+        }
+        poolKeys.add(pool.poolKey);
+        poolIds.add(pool.poolId);
+        if (!Number.isInteger(pool.feeRate) || pool.feeRate < 0 || pool.feeRate >= FLOWX_CLMM_MAINNET.feeRateDenominator) {
+            throw new ReadServiceInputError("registry_miss", "FlowX pinned pool fee rate is outside the 1e6 denominator", {
+                poolKey: pool.poolKey,
+                feeRate: pool.feeRate
+            });
+        }
+        if (!Number.isInteger(pool.tickSpacing) || pool.tickSpacing <= 0) {
+            throw new ReadServiceInputError("registry_miss", "FlowX pinned pool tick spacing is not a positive integer", {
+                poolKey: pool.poolKey,
+                tickSpacing: pool.tickSpacing
+            });
+        }
+    }
+}

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"
+        }
+    };
+}