@coinlist-co/react 0.11.1-rc.209af8d → 0.11.1-rc.578d93b

package/dist/{chunk-3Z4PLLV7.js → chunk-HYC4JARU.js}

@@ -202,6 +202,12 @@ var InvariantError = class extends Error {
     this.name = "InvariantError";
   }
 };
+var MathError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MathError";
+  }
+};
 
 // src/shared/api/pagination.ts
 async function fetchAllPages(fetchPage, baseParams) {
@@ -277,9 +283,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(
@@ -517,6 +539,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" };
   }
@@ -1196,47 +1221,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;
@@ -1273,27 +1373,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;
@@ -1332,10 +1462,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);
     });
   }
 };
@@ -2135,6 +2271,7 @@ export {
   NotAuthenticatedError,
   ValidationError,
   InvariantError,
+  MathError,
   describeErrorUnredacted,
   internalLogger,
   HttpClient,
@@ -2215,7 +2352,8 @@ export {
   Ticker,
   OndoTradingStatus,
   OndoQuote,
-  OndoSwapTransaction,
+  OndoBuyTransaction,
+  OndoSellTransaction,
   OndoNamespaceImpl,
   SuperstateSwapNamespaceImpl,
   fetchOffers,
@@ -2246,4 +2384,4 @@ export {
   OAuthRefreshToken,
   OAuthSession
 };
-//# sourceMappingURL=chunk-3Z4PLLV7.js.map
+//# sourceMappingURL=chunk-HYC4JARU.js.map