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

package/dist/{chunk-UIIXXLA7.js → chunk-7CTH4KPU.js}

@@ -25,6 +25,8 @@ var retryAttempt = (attempt) => ({
 var renewAttempted = (value) => ({
   renewAttempted: value
 });
+var requestId = (id) => ({ requestId: id });
+var getRequestId = (attrs) => attrs?.requestId ?? null;
 var isProtected = (attrs) => attrs?.protected === true;
 var needUserAgent = (attrs) => attrs?.userAgent === true;
 var isIdempotent = (attrs) => attrs?.idempotencyKey === true;
@@ -46,7 +48,9 @@ var Attributes = {
   renewAttempted,
   wasRenewAttempted,
   clientCredentials,
-  getClientCredentials
+  getClientCredentials,
+  requestId,
+  getRequestId
 };
 
 // src/shared/api/http.ts
@@ -56,6 +60,16 @@ var HttpError = class extends Error {
     this.name = "HttpError";
     this.response = response;
   }
+  /**
+   * 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() {
+    return this.response.requestId ?? null;
+  }
 };
 function apiErrorCode(error) {
   if (!(error instanceof HttpError)) return null;
@@ -163,22 +177,6 @@ var Request = {
   concatAttributes
 };
 
-// src/shared/api/pagination.ts
-async function fetchAllPages(fetchPage, baseParams) {
-  const items = [];
-  let cursor = null;
-  do {
-    const params = {
-      ...baseParams ?? {},
-      after: cursor ?? void 0
-    };
-    const page = await fetchPage(params);
-    items.push(...page.data);
-    cursor = page.startingAfter;
-  } while (cursor);
-  return items;
-}
-
 // src/shared/types/errors.ts
 var NotImplementedError = class extends Error {
   constructor(message = "Not implemented yet") {
@@ -198,11 +196,41 @@ var ValidationError = class extends Error {
     this.name = "ValidationError";
   }
 };
+var InvariantError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvariantError";
+  }
+};
+var MathError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MathError";
+  }
+};
+
+// src/shared/api/pagination.ts
+async function fetchAllPages(fetchPage, baseParams) {
+  const items = [];
+  let cursor = null;
+  do {
+    const params = {
+      ...baseParams ?? {},
+      after: cursor ?? void 0
+    };
+    const page = await fetchPage(params);
+    items.push(...page.data);
+    cursor = page.startingAfter;
+  } while (cursor);
+  return items;
+}
 
 // src/shared/types/blockchain/core.ts
 var ETHEREUM_CHAINS = {
   ethereum_mainnet: true,
-  ethereum_sepolia: true
+  ethereum_sepolia: true,
+  base_mainnet: true,
+  base_sepolia: true
 };
 var EthereumChain = (value) => {
   if (!Object.keys(ETHEREUM_CHAINS).includes(value)) {
@@ -245,27 +273,46 @@ var STABLE_DECIMALS = AssetDecimals(6);
 var DecimalString = (value) => value;
 var MAX_UINT_256 = 2n ** 256n - 1n;
 var assertUint256 = (value) => {
-  if (value < 0n || value > MAX_UINT_256) {
-    throw new Error(`Value out of uint256 bounds: ${value}`);
-  }
-  return value;
+  if (isUint256(value)) return value;
+  throw new InvariantError(`Value out of uint256 bounds: ${value}`);
 };
+var parseUint256 = (value, label) => {
+  if (isUint256(value)) return value;
+  throw new ValidationError(`${label}: out of uint256 bounds (${value})`);
+};
+var isUint256 = (value) => value >= 0n && value <= MAX_UINT_256;
 var BlockchainAmount = Object.assign(
   (value) => value,
   {
     add: (a, b) => combineAmounts(a, b, (x, y) => x + y),
-    sub: (a, b) => combineAmounts(a, b, (x, y) => x - y)
+    sub: (a, b) => combineAmounts(a, b, (x, y) => x - y),
+    mul: multiplyAmounts,
+    div: divideAmounts
   }
 );
+function multiplyAmounts(a, b) {
+  const product = a.raw * b.raw;
+  return BlockchainAmount({
+    raw: product / 10n ** BigInt(b.decimals),
+    decimals: a.decimals
+  });
+}
+function divideAmounts(a, b) {
+  if (b.raw === 0n) {
+    throw new MathError("Cannot divide a BlockchainAmount by zero");
+  }
+  const scaled = a.raw * 10n ** BigInt(b.decimals);
+  return BlockchainAmount({ raw: scaled / b.raw, decimals: a.decimals });
+}
 function combineAmounts(a, b, op) {
   if (a.decimals !== b.decimals) {
-    throw new Error(
+    throw new InvariantError(
       `Cannot combine BlockchainAmounts with different decimals: ${a.decimals} vs ${b.decimals}`
     );
   }
   const raw = op(a.raw, b.raw);
   if (raw < 0n || raw > MAX_UINT_256) {
-    throw new Error(`BlockchainAmount out of uint256 bounds: ${raw}`);
+    throw new InvariantError(`BlockchainAmount out of uint256 bounds: ${raw}`);
   }
   return BlockchainAmount({ raw, decimals: a.decimals });
 }
@@ -285,7 +332,9 @@ var AssetIconUrl = (value) => value;
 // src/shared/core/blockchain/chain.ts
 var CHAIN_IDS = {
   ethereum_mainnet: 1,
-  ethereum_sepolia: 11155111
+  ethereum_sepolia: 11155111,
+  base_mainnet: 8453,
+  base_sepolia: 84532
 };
 function getChainId(chain) {
   return CHAIN_IDS[chain];
@@ -304,6 +353,10 @@ function getNetworkName(chain) {
       return "Ethereum";
     case "ethereum_sepolia":
       return "Ethereum Sepolia";
+    case "base_mainnet":
+      return "Base";
+    case "base_sepolia":
+      return "Base Sepolia";
     default: {
       const _exhaustive = chain;
       return _exhaustive;
@@ -319,6 +372,10 @@ function explorerBaseUrl(chain) {
       return "https://etherscan.io";
     case "ethereum_sepolia":
       return "https://sepolia.etherscan.io";
+    case "base_mainnet":
+      return "https://basescan.org";
+    case "base_sepolia":
+      return "https://sepolia-explorer.base.org";
     default: {
       const _exhaustive = chain;
       return _exhaustive;
@@ -334,25 +391,31 @@ var SwapAuthorization = {
 };
 var SwapPreview = {
   fromDto: (dto) => ({
-    inputAmount: assertUint256(BigInt(dto.pay_input_amount)),
-    fee: assertUint256(BigInt(dto.fee)),
-    outputAmount: assertUint256(BigInt(dto.receive_output_amount))
+    inputAmount: parseUint256(
+      BigInt(dto.pay_input_amount),
+      "SwapPreview.pay_input_amount"
+    ),
+    fee: parseUint256(BigInt(dto.fee), "SwapPreview.fee"),
+    outputAmount: parseUint256(
+      BigInt(dto.receive_output_amount),
+      "SwapPreview.receive_output_amount"
+    )
   })
 };
 var SwapStatus = {
   fromDto: (dto) => ({
-    stopped: assertUint256(BigInt(dto.stopped)),
-    swapLevel: assertUint256(BigInt(dto.swap_level))
+    stopped: parseUint256(BigInt(dto.stopped), "SwapStatus.stopped"),
+    swapLevel: parseUint256(BigInt(dto.swap_level), "SwapStatus.swap_level")
   })
 };
 var TokenAllowance = {
   fromDto: (dto) => ({
-    allowance: assertUint256(BigInt(dto.allowance))
+    allowance: parseUint256(BigInt(dto.allowance), "TokenAllowance.allowance")
   })
 };
 var TokenBalance = {
   fromDto: (dto) => ({
-    balance: assertUint256(BigInt(dto.balance))
+    balance: parseUint256(BigInt(dto.balance), "TokenBalance.balance")
   })
 };
 var AllowWalletResponse = {
@@ -477,18 +540,172 @@ function toErc20Asset(dto) {
   };
 }
 
+// src/shared/core/observability/log-cause.ts
+function classifyLogCause(error) {
+  if (error instanceof HttpError) {
+    return httpCause(error);
+  }
+  if (error instanceof ValidationError) {
+    return { type: "validation", message: error.message };
+  }
+  if (error instanceof InvariantError) {
+    return { type: "invariant", message: error.message };
+  }
+  if (error instanceof MathError) {
+    return { type: "math", message: error.message };
+  }
+  if (error instanceof NotAuthenticatedError) {
+    return { type: "not-authenticated" };
+  }
+  if (error instanceof NotImplementedError) {
+    return { type: "not-implemented" };
+  }
+  return { type: "generic-error", name: errorName(error) };
+}
+function describeErrorUnredacted(error) {
+  if (error instanceof HttpError) {
+    return describeHttpErrorRedacted(error);
+  }
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return `thrown non-error: ${stringifyUnredacted(error)}`;
+}
+function stringifyUnredacted(value) {
+  if (value === void 0) return "";
+  try {
+    return JSON.stringify(
+      value,
+      (_key, item) => typeof item === "bigint" ? `${item}` : item
+    ) ?? String(value);
+  } catch (_) {
+    return "<unserializable>";
+  }
+}
+function describeHttpErrorRedacted(error) {
+  const code = apiErrorCode(error);
+  const status = error.response.status;
+  return code === null ? `HttpError ${status}` : `HttpError ${status} (${code})`;
+}
+function errorName(error) {
+  return error instanceof Error ? error.name : `non-error ${typeof error}`;
+}
+function httpCause(error) {
+  return {
+    type: "http",
+    requestId: error.requestId,
+    status: error.response.status,
+    code: apiErrorCode(error),
+    eventId: apiErrorEventId(error)
+  };
+}
+function apiErrorEventId(error) {
+  const body = error.response.body;
+  if (typeof body !== "object" || body === null) return null;
+  const eventId = body.event_id;
+  return typeof eventId === "string" ? eventId : null;
+}
+
+// src/shared/core/observability/internal-logger.ts
+function internalLogger(logger, scope) {
+  return logger ? scopedLogger(logger, scope, {}) : noopInternalLogger;
+}
+var LEVEL_RANK = {
+  none: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+function scopedLogger(logger, scope, bindings) {
+  const admits = (level) => LEVEL_RANK[logger.level()] >= LEVEL_RANK[level];
+  const safe = (event) => ({
+    msg: event.msg,
+    scope,
+    bindings,
+    fields: event.fields ?? {},
+    ...event.cause === void 0 ? {} : { cause: event.cause }
+  });
+  const unredacted = (event) => ({
+    msg: event.msg,
+    scope,
+    bindings,
+    fields: event.fields ?? {}
+  });
+  const self = {
+    child: (binding) => scopedLogger(logger, scope, { ...bindings, ...binding }),
+    debug: (event) => {
+      if (admits("debug")) logger.debug(() => unredacted(event()));
+    },
+    info: (event) => {
+      if (admits("info")) logger.info(() => safe(event()));
+    },
+    warn: (event) => {
+      if (admits("warn")) logger.warn(() => safe(event()));
+    },
+    error: (event) => {
+      if (admits("error")) logger.error(() => safe(event()));
+    },
+    failure: (event, error) => {
+      if (admits("debug"))
+        logger.debug(() => unredacted(verbatim(event(), error)));
+      if (admits("error")) logger.error(() => safe(classified(event(), error)));
+    },
+    warning: (event, error) => {
+      if (admits("debug"))
+        logger.debug(() => unredacted(verbatim(event(), error)));
+      if (admits("warn")) logger.warn(() => safe(classified(event(), error)));
+    },
+    wrap: async (op, params, run) => {
+      const opLog = self.child({ op });
+      opLog.debug(() => ({ msg: "call", fields: { params } }));
+      try {
+        return await run();
+      } catch (error) {
+        opLog.failure(() => ({ msg: "call failed" }), error);
+        throw error;
+      }
+    }
+  };
+  return self;
+}
+function verbatim(event, error) {
+  return {
+    msg: event.msg,
+    fields: { ...event.fields, error: describeErrorUnredacted(error) }
+  };
+}
+function classified(event, error) {
+  return { ...event, cause: event.cause ?? classifyLogCause(error) };
+}
+var noopInternalLogger = {
+  child: () => noopInternalLogger,
+  debug: () => void 0,
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0,
+  failure: () => void 0,
+  warning: () => void 0,
+  wrap: (_op, _params, run) => run()
+};
+
 // src/shared/core/blockchain/erc20/erc20-namespace.ts
 var Erc20NamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "ERC20");
   }
   async getAllowance(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getTokenAllowance(this.ctx.api, params);
+    return this.log.wrap("getAllowance", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getTokenAllowance(this.ctx.api, params);
+    });
   }
   async getBalance(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getTokenBalance(this.ctx.api, params);
+    return this.log.wrap("getBalance", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getTokenBalance(this.ctx.api, params);
+    });
   }
 };
 
@@ -684,15 +901,30 @@ var Asset = {
 var OfferId = (value) => value;
 var OfferSlug = (value) => value;
 var Offer = {
+  fromDto: (dto) => {
+    if (!Array.isArray(dto.tokens)) {
+      throw new ValidationError(
+        `Offer.tokens: expected an array, got ${typeof dto.tokens}`
+      );
+    }
+    return {
+      id: OfferId(dto.id),
+      slug: OfferSlug(dto.slug),
+      type: dto.type,
+      tagline: dto.tagline,
+      bannerUrl: dto.banner_url,
+      logoUrl: dto.logo_url,
+      startsAt: new Date(dto.starts_at),
+      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
+      tokens: dto.tokens.map(OfferToken.fromDto)
+    };
+  }
+};
+var OfferToken = {
   fromDto: (dto) => ({
-    id: OfferId(dto.id),
-    slug: OfferSlug(dto.slug),
-    type: dto.type,
-    tagline: dto.tagline,
-    bannerUrl: dto.banner_url,
-    logoUrl: dto.logo_url,
-    startsAt: new Date(dto.starts_at),
-    endsAt: dto.ends_at ? new Date(dto.ends_at) : null
+    role: dto.role,
+    chain: Chain(dto.chain),
+    address: EvmContractAddress(dto.address)
   })
 };
 
@@ -752,25 +984,39 @@ var OfferOptionSlug = (value) => value;
 var OfferDetail = {
   fromDto: (dto) => {
     if (!Array.isArray(dto.funding_assets)) {
-      throw new Error(`funding_assets must be an array`);
+      throw new ValidationError(
+        `OfferDetail.funding_assets: expected an array, got ${typeof dto.funding_assets}`
+      );
     }
     if (!Array.isArray(dto.options)) {
-      throw new Error(`options must be an array`);
+      throw new ValidationError(
+        `OfferDetail.options: expected an array, got ${typeof dto.options}`
+      );
     }
     if (!Array.isArray(dto.terms)) {
-      throw new Error(`terms must be an array`);
+      throw new ValidationError(
+        `OfferDetail.terms: expected an array, got ${typeof dto.terms}`
+      );
     }
     if (!Array.isArray(dto.links)) {
-      throw new Error(`links must be an array`);
+      throw new ValidationError(
+        `OfferDetail.links: expected an array, got ${typeof dto.links}`
+      );
     }
     if (!Array.isArray(dto.faqs)) {
-      throw new Error(`faqs must be an array`);
+      throw new ValidationError(
+        `OfferDetail.faqs: expected an array, got ${typeof dto.faqs}`
+      );
     }
     if (!Array.isArray(dto.milestones)) {
-      throw new Error(`milestones must be an array`);
+      throw new ValidationError(
+        `OfferDetail.milestones: expected an array, got ${typeof dto.milestones}`
+      );
     }
     if (!Array.isArray(dto.tokens)) {
-      throw new Error(`tokens must be an array`);
+      throw new ValidationError(
+        `OfferDetail.tokens: expected an array, got ${typeof dto.tokens}`
+      );
     }
     return {
       id: OfferId(dto.id),
@@ -832,13 +1078,6 @@ var Milestone = {
     status: dto.status
   })
 };
-var OfferToken = {
-  fromDto: (dto) => ({
-    role: dto.role,
-    chain: Chain(dto.chain),
-    address: EvmContractAddress(dto.address)
-  })
-};
 
 // src/shared/types/providers/coin-list/token-sale.ts
 var ParticipationId = (value) => value;
@@ -925,22 +1164,31 @@ async function createParticipation(api, params) {
 var CoinListTokenSaleNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "TOKEN_SALE");
   }
   async list(offerId) {
-    await this.ctx.ensureUserAuthenticated();
-    return fetchParticipations(this.ctx.api, offerId);
+    return this.log.wrap("list", offerId, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchParticipations(this.ctx.api, offerId);
+    });
   }
   async listPage(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return fetchParticipationsPage(this.ctx.api, params);
+    return this.log.wrap("listPage", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchParticipationsPage(this.ctx.api, params);
+    });
   }
   async get(id) {
-    await this.ctx.ensureUserAuthenticated();
-    return fetchParticipation(this.ctx.api, id);
+    return this.log.wrap("get", id, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchParticipation(this.ctx.api, id);
+    });
   }
   async createParticipation(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return createParticipation(this.ctx.api, params);
+    return this.log.wrap("createParticipation", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createParticipation(this.ctx.api, params);
+    });
   }
 };
 
@@ -985,47 +1233,122 @@ var OndoQuote = {
     };
   }
 };
-var OndoSwapTransaction = {
+var OndoBuyTransaction = {
   fromDto: (dto) => {
-    const inputDecimals = AssetDecimals(dto.pay_input_decimals);
+    const spendDecimals = AssetDecimals(dto.spend_input_decimals);
     const outputDecimals = AssetDecimals(dto.receive_output_decimals);
     return {
-      tx: {
-        to: EvmContractAddress(dto.to),
-        data: HexEncodedTransactionData(dto.data)
-      },
-      expiresAt: parseExpiresAt(dto.expires_at),
-      payInputAmount: blockchainAmountFromRawOrThrow({
-        label: "pay_input_amount",
-        raw: dto.pay_input_amount,
-        decimals: inputDecimals
-      }),
+      ...parseSwapCore(dto, spendDecimals),
+      side: "buy",
       fee: blockchainAmountFromRawOrThrow({
         label: "fee",
         raw: dto.fee,
-        decimals: inputDecimals
+        decimals: spendDecimals
       }),
       notionalValue: blockchainAmountFromRawOrThrow({
         label: "notional_value",
         raw: dto.notional_value,
-        decimals: inputDecimals
+        decimals: spendDecimals
       }),
-      receiveOutputAmount: parseReceiveOutputAmount(
-        dto.receive_output_amount,
-        outputDecimals
-      )
+      receiveOutputAmount: parsePositiveAmount({
+        label: "receive_output_amount",
+        raw: dto.receive_output_amount,
+        decimals: outputDecimals,
+        // A transaction that yields nothing is not one to sign - the user
+        // would pay the deposit and receive no asset - and frontline refuses
+        // to emit one. A zero here is a changed encoding, not a small order.
+        // Rejecting it at the boundary is also what lets `computeOndoBuyPrice`
+        // divide by it without a fallible result: the failure surfaces as the
+        // data hook's ERROR state rather than as a division during render.
+        reason: "a buy that yields nothing is not fillable"
+      })
+    };
+  }
+};
+var OndoSellTransaction = {
+  fromDto: (dto) => {
+    const spendDecimals = AssetDecimals(dto.spend_input_decimals);
+    const outputDecimals = AssetDecimals(dto.receive_output_decimals);
+    const expectedQuantity = parsePositiveAmount({
+      label: "expected_quantity",
+      raw: dto.expected_quantity,
+      decimals: outputDecimals,
+      reason: "a sale that yields nothing is not fillable"
+    });
+    return {
+      ...parseSwapCore(dto, spendDecimals),
+      side: "sell",
+      expected: {
+        quantity: expectedQuantity,
+        fee: blockchainAmountFromRawOrThrow({
+          label: "expected_fee",
+          raw: dto.expected_fee,
+          decimals: outputDecimals
+        })
+      },
+      minimum: {
+        quantity: parseMinimumQuantity(
+          dto.minimum_quantity,
+          outputDecimals,
+          expectedQuantity
+        ),
+        fee: blockchainAmountFromRawOrThrow({
+          label: "minimum_fee",
+          raw: dto.minimum_fee,
+          decimals: outputDecimals
+        })
+      }
     };
   }
 };
-function parseReceiveOutputAmount(raw, decimals) {
-  const amount = blockchainAmountFromRawOrThrow({
-    label: "receive_output_amount",
+function parseSwapCore(dto, spendDecimals) {
+  return {
+    tx: {
+      to: EvmContractAddress(dto.to),
+      data: HexEncodedTransactionData(dto.data)
+    },
+    expiresAt: parseExpiresAt(dto.expires_at),
+    spendInputAmount: parsePositiveAmount({
+      label: "spend_input_amount",
+      raw: dto.spend_input_amount,
+      decimals: spendDecimals,
+      // A transaction that takes nothing from the wallet is not one to sign:
+      // it would settle one leg of a trade and skip the other. Frontline
+      // refuses an `amount` of zero whichever way the trade runs, so this is a
+      // changed encoding rather than a small order.
+      //
+      // Guarded on both sides rather than on the sale alone, because which
+      // amount becomes the divisor in the price flips with the direction: a
+      // guard placed by that would be a rule about the arithmetic rather than
+      // about the trade.
+      reason: "a swap that spends nothing is not fillable"
+    })
+  };
+}
+function parseMinimumQuantity(raw, decimals, expectedQuantity) {
+  const amount = parsePositiveAmount({
+    label: "minimum_quantity",
     raw,
-    decimals
+    decimals,
+    reason: "a floor of zero guarantees nothing"
   });
+  if (amount.raw > expectedQuantity.raw) {
+    throw new ValidationError(
+      `minimum_quantity: must not exceed expected_quantity ("${raw}" > "${expectedQuantity.raw}")`
+    );
+  }
+  return amount;
+}
+function parsePositiveAmount({
+  label,
+  raw,
+  decimals,
+  reason
+}) {
+  const amount = blockchainAmountFromRawOrThrow({ label, raw, decimals });
   if (amount.raw <= 0n) {
     throw new ValidationError(
-      `receive_output_amount: must be greater than zero ("${raw}")`
+      `${label}: must be greater than zero ("${raw}") - ${reason}`
     );
   }
   return amount;
@@ -1062,27 +1385,57 @@ async function getOndoQuote(api, params) {
   });
   return OndoQuote.fromDto(dto);
 }
-async function buildOndoSwapTransaction(api, params) {
+async function buildOndoBuy(api, params) {
   const dto = await api.send({
     method: "POST",
-    url: "/v1/ondo/swap/transaction",
-    body: {
-      symbol: params.symbol,
-      chain: params.chain,
-      wallet_address: params.walletAddress,
-      amount: params.amount.raw.toString()
-    },
+    url: "/v1/ondo/swap/buy",
+    body: swapBody(params),
     attributes: Attributes.protected()
   });
-  assertFundingScaleAgrees(dto, params);
-  return OndoSwapTransaction.fromDto(dto);
+  assertSpendScaleAgrees({
+    published: dto.spend_input_decimals,
+    sized: params.amount,
+    trade: "purchase"
+  });
+  return OndoBuyTransaction.fromDto(dto);
 }
-function assertFundingScaleAgrees(dto, params) {
-  if (dto.pay_input_decimals !== params.amount.decimals) {
-    throw new ValidationError(
-      `pay_input_decimals: the swap was priced in ${dto.pay_input_decimals} decimals but the order was sized in ${params.amount.decimals}`
-    );
-  }
+async function buildOndoSell(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/ondo/swap/sell",
+    body: swapBody(params),
+    attributes: Attributes.protected()
+  });
+  assertSpendScaleAgrees({
+    published: dto.spend_input_decimals,
+    sized: params.amount,
+    trade: "sale",
+    // The two answers come from two chains, so on a testnet they can disagree
+    // for a reason that is neither the caller's nor a corrupt response. Say so,
+    // or a QA run reads as a puzzle rather than a diagnosis.
+    note: "the quote resolves the asset on Ethereum mainnet while the swap executes on the chain requested, so these disagree until frontline serves a chain-scoped quote"
+  });
+  return OndoSellTransaction.fromDto(dto);
+}
+function swapBody(params) {
+  return {
+    symbol: params.symbol,
+    chain: params.chain,
+    wallet_address: params.walletAddress,
+    amount: params.amount.raw.toString()
+  };
+}
+function assertSpendScaleAgrees({
+  published,
+  sized,
+  trade,
+  note
+}) {
+  if (published === sized.decimals) return;
+  const because = note === void 0 ? "" : ` - ${note}`;
+  throw new ValidationError(
+    `spend_input_decimals: the ${trade} was priced in ${published} decimals but the order was sized in ${sized.decimals}${because}`
+  );
 }
 function sizeParam(params) {
   const tokenAmount = "tokenAmount" in params ? params.tokenAmount : void 0;
@@ -1107,18 +1460,31 @@ function sizeParam(params) {
 var OndoNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "ONDO");
   }
   async getTradingStatus(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getOndoTradingStatus(this.ctx.api, params);
+    return this.log.wrap("getTradingStatus", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getOndoTradingStatus(this.ctx.api, params);
+    });
   }
   async getQuote(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getOndoQuote(this.ctx.api, params);
+    return this.log.wrap("getQuote", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getOndoQuote(this.ctx.api, params);
+    });
   }
-  async buildSwapTransaction(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return buildOndoSwapTransaction(this.ctx.api, params);
+  async buildBuyTransaction(params) {
+    return this.log.wrap("buildBuyTransaction", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return buildOndoBuy(this.ctx.api, params);
+    });
+  }
+  async buildSellTransaction(params) {
+    return this.log.wrap("buildSellTransaction", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return buildOndoSell(this.ctx.api, params);
+    });
   }
 };
 
@@ -1126,26 +1492,37 @@ var OndoNamespaceImpl = class {
 var SuperstateSwapNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "SUPERSTATE");
   }
   async getAuthorization(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getSwapAuthorization(this.ctx.api, params);
+    return this.log.wrap("getAuthorization", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getSwapAuthorization(this.ctx.api, params);
+    });
   }
   async getPreview(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getSwapPreview(this.ctx.api, params);
+    return this.log.wrap("getPreview", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getSwapPreview(this.ctx.api, params);
+    });
   }
   async getStatus(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getSwapStatus(this.ctx.api, params);
+    return this.log.wrap("getStatus", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getSwapStatus(this.ctx.api, params);
+    });
   }
   async getOutputToken(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return getSwapOutputToken(this.ctx.api, params);
+    return this.log.wrap("getOutputToken", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getSwapOutputToken(this.ctx.api, params);
+    });
   }
   async allowWallet(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return allowWallet(this.ctx.api, params);
+    return this.log.wrap("allowWallet", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return allowWallet(this.ctx.api, params);
+    });
   }
 };
 
@@ -1278,38 +1655,49 @@ async function fetchRequirementStatuses(api, offerId) {
 var RequirementsNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "REQUIREMENTS");
   }
   async forOffer(offerId) {
-    await this.ctx.ensureUserAuthenticated();
-    return fetchOfferRequirements(
-      this.ctx.api,
-      offerId,
-      void 0
-    );
+    return this.log.wrap("forOffer", offerId, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchOfferRequirements(
+        this.ctx.api,
+        offerId,
+        void 0
+      );
+    });
   }
   async statuses(offerId) {
-    await this.ctx.ensureUserAuthenticated();
-    return fetchRequirementStatuses(this.ctx.api, offerId);
+    return this.log.wrap("statuses", offerId, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchRequirementStatuses(this.ctx.api, offerId);
+    });
   }
   async createKycToken(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return createKycToken(
-      this.ctx.api,
-      params?.levelName,
-      params?.reset
-    );
+    return this.log.wrap("createKycToken", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createKycToken(
+        this.ctx.api,
+        params?.levelName,
+        params?.reset
+      );
+    });
   }
   async getPii() {
-    await this.ctx.ensureUserAuthenticated();
-    return fetchPii(this.ctx.api);
+    return this.log.wrap("getPii", void 0, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchPii(this.ctx.api);
+    });
   }
   async submitDocument(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return submitDocument(
-      this.ctx.api,
-      params.documentType,
-      params.fields
-    );
+    return this.log.wrap("submitDocument", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return submitDocument(
+        this.ctx.api,
+        params.documentType,
+        params.fields
+      );
+    });
   }
 };
 
@@ -1339,27 +1727,47 @@ var TokenMetadata = {
       logoDark: dto.logo_dark === void 0 ? null : TokenLogo.fromDto(dto.logo_dark, baseUrl)
     };
   },
+  /**
+   * Maps the complete registry snapshot to every token it lists across the
+   * chains this SDK models, skipping native coins and chains outside
+   * {@link EthereumChain} (e.g. Solana) rather than failing on them — the
+   * registry may serve chains ahead of the SDK's type surface.
+   */
+  fromRegistryDto: (dto, baseUrl) => {
+    assertSupportedSchemaVersion(dto.schema_version);
+    return dto.chains.flatMap((chainDto) => {
+      let chain;
+      try {
+        chain = EthereumChain(chainDto.chain);
+      } catch {
+        return [];
+      }
+      return tokensOfChain(chain, chainDto.assets, baseUrl);
+    });
+  },
   /**
    * Maps a chain snapshot to the tokens it lists, skipping the chain's native
    * coin (`kind: 'COIN'`, no contract address).
    */
   fromChainAssetsDto: (dto, baseUrl) => {
     assertSupportedSchemaVersion(dto.schema_version);
-    const chain = EthereumChain(dto.chain);
-    return dto.assets.filter((asset) => asset.kind === "TOKEN" && asset.address !== void 0).map((asset) => ({
-      identifier: {
-        chain,
-        // The filter above cannot narrow `address` for the type checker.
-        address: EvmContractAddress(asset.address)
-      },
-      name: asset.name,
-      symbol: AssetSymbol(asset.symbol),
-      decimals: AssetDecimals(asset.decimals),
-      logo: TokenLogo.fromDto(asset.logo, baseUrl),
-      logoDark: asset.logo_dark === void 0 ? null : TokenLogo.fromDto(asset.logo_dark, baseUrl)
-    }));
+    return tokensOfChain(EthereumChain(dto.chain), dto.assets, baseUrl);
   }
 };
+function tokensOfChain(chain, assets, baseUrl) {
+  return assets.filter((asset) => asset.kind === "TOKEN" && asset.address !== void 0).map((asset) => ({
+    identifier: {
+      chain,
+      // The filter above cannot narrow `address` for the type checker.
+      address: EvmContractAddress(asset.address)
+    },
+    name: asset.name,
+    symbol: AssetSymbol(asset.symbol),
+    decimals: AssetDecimals(asset.decimals),
+    logo: TokenLogo.fromDto(asset.logo, baseUrl),
+    logoDark: asset.logo_dark === void 0 ? null : TokenLogo.fromDto(asset.logo_dark, baseUrl)
+  }));
+}
 function assertSupportedSchemaVersion(version) {
   if (version !== 1) {
     throw new ValidationError(
@@ -1389,17 +1797,16 @@ var COINLIST_BASE_URL = "https://coinlist.co";
 var OAUTH_PAGE_PATH = "/oauth/authorize";
 var SUPPORT_NEW_TICKET_URL = "https://support.coinlist.co/support/tickets/new";
 var VERIFY_IDENTITY_PATH = "/verify-identity";
-var VERIFY_IDENTITY_VERIFIED_PATH = "/verify-identity/identity_verified";
-var VERIFY_IDENTITY_PROOF_OF_ADDRESS_PATH = "/verify-identity/proof_of_address";
-var VERIFY_IDENTITY_SOURCE_OF_FUNDS_PATH = "/verify-identity/source_of_funds";
 var VERIFY_IDENTITY_ACCREDITATION_PATH = "/verify-identity/accreditation_full";
 var WALLET_PATH = "/wallet";
 
 // src/shared/api/http-client.ts
 var HttpClient = class {
-  constructor(config, middleware = {}) {
+  constructor(config, middleware = {}, logger = null, options = {}) {
     this.config = config;
     this.middleware = middleware;
+    this.log = internalLogger(logger, "HTTP");
+    this.makeRequestId = options.makeRequestId ?? defaultMakeRequestId;
   }
   async send(request) {
     return this.runRequestWithAfterMiddleware(request);
@@ -1435,7 +1842,13 @@ var HttpClient = class {
     return {
       ...request,
       url,
-      headers
+      headers,
+      // Only when absent: a retry or a post-renewal re-send arrives with the
+      // first attempt's id already on it, and keeping it is the whole point.
+      attributes: Attributes.getRequestId(request.attributes) === null ? Attributes.concat(
+        request.attributes ?? Attributes.empty,
+        Attributes.requestId(this.makeRequestId())
+      ) : request.attributes
     };
   }
   /**
@@ -1459,14 +1872,93 @@ var HttpClient = class {
     }
     return request;
   }
-  executeRequest(request) {
-    return makeRequest(request);
+  /**
+   * One physical attempt, logged as one line.
+   *
+   * A non-2xx is a `warn` rather than an `error` because the wire does not
+   * know whether it is a failure: the retry middleware may turn a 503 into a
+   * success, and the token registry reads a 404 as "not listed". The namespace
+   * above decides, and logs the `error` when it does.
+   */
+  async executeRequest(request) {
+    const requestId2 = Attributes.getRequestId(request.attributes);
+    const log = requestId2 === null ? this.log : this.log.child({ requestId: requestId2 });
+    const attempt = Attributes.getRetryAttempt(request.attributes) + 1;
+    const startedAt = Date.now();
+    log.debug(() => ({
+      msg: "request sent",
+      fields: describeRequestUnredacted(request)
+    }));
+    try {
+      const response = await makeRequest(request);
+      const elapsed = Date.now() - startedAt;
+      const outcome = () => ({
+        msg: "request completed",
+        fields: {
+          ...identifyRequest(request),
+          "http.response.status_code": response.status,
+          duration_ms: elapsed,
+          attempt
+        }
+      });
+      if (response.status >= 200 && response.status < 300) {
+        log.info(outcome);
+      } else {
+        log.warn(outcome);
+      }
+      log.debug(() => ({
+        msg: "response received",
+        fields: { body: response.body }
+      }));
+      return requestId2 === null ? response : { ...response, requestId: requestId2 };
+    } catch (error) {
+      const elapsed = Date.now() - startedAt;
+      log.warning(
+        () => ({
+          msg: "request threw",
+          fields: {
+            ...identifyRequest(request),
+            duration_ms: elapsed,
+            attempt
+          }
+        }),
+        error
+      );
+      throw error;
+    }
   }
 };
+function identifyRequest(request) {
+  const { host, path } = splitUrl(request.url);
+  return {
+    "http.request.method": request.method,
+    "server.address": host,
+    "url.path": path
+  };
+}
+function splitUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return { host: parsed.host, path: parsed.pathname };
+  } catch (_) {
+    return { host: null, path: url };
+  }
+}
+function defaultMakeRequestId() {
+  return Math.random().toString(36).slice(2, 10).padEnd(8, "0");
+}
+function describeRequestUnredacted(request) {
+  return {
+    "http.request.method": request.method,
+    "url.full": buildUrlWithQueryParams(request.url, request.queryParams),
+    headers: request.headers,
+    ...request.method === "POST" ? { body: request.body } : {}
+  };
+}
 
 // src/shared/api/nabu/tokens.ts
-function createNabuApiClient(baseUrl) {
-  return new HttpClient({ baseUrl });
+function createNabuApiClient(baseUrl, logger = null) {
+  return new HttpClient({ baseUrl }, {}, logger);
 }
 async function fetchTokenMetadata(client, token) {
   const address = checksummed(token.address);
@@ -1516,6 +2008,29 @@ async function fetchTokensMetadata(client, chain) {
   }
   return TokenMetadata.fromChainAssetsDto(response.body, client.config.baseUrl);
 }
+async function fetchAllTokensMetadata(client) {
+  let response;
+  try {
+    response = await client.send({
+      method: "GET",
+      url: `/assets.json`
+    });
+  } catch (error) {
+    if (isRegistryHtmlFallback(error)) {
+      throw new ValidationError(
+        "Token registry returned non-JSON for the complete snapshot"
+      );
+    }
+    throw error;
+  }
+  assertOk(response);
+  if (response.body === null) {
+    throw new ValidationError(
+      "Token registry returned an empty complete snapshot"
+    );
+  }
+  return TokenMetadata.fromRegistryDto(response.body, client.config.baseUrl);
+}
 function isRegistryHtmlFallback(error) {
   return error instanceof HttpError && error.response.status >= 200 && error.response.status < 300;
 }
@@ -1539,14 +2054,23 @@ var TokensNamespaceImpl = class {
    * registry is unauthenticated and on its own host, so the frontline sender
    * and the auth check would both be dead weight here.
    */
-  constructor(baseUrl) {
-    this.api = createNabuApiClient(baseUrl);
+  constructor(baseUrl, logger = null) {
+    this.api = createNabuApiClient(baseUrl, logger);
+    this.log = internalLogger(logger, "TOKENS");
   }
   get(token) {
-    return fetchTokenMetadata(this.api, token);
+    return this.log.wrap(
+      "get",
+      token,
+      () => fetchTokenMetadata(this.api, token)
+    );
   }
   list(chain) {
-    return fetchTokensMetadata(this.api, chain);
+    return this.log.wrap(
+      "list",
+      chain,
+      () => chain === void 0 ? fetchAllTokensMetadata(this.api) : fetchTokensMetadata(this.api, chain)
+    );
   }
 };
 
@@ -1652,33 +2176,42 @@ async function removeOptionAddress(api, offerId, addressId) {
 var WalletsNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "WALLETS");
   }
   async createOwnershipChallenge(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return createWalletOwnershipChallenge(
-      this.ctx.api,
-      params
-    );
+    return this.log.wrap("createOwnershipChallenge", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createWalletOwnershipChallenge(
+        this.ctx.api,
+        params
+      );
+    });
   }
   async connectExternal(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return connectExternalWallet(this.ctx.api, params);
+    return this.log.wrap("connectExternal", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return connectExternalWallet(this.ctx.api, params);
+    });
   }
   async list(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return listOptionAddresses(
-      this.ctx.api,
-      params.offerId,
-      params.offerOptionId
-    );
+    return this.log.wrap("list", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return listOptionAddresses(
+        this.ctx.api,
+        params.offerId,
+        params.offerOptionId
+      );
+    });
   }
   async remove(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return removeOptionAddress(
-      this.ctx.api,
-      params.offerId,
-      params.addressId
-    );
+    return this.log.wrap("remove", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return removeOptionAddress(
+        this.ctx.api,
+        params.offerId,
+        params.addressId
+      );
+    });
   }
 };
 
