@zktx.io/sui-mcp 0.5.0

package/dist/core/proposal/types.js

@@ -0,0 +1,35 @@
+export const EXTERNAL_PROPOSAL_CONTRACT_VERSION = "external-proposal-alpha-2026-05-25";
+export const PROPOSAL_REVIEW_MODEL_VERSION = "proposal-review-model-alpha-2026-05-25";
+export const EXTERNAL_PROPOSAL_SETTLEMENT_TOKEN_SELECTION_UNSUPPORTED_CLAIM_ID = "settlement_token_selection";
+export const EXTERNAL_PROPOSAL_REVIEW_ALWAYS_UNSUPPORTED_CLAIMS = [
+    {
+        id: "external_transaction_material_trusted_authority",
+        label: "External transaction material",
+        reason: "External proposal data is not accepted as transaction-building input, signing data, or wallet authorization."
+    },
+    {
+        id: "signing_readiness",
+        label: "Signing readiness",
+        reason: "This review session is read-only and has no reviewed signable adapter, transaction regeneration, or wallet handoff."
+    },
+    {
+        id: "route_recommendation",
+        label: "Route recommendation",
+        reason: "The review model does not rank venues, choose routes, or make best-price recommendations."
+    },
+    {
+        id: EXTERNAL_PROPOSAL_SETTLEMENT_TOKEN_SELECTION_UNSUPPORTED_CLAIM_ID,
+        label: "Settlement-token selection",
+        reason: "External proposal review can display declared asset fields, but it does not verify that the user selected a settlement token and does not choose one for the user."
+    },
+    {
+        id: "fiat_usd_cash_out",
+        label: "Fiat USD cash-out",
+        reason: "Settlement assets are not treated as fiat USD, bank cash-out amounts, or peg guarantees."
+    },
+    {
+        id: "profit_or_pnl",
+        label: "P&L, tax, and cost basis",
+        reason: "The current release does not compute profit, loss, tax, or cost basis."
+    }
+];

package/dist/core/read/amounts.js

@@ -0,0 +1,14 @@
+import { ReadServiceInputError } from "./readServiceTypes.js";
+export function sumRawAmounts(rawAmounts, field = "balance") {
+    let total = 0n;
+    for (const rawAmount of rawAmounts) {
+        if (!/^\d+$/.test(rawAmount)) {
+            throw new ReadServiceInputError("input_invalid", "raw amount must be an unsigned integer string", {
+                field,
+                value: rawAmount
+            });
+        }
+        total += BigInt(rawAmount);
+    }
+    return total.toString();
+}

package/dist/core/read/coinMetadata.js

@@ -0,0 +1,60 @@
+import { normalizeStructTag, parseToUnits } from "@mysten/sui/utils";
+export const COIN_METADATA_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+export const SUI_METADATA_UNIT_SOURCE = "sui_core_getCoinMetadata";
+export const DEEPBOOK_SCALAR_UNIT_SOURCE = "deepbook_mainnetCoins_scalar";
+export const DISPLAY_AMOUNT_SOURCE = "raw_balance_with_verified_decimals";
+export function normalizeCoinType(coinType) {
+    return normalizeStructTag(coinType);
+}
+export function decimalsFromScalar(scalar) {
+    if (!Number.isSafeInteger(scalar) || scalar < 1) {
+        return undefined;
+    }
+    let value = scalar;
+    let decimals = 0;
+    while (value > 1 && value % 10 === 0) {
+        value /= 10;
+        decimals += 1;
+    }
+    return value === 1 ? decimals : undefined;
+}
+export function assertValidDecimals(decimals) {
+    if (!Number.isInteger(decimals) || decimals < 0 || decimals > 255) {
+        throw new Error("Coin metadata decimals must be an integer from 0 to 255");
+    }
+    return decimals;
+}
+export function formatRawAmount(rawAmount, decimals) {
+    assertValidDecimals(decimals);
+    if (!/^\d+$/.test(rawAmount)) {
+        throw new Error("raw amount must be an unsigned integer string");
+    }
+    const normalizedRaw = rawAmount.replace(/^0+(?=\d)/, "");
+    if (decimals === 0) {
+        return normalizedRaw;
+    }
+    const padded = normalizedRaw.padStart(decimals + 1, "0");
+    const integerPart = padded.slice(0, -decimals).replace(/^0+(?=\d)/, "");
+    const fractionalPart = padded.slice(-decimals).replace(/0+$/, "");
+    return fractionalPart.length === 0 ? integerPart : `${integerPart}.${fractionalPart}`;
+}
+export function assertDisplayAmountSyntax(displayAmount) {
+    if (!/^\d+(?:\.\d+)?$/.test(displayAmount)) {
+        throw new Error("display amount must be an unsigned decimal string");
+    }
+    return displayAmount;
+}
+export function parseDisplayAmountToRaw(displayAmount, decimals) {
+    assertValidDecimals(decimals);
+    assertDisplayAmountSyntax(displayAmount);
+    try {
+        return parseToUnits(displayAmount, decimals).toString();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "unknown";
+        if (message.startsWith("Too many decimal places")) {
+            throw new Error("display amount has more fractional digits than verified decimals");
+        }
+        throw error;
+    }
+}

