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

package/dist/server/index.cjs

@@ -240,6 +240,12 @@ var InvariantError = class extends Error {
     this.name = "InvariantError";
   }
 };
+var MathError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MathError";
+  }
+};
 
 // src/shared/core/observability/log-cause.ts
 function classifyLogCause(error) {
@@ -252,6 +258,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" };
   }
@@ -902,7 +911,9 @@ async function fetchAllPages(fetchPage, baseParams) {
 // 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)) {
@@ -951,9 +962,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(
@@ -1694,7 +1721,9 @@ var USD_FRACTION_DIGITS = AssetDecimals(2);
 // 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 chainFromId(chainId) {
   const chains = Object.keys(CHAIN_IDS);
@@ -1770,47 +1799,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;
@@ -1847,27 +1951,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;
@@ -1906,10 +2040,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);
     });
   }
 };
@@ -1981,27 +2121,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(
@@ -2070,6 +2230,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;
 }
@@ -2108,7 +2291,7 @@ var TokensNamespaceImpl = class {
     return this.log.wrap(
       "list",
       chain,
-      () => fetchTokensMetadata(this.api, chain)
+      () => chain === void 0 ? fetchAllTokensMetadata(this.api) : fetchTokensMetadata(this.api, chain)
     );
   }
 };