@@ -1740,20 +2273,21 @@ export {
   OAUTH_PAGE_PATH,
   SUPPORT_NEW_TICKET_URL,
   VERIFY_IDENTITY_PATH,
-  VERIFY_IDENTITY_VERIFIED_PATH,
-  VERIFY_IDENTITY_PROOF_OF_ADDRESS_PATH,
-  VERIFY_IDENTITY_SOURCE_OF_FUNDS_PATH,
   VERIFY_IDENTITY_ACCREDITATION_PATH,
   WALLET_PATH,
   Attributes,
   HttpError,
   apiErrorCode,
   Request,
-  HttpClient,
-  fetchAllPages,
   NotImplementedError,
   NotAuthenticatedError,
   ValidationError,
+  InvariantError,
+  MathError,
+  describeErrorUnredacted,
+  internalLogger,
+  HttpClient,
+  fetchAllPages,
   ETHEREUM_CHAINS,
   EthereumChain,
   SOLANA_CHAINS,
@@ -1768,6 +2302,7 @@ export {
   DecimalString,
   MAX_UINT_256,
   assertUint256,
+  parseUint256,
   BlockchainAmount,
   AssetSymbol,
   StablecoinSymbol,
@@ -1810,6 +2345,7 @@ export {
   OfferId,
   OfferSlug,
   Offer,
+  OfferToken,
   OfferOptionId,
   OfferOptionSlug,
   OfferDetail,
@@ -1818,7 +2354,6 @@ export {
   Link,
   TermItem,
   Milestone,
-  OfferToken,
   ParticipationId,
   Blockchain,
   WalletAddress,
@@ -1829,7 +2364,8 @@ export {
   Ticker,
   OndoTradingStatus,
   OndoQuote,
-  OndoSwapTransaction,
+  OndoBuyTransaction,
+  OndoSellTransaction,
   OndoNamespaceImpl,
   SuperstateSwapNamespaceImpl,
   fetchOffers,
@@ -1860,4 +2396,4 @@ export {
   OAuthRefreshToken,
   OAuthSession
 };
-//# sourceMappingURL=chunk-UIIXXLA7.js.map
+//# sourceMappingURL=chunk-7CTH4KPU.js.map