package/dist/core/read/deepbookOfficialIndexerSource.js

@@ -0,0 +1,373 @@
+import { z } from "zod";
+import { normalizeCoinType } from "./coinMetadata.js";
+export const DEFAULT_DEEPBOOK_OFFICIAL_INDEXER_BASE_URL = "https://deepbook-indexer.mainnet.mystenlabs.com";
+export const DEFAULT_DEEPBOOK_OFFICIAL_INDEXER_FETCH_TIMEOUT_MS = 10_000;
+export const DEEPBOOK_OFFICIAL_INDEXER_CANONICAL_USDC_COIN_TYPE = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
+export const DEEPBOOK_OFFICIAL_INDEXER_PRICE_CONVENTION = "USDC_PER_BASE";
+export const DEEPBOOK_OFFICIAL_INDEXER_SOURCE_STATEMENT = "Sui MCP read DeepBookV3 official Indexer candle data for this response.";
+export const DEEPBOOK_OFFICIAL_INDEXER_CANDLE_TIMESTAMP_BOUNDARY = "open";
+export const DEEPBOOK_OFFICIAL_INDEXER_INTERVALS = ["1m", "5m", "15m", "30m", "1h", "4h", "1d", "1w"];
+export const DEFAULT_DEEPBOOK_OFFICIAL_INDEXER_INTERVAL = "15m";
+const SUI_OBJECT_ID_PATTERN = /^0x[0-9a-f]{64}$/i;
+const DECIMAL_STRING_PATTERN = /^(0|[1-9][0-9]*)(\.[0-9]+)?$/;
+export class DeepbookOfficialIndexerSourceError extends Error {
+    reason;
+    details;
+    constructor(reason, message, details = {}) {
+        super(message);
+        this.reason = reason;
+        this.details = details;
+    }
+}
+const finiteNonNegativeNumberSchema = z.number().refine((value) => Number.isFinite(value) && value >= 0, {
+    message: "expected a finite non-negative number"
+});
+const timestampMsSchema = z.number().int().refine((value) => Number.isSafeInteger(value) && value >= 0, {
+    message: "expected a finite non-negative integer millisecond timestamp"
+});
+const decimalStringSchema = z.string().regex(DECIMAL_STRING_PATTERN);
+const isoDateStringSchema = z.string().refine((value) => {
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
+}, "expected an ISO timestamp string");
+const coinTypeSchema = z.string().min(1).refine((value) => {
+    try {
+        normalizeCoinType(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}, "expected a valid Sui coin type");
+export const deepbookOfficialIndexerIntervalSchema = z.enum(DEEPBOOK_OFFICIAL_INDEXER_INTERVALS);
+export const deepbookOfficialIndexerPoolSchema = z.object({
+    pool_id: z.string().regex(SUI_OBJECT_ID_PATTERN),
+    pool_name: z.string().min(1),
+    base_asset_id: coinTypeSchema,
+    base_asset_symbol: z.string().min(1),
+    base_asset_decimals: z.number().int().min(0).max(255),
+    quote_asset_id: coinTypeSchema,
+    quote_asset_symbol: z.string().min(1),
+    quote_asset_decimals: z.number().int().min(0).max(255)
+});
+export const deepbookOfficialIndexerPoolsSchema = z.array(deepbookOfficialIndexerPoolSchema).min(1);
+const deepbookOfficialIndexerWireCandleSchema = z.tuple([
+    timestampMsSchema,
+    finiteNonNegativeNumberSchema,
+    finiteNonNegativeNumberSchema,
+    finiteNonNegativeNumberSchema,
+    finiteNonNegativeNumberSchema,
+    finiteNonNegativeNumberSchema
+]).superRefine((candle, context) => {
+    const [, open, high, low, close] = candle;
+    if (high < open || high < low || high < close) {
+        context.addIssue({
+            code: "custom",
+            message: "candle high must be greater than or equal to open low and close",
+            path: [2]
+        });
+    }
+    if (low > open || low > high || low > close) {
+        context.addIssue({
+            code: "custom",
+            message: "candle low must be less than or equal to open high and close",
+            path: [3]
+        });
+    }
+});
+export const deepbookOfficialIndexerOhclvResponseSchema = z.object({
+    candles: z.array(deepbookOfficialIndexerWireCandleSchema)
+}).superRefine((response, context) => {
+    const seen = new Set();
+    for (const [index, candle] of response.candles.entries()) {
+        const timestampMs = candle[0];
+        if (seen.has(timestampMs)) {
+            context.addIssue({
+                code: "custom",
+                message: "duplicate candle timestamp",
+                path: ["candles", index, 0]
+            });
+            continue;
+        }
+        seen.add(timestampMs);
+    }
+});
+export const deepbookOfficialIndexerCandleSchema = z.object({
+    timestampMs: timestampMsSchema,
+    start: isoDateStringSchema,
+    end: isoDateStringSchema,
+    open: decimalStringSchema,
+    high: decimalStringSchema,
+    low: decimalStringSchema,
+    close: decimalStringSchema,
+    volume: decimalStringSchema
+}).strict().superRefine((candle, context) => {
+    if (Date.parse(candle.end) <= Date.parse(candle.start)) {
+        context.addIssue({ code: "custom", message: "candle end must be after start", path: ["end"] });
+    }
+});
+export class DeepbookOfficialIndexerSource {
+    baseUrl;
+    fetchImpl;
+    timeoutMs;
+    now;
+    constructor(options = {}) {
+        this.baseUrl = normalizeDeepbookOfficialIndexerBaseUrl(options.baseUrl ?? DEFAULT_DEEPBOOK_OFFICIAL_INDEXER_BASE_URL);
+        this.fetchImpl = options.fetch ?? fetch;
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_DEEPBOOK_OFFICIAL_INDEXER_FETCH_TIMEOUT_MS;
+        this.now = options.now ?? (() => new Date());
+    }
+    poolsUrl() {
+        return new URL("get_pools", `${this.baseUrl}/`).toString();
+    }
+    candlesUrl(input) {
+        const interval = parseDeepbookOfficialIndexerInterval(input.interval);
+        assertPoolName(input.poolName);
+        const url = new URL(`ohclv/${encodeURIComponent(input.poolName)}`, `${this.baseUrl}/`);
+        url.searchParams.set("interval", interval);
+        if (input.startTimeMs !== undefined) {
+            assertTimestampMs(input.startTimeMs, "startTimeMs");
+            url.searchParams.set("start_time", input.startTimeMs.toString());
+        }
+        if (input.endTimeMs !== undefined) {
+            assertTimestampMs(input.endTimeMs, "endTimeMs");
+            url.searchParams.set("end_time", input.endTimeMs.toString());
+        }
+        if (input.limit !== undefined) {
+            assertPositiveInteger(input.limit, "limit");
+            url.searchParams.set("limit", input.limit.toString());
+        }
+        return url.toString();
+    }
+    async fetchPools() {
+        const response = await this.fetchJson("get_pools", this.poolsUrl());
+        const pools = parseOfficialIndexerPayload(deepbookOfficialIndexerPoolsSchema, response.json, response.source);
+        return { source: response.source, pools };
+    }
+    async fetchCandles(input) {
+        const interval = parseDeepbookOfficialIndexerInterval(input.interval);
+        const url = this.candlesUrl({ ...input, interval });
+        const response = await this.fetchJson("ohclv", url, { ...input, interval });
+        const payload = parseOfficialIndexerPayload(deepbookOfficialIndexerOhclvResponseSchema, response.json, response.source);
+        const candles = payload.candles
+            .map((wireCandle) => officialWireCandleToCandle(wireCandle, interval))
+            .sort((left, right) => left.timestampMs - right.timestampMs);
+        return {
+            source: response.source,
+            candles
+        };
+    }
+    async fetchJson(endpoint, url, input = {}) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        let response;
+        try {
+            response = await this.fetchImpl(url, {
+                signal: controller.signal,
+                headers: {
+                    accept: "application/json",
+                    "user-agent": "sui-mcp"
+                }
+            });
+        }
+        catch (error) {
+            throw officialIndexerFetchError(error, endpoint, url);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        if (!response.ok) {
+            throw new DeepbookOfficialIndexerSourceError("source_http_error", "DeepBook official Indexer source returned an error", {
+                endpoint,
+                url,
+                httpStatus: response.status
+            });
+        }
+        let json;
+        try {
+            json = await response.json();
+        }
+        catch (error) {
+            throw new DeepbookOfficialIndexerSourceError("invalid_payload", "DeepBook official Indexer source returned invalid JSON", {
+                endpoint,
+                url,
+                message: error instanceof Error ? error.message : String(error)
+            });
+        }
+        return {
+            source: {
+                baseUrl: this.baseUrl,
+                endpoint,
+                url,
+                fetchedAt: this.now().toISOString(),
+                sourceStatement: DEEPBOOK_OFFICIAL_INDEXER_SOURCE_STATEMENT,
+                poolName: input.poolName,
+                interval: input.interval,
+                startTimeMs: input.startTimeMs,
+                endTimeMs: input.endTimeMs,
+                limit: input.limit
+            },
+            json
+        };
+    }
+}
+export function normalizeDeepbookOfficialIndexerBaseUrl(value) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new DeepbookOfficialIndexerSourceError("invalid_source_url", "DeepBook official Indexer base URL must be a valid URL");
+    }
+    if (parsed.protocol !== "https:") {
+        throw new DeepbookOfficialIndexerSourceError("invalid_source_url", "DeepBook official Indexer base URL must use https");
+    }
+    if (!parsed.hostname) {
+        throw new DeepbookOfficialIndexerSourceError("invalid_source_url", "DeepBook official Indexer base URL must include a host");
+    }
+    if (parsed.username || parsed.password || parsed.search || parsed.hash) {
+        throw new DeepbookOfficialIndexerSourceError("invalid_source_url", "DeepBook official Indexer base URL must not include credentials, query, or fragment");
+    }
+    const pathname = parsed.pathname.replace(/\/+$/, "");
+    return `${parsed.origin}${pathname}`;
+}
+export function parseDeepbookOfficialIndexerInterval(value) {
+    const parsed = deepbookOfficialIndexerIntervalSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new DeepbookOfficialIndexerSourceError("invalid_payload", "DeepBook official Indexer interval is not supported", { interval: value });
+    }
+    return parsed.data;
+}
+export function deepbookOfficialIndexerIntervalDurationMs(interval) {
+    switch (interval) {
+        case "1m":
+            return 60_000;
+        case "5m":
+            return 5 * 60_000;
+        case "15m":
+            return 15 * 60_000;
+        case "30m":
+            return 30 * 60_000;
+        case "1h":
+            return 60 * 60_000;
+        case "4h":
+            return 4 * 60 * 60_000;
+        case "1d":
+            return 24 * 60 * 60_000;
+        case "1w":
+            return 7 * 24 * 60 * 60_000;
+    }
+}
+export function isDeepbookOfficialIndexerCanonicalUsdcPool(pool) {
+    return normalizeCoinType(pool.quote_asset_id) === normalizeCoinType(DEEPBOOK_OFFICIAL_INDEXER_CANONICAL_USDC_COIN_TYPE);
+}
+export function selectDeepbookOfficialIndexerCanonicalUsdcPools(pools) {
+    return pools.filter(isDeepbookOfficialIndexerCanonicalUsdcPool);
+}
+function officialWireCandleToCandle([timestampMs, open, high, low, close, volume], interval) {
+    const start = new Date(timestampMs).toISOString();
+    const end = new Date(timestampMs + deepbookOfficialIndexerIntervalDurationMs(interval)).toISOString();
+    return deepbookOfficialIndexerCandleSchema.parse({
+        timestampMs,
+        start,
+        end,
+        open: decimalStringFromNumber(open),
+        high: decimalStringFromNumber(high),
+        low: decimalStringFromNumber(low),
+        close: decimalStringFromNumber(close),
+        volume: decimalStringFromNumber(volume)
+    });
+}
+function decimalStringFromNumber(value) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new DeepbookOfficialIndexerSourceError("invalid_payload", "DeepBook official Indexer number is invalid", {
+            value
+        });
+    }
+    const asString = value.toString();
+    if (!/[eE]/.test(asString)) {
+        return asString;
+    }
+    const [coefficient, exponentText] = asString.toLowerCase().split("e");
+    const exponent = Number(exponentText);
+    if (coefficient === undefined || exponentText === undefined || !Number.isInteger(exponent)) {
+        throw new DeepbookOfficialIndexerSourceError("invalid_payload", "DeepBook official Indexer number is invalid", {
+            value
+        });
+    }
+    const [rawIntegerPart, fractionalPart = ""] = coefficient.split(".");
+    const integerPart = rawIntegerPart ?? "";
+    const digits = `${integerPart}${fractionalPart}`;
+    const decimalPosition = integerPart.length + exponent;
+    let decimal;
+    if (decimalPosition <= 0) {
+        decimal = `0.${"0".repeat(-decimalPosition)}${digits}`;
+    }
+    else if (decimalPosition >= digits.length) {
+        decimal = `${digits}${"0".repeat(decimalPosition - digits.length)}`;
+    }
+    else {
+        decimal = `${digits.slice(0, decimalPosition)}.${digits.slice(decimalPosition)}`;
+    }
+    return normalizeDecimalString(decimal);
+}
+function normalizeDecimalString(value) {
+    const unsigned = value.replace(/^0+(?=\d)/, "");
+    const trimmed = unsigned.includes(".") ? unsigned.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "") : unsigned;
+    return trimmed === "" ? "0" : trimmed;
+}
+function parseOfficialIndexerPayload(schema, json, source) {
+    const parsed = schema.safeParse(json);
+    if (!parsed.success) {
+        throw new DeepbookOfficialIndexerSourceError("invalid_payload", "DeepBook official Indexer payload failed schema validation", {
+            endpoint: source.endpoint,
+            url: source.url,
+            issues: parsed.error.issues.map((issue) => ({
+                path: issue.path.join("."),
+                message: issue.message
+            }))
+        });
+    }
+    return parsed.data;
+}
+function assertPoolName(poolName) {
+    if (!/^[A-Z0-9]+_[A-Z0-9]+$/.test(poolName)) {
+        throw new DeepbookOfficialIndexerSourceError("invalid_payload", "DeepBook official Indexer pool name is invalid", {
+            poolName
+        });
+    }
+}
+function assertTimestampMs(value, field) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new DeepbookOfficialIndexerSourceError("invalid_payload", `DeepBook official Indexer ${field} is invalid`, {
+            [field]: value
+        });
+    }
+}
+function assertPositiveInteger(value, field) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new DeepbookOfficialIndexerSourceError("invalid_payload", `DeepBook official Indexer ${field} is invalid`, {
+            [field]: value
+        });
+    }
+}
+function officialIndexerFetchError(error, endpoint, url) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (isAbortError(error)) {
+        return new DeepbookOfficialIndexerSourceError("source_timeout", "DeepBook official Indexer source timed out", {
+            endpoint,
+            url,
+            message
+        });
+    }
+    return new DeepbookOfficialIndexerSourceError("source_unavailable", "DeepBook official Indexer source could not be read", {
+        endpoint,
+        url,
+        message
+    });
+}
+function isAbortError(error) {
+    return error instanceof DOMException
+        ? error.name === "AbortError"
+        : error instanceof Error && error.name === "AbortError";
+}

