@coinlist-co/react 0.11.1-rc.8cfcd2a → 0.11.1-rc.e102bdb

package/dist/shared/index.cjs

@@ -45,6 +45,7 @@ __export(shared_exports, {
   Cursor: () => Cursor,
   DEFAULT_AMOUNT_TO_COMPUTE_PRICE: () => DEFAULT_AMOUNT_TO_COMPUTE_PRICE,
   DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE: () => DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE,
+  DEFAULT_ONDO_SELL_TOKENS_TO_COMPUTE_PRICE: () => DEFAULT_ONDO_SELL_TOKENS_TO_COMPUTE_PRICE,
   DEFAULT_SLIPPAGE_BPS: () => DEFAULT_SLIPPAGE_BPS,
   DecimalString: () => DecimalString,
   DocumentSubmission: () => DocumentSubmission,
@@ -67,6 +68,7 @@ __export(shared_exports, {
   Link: () => Link,
   MAX_ASSET_DECIMALS: () => MAX_ASSET_DECIMALS,
   MAX_UINT_256: () => MAX_UINT_256,
+  MathError: () => MathError,
   Milestone: () => Milestone,
   NA_AMOUNT_ASSET_UI: () => NA_AMOUNT_ASSET_UI,
   NotAuthenticatedError: () => NotAuthenticatedError,
@@ -75,6 +77,7 @@ __export(shared_exports, {
   OAuthSession: () => OAuthSession,
   ONDO_POLL_INTERVAL_MS: () => ONDO_POLL_INTERVAL_MS,
   ONDO_QUOTE_EXPIRY_THRESHOLD_MS: () => ONDO_QUOTE_EXPIRY_THRESHOLD_MS,
+  ONDO_SETTLEMENT_ASSET: () => ONDO_SETTLEMENT_ASSET,
   ONDO_SUPPORTED_INPUT_ASSETS: () => ONDO_SUPPORTED_INPUT_ASSETS,
   Offer: () => Offer,
   OfferDetail: () => OfferDetail,
@@ -87,9 +90,10 @@ __export(shared_exports, {
   OfferSlug: () => OfferSlug,
   OfferToken: () => OfferToken,
   OffersNamespaceImpl: () => OffersNamespaceImpl,
+  OndoBuyTransaction: () => OndoBuyTransaction,
   OndoNamespaceImpl: () => OndoNamespaceImpl,
   OndoQuote: () => OndoQuote,
-  OndoSwapTransaction: () => OndoSwapTransaction,
+  OndoSellTransaction: () => OndoSellTransaction,
   OndoTradingStatus: () => OndoTradingStatus,
   PKCEState: () => PKCEState,
   PaginatedResponse: () => PaginatedResponse,
@@ -149,7 +153,8 @@ __export(shared_exports, {
   assetAmount: () => assetAmount,
   blockchainAmountFromRawOrThrow: () => blockchainAmountFromRawOrThrow,
   chainFromId: () => chainFromId,
-  computeOndoPrice: () => computeOndoPrice,
+  computeOndoBuyPrice: () => computeOndoBuyPrice,
+  computeOndoSellPrice: () => computeOndoSellPrice,
   computePrice: () => computePrice,
   computeSlip: () => computeSlip,
   decodeSwappedOutputAmount: () => decodeSwappedOutputAmount,
@@ -442,11 +447,19 @@ var InvariantError = class extends Error {
     this.name = "InvariantError";
   }
 };
+var MathError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MathError";
+  }
+};
 
 // src/shared/types/blockchain/core.ts
 var ETHEREUM_CHAINS = {
   ethereum_mainnet: true,
-  ethereum_sepolia: true
+  ethereum_sepolia: true,
+  base_mainnet: true,
+  base_sepolia: true
 };
 var EthereumChain = (value) => {
   if (!Object.keys(ETHEREUM_CHAINS).includes(value)) {
@@ -501,9 +514,25 @@ var BlockchainAmount = Object.assign(
   (value) => value,
   {
     add: (a, b) => combineAmounts(a, b, (x, y) => x + y),
-    sub: (a, b) => combineAmounts(a, b, (x, y) => x - y)
+    sub: (a, b) => combineAmounts(a, b, (x, y) => x - y),
+    mul: multiplyAmounts,
+    div: divideAmounts
   }
 );
+function multiplyAmounts(a, b) {
+  const product = a.raw * b.raw;
+  return BlockchainAmount({
+    raw: product / 10n ** BigInt(b.decimals),
+    decimals: a.decimals
+  });
+}
+function divideAmounts(a, b) {
+  if (b.raw === 0n) {
+    throw new MathError("Cannot divide a BlockchainAmount by zero");
+  }
+  const scaled = a.raw * 10n ** BigInt(b.decimals);
+  return BlockchainAmount({ raw: scaled / b.raw, decimals: a.decimals });
+}
 function combineAmounts(a, b, op) {
   if (a.decimals !== b.decimals) {
     throw new InvariantError(
@@ -538,7 +567,9 @@ var AssetIconUrl = (value) => value;
 // src/shared/core/blockchain/chain.ts
 var CHAIN_IDS = {
   ethereum_mainnet: 1,
-  ethereum_sepolia: 11155111
+  ethereum_sepolia: 11155111,
+  base_mainnet: 8453,
+  base_sepolia: 84532
 };
 function getChainId(chain) {
   return CHAIN_IDS[chain];
@@ -557,6 +588,10 @@ function getNetworkName(chain) {
       return "Ethereum";
     case "ethereum_sepolia":
       return "Ethereum Sepolia";
+    case "base_mainnet":
+      return "Base";
+    case "base_sepolia":
+      return "Base Sepolia";
     default: {
       const _exhaustive = chain;
       return _exhaustive;
@@ -572,6 +607,10 @@ function explorerBaseUrl(chain) {
       return "https://etherscan.io";
     case "ethereum_sepolia":
       return "https://sepolia.etherscan.io";
+    case "base_mainnet":
+      return "https://basescan.org";
+    case "base_sepolia":
+      return "https://sepolia-explorer.base.org";
     default: {
       const _exhaustive = chain;
       return _exhaustive;
@@ -847,6 +886,9 @@ function classifyLogCause(error) {
   if (error instanceof InvariantError) {
     return { type: "invariant", message: error.message };
   }
+  if (error instanceof MathError) {
+    return { type: "math", message: error.message };
+  }
   if (error instanceof NotAuthenticatedError) {
     return { type: "not-authenticated" };
   }
@@ -1172,6 +1214,12 @@ var USDC_ADDRESSES = {
   ),
   ethereum_sepolia: EvmContractAddress(
     "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
+  ),
+  base_mainnet: EvmContractAddress(
+    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+  ),
+  base_sepolia: EvmContractAddress(
+    "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
   )
 };
 var USDT_ADDRESSES = {
@@ -1180,7 +1228,11 @@ var USDT_ADDRESSES = {
   ),
   ethereum_sepolia: EvmContractAddress(
     "0x7169D38820dfd117C3FA1f22a697dBA58d90BA06"
-  )
+  ),
+  base_mainnet: EvmContractAddress(
+    "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2"
+  ),
+  base_sepolia: null
 };
 var TOKEN_REGISTRY = {
   erc20: (symbol) => {
@@ -1193,16 +1245,17 @@ var TOKEN_REGISTRY = {
         throw new InvariantError(`Unknown asset symbol: ${symbol}`);
     }
   },
-  contractAddress: (symbol, chain) => {
-    switch (symbol) {
-      case "USDC":
-        return USDC_ADDRESSES[chain];
-      case "USDT":
-        return USDT_ADDRESSES[chain];
-      default:
-        throw new InvariantError(`Unknown asset symbol: ${symbol}`);
-    }
-  }
+  /**
+   * USDC's contract on `chain`. USDC is deployed on every chain the SDK
+   * models, so the table is total and the answer is never `null`.
+   */
+  usdcAddress: (chain) => USDC_ADDRESSES[chain],
+  /**
+   * USDT's contract on `chain`, or `null` where Tether publishes none —
+   * Base Sepolia today. The honest answer, never a fake address a balance
+   * read would call.
+   */
+  usdtAddress: (chain) => USDT_ADDRESSES[chain]
 };
 
 // src/shared/types/pagination.ts
@@ -1499,30 +1552,49 @@ function ondoSwapContractAddress(chain) {
 var ONDO_POLL_INTERVAL_MS = 15e3;
 var ONDO_QUOTE_EXPIRY_THRESHOLD_MS = 5e3;
 var DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE = DecimalString("1000");
+var ONDO_SETTLEMENT_ASSET = USDC_SYMBOL;
+var DEFAULT_ONDO_SELL_TOKENS_TO_COMPUTE_PRICE = 1;
 var ONDO_SUPPORTED_INPUT_ASSETS = [
   USDC_SYMBOL
 ];
 
 // src/shared/core/checkout/ondo/math.ts
-function computeOndoPrice(transaction) {
+function computeOndoBuyPrice(transaction) {
   const { notionalValue, receiveOutputAmount } = transaction;
-  if (receiveOutputAmount.raw <= 0n) {
-    throw new ValidationError(
-      "Ondo price: receiveOutputAmount must be greater than zero"
-    );
+  return pricePerShare({
+    usd: notionalValue,
+    shares: receiveOutputAmount
+  });
+}
+function computeOndoSellPrice(transaction) {
+  const { expected, spendInputAmount } = transaction;
+  return pricePerShare({
+    usd: grossProceeds(expected),
+    shares: spendInputAmount
+  });
+}
+function grossProceeds(expected) {
+  const raw = expected.quantity.raw + expected.fee.raw;
+  if (raw > MAX_UINT_256) {
+    throw new MathError(`Ondo sell proceeds: out of uint256 bounds (${raw})`);
   }
-  const scaled = notionalValue.raw * 10n ** BigInt(receiveOutputAmount.decimals);
-  const raw = scaled / receiveOutputAmount.raw;
+  return BlockchainAmount.add(expected.quantity, expected.fee);
+}
+function pricePerShare({
+  usd,
+  shares
+}) {
+  const price = BlockchainAmount.div(usd, shares);
   return BlockchainAmount({
-    raw: assertPriceFits(raw),
-    decimals: notionalValue.decimals
+    raw: assertPriceFits(price.raw),
+    decimals: price.decimals
   });
 }
 function assertPriceFits(raw) {
   try {
     return assertUint256(raw);
   } catch {
-    throw new ValidationError(`Ondo price: out of uint256 bounds (${raw})`);
+    throw new MathError(`Ondo price: out of uint256 bounds (${raw})`);
   }
 }
 
@@ -1567,47 +1639,122 @@ var OndoQuote = {
     };
   }
 };
-var OndoSwapTransaction = {
+var OndoBuyTransaction = {
   fromDto: (dto) => {
-    const inputDecimals = AssetDecimals(dto.pay_input_decimals);
+    const spendDecimals = AssetDecimals(dto.spend_input_decimals);
     const outputDecimals = AssetDecimals(dto.receive_output_decimals);
     return {
-      tx: {
-        to: EvmContractAddress(dto.to),
-        data: HexEncodedTransactionData(dto.data)
-      },
-      expiresAt: parseExpiresAt(dto.expires_at),
-      payInputAmount: blockchainAmountFromRawOrThrow({
-        label: "pay_input_amount",
-        raw: dto.pay_input_amount,
-        decimals: inputDecimals
-      }),
+      ...parseSwapCore(dto, spendDecimals),
+      side: "buy",
       fee: blockchainAmountFromRawOrThrow({
         label: "fee",
         raw: dto.fee,
-        decimals: inputDecimals
+        decimals: spendDecimals
       }),
       notionalValue: blockchainAmountFromRawOrThrow({
         label: "notional_value",
         raw: dto.notional_value,
-        decimals: inputDecimals
+        decimals: spendDecimals
       }),
-      receiveOutputAmount: parseReceiveOutputAmount(
-        dto.receive_output_amount,
-        outputDecimals
-      )
+      receiveOutputAmount: parsePositiveAmount({
+        label: "receive_output_amount",
+        raw: dto.receive_output_amount,
+        decimals: outputDecimals,
+        // A transaction that yields nothing is not one to sign - the user
+        // would pay the deposit and receive no asset - and frontline refuses
+        // to emit one. A zero here is a changed encoding, not a small order.
+        // Rejecting it at the boundary is also what lets `computeOndoBuyPrice`
+        // divide by it without a fallible result: the failure surfaces as the
+        // data hook's ERROR state rather than as a division during render.
+        reason: "a buy that yields nothing is not fillable"
+      })
     };
   }
 };
-function parseReceiveOutputAmount(raw, decimals) {
-  const amount = blockchainAmountFromRawOrThrow({
-    label: "receive_output_amount",
+var OndoSellTransaction = {
+  fromDto: (dto) => {
+    const spendDecimals = AssetDecimals(dto.spend_input_decimals);
+    const outputDecimals = AssetDecimals(dto.receive_output_decimals);
+    const expectedQuantity = parsePositiveAmount({
+      label: "expected_quantity",
+      raw: dto.expected_quantity,
+      decimals: outputDecimals,
+      reason: "a sale that yields nothing is not fillable"
+    });
+    return {
+      ...parseSwapCore(dto, spendDecimals),
+      side: "sell",
+      expected: {
+        quantity: expectedQuantity,
+        fee: blockchainAmountFromRawOrThrow({
+          label: "expected_fee",
+          raw: dto.expected_fee,
+          decimals: outputDecimals
+        })
+      },
+      minimum: {
+        quantity: parseMinimumQuantity(
+          dto.minimum_quantity,
+          outputDecimals,
+          expectedQuantity
+        ),
+        fee: blockchainAmountFromRawOrThrow({
+          label: "minimum_fee",
+          raw: dto.minimum_fee,
+          decimals: outputDecimals
+        })
+      }
+    };
+  }
+};
+function parseSwapCore(dto, spendDecimals) {
+  return {
+    tx: {
+      to: EvmContractAddress(dto.to),
+      data: HexEncodedTransactionData(dto.data)
+    },
+    expiresAt: parseExpiresAt(dto.expires_at),
+    spendInputAmount: parsePositiveAmount({
+      label: "spend_input_amount",
+      raw: dto.spend_input_amount,
+      decimals: spendDecimals,
+      // A transaction that takes nothing from the wallet is not one to sign:
+      // it would settle one leg of a trade and skip the other. Frontline
+      // refuses an `amount` of zero whichever way the trade runs, so this is a
+      // changed encoding rather than a small order.
+      //
+      // Guarded on both sides rather than on the sale alone, because which
+      // amount becomes the divisor in the price flips with the direction: a
+      // guard placed by that would be a rule about the arithmetic rather than
+      // about the trade.
+      reason: "a swap that spends nothing is not fillable"
+    })
+  };
+}
+function parseMinimumQuantity(raw, decimals, expectedQuantity) {
+  const amount = parsePositiveAmount({
+    label: "minimum_quantity",
     raw,
-    decimals
+    decimals,
+    reason: "a floor of zero guarantees nothing"
   });
+  if (amount.raw > expectedQuantity.raw) {
+    throw new ValidationError(
+      `minimum_quantity: must not exceed expected_quantity ("${raw}" > "${expectedQuantity.raw}")`
+    );
+  }
+  return amount;
+}
+function parsePositiveAmount({
+  label,
+  raw,
+  decimals,
+  reason
+}) {
+  const amount = blockchainAmountFromRawOrThrow({ label, raw, decimals });
   if (amount.raw <= 0n) {
     throw new ValidationError(
-      `receive_output_amount: must be greater than zero ("${raw}")`
+      `${label}: must be greater than zero ("${raw}") - ${reason}`
     );
   }
   return amount;
@@ -1644,27 +1791,57 @@ async function getOndoQuote(api, params) {
   });
   return OndoQuote.fromDto(dto);
 }
-async function buildOndoSwapTransaction(api, params) {
+async function buildOndoBuy(api, params) {
   const dto = await api.send({
     method: "POST",
-    url: "/v1/ondo/swap/transaction",
-    body: {
-      symbol: params.symbol,
-      chain: params.chain,
-      wallet_address: params.walletAddress,
-      amount: params.amount.raw.toString()
-    },
+    url: "/v1/ondo/swap/buy",
+    body: swapBody(params),
     attributes: Attributes.protected()
   });
-  assertFundingScaleAgrees(dto, params);
-  return OndoSwapTransaction.fromDto(dto);
+  assertSpendScaleAgrees({
+    published: dto.spend_input_decimals,
+    sized: params.amount,
+    trade: "purchase"
+  });
+  return OndoBuyTransaction.fromDto(dto);
 }
-function assertFundingScaleAgrees(dto, params) {
-  if (dto.pay_input_decimals !== params.amount.decimals) {
-    throw new ValidationError(
-      `pay_input_decimals: the swap was priced in ${dto.pay_input_decimals} decimals but the order was sized in ${params.amount.decimals}`
-    );
-  }
+async function buildOndoSell(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/ondo/swap/sell",
+    body: swapBody(params),
+    attributes: Attributes.protected()
+  });
+  assertSpendScaleAgrees({
+    published: dto.spend_input_decimals,
+    sized: params.amount,
+    trade: "sale",
+    // The two answers come from two chains, so on a testnet they can disagree
+    // for a reason that is neither the caller's nor a corrupt response. Say so,
+    // or a QA run reads as a puzzle rather than a diagnosis.
+    note: "the quote resolves the asset on Ethereum mainnet while the swap executes on the chain requested, so these disagree until frontline serves a chain-scoped quote"
+  });
+  return OndoSellTransaction.fromDto(dto);
+}
+function swapBody(params) {
+  return {
+    symbol: params.symbol,
+    chain: params.chain,
+    wallet_address: params.walletAddress,
+    amount: params.amount.raw.toString()
+  };
+}
+function assertSpendScaleAgrees({
+  published,
+  sized,
+  trade,
+  note
+}) {
+  if (published === sized.decimals) return;
+  const because = note === void 0 ? "" : ` - ${note}`;
+  throw new ValidationError(
+    `spend_input_decimals: the ${trade} was priced in ${published} decimals but the order was sized in ${sized.decimals}${because}`
+  );
 }
 function sizeParam(params) {
   const tokenAmount = "tokenAmount" in params ? params.tokenAmount : void 0;
@@ -1703,10 +1880,16 @@ var OndoNamespaceImpl = class {
       return getOndoQuote(this.ctx.api, params);
     });
   }
-  async buildSwapTransaction(params) {
-    return this.log.wrap("buildSwapTransaction", params, async () => {
+  async buildBuyTransaction(params) {
+    return this.log.wrap("buildBuyTransaction", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return buildOndoBuy(this.ctx.api, params);
+    });
+  }
+  async buildSellTransaction(params) {
+    return this.log.wrap("buildSellTransaction", params, async () => {
       await this.ctx.ensureUserAuthenticated();
-      return buildOndoSwapTransaction(this.ctx.api, params);
+      return buildOndoSell(this.ctx.api, params);
     });
   }
 };
@@ -2473,27 +2656,47 @@ var TokenMetadata = {
       logoDark: dto.logo_dark === void 0 ? null : TokenLogo.fromDto(dto.logo_dark, baseUrl)
     };
   },
+  /**
+   * Maps the complete registry snapshot to every token it lists across the
+   * chains this SDK models, skipping native coins and chains outside
+   * {@link EthereumChain} (e.g. Solana) rather than failing on them — the
+   * registry may serve chains ahead of the SDK's type surface.
+   */
+  fromRegistryDto: (dto, baseUrl) => {
+    assertSupportedSchemaVersion(dto.schema_version);
+    return dto.chains.flatMap((chainDto) => {
+      let chain;
+      try {
+        chain = EthereumChain(chainDto.chain);
+      } catch {
+        return [];
+      }
+      return tokensOfChain(chain, chainDto.assets, baseUrl);
+    });
+  },
   /**
    * Maps a chain snapshot to the tokens it lists, skipping the chain's native
    * coin (`kind: 'COIN'`, no contract address).
    */
   fromChainAssetsDto: (dto, baseUrl) => {
     assertSupportedSchemaVersion(dto.schema_version);
-    const chain = EthereumChain(dto.chain);
-    return dto.assets.filter((asset) => asset.kind === "TOKEN" && asset.address !== void 0).map((asset) => ({
-      identifier: {
-        chain,
-        // The filter above cannot narrow `address` for the type checker.
-        address: EvmContractAddress(asset.address)
-      },
-      name: asset.name,
-      symbol: AssetSymbol(asset.symbol),
-      decimals: AssetDecimals(asset.decimals),
-      logo: TokenLogo.fromDto(asset.logo, baseUrl),
-      logoDark: asset.logo_dark === void 0 ? null : TokenLogo.fromDto(asset.logo_dark, baseUrl)
-    }));
+    return tokensOfChain(EthereumChain(dto.chain), dto.assets, baseUrl);
   }
 };
+function tokensOfChain(chain, assets, baseUrl) {
+  return assets.filter((asset) => asset.kind === "TOKEN" && asset.address !== void 0).map((asset) => ({
+    identifier: {
+      chain,
+      // The filter above cannot narrow `address` for the type checker.
+      address: EvmContractAddress(asset.address)
+    },
+    name: asset.name,
+    symbol: AssetSymbol(asset.symbol),
+    decimals: AssetDecimals(asset.decimals),
+    logo: TokenLogo.fromDto(asset.logo, baseUrl),
+    logoDark: asset.logo_dark === void 0 ? null : TokenLogo.fromDto(asset.logo_dark, baseUrl)
+  }));
+}
 function assertSupportedSchemaVersion(version) {
   if (version !== 1) {
     throw new ValidationError(
@@ -2562,6 +2765,29 @@ async function fetchTokensMetadata(client, chain) {
   }
   return TokenMetadata.fromChainAssetsDto(response.body, client.config.baseUrl);
 }
+async function fetchAllTokensMetadata(client) {
+  let response;
+  try {
+    response = await client.send({
+      method: "GET",
+      url: `/assets.json`
+    });
+  } catch (error) {
+    if (isRegistryHtmlFallback(error)) {
+      throw new ValidationError(
+        "Token registry returned non-JSON for the complete snapshot"
+      );
+    }
+    throw error;
+  }
+  assertOk(response);
+  if (response.body === null) {
+    throw new ValidationError(
+      "Token registry returned an empty complete snapshot"
+    );
+  }
+  return TokenMetadata.fromRegistryDto(response.body, client.config.baseUrl);
+}
 function isRegistryHtmlFallback(error) {
   return error instanceof HttpError && error.response.status >= 200 && error.response.status < 300;
 }
@@ -2600,7 +2826,7 @@ var TokensNamespaceImpl = class {
     return this.log.wrap(
       "list",
       chain,
-      () => fetchTokensMetadata(this.api, chain)
+      () => chain === void 0 ? fetchAllTokensMetadata(this.api) : fetchTokensMetadata(this.api, chain)
     );
   }
 };
@@ -2803,6 +3029,7 @@ var User = {
   Cursor,
   DEFAULT_AMOUNT_TO_COMPUTE_PRICE,
   DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE,
+  DEFAULT_ONDO_SELL_TOKENS_TO_COMPUTE_PRICE,
   DEFAULT_SLIPPAGE_BPS,
   DecimalString,
   DocumentSubmission,
@@ -2825,6 +3052,7 @@ var User = {
   Link,
   MAX_ASSET_DECIMALS,
   MAX_UINT_256,
+  MathError,
   Milestone,
   NA_AMOUNT_ASSET_UI,
   NotAuthenticatedError,
@@ -2833,6 +3061,7 @@ var User = {
   OAuthSession,
   ONDO_POLL_INTERVAL_MS,
   ONDO_QUOTE_EXPIRY_THRESHOLD_MS,
+  ONDO_SETTLEMENT_ASSET,
   ONDO_SUPPORTED_INPUT_ASSETS,
   Offer,
   OfferDetail,
@@ -2845,9 +3074,10 @@ var User = {
   OfferSlug,
   OfferToken,
   OffersNamespaceImpl,
+  OndoBuyTransaction,
   OndoNamespaceImpl,
   OndoQuote,
-  OndoSwapTransaction,
+  OndoSellTransaction,
   OndoTradingStatus,
   PKCEState,
   PaginatedResponse,
@@ -2907,7 +3137,8 @@ var User = {
   assetAmount,
   blockchainAmountFromRawOrThrow,
   chainFromId,
-  computeOndoPrice,
+  computeOndoBuyPrice,
+  computeOndoSellPrice,
   computePrice,
   computeSlip,
   decodeSwappedOutputAmount,