@stelis/say-ur-intent 0.0.0 → 0.0.2

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

package/dist/core/read/deepbookReadHelpers.js

@@ -0,0 +1,265 @@
+import { formatRawAmount, parseDisplayAmountToRaw } from "./coinMetadata.js";
+import { MAX_RAW_U64, parseRawU64 } from "../numeric/rawU64.js";
+import { parseSuiAddress } from "../suiAddress.js";
+import { DEEPBOOK_ACCOUNT_QUANTITY_KIND, DEEPBOOK_MID_PRICE_SEMANTICS_KIND, DEEPBOOK_QUOTE_QUANTITY_KIND, 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 deepbookAccountInventorySource(methods) {
+    return {
+        sdk: "@mysten/deepbook-v3",
+        transport: "grpc",
+        simulation: "client.core.simulateTransaction",
+        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,133 @@
+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;
+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);
+        }
+    }
+}