@coinlist-co/react 0.11.0 → 0.11.1-rc.10770e8

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

@@ -1,4 +1,4 @@
-import { Hex } from 'viem';
+import { Hash, Hex } from 'viem';
 
 declare const __brand: unique symbol;
 type Newtype<Base, Branding> = Base & {
@@ -20,12 +20,544 @@ declare const ClientId: (value: string) => ClientId;
 type ClientSecret = Newtype<string, 'ClientSecret'>;
 declare const ClientSecret: (value: string) => ClientSecret;
 
+/**
+ * A classified wallet or transaction failure. The SDK derives this from
+ * whatever the {@link EvmWallet} throws, so hosts get a stable, typed error
+ * shape regardless of the wallet library underneath.
+ *
+ * Lives here rather than beside its classifier because it is the failure half
+ * of the {@link EvmWallet} contract, and because both `@/shared` and
+ * `@/client` name it: {@link LogCause} carries one, and classifying a thrown
+ * error into one needs viem's error classes, which are browser-side.
+ */
+type WalletError = {
+    type: 'user_rejected';
+} | {
+    type: 'insufficient_funds';
+} | {
+    type: 'contract_reverted';
+    /**
+     * What the contract said, when it said anything: a `require` string, a
+     * panic description, a custom error's name, or the four-byte selector of
+     * an error the ABI could not decode.
+     *
+     * `null` when a revert carried no data, since the string the RPC node
+     * offers in its place is not the contract's - see `classifyWalletError`.
+     * Nullable rather than optional so that every arm has to answer the
+     * question: "it reverted and said nothing" is a fact about the revert,
+     * and a caller should have to read it rather than miss it.
+     *
+     * Never the custom error's arguments. A name is a compile-time
+     * identifier; its operands are runtime values - an address, a balance -
+     * and those are `'debug'` material.
+     */
+    reason: string | null;
+} | {
+    type: 'timeout';
+    hash: Hash;
+} | {
+    type: 'unknown';
+    cause: unknown;
+};
+/**
+ * A {@link WalletError} as it may be reported above `'debug'`: the
+ * classification, never the throw.
+ *
+ * Only the `unknown` arm differs, and it differs because it is the one arm
+ * carrying a value the SDK did not author - the raw error the wallet library
+ * threw, whose message and metadata hold the transaction's `from`, `to`,
+ * `value` and calldata. The other four carry compile-time constants or a
+ * server-minted identifier already, so they pass through as they stand.
+ *
+ * This exists as a type rather than as a scrub some function remembers to
+ * apply: `LogCause` names it, so an arm that grew a raw field would fail the
+ * build instead of quietly reaching {@link Logger.error}.
+ */
+type RedactedWalletError = Exclude<WalletError, {
+    type: 'unknown';
+}> | {
+    type: 'unknown';
+};
+declare const RedactedWalletError: {
+    fromWalletError: (error: WalletError) => RedactedWalletError;
+};
+
+/**
+ * The observability seam a host implements to see inside the SDK.
+ *
+ * Pass an implementation as {@link Config.logger} and the SDK reports every
+ * request it makes, every failure it classifies, and every state a hook
+ * settles into. Leave it out and the SDK logs nothing at all - there is no
+ * fallback to `console`, at any level, on any codepath.
+ *
+ * Four methods over a {@link LogEvent} lambda, plus {@link level}. An event is
+ * a constant `msg`, the {@link LogScope} it came from, the accumulated
+ * {@link LogBindings}, and a bag of `fields` - so a host forwards structured
+ * records rather than parsing strings.
+ *
+ * ```ts
+ * const logger: Logger = {
+ *   level: () => 'info',
+ *   debug: () => {},
+ *   info: (event) => sink.info(toRecord(event())),
+ *   warn: (event) => sink.warn(toRecord(event())),
+ *   error: (event) => sink.error(toRecord(event())),
+ * };
+ * ```
+ *
+ * {@link pinoClientLogger} and {@link pinoServerLogger} are ready-made
+ * implementations over pino, and are what most hosts should reach for.
+ *
+ * ## Where to run it
+ *
+ * **Not in production, as the default answer.** Development, tests, staging,
+ * and reproducing a reported bug are where this seam earns its keep. Left
+ * undefined elsewhere it discloses nothing, and that holds no matter what a
+ * later revision of the SDK puts on a line.
+ *
+ * Where you do run one in production, `'info'` and above is the only sane
+ * choice, and the shipped implementations make the alternative unrepresentable
+ * rather than merely discouraged: `isDev: false` narrows the level to
+ * {@link ProductionLogLevel}, so `'debug'` does not compile. That narrowing is
+ * a guard for the partner who ignored this paragraph, not an endorsement of
+ * the practice.
+ *
+ * The distinction worth holding onto: `'info'` and above are **redacted by
+ * construction** - see the next section for exactly what that covers, and the
+ * type that enforces it. Redacted is a mechanism the SDK can hold itself to. A
+ * blanket "safe in production" is a promise about your environment that the
+ * SDK is in no position to make, and one that a single future field could
+ * quietly break.
+ *
+ * `'debug'` is for reproducing a bug: a developer's machine, tests, and beta
+ * or staging environments where the data flowing through the SDK is not real
+ * customer data.
+ *
+ * ## What each level may disclose
+ *
+ * **`'debug'` is unredacted. Every other level is not.**
+ *
+ * At `'debug'` the SDK reports request and response bodies, request headers,
+ * the full URL including its query string, and operation parameters
+ * **verbatim** - bearer tokens, KYC answers, tax-document fields, wallet
+ * signatures, the lot. There is no denylist and no redaction: see ADR-8 for
+ * why a partial guarantee was rejected in favour of an honest absence of one.
+ *
+ * At `'info'`, `'warn'` and `'error'` the SDK emits only its own
+ * classification of what happened and identifiers the server minted: a method
+ * and a bare path, a status, a duration, a {@link RequestId}, a frontline
+ * error code and event id, a {@link LogCause} arm. No request body, no
+ * response body, no query string, no host-supplied parameters, and no message
+ * text read off a thrown error the SDK did not author.
+ *
+ * The type carries that boundary rather than merely documenting it:
+ * {@link SafeEvent} constrains every field value to a {@link LogValue} scalar,
+ * so spreading a body, a DTO or an operation's params into an `info`, `warn`
+ * or `error` line does not compile. Only {@link DebugEvent} accepts arbitrary
+ * values.
+ *
+ * The one deliberate exception is an SDK-authored validation message, which
+ * quotes the single scalar that failed to map - `Unsupported chain:
+ * "solana_mainnet"`. It is a hand-written template naming one offending value,
+ * not a payload, and it is the whole reason this seam exists.
+ *
+ * ## Your responsibility
+ *
+ * The SDK hands you events. What happens next is yours: **you own the final
+ * filtering, redaction and retention** before anything is written to a file, a
+ * console, or a third-party sink such as Sentry or Datadog. In particular, if
+ * you implement {@link debug} and forward it anywhere durable, you have taken
+ * on storing live credentials and personal data, deliberately. Implement
+ * `debug` as a no-op - or return a level below it from {@link level} - in any
+ * environment where that is not acceptable.
+ *
+ * **Every event is a lambda, and that is load bearing.** The SDK consults
+ * {@link level} first and never invokes the lambda when the level forbids it,
+ * so an expensive debug event - a serialized DTO, a loop over balances - costs
+ * nothing in production where the level is `'error'` or `'none'`. Build the
+ * event inside the lambda, never outside it.
+ *
+ * ## Every method must be total
+ *
+ * **None of the five methods may throw, and that includes {@link level}.** The
+ * SDK calls them inline, on the codepath of the work it is reporting, and it
+ * does not catch them: a `logger.error` that throws while reporting a failed
+ * request turns that request's rejection into your logger's exception, and a
+ * `level()` that throws breaks the call it was asked about even when nothing
+ * else went wrong.
+ *
+ * That is deliberate. Swallowing would hide a logger that is broken in every
+ * environment, and the SDK cannot tell a transport blip in your sink from a
+ * bug in your implementation. So the contract is on this side of the seam:
+ * catch inside your implementation, and never let an exception out. The
+ * shipped pino implementations do exactly that.
+ *
+ * ```ts
+ * error: (event) => {
+ *   try {
+ *     const e = event();
+ *     Sentry.captureMessage(e.msg, { extra: e });
+ *   } catch {
+ *     // never rethrow: the SDK is on the other side of this call
+ *   }
+ * },
+ * ```
+ */
+interface Logger {
+    /**
+     * The most detailed level this logger wants. Consulted before **every** log
+     * call, so keep it cheap and pure: return a captured constant or read a
+     * plain field. Do not read an environment variable, hit storage, or call
+     * out to a feature-flag service here.
+     *
+     * Returning `'none'` silences the SDK as completely as omitting the logger.
+     *
+     * **Must not throw.** It is consulted inside every SDK operation, so an
+     * exception here fails the operation itself.
+     */
+    level(): LogLevel;
+    /**
+     * Fine-grained detail: request and response bodies, full URLs, headers,
+     * operation parameters, hook transitions.
+     *
+     * **Unredacted.** This is the only level that may carry credentials or
+     * personal data, and it always may. Its event is a {@link DebugEvent}, whose
+     * fields accept arbitrary values for exactly that reason. Do not forward it
+     * to a durable or third-party sink outside development and beta.
+     *
+     * **Must not throw**, here and on every method below.
+     */
+    debug(event: () => DebugEvent): void;
+    /** Notable, expected events: a request completing, a flow advancing. */
+    info(event: () => SafeEvent): void;
+    /**
+     * Recoverable trouble: a retried request, a renewed session, a poll tick
+     * that failed while the last value still stands.
+     *
+     * Carries a {@link LogCause} when one was classified, the same as
+     * {@link error} does. What separates the two levels is whether anything
+     * actually broke, not how much is known about it.
+     */
+    warn(event: () => SafeEvent): void;
+    /**
+     * A failure. {@link SafeEvent.cause} carries what the SDK knows about it,
+     * classified into {@link LogCause}, and is absent when the failure is not an
+     * error the SDK caught - a flow reporting the step it stopped at, for
+     * instance.
+     *
+     * Every part of the event is SDK-authored classification or server-authored
+     * identifiers, so forwarding it as it stands is safe. `scope` says which
+     * part of the SDK the line came from, which is what to route or filter on.
+     */
+    error(event: () => SafeEvent): void;
+}
+/**
+ * A value the SDK is willing to put in a structured field above `'debug'`.
+ *
+ * Scalars only, and that is the redaction boundary made structural rather than
+ * documentary. Every leak ADR-8 found was an *object* spread onto a line that
+ * a host forwards to a tracker - an operation's params, a thrown wallet error,
+ * a response body. None of them is assignable to this, so each is now a
+ * compile error rather than a review catch.
+ *
+ * It does not stop a call site writing `{ token: accessToken }`, and it is not
+ * meant to: a string is a string. What it stops is the mistake that actually
+ * happened.
+ */
+type LogValue = string | number | boolean | null;
+/**
+ * Fields safe at every level: SDK-authored classification and server-minted
+ * identifiers, constrained to {@link LogValue}.
+ */
+type SafeFields = Readonly<Record<string, LogValue>>;
+/**
+ * Fields for `'debug'` only: bodies, headers, full URLs, operation params,
+ * raw thrown values. Arbitrary values, because that is the point of the level.
+ *
+ * The SDK's own implementations render these into a form that cannot fail to
+ * serialize - a `bigint`, a cycle or a getter that throws must never turn a
+ * log line into a second failure - but they are otherwise passed through.
+ */
+type UnredactedFields = Readonly<Record<string, unknown>>;
+/**
+ * One narrowing applied to a logger by {@link InternalLogger.child}.
+ *
+ * A union of single-key objects rather than a positional `string`, because the
+ * three things the SDK narrows by are not the same kind of thing: a request id
+ * correlates retries of one wire call, a flow name names an on-chain
+ * procedure, a hook name names a React binding. Rendered into one `[SCOPE:x]`
+ * prefix they were indistinguishable; as fields they must not be.
+ *
+ * `requestId` keeps its {@link RequestId} newtype rather than widening to
+ * `string` at the seam.
+ */
+type LogBinding = {
+    readonly requestId: RequestId;
+} | {
+    readonly flow: string;
+} | {
+    readonly hook: string;
+} | {
+    readonly op: string;
+};
+/**
+ * Every {@link LogBinding} applied so far, merged. This is what reaches a
+ * host, so a line from `prepareOndoSell` carries `flow: 'prepareSell'` as its
+ * own key and is filterable without parsing anything.
+ */
+type LogBindings = {
+    readonly [K in LogBinding as keyof K]?: K[keyof K];
+};
+type BaseEvent = {
+    /**
+     * What happened, as a **constant string literal**.
+     *
+     * Never interpolated. A log aggregator groups by message, so a `msg` that
+     * embeds a status, a count or a reason produces one group per distinct
+     * value and is not groupable at all. Every varying value belongs in
+     * `fields`, which is what a host filters and facets on.
+     *
+     * This is a convention, not a checked rule: deslop reasons about import
+     * edges and cannot see a template literal, and the type-level approximations
+     * catch only some interpolations. ADR-8 records why a partial guarantee was
+     * refused here as elsewhere.
+     */
+    readonly msg: string;
+    /**
+     * Which part of the SDK reported this. Stamped by
+     * {@link internalLogger}, never by a call site.
+     */
+    readonly scope: LogScope;
+    /** Every {@link LogBinding} applied by {@link InternalLogger.child}. */
+    readonly bindings: LogBindings;
+};
+/**
+ * An event for `'info'`, `'warn'` and `'error'` - the levels a host may run in
+ * production.
+ *
+ * Its fields are {@link SafeFields}, so nothing but a scalar can reach it.
+ */
+type SafeEvent = BaseEvent & {
+    readonly fields: SafeFields;
+    /**
+     * What the SDK knows about an accompanying failure, classified. Absent when
+     * there is nothing to classify.
+     */
+    readonly cause?: LogCause;
+};
+/**
+ * An event for `'debug'`, the unredacted level. Its fields accept anything.
+ */
+type DebugEvent = BaseEvent & {
+    readonly fields: UnredactedFields;
+};
+/**
+ * How much the SDK may report, from silent to everything.
+ *
+ * Ordered: each level admits itself and everything before it, so `'info'`
+ * shows errors, warnings and info but not debug. `'none'` admits nothing.
+ *
+ * `'debug'` is the unredacted level, and it is deliberately the bottom of the
+ * ladder: the guarantee "`debug` is unredacted and every other level is not"
+ * only closes if there is nothing below it. That is why the SDK keeps its own
+ * five levels rather than adopting pino's seven, which put `trace` underneath.
+ */
+type LogLevel = 'none' | 'error' | 'warn' | 'info' | 'debug';
+/**
+ * The redacted levels: the only ones to consider running in production.
+ *
+ * Every level except `'debug'`, which is unredacted by design. Used by the
+ * shipped pino implementations to make a production `'debug'` logger
+ * unrepresentable rather than merely discouraged - see
+ * {@link PinoLoggerOptions}.
+ *
+ * The name marks which levels are *redacted*, not a verdict that running them
+ * in production is safe. The SDK's advice is to leave {@link Config.logger}
+ * undefined there; this type is what stops the partner who does not take it
+ * from reaching the unredacted level as well.
+ */
+type ProductionLogLevel = Exclude<LogLevel, 'debug'>;
+/**
+ * How to build one of the SDK's pino-backed loggers.
+ *
+ * A union rather than `{ level, isDev }`, and that is the whole point:
+ * `{ isDev: false, level: 'debug' }` does not typecheck, so a production
+ * build cannot ship a logger that prints bearer tokens to a browser console.
+ *
+ * `isDev` does exactly one thing - decide whether `'debug'` is a legal level.
+ * It changes no formatting: dev output and production output are the same
+ * shape, so what you debug is what you ship. Pretty-printing is a pipe the
+ * host owns (`node server.js | npx pino-pretty`), not a dependency the SDK
+ * takes.
+ */
+type PinoLoggerOptions = {
+    readonly isDev: true;
+    readonly level: LogLevel;
+} | {
+    readonly isDev: false;
+    readonly level: ProductionLogLevel;
+};
+/**
+ * Which part of the SDK a line came from, carried as the `scope` field on
+ * every event.
+ *
+ * It names the seam that **reported** the line, not the layer that raised what
+ * it reports: an error from `OFFERS` surfaced by `useOffers` is reported on a
+ * `HOOKS` line, because that is the hook telling you what it did with it. The
+ * `OFFERS` line for the same error is emitted separately, by the namespace.
+ *
+ * A closed union rather than a free string so that `ONDO` and `Ondo` cannot
+ * both appear, so that adding a namespace without giving it a scope fails to
+ * compile, and so that a host can `switch` on it when routing. Anything finer
+ * - an operation, a flow, a hook - is a {@link LogBinding} and appears as its
+ * own field.
+ */
+type LogScope = 'HTTP' | 'AUTH' | 'OFFERS' | 'REQUIREMENTS' | 'WALLETS' | 'ERC20' | 'TOKEN_SALE' | 'SUPERSTATE' | 'ONDO' | 'TOKENS' | 'SUPPORT' | 'HOOKS';
+/**
+ * Correlates every line one logical request produces. The first attempt, each
+ * retry, and the re-send after a session renewal all carry the same id, so a
+ * failure can be read back to the request that caused it.
+ */
+type RequestId = Newtype<string, 'RequestId'>;
+/**
+ * The id frontline keys its own logs by, minted server-side and returned as
+ * `event_id` on an error envelope. Quote it when raising a ticket with
+ * CoinList support: it is what leads from a partner's log line to the request
+ * as the backend saw it.
+ *
+ * A {@link Newtype} rather than a bare `string` because it sits next to
+ * {@link RequestId} and frontline's `code` on the same cause, and the three
+ * are not interchangeable: an id swapped for a code reads plausibly and points
+ * a support engineer at nothing.
+ */
+type FrontlineEventId = Newtype<string, 'FrontlineEventId'>;
+/**
+ * What the SDK knows about a failure, classified.
+ *
+ * **Safe to forward as it stands.** Every arm is SDK-authored classification
+ * or a server-authored identifier: no request or response body, no host-
+ * supplied parameter, and no value read off a thrown error the SDK did not
+ * author. There is nothing here to strip before handing it to an error
+ * tracker, which is deliberate - a `LogCause` reaches {@link Logger.error},
+ * the level a host actually runs in production, and a guarantee that depends
+ * on the host remembering to strip a field is not a guarantee.
+ *
+ * It is the SDK's **only** structured classification of a thrown error, and it
+ * reaches {@link Logger.warn} as well as {@link Logger.error}: a recoverable
+ * failure is no less worth naming than a fatal one, and rendering it into a
+ * string instead would have meant interpolating into `msg`.
+ *
+ * Bodies are a `'debug'`-only disclosure and stay on the `HTTP` lines, which
+ * {@link RequestId} points at.
+ *
+ * The arms are the remedies, not the exception classes: a `validation` cause
+ * means the backend sent something the SDK does not understand and is worth
+ * reporting to CoinList, while an `invariant` cause means the SDK itself
+ * computed something impossible and is worth reporting as an SDK bug. Reading
+ * `type` should tell you who has to fix it.
+ *
+ * It carries no scope of its own. The {@link SafeEvent} it arrives on has one,
+ * and a cause could only ever have repeated it: the scope is stamped by the
+ * logger that *emits* the line, not by the layer that raised the error, so a
+ * `validation` failure from `OFFERS` surfaced by `useOffers` would have been
+ * tagged `HOOKS` on the hook's line. Forward the event, not the cause alone.
+ */
+type LogCause = 
+/**
+ * A request reached the backend and came back non-2xx.
+ *
+ * Deliberately carries no response body. `requestId` is how you get the
+ * rest: the `HTTP` lines for the same request carry the method, the path,
+ * the duration, every retry, and at `'debug'` the body itself. `code` and
+ * `eventId` are frontline's own - quote `eventId` when raising a ticket with
+ * CoinList support.
+ */
+{
+    type: 'http';
+    requestId: RequestId | null;
+    status: number;
+    code: string | null;
+    eventId: FrontlineEventId | null;
+}
+/**
+ * The wire succeeded; the payload was not a shape the SDK can map.
+ *
+ * `message` is an SDK-authored template and may quote the single scalar that
+ * failed - `Unsupported chain: "solana_mainnet"`, `expires_at: not a date
+ * ("13/40/2026")`. That one value is the point of the arm; it is never a
+ * body and never a whole field set.
+ */
+ | {
+    type: 'validation';
+    message: string;
+}
+/**
+ * The SDK computed something impossible. An SDK bug - please report it.
+ * `message` is an SDK-authored template, like `validation`'s.
+ */
+ | {
+    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';
+}
+/** A code path the SDK has not shipped yet. */
+ | {
+    type: 'not-implemented';
+}
+/**
+ * The user's wallet, or the chain, refused.
+ *
+ * {@link RedactedWalletError} rather than the full `WalletError`: its
+ * `unknown` arm arrives with its `cause` dropped, that field holding the raw
+ * wallet-library error whose message and metadata carry the transaction's
+ * `from`, `to`, `value` and calldata. It is still on the flow's own returned
+ * result, and on the `'debug'` line the flow seam emits beside this one.
+ *
+ * A type rather than a scrub applied at the call site, so an arm that grew a
+ * raw field would fail the build.
+ */
+ | {
+    type: 'wallet';
+    error: RedactedWalletError;
+}
+/**
+ * Something the SDK does not recognise - usually a host-supplied lambda
+ * (`getAccessToken`, an {@link EvmWallet} method) throwing, or a
+ * network-level `fetch` failure.
+ *
+ * `name` is the error's class name and nothing else. The message and the
+ * thrown value itself are host-authored, so they are a `'debug'` disclosure:
+ * the paired debug line renders them in full.
+ */
+ | {
+    type: 'generic-error';
+    name: string;
+};
+
 /**
  * The exhaustive chain set: a new {@link EthereumChain} is a compile error
  * 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.
  *
@@ -147,11 +679,25 @@ declare const MAX_UINT_256: bigint;
  */
 type Uint256 = bigint;
 /**
- * Asserts a raw bigint falls within uint256 bounds, throwing otherwise. Use at
- * on-chain arithmetic boundaries (bps math, price computation) where a computed
- * value could underflow below zero or overflow above 2^256-1.
+ * Asserts a computed bigint falls within uint256 bounds. Use at on-chain
+ * arithmetic boundaries (bps math, price computation) where the SDK's own
+ * arithmetic could underflow below zero or overflow above 2^256-1.
+ *
+ * Throws {@link InvariantError}, because reaching it means the SDK computed
+ * something no chain could represent. **For a value that came off the wire,
+ * use {@link parseUint256} instead**: the backend sending an unrepresentable
+ * number is a {@link ValidationError}, and the two have different remedies.
  */
 declare const assertUint256: (value: bigint) => Uint256;
+/**
+ * {@link assertUint256} at a wire boundary: the same bounds check, reported as
+ * a {@link ValidationError} against the named field, because a value out of
+ * range here is the backend's, not the SDK's.
+ *
+ * `label` names the field the way a DTO mapper's other failures do, so a log
+ * line says which one - `SwapPreview.pay_input_amount`, not `a number`.
+ */
+declare const parseUint256: (value: bigint, label: string) => Uint256;
 type BlockchainAmount = Newtype<{
     raw: Uint256;
     decimals: AssetDecimals;
@@ -159,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;
@@ -167,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;
 /**
@@ -225,6 +821,13 @@ declare const OAuthSession: {
 };
 
 type HttpRequestAttributes = {
+    /**
+     * Correlates the log lines of one logical request. Minted by
+     * {@link HttpClient} on the first attempt and carried onto every retry and
+     * post-renewal re-send by {@link concat}, which is what lets a reader tell
+     * three attempts of one request from three separate requests.
+     */
+    requestId?: RequestId;
     protected?: boolean;
     userAgent?: boolean;
     idempotencyKey?: boolean;
@@ -272,10 +875,25 @@ type HttpResponse<TBody = unknown> = {
     status: number;
     headers?: Record<string, string>;
     body: TBody | null;
+    /**
+     * The id of the request that produced this response, stamped by
+     * {@link HttpClient} so that whoever turns a non-2xx into an
+     * {@link HttpError} can carry it without threading the request alongside.
+     * Absent when the response did not come from an `HttpClient`.
+     */
+    requestId?: RequestId;
 };
 declare class HttpError<TBody = unknown> extends Error {
     readonly response: HttpResponse<TBody>;
     constructor(response: HttpResponse<TBody>);
+    /**
+     * Correlates this failure with the `[HTTP]` log lines for the same request,
+     * which carry the method, the URL, the duration and every retry. `null` when
+     * the response did not come from an {@link HttpClient}.
+     *
+     * Worth quoting in a bug report: it is what makes a log excerpt readable.
+     */
+    get requestId(): RequestId | null;
 }
 /**
  * The machine-readable `code` frontline attaches to an error, or `null` for
@@ -304,6 +922,15 @@ interface Sender {
 
 interface SharedNamespaceContext {
     readonly api: Sender;
+    /**
+     * The host's logger, or `null` when they supplied none.
+     *
+     * Deliberately the raw port rather than a pre-scoped {@link InternalLogger}:
+     * one context serves every namespace, and each namespace owns its own scope.
+     * A namespace turns it into something usable in its constructor, with
+     * `internalLogger(ctx.logger, 'OFFERS')`.
+     */
+    readonly logger: Logger | null;
     ensureUserAuthenticated(): Promise<void>;
 }
 
@@ -430,11 +1057,89 @@ interface Erc20Namespace {
 }
 declare class Erc20NamespaceImpl implements Erc20Namespace {
     private readonly ctx;
+    private readonly log;
     constructor(ctx: SharedNamespaceContext);
     getAllowance(params: GetTokenAllowanceParams): Promise<TokenAllowance>;
     getBalance(params: GetTokenBalanceParams): Promise<TokenBalance>;
 }
 
+/**
+ * The logging surface SDK code uses. Never exported to hosts: they implement
+ * {@link Logger}, which is deliberately smaller.
+ */
+type InternalLogger = {
+    /**
+     * A logger narrowed by one more {@link LogBinding}, which every line it
+     * emits carries as its own field.
+     */
+    child(binding: LogBinding): InternalLogger;
+    /**
+     * The unredacted level. Request and response bodies, full URLs, headers,
+     * operation params and raw thrown errors belong here and **only** here.
+     */
+    debug(event: () => InternalDebugEvent): void;
+    info(event: () => InternalSafeEvent): void;
+    warn(event: () => InternalSafeEvent): void;
+    /**
+     * Reports a failure whose cause is already known, or has none. Prefer
+     * {@link failure}, which classifies a thrown error for you.
+     */
+    error(event: () => InternalSafeEvent): void;
+    /**
+     * Reports a thrown error, classifying it into a {@link LogCause}. Prefer
+     * this over `error` at a `catch`: classification only happens when the level
+     * admits it.
+     *
+     * The `error` line names the error's class but never its message, since an
+     * error the SDK did not author may say anything at all. The verbatim
+     * rendering goes onto a paired `debug` line instead.
+     *
+     * For a failure the SDK recovers from, use {@link warning} instead. An
+     * `error` line a host cannot act on is worse than no line at all: it trains
+     * them to ignore the ones that matter.
+     */
+    failure(event: () => InternalSafeEvent, error: unknown): void;
+    /**
+     * {@link failure} for trouble that did not break anything: a poll tick that
+     * failed while the last value still stands, a retried request.
+     *
+     * Carries the classified {@link LogCause} exactly as `failure` does. The two
+     * differ in level and in nothing else, because what separates them is
+     * whether anything actually broke - not how much is known about it.
+     */
+    warning(event: () => InternalSafeEvent, error: unknown): void;
+    /**
+     * Runs one namespace operation with logging around it: the call and its
+     * params at `debug`, and any throw at `error` with the cause classified.
+     * Every line carries `op` as a binding.
+     *
+     * **The params never reach the `error` line.** They routinely hold the
+     * things this SDK must not put in front of a production error tracker - an
+     * app bearer token, a document's signing fields, a wallet signature - and
+     * the `debug` line plus the request id is how you get them back. The type
+     * says so: `params` is `unknown`, which is not a {@link SafeFields} value.
+     *
+     * Always rethrows. Logging observes behaviour, it never changes it.
+     */
+    wrap<T>(op: string, params: unknown, run: () => Promise<T>): Promise<T>;
+};
+/**
+ * What a call site hands to `info`, `warn`, `error`, `failure` or `warning` -
+ * a {@link SafeEvent} minus the scope and bindings the logger stamps itself.
+ */
+type InternalSafeEvent = {
+    /** A **constant** string literal. Every varying value belongs in `fields`. */
+    readonly msg: string;
+    readonly fields?: SafeFields;
+    readonly cause?: LogCause;
+};
+/** What a call site hands to `debug`. Its fields accept anything. */
+type InternalDebugEvent = {
+    /** A **constant** string literal. Every varying value belongs in `fields`. */
+    readonly msg: string;
+    readonly fields?: UnredactedFields;
+};
+
 /**
  * The product an offer is checked out through. The backend sends one compound
  * `{supplier}::{saleType}` string, verbatim as spelled below: a double colon
@@ -456,6 +1161,12 @@ type OfferDto = {
     logo_url: string;
     starts_at: string;
     ends_at: string | null;
+    tokens: OfferTokenDto[];
+};
+type OfferTokenDto = {
+    role: 'funding' | 'distribution' | 'swap';
+    chain: string;
+    address: string;
 };
 
 type OfferId = Newtype<string, 'OfferId'>;
@@ -472,10 +1183,20 @@ type Offer = {
     logoUrl: string;
     startsAt: Date;
     endsAt: Date | null;
+    tokens: OfferToken[];
 };
 declare const Offer: {
     fromDto: (dto: OfferDto) => Offer;
 };
+type TokenRole = 'funding' | 'distribution' | 'swap';
+type OfferToken = {
+    role: TokenRole;
+    chain: Chain;
+    address: EvmContractAddress;
+};
+declare const OfferToken: {
+    fromDto: (dto: OfferTokenDto) => OfferToken;
+};
 
 /**
  * The cursor-paginated envelope every list endpoint returns.
@@ -563,7 +1284,7 @@ type OfferDetailDto = {
     asset: AssetDto;
     faqs: OfferDetailFaqDto[];
     funding_assets: AssetDto[];
-    tokens: OfferDetailTokenDto[];
+    tokens: OfferTokenDto[];
     id: string;
     links: OfferDetailLinkDto[];
     milestones: OfferDetailMilestoneDto[];
@@ -608,11 +1329,6 @@ type OfferDetailTermDto = {
     key: string | null;
     value: string | null;
 };
-type OfferDetailTokenDto = {
-    role: 'funding' | 'distribution' | 'swap';
-    chain: string;
-    address: string;
-};
 
 type OfferOptionId = Newtype<string, 'OfferOptionId'>;
 declare const OfferOptionId: (value: string) => OfferOptionId;
@@ -684,15 +1400,6 @@ type Milestone = {
 declare const Milestone: {
     fromDto: (dto: OfferDetailMilestoneDto) => Milestone;
 };
-type TokenRole = 'funding' | 'distribution' | 'swap';
-type OfferToken = {
-    role: TokenRole;
-    chain: Chain;
-    address: EvmContractAddress;
-};
-declare const OfferToken: {
-    fromDto: (dto: OfferDetailTokenDto) => OfferToken;
-};
 
 /** Unique identifier for a participation. */
 type ParticipationId = Newtype<string, 'ParticipationId'>;
@@ -812,6 +1519,7 @@ interface CoinListTokenSaleNamespace {
 }
 declare class CoinListTokenSaleNamespaceImpl implements CoinListTokenSaleNamespace {
     private readonly ctx;
+    protected readonly log: InternalLogger;
     constructor(ctx: SharedNamespaceContext);
     list(offerId?: OfferId): Promise<Participation[]>;
     listPage(params: ParticipationsPaginationParams): Promise<PaginatedResponse<Participation>>;
@@ -855,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.
      *
-     * Its `decimals` are also what the response's `pay_input_decimals` is
+     * 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 `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.
@@ -964,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.
+ * The transport half of a built swap, identical on both sides.
  *
- * 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.
+ * `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.
  *
- * **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.
- *
- * 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;
@@ -1005,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;
     /**
@@ -1048,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.
@@ -1092,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;
@@ -1123,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`.
+ * The half of a built swap that both sides share: the calldata, its deadline,
+ * and what the wallet parts with.
  *
- * 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.
- *
- * **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.
@@ -1153,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,
@@ -1170,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,
@@ -1200,26 +2147,44 @@ 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.
      */
-    buildSwapTransaction(params: BuildOndoSwapTransactionParams): Promise<OndoSwapTransaction>;
+    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`.
+     */
+    buildSellTransaction(params: BuildOndoSellParams): Promise<OndoSellTransaction>;
 }
 declare class OndoNamespaceImpl implements OndoNamespace {
     private readonly ctx;
+    protected readonly log: InternalLogger;
     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. */
@@ -1272,6 +2237,7 @@ interface SuperstateSwapNamespace {
 }
 declare class SuperstateSwapNamespaceImpl implements SuperstateSwapNamespace {
     private readonly ctx;
+    protected readonly log: InternalLogger;
     constructor(ctx: SharedNamespaceContext);
     getAuthorization(params: GetSwapAuthorizationParams): Promise<SwapAuthorization>;
     getPreview(params: GetSwapPreviewParams): Promise<SwapPreview>;
@@ -1465,6 +2431,7 @@ interface WalletsNamespace {
 }
 declare class WalletsNamespaceImpl implements WalletsNamespace {
     private readonly ctx;
+    private readonly log;
     constructor(ctx: SharedNamespaceContext);
     createOwnershipChallenge(params: CreateWalletOwnershipChallengeParams): Promise<WalletOwnershipChallenge>;
     connectExternal(params: ConnectExternalWalletParams): Promise<OfferOptionAddress>;
@@ -1577,7 +2544,7 @@ declare const Pii: {
     fromDto: (dto: PiiDto) => Pii;
 };
 
-type RequirementTypeDto = 'kyc_approved' | 'identity_verified' | 'proof_of_address' | 'source_of_funds' | 'external_wallet' | 'whitelisted_wallet' | 'jurisdiction' | 'accreditation' | 'document';
+type RequirementTypeDto = 'kyc_approved' | 'external_wallet' | 'whitelisted_wallet' | 'jurisdiction' | 'accreditation' | 'document';
 type RequirementDto = {
     object: 'requirement';
     id: string;
@@ -1701,6 +2668,7 @@ interface RequirementsNamespace {
 }
 declare class RequirementsNamespaceImpl implements RequirementsNamespace {
     protected readonly ctx: SharedNamespaceContext;
+    protected readonly log: InternalLogger;
     constructor(ctx: SharedNamespaceContext);
     forOffer(offerId: OfferId): Promise<Record<OfferOptionId, Requirement[]>>;
     statuses(offerId: OfferId): Promise<RequirementStatusInfo[]>;
@@ -1738,6 +2706,7 @@ interface OffersNamespace {
 }
 declare class OffersNamespaceImpl implements OffersNamespace {
     private readonly ctx;
+    private readonly log;
     constructor(ctx: SharedNamespaceContext);
     list(): Promise<Offer[]>;
     listPage(params: PaginationParams): Promise<PaginatedResponse<Offer>>;
@@ -1806,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
@@ -1855,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).
@@ -1865,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
@@ -1879,26 +2865,31 @@ 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;
+    private readonly log;
     /**
      * Takes the registry origin rather than a `SharedNamespaceContext`: the
      * registry is unauthenticated and on its own host, so the frontline sender
      * and the auth check would both be dead weight here.
      */
-    constructor(baseUrl: string);
+    constructor(baseUrl: string, logger?: Logger | null);
     get(token: TokenIdentifier): Promise<TokenMetadata | null>;
-    list(chain: EthereumChain): Promise<TokenMetadata[]>;
+    list(chain?: EthereumChain): Promise<TokenMetadata[]>;
 }
 
 interface Config {
@@ -1921,6 +2912,48 @@ interface Config {
      * registry.
      */
     readonly tokensBaseUrl?: string;
+    /**
+     * Where the SDK reports what it is doing. **Omit it and the SDK logs nothing
+     * at all** - no `console` fallback, at any level, on any codepath. Supply
+     * one and every request, every classified failure and every hook state
+     * transition is reported at the level your logger asks for.
+     *
+     * Absent, the SDK says nothing at all - there is no fallback to `console`,
+     * at any level, on any codepath.
+     *
+     * **Running the SDK's logging in production is not advised.** The safest
+     * posture is to leave this undefined outside development, staging and
+     * incident reproduction: a seam that emits nothing cannot disclose anything,
+     * and that property does not depend on the SDK continuing to get redaction
+     * right.
+     *
+     * If you do run one there, run it at `'info'` or above and know what that
+     * does and does not buy you. Those levels are **redacted by construction**:
+     * they carry only SDK-authored classification and server-authored
+     * identifiers, and the type system holds that line rather than a convention -
+     * an event at those levels accepts scalar fields only, so a body, a DTO or
+     * an operation's parameters cannot be put on one. What the SDK does **not**
+     * give you is a warranty that the result is safe for your environment. The
+     * mechanism is checkable and stated; the conclusion depends on your sink,
+     * your retention and your threat model, and it is yours to draw.
+     *
+     * **`'debug'` is not.** It reports request and response bodies, full URLs,
+     * headers and operation parameters verbatim - bearer tokens, KYC answers,
+     * tax-document fields, wallet signatures - and **the SDK does not redact**.
+     * Run it on a developer's machine, in tests, and in beta or staging
+     * environments where the data flowing through is not real customer data.
+     * The shipped implementations make that structural: built with
+     * `isDev: false`, `'debug'` does not typecheck. Either way, filtering,
+     * redaction and retention at your sink are yours, not the SDK's.
+     *
+     * Every method you implement here **must be total**: the SDK calls them on
+     * the codepath of the work they report and does not catch them, so a logger
+     * that throws fails the operation it was describing.
+     *
+     * See {@link Logger} for the full contract, and {@link pinoClientLogger} or
+     * {@link pinoServerLogger} for a ready-made implementation over pino.
+     */
+    readonly logger?: Logger;
 }
 
-export { type HttpResponse as $, AuthorizationCode as A, BlockchainAmount as B, CodeVerifier as C, type RequirementType as D, EvmWalletAddress as E, type RequirementStatusValue as F, OfferOptionAddress as G, RequirementId as H, type WalletChallengeType as I, DocumentSubmission as J, type KycLevelName as K, OndoTradingStatus as L, AssetDecimals as M, OndoQuote as N, OfferId as O, Participation as P, type OrderBookSide as Q, type RequirementsNamespace as R, type SharedNamespaceContext as S, type Tx as T, type OndoQuoteSize as U, type BuildOndoSwapTransactionParams as V, type WalletsNamespace as W, OfferOptionAddressId as X, TokenMetadata as Y, type TokenIdentifier as Z, HttpError as _, EthereumChain as a, type RemoveOptionAddressParams as a$, KycToken as a0, OAuthSession as a1, ClientCredentialsOAuth as a2, ClientSecret as a3, type Sender as a4, PaginationParams as a5, PaginatedResponse as a6, type Uint256 as a7, KnownAssetSymbol as a8, DecimalString as a9, type GetTokenBalanceParams as aA, HexEncodedTransactionData as aB, Iso2CountryCode as aC, Link as aD, type ListOptionAddressesParams as aE, MAX_ASSET_DECIMALS as aF, MAX_UINT_256 as aG, Milestone as aH, OAuthRefreshToken as aI, OfferOption as aJ, OfferOptionSlug as aK, OfferSlug as aL, OfferToken as aM, OffersNamespaceImpl as aN, type OndoQuoteDuration as aO, PKCEState as aP, type PaginatedResponseDto as aQ, ParticipationId as aR, type ParticipationStatus as aS, ParticipationsPaginationParams as aT, Pii as aU, PiiAddress as aV, PiiJurisdiction as aW, type PiiKind as aX, type QueryParamValue as aY, type QueryParamValues as aZ, RedirectUri as a_, SwapStatus as aa, type Newtype as ab, type AllowWalletParams as ac, AllowWalletResponse as ad, Asset as ae, AssetCode as af, Blockchain as ag, Chain as ah, ClientId as ai, CodeChallenge as aj, ConnectExternalWalletParams as ak, type CreateKycTokenParams as al, CreateParticipationParams as am, CreateWalletOwnershipChallengeParams as an, Cursor as ao, type DocumentFormType as ap, type DocumentSubmissionStatus as aq, type DocumentType as ar, ETHEREUM_CHAINS as as, Erc20NamespaceImpl as at, FaqItem as au, type GetOndoQuoteParams as av, type GetOndoTradingStatusParams as aw, type GetSwapAuthorizationParams as ax, type GetSwapPreviewParams as ay, type GetTokenAllowanceParams as az, type Erc20Namespace as b, type RequirementActionNeededReason as b0, SOLANA_CHAINS as b1, STABLE_DECIMALS as b2, SolanaChain as b3, type SubmitDocumentParams as b4, SwapAuthorization as b5, type SwapContractRef as b6, SwapPreview as b7, TermItem as b8, Ticker as b9, TokenAllowance as ba, TokenBalance as bb, TokenLogo as bc, type TokenLogoImage as bd, TokenLogoUrl as be, type TokenRole as bf, TokensNamespaceImpl as bg, WalletAddress as bh, WalletOwnershipChallenge as bi, type WalletProtocol as bj, WalletsNamespaceImpl as bk, apiErrorCode as bl, assertUint256 as bm, EvmContractAddress as c, type CoinListTokenSaleNamespace as d, OfferOptionId as e, AssetId as f, CoinListTokenSaleNamespaceImpl as g, type OndoNamespace as h, AssetSymbol as i, OndoSwapTransaction as j, OndoNamespaceImpl as k, type SuperstateSwapNamespace as l, Bps as m, SuperstateSwapNamespaceImpl as n, Requirement as o, RequirementsNamespaceImpl as p, type Config as q, type OAuthAccessToken as r, type OffersNamespace as s, type TokensNamespace 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 };