package/dist/core/read/deepbookRawQuoteClient.js

@@ -0,0 +1,86 @@
+import { bcs } from "@mysten/sui/bcs";
+import { Transaction } from "@mysten/sui/transactions";
+import { DeepBookClient } from "@mysten/deepbook-v3";
+import { ReadServiceInputError } from "./readServiceTypes.js";
+export function createDeepBookReadClient(input) {
+    const sdkClient = new DeepBookClient({
+        client: input.client,
+        address: input.simulationSender,
+        network: input.network,
+        ...(input.balanceManagers === undefined ? {} : { balanceManagers: input.balanceManagers })
+    });
+    return {
+        midPrice: (poolKey) => sdkClient.midPrice(poolKey),
+        poolBookParams: (poolKey) => sdkClient.poolBookParams(poolKey),
+        getLevel2TicksFromMid: (poolKey, ticks) => sdkClient.getLevel2TicksFromMid(poolKey, ticks),
+        getQuoteQuantityOutRaw: (poolKey, baseQuantity) => simulateDeepbookRawQuote({
+            client: input.client,
+            simulationSender: input.simulationSender,
+            poolKey,
+            command: () => sdkClient.deepBook.getQuoteQuantityOut(poolKey, baseQuantity)
+        }),
+        getBaseQuantityOutRaw: (poolKey, quoteQuantity) => simulateDeepbookRawQuote({
+            client: input.client,
+            simulationSender: input.simulationSender,
+            poolKey,
+            command: () => sdkClient.deepBook.getBaseQuantityOut(poolKey, quoteQuantity)
+        }),
+        getQuoteQuantityOutInputFeeRaw: (poolKey, baseQuantity) => simulateDeepbookRawQuote({
+            client: input.client,
+            simulationSender: input.simulationSender,
+            poolKey,
+            command: () => sdkClient.deepBook.getQuoteQuantityOutInputFee(poolKey, baseQuantity)
+        }),
+        getBaseQuantityOutInputFeeRaw: (poolKey, quoteQuantity) => simulateDeepbookRawQuote({
+            client: input.client,
+            simulationSender: input.simulationSender,
+            poolKey,
+            command: () => sdkClient.deepBook.getBaseQuantityOutInputFee(poolKey, quoteQuantity)
+        }),
+        getBalanceManagerIds: (owner) => sdkClient.getBalanceManagerIds(owner),
+        accountExists: (poolKey, managerKey) => sdkClient.accountExists(poolKey, managerKey),
+        account: (poolKey, managerKey) => sdkClient.account(poolKey, managerKey),
+        lockedBalance: (poolKey, balanceManagerKey) => sdkClient.lockedBalance(poolKey, balanceManagerKey),
+        accountOpenOrders: (poolKey, managerKey) => sdkClient.accountOpenOrders(poolKey, managerKey)
+    };
+}
+async function simulateDeepbookRawQuote(input) {
+    const tx = new Transaction();
+    tx.setSender(input.simulationSender);
+    tx.add(input.command());
+    const result = await input.client.core.simulateTransaction({
+        transaction: tx,
+        include: { commandResults: true, effects: true }
+    });
+    const returnValues = result.commandResults?.[0]?.returnValues;
+    if (!Array.isArray(returnValues) || returnValues.length < 3) {
+        throw new ReadServiceInputError("quote_unavailable", "DeepBook raw quote return values are unavailable", {
+            poolKey: input.poolKey,
+            expectedReturnValues: ["base_quantity_out", "quote_quantity_out", "deep_quantity_required"]
+        });
+    }
+    return {
+        baseOutRaw: parseU64ReturnValue(returnValues[0], "baseOutRaw", input.poolKey),
+        quoteOutRaw: parseU64ReturnValue(returnValues[1], "quoteOutRaw", input.poolKey),
+        deepRequiredRaw: parseU64ReturnValue(returnValues[2], "deepRequiredRaw", input.poolKey)
+    };
+}
+function parseU64ReturnValue(value, field, poolKey) {
+    const bcsValue = typeof value === "object" && value !== null && "bcs" in value ? value.bcs : undefined;
+    if (!(bcsValue instanceof Uint8Array)) {
+        throw new ReadServiceInputError("quote_unavailable", "DeepBook raw quote return value is unavailable", {
+            poolKey,
+            field
+        });
+    }
+    try {
+        return bcs.U64.parse(bcsValue).toString();
+    }
+    catch (error) {
+        throw new ReadServiceInputError("quote_unavailable", "DeepBook raw quote return value is not a u64", {
+            poolKey,
+            field,
+            reason: error instanceof Error ? error.message : "unknown"
+        });
+    }
+}