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

package/dist/{config-C6vlghJY.d.cts → config-CMl1bR3F.d.cts}

@@ -302,7 +302,7 @@ type LogBinding = {
 };
 /**
  * Every {@link LogBinding} applied so far, merged. This is what reaches a
- * host, so a line from `prepareOndoSwap` carries `flow: 'prepareSwap'` as its
+ * host, so a line from `prepareOndoSell` carries `flow: 'prepareSell'` as its
  * own key and is filterable without parsing anything.
  */
 type LogBindings = {
@@ -499,6 +499,21 @@ type LogCause =
     type: 'invariant';
     message: string;
 }
+/**
+ * Every operand was well-formed and the arithmetic on them still had no
+ * answer: a division by zero, a result outside the range its type can hold.
+ * `message` is an SDK-authored template, like `validation`'s.
+ *
+ * Separate from `invariant` because the remedy differs. An `invariant` says
+ * the SDK computed something impossible and is a bug to report against the
+ * SDK; a `math` says the operation was well-posed and the operands, which
+ * came off the wire, admit no result - so it points at the response the same
+ * way `validation` does, one step later.
+ */
+ | {
+    type: 'math';
+    message: string;
+}
 /** An API-backed call was made without a logged-in user. */
  | {
     type: 'not-authenticated';
@@ -542,7 +557,7 @@ type LogCause =
  * here until it is listed, which is what keeps the constructor total.
  */
 declare const ETHEREUM_CHAINS: Record<EthereumChain, true>;
-type EthereumChain = 'ethereum_mainnet' | 'ethereum_sepolia';
+type EthereumChain = 'ethereum_mainnet' | 'ethereum_sepolia' | 'base_mainnet' | 'base_sepolia';
 /**
  * Validates that a raw backend string names a chain the SDK supports.
  *
@@ -690,7 +705,7 @@ type BlockchainAmount = Newtype<{
 /**
  * Constructs a {@link BlockchainAmount} and exposes arithmetic helpers.
  * TypeScript has no operator overloading, so use `BlockchainAmount.add(a, b)`
- * instead of `+`/`-` on the objects directly.
+ * instead of `+`/`-`/`*`/`/` on the objects directly.
  */
 declare const BlockchainAmount: ((value: {
     raw: Uint256;
@@ -698,7 +713,57 @@ declare const BlockchainAmount: ((value: {
 }) => BlockchainAmount) & {
     add: (a: BlockchainAmount, b: BlockchainAmount) => BlockchainAmount;
     sub: (a: BlockchainAmount, b: BlockchainAmount) => BlockchainAmount;
+    mul: typeof multiplyAmounts;
+    div: typeof divideAmounts;
 };
+/**
+ * `a * b`, denominated in `a`'s decimals - a price times a quantity, an amount
+ * times a rate.
+ *
+ * The exact inverse of {@link divideAmounts}, and it reads the same way round:
+ * the answer stays in `a`'s scale and `b`'s divides back out, so the two
+ * compose - `mul(div(a, b), b)` is `a` again, short only what truncation took.
+ * That is what makes `price x quantity` land in the currency the price was
+ * quoted in rather than at some product of two exponents no token uses.
+ *
+ * The multiplication happens *before* the division by `10^b.decimals`, so the
+ * full precision of both operands survives into the one rounding at the end.
+ * Like `div` it truncates towards zero on both signs, which is the safe
+ * direction for money: a total is never inflated past what the parts hold.
+ *
+ * Total - unlike `div`, there is nothing here to reject. The scale it divides
+ * by is a power of ten, never zero, and a product is not bounds-checked for
+ * the same reason a quotient is not: whether one past uint256 is a corrupt
+ * response or an expected magnitude belongs to the caller.
+ */
+declare function multiplyAmounts(a: BlockchainAmount, b: BlockchainAmount): BlockchainAmount;
+/**
+ * `a / b`, denominated in `a`'s decimals - a price, a ratio, a rate.
+ *
+ * Unlike {@link combineAmounts}, the two operands may be at different scales,
+ * and usually are: dividing dollars by shares is the point of the operation,
+ * and the two tokens rarely share an exponent. `b`'s scale divides back out -
+ * the numerator is scaled by `10^b.decimals` *before* the division, so nothing
+ * is lost to integer truncation early and the quotient lands in `a`'s scale,
+ * which is the one the amounts it is rendered beside are in.
+ *
+ * Truncates towards zero on both signs, which is what BigInt division already
+ * does and the safe direction for money: the total a price implies never
+ * exceeds, in magnitude, the amount that actually moved.
+ *
+ * A zero divisor is the only rejection. The quotient is deliberately *not*
+ * bounds-checked the way {@link combineAmounts} checks a sum: scaling the
+ * numerator carries even legal pairs past uint256 (a maximal amount over a
+ * single base unit), and whether that reads as a corrupt response or an
+ * expected magnitude is the caller's to judge - see `computeOndoBuyPrice` and
+ * `computeOndoSellPrice`, which bounds-check the price they build out of this.
+ *
+ * @throws MathError when `b` is zero. `add` and `sub` throw a bare `Error`
+ * because a scale mismatch is a programming error caught in review; a zero
+ * divisor arrives from a server response and is divided by during render, so
+ * it is a named failure a screen can catch and map to a failed state.
+ */
+declare function divideAmounts(a: BlockchainAmount, b: BlockchainAmount): BlockchainAmount;
 type AssetSymbol = Newtype<string, 'AssetSymbol'>;
 declare const AssetSymbol: (value: string) => AssetSymbol;
 /**
@@ -1498,53 +1563,98 @@ type GetOndoQuoteParams = {
     duration?: OndoQuoteDuration;
 } & OndoQuoteSize;
 /**
- * What it takes to turn an indicative price into signed, fillable calldata.
- *
- * Sized by `amount` alone - the coin being spent, in its own base units - with
- * no `notionalValue` alternative: the calldata authorises a specific ERC-20
- * pull, so the number that ends up on chain has to be the number the caller
- * meant, not one derived from a dollar figure. It is the **gross**: CoinList's
- * fee comes off it, and Ondo prices the remainder.
+ * What both builders take, before the one field whose meaning forks.
  *
- * Buy-only, so there is no `side`. There is no funding token either - frontline
- * resolves both tokens from the offer, because Ninshubur signs a request bound
- * to them and a caller that could name them could have CoinList sign for a
- * contract of its own.
+ * There is no funding token and no asset here - frontline resolves both from
+ * the offer, because Ninshubur signs a request bound to them and a caller that
+ * could name them could have CoinList sign for a contract of its own. Which
+ * endpoint was called is what says which of the two `amount` counts.
  *
- * `chain` is required here although the read params refuse it, because this
- * one names a real contract on a real chain rather than asking Ondo for a
- * price. `walletAddress` must be the wallet that will *send* the transaction:
- * the calldata is signed over it, so a transaction built for one wallet and
- * broadcast by another reverts.
+ * `chain` is required although the read params refuse it, because these name a
+ * real contract on a real chain rather than asking Ondo for a price.
  */
-type BuildOndoSwapTransactionParams = {
+type BuildOndoSwapParamsCore = {
     symbol: AssetSymbol;
     chain: EthereumChain;
-    /** The wallet that will broadcast, and that receives the asset. */
+    /**
+     * The wallet that will *send* the transaction, and that receives the other
+     * token. The calldata is signed over it, so a transaction built for one
+     * wallet and broadcast by another reverts.
+     */
     walletAddress: EvmWalletAddress;
+};
+/**
+ * What it takes to turn an indicative price into signed, fillable calldata for
+ * a purchase: `POST /v1/ondo/swap/buy`.
+ *
+ * Separate from {@link BuildOndoSellParams} although the fields match today,
+ * because `amount` is denominated in a different token on each - which is
+ * frontline's own reason for splitting the endpoint rather than taking a
+ * `side`. Sharing one type would re-merge the distinction the split exists to
+ * make, and the two will diverge the day either side gains a knob.
+ */
+type BuildOndoBuyParams = BuildOndoSwapParamsCore & {
     /**
-     * The gross amount to spend, in the funding token's base units.
+     * The **gross** deposit, in the base units of the funding token - the coin
+     * the user chose and approved.
+     *
+     * Sized by `amount` alone, with no `notionalValue` alternative: the calldata
+     * authorises a specific ERC-20 pull, so the number that ends up on chain has
+     * to be the number the caller meant rather than one derived from a dollar
+     * figure. CoinList's fee comes off it, and Ondo prices the remainder.
      *
-     * Its `decimals` are also what the response's `pay_input_decimals` is
+     * Its `decimals` are also what the response's `spend_input_decimals` is
      * checked against: frontline resolves the funding token from the offer
      * rather than from this request, so the two are independent answers to the
      * same question and a disagreement means the wrong token was sized.
      */
     amount: BlockchainAmount;
 };
+/**
+ * What it takes to turn an indicative price into signed, fillable calldata for
+ * a sale: `POST /v1/ondo/swap/sell`.
+ *
+ * See {@link BuildOndoBuyParams} for why this is its own type.
+ */
+type BuildOndoSellParams = BuildOndoSwapParamsCore & {
+    /**
+     * The quantity of the **asset** to sell, in the asset's own base units - not
+     * in the funding token's, which is the same integer meaning something 1e12
+     * different.
+     *
+     * This is the figure the wallet must have approved: a sale delivers the
+     * asset, so the swap contract pulls it with `transferFrom` exactly as it
+     * pulls the deposit on a purchase.
+     *
+     * Its `decimals` are checked against the response's `spend_input_decimals`,
+     * which frontline reads on-chain from the asset on `chain`. The SDK's own
+     * answer comes from the quote, which resolves the asset on Ethereum mainnet,
+     * so on a testnet these are two independent resolutions of two different
+     * contracts - and the check is what says so.
+     */
+    amount: BlockchainAmount;
+};
 
 /**
  * Raw JSON models for the Ondo swap endpoints, mirroring
- * `OndoSwapTradingStatus`, `OndoSwapQuote` and `OndoSwapTransaction` in
- * frontline's OpenAPI schema. The two GETs are free to poll: neither spends an
- * attestation, so a client may call them while the user edits an order. The
- * POST ({@link OndoSwapTransactionDto}) is not - it spends one and hands back
- * signed calldata with a deadline.
+ * `OndoSwapTradingStatus`, `OndoSwapQuote`, `OndoSwapBuy` and `OndoSwapSell`
+ * in frontline's OpenAPI schema. The two GETs are free to poll: neither spends
+ * an attestation, so a client may call them while the user edits an order. The
+ * two POSTs are not - each spends one and hands back signed calldata with a
+ * deadline.
+ *
+ * **One endpoint per side, and therefore one model per side.** The reads take
+ * a `side` and answer the same shape either way, so they stay single. The
+ * writes do not: a buy commits to an exact quantity, a sell to a range with a
+ * floor beneath it, and `amount` is the funding token on one and the asset on
+ * the other. Only the transport fields mean the same thing on both.
+ * `POST /v1/ondo/swap/transaction` survives as a deprecated alias of the buy
+ * under the old `pay_input_*` names; the SDK does not call it.
  *
  * Neither GET takes a `chain`. Ondo runs no sandbox, so every environment
- * prices against Ondo production on Ethereum mainnet. The POST does carry one:
- * it targets a real contract, which on every environment but production is the
- * Sepolia one with the mocked attestation.
+ * prices against Ondo production on Ethereum mainnet. The POSTs do carry one:
+ * they target a real contract, which on every environment but production is
+ * the Sepolia one with the mocked attestation.
  */
 /**
  * Whether an asset can be traded right now, and the caps if so.
@@ -1607,34 +1717,19 @@ type OndoQuoteDto = {
     price: string;
 };
 /**
- * Signed, ready-to-broadcast calldata for a buy, and the amounts it commits
- * to: `POST /v1/ondo/swap/transaction`.
- *
- * Unlike {@link OndoQuoteDto} this **spends an attestation**, so it is not
- * pollable: one call per order, plus one per user-requested refresh. Frontline
- * also reads the wallet's allowance before asking Ninshubur for anything, so
- * an unapproved wallet is refused here rather than reverting on chain.
- *
- * Buy-only. There is no `side`: the funding token goes in and the asset comes
- * out, both resolved from the offer, so a caller cannot name either.
+ * The transport half of a built swap, identical on both sides.
  *
- * **Carries no identity and no price.** No `chain_id`, `symbol`, `ticker`,
- * `side` or `price` - the request named the first few and frontline drops
- * Ninshubur's `price` deliberately, because `GET /v1/ondo/swap/quote` already
- * publishes one under that name at a different scale. Anything the UI needs
- * beyond the amounts comes from that GET or from the offer.
+ * `spend_input_amount` is the only key here whose *token* depends on the side,
+ * and `spend_input_decimals` is what says at what scale. Everything below this
+ * point differs, which is why the two responses are two types rather than one
+ * with nullable halves.
  *
- * Every amount is a uint256 decimal string in one of two scales, and **both
- * scales are on the wire**: `receive_output_amount` is in
- * `receive_output_decimals`, and the other three are in
- * `pay_input_decimals`. Neither is interchangeable with the quote's
- * `asset_decimals`, which answers for a different number - see the two fields
- * below.
- *
- * The response has no `object` envelope. `action` says what to do with the
- * body, matching `AllowWalletResponseDto`.
+ * There is no `object` envelope and no `side` echo. `action` says what to do
+ * with the body, matching `AllowWalletResponseDto`; which trade it encodes is
+ * settled by the endpoint that was called, so nothing on the wire has to say
+ * it and nothing has to be checked against it.
  */
-type OndoSwapTransactionDto = {
+type OndoSwapDtoCore = {
     action: 'broadcast_transaction';
     /** The swap contract the transaction is sent to. */
     to: string;
@@ -1648,36 +1743,74 @@ type OndoSwapTransactionDto = {
      */
     expires_at: string;
     /**
-     * Gross amount the wallet pays, echoing the requested `amount`, in the
-     * funding token's smallest unit. The approval is compared against this.
+     * Gross amount the wallet spends, echoing the requested `amount`, in the
+     * smallest unit of the token this side spends - the funding token on a buy,
+     * the asset on a sell. The approval is compared against this.
+     *
+     * Named `pay_input_amount` on the deprecated
+     * `POST /v1/ondo/swap/transaction`. `pay` was accurate only while a buy was
+     * the sole thing this could encode: a sell delivers the asset rather than
+     * paying for one.
      */
-    pay_input_amount: string;
+    spend_input_amount: string;
     /**
-     * Decimals `pay_input_amount`, `fee` and `notional_value` are counted in.
+     * Decimals `spend_input_amount` is counted in.
+     *
+     * Frontline reads it on-chain from the token the side spends, which it
+     * resolves from the offer rather than from anything the caller sent. That
+     * makes it the only published scale for a token the request never names -
+     * and an independent answer to the one the SDK derived when it sized the
+     * order, which is why both builders compare the two.
      *
-     * Frontline reads it on-chain from the funding token, which it resolves from
-     * the offer rather than from anything the caller sent. That makes it the
-     * only published scale for a token the request never names - and an
-     * independent answer to the one the SDK derived when it sized the order,
-     * which is why `buildOndoSwapTransaction` compares the two.
+     * **The same key, two scales.** It counts whichever token the side spends:
+     * the funding token's 6 on a buy, the asset's 18 on a sell. Worth knowing
+     * before integrating against both.
      */
-    pay_input_decimals: number;
+    spend_input_decimals: number;
+};
+/**
+ * Signed, ready-to-broadcast calldata for a purchase, and the amounts it
+ * commits to: `POST /v1/ondo/swap/buy`.
+ *
+ * Unlike {@link OndoQuoteDto} this **spends an attestation**, so it is not
+ * pollable: one call per order, plus one per user-requested refresh. Frontline
+ * also reads the wallet's allowance on the funding token before asking
+ * Ninshubur for anything, so an unapproved wallet is refused here rather than
+ * reverting on chain.
+ *
+ * The quantity is attested and exact, with no floor beneath it, which is what
+ * separates a buy from an {@link OndoSellDto}.
+ *
+ * **Carries no identity and no price.** No `chain_id`, `symbol`, `ticker` or
+ * `price` - the request named the first few and frontline drops Ninshubur's
+ * `price` deliberately, because `GET /v1/ondo/swap/quote` already publishes
+ * one under that name at a different scale. Anything the UI needs beyond the
+ * amounts comes from that GET or from the offer.
+ *
+ * Two scales are on the wire: `fee` and `notional_value` are in
+ * `spend_input_decimals`, and `receive_output_amount` is in
+ * `receive_output_decimals`. Neither is interchangeable with the quote's
+ * `asset_decimals`, which answers for a different number.
+ */
+type OndoBuyDto = OndoSwapDtoCore & {
     /**
-     * CoinList's cut of `pay_input_amount`, in the same units. Taken off the
-     * deposit rather than added on top, so the approval never has to cover more.
-     * `"0"` until ENG-1718 turns a fee on - frontline rejects a non-zero one
-     * today.
+     * CoinList's cut of `spend_input_amount`, in the same units. `"0"` until
+     * ENG-1718 turns a fee on - frontline rejects a non-zero one today.
+     *
+     * Taken at execution rather than added on top, so the wallet never approves
+     * more than `spend_input_amount`.
      */
     fee: string;
     /**
-     * `pay_input_amount` less `fee`, in the same units. This is the amount Ondo
-     * actually priced, and the numerator of the fill price.
+     * `spend_input_amount` less `fee`, in `spend_input_decimals`: the part that
+     * reaches Ondo, what the quantity was priced against, and what the
+     * signature commits to.
      */
     notional_value: string;
     /**
-     * Quantity of the asset the wallet receives, in the *asset's* smallest unit,
-     * e.g. `"264000000000000000"`. Scale it by `receive_output_decimals`, not by
-     * the funding token's and not by {@link OndoQuoteDto}'s `asset_decimals`.
+     * Quantity of the asset the wallet receives, in the asset's smallest unit.
+     * Scale it by `receive_output_decimals`, not by the funding token's and not
+     * by {@link OndoQuoteDto}'s `asset_decimals`.
      */
     receive_output_amount: string;
     /**
@@ -1691,6 +1824,74 @@ type OndoSwapTransactionDto = {
      */
     receive_output_decimals: number;
 };
+/**
+ * Signed, ready-to-broadcast calldata for a sale, and the range it commits to:
+ * `POST /v1/ondo/swap/sell`.
+ *
+ * Like {@link OndoBuyDto} it **spends an attestation** and expires, so it is
+ * called once on confirmation and never on a timer. Frontline reads the
+ * wallet's allowance on the **asset** before signing - a sell delivers it -
+ * and refuses a short one with a 422 naming that address.
+ *
+ * **A sell commits to a range rather than a quantity.** Ondo settles through
+ * USDon before converting to the settlement token, so the response publishes
+ * what to expect and the floor the calldata enforces, each with the fee
+ * charged at it. There is no `notional_value`: a sell commits on the output
+ * side, so there is no fee-exclusive input to report and frontline declines to
+ * relate numbers Ninshubur did not relate.
+ *
+ * All four amounts below are in `receive_output_decimals`. The one amount that
+ * is not is `spend_input_amount`, in `spend_input_decimals` - see
+ * {@link OndoSwapDtoCore}.
+ *
+ * One thing the response does not say, and the calldata does: the floor signed
+ * into `data` is **gross** of CoinList's fee, so a caller decoding it finds a
+ * larger number than `minimum_quantity`. Both are correct; `minimum_quantity`
+ * is what the wallet actually receives.
+ */
+type OndoSellDto = OndoSwapDtoCore & {
+    /**
+     * CoinList's cut at the expected outcome, in the settlement token. Already
+     * deducted from `expected_quantity` rather than charged on top of it.
+     *
+     * `"0"` until ENG-1718 turns a fee on - frontline rejects a non-zero one on
+     * either side today.
+     */
+    expected_fee: string;
+    /**
+     * What the sale is expected to return, **net of `expected_fee`**, in the
+     * settlement token's smallest unit.
+     *
+     * An expectation rather than a guarantee. What the contract enforces is
+     * {@link OndoSellDto.minimum_quantity}.
+     */
+    expected_quantity: string;
+    /**
+     * CoinList's cut at the floor, in the same units.
+     *
+     * A different number from `expected_fee` because the two are charged on
+     * different amounts - which is why frontline publishes both rather than one.
+     * This is the one to disclose worst-case cost with.
+     */
+    minimum_fee: string;
+    /**
+     * The least the wallet can receive, **net of `minimum_fee`**, in the same
+     * units. Below it the transaction reverts on chain.
+     *
+     * Frontline guarantees it is at most `expected_quantity` and greater than
+     * zero. The settlement lands somewhere between the two.
+     */
+    minimum_quantity: string;
+    /**
+     * Decimals both quantities and both fees are counted in, reported by
+     * whatever priced them rather than looked up from the token.
+     *
+     * Not the same number as {@link OndoQuoteDto}'s `asset_decimals`, which
+     * answers for the asset being sold rather than for the coin the proceeds
+     * arrive in.
+     */
+    receive_output_decimals: number;
+};
 
 /**
  * Whether an Ondo asset can be traded right now.
@@ -1735,22 +1936,30 @@ declare const OndoTradingStatus: {
  * contract's `preview`, and no such contract exists for Ondo yet.
  *
  * The quote carries no transaction to broadcast and no expiry. Building one is
- * a separate endpoint that spends an attestation - see
- * {@link OndoSwapTransaction}.
+ * a separate endpoint per side that spends an attestation - see
+ * {@link OndoBuyTransaction} and {@link OndoSellTransaction}.
  */
 type OndoQuote = {
     /** Always `ethereum_mainnet`: Ondo runs no sandbox in any environment. */
     chain: EthereumChain;
     ticker: Ticker;
-    /** Needed to approve or transfer the asset; the quote is the only source. */
+    /**
+     * Needed to approve or transfer the asset; the quote is the only source.
+     *
+     * **Resolved on Ethereum mainnet**, like everything else on this quote, and
+     * therefore not necessarily the contract the swap pulls from on the chain
+     * the order executes on. Frontline resolves that one per chain and publishes
+     * it nowhere, so on a testnet these are two different tokens. Tracked
+     * against the frontline stack that follows ENG-1756.
+     */
     assetAddress: EvmContractAddress;
     /**
      * The asset as the quote resolves it, from frontline's own catalogue.
      *
      * Its `decimals` scale {@link tokenBaseUnits} and nothing else. They are
-     * **not** the scale of an {@link OndoSwapTransaction}'s output: that one is
-     * reported by whatever priced the quantity, the two sources are allowed to
-     * disagree, and only the one that produced a number answers for it.
+     * **not** the scale of a built transaction's spend or output: those are
+     * reported by whatever priced them, the sources are allowed to disagree, and
+     * only the one that produced a number answers for it.
      */
     asset: Erc20Asset;
     side: OrderBookSide;
@@ -1766,26 +1975,22 @@ declare const OndoQuote: {
     fromDto: (dto: OndoQuoteDto) => OndoQuote;
 };
 /**
- * A signed, expiring buy: the calldata that fills it and the amounts it
- * commits to, from `buildSwapTransaction`.
- *
- * Distinct from {@link OndoQuote} in three ways that matter: it costs an
- * attestation to obtain, it expires, and it carries a {@link Tx} the wallet
- * broadcasts verbatim. Treat it as single-use - once broadcast (or once
- * `expiresAt` passes) it is spent, and a new one must be built.
+ * The half of a built swap that both sides share: the calldata, its deadline,
+ * and what the wallet parts with.
  *
- * **It carries no identity.** No chain, ticker, asset or side: the endpoint
- * publishes none of them, and inventing them from the request would assert
- * what the server resolved rather than report it. What it does publish is the
- * scale of every amount on it, so a caller needs nothing alongside it to read
- * the numbers - only to name the asset, which the offer already does.
+ * There is deliberately **no union over the two sides**. Each is built by its
+ * own endpoint and its own namespace method, so a caller never holds one
+ * without knowing which it is, and a union would only re-pose a question the
+ * call site had already answered. What is genuinely common lives here, and
+ * {@link executeOndoSwap} takes this rather than either arm - broadcasting
+ * knows nothing about the direction of the trade.
  *
- * It carries no price either. Divide {@link notionalValue} by
- * {@link receiveOutputAmount} - see `computeOndoPrice` - which is the price
- * this transaction actually fills at rather than an indicative one that has
- * since moved.
+ * `side` is not on this type but on each arm, as a literal the SDK authors
+ * from the method that was called. The wire stopped echoing one when the
+ * endpoint split, and it is still worth carrying: `OndoOrderPlaced` is a union
+ * the SDK builds from both, and that union needs a tag.
  */
-type OndoSwapTransaction = {
+type OndoSwapTransactionCore = {
     /**
      * Broadcast as-is. The `to` is the swap contract, which is also the ERC-20
      * spender the user must have approved.
@@ -1796,16 +2001,51 @@ type OndoSwapTransaction = {
      * reverts, so callers must compare against it before signing.
      */
     expiresAt: Date;
-    /** Gross amount the wallet pays, in the funding token's decimals. */
-    payInputAmount: BlockchainAmount;
     /**
-     * CoinList's cut of {@link payInputAmount}, in the same decimals. Taken off
-     * the deposit rather than added on top, so the approval never has to cover
-     * more than `payInputAmount`. Zero until ENG-1718 lands.
+     * Gross amount the wallet spends, in the decimals of the token this side
+     * spends: the funding token on a buy, the asset on a sell.
+     *
+     * The same field at two scales, which is the whole reason the two sides are
+     * two types. It is also what the approval has to cover.
+     */
+    spendInputAmount: BlockchainAmount;
+};
+/**
+ * A signed, expiring purchase: a funding token in, an exact quantity of the
+ * asset out.
+ *
+ * Distinct from {@link OndoQuote} in three ways that matter: it costs an
+ * attestation to obtain, it expires, and it carries a {@link Tx} the wallet
+ * broadcasts verbatim. Treat it as single-use - once broadcast (or once
+ * `expiresAt` passes) it is spent, and a new one must be built.
+ *
+ * **The quantity is attested and exact, with no floor beneath it.** That is
+ * what separates it from an {@link OndoSellTransaction}, which commits to a
+ * range: nothing here is an estimate.
+ *
+ * **It carries no other identity.** No chain, ticker or asset: the endpoint
+ * publishes none of them, and inventing them from the request would assert
+ * what the server resolved rather than report it. What it does publish is the
+ * scale of every amount on it, so a caller needs nothing alongside it to read
+ * the numbers - only to name the assets, which the offer already does.
+ *
+ * It carries no price either. See `computeOndoBuyPrice`, which derives it from
+ * the amounts the response does carry - the price this transaction fills at,
+ * rather than an indicative one that has since moved.
+ */
+type OndoBuyTransaction = OndoSwapTransactionCore & {
+    side: 'buy';
+    /**
+     * CoinList's cut, in `spendInputAmount`'s decimals. Zero until ENG-1718
+     * lands - frontline rejects a non-zero one on either side today.
+     *
+     * Taken at execution rather than added on top, so the approval never has to
+     * cover more than `spendInputAmount`.
      */
     fee: BlockchainAmount;
     /**
-     * `payInputAmount` less `fee`, in the same decimals: what Ondo priced.
+     * `spendInputAmount` less `fee`, in the same decimals: what Ondo priced, and
+     * the numerator of the fill price.
      *
      * Read from the response rather than subtracted here. Whether the fee comes
      * off the deposit or goes on top of it is the server's definition to change,
@@ -1813,22 +2053,86 @@ type OndoSwapTransaction = {
      */
     notionalValue: BlockchainAmount;
     /**
-     * What the buyer receives, at the scale whatever priced the quantity
-     * reported - not at the {@link OndoQuote}'s.
+     * Quantity of the asset the wallet receives, at the scale whatever priced it
+     * reported - not at the {@link OndoQuote}'s `asset.decimals`.
      */
     receiveOutputAmount: BlockchainAmount;
 };
-declare const OndoSwapTransaction: {
-    fromDto: (dto: OndoSwapTransactionDto) => OndoSwapTransaction;
+declare const OndoBuyTransaction: {
+    fromDto: (dto: OndoBuyDto) => OndoBuyTransaction;
+};
+/**
+ * One end of the range a sale commits to: what arrives, and what CoinList took
+ * to get it there.
+ *
+ * The two travel together because they are charged against each other -
+ * `quantity` is already **net** of `fee` - and because the pair a caller wants
+ * is always both halves of the same outcome. Grouping them is what makes
+ * "the expected quantity, less the fee at the floor" unrepresentable rather
+ * than merely wrong.
+ */
+type OndoSellOutcome = {
+    /** What the wallet receives at this outcome, net of {@link fee}. */
+    quantity: BlockchainAmount;
+    /**
+     * CoinList's cut at this outcome, in the same decimals. Zero until ENG-1718
+     * lands - frontline rejects a non-zero one on either side today.
+     *
+     * Already deducted from {@link quantity} rather than charged on top of it.
+     */
+    fee: BlockchainAmount;
+};
+/**
+ * A signed, expiring sale: the asset in, a settlement coin out, somewhere
+ * between two published outcomes.
+ *
+ * Single-use and expiring for the same reasons as an {@link OndoBuyTransaction},
+ * and obtained the same way - one endpoint, one attestation.
+ *
+ * **A sale commits to a range, not a quantity.** Ondo settles through USDon
+ * before converting to the settlement token, so {@link expected} is what to
+ * expect and {@link minimum} is what the calldata enforces. A screen that
+ * shows only the first presents a firm-looking number the contract may
+ * legitimately fill below.
+ *
+ * There is deliberately no counterpart to a buy's `notionalValue`. A sale
+ * commits on the output side, so frontline reports no fee-exclusive input and
+ * refuses to relate numbers Ninshubur did not relate. What it does relate is
+ * each quantity to the fee beside it, which is why {@link OndoSellOutcome}
+ * pairs them.
+ *
+ * One thing this type cannot see: the floor signed into `tx.data` is gross of
+ * the fee, so a caller decoding the calldata finds a larger number than
+ * `minimum.quantity`. Both are correct; `minimum.quantity` is what the wallet
+ * actually receives.
+ */
+type OndoSellTransaction = OndoSwapTransactionCore & {
+    side: 'sell';
+    /** What the sale is expected to return. An expectation, not a guarantee. */
+    expected: OndoSellOutcome;
+    /**
+     * The floor the calldata enforces. A fill below it reverts on chain, so this
+     * - not {@link expected} - is what a seller is actually guaranteed.
+     */
+    minimum: OndoSellOutcome;
+};
+declare const OndoSellTransaction: {
+    fromDto: (dto: OndoSellDto) => OndoSellTransaction;
 };
 
 /**
  * Ondo swap reads, plus the write that turns one into a fillable transaction.
  *
  * The two reads are free to poll - neither spends an attestation, so a client
- * may call them while the user edits an order. {@link buildSwapTransaction} is
- * not: budget one call per order placed, plus one per refresh the user asks
- * for.
+ * may call them while the user edits an order. The two builders are not:
+ * budget one call per order placed, plus one per refresh the user asks for.
+ *
+ * **One builder per side, mirroring the endpoints.** A purchase and a sale
+ * agree on how to broadcast and on nothing else: a purchase commits to an
+ * exact quantity, a sale to a range with a floor beneath it, and `amount` is
+ * the funding token on one and the asset on the other. A single method taking
+ * a `side` would have to return a union the caller then re-narrows, having
+ * already decided which trade it was placing.
  *
  * **No CoinList fee is applied to a read quote, and no read discloses one.**
  * Ondo prices exactly the amount passed. A CoinList approval is fee-inclusive,
@@ -1843,19 +2147,35 @@ interface OndoNamespace {
     getTradingStatus(params: GetOndoTradingStatusParams): Promise<OndoTradingStatus>;
     getQuote(params: GetOndoQuoteParams): Promise<OndoQuote>;
     /**
-     * Builds the buy for a specific wallet and amount: spends an attestation and
-     * returns calldata to broadcast, valid until
-     * {@link OndoSwapTransaction.expiresAt}.
+     * Builds a purchase for a specific wallet and deposit: spends an attestation
+     * and returns calldata to broadcast, valid until
+     * {@link OndoBuyTransaction.expiresAt}.
      *
      * The wallet must have approved the swap contract to spend `amount` of the
-     * offer's funding token first - frontline reads the allowance before asking
-     * Ninshubur for anything, and rejects a short one with a 422 carrying
-     * `code: "insufficient_allowance"`. See `prepareSwap` on the client
+     * offer's **funding token** first. Frontline reads that allowance before
+     * asking Ninshubur for anything, and rejects a short one with a 422 carrying
+     * `code: "insufficient_allowance"`. See `prepareBuy` on the client
      * namespace, which approves and then builds, in that order.
      *
-     * Buy-only, and the tokens are the offer's rather than the caller's to name.
+     * The tokens themselves are the offer's rather than the caller's to name.
+     */
+    buildBuyTransaction(params: BuildOndoBuyParams): Promise<OndoBuyTransaction>;
+    /**
+     * Builds a sale for a specific wallet and quantity: spends an attestation
+     * and returns calldata to broadcast, valid until
+     * {@link OndoSellTransaction.expiresAt}.
+     *
+     * The approval this one needs is on the **asset**, not on a stablecoin - a
+     * sale delivers the asset, so the swap contract pulls it with `transferFrom`
+     * exactly as it pulls the deposit on a purchase. Same 422 when it is short,
+     * with a message naming that address. See `prepareSell` on the client
+     * namespace.
+     *
+     * Returns a range rather than a quantity: Ondo settles through USDon before
+     * converting to the settlement token, so disclose
+     * {@link OndoSellTransaction.minimum} and not only `expected`.
      */
-    buildSwapTransaction(params: BuildOndoSwapTransactionParams): Promise<OndoSwapTransaction>;
+    buildSellTransaction(params: BuildOndoSellParams): Promise<OndoSellTransaction>;
 }
 declare class OndoNamespaceImpl implements OndoNamespace {
     private readonly ctx;
@@ -1863,7 +2183,8 @@ declare class OndoNamespaceImpl implements OndoNamespace {
     constructor(ctx: SharedNamespaceContext);
     getTradingStatus(params: GetOndoTradingStatusParams): Promise<OndoTradingStatus>;
     getQuote(params: GetOndoQuoteParams): Promise<OndoQuote>;
-    buildSwapTransaction(params: BuildOndoSwapTransactionParams): Promise<OndoSwapTransaction>;
+    buildBuyTransaction(params: BuildOndoBuyParams): Promise<OndoBuyTransaction>;
+    buildSellTransaction(params: BuildOndoSellParams): Promise<OndoSellTransaction>;
 }
 
 /** Parameters shared by contract reads scoped to a chain. */
@@ -2454,6 +2775,16 @@ type NabuChainAssetsDto = {
     protocol: string;
     assets: NabuChainAssetDto[];
 };
+/** The registry's `/assets.json` route: the complete snapshot, every chain. */
+type NabuRegistryDto = {
+    data_version: string;
+    schema_version: number;
+    chains: Array<{
+        chain: string;
+        protocol: string;
+        assets: NabuChainAssetDto[];
+    }>;
+};
 
 /**
  * An absolute URL to a logo image in the token registry. Registry image URLs
@@ -2503,6 +2834,13 @@ type TokenMetadata = {
 declare const TokenMetadata: {
     /** `baseUrl` is the registry origin; registry logo URLs are root-relative. */
     fromDto: (dto: NabuTokenDto, baseUrl: string) => TokenMetadata;
+    /**
+     * 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: NabuRegistryDto, baseUrl: string) => TokenMetadata[];
     /**
      * Maps a chain snapshot to the tokens it lists, skipping the chain's native
      * coin (`kind: 'COIN'`, no contract address).
@@ -2513,7 +2851,7 @@ declare const TokenMetadata: {
 /**
  * Token display metadata — name, symbol, decimals, and logos — from
  * CoinList's public token registry, keyed by {@link TokenIdentifier} (the
- * same chain + address pairs `OfferDetail.tokens` carries).
+ * same chain + address pairs `Offer.tokens` carries).
  *
  * Unlike the other namespaces, this one is public: no method requires an
  * authenticated user, and nothing here touches the CoinList API — reads go to
@@ -2527,15 +2865,19 @@ interface TokensNamespace {
      */
     get(token: TokenIdentifier): Promise<TokenMetadata | null>;
     /**
-     * Fetches all available tokens the registry lists for `chain`, in one
-     * request. Prefer this over calling {@link get} in a loop when displaying a
-     * catalogue: two hundred tokens is still a single snapshot download.
+     * Fetches every token the registry lists, in one request: the complete
+     * snapshot with no `chain`, or one chain's snapshot with it. Prefer this
+     * over calling {@link get} in a loop when displaying a catalogue — two
+     * hundred tokens across three chains is still a single download.
+     *
+     * The complete snapshot spans every chain the registry knows; tokens on
+     * chains this SDK does not model (e.g. Solana) are left out of the result.
      *
-     * Unlike {@link get}, a missing chain snapshot throws rather than returning
-     * `[]`: the registry publishes one for every chain it knows, so its absence
-     * is a deployment problem, not an empty catalogue.
+     * Unlike {@link get}, a missing snapshot throws rather than returning `[]`:
+     * the registry always publishes the complete snapshot and one per chain it
+     * knows, so an absence is a deployment problem, not an empty catalogue.
      */
-    list(chain: EthereumChain): Promise<TokenMetadata[]>;
+    list(chain?: EthereumChain): Promise<TokenMetadata[]>;
 }
 declare class TokensNamespaceImpl implements TokensNamespace {
     private readonly api;
@@ -2547,7 +2889,7 @@ declare class TokensNamespaceImpl implements TokensNamespace {
      */
     constructor(baseUrl: string, logger?: Logger | null);
     get(token: TokenIdentifier): Promise<TokenMetadata | null>;
-    list(chain: EthereumChain): Promise<TokenMetadata[]>;
+    list(chain?: EthereumChain): Promise<TokenMetadata[]>;
 }
 
 interface Config {
@@ -2614,4 +2956,4 @@ interface Config {
     readonly logger?: Logger;
 }
 
-export { type TokenIdentifier as $, AuthorizationCode as A, BlockchainAmount as B, CodeVerifier as C, type RequirementType as D, type Erc20Namespace as E, type RequirementStatusValue as F, OfferOptionAddress as G, RequirementId as H, DocumentSubmission as I, type WalletChallengeType as J, type KycLevelName as K, type Logger as L, type PinoLoggerOptions as M, OndoTradingStatus as N, OfferId as O, Participation as P, AssetDecimals as Q, type RequirementsNamespace as R, type SharedNamespaceContext as S, type TokensNamespace as T, OndoQuote as U, type OrderBookSide as V, type WalletError as W, type OndoQuoteSize as X, type BuildOndoSwapTransactionParams as Y, OfferOptionAddressId as Z, TokenMetadata as _, EthereumChain as a, OfferSlug as a$, type DebugEvent as a0, type FrontlineEventId as a1, HttpError as a2, type HttpResponse as a3, KycToken as a4, type LogBinding as a5, type LogBindings as a6, type LogCause as a7, type LogLevel as a8, type LogScope as a9, ConnectExternalWalletParams as aA, type CreateKycTokenParams as aB, CreateParticipationParams as aC, CreateWalletOwnershipChallengeParams as aD, Cursor as aE, type DocumentFormType as aF, type DocumentSubmissionStatus as aG, type DocumentType as aH, ETHEREUM_CHAINS as aI, Erc20NamespaceImpl as aJ, FaqItem as aK, type GetOndoQuoteParams as aL, type GetOndoTradingStatusParams as aM, type GetSwapAuthorizationParams as aN, type GetSwapPreviewParams as aO, type GetTokenAllowanceParams as aP, type GetTokenBalanceParams as aQ, HexEncodedTransactionData as aR, Iso2CountryCode as aS, Link as aT, type ListOptionAddressesParams as aU, MAX_ASSET_DECIMALS as aV, MAX_UINT_256 as aW, Milestone as aX, OAuthRefreshToken as aY, OfferOption as aZ, OfferOptionSlug as a_, type LogValue as aa, type ProductionLogLevel as ab, RedactedWalletError as ac, type RequestId as ad, type SafeEvent as ae, type SafeFields as af, type UnredactedFields as ag, OAuthSession as ah, ClientCredentialsOAuth as ai, ClientSecret as aj, type Sender as ak, PaginationParams as al, PaginatedResponse as am, type Uint256 as an, KnownAssetSymbol as ao, DecimalString as ap, SwapStatus as aq, type Newtype as ar, type AllowWalletParams as as, AllowWalletResponse as at, Asset as au, AssetCode as av, Blockchain as aw, Chain as ax, ClientId as ay, CodeChallenge as az, EvmContractAddress as b, OfferToken as b0, OffersNamespaceImpl as b1, type OndoQuoteDuration as b2, PKCEState as b3, type PaginatedResponseDto as b4, ParticipationId as b5, type ParticipationStatus as b6, ParticipationsPaginationParams as b7, Pii as b8, PiiAddress as b9, type WalletProtocol as bA, WalletsNamespaceImpl as bB, apiErrorCode as bC, assertUint256 as bD, parseUint256 as bE, PiiJurisdiction as ba, type PiiKind as bb, type QueryParamValue as bc, type QueryParamValues as bd, RedirectUri as be, type RemoveOptionAddressParams as bf, type RequirementActionNeededReason as bg, SOLANA_CHAINS as bh, STABLE_DECIMALS as bi, SolanaChain as bj, type SubmitDocumentParams as bk, SwapAuthorization as bl, type SwapContractRef as bm, SwapPreview as bn, TermItem as bo, Ticker as bp, TokenAllowance as bq, TokenBalance as br, TokenLogo as bs, type TokenLogoImage as bt, TokenLogoUrl as bu, type TokenRole as bv, TokensNamespaceImpl as bw, type Tx as bx, WalletAddress as by, WalletOwnershipChallenge as bz, type CoinListTokenSaleNamespace as c, OfferOptionId as d, AssetId as e, CoinListTokenSaleNamespaceImpl as f, type OndoNamespace as g, AssetSymbol as h, OndoSwapTransaction as i, OndoNamespaceImpl as j, type SuperstateSwapNamespace as k, type WalletsNamespace as l, Bps as m, EvmWalletAddress as n, SuperstateSwapNamespaceImpl as o, Requirement as p, RequirementsNamespaceImpl as q, type Config as r, type OAuthAccessToken as s, type OffersNamespace as t, type Erc20Asset as u, OfferDetail as v, StablecoinSymbol as w, type OfferType as x, Offer as y, RequirementStatusInfo as z };
+export { type OndoQuoteSize as $, AuthorizationCode as A, BlockchainAmount as B, CodeVerifier as C, type OfferType as D, type Erc20Namespace as E, Offer as F, RequirementStatusInfo as G, type RequirementType as H, type RequirementStatusValue as I, OfferOptionAddress as J, RequirementId as K, type Logger as L, type KycLevelName as M, DocumentSubmission as N, OfferId as O, Participation as P, type WalletChallengeType as Q, type RequirementsNamespace as R, type SharedNamespaceContext as S, type TokensNamespace as T, type PinoLoggerOptions as U, OndoTradingStatus as V, type WalletError as W, AssetDecimals as X, type BuildOndoBuyParams as Y, type BuildOndoSellParams as Z, OndoQuote as _, EthereumChain as a, Milestone as a$, OfferOptionAddressId as a0, TokenMetadata as a1, type TokenIdentifier as a2, type DebugEvent as a3, type FrontlineEventId as a4, HttpError as a5, type HttpResponse as a6, KycToken as a7, type LogBinding as a8, type LogBindings as a9, type BuildOndoSwapParamsCore as aA, Chain as aB, ClientId as aC, CodeChallenge as aD, ConnectExternalWalletParams as aE, type CreateKycTokenParams as aF, CreateParticipationParams as aG, CreateWalletOwnershipChallengeParams as aH, Cursor as aI, type DocumentFormType as aJ, type DocumentSubmissionStatus as aK, type DocumentType as aL, ETHEREUM_CHAINS as aM, Erc20NamespaceImpl as aN, FaqItem as aO, type GetOndoQuoteParams as aP, type GetOndoTradingStatusParams as aQ, type GetSwapAuthorizationParams as aR, type GetSwapPreviewParams as aS, type GetTokenAllowanceParams as aT, type GetTokenBalanceParams as aU, HexEncodedTransactionData as aV, Iso2CountryCode as aW, Link as aX, type ListOptionAddressesParams as aY, MAX_ASSET_DECIMALS as aZ, MAX_UINT_256 as a_, type LogCause as aa, type LogLevel as ab, type LogScope as ac, type LogValue as ad, type ProductionLogLevel as ae, RedactedWalletError as af, type RequestId as ag, type SafeEvent as ah, type SafeFields as ai, type UnredactedFields as aj, OAuthSession as ak, ClientCredentialsOAuth as al, ClientSecret as am, type Sender as an, PaginationParams as ao, PaginatedResponse as ap, type Uint256 as aq, KnownAssetSymbol as ar, DecimalString as as, SwapStatus as at, type Newtype as au, type AllowWalletParams as av, AllowWalletResponse as aw, Asset as ax, AssetCode as ay, Blockchain as az, EvmContractAddress as b, OAuthRefreshToken as b0, OfferOption as b1, OfferOptionSlug as b2, OfferSlug as b3, OfferToken as b4, OffersNamespaceImpl as b5, type OndoQuoteDuration as b6, type OndoSellOutcome as b7, PKCEState as b8, type PaginatedResponseDto as b9, type TokenRole as bA, TokensNamespaceImpl as bB, type Tx as bC, WalletAddress as bD, WalletOwnershipChallenge as bE, type WalletProtocol as bF, WalletsNamespaceImpl as bG, apiErrorCode as bH, assertUint256 as bI, parseUint256 as bJ, ParticipationId as ba, type ParticipationStatus as bb, ParticipationsPaginationParams as bc, Pii as bd, PiiAddress as be, PiiJurisdiction as bf, type PiiKind as bg, type QueryParamValue as bh, type QueryParamValues as bi, RedirectUri as bj, type RemoveOptionAddressParams as bk, type RequirementActionNeededReason as bl, SOLANA_CHAINS as bm, STABLE_DECIMALS as bn, SolanaChain as bo, type SubmitDocumentParams as bp, SwapAuthorization as bq, type SwapContractRef as br, SwapPreview as bs, TermItem as bt, Ticker as bu, TokenAllowance as bv, TokenBalance as bw, TokenLogo as bx, type TokenLogoImage as by, TokenLogoUrl as bz, type CoinListTokenSaleNamespace as c, OfferOptionId as d, AssetId as e, CoinListTokenSaleNamespaceImpl as f, type OndoNamespace as g, AssetSymbol as h, OndoBuyTransaction as i, OndoSellTransaction as j, type OndoSwapTransactionCore as k, type OrderBookSide as l, OndoNamespaceImpl as m, type SuperstateSwapNamespace as n, type WalletsNamespace as o, Bps as p, EvmWalletAddress as q, SuperstateSwapNamespaceImpl as r, Requirement as s, RequirementsNamespaceImpl as t, type Config as u, type OAuthAccessToken as v, type OffersNamespace as w, StablecoinSymbol as x, type Erc20Asset as y, OfferDetail as z };