@coinlist-co/react 0.11.0 → 0.11.1-rc.22d81d4

package/dist/client/index.cjs

@@ -68,6 +68,7 @@ __export(client_exports, {
   OndoReviewView: () => OndoReviewView,
   OndoSidebarView: () => OndoSidebarView,
   OndoWalletSelectView: () => OndoWalletSelectView,
+  RedactedWalletError: () => RedactedWalletError,
   RequirementItem: () => RequirementItem,
   RequirementItemUi: () => RequirementItemUi,
   RequirementStatus: () => RequirementStatus,
@@ -100,6 +101,7 @@ __export(client_exports, {
   formatMonthYear: () => formatMonthYear,
   offerIconUrl: () => offerIconUrl,
   ondoLoadErrorReason: () => ondoLoadErrorReason,
+  pinoClientLogger: () => pinoClientLogger,
   prepareOndoSwap: () => prepareOndoSwap,
   quoteIsStale: () => quoteIsStale,
   quoteOverAsks: () => quoteOverAsks,
@@ -145,7 +147,7 @@ __export(client_exports, {
 module.exports = __toCommonJS(client_exports);
 
 // src/client/CoinListProvider.tsx
-var import_react2 = require("react");
+var import_react3 = require("react");
 
 // src/shared/core/utils/crypto.ts
 async function sha256(data) {
@@ -218,9 +220,6 @@ 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";
 
@@ -251,6 +250,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;
@@ -272,7 +273,9 @@ var Attributes = {
   renewAttempted,
   wasRenewAttempted,
   clientCredentials,
-  getClientCredentials
+  getClientCredentials,
+  requestId,
+  getRequestId
 };
 
 // src/client/core/api/middleware/user-agent.ts
@@ -306,6 +309,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;
@@ -413,11 +426,185 @@ var Request = {
   concatAttributes
 };
 
+// src/shared/types/errors.ts
+var NotImplementedError = class extends Error {
+  constructor(message = "Not implemented yet") {
+    super(message);
+    this.name = "NotImplementedError";
+  }
+};
+var NotAuthenticatedError = class extends Error {
+  constructor(message = "The user is not authenticated. Go through the OAuth flow first!") {
+    super(message);
+    this.name = "NotAuthenticatedError";
+  }
+};
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var InvariantError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvariantError";
+  }
+};
+
+// 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 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/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);
@@ -453,7 +640,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
     };
   }
   /**
@@ -477,10 +670,89 @@ 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/middleware/attach-session-middleware.ts
 function attachSessionMiddleware(fetchAccessToken) {
@@ -588,18 +860,22 @@ function renewSessionMiddleware(fetchAccessToken) {
 
 // src/shared/api/authenticated-api-client.ts
 var AuthenticatedApiClient = class {
-  constructor(config, fetchAccessToken, additionalBeforeRequest = []) {
-    this.httpClient = new HttpClient(config, {
-      beforeRequest: [
-        attachSessionMiddleware(fetchAccessToken),
-        ...additionalBeforeRequest,
-        idempotencyKeyMiddleware
-      ],
-      afterRequest: [
-        renewSessionMiddleware(fetchAccessToken),
-        requestRetryMiddleware
-      ]
-    });
+  constructor(config, fetchAccessToken, additionalBeforeRequest = [], logger = null) {
+    this.httpClient = new HttpClient(
+      config,
+      {
+        beforeRequest: [
+          attachSessionMiddleware(fetchAccessToken),
+          ...additionalBeforeRequest,
+          idempotencyKeyMiddleware
+        ],
+        afterRequest: [
+          renewSessionMiddleware(fetchAccessToken),
+          requestRetryMiddleware
+        ]
+      },
+      logger
+    );
   }
   async send(request) {
     const response = await this.httpClient.send(request);
@@ -613,10 +889,13 @@ var AuthenticatedApiClient = class {
 
 // src/client/core/api/api-client.ts
 var ApiClient = class {
-  constructor(config, fetchAccessToken) {
-    this.client = new AuthenticatedApiClient(config, fetchAccessToken, [
-      userAgentMiddleware
-    ]);
+  constructor(config, fetchAccessToken, logger = null) {
+    this.client = new AuthenticatedApiClient(
+      config,
+      fetchAccessToken,
+      [userAgentMiddleware],
+      logger
+    );
   }
   async send(request) {
     return this.client.send(request);
@@ -653,11 +932,15 @@ var ClientAuthNamespaceImpl = class {
   constructor(config, session) {
     this.config = config;
     this.session = session;
+    this.log = internalLogger(config.logger ?? null, "AUTH");
   }
   getState() {
     return this.session.getState();
   }
   async startOAuth() {
+    return this.log.wrap("startOAuth", void 0, () => this.redirectToOAuth());
+  }
+  async redirectToOAuth() {
     const pkceParams = await generatePKCEParams(this.config);
     sessionStorage.setItem(OAUTH_STATE_KEY, pkceParams.state);
     sessionStorage.setItem(OAUTH_CODE_VERIFIER_KEY, pkceParams.codeVerifier);
@@ -670,9 +953,37 @@ var ClientAuthNamespaceImpl = class {
       state: pkceParams.state
     });
     const baseUrl = this.config.coinlistBaseUrl ?? COINLIST_BASE_URL;
+    this.log.child({ op: "startOAuth" }).info(() => ({ msg: "redirecting to CoinList", fields: { baseUrl } }));
     window.location.href = `${baseUrl}${OAUTH_PAGE_PATH}?${params.toString()}`;
   }
+  /**
+   * Every failure here is silent from the browser's side - a state mismatch
+   * and a missing verifier both just leave the user logged out - so the
+   * reason is logged rather than left for the host to infer from a callback.
+   */
   completeOAuth() {
+    const result = this.readOauthCallback();
+    switch (result.type) {
+      case "error":
+        this.log.child({ op: "completeOAuth" }).error(() => ({
+          msg: "oauth callback rejected",
+          fields: { reason: result.reason }
+        }));
+        return result;
+      case "ok":
+        this.log.child({ op: "completeOAuth" }).info(() => ({ msg: "authorization code received" }));
+        return result;
+      default: {
+        const _exhaustive = result;
+        return result;
+      }
+    }
+  }
+  logout() {
+    this.log.child({ op: "logout" }).info(() => ({ msg: "access token cleared" }));
+    this.session.clearAccessToken();
+  }
+  readOauthCallback() {
     const params = new URLSearchParams(window.location.search);
     const coinlistError = params.get("error");
     if (coinlistError) {
@@ -700,28 +1011,36 @@ var ClientAuthNamespaceImpl = class {
       codeVerifier: CodeVerifier(codeVerifierValue)
     };
   }
-  logout() {
-    this.session.clearAccessToken();
-  }
 };
 
 // src/client/core/blockchain/wallet-error.ts
 var import_viem = require("viem");
 function classifyWalletError(error, ctx) {
-  if (error instanceof import_viem.UserRejectedRequestError) {
+  if (causeOf(error, import_viem.UserRejectedRequestError)) {
     return { type: "user_rejected" };
   }
-  if (error instanceof import_viem.InsufficientFundsError) {
+  if (causeOf(error, import_viem.InsufficientFundsError)) {
     return { type: "insufficient_funds" };
   }
-  if (error instanceof import_viem.ContractFunctionRevertedError) {
-    return { type: "contract_reverted", reason: error.reason ?? error.message };
+  const reverted = causeOf(error, import_viem.ContractFunctionRevertedError);
+  if (reverted) {
+    return { type: "contract_reverted", reason: revertReason(reverted) };
   }
-  if (error instanceof import_viem.WaitForTransactionReceiptTimeoutError && ctx?.hash) {
+  if (causeOf(error, import_viem.WaitForTransactionReceiptTimeoutError) && ctx?.hash) {
     return { type: "timeout", hash: ctx.hash };
   }
   return { type: "unknown", cause: error };
 }
+function causeOf(error, errorClass) {
+  if (error instanceof errorClass) return error;
+  if (!(error instanceof import_viem.BaseError)) return null;
+  const found = error.walk((cause) => cause instanceof errorClass);
+  return found instanceof errorClass ? found : null;
+}
+function revertReason(error) {
+  if (!error.raw || error.raw === "0x") return null;
+  return error.reason ?? error.data?.errorName ?? error.signature ?? null;
+}
 
 // src/shared/core/blockchain/erc20/abi.ts
 var ERC20_ABI = [
@@ -833,8 +1152,8 @@ async function ensureErc20Allowance({
   spender,
   onProgress
 }) {
-  const emit = (phase) => onProgress?.(phase);
-  emit("checking-allowance");
+  const emit2 = (phase) => onProgress?.(phase);
+  emit2("checking-allowance");
   let allowance;
   try {
     allowance = await erc20.getAllowance({
@@ -856,7 +1175,7 @@ async function ensureErc20Allowance({
         value: 0n,
         pending: "resetting-allowance",
         confirming: "confirming-allowance-reset",
-        emit
+        emit: emit2
       });
       if (reset.type === "error") return { type: "error", error: reset.error };
     }
@@ -868,7 +1187,7 @@ async function ensureErc20Allowance({
       value: amount.raw,
       pending: "approving",
       confirming: "confirming-approval",
-      emit
+      emit: emit2
     });
     if (approve.type === "error") {
       return { type: "error", error: approve.error };
@@ -887,9 +1206,9 @@ async function submitErc20Approval(args) {
     value,
     pending,
     confirming,
-    emit
+    emit: emit2
   } = args;
-  emit(pending);
+  emit2(pending);
   let hash;
   try {
     hash = await wallet.writeContract({
@@ -905,7 +1224,7 @@ async function submitErc20Approval(args) {
       error: { step: "approval", cause: classifyWalletError(error) }
     };
   }
-  emit(confirming);
+  emit2(confirming);
   let receipt;
   try {
     receipt = await wallet.awaitTx(hash, chain);
@@ -937,20 +1256,6 @@ async function fetchAllPages(fetchPage, baseParams) {
   return items;
 }
 
-// src/shared/types/errors.ts
-var NotAuthenticatedError = class extends Error {
-  constructor(message = "The user is not authenticated. Go through the OAuth flow first!") {
-    super(message);
-    this.name = "NotAuthenticatedError";
-  }
-};
-var ValidationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ValidationError";
-  }
-};
-
 // src/shared/types/blockchain/core.ts
 var ETHEREUM_CHAINS = {
   ethereum_mainnet: true,
@@ -991,11 +1296,14 @@ 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,
   {
@@ -1005,13 +1313,13 @@ var BlockchainAmount = Object.assign(
 );
 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 });
 }
@@ -1082,25 +1390,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 = {
@@ -1229,14 +1543,19 @@ function toErc20Asset(dto) {
 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);
+    });
   }
 };
 
@@ -1420,7 +1739,7 @@ var TOKEN_REGISTRY = {
       case "USDT":
         return USDT;
       default:
-        throw new Error(`Unknown asset symbol: ${symbol}`);
+        throw new InvariantError(`Unknown asset symbol: ${symbol}`);
     }
   },
   contractAddress: (symbol, chain) => {
@@ -1430,7 +1749,7 @@ var TOKEN_REGISTRY = {
       case "USDT":
         return USDT_ADDRESSES[chain];
       default:
-        throw new Error(`Unknown asset symbol: ${symbol}`);
+        throw new InvariantError(`Unknown asset symbol: ${symbol}`);
     }
   }
 };
@@ -1476,15 +1795,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)
   })
 };
 
@@ -1494,25 +1828,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),
@@ -1574,13 +1922,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;
@@ -1667,22 +2008,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);
+    });
   }
 };
 
@@ -1888,18 +2238,25 @@ 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);
+    return this.log.wrap("buildSwapTransaction", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return buildOndoSwapTransaction(this.ctx.api, params);
+    });
   }
 };
 
@@ -2213,26 +2570,37 @@ function formattedPricePerShare(quote, locale) {
 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);
+    });
   }
 };
 
@@ -2269,18 +2637,25 @@ async function fetchOfferDetails(api, id, clientCreds) {
 var OffersNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "OFFERS");
   }
   async list() {
-    await this.ctx.ensureUserAuthenticated();
-    return fetchOffers(this.ctx.api, void 0);
+    return this.log.wrap("list", void 0, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchOffers(this.ctx.api, void 0);
+    });
   }
   async listPage(params) {
-    await this.ctx.ensureUserAuthenticated();
-    return fetchOffersPage(this.ctx.api, params, void 0);
+    return this.log.wrap("listPage", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchOffersPage(this.ctx.api, params, void 0);
+    });
   }
   async get(id) {
-    await this.ctx.ensureUserAuthenticated();
-    return fetchOfferDetails(this.ctx.api, id, void 0);
+    return this.log.wrap("get", id, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchOfferDetails(this.ctx.api, id, void 0);
+    });
   }
 };
 
@@ -2413,38 +2788,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
+      );
+    });
   }
 };
 
@@ -2515,8 +2901,8 @@ var resolveLogoUrl = (url, baseUrl) => TokenLogoUrl(
 );
 
 // 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);
@@ -2589,14 +2975,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,
+      () => fetchTokensMetadata(this.api, chain)
+    );
   }
 };
 
@@ -2702,36 +3097,50 @@ 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
+      );
+    });
   }
 };
 
+// src/shared/types/blockchain/wallet-error.ts
+var RedactedWalletError = {
+  fromWalletError: (error) => error.type === "unknown" ? { type: "unknown" } : error
+};
+
 // src/client/core/checkout/coin-list/token-sale-flows.ts
 async function executeTokenSale(params) {
   const {
@@ -2747,8 +3156,8 @@ async function executeTokenSale(params) {
     amount,
     onProgress
   } = params;
-  const emit = (phase) => onProgress?.(phase);
-  emit("checking-allowance");
+  const emit2 = (phase) => onProgress?.(phase);
+  emit2("checking-allowance");
   let currentAllowance;
   try {
     const allowance = await erc20.getAllowance({
@@ -2770,7 +3179,7 @@ async function executeTokenSale(params) {
       value: 0n,
       pending: "resetting-allowance",
       confirming: "confirming-allowance-reset",
-      emit
+      emit: emit2
     });
     if (reset.type === "error") {
       return {
@@ -2787,13 +3196,13 @@ async function executeTokenSale(params) {
     value: amount.raw,
     pending: "approving",
     confirming: "confirming-approval",
-    emit
+    emit: emit2
   });
   if (approve.type === "error") {
     return { type: "error", error: approve.error };
   }
   const approvalTxHash = approve.txHash;
-  emit("recording-participation");
+  emit2("recording-participation");
   let participation;
   try {
     participation = await tokenSale.createParticipation({
@@ -2811,6 +3220,72 @@ async function executeTokenSale(params) {
   return { type: "success", participation, approvalTxHash };
 }
 
+// src/client/core/observability/flow-logging.ts
+async function withFlowLogging(log, flow, onProgress, run) {
+  const flowLog = log.child({ flow });
+  flowLog.info(() => ({ msg: "flow started" }));
+  try {
+    const result = await run((phase) => {
+      flowLog.info(() => ({ msg: "flow advanced", fields: { phase } }));
+      onProgress?.(phase);
+    });
+    logOutcome(flowLog, result);
+    return result;
+  } catch (error) {
+    flowLog.failure(
+      () => ({ msg: "flow threw instead of returning a step" }),
+      error
+    );
+    throw error;
+  }
+}
+function logOutcome(log, outcome) {
+  switch (outcome.type) {
+    case "success":
+      log.info(() => ({ msg: "flow succeeded" }));
+      return;
+    case "error":
+      log.debug(() => ({
+        msg: "flow failed",
+        fields: {
+          step: outcome.error.step,
+          error: describeErrorUnredacted(outcome.error.cause)
+        }
+      }));
+      log.error(() => ({
+        msg: "flow failed",
+        fields: { step: outcome.error.step },
+        ...walletCause(outcome.error.cause)
+      }));
+      return;
+    default: {
+      const _exhaustive = outcome;
+      return;
+    }
+  }
+}
+function walletCause(cause) {
+  if (!isWalletError(cause)) return {};
+  return {
+    cause: {
+      type: "wallet",
+      error: RedactedWalletError.fromWalletError(cause)
+    }
+  };
+}
+var WALLET_ERROR_TYPES = /* @__PURE__ */ new Set([
+  "user_rejected",
+  "insufficient_funds",
+  "contract_reverted",
+  "timeout",
+  "unknown"
+]);
+function isWalletError(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const type = value.type;
+  return typeof type === "string" && WALLET_ERROR_TYPES.has(type);
+}
+
 // src/client/core/checkout/coin-list/client-token-sale-namespace.ts
 var ClientCoinListTokenSaleNamespaceImpl = class extends CoinListTokenSaleNamespaceImpl {
   constructor(ctx, erc20) {
@@ -2818,7 +3293,17 @@ var ClientCoinListTokenSaleNamespaceImpl = class extends CoinListTokenSaleNamesp
     this.erc20 = erc20;
   }
   execute(params) {
-    return executeTokenSale({ ...params, erc20: this.erc20, tokenSale: this });
+    return withFlowLogging(
+      this.log,
+      "execute",
+      params.onProgress,
+      (onProgress) => executeTokenSale({
+        ...params,
+        onProgress,
+        erc20: this.erc20,
+        tokenSale: this
+      })
+    );
   }
 };
 
@@ -2844,7 +3329,7 @@ async function prepareOndoSwap(params) {
     amount,
     onProgress
   } = params;
-  const emit = (phase) => onProgress?.(phase);
+  const emit2 = (phase) => onProgress?.(phase);
   const spender = ondoSwapContractAddress(chain);
   if (spender === null) {
     return { type: "error", error: { step: "unsupported-chain", chain } };
@@ -2856,10 +3341,10 @@ async function prepareOndoSwap(params) {
     amount,
     wallet,
     spender,
-    onProgress: emit
+    onProgress: emit2
   });
   if (allowance.type === "error") return allowance;
-  emit("building-transaction");
+  emit2("building-transaction");
   try {
     const transaction = await ondo.buildSwapTransaction({
       symbol,
@@ -2878,7 +3363,7 @@ async function prepareOndoSwap(params) {
 var INSUFFICIENT_ALLOWANCE_CODE = "insufficient_allowance";
 async function executeOndoSwap(params) {
   const { wallet, transaction, chain, now = /* @__PURE__ */ new Date(), onProgress } = params;
-  const emit = (phase) => onProgress?.(phase);
+  const emit2 = (phase) => onProgress?.(phase);
   if (now.getTime() >= transaction.expiresAt.getTime()) {
     return { type: "error", error: { step: "quote-expired" } };
   }
@@ -2892,7 +3377,7 @@ async function executeOndoSwap(params) {
       }
     };
   }
-  emit("broadcasting-swap");
+  emit2("broadcasting-swap");
   let txHash;
   try {
     txHash = await wallet.broadcastRawTx({
@@ -2906,7 +3391,7 @@ async function executeOndoSwap(params) {
       error: { step: "swap", cause: classifyWalletError(error) }
     };
   }
-  emit("confirming-swap");
+  emit2("confirming-swap");
   let receipt;
   try {
     receipt = await wallet.awaitTx(txHash, chain);
@@ -2932,10 +3417,25 @@ var ClientOndoNamespaceImpl = class extends OndoNamespaceImpl {
     this.erc20 = erc20;
   }
   prepareSwap(params) {
-    return prepareOndoSwap({ ...params, ondo: this, erc20: this.erc20 });
+    return withFlowLogging(
+      this.log,
+      "prepareSwap",
+      params.onProgress,
+      (onProgress) => prepareOndoSwap({
+        ...params,
+        onProgress,
+        ondo: this,
+        erc20: this.erc20
+      })
+    );
   }
   executeSwap(params) {
-    return executeOndoSwap(params);
+    return withFlowLogging(
+      this.log,
+      "executeSwap",
+      params.onProgress,
+      (onProgress) => executeOndoSwap({ ...params, onProgress })
+    );
   }
 };
 
@@ -2952,10 +3452,10 @@ async function executeSwap(params) {
     slippageBps,
     onProgress
   } = params;
-  const emit = (phase) => onProgress?.(phase);
+  const emit2 = (phase) => onProgress?.(phase);
   const inputAmount = BlockchainAmount.add(quote.inputTokenAmount, quote.fee);
   const minOut = computeSlip(quote.outputTokenAmount, slippageBps).raw;
-  emit("checking-status");
+  emit2("checking-status");
   let status;
   try {
     status = await swap.getStatus({ contractAddress, chain });
@@ -2972,12 +3472,12 @@ async function executeSwap(params) {
     amount: inputAmount,
     wallet,
     spender: contractAddress,
-    onProgress: emit
+    onProgress: emit2
   });
   if (allowanceRes.type === "error") {
     return allowanceRes;
   }
-  emit("swapping");
+  emit2("swapping");
   let swapTxHash;
   try {
     swapTxHash = await wallet.writeContract({
@@ -2993,7 +3493,7 @@ async function executeSwap(params) {
       error: { step: "swap", cause: classifyWalletError(error) }
     };
   }
-  emit("confirming-swap");
+  emit2("confirming-swap");
   let receipt;
   try {
     receipt = await wallet.awaitTx(swapTxHash, chain);
@@ -3028,9 +3528,9 @@ async function executeSwap(params) {
 }
 async function authorizeWallet(params) {
   const { swap, wallets, wallet, offerId, contractAddress, chain, onProgress } = params;
-  const emit = (phase) => onProgress?.(phase);
+  const emit2 = (phase) => onProgress?.(phase);
   const walletAddress = wallet.address;
-  emit("checking-authorization");
+  emit2("checking-authorization");
   let auth;
   try {
     auth = await swap.getAuthorization({
@@ -3042,7 +3542,7 @@ async function authorizeWallet(params) {
     return { type: "error", error: { step: "authorization-check" } };
   }
   if (auth.authorized) return { type: "success" };
-  emit("requesting-challenge");
+  emit2("requesting-challenge");
   let challenge;
   try {
     challenge = await wallets.createOwnershipChallenge({
@@ -3053,7 +3553,7 @@ async function authorizeWallet(params) {
   } catch {
     return { type: "error", error: { step: "challenge-request" } };
   }
-  emit("signing-message");
+  emit2("signing-message");
   let signature;
   try {
     signature = await wallet.signMessage(challenge.message);
@@ -3063,7 +3563,7 @@ async function authorizeWallet(params) {
       error: { step: "signing", cause: classifyWalletError(error) }
     };
   }
-  emit("submitting-signature");
+  emit2("submitting-signature");
   let allow;
   try {
     allow = await swap.allowWallet({
@@ -3076,7 +3576,7 @@ async function authorizeWallet(params) {
     return { type: "error", error: { step: "allow-wallet" } };
   }
   if (allow.action === "broadcast_transaction") {
-    emit("broadcasting-transaction");
+    emit2("broadcasting-transaction");
     let hash;
     try {
       hash = await wallet.broadcastRawTx({
@@ -3090,7 +3590,7 @@ async function authorizeWallet(params) {
         error: { step: "broadcast", cause: classifyWalletError(error) }
       };
     }
-    emit("awaiting-confirmation");
+    emit2("awaiting-confirmation");
     try {
       await wallet.awaitTx(hash, chain);
     } catch (error) {
@@ -3103,7 +3603,7 @@ async function authorizeWallet(params) {
       };
     }
   }
-  emit("verifying-authorization");
+  emit2("verifying-authorization");
   let reCheck;
   try {
     reCheck = await swap.getAuthorization({
@@ -3128,10 +3628,25 @@ var ClientSuperstateSwapNamespaceImpl = class extends SuperstateSwapNamespaceImp
     this.wallets = wallets;
   }
   execute(params) {
-    return executeSwap({ ...params, swap: this, erc20: this.erc20 });
+    return withFlowLogging(
+      this.log,
+      "execute",
+      params.onProgress,
+      (onProgress) => executeSwap({ ...params, onProgress, swap: this, erc20: this.erc20 })
+    );
   }
   authorizeWallet(params) {
-    return authorizeWallet({ ...params, swap: this, wallets: this.wallets });
+    return withFlowLogging(
+      this.log,
+      "authorizeWallet",
+      params.onProgress,
+      (onProgress) => authorizeWallet({
+        ...params,
+        onProgress,
+        swap: this,
+        wallets: this.wallets
+      })
+    );
   }
 };
 
@@ -3157,12 +3672,6 @@ function requirementPath(requirement) {
   switch (requirement.type) {
     case "kyc_approved":
       return VERIFY_IDENTITY_PATH;
-    case "identity_verified":
-      return VERIFY_IDENTITY_VERIFIED_PATH;
-    case "proof_of_address":
-      return VERIFY_IDENTITY_PROOF_OF_ADDRESS_PATH;
-    case "source_of_funds":
-      return VERIFY_IDENTITY_SOURCE_OF_FUNDS_PATH;
     case "accreditation":
       return VERIFY_IDENTITY_ACCREDITATION_PATH;
     case "external_wallet":
@@ -3187,7 +3696,14 @@ function requirementPath(requirement) {
 
 // src/client/core/support/client-support-namespace.ts
 var ClientSupportNamespaceImpl = class {
+  constructor(logger = null) {
+    this.log = internalLogger(logger, "SUPPORT");
+  }
   contact() {
+    this.log.child({ op: "contact" }).info(() => ({
+      msg: "opening the support ticket page",
+      fields: { supportUrl: SUPPORT_NEW_TICKET_URL }
+    }));
     openInNewTab(SUPPORT_NEW_TICKET_URL);
   }
 };
@@ -3201,15 +3717,18 @@ var CoinListClientImpl = class {
     this._config = _config;
     /** Cached access token: undefined = loading, null = no token, AccessToken = logged in */
     this._accessToken = void 0;
+    const logger = _config.logger ?? null;
     this.api = new ApiClient(
       {
         baseUrl: _config.baseUrl || PUBLIC_API_BASE_URL,
         xApiVersion: API_VERSION
       },
-      this.fetchAccessToken.bind(this)
+      this.fetchAccessToken.bind(this),
+      logger
     );
     const ctx = {
       api: this.api,
+      logger,
       ensureUserAuthenticated: async () => this.ensureAuthenticated()
     };
     this.auth = new ClientAuthNamespaceImpl(_config, {
@@ -3233,9 +3752,10 @@ var CoinListClientImpl = class {
     );
     this.ondo = new ClientOndoNamespaceImpl(ctx, this.erc20);
     this.tokens = new TokensNamespaceImpl(
-      _config.tokensBaseUrl ?? NABU_BASE_URL
+      _config.tokensBaseUrl ?? NABU_BASE_URL,
+      logger
     );
-    this.support = new ClientSupportNamespaceImpl();
+    this.support = new ClientSupportNamespaceImpl(logger);
   }
   async init() {
     await this.fetchAccessToken(true);
@@ -3276,17 +3796,28 @@ function useLocale() {
   return (0, import_react.useContext)(CoinListLocaleContext);
 }
 
+// src/client/hooks/shared/useLogger.ts
+var import_react2 = require("react");
+var CoinListLoggerContext = (0, import_react2.createContext)(null);
+function useLogger(hook) {
+  const logger = (0, import_react2.useContext)(CoinListLoggerContext);
+  return (0, import_react2.useMemo)(
+    () => internalLogger(logger, "HOOKS").child({ hook }),
+    [logger, hook]
+  );
+}
+
 // src/client/CoinListProvider.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
-var CoinListContext = (0, import_react2.createContext)(null);
+var CoinListContext = (0, import_react3.createContext)(null);
 function CoinListContextProvider({
   config,
   locale,
   children
 }) {
-  const [isReady, setIsReady] = (0, import_react2.useState)(false);
-  const coinlist = (0, import_react2.useMemo)(() => createCoinListClient(config), [config]);
-  (0, import_react2.useEffect)(() => {
+  const [isReady, setIsReady] = (0, import_react3.useState)(false);
+  const coinlist = (0, import_react3.useMemo)(() => createCoinListClient(config), [config]);
+  (0, import_react3.useEffect)(() => {
     let isCancelled = false;
     if (coinlist.auth.getState() === "unknown") {
       coinlist.init().then(() => {
@@ -3305,22 +3836,23 @@ function CoinListContextProvider({
       isCancelled = true;
     };
   }, [coinlist]);
-  const value = (0, import_react2.useMemo)(() => ({ coinlist, isReady }), [coinlist, isReady]);
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CoinListContext.Provider, { value, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CoinListLocaleContext.Provider, { value: locale ?? DEFAULT_LOCALE, children }) });
+  const value = (0, import_react3.useMemo)(() => ({ coinlist, isReady }), [coinlist, isReady]);
+  const logger = config.logger ?? null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CoinListContext.Provider, { value, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CoinListLocaleContext.Provider, { value: locale ?? DEFAULT_LOCALE, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CoinListLoggerContext.Provider, { value: logger, children }) }) });
 }
 var CoinListProvider = CoinListContextProvider;
 
 // src/client/CoinListStyleScope.tsx
-var import_react3 = require("react");
+var import_react4 = require("react");
 
 // src/client/generated/sdk-styles.gen.ts
 var sdkStyles = '/*! tailwindcss v4.2.1 | MIT License | https://tailwindcss.com */\n@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-space-y-reverse:0;--tw-divide-y-reverse:0;--tw-border-style:solid;--tw-gradient-position:initial;--tw-gradient-from:#0000;--tw-gradient-via:#0000;--tw-gradient-to:#0000;--tw-gradient-stops:initial;--tw-gradient-via-stops:initial;--tw-gradient-from-position:0%;--tw-gradient-via-position:50%;--tw-gradient-to-position:100%;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-ordinal:initial;--tw-slashed-zero:initial;--tw-numeric-figure:initial;--tw-numeric-spacing:initial;--tw-numeric-fraction:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-duration:initial;--tw-ease:initial}}}@layer theme{:root,:host{--clcosdk-font-mono:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;--clcosdk-color-red-400:oklch(70.4% .191 22.216);--clcosdk-color-red-500:oklch(63.7% .237 25.331);--clcosdk-color-amber-500:oklch(76.9% .188 70.08);--clcosdk-color-gray-400:oklch(70.7% .022 261.325);--clcosdk-color-gray-500:oklch(55.1% .027 264.364);--clcosdk-color-black:#000;--clcosdk-spacing:.25rem;--clcosdk-container-sm:24rem;--clcosdk-container-md:28rem;--clcosdk-container-xl:36rem;--clcosdk-text-xs:.75rem;--clcosdk-text-xs--line-height:calc(1 / .75);--clcosdk-text-sm:.875rem;--clcosdk-text-sm--line-height:calc(1.25 / .875);--clcosdk-text-base:1rem;--clcosdk-text-base--line-height:calc(1.5 / 1);--clcosdk-text-lg:1.125rem;--clcosdk-text-lg--line-height:calc(1.75 / 1.125);--clcosdk-font-weight-normal:400;--clcosdk-font-weight-medium:500;--clcosdk-font-weight-semibold:600;--clcosdk-radius-md:.375rem;--clcosdk-radius-lg:.5rem;--clcosdk-radius-xl:.75rem;--clcosdk-radius-2xl:1rem;--clcosdk-ease-in-out:cubic-bezier(.4, 0, .2, 1);--clcosdk-animate-spin:spin 1s linear infinite;--clcosdk-animate-pulse:pulse 2s cubic-bezier(.4, 0, .6, 1) infinite;--clcosdk-color-brand-primary:var(--color-brand-primary)}}@layer base{.clco-sdk-root{--color-brand-primary:#171717;--color-brand-primary-hover:#000;--color-brand-primary-active:#262626;--color-accent:#2b3a67;--color-accent-hover:#243057;--color-accent-active:#1d2647;--color-accent-focus:#c7d2fe;--color-accent-subtle:#eef1f8;--color-text-primary:#171717;--color-text-secondary:#8c8c8c;--color-text-disabled:#d1d1d1;--color-text-inverse:#fff;--color-background:#fff;--color-surface:#fafafa;--color-section:#f3f3f3;--color-border:#e5e5e5;--color-divider:#ececec;--color-overlay:#00000080;--color-positive:#15803d;--color-positive-subtle:#dcfce7;--color-negative:#dc2626;--color-negative-subtle:#fee2e2;--color-success:#2c8c5e;--color-success-subtle:#e6f4ec;--color-success-border:#cfe9db;--color-warning:#e08a1a;--color-warning-subtle:#fff7ed;--color-warning-border:#fdead7;--color-error:#b42318;--color-error-subtle:#feeceb;--color-error-border:#fbd5d2;--shadow-step-active:0px 0px 10px 0px #0000001a;--shadow-dialog:0px 8px 32px 0px #0000001a;--btn-primary-gradient:linear-gradient(180deg, #262626 0%, #1c1c1c 50%, #0f0f0f 100%);--btn-primary-shadow:inset 0px -1px 3px 0px #00000059, inset 0px 1px 2px 0px #ffffff2e, inset 0px 1px 0px 0px #ffffff1a}@media (prefers-color-scheme:dark){.clco-sdk-root:not(:where(.light,.light *)){--color-brand-primary:#f4f4f5;--color-brand-primary-hover:#fff;--color-brand-primary-active:#e4e4e7;--color-accent:#6f82c9;--color-accent-hover:#8799e4;--color-accent-active:#5b6fcf;--color-accent-focus:#6f82c959;--color-accent-subtle:#6f82c91f;--color-text-primary:#f4f4f5;--color-text-secondary:#a1a1aa;--color-text-disabled:#71717a;--color-text-inverse:#171717;--color-background:#0f1115;--color-surface:#161a20;--color-section:#20242c;--color-border:#2a2e35;--color-divider:#323741;--color-overlay:#000000b3;--color-positive:#22c55e;--color-positive-subtle:#22c55e1f;--color-negative:#ef4444;--color-negative-subtle:#ef44441f;--color-success:#34d399;--color-success-subtle:#34d3991f;--color-success-border:#34d39940;--color-warning:#f59e0b;--color-warning-subtle:#f59e0b1f;--color-warning-border:#f59e0b40;--color-error:#f87171;--color-error-subtle:#f871711f;--color-error-border:#f8717140;--shadow-step-active:0px 0px 10px 0px #00000080;--shadow-dialog:0px 8px 32px 0px #0009;--btn-primary-gradient:linear-gradient(180deg, #fafafa 0%, #f0f0f0 50%, #e4e4e7 100%);--btn-primary-shadow:inset 0px -1px 3px 0px #0000001f, inset 0px 1px 2px 0px #fff9, inset 0px 1px 0px 0px #fff6}}:where(.dark,.dark *) .clco-sdk-root{--color-brand-primary:#f4f4f5;--color-brand-primary-hover:#fff;--color-brand-primary-active:#e4e4e7;--color-accent:#6f82c9;--color-accent-hover:#8799e4;--color-accent-active:#5b6fcf;--color-accent-focus:#6f82c959;--color-accent-subtle:#6f82c91f;--color-text-primary:#f4f4f5;--color-text-secondary:#a1a1aa;--color-text-disabled:#71717a;--color-text-inverse:#171717;--color-background:#0f1115;--color-surface:#161a20;--color-section:#20242c;--color-border:#2a2e35;--color-divider:#323741;--color-overlay:#000000b3;--color-positive:#22c55e;--color-positive-subtle:#22c55e1f;--color-negative:#ef4444;--color-negative-subtle:#ef44441f;--color-success:#34d399;--color-success-subtle:#34d3991f;--color-success-border:#34d39940;--color-warning:#f59e0b;--color-warning-subtle:#f59e0b1f;--color-warning-border:#f59e0b40;--color-error:#f87171;--color-error-subtle:#f871711f;--color-error-border:#f8717140;--shadow-step-active:0px 0px 10px 0px #00000080;--shadow-dialog:0px 8px 32px 0px #0009;--btn-primary-gradient:linear-gradient(180deg, #fafafa 0%, #f0f0f0 50%, #e4e4e7 100%);--btn-primary-shadow:inset 0px -1px 3px 0px #0000001f, inset 0px 1px 2px 0px #fff9, inset 0px 1px 0px 0px #fff6}.clco-sdk-root{color:var(--color-text-primary);-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;font-family:Inter,sans-serif}.clco-sdk-root *,.clco-sdk-root :before,.clco-sdk-root :after{box-sizing:border-box}.clco-sdk-root button{appearance:none;cursor:pointer;font:inherit;color:inherit;background:0 0;border:none;padding:0}.clco-sdk-root input,.clco-sdk-root textarea,.clco-sdk-root select{font:inherit;color:inherit;background:0 0;border:none;border-radius:0;padding:0}.clco-sdk-root a{color:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}.clco-sdk-root ul,.clco-sdk-root ol{margin:0;padding:0;list-style:none}.clco-sdk-root h1,.clco-sdk-root h2,.clco-sdk-root h3,.clco-sdk-root h4,.clco-sdk-root h5,.clco-sdk-root h6,.clco-sdk-root p,.clco-sdk-root figure,.clco-sdk-root blockquote,.clco-sdk-root dl,.clco-sdk-root dd,.clco-sdk-root pre{margin:0}.clco-sdk-root img,.clco-sdk-root svg{max-width:100%;display:block}}@layer components;@layer utilities{.clcosdk\\:pointer-events-none{pointer-events:none}.clcosdk\\:sr-only{clip-path:inset(50%);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.clcosdk\\:absolute{position:absolute}.clcosdk\\:fixed{position:fixed}.clcosdk\\:relative{position:relative}.clcosdk\\:inset-0{inset:calc(var(--clcosdk-spacing) * 0)}.clcosdk\\:top-4{top:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:top-full{top:100%}.clcosdk\\:-right-0\\.5{right:calc(var(--clcosdk-spacing) * -.5)}.clcosdk\\:right-4{right:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:-bottom-0\\.5{bottom:calc(var(--clcosdk-spacing) * -.5)}.clcosdk\\:bottom-full{bottom:100%}.clcosdk\\:left-1\\/2{left:50%}.clcosdk\\:z-50{z-index:50}.clcosdk\\:order-1{order:1}.clcosdk\\:order-2{order:2}.clcosdk\\:mt-2{margin-top:calc(var(--clcosdk-spacing) * 2)}.clcosdk\\:mt-4{margin-top:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:mb-2{margin-bottom:calc(var(--clcosdk-spacing) * 2)}.clcosdk\\:mb-6{margin-bottom:calc(var(--clcosdk-spacing) * 6)}.clcosdk\\:flex{display:flex}.clcosdk\\:grid{display:grid}.clcosdk\\:inline-flex{display:inline-flex}.clcosdk\\:size-2{width:calc(var(--clcosdk-spacing) * 2);height:calc(var(--clcosdk-spacing) * 2)}.clcosdk\\:size-3{width:calc(var(--clcosdk-spacing) * 3);height:calc(var(--clcosdk-spacing) * 3)}.clcosdk\\:size-3\\.5{width:calc(var(--clcosdk-spacing) * 3.5);height:calc(var(--clcosdk-spacing) * 3.5)}.clcosdk\\:size-4{width:calc(var(--clcosdk-spacing) * 4);height:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:size-5{width:calc(var(--clcosdk-spacing) * 5);height:calc(var(--clcosdk-spacing) * 5)}.clcosdk\\:size-10{width:calc(var(--clcosdk-spacing) * 10);height:calc(var(--clcosdk-spacing) * 10)}.clcosdk\\:size-16{width:calc(var(--clcosdk-spacing) * 16);height:calc(var(--clcosdk-spacing) * 16)}.clcosdk\\:size-24{width:calc(var(--clcosdk-spacing) * 24);height:calc(var(--clcosdk-spacing) * 24)}.clcosdk\\:size-full{width:100%;height:100%}.clcosdk\\:h-1{height:calc(var(--clcosdk-spacing) * 1)}.clcosdk\\:h-3{height:calc(var(--clcosdk-spacing) * 3)}.clcosdk\\:h-4{height:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:h-5{height:calc(var(--clcosdk-spacing) * 5)}.clcosdk\\:h-6{height:calc(var(--clcosdk-spacing) * 6)}.clcosdk\\:h-8{height:calc(var(--clcosdk-spacing) * 8)}.clcosdk\\:h-9{height:calc(var(--clcosdk-spacing) * 9)}.clcosdk\\:h-10{height:calc(var(--clcosdk-spacing) * 10)}.clcosdk\\:h-11{height:calc(var(--clcosdk-spacing) * 11)}.clcosdk\\:h-12{height:calc(var(--clcosdk-spacing) * 12)}.clcosdk\\:h-14{height:calc(var(--clcosdk-spacing) * 14)}.clcosdk\\:h-28{height:calc(var(--clcosdk-spacing) * 28)}.clcosdk\\:h-52{height:calc(var(--clcosdk-spacing) * 52)}.clcosdk\\:h-\\[18px\\]{height:18px}.clcosdk\\:h-\\[54px\\]{height:54px}.clcosdk\\:h-auto{height:auto}.clcosdk\\:h-full{height:100%}.clcosdk\\:h-px{height:1px}.clcosdk\\:max-h-\\[92vh\\]{max-height:92vh}.clcosdk\\:max-h-full{max-height:100%}.clcosdk\\:min-h-0{min-height:calc(var(--clcosdk-spacing) * 0)}.clcosdk\\:min-h-9{min-height:calc(var(--clcosdk-spacing) * 9)}.clcosdk\\:min-h-40{min-height:calc(var(--clcosdk-spacing) * 40)}.clcosdk\\:min-h-\\[2\\.4rem\\]{min-height:2.4rem}.clcosdk\\:min-h-screen{min-height:100vh}.clcosdk\\:w-1{width:calc(var(--clcosdk-spacing) * 1)}.clcosdk\\:w-4{width:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:w-5{width:calc(var(--clcosdk-spacing) * 5)}.clcosdk\\:w-6{width:calc(var(--clcosdk-spacing) * 6)}.clcosdk\\:w-12{width:calc(var(--clcosdk-spacing) * 12)}.clcosdk\\:w-16{width:calc(var(--clcosdk-spacing) * 16)}.clcosdk\\:w-20{width:calc(var(--clcosdk-spacing) * 20)}.clcosdk\\:w-24{width:calc(var(--clcosdk-spacing) * 24)}.clcosdk\\:w-28{width:calc(var(--clcosdk-spacing) * 28)}.clcosdk\\:w-32{width:calc(var(--clcosdk-spacing) * 32)}.clcosdk\\:w-40{width:calc(var(--clcosdk-spacing) * 40)}.clcosdk\\:w-48{width:calc(var(--clcosdk-spacing) * 48)}.clcosdk\\:w-80{width:calc(var(--clcosdk-spacing) * 80)}.clcosdk\\:w-96{width:calc(var(--clcosdk-spacing) * 96)}.clcosdk\\:w-\\[16px\\]{width:16px}.clcosdk\\:w-\\[448px\\]{width:448px}.clcosdk\\:w-auto{width:auto}.clcosdk\\:w-component{width:448px}.clcosdk\\:w-fit{width:fit-content}.clcosdk\\:w-full{width:100%}.clcosdk\\:w-max{width:max-content}.clcosdk\\:max-w-\\[16rem\\]{max-width:16rem}.clcosdk\\:max-w-\\[22rem\\]{max-width:22rem}.clcosdk\\:max-w-\\[28rem\\]{max-width:28rem}.clcosdk\\:max-w-\\[30rem\\]{max-width:30rem}.clcosdk\\:max-w-\\[760px\\]{max-width:760px}.clcosdk\\:max-w-\\[1200px\\]{max-width:1200px}.clcosdk\\:max-w-full{max-width:100%}.clcosdk\\:max-w-md{max-width:var(--clcosdk-container-md)}.clcosdk\\:max-w-sm{max-width:var(--clcosdk-container-sm)}.clcosdk\\:max-w-xl{max-width:var(--clcosdk-container-xl)}.clcosdk\\:min-w-0{min-width:calc(var(--clcosdk-spacing) * 0)}.clcosdk\\:flex-1{flex:1}.clcosdk\\:shrink-0{flex-shrink:0}.clcosdk\\:-translate-x-1\\/2{--tw-translate-x:calc(calc(1 / 2 * 100%) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.clcosdk\\:rotate-90{rotate:90deg}.clcosdk\\:rotate-180{rotate:180deg}.clcosdk\\:animate-pulse{animation:var(--clcosdk-animate-pulse)}.clcosdk\\:animate-spin{animation:var(--clcosdk-animate-spin)}.clcosdk\\:cursor-pointer{cursor:pointer}.clcosdk\\:grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.clcosdk\\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.clcosdk\\:grid-rows-\\[0fr\\]{grid-template-rows:0fr}.clcosdk\\:grid-rows-\\[1fr\\]{grid-template-rows:1fr}.clcosdk\\:flex-col{flex-direction:column}.clcosdk\\:flex-wrap{flex-wrap:wrap}.clcosdk\\:items-center{align-items:center}.clcosdk\\:items-end{align-items:flex-end}.clcosdk\\:items-start{align-items:flex-start}.clcosdk\\:justify-between{justify-content:space-between}.clcosdk\\:justify-center{justify-content:center}.clcosdk\\:justify-end{justify-content:flex-end}.clcosdk\\:gap-1{gap:calc(var(--clcosdk-spacing) * 1)}.clcosdk\\:gap-1\\.5{gap:calc(var(--clcosdk-spacing) * 1.5)}.clcosdk\\:gap-2{gap:calc(var(--clcosdk-spacing) * 2)}.clcosdk\\:gap-3{gap:calc(var(--clcosdk-spacing) * 3)}.clcosdk\\:gap-4{gap:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:gap-5{gap:calc(var(--clcosdk-spacing) * 5)}.clcosdk\\:gap-6{gap:calc(var(--clcosdk-spacing) * 6)}.clcosdk\\:gap-8{gap:calc(var(--clcosdk-spacing) * 8)}.clcosdk\\:gap-\\[5px\\]{gap:5px}:where(.clcosdk\\:space-y-3>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--clcosdk-spacing) * 3) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--clcosdk-spacing) * 3) * calc(1 - var(--tw-space-y-reverse)))}:where(.clcosdk\\:space-y-4>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--clcosdk-spacing) * 4) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--clcosdk-spacing) * 4) * calc(1 - var(--tw-space-y-reverse)))}:where(.clcosdk\\:divide-y>:not(:last-child)){--tw-divide-y-reverse:0;border-bottom-style:var(--tw-border-style);border-top-style:var(--tw-border-style);border-top-width:calc(1px * var(--tw-divide-y-reverse));border-bottom-width:calc(1px * calc(1 - var(--tw-divide-y-reverse)))}:where(.clcosdk\\:divide-border>:not(:last-child)){border-color:var(--color-border)}:where(.clcosdk\\:divide-divider>:not(:last-child)){border-color:var(--color-divider)}.clcosdk\\:self-start{align-self:flex-start}.clcosdk\\:truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.clcosdk\\:overflow-hidden{overflow:hidden}.clcosdk\\:overflow-y-auto{overflow-y:auto}.clcosdk\\:rounded{border-radius:.25rem}.clcosdk\\:rounded-2xl{border-radius:var(--clcosdk-radius-2xl)}.clcosdk\\:rounded-btn{border-radius:12px}.clcosdk\\:rounded-card{border-radius:24px}.clcosdk\\:rounded-full{border-radius:3.40282e38px}.clcosdk\\:rounded-lg{border-radius:var(--clcosdk-radius-lg)}.clcosdk\\:rounded-md{border-radius:var(--clcosdk-radius-md)}.clcosdk\\:rounded-xl{border-radius:var(--clcosdk-radius-xl)}.clcosdk\\:border{border-style:var(--tw-border-style);border-width:1px}.clcosdk\\:border-2{border-style:var(--tw-border-style);border-width:2px}.clcosdk\\:border-\\[1\\.5px\\]{border-style:var(--tw-border-style);border-width:1.5px}.clcosdk\\:border-t{border-top-style:var(--tw-border-style);border-top-width:1px}.clcosdk\\:border-dashed{--tw-border-style:dashed;border-style:dashed}.clcosdk\\:border-accent\\/50{border-color:var(--color-accent)}@supports (color:color-mix(in lab, red, red)){.clcosdk\\:border-accent\\/50{border-color:color-mix(in oklab, var(--color-accent) 50%, transparent)}}.clcosdk\\:border-accent\\/60{border-color:var(--color-accent)}@supports (color:color-mix(in lab, red, red)){.clcosdk\\:border-accent\\/60{border-color:color-mix(in oklab, var(--color-accent) 60%, transparent)}}.clcosdk\\:border-amber-500{border-color:var(--clcosdk-color-amber-500)}.clcosdk\\:border-background{border-color:var(--color-background)}.clcosdk\\:border-border,.clcosdk\\:border-border\\/60{border-color:var(--color-border)}@supports (color:color-mix(in lab, red, red)){.clcosdk\\:border-border\\/60{border-color:color-mix(in oklab, var(--color-border) 60%, transparent)}}.clcosdk\\:border-brand-primary{border-color:var(--color-brand-primary)}.clcosdk\\:border-current{border-color:currentColor}.clcosdk\\:border-divider{border-color:var(--color-divider)}.clcosdk\\:border-error-border{border-color:var(--color-error-border)}.clcosdk\\:border-success-border{border-color:var(--color-success-border)}.clcosdk\\:border-warning-border{border-color:var(--color-warning-border)}.clcosdk\\:border-t-transparent{border-top-color:#0000}.clcosdk\\:bg-accent\\/10{background-color:var(--color-accent)}@supports (color:color-mix(in lab, red, red)){.clcosdk\\:bg-accent\\/10{background-color:color-mix(in oklab, var(--color-accent) 10%, transparent)}}.clcosdk\\:bg-background{background-color:var(--color-background)}.clcosdk\\:bg-black\\/50{background-color:var(--clcosdk-color-black)}@supports (color:color-mix(in lab, red, red)){.clcosdk\\:bg-black\\/50{background-color:color-mix(in oklab, var(--clcosdk-color-black) 50%, transparent)}}.clcosdk\\:bg-brand-primary{background-color:var(--color-brand-primary)}.clcosdk\\:bg-divider{background-color:var(--color-divider)}.clcosdk\\:bg-error-subtle{background-color:var(--color-error-subtle)}.clcosdk\\:bg-overlay{background-color:var(--color-overlay)}.clcosdk\\:bg-positive{background-color:var(--color-positive)}.clcosdk\\:bg-positive-subtle{background-color:var(--color-positive-subtle)}.clcosdk\\:bg-section{background-color:var(--color-section)}.clcosdk\\:bg-success-subtle{background-color:var(--color-success-subtle)}.clcosdk\\:bg-surface{background-color:var(--color-surface)}.clcosdk\\:bg-text-disabled{background-color:var(--color-text-disabled)}.clcosdk\\:bg-text-primary{background-color:var(--color-text-primary)}.clcosdk\\:bg-transparent{background-color:#0000}.clcosdk\\:bg-warning-subtle{background-color:var(--color-warning-subtle)}.clcosdk\\:bg-gradient-to-b{--tw-gradient-position:to bottom in oklab;background-image:linear-gradient(var(--tw-gradient-stops))}.clcosdk\\:bg-gradient-to-br{--tw-gradient-position:to bottom right in oklab;background-image:linear-gradient(var(--tw-gradient-stops))}.clcosdk\\:bg-\\[image\\:var\\(--btn-primary-gradient\\)\\]{background-image:var(--btn-primary-gradient)}.clcosdk\\:from-surface{--tw-gradient-from:var(--color-surface);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.clcosdk\\:from-transparent{--tw-gradient-from:transparent;--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.clcosdk\\:via-section{--tw-gradient-via:var(--color-section);--tw-gradient-via-stops:var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-via) var(--tw-gradient-via-position), var(--tw-gradient-to) var(--tw-gradient-to-position);--tw-gradient-stops:var(--tw-gradient-via-stops)}.clcosdk\\:via-transparent{--tw-gradient-via:transparent;--tw-gradient-via-stops:var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-via) var(--tw-gradient-via-position), var(--tw-gradient-to) var(--tw-gradient-to-position);--tw-gradient-stops:var(--tw-gradient-via-stops)}.clcosdk\\:to-background{--tw-gradient-to:var(--color-background);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.clcosdk\\:to-overlay\\/35{--tw-gradient-to:var(--color-overlay)}@supports (color:color-mix(in lab, red, red)){.clcosdk\\:to-overlay\\/35{--tw-gradient-to:color-mix(in oklab, var(--color-overlay) 35%, transparent)}}.clcosdk\\:to-overlay\\/35{--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.clcosdk\\:object-contain{object-fit:contain}.clcosdk\\:object-cover{object-fit:cover}.clcosdk\\:p-0{padding:calc(var(--clcosdk-spacing) * 0)}.clcosdk\\:p-1\\.5{padding:calc(var(--clcosdk-spacing) * 1.5)}.clcosdk\\:p-3{padding:calc(var(--clcosdk-spacing) * 3)}.clcosdk\\:p-3\\.5{padding:calc(var(--clcosdk-spacing) * 3.5)}.clcosdk\\:p-4{padding:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:p-6{padding:calc(var(--clcosdk-spacing) * 6)}.clcosdk\\:p-8{padding:calc(var(--clcosdk-spacing) * 8)}.clcosdk\\:p-16{padding:calc(var(--clcosdk-spacing) * 16)}.clcosdk\\:px-2{padding-inline:calc(var(--clcosdk-spacing) * 2)}.clcosdk\\:px-3{padding-inline:calc(var(--clcosdk-spacing) * 3)}.clcosdk\\:px-4{padding-inline:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:px-5{padding-inline:calc(var(--clcosdk-spacing) * 5)}.clcosdk\\:px-6{padding-inline:calc(var(--clcosdk-spacing) * 6)}.clcosdk\\:py-1\\.5{padding-block:calc(var(--clcosdk-spacing) * 1.5)}.clcosdk\\:py-2{padding-block:calc(var(--clcosdk-spacing) * 2)}.clcosdk\\:py-3{padding-block:calc(var(--clcosdk-spacing) * 3)}.clcosdk\\:py-8{padding-block:calc(var(--clcosdk-spacing) * 8)}.clcosdk\\:py-12{padding-block:calc(var(--clcosdk-spacing) * 12)}.clcosdk\\:pt-1{padding-top:calc(var(--clcosdk-spacing) * 1)}.clcosdk\\:pt-4{padding-top:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:pt-14{padding-top:calc(var(--clcosdk-spacing) * 14)}.clcosdk\\:pr-4{padding-right:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:pb-4{padding-bottom:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:pl-3{padding-left:calc(var(--clcosdk-spacing) * 3)}.clcosdk\\:text-center{text-align:center}.clcosdk\\:text-left{text-align:left}.clcosdk\\:text-right{text-align:right}.clcosdk\\:font-mono{font-family:var(--clcosdk-font-mono)}.clcosdk\\:text-base{font-size:var(--clcosdk-text-base);line-height:var(--tw-leading,var(--clcosdk-text-base--line-height))}.clcosdk\\:text-lg{font-size:var(--clcosdk-text-lg);line-height:var(--tw-leading,var(--clcosdk-text-lg--line-height))}.clcosdk\\:text-sm{font-size:var(--clcosdk-text-sm);line-height:var(--tw-leading,var(--clcosdk-text-sm--line-height))}.clcosdk\\:text-xs{font-size:var(--clcosdk-text-xs);line-height:var(--tw-leading,var(--clcosdk-text-xs--line-height))}.clcosdk\\:text-\\[11px\\]{font-size:11px}.clcosdk\\:text-\\[12px\\]{font-size:12px}.clcosdk\\:text-\\[14px\\]{font-size:14px}.clcosdk\\:text-\\[15px\\]{font-size:15px}.clcosdk\\:text-\\[16px\\]{font-size:16px}.clcosdk\\:text-\\[18px\\]{font-size:18px}.clcosdk\\:text-\\[22px\\]{font-size:22px}.clcosdk\\:text-\\[28px\\]{font-size:28px}.clcosdk\\:text-\\[36px\\]{font-size:36px}.clcosdk\\:text-\\[48px\\]{font-size:48px}.clcosdk\\:text-\\[64px\\]{font-size:64px}.clcosdk\\:leading-\\[110\\%\\]{--tw-leading:110%;line-height:110%}.clcosdk\\:leading-\\[120\\%\\]{--tw-leading:120%;line-height:120%}.clcosdk\\:leading-\\[125\\%\\]{--tw-leading:125%;line-height:125%}.clcosdk\\:leading-\\[130\\%\\]{--tw-leading:130%;line-height:130%}.clcosdk\\:leading-\\[135\\%\\]{--tw-leading:135%;line-height:135%}.clcosdk\\:leading-\\[140\\%\\]{--tw-leading:140%;line-height:140%}.clcosdk\\:leading-\\[150\\%\\]{--tw-leading:150%;line-height:150%}.clcosdk\\:leading-\\[160\\%\\]{--tw-leading:160%;line-height:160%}.clcosdk\\:font-medium{--tw-font-weight:var(--clcosdk-font-weight-medium);font-weight:var(--clcosdk-font-weight-medium)}.clcosdk\\:font-normal{--tw-font-weight:var(--clcosdk-font-weight-normal);font-weight:var(--clcosdk-font-weight-normal)}.clcosdk\\:font-semibold{--tw-font-weight:var(--clcosdk-font-weight-semibold);font-weight:var(--clcosdk-font-weight-semibold)}.clcosdk\\:tracking-\\[0\\.12px\\]{--tw-tracking:.12px;letter-spacing:.12px}.clcosdk\\:tracking-\\[0\\.28px\\]{--tw-tracking:.28px;letter-spacing:.28px}.clcosdk\\:break-words{overflow-wrap:break-word}.clcosdk\\:whitespace-nowrap{white-space:nowrap}.clcosdk\\:text-background{color:var(--color-background)}.clcosdk\\:text-brand-primary{color:var(--color-brand-primary)}.clcosdk\\:text-error{color:var(--color-error)}.clcosdk\\:text-positive{color:var(--color-positive)}.clcosdk\\:text-success{color:var(--color-success)}.clcosdk\\:text-text-disabled{color:var(--color-text-disabled)}.clcosdk\\:text-text-inverse{color:var(--color-text-inverse)}.clcosdk\\:text-text-primary{color:var(--color-text-primary)}.clcosdk\\:text-text-secondary{color:var(--color-text-secondary)}.clcosdk\\:text-warning{color:var(--color-warning)}.clcosdk\\:capitalize{text-transform:capitalize}.clcosdk\\:tabular-nums{--tw-numeric-spacing:tabular-nums;font-variant-numeric:var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,)}.clcosdk\\:no-underline{text-decoration-line:none}.clcosdk\\:underline{text-decoration-line:underline}.clcosdk\\:underline-offset-2{text-underline-offset:2px}.clcosdk\\:underline-offset-4{text-underline-offset:4px}.clcosdk\\:opacity-0{opacity:0}.clcosdk\\:opacity-60{opacity:.6}.clcosdk\\:shadow-\\[0_0_0_3px_rgba\\(59\\,130\\,246\\,0\\.2\\)\\]{--tw-shadow:0 0 0 3px var(--tw-shadow-color,#3b82f633);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.clcosdk\\:shadow-\\[0_0_0_3px_rgba\\(59\\,130\\,246\\,0\\.18\\)\\]{--tw-shadow:0 0 0 3px var(--tw-shadow-color,#3b82f62e);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.clcosdk\\:shadow-\\[0_0_0_3px_rgba\\(59\\,130\\,246\\,0\\.25\\)\\]{--tw-shadow:0 0 0 3px var(--tw-shadow-color,#3b82f640);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.clcosdk\\:shadow-\\[0_10px_24px_rgba\\(0\\,0\\,0\\,0\\.18\\)\\]{--tw-shadow:0 10px 24px var(--tw-shadow-color,#0000002e);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.clcosdk\\:shadow-\\[0_10px_24px_rgba\\(0\\,0\\,0\\,0\\.25\\)\\]{--tw-shadow:0 10px 24px var(--tw-shadow-color,#00000040);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.clcosdk\\:shadow-\\[var\\(--btn-primary-shadow\\)\\]{--tw-shadow:var(--btn-primary-shadow);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.clcosdk\\:shadow-card{--tw-shadow:0px 4px 6px -2px var(--tw-shadow-color,#0000000d), 0px 12px 24px -4px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.clcosdk\\:shadow-dialog{--tw-shadow:var(--shadow-dialog);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.clcosdk\\:shadow-step-active{--tw-shadow:var(--shadow-step-active);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.clcosdk\\:transition-\\[grid-template-rows\\]{transition-property:grid-template-rows;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.clcosdk\\:transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.clcosdk\\:transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.clcosdk\\:transition-opacity{transition-property:opacity;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.clcosdk\\:transition-transform{transition-property:transform,translate,scale,rotate;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.clcosdk\\:duration-200{--tw-duration:.2s;transition-duration:.2s}.clcosdk\\:duration-300{--tw-duration:.3s;transition-duration:.3s}.clcosdk\\:ease-in-out{--tw-ease:var(--clcosdk-ease-in-out);transition-timing-function:var(--clcosdk-ease-in-out)}.clcosdk\\:outline-none{--tw-outline-style:none;outline-style:none}.clcosdk\\:group-focus-within\\:opacity-100:is(:where(.clcosdk\\:group):focus-within *){opacity:1}@media (hover:hover){.clcosdk\\:group-hover\\:opacity-100:is(:where(.clcosdk\\:group):hover *){opacity:1}}.clcosdk\\:placeholder\\:text-text-disabled::placeholder{color:var(--color-text-disabled)}@media (hover:hover){.clcosdk\\:hover\\:-translate-y-0\\.5:hover{--tw-translate-y:calc(var(--clcosdk-spacing) * -.5);translate:var(--tw-translate-x) var(--tw-translate-y)}.clcosdk\\:hover\\:border-divider:hover{border-color:var(--color-divider)}.clcosdk\\:hover\\:border-text-disabled:hover{border-color:var(--color-text-disabled)}.clcosdk\\:hover\\:bg-\\[\\#fcdcd8\\]:hover{background-color:#fcdcd8}.clcosdk\\:hover\\:bg-border:hover{background-color:var(--color-border)}.clcosdk\\:hover\\:bg-brand-primary:hover{background-color:var(--color-brand-primary)}.clcosdk\\:hover\\:bg-brand-primary-hover:hover{background-color:var(--color-brand-primary-hover)}.clcosdk\\:hover\\:bg-section:hover{background-color:var(--color-section)}.clcosdk\\:hover\\:bg-surface:hover{background-color:var(--color-surface)}.clcosdk\\:hover\\:text-\\[\\#8b1a13\\]:hover{color:#8b1a13}.clcosdk\\:hover\\:text-text-primary:hover{color:var(--color-text-primary)}.clcosdk\\:hover\\:underline:hover{text-decoration-line:underline}.clcosdk\\:hover\\:opacity-80:hover{opacity:.8}.clcosdk\\:hover\\:opacity-90:hover{opacity:.9}.clcosdk\\:hover\\:shadow-\\[0px_14px_32px_-10px_rgba\\(0\\,0\\,0\\,0\\.35\\)\\]:hover{--tw-shadow:0px 14px 32px -10px var(--tw-shadow-color,#00000059);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}}.clcosdk\\:focus-visible\\:ring-2:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.clcosdk\\:focus-visible\\:ring-accent-focus:focus-visible{--tw-ring-color:var(--color-accent-focus)}.clcosdk\\:focus-visible\\:ring-gray-400:focus-visible{--tw-ring-color:var(--clcosdk-color-gray-400)}.clcosdk\\:focus-visible\\:ring-gray-500:focus-visible{--tw-ring-color:var(--clcosdk-color-gray-500)}.clcosdk\\:focus-visible\\:ring-red-400:focus-visible{--tw-ring-color:var(--clcosdk-color-red-400)}.clcosdk\\:focus-visible\\:ring-red-500:focus-visible{--tw-ring-color:var(--clcosdk-color-red-500)}.clcosdk\\:focus-visible\\:ring-offset-2:focus-visible{--tw-ring-offset-width:2px;--tw-ring-offset-shadow:var(--tw-ring-inset,) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color)}.clcosdk\\:focus-visible\\:outline-none:focus-visible{--tw-outline-style:none;outline-style:none}.clcosdk\\:active\\:bg-\\[\\#d9d9d9\\]:active{background-color:#d9d9d9}.clcosdk\\:active\\:bg-\\[\\#f9c9c4\\]:active{background-color:#f9c9c4}.clcosdk\\:active\\:bg-border:active{background-color:var(--color-border)}.clcosdk\\:active\\:bg-brand-primary-active:active{background-color:var(--color-brand-primary-active)}.clcosdk\\:active\\:text-\\[\\#6d1510\\]:active{color:#6d1510}.clcosdk\\:active\\:opacity-80:active{opacity:.8}.clcosdk\\:disabled\\:pointer-events-none:disabled{pointer-events:none}.clcosdk\\:disabled\\:cursor-not-allowed:disabled{cursor:not-allowed}.clcosdk\\:disabled\\:opacity-40:disabled{opacity:.4}.clcosdk\\:disabled\\:opacity-50:disabled{opacity:.5}.clcosdk\\:aria-disabled\\:cursor-not-allowed[aria-disabled=true]{cursor:not-allowed}.clcosdk\\:aria-disabled\\:opacity-50[aria-disabled=true]{opacity:.5}@media not all and (min-width:48rem){.clcosdk\\:max-md\\:hidden{display:none}.clcosdk\\:max-md\\:w-full{width:100%}.clcosdk\\:max-md\\:justify-start{justify-content:flex-start}.clcosdk\\:max-md\\:gap-4{gap:calc(var(--clcosdk-spacing) * 4)}.clcosdk\\:max-md\\:rounded-none{border-radius:0}.clcosdk\\:max-md\\:border-0{border-style:var(--tw-border-style);border-width:0}.clcosdk\\:max-md\\:bg-transparent{background-color:#0000}.clcosdk\\:max-md\\:p-0{padding:calc(var(--clcosdk-spacing) * 0)}}@media (min-width:40rem){.clcosdk\\:sm\\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}}@media (min-width:48rem){.clcosdk\\:md\\:order-1{order:1}.clcosdk\\:md\\:order-2{order:2}.clcosdk\\:md\\:hidden{display:none}.clcosdk\\:md\\:grid-cols-\\[minmax\\(0\\,11fr\\)_minmax\\(0\\,8fr\\)\\]{grid-template-columns:minmax(0,11fr) minmax(0,8fr)}.clcosdk\\:md\\:flex-row{flex-direction:row}.clcosdk\\:md\\:items-center{align-items:center}.clcosdk\\:md\\:items-end{align-items:flex-end}.clcosdk\\:md\\:justify-between{justify-content:space-between}.clcosdk\\:md\\:justify-end{justify-content:flex-end}.clcosdk\\:md\\:gap-6{gap:calc(var(--clcosdk-spacing) * 6)}.clcosdk\\:md\\:gap-x-12{column-gap:calc(var(--clcosdk-spacing) * 12)}.clcosdk\\:md\\:self-end{align-self:flex-end}.clcosdk\\:md\\:rounded-card{border-radius:24px}.clcosdk\\:md\\:rounded-dialog{border-radius:32px}.clcosdk\\:md\\:p-6{padding:calc(var(--clcosdk-spacing) * 6)}.clcosdk\\:md\\:px-6{padding-inline:calc(var(--clcosdk-spacing) * 6)}.clcosdk\\:md\\:px-8{padding-inline:calc(var(--clcosdk-spacing) * 8)}}@media (prefers-color-scheme:dark){@media (hover:hover){.clcosdk\\:dark\\:hover\\:bg-\\[rgba\\(248\\,113\\,113\\,0\\.20\\)\\]:not(:where(.light,.light *)):hover{background-color:#f8717133}}}@media (hover:hover){.clcosdk\\:dark\\:hover\\:bg-\\[rgba\\(248\\,113\\,113\\,0\\.20\\)\\]:where(.dark,.dark *):hover{background-color:#f8717133}}@media (prefers-color-scheme:dark){@media (hover:hover){.clcosdk\\:dark\\:hover\\:text-\\[\\#fca5a5\\]:not(:where(.light,.light *)):hover{color:#fca5a5}}}@media (hover:hover){.clcosdk\\:dark\\:hover\\:text-\\[\\#fca5a5\\]:where(.dark,.dark *):hover{color:#fca5a5}}@media (prefers-color-scheme:dark){.clcosdk\\:dark\\:active\\:bg-\\[rgba\\(248\\,113\\,113\\,0\\.30\\)\\]:not(:where(.light,.light *)):active{background-color:#f871714d}}.clcosdk\\:dark\\:active\\:bg-\\[rgba\\(248\\,113\\,113\\,0\\.30\\)\\]:where(.dark,.dark *):active{background-color:#f871714d}@media (prefers-color-scheme:dark){.clcosdk\\:dark\\:active\\:bg-divider:not(:where(.light,.light *)):active{background-color:var(--color-divider)}}.clcosdk\\:dark\\:active\\:bg-divider:where(.dark,.dark *):active{background-color:var(--color-divider)}@media (prefers-color-scheme:dark){.clcosdk\\:dark\\:active\\:text-\\[\\#f87171\\]:not(:where(.light,.light *)):active{color:#f87171}}.clcosdk\\:dark\\:active\\:text-\\[\\#f87171\\]:where(.dark,.dark *):active{color:#f87171}.clcosdk\\:\\[\\&_circle\\]\\:fill-error-subtle circle{fill:var(--color-error-subtle)}.clcosdk\\:\\[\\&_circle\\]\\:fill-success-subtle circle{fill:var(--color-success-subtle)}.clcosdk\\:\\[\\&_circle\\]\\:fill-warning-subtle circle{fill:var(--color-warning-subtle)}}@property --tw-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-z{syntax:"*";inherits:false;initial-value:0}@property --tw-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-divide-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-gradient-position{syntax:"*";inherits:false}@property --tw-gradient-from{syntax:"<color>";inherits:false;initial-value:#0000}@property --tw-gradient-via{syntax:"<color>";inherits:false;initial-value:#0000}@property --tw-gradient-to{syntax:"<color>";inherits:false;initial-value:#0000}@property --tw-gradient-stops{syntax:"*";inherits:false}@property --tw-gradient-via-stops{syntax:"*";inherits:false}@property --tw-gradient-from-position{syntax:"<length-percentage>";inherits:false;initial-value:0%}@property --tw-gradient-via-position{syntax:"<length-percentage>";inherits:false;initial-value:50%}@property --tw-gradient-to-position{syntax:"<length-percentage>";inherits:false;initial-value:100%}@property --tw-leading{syntax:"*";inherits:false}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@property --tw-ordinal{syntax:"*";inherits:false}@property --tw-slashed-zero{syntax:"*";inherits:false}@property --tw-numeric-figure{syntax:"*";inherits:false}@property --tw-numeric-spacing{syntax:"*";inherits:false}@property --tw-numeric-fraction{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"<length>";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-duration{syntax:"*";inherits:false}@property --tw-ease{syntax:"*";inherits:false}@keyframes spin{to{transform:rotate(360deg)}}@keyframes pulse{50%{opacity:.5}}';
 
 // src/client/CoinListStyleScope.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
-var ScopeContext = (0, import_react3.createContext)(false);
+var ScopeContext = (0, import_react4.createContext)(false);
 function CoinListStyleScope({ children }) {
-  const alreadyScoped = (0, import_react3.useContext)(ScopeContext);
+  const alreadyScoped = (0, import_react4.useContext)(ScopeContext);
   if (alreadyScoped) {
     return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children });
   }
@@ -3357,7 +3889,7 @@ function CoinListStyleScope({ children }) {
 
 // src/client/components/design-system/ClButton.tsx
 var import_class_variance_authority = require("class-variance-authority");
-var import_react4 = require("react");
+var import_react5 = require("react");
 
 // src/client/components/design-system/utils.ts
 var import_clsx = require("clsx");
@@ -3424,7 +3956,7 @@ var buttonVariants = (0, import_class_variance_authority.cva)(
     }
   }
 );
-var ClButton = (0, import_react4.forwardRef)(
+var ClButton = (0, import_react5.forwardRef)(
   ({
     className,
     variant,
@@ -3768,12 +4300,12 @@ function CoinListSignInCardView({
 }
 
 // src/client/hooks/auth/useCoinListSignInCardViewModel.ts
-var import_react6 = require("react");
+var import_react7 = require("react");
 
 // src/client/hooks/useCoinList.ts
-var import_react5 = require("react");
+var import_react6 = require("react");
 function useCoinList() {
-  const context = (0, import_react5.useContext)(CoinListContext);
+  const context = (0, import_react6.useContext)(CoinListContext);
   if (context === null) {
     throw new CoinListClientInitializationError();
   }
@@ -3794,11 +4326,11 @@ var ERROR_MESSAGE = "Error signing in. Please try again.";
 function useCoinListSignInCardViewModel(options = {}) {
   const { status = "idle", onSignIn, onClose } = options;
   const { coinlist } = useCoinList();
-  const state = (0, import_react6.useMemo)(() => {
+  const state = (0, import_react7.useMemo)(() => {
     const closable = onClose !== void 0;
     return status === "error" ? { type: "error", message: ERROR_MESSAGE, closable } : { type: "idle", closable };
   }, [status, onClose]);
-  const onEvent = (0, import_react6.useCallback)(
+  const onEvent = (0, import_react7.useCallback)(
     (event) => {
       switch (event.type) {
         case "ON_SIGN_IN":
@@ -3846,7 +4378,7 @@ function CoinListSignInCardContainer({
 }
 
 // src/client/components/checkout/shared/amount/CheckoutAmountInput.tsx
-var import_react7 = require("react");
+var import_react8 = require("react");
 var import_jsx_runtime12 = require("react/jsx-runtime");
 function CheckoutAmountInput({
   label,
@@ -3856,12 +4388,13 @@ function CheckoutAmountInput({
   invalid = false,
   disabled = false,
   prefix,
-  suffix,
+  prefixTone = "primary",
   action,
   className
 }) {
-  const inputId = (0, import_react7.useId)();
+  const inputId = (0, import_react8.useId)();
   const toneClass = invalid ? "clcosdk:text-error" : "clcosdk:text-text-primary";
+  const prefixToneClass = prefixTone === "muted" ? "clcosdk:text-text-secondary" : toneClass;
   return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(CoinListStyleScope, { children: /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
     "div",
     {
@@ -3891,7 +4424,7 @@ function CheckoutAmountInput({
                     className: cn(
                       typeClasses.h4,
                       "clcosdk:shrink-0 clcosdk:font-medium",
-                      toneClass
+                      prefixToneClass
                     ),
                     children: prefix
                   }
@@ -3915,16 +4448,6 @@ function CheckoutAmountInput({
                       toneClass
                     )
                   }
-                ),
-                suffix && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
-                  "span",
-                  {
-                    className: cn(
-                      typeClasses.h4,
-                      "clcosdk:shrink-0 clcosdk:font-medium clcosdk:text-text-secondary"
-                    ),
-                    children: suffix
-                  }
                 )
               ] }),
               action
@@ -4284,7 +4807,8 @@ function ActiveView({
             placeholder: AMOUNT_PLACEHOLDER,
             invalid: state.error !== null,
             disabled: isLoading,
-            suffix: selectedAsset?.symbol,
+            prefix: selectedAsset?.symbol,
+            prefixTone: "muted",
             action: selectedAsset && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
               MaxButton,
               {
@@ -4489,13 +5013,13 @@ function CheckoutDetailList({
 }
 
 // src/client/components/design-system/Modal.tsx
-var import_react8 = require("react");
+var import_react9 = require("react");
 var import_jsx_runtime21 = require("react/jsx-runtime");
 function Modal({ label, onClose, children, className }) {
-  const surfaceRef = (0, import_react8.useRef)(null);
-  const onCloseRef = (0, import_react8.useRef)(onClose);
+  const surfaceRef = (0, import_react9.useRef)(null);
+  const onCloseRef = (0, import_react9.useRef)(onClose);
   onCloseRef.current = onClose;
-  (0, import_react8.useEffect)(() => {
+  (0, import_react9.useEffect)(() => {
     const previouslyFocused = document.activeElement;
     surfaceRef.current?.focus();
     const onKeyDown = (event) => {
@@ -4775,7 +5299,7 @@ function Skeleton({ variant = "text", className }) {
 }
 
 // src/client/components/design-system/Tooltip.tsx
-var import_react9 = require("react");
+var import_react10 = require("react");
 var import_jsx_runtime26 = require("react/jsx-runtime");
 var positionClasses = {
   top: "clcosdk:bottom-full clcosdk:mb-2",
@@ -4787,7 +5311,7 @@ function Tooltip({
   children,
   className
 }) {
-  const tooltipId = (0, import_react9.useId)();
+  const tooltipId = (0, import_react10.useId)();
   return /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(
     "span",
     {
@@ -4919,7 +5443,8 @@ function ActiveView2({
         }
       )
     ] }),
-    state.error ? /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(QuoteLine, { tone: "error", children: state.error }) : /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(QuoteStatusLine, { quote: state.quote, onEvent }),
+    state.error !== null && /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(QuoteLine, { tone: "error", children: state.error }),
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(QuoteStatusLine, { quote: state.quote, onEvent }),
     /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
       ClButton,
       {
@@ -5143,7 +5668,7 @@ function StatusIndicator({ status, className }) {
 
 // src/client/components/checkout/shared/sidebar/CheckoutSidebarCard.tsx
 var import_lucide_react5 = require("lucide-react");
-var import_react10 = require("react");
+var import_react11 = require("react");
 
 // src/client/components/checkout/shared/common/CheckoutCard.tsx
 var import_jsx_runtime29 = require("react/jsx-runtime");
@@ -5173,8 +5698,8 @@ function CheckoutSidebarCard({
   hideDetailsLabel,
   className
 }) {
-  const [expanded, setExpanded] = (0, import_react10.useState)(false);
-  const rowsId = (0, import_react10.useId)();
+  const [expanded, setExpanded] = (0, import_react11.useState)(false);
+  const rowsId = (0, import_react11.useId)();
   return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(CoinListStyleScope, { children: /* @__PURE__ */ (0, import_jsx_runtime30.jsxs)(
     CheckoutCard,
     {
@@ -5321,7 +5846,7 @@ function PriceCaption({ price }) {
 var import_lucide_react6 = require("lucide-react");
 
 // src/client/components/checkout/shared/selection/SelectableOptionRow.tsx
-var import_react11 = require("react");
+var import_react12 = require("react");
 var import_jsx_runtime32 = require("react/jsx-runtime");
 function SelectableOptionRow({
   selected,
@@ -5405,10 +5930,10 @@ function RadioCircle({ selected }) {
   );
 }
 function OptionMetaRow({ children }) {
-  const items = import_react11.Children.toArray(children).filter(Boolean);
+  const items = import_react12.Children.toArray(children).filter(Boolean);
   return /* @__PURE__ */ (0, import_jsx_runtime32.jsx)("div", { className: "clcosdk:flex clcosdk:min-w-0 clcosdk:items-center clcosdk:gap-1.5", children: items.map((item, index) => (
     // biome-ignore lint/suspicious/noArrayIndexKey: positional separators, and the list is caller-authored JSX.
-    /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)(import_react11.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)(import_react12.Fragment, { children: [
       index > 0 && /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(MetaDot, {}),
       item
     ] }, index)
@@ -6006,7 +6531,7 @@ var SUPERSTATE_TOS_URL = "https://superstate.com/terms";
 
 // src/client/components/checkout/superstate/swap/review/SlippagePicker.tsx
 var import_lucide_react8 = require("lucide-react");
-var import_react12 = require("react");
+var import_react13 = require("react");
 var import_jsx_runtime37 = require("react/jsx-runtime");
 function SlippagePicker({
   slippage,
@@ -6015,7 +6540,7 @@ function SlippagePicker({
   onSelect,
   className
 }) {
-  const optionsId = (0, import_react12.useId)();
+  const optionsId = (0, import_react13.useId)();
   return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(CoinListStyleScope, { children: /* @__PURE__ */ (0, import_jsx_runtime37.jsxs)(
     "div",
     {
@@ -6874,10 +7399,10 @@ function ErrorView3({
 }
 
 // src/client/hooks/checkout/ondo/buy/useOndoBuyCheckoutViewModel.ts
-var import_react21 = require("react");
+var import_react22 = require("react");
 
 // src/client/hooks/checkout/ondo/buy/amount/useOndoAmountViewModel.ts
-var import_react14 = require("react");
+var import_react15 = require("react");
 
 // src/client/ui/format/asset-icon.ts
 var USDC_ICON_URL = AssetIconUrl(
@@ -6950,7 +7475,7 @@ var CheckoutAssetUi = {
 };
 
 // src/client/hooks/shared/erc20/useErc20TokenBalances.ts
-var import_react13 = require("react");
+var import_react14 = require("react");
 var ERC20_BALANCE_POLL_INTERVAL_MS = 15e3;
 function useErc20TokenBalances(options) {
   const {
@@ -6961,12 +7486,12 @@ function useErc20TokenBalances(options) {
     enabled
   } = options;
   const { coinlist, isReady } = useCoinList();
-  const [balances, setBalances] = (0, import_react13.useState)(/* @__PURE__ */ new Map());
-  const [isLoading, setIsLoading] = (0, import_react13.useState)(true);
-  const fetchIdRef = (0, import_react13.useRef)(0);
-  const isFetchingRef = (0, import_react13.useRef)(false);
+  const [balances, setBalances] = (0, import_react14.useState)(/* @__PURE__ */ new Map());
+  const [isLoading, setIsLoading] = (0, import_react14.useState)(true);
+  const fetchIdRef = (0, import_react14.useRef)(0);
+  const isFetchingRef = (0, import_react14.useRef)(false);
   const assetsKey = assets.join(",");
-  (0, import_react13.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     if (!isReady) return;
     if (!enabled) {
       setIsLoading(false);
@@ -7031,13 +7556,13 @@ function useOndoAmountViewModel({
 }) {
   const { coinlist } = useCoinList();
   const locale = useLocale();
-  const [amountInput, setAmountInput] = (0, import_react14.useState)("");
-  const [selectedAsset, setSelectedAsset] = (0, import_react14.useState)(
+  const [amountInput, setAmountInput] = (0, import_react15.useState)("");
+  const [selectedAsset, setSelectedAsset] = (0, import_react15.useState)(
     ONDO_SUPPORTED_INPUT_ASSETS[0]
   );
-  const [error, setError] = (0, import_react14.useState)(null);
-  const [phase, setPhase] = (0, import_react14.useState)(null);
-  const preparationIdRef = (0, import_react14.useRef)(0);
+  const [error, setError] = (0, import_react15.useState)(null);
+  const [phase, setPhase] = (0, import_react15.useState)(null);
+  const preparationIdRef = (0, import_react15.useRef)(0);
   const isActive = stepInput.type === "active";
   const networkName = getNetworkName(chain);
   const marketClosed = isActive && stepInput.tradingStatus?.type === "not-tradable";
@@ -7047,7 +7572,7 @@ function useOndoAmountViewModel({
     assets: ONDO_SUPPORTED_INPUT_ASSETS,
     enabled: isActive
   });
-  (0, import_react14.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     if (stepInput.type === "incomplete") {
       ++preparationIdRef.current;
       setAmountInput("");
@@ -7325,10 +7850,10 @@ function toInputAssetUi({
 }
 
 // src/client/hooks/checkout/ondo/buy/review/useOndoReviewViewModel.ts
-var import_react17 = require("react");
+var import_react18 = require("react");
 
 // src/client/hooks/checkout/ondo/shared/data/useOndoSwapTransaction.ts
-var import_react15 = require("react");
+var import_react16 = require("react");
 
 // src/client/hooks/checkout/ondo/shared/data/ondo-load-error.ts
 function ondoLoadErrorReason(error) {
@@ -7339,7 +7864,8 @@ function ondoLoadErrorReason(error) {
 function useOndoSwapTransaction(options) {
   const { request, data, enabled } = options;
   const { coinlist, isReady } = useCoinList();
-  const [state, setState] = (0, import_react15.useState)(
+  const log = useLogger("useOndoSwapTransaction");
+  const [state, setState] = (0, import_react16.useState)(
     () => data === void 0 ? { type: "LOADING" } : {
       type: "CONTENT",
       transaction: data,
@@ -7347,12 +7873,12 @@ function useOndoSwapTransaction(options) {
       refreshError: null
     }
   );
-  const fetchIdRef = (0, import_react15.useRef)(0);
-  const isFetchingRef = (0, import_react15.useRef)(false);
+  const fetchIdRef = (0, import_react16.useRef)(0);
+  const isFetchingRef = (0, import_react16.useRef)(false);
   const requestKey = request === null ? null : stableKey(request);
-  const requestRef = (0, import_react15.useRef)(request);
+  const requestRef = (0, import_react16.useRef)(request);
   requestRef.current = request;
-  const build = (0, import_react15.useCallback)(async () => {
+  const build = (0, import_react16.useCallback)(async () => {
     const params = requestRef.current;
     if (!isReady || !enabled || params === null) return;
     if (isFetchingRef.current) return;
@@ -7364,6 +7890,10 @@ function useOndoSwapTransaction(options) {
     try {
       const transaction = await coinlist.ondo.buildSwapTransaction(params);
       if (currentFetchId !== fetchIdRef.current) return;
+      log.debug(() => ({
+        msg: "settled",
+        fields: { state: "CONTENT" }
+      }));
       setState({
         type: "CONTENT",
         transaction,
@@ -7373,14 +7903,18 @@ function useOndoSwapTransaction(options) {
     } catch (error) {
       if (currentFetchId !== fetchIdRef.current) return;
       const reason = ondoLoadErrorReason(error);
+      log.failure(
+        () => ({ msg: "settled", fields: { state: "ERROR", reason } }),
+        error
+      );
       setState(
         (previous) => previous.type === "CONTENT" ? { ...previous, isRefreshing: false, refreshError: reason } : { type: "ERROR", reason }
       );
     } finally {
       isFetchingRef.current = false;
     }
-  }, [coinlist, isReady, enabled]);
-  (0, import_react15.useEffect)(() => {
+  }, [coinlist, isReady, enabled, log]);
+  (0, import_react16.useEffect)(() => {
     if (data === void 0) return;
     ++fetchIdRef.current;
     setState({
@@ -7391,14 +7925,14 @@ function useOndoSwapTransaction(options) {
     });
   }, [data]);
   const hasSeed = data !== void 0;
-  (0, import_react15.useEffect)(() => {
+  (0, import_react16.useEffect)(() => {
     if (hasSeed || requestKey === null) return;
     build();
     return () => {
       ++fetchIdRef.current;
     };
   }, [build, requestKey, hasSeed]);
-  const refetch = (0, import_react15.useCallback)(() => {
+  const refetch = (0, import_react16.useCallback)(() => {
     build();
   }, [build]);
   return { state, refetch };
@@ -7414,7 +7948,7 @@ function stableKey(request) {
 }
 
 // src/client/ui/hooks/useCountdown.ts
-var import_react16 = require("react");
+var import_react17 = require("react");
 var DEFAULT_TICK_MS = 1e3;
 function useCountdown({
   until,
@@ -7422,8 +7956,8 @@ function useCountdown({
   enabled = true
 }) {
   const untilMs = until?.getTime() ?? null;
-  const [, tick] = (0, import_react16.useReducer)(nextTick, 0);
-  (0, import_react16.useEffect)(() => {
+  const [, tick] = (0, import_react17.useReducer)(nextTick, 0);
+  (0, import_react17.useEffect)(() => {
     if (untilMs === null || !enabled || remainingSeconds(untilMs) === 0) return;
     const interval = setInterval(() => {
       tick();
@@ -7451,8 +7985,8 @@ function useOndoReviewViewModel({
 }) {
   const { coinlist } = useCoinList();
   const locale = useLocale();
-  const [phase, setPhase] = (0, import_react17.useState)(null);
-  const [error, setError] = (0, import_react17.useState)(null);
+  const [phase, setPhase] = (0, import_react18.useState)(null);
+  const [error, setError] = (0, import_react18.useState)(null);
   const isActive = stepInput.type === "active";
   const { state: transactionState, refetch } = useOndoSwapTransaction({
     request: isActive ? {
@@ -7464,7 +7998,7 @@ function useOndoReviewViewModel({
     data: isActive ? stepInput.transaction : void 0,
     enabled: isActive
   });
-  (0, import_react17.useEffect)(() => {
+  (0, import_react18.useEffect)(() => {
     if (stepInput.type === "incomplete") setError(null);
   }, [stepInput.type]);
   const transaction = transactionState.type === "CONTENT" ? transactionState.transaction : null;
@@ -7708,7 +8242,7 @@ function toMarketUi(state) {
 }
 
 // src/client/hooks/checkout/ondo/buy/wallet/useOndoWalletSelectViewModel.ts
-var import_react18 = require("react");
+var import_react19 = require("react");
 var CONNECT_FAILED = "Could not connect that wallet. Please try again.";
 function useOndoWalletSelectViewModel({
   stepInput,
@@ -7717,8 +8251,9 @@ function useOndoWalletSelectViewModel({
   onComplete,
   onEdit
 }) {
-  const [selected, setSelected] = (0, import_react18.useState)(null);
-  const [error, setError] = (0, import_react18.useState)(null);
+  const log = useLogger("useOndoWalletSelectViewModel");
+  const [selected, setSelected] = (0, import_react19.useState)(null);
+  const [error, setError] = (0, import_react19.useState)(null);
   const networkName = getNetworkName(chain);
   const selectedWallet = resolveWallet(wallets, selected);
   const uiState = () => {
@@ -7761,7 +8296,11 @@ function useOndoWalletSelectViewModel({
     setError(null);
     try {
       await wallets.connectExternal();
-    } catch {
+    } catch (error2) {
+      log.failure(
+        () => ({ msg: "the host connectExternal handler threw" }),
+        error2
+      );
       setError(CONNECT_FAILED);
       return;
     }
@@ -7844,7 +8383,7 @@ function toConfirmedWalletUi(wallets, wallet) {
 }
 
 // src/client/hooks/checkout/ondo/shared/data/useOndoPrice.ts
-var import_react19 = require("react");
+var import_react20 = require("react");
 var LOADING = { type: "LOADING" };
 function useOndoPrice(options) {
   const {
@@ -7856,13 +8395,15 @@ function useOndoPrice(options) {
     enabled
   } = options;
   const { coinlist, isReady } = useCoinList();
-  const [state, setState] = (0, import_react19.useState)(
+  const log = useLogger("useOndoPrice");
+  const [state, setState] = (0, import_react20.useState)(
     () => data === void 0 ? LOADING : { type: "CONTENT", quote: data, isRefreshing: false }
   );
-  const fetchIdRef = (0, import_react19.useRef)(0);
-  const isFetchingRef = (0, import_react19.useRef)(false);
+  const fetchIdRef = (0, import_react20.useRef)(0);
+  const isFetchingRef = (0, import_react20.useRef)(false);
+  const hasQuoteRef = (0, import_react20.useRef)(data !== void 0);
   const sizeKey = quoteSizeKey(size);
-  (0, import_react19.useEffect)(() => {
+  (0, import_react20.useEffect)(() => {
     if (!isReady || !enabled) return;
     const size2 = quoteSizeFromKey(sizeKey);
     const currentFetchId = ++fetchIdRef.current;
@@ -7876,11 +8417,31 @@ function useOndoPrice(options) {
       try {
         const quote = await coinlist.ondo.getQuote({ symbol, side, ...size2 });
         if (currentFetchId !== fetchIdRef.current) return;
+        log.debug(() => ({
+          msg: "settled",
+          fields: { state: "CONTENT" }
+        }));
+        hasQuoteRef.current = true;
         setState({ type: "CONTENT", quote, isRefreshing: false });
       } catch (error) {
         if (currentFetchId !== fetchIdRef.current) return;
+        const reason = ondoLoadErrorReason(error);
+        if (hasQuoteRef.current) {
+          log.warning(
+            () => ({
+              msg: "poll failed; keeping the last quote",
+              fields: { reason }
+            }),
+            error
+          );
+        } else {
+          log.failure(
+            () => ({ msg: "settled", fields: { state: "ERROR", reason } }),
+            error
+          );
+        }
         setState(
-          (previous) => previous.type === "CONTENT" ? { ...previous, isRefreshing: false } : { type: "ERROR", reason: ondoLoadErrorReason(error) }
+          (previous) => previous.type === "CONTENT" ? { ...previous, isRefreshing: false } : { type: "ERROR", reason }
         );
       } finally {
         if (currentFetchId === fetchIdRef.current) {
@@ -7894,7 +8455,7 @@ function useOndoPrice(options) {
       clearInterval(interval);
       ++fetchIdRef.current;
     };
-  }, [coinlist, isReady, enabled, symbol, side, sizeKey, pollIntervalMs]);
+  }, [coinlist, isReady, enabled, symbol, side, sizeKey, pollIntervalMs, log]);
   return { state };
 }
 function quoteSizeKey(size) {
@@ -7915,7 +8476,7 @@ function quoteSizeFromKey(key) {
 }
 
 // src/client/hooks/checkout/ondo/shared/data/useOndoTradingStatus.ts
-var import_react20 = require("react");
+var import_react21 = require("react");
 var LOADING2 = { type: "LOADING" };
 function useOndoTradingStatus(options) {
   const {
@@ -7926,12 +8487,14 @@ function useOndoTradingStatus(options) {
     enabled
   } = options;
   const { coinlist, isReady } = useCoinList();
-  const [state, setState] = (0, import_react20.useState)(
+  const log = useLogger("useOndoTradingStatus");
+  const [state, setState] = (0, import_react21.useState)(
     () => data === void 0 ? LOADING2 : { type: "CONTENT", status: data }
   );
-  const fetchIdRef = (0, import_react20.useRef)(0);
-  const isFetchingRef = (0, import_react20.useRef)(false);
-  (0, import_react20.useEffect)(() => {
+  const fetchIdRef = (0, import_react21.useRef)(0);
+  const isFetchingRef = (0, import_react21.useRef)(false);
+  const hasStatusRef = (0, import_react21.useRef)(data !== void 0);
+  (0, import_react21.useEffect)(() => {
     if (!isReady || !enabled) return;
     const currentFetchId = ++fetchIdRef.current;
     isFetchingRef.current = false;
@@ -7941,11 +8504,31 @@ function useOndoTradingStatus(options) {
       try {
         const status = await coinlist.ondo.getTradingStatus({ symbol, side });
         if (currentFetchId !== fetchIdRef.current) return;
+        log.debug(() => ({
+          msg: "settled",
+          fields: { state: "CONTENT", status: status.type }
+        }));
+        hasStatusRef.current = true;
         setState({ type: "CONTENT", status });
       } catch (error) {
         if (currentFetchId !== fetchIdRef.current) return;
+        const reason = ondoLoadErrorReason(error);
+        if (hasStatusRef.current) {
+          log.warning(
+            () => ({
+              msg: "poll failed; keeping the last status",
+              fields: { reason }
+            }),
+            error
+          );
+        } else {
+          log.failure(
+            () => ({ msg: "settled", fields: { state: "ERROR", reason } }),
+            error
+          );
+        }
         setState(
-          (previous) => previous.type === "CONTENT" ? previous : { type: "ERROR", reason: ondoLoadErrorReason(error) }
+          (previous) => previous.type === "CONTENT" ? previous : { type: "ERROR", reason }
         );
       } finally {
         if (currentFetchId === fetchIdRef.current) {
@@ -7959,7 +8542,7 @@ function useOndoTradingStatus(options) {
       clearInterval(interval);
       ++fetchIdRef.current;
     };
-  }, [coinlist, isReady, enabled, symbol, side, pollIntervalMs]);
+  }, [coinlist, isReady, enabled, symbol, side, pollIntervalMs, log]);
   return { state };
 }
 
@@ -7973,8 +8556,8 @@ function useOndoBuyCheckoutViewModel({
   onOrderConfirmed
 }) {
   const locale = useLocale();
-  const [step, setStep] = (0, import_react21.useState)({ type: "wallet" });
-  const [orderConfirmed, setOrderConfirmed] = (0, import_react21.useState)({ type: "hidden" });
+  const [step, setStep] = (0, import_react22.useState)({ type: "wallet" });
+  const [orderConfirmed, setOrderConfirmed] = (0, import_react22.useState)({ type: "hidden" });
   const { state: priceState } = useOndoPrice({
     symbol: ondoSymbol,
     side: "buy",
@@ -8161,10 +8744,10 @@ function toOrderConfirmedUi({
 }
 
 // src/client/hooks/checkout/superstate/swap/useSuperstateSwapCheckoutViewModel.ts
-var import_react27 = require("react");
+var import_react28 = require("react");
 
 // src/client/hooks/checkout/superstate/swap/amount/useSuperstateAmountViewModel.ts
-var import_react22 = require("react");
+var import_react23 = require("react");
 var NO_WALLET2 = EvmWalletAddress(
   "0x0000000000000000000000000000000000000000"
 );
@@ -8178,11 +8761,11 @@ function useSuperstateAmountViewModel({
   enabled = true
 }) {
   const locale = useLocale();
-  const [amountInput, setAmountInput] = (0, import_react22.useState)("");
-  const [selectedAsset, setSelectedAsset] = (0, import_react22.useState)(
+  const [amountInput, setAmountInput] = (0, import_react23.useState)("");
+  const [selectedAsset, setSelectedAsset] = (0, import_react23.useState)(
     SUPERSTATE_SUPPORTED_INPUT_ASSETS[0]
   );
-  const [error, setError] = (0, import_react22.useState)(null);
+  const [error, setError] = (0, import_react23.useState)(null);
   const isActive = stepInput.type === "active";
   const networkName = getNetworkName(chain);
   const { balances, isLoading: balancesLoading } = useErc20TokenBalances({
@@ -8195,7 +8778,7 @@ function useSuperstateAmountViewModel({
     // on this step satisfies the first and not the second.
     enabled: enabled && isActive
   });
-  (0, import_react22.useEffect)(() => {
+  (0, import_react23.useEffect)(() => {
     if (stepInput.type === "incomplete") {
       setAmountInput("");
       setSelectedAsset(SUPERSTATE_SUPPORTED_INPUT_ASSETS[0]);
@@ -8366,19 +8949,20 @@ function toInputAssetUi2({
 }
 
 // src/client/hooks/checkout/superstate/swap/data/useSwapOutputToken.ts
-var import_react23 = require("react");
+var import_react24 = require("react");
 var LOADING_STATE = { type: "LOADING" };
 function useSwapOutputToken(options) {
   const { contractAddress, chain, enabled } = options;
   const { coinlist, isReady } = useCoinList();
-  const [outputTokenState, setOutputTokenState] = (0, import_react23.useState)(LOADING_STATE);
-  const [retryCount, setRetryCount] = (0, import_react23.useState)(0);
-  const fetchIdRef = (0, import_react23.useRef)(0);
-  const refetch = (0, import_react23.useCallback)(() => {
+  const log = useLogger("useSwapOutputToken");
+  const [outputTokenState, setOutputTokenState] = (0, import_react24.useState)(LOADING_STATE);
+  const [retryCount, setRetryCount] = (0, import_react24.useState)(0);
+  const fetchIdRef = (0, import_react24.useRef)(0);
+  const refetch = (0, import_react24.useCallback)(() => {
     setOutputTokenState(LOADING_STATE);
     setRetryCount((count) => count + 1);
   }, []);
-  (0, import_react23.useEffect)(() => {
+  (0, import_react24.useEffect)(() => {
     if (!enabled || !isReady) return;
     const currentFetchId = ++fetchIdRef.current;
     const load = async () => {
@@ -8388,9 +8972,17 @@ function useSwapOutputToken(options) {
           chain
         });
         if (currentFetchId !== fetchIdRef.current) return;
+        log.debug(() => ({
+          msg: "settled",
+          fields: { state: "CONTENT", symbol: outputToken.symbol }
+        }));
         setOutputTokenState({ type: "CONTENT", outputToken });
-      } catch {
+      } catch (error) {
         if (currentFetchId !== fetchIdRef.current) return;
+        log.failure(
+          () => ({ msg: "settled", fields: { state: "ERROR" } }),
+          error
+        );
         setOutputTokenState({ type: "ERROR" });
       }
     };
@@ -8398,12 +8990,12 @@ function useSwapOutputToken(options) {
     return () => {
       ++fetchIdRef.current;
     };
-  }, [coinlist, isReady, contractAddress, chain, enabled, retryCount]);
+  }, [coinlist, isReady, contractAddress, chain, enabled, retryCount, log]);
   return { outputTokenState, refetch };
 }
 
 // src/client/hooks/checkout/superstate/swap/data/useSwapQuote.ts
-var import_react24 = require("react");
+var import_react25 = require("react");
 function useSwapQuote(options) {
   const {
     contractAddress,
@@ -8415,13 +9007,14 @@ function useSwapQuote(options) {
     enabled
   } = options;
   const { coinlist, isReady } = useCoinList();
-  const [quote, setQuote] = (0, import_react24.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react24.useState)(true);
-  const [isRefreshing, setIsRefreshing] = (0, import_react24.useState)(false);
-  const isFetchingRef = (0, import_react24.useRef)(false);
-  const hasQuoteRef = (0, import_react24.useRef)(false);
-  const fetchIdRef = (0, import_react24.useRef)(0);
-  (0, import_react24.useEffect)(() => {
+  const log = useLogger("useSwapQuote");
+  const [quote, setQuote] = (0, import_react25.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react25.useState)(true);
+  const [isRefreshing, setIsRefreshing] = (0, import_react25.useState)(false);
+  const isFetchingRef = (0, import_react25.useRef)(false);
+  const hasQuoteRef = (0, import_react25.useRef)(false);
+  const fetchIdRef = (0, import_react25.useRef)(0);
+  (0, import_react25.useEffect)(() => {
     if (!isReady) return;
     if (!enabled) {
       setIsLoading(false);
@@ -8455,7 +9048,11 @@ function useSwapQuote(options) {
           hasQuoteRef.current = true;
           setIsLoading(false);
         }
-      } catch {
+      } catch (error) {
+        log.warning(
+          () => ({ msg: "poll failed; retrying on the next tick" }),
+          error
+        );
       } finally {
         if (currentFetchId === fetchIdRef.current) {
           isFetchingRef.current = false;
@@ -8480,13 +9077,14 @@ function useSwapQuote(options) {
     inputTokenAddress,
     outputTokenDecimals,
     pollIntervalMs,
-    enabled
+    enabled,
+    log
   ]);
   return { quote, isLoading, isRefreshing };
 }
 
 // src/client/hooks/checkout/superstate/swap/review/useSuperstateReviewViewModel.ts
-var import_react25 = require("react");
+var import_react26 = require("react");
 function useSuperstateReviewViewModel({
   stepInput,
   contractAddress,
@@ -8496,11 +9094,11 @@ function useSuperstateReviewViewModel({
 }) {
   const { coinlist, isReady } = useCoinList();
   const locale = useLocale();
-  const [slippageBps, setSlippageBps] = (0, import_react25.useState)(DEFAULT_SLIPPAGE_BPS);
-  const [slippageExpanded, setSlippageExpanded] = (0, import_react25.useState)(false);
-  const [phase, setPhase] = (0, import_react25.useState)(null);
-  const [error, setError] = (0, import_react25.useState)(null);
-  (0, import_react25.useEffect)(() => {
+  const [slippageBps, setSlippageBps] = (0, import_react26.useState)(DEFAULT_SLIPPAGE_BPS);
+  const [slippageExpanded, setSlippageExpanded] = (0, import_react26.useState)(false);
+  const [phase, setPhase] = (0, import_react26.useState)(null);
+  const [error, setError] = (0, import_react26.useState)(null);
+  (0, import_react26.useEffect)(() => {
     if (stepInput.type === "incomplete") {
       setSlippageBps(DEFAULT_SLIPPAGE_BPS);
       setSlippageExpanded(false);
@@ -8817,7 +9415,7 @@ function priceUi(quote, outputToken, locale) {
 }
 
 // src/client/hooks/checkout/superstate/swap/wallet/useSuperstateWalletViewModel.ts
-var import_react26 = require("react");
+var import_react27 = require("react");
 var CONNECT_FAILED2 = "Could not connect that wallet. Please try again.";
 function useSuperstateWalletViewModel({
   stepInput,
@@ -8829,12 +9427,13 @@ function useSuperstateWalletViewModel({
   onEdit
 }) {
   const { coinlist, isReady } = useCoinList();
-  const [selected, setSelected] = (0, import_react26.useState)(null);
-  const [phase, setPhase] = (0, import_react26.useState)(null);
-  const [error, setError] = (0, import_react26.useState)(null);
+  const log = useLogger("useSuperstateWalletViewModel");
+  const [selected, setSelected] = (0, import_react27.useState)(null);
+  const [phase, setPhase] = (0, import_react27.useState)(null);
+  const [error, setError] = (0, import_react27.useState)(null);
   const networkName = getNetworkName(chain);
   const selectedWallet = resolveWallet2(wallets, selected);
-  (0, import_react26.useEffect)(() => {
+  (0, import_react27.useEffect)(() => {
     if (stepInput.type === "completed") {
       setPhase(null);
       setError(null);
@@ -8909,7 +9508,11 @@ function useSuperstateWalletViewModel({
     setError(null);
     try {
       await wallets.connectExternal();
-    } catch {
+    } catch (error2) {
+      log.failure(
+        () => ({ msg: "the host connectExternal handler threw" }),
+        error2
+      );
       setError(CONNECT_FAILED2);
       return;
     }
@@ -9050,8 +9653,8 @@ function useSuperstateSwapCheckoutViewModel({
   const locale = useLocale();
   const contractAddress = superstateSwapContractAddress(chain);
   const assetIconUrl = offerIconUrl(offer);
-  const [step, setStep] = (0, import_react27.useState)({ type: "wallet" });
-  const [orderConfirmed, setOrderConfirmed] = (0, import_react27.useState)({ type: "hidden" });
+  const [step, setStep] = (0, import_react28.useState)({ type: "wallet" });
+  const [orderConfirmed, setOrderConfirmed] = (0, import_react28.useState)({ type: "hidden" });
   const live = enabled && contractAddress !== null;
   const contract = contractAddress ?? NO_CONTRACT;
   const { outputTokenState, refetch: refetchOutputToken } = useSwapOutputToken({
@@ -9606,18 +10209,19 @@ function EmptyState() {
 }
 
 // src/client/hooks/offers/grid/useOffersGridViewModel.ts
-var import_react29 = require("react");
+var import_react30 = require("react");
 
 // src/client/hooks/offers/data/useOffers.ts
-var import_react28 = require("react");
+var import_react29 = require("react");
 var LOADING_STATE2 = { type: "LOADING" };
 function useOffers(options = {}) {
   const { coinlist, isReady } = useCoinList();
+  const log = useLogger("useOffers");
   const { data: serverOffers } = options;
-  const [offersState, setOffersState] = (0, import_react28.useState)(
+  const [offersState, setOffersState] = (0, import_react29.useState)(
     serverOffers !== void 0 ? { type: "CONTENT", offers: serverOffers } : LOADING_STATE2
   );
-  (0, import_react28.useEffect)(() => {
+  (0, import_react29.useEffect)(() => {
     let isCancelled = false;
     if (!isReady) {
       if (serverOffers === void 0) {
@@ -9635,18 +10239,26 @@ function useOffers(options = {}) {
     setOffersState(LOADING_STATE2);
     coinlist.offers.list().then((offers) => {
       if (!isCancelled) {
+        log.debug(() => ({
+          msg: "settled",
+          fields: { state: "CONTENT", count: offers.length }
+        }));
         setOffersState({ type: "CONTENT", offers });
       }
     }).catch((error) => {
       if (!isCancelled) {
         const reason = error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+        log.failure(
+          () => ({ msg: "settled", fields: { state: "ERROR", reason } }),
+          error
+        );
         setOffersState({ type: "ERROR", reason });
       }
     });
     return () => {
       isCancelled = true;
     };
-  }, [coinlist, isReady, serverOffers]);
+  }, [coinlist, isReady, serverOffers, log]);
   return { offersState };
 }
 
@@ -9678,11 +10290,11 @@ function useOffersGridViewModel(options = {}) {
   const { data, onOfferClick } = options;
   const { offersState } = useOffers({ data });
   const locale = useLocale();
-  const state = (0, import_react29.useMemo)(
+  const state = (0, import_react30.useMemo)(
     () => toUiState(offersState, locale, onOfferClick !== void 0),
     [offersState, locale, onOfferClick]
   );
-  const onEvent = (0, import_react29.useCallback)(
+  const onEvent = (0, import_react30.useCallback)(
     (event) => {
       switch (event.type) {
         case "ON_OFFER_CLICK": {
@@ -9745,13 +10357,13 @@ function OffersGridContainer({
 }
 
 // src/client/components/requirements/checklist/ConnectedWalletList.tsx
-var import_react30 = require("react");
+var import_react31 = require("react");
 var import_jsx_runtime48 = require("react/jsx-runtime");
 function ConnectedWalletRow({
   wallet,
   onRemove
 }) {
-  const [state, setState] = (0, import_react30.useState)("idle");
+  const [state, setState] = (0, import_react31.useState)("idle");
   const remove = async () => {
     if (!onRemove) return;
     setState("removing");
@@ -10321,23 +10933,24 @@ function toError(error) {
 }
 
 // src/client/hooks/requirements/identity-verification/useIdentityVerificationViewModel.ts
-var import_react32 = require("react");
+var import_react33 = require("react");
 
 // src/client/hooks/requirements/data/useKycToken.ts
-var import_react31 = require("react");
+var import_react32 = require("react");
 var IDLE_STATE = { type: "IDLE" };
 var LOADING_STATE3 = { type: "LOADING" };
 function useKycToken(levelName, reset) {
   const { coinlist } = useCoinList();
-  const [kycTokenState, setKycTokenState] = (0, import_react31.useState)(IDLE_STATE);
-  const resetPendingRef = (0, import_react31.useRef)(reset === true);
-  const tokenIssuedRef = (0, import_react31.useRef)(false);
-  (0, import_react31.useEffect)(() => {
+  const log = useLogger("useKycToken");
+  const [kycTokenState, setKycTokenState] = (0, import_react32.useState)(IDLE_STATE);
+  const resetPendingRef = (0, import_react32.useRef)(reset === true);
+  const tokenIssuedRef = (0, import_react32.useRef)(false);
+  (0, import_react32.useEffect)(() => {
     if (!tokenIssuedRef.current) {
       resetPendingRef.current = reset === true;
     }
   }, [reset]);
-  const fetchToken = (0, import_react31.useCallback)(async () => {
+  const fetchToken = (0, import_react32.useCallback)(async () => {
     setKycTokenState(LOADING_STATE3);
     try {
       const kycToken = await coinlist.requirements.createKycToken({
@@ -10346,14 +10959,22 @@ function useKycToken(levelName, reset) {
       });
       resetPendingRef.current = false;
       tokenIssuedRef.current = true;
+      log.debug(() => ({
+        msg: "settled",
+        fields: { state: "CONTENT" }
+      }));
       setKycTokenState({ type: "CONTENT", token: kycToken.token });
       return kycToken.token;
     } catch (error) {
       const reason = error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+      log.failure(
+        () => ({ msg: "settled", fields: { state: "ERROR", reason } }),
+        error
+      );
       setKycTokenState({ type: "ERROR", reason });
       throw error;
     }
-  }, [coinlist, levelName]);
+  }, [coinlist, levelName, log]);
   return { kycTokenState, fetchToken };
 }
 
@@ -10363,8 +10984,8 @@ var GENERIC_ERROR_MESSAGE2 = "Unable to start identity verification right now. P
 function useIdentityVerificationViewModel(options = {}) {
   const { levelName, reset, locale, onSubmitted, onError } = options;
   const { kycTokenState, fetchToken } = useKycToken(levelName, reset);
-  const fetchedRef = (0, import_react32.useRef)(false);
-  (0, import_react32.useEffect)(() => {
+  const fetchedRef = (0, import_react33.useRef)(false);
+  (0, import_react33.useEffect)(() => {
     if (fetchedRef.current) {
       return;
     }
@@ -10372,7 +10993,7 @@ function useIdentityVerificationViewModel(options = {}) {
     fetchToken().catch(() => {
     });
   }, [fetchToken]);
-  const state = (0, import_react32.useMemo)(() => {
+  const state = (0, import_react33.useMemo)(() => {
     switch (kycTokenState.type) {
       case "IDLE":
       case "LOADING":
@@ -10398,7 +11019,7 @@ function useIdentityVerificationViewModel(options = {}) {
       }
     }
   }, [kycTokenState, locale, fetchToken]);
-  const onEvent = (0, import_react32.useCallback)(
+  const onEvent = (0, import_react33.useCallback)(
     (event) => {
       switch (event.type) {
         case "ON_RETRY":
@@ -10660,10 +11281,10 @@ function SignOnlyScreen({
 }
 
 // src/client/hooks/requirements/tax-document/useTaxDocumentModalViewModel.ts
-var import_react34 = require("react");
+var import_react35 = require("react");
 
 // src/client/hooks/requirements/data/useTaxDocument.ts
-var import_react33 = require("react");
+var import_react34 = require("react");
 var IDLE_SIGN = { type: "idle", error: null };
 var LOADING_STATE4 = { type: "LOADING" };
 var SIGN_FAILED_MESSAGE = "Unable to sign document. Please try again.";
@@ -10737,8 +11358,9 @@ function useTaxDocument({
   isOpen
 }) {
   const { coinlist, isReady } = useCoinList();
-  const [state, setState] = (0, import_react33.useState)(LOADING_STATE4);
-  (0, import_react33.useEffect)(() => {
+  const log = useLogger("useTaxDocument");
+  const [state, setState] = (0, import_react34.useState)(LOADING_STATE4);
+  (0, import_react34.useEffect)(() => {
     let isCancelled = false;
     if (!isOpen) {
       return () => {
@@ -10768,16 +11390,18 @@ function useTaxDocument({
       });
     }).catch((error) => {
       if (isCancelled) return;
-      setState({
-        type: "ERROR",
-        reason: error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error"
-      });
+      const reason = error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+      log.failure(
+        () => ({ msg: "settled", fields: { state: "ERROR", reason } }),
+        error
+      );
+      setState({ type: "ERROR", reason });
     });
     return () => {
       isCancelled = true;
     };
-  }, [coinlist, isReady, isOpen]);
-  const onEditField = (0, import_react33.useCallback)(
+  }, [coinlist, isReady, isOpen, log]);
+  const onEditField = (0, import_react34.useCallback)(
     (field, value) => {
       setState(
         (prev) => prev.type === "EDITING" ? { ...prev, fields: { ...prev.fields, [field]: value } } : prev
@@ -10785,7 +11409,7 @@ function useTaxDocument({
     },
     []
   );
-  const onStartEdit = (0, import_react33.useCallback)(() => {
+  const onStartEdit = (0, import_react34.useCallback)(() => {
     setState(
       (prev) => prev.type === "REVIEW" ? {
         type: "EDITING",
@@ -10796,7 +11420,7 @@ function useTaxDocument({
       } : prev
     );
   }, []);
-  const onSaveEdit = (0, import_react33.useCallback)(() => {
+  const onSaveEdit = (0, import_react34.useCallback)(() => {
     setState(
       (prev) => prev.type === "EDITING" ? {
         type: "REVIEW",
@@ -10807,7 +11431,7 @@ function useTaxDocument({
       } : prev
     );
   }, []);
-  const onCancelEdit = (0, import_react33.useCallback)(() => {
+  const onCancelEdit = (0, import_react34.useCallback)(() => {
     setState(
       (prev) => prev.type === "EDITING" ? {
         type: "REVIEW",
@@ -10818,7 +11442,7 @@ function useTaxDocument({
       } : prev
     );
   }, []);
-  const onSign = (0, import_react33.useCallback)(() => {
+  const onSign = (0, import_react34.useCallback)(() => {
     if (state.type !== "REVIEW" && state.type !== "SIGN_ONLY") return;
     if (state.type === "REVIEW" && state.fields.dob.trim() !== "" && !isValidUsDate(state.fields.dob)) {
       setState({
@@ -10833,12 +11457,13 @@ function useTaxDocument({
       fields: state.type === "REVIEW" ? toSubmissionFields(state.fields, state.addressParts) : {}
     }).then((submission) => {
       setState({ type: "SUBMITTED", submission });
-    }).catch(() => {
+    }).catch((error) => {
+      log.failure(() => ({ msg: "signing the tax document failed" }), error);
       setState(
         (prev) => prev.type === "REVIEW" || prev.type === "SIGN_ONLY" ? { ...prev, sign: { type: "idle", error: SIGN_FAILED_MESSAGE } } : prev
       );
     });
-  }, [state, coinlist]);
+  }, [state, coinlist, log]);
   return { state, onEditField, onStartEdit, onSaveEdit, onCancelEdit, onSign };
 }
 
@@ -10859,19 +11484,19 @@ function useTaxDocumentModalViewModel({
   onSubmitted
 }) {
   const { state, onEditField, onStartEdit, onSaveEdit, onCancelEdit, onSign } = useTaxDocument({ isOpen });
-  (0, import_react34.useEffect)(() => {
+  (0, import_react35.useEffect)(() => {
     if (state.type === "SUBMITTED") {
       onSubmitted?.(state.submission);
       onClose();
     }
   }, [state]);
-  const uiState = (0, import_react34.useMemo)(() => {
+  const uiState = (0, import_react35.useMemo)(() => {
     if (!isOpen || state.type === "SUBMITTED") {
       return { type: "hidden" };
     }
     return { type: "content", title: toTitle(state), screen: toScreen(state) };
   }, [isOpen, state]);
-  const onEvent = (0, import_react34.useCallback)(
+  const onEvent = (0, import_react35.useCallback)(
     (event) => {
       switch (event.type) {
         case "ON_CLOSE":
@@ -10977,14 +11602,14 @@ function TaxDocumentModalContainer({
 }
 
 // src/client/components/requirements/wallet/ConnectWalletModalView.tsx
-var import_react35 = require("react");
+var import_react36 = require("react");
 var import_jsx_runtime57 = require("react/jsx-runtime");
 function ConnectWalletModalView({
   state,
   onEvent,
   className
 }) {
-  const titleId = (0, import_react35.useId)();
+  const titleId = (0, import_react36.useId)();
   if (state.type === "hidden") {
     return null;
   }
@@ -11087,10 +11712,10 @@ function Screen2({
 }
 
 // src/client/hooks/requirements/wallet/useConnectWalletModalViewModel.ts
-var import_react37 = require("react");
+var import_react38 = require("react");
 
 // src/client/hooks/requirements/data/useConnectWallet.ts
-var import_react36 = require("react");
+var import_react37 = require("react");
 
 // src/client/core/wallets/connect-external-wallet.ts
 var DEFAULT_STATEMENT = "Sign this message to prove you own this wallet. This does not cost gas or move funds.";
@@ -11158,9 +11783,9 @@ async function connectExternalWalletFlow(params) {
     isCancelled,
     onProgress
   } = params;
-  const emit = (phase) => onProgress?.(phase);
+  const emit2 = (phase) => onProgress?.(phase);
   const cancelled = () => isCancelled?.() ?? false;
-  emit("requesting-challenge");
+  emit2("requesting-challenge");
   let challenge;
   try {
     challenge = await coinlist.wallets.createOwnershipChallenge(
@@ -11170,7 +11795,7 @@ async function connectExternalWalletFlow(params) {
     return { type: "error", error: classifyApiError(error) };
   }
   if (cancelled()) return { type: "cancelled" };
-  emit("signing-message");
+  emit2("signing-message");
   let signature;
   try {
     signature = await wallet.signMessage(challenge.message);
@@ -11181,7 +11806,7 @@ async function connectExternalWalletFlow(params) {
     return { type: "error", error: flowError("unknown") };
   }
   if (cancelled()) return { type: "cancelled" };
-  emit("submitting-signature");
+  emit2("submitting-signature");
   try {
     const binding = await coinlist.wallets.connectExternal({
       offerId,
@@ -11221,24 +11846,24 @@ function useConnectWallet({
   statement
 }) {
   const { coinlist } = useCoinList();
-  const [state, setState] = (0, import_react36.useState)(
+  const [state, setState] = (0, import_react37.useState)(
     () => wallet ? { type: "READY", address: wallet.address, sign: IDLE_SIGN2 } : { type: "NEEDS_WALLET" }
   );
-  const attempt = (0, import_react36.useRef)(0);
-  (0, import_react36.useEffect)(() => {
+  const attempt = (0, import_react37.useRef)(0);
+  (0, import_react37.useEffect)(() => {
     attempt.current += 1;
     if (!isOpen) return;
     setState(
       wallet ? { type: "READY", address: wallet.address, sign: IDLE_SIGN2 } : { type: "NEEDS_WALLET" }
     );
   }, [isOpen, wallet?.address]);
-  (0, import_react36.useEffect)(
+  (0, import_react37.useEffect)(
     () => () => {
       attempt.current += 1;
     },
     []
   );
-  const onSign = (0, import_react36.useCallback)(() => {
+  const onSign = (0, import_react37.useCallback)(() => {
     if (!wallet || state.type !== "READY") return;
     attempt.current += 1;
     const gen = attempt.current;
@@ -11300,13 +11925,13 @@ function useConnectWalletModalViewModel({
     challengeType,
     statement
   });
-  (0, import_react37.useEffect)(() => {
+  (0, import_react38.useEffect)(() => {
     if (state.type === "CONNECTED") {
       onConnected?.(state.binding);
       onClose();
     }
   }, [state]);
-  const uiState = (0, import_react37.useMemo)(() => {
+  const uiState = (0, import_react38.useMemo)(() => {
     if (!isOpen || state.type === "CONNECTED") {
       return { type: "hidden" };
     }
@@ -11331,7 +11956,7 @@ function useConnectWalletModalViewModel({
       canRequestConnect
     };
   }, [isOpen, state, onRequestConnect]);
-  const onEvent = (0, import_react37.useCallback)(
+  const onEvent = (0, import_react38.useCallback)(
     (event) => {
       switch (event.type) {
         case "ON_CLOSE":
@@ -11372,7 +11997,7 @@ function ConnectWalletModalContainer({
 }
 
 // src/client/hooks/requirements/checklist/useRequirementsChecklistViewModel.ts
-var import_react40 = require("react");
+var import_react41 = require("react");
 
 // src/client/hooks/requirements/checklist/useRequirementsChecklistViewModel.types.ts
 var RequirementItemUi = {
@@ -11426,7 +12051,7 @@ var ChecklistStatus = {
 };
 
 // src/client/hooks/requirements/data/useOptionAddresses.ts
-var import_react38 = require("react");
+var import_react39 = require("react");
 var LOADING_STATE5 = { type: "LOADING" };
 var EMPTY_STATE = {
   type: "CONTENT",
@@ -11434,20 +12059,21 @@ var EMPTY_STATE = {
 };
 function useOptionAddresses(offerId, offerOptionId, options = {}) {
   const { coinlist, isReady } = useCoinList();
+  const log = useLogger("useOptionAddresses");
   const { data, enabled = true } = options;
-  const [addressesState, setAddressesState] = (0, import_react38.useState)(
+  const [addressesState, setAddressesState] = (0, import_react39.useState)(
     data !== void 0 ? { type: "CONTENT", addresses: data } : LOADING_STATE5
   );
-  const [fetchKey, setFetchKey] = (0, import_react38.useState)(0);
-  const refetch = (0, import_react38.useCallback)(() => setFetchKey((k) => k + 1), []);
-  const disconnect = (0, import_react38.useCallback)(
+  const [fetchKey, setFetchKey] = (0, import_react39.useState)(0);
+  const refetch = (0, import_react39.useCallback)(() => setFetchKey((k) => k + 1), []);
+  const disconnect = (0, import_react39.useCallback)(
     async (addressId) => {
       await coinlist.wallets.remove({ offerId, addressId });
       refetch();
     },
     [coinlist, offerId, refetch]
   );
-  (0, import_react38.useEffect)(() => {
+  (0, import_react39.useEffect)(() => {
     let isCancelled = false;
     if (!enabled) {
       setAddressesState(
@@ -11479,33 +12105,42 @@ function useOptionAddresses(offerId, offerOptionId, options = {}) {
     setAddressesState(LOADING_STATE5);
     coinlist.wallets.list({ offerId, offerOptionId }).then((addresses) => {
       if (!isCancelled) {
+        log.debug(() => ({
+          msg: "settled",
+          fields: { state: "CONTENT", count: addresses.length }
+        }));
         setAddressesState({ type: "CONTENT", addresses });
       }
     }).catch((error) => {
       if (!isCancelled) {
         const reason = error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+        log.failure(
+          () => ({ msg: "settled", fields: { state: "ERROR", reason } }),
+          error
+        );
         setAddressesState({ type: "ERROR", reason });
       }
     });
     return () => {
       isCancelled = true;
     };
-  }, [coinlist, isReady, enabled, offerId, offerOptionId, fetchKey]);
+  }, [coinlist, isReady, enabled, offerId, offerOptionId, fetchKey, log]);
   return { addressesState, refetch, disconnect };
 }
 
 // src/client/hooks/requirements/data/useRequirements.ts
-var import_react39 = require("react");
+var import_react40 = require("react");
 var LOADING_STATE6 = { type: "LOADING" };
 function useRequirements(offerId, options = {}) {
   const { coinlist, isReady } = useCoinList();
+  const log = useLogger("useRequirements");
   const { data } = options;
-  const [requirementsState, setRequirementsState] = (0, import_react39.useState)(
+  const [requirementsState, setRequirementsState] = (0, import_react40.useState)(
     data !== void 0 ? { type: "CONTENT", ...data } : LOADING_STATE6
   );
-  const [fetchKey, setFetchKey] = (0, import_react39.useState)(0);
-  const refetch = (0, import_react39.useCallback)(() => setFetchKey((k) => k + 1), []);
-  (0, import_react39.useEffect)(() => {
+  const [fetchKey, setFetchKey] = (0, import_react40.useState)(0);
+  const refetch = (0, import_react40.useCallback)(() => setFetchKey((k) => k + 1), []);
+  (0, import_react40.useEffect)(() => {
     let isCancelled = false;
     if (!isReady) {
       if (data === void 0) {
@@ -11532,6 +12167,14 @@ function useRequirements(offerId, options = {}) {
       coinlist.requirements.statuses(offerId)
     ]).then(([requirementsByOptionId, statuses]) => {
       if (!isCancelled) {
+        log.debug(() => ({
+          msg: "settled",
+          fields: {
+            state: "CONTENT",
+            options: Object.keys(requirementsByOptionId).length,
+            statuses: statuses.length
+          }
+        }));
         setRequirementsState({
           type: "CONTENT",
           requirements: requirementsByOptionId,
@@ -11541,22 +12184,23 @@ function useRequirements(offerId, options = {}) {
     }).catch((error) => {
       if (!isCancelled) {
         const reason = error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+        log.failure(
+          () => ({ msg: "settled", fields: { state: "ERROR", reason } }),
+          error
+        );
         setRequirementsState({ type: "ERROR", reason });
       }
     });
     return () => {
       isCancelled = true;
     };
-  }, [coinlist, isReady, offerId, fetchKey]);
+  }, [coinlist, isReady, offerId, fetchKey, log]);
   return { requirementsState, refetch };
 }
 
 // src/client/hooks/requirements/checklist/useRequirementsChecklistViewModel.ts
 var DEFAULT_LABELS = {
   kyc_approved: "KYC Verification",
-  identity_verified: "Identity Verification",
-  proof_of_address: "Proof of Address",
-  source_of_funds: "Source of Funds",
   external_wallet: "External Wallet",
   whitelisted_wallet: "Whitelisted Wallet",
   jurisdiction: "Jurisdiction Check",
@@ -11565,9 +12209,6 @@ var DEFAULT_LABELS = {
 };
 var DEFAULT_DESCRIPTIONS = {
   kyc_approved: "Complete Know Your Customer verification.",
-  identity_verified: "Verify your identity.",
-  proof_of_address: "Provide proof of your residential address.",
-  source_of_funds: "Provide documentation for your source of funds.",
   external_wallet: "Connect an external wallet.",
   whitelisted_wallet: "Connect a whitelisted wallet.",
   jurisdiction: "Confirm your jurisdiction eligibility.",
@@ -11596,21 +12237,22 @@ function useRequirementsChecklistViewModel(options) {
     data,
     identityVerificationOptions
   } = options;
+  const log = useLogger("useRequirementsChecklistViewModel");
   const { coinlist } = useCoinList();
   const { requirementsState, refetch } = useRequirements(offerId, { data });
-  const [expandedId, setExpandedId] = (0, import_react40.useState)(null);
-  const [taxDocumentOpen, setTaxDocumentOpen] = (0, import_react40.useState)(false);
-  const [connectWalletOpen, setConnectWalletOpen] = (0, import_react40.useState)(false);
-  const [verifyingRequirementId, setVerifyingRequirementId] = (0, import_react40.useState)(null);
-  const isMountedRef = (0, import_react40.useRef)(true);
-  (0, import_react40.useEffect)(() => {
+  const [expandedId, setExpandedId] = (0, import_react41.useState)(null);
+  const [taxDocumentOpen, setTaxDocumentOpen] = (0, import_react41.useState)(false);
+  const [connectWalletOpen, setConnectWalletOpen] = (0, import_react41.useState)(false);
+  const [verifyingRequirementId, setVerifyingRequirementId] = (0, import_react41.useState)(null);
+  const isMountedRef = (0, import_react41.useRef)(true);
+  (0, import_react41.useEffect)(() => {
     isMountedRef.current = true;
     return () => {
       isMountedRef.current = false;
     };
   }, []);
-  const [hasWalletRequirement, setHasWalletRequirement] = (0, import_react40.useState)(false);
-  (0, import_react40.useEffect)(() => {
+  const [hasWalletRequirement, setHasWalletRequirement] = (0, import_react41.useState)(false);
+  (0, import_react41.useEffect)(() => {
     if (requirementsState.type === "CONTENT") {
       setHasWalletRequirement(
         (requirementsState.requirements[optionId] ?? []).some(
@@ -11626,14 +12268,14 @@ function useRequirementsChecklistViewModel(options) {
   } = useOptionAddresses(offerId, optionId, {
     enabled: hasWalletRequirement
   });
-  const removeWallet = (0, import_react40.useCallback)(
+  const removeWallet = (0, import_react41.useCallback)(
     async (addressId) => {
       await disconnect(OfferOptionAddressId(addressId));
       refetch();
     },
     [disconnect, refetch]
   );
-  const awaitVerificationResult = (0, import_react40.useCallback)(
+  const awaitVerificationResult = (0, import_react41.useCallback)(
     (requirementId, statusBeforeSubmit) => {
       void (async () => {
         const deadline = Date.now() + VERIFICATION_POLL_TIMEOUT_MS;
@@ -11647,6 +12289,9 @@ function useRequirementsChecklistViewModel(options) {
             )?.status;
             if (current !== void 0 && current !== statusBeforeSubmit) break;
           } catch (_) {
+            log.debug(() => ({
+              msg: "status poll tick failed; retrying until deadline"
+            }));
           }
         }
         if (isMountedRef.current) {
@@ -11655,13 +12300,13 @@ function useRequirementsChecklistViewModel(options) {
         }
       })();
     },
-    [coinlist, offerId, refetch]
+    [coinlist, offerId, refetch, log]
   );
-  const requirements = (0, import_react40.useMemo)(
+  const requirements = (0, import_react41.useMemo)(
     () => requirementsState.type === "CONTENT" ? requirementsState.requirements[optionId] ?? [] : [],
     [requirementsState, optionId]
   );
-  const statusById = (0, import_react40.useMemo)(() => {
+  const statusById = (0, import_react41.useMemo)(() => {
     if (requirementsState.type !== "CONTENT") {
       return /* @__PURE__ */ new Map();
     }
@@ -11670,7 +12315,7 @@ function useRequirementsChecklistViewModel(options) {
       requirementsState.statuses.filter((s) => ids.has(s.id)).map((s) => [s.id, s])
     );
   }, [requirementsState, requirements]);
-  const state = (0, import_react40.useMemo)(() => {
+  const state = (0, import_react41.useMemo)(() => {
     switch (requirementsState.type) {
       case "LOADING":
         return { type: "loading" };
@@ -11739,7 +12384,7 @@ function useRequirementsChecklistViewModel(options) {
     identityVerificationOptions,
     removeWallet
   ]);
-  const handleRequirementAction = (0, import_react40.useCallback)(
+  const handleRequirementAction = (0, import_react41.useCallback)(
     (requirement) => {
       const inlineVerification = statusById.get(requirement.id)?.kycLevel !== void 0 && onRequirementActionOverride === void 0;
       if (inlineVerification) {
@@ -11771,7 +12416,7 @@ function useRequirementsChecklistViewModel(options) {
       coinlist
     ]
   );
-  const onEvent = (0, import_react40.useCallback)(
+  const onEvent = (0, import_react41.useCallback)(
     (event) => {
       switch (event.type) {
         case "ON_TOGGLE_ITEM":
@@ -11934,26 +12579,179 @@ function RequirementsChecklistContainer({
   ] });
 }
 
+// src/client/core/observability/pino-client-logger.ts
+var import_pino = require("pino");
+
+// src/shared/core/observability/pino-logger.ts
+function toPinoRecord(event) {
+  try {
+    const record = {};
+    for (const key of ownKeys(event.fields)) {
+      record[key] = readProperty(event.fields, key, 0, /* @__PURE__ */ new WeakSet());
+    }
+    const cause = "cause" in event ? event.cause : void 0;
+    if (cause !== void 0) {
+      record.cause = sanitize(cause, 0, /* @__PURE__ */ new WeakSet());
+    }
+    return { ...record, scope: event.scope, ...event.bindings };
+  } catch (_) {
+    return { "log.render": "<unrenderable event>" };
+  }
+}
+var PINO_LEVEL = {
+  none: "silent",
+  error: "error",
+  warn: "warn",
+  info: "info",
+  debug: "debug"
+};
+var MAX_DEPTH = 8;
+function sanitize(value, depth, seen) {
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return value;
+    case "number":
+      return Number.isFinite(value) ? value : String(value);
+    case "bigint":
+      return value.toString();
+    case "undefined":
+      return "<undefined>";
+    case "function":
+      return "<function>";
+    case "symbol":
+      return value.toString();
+    case "object":
+      return value === null ? null : sanitizeObject(value, depth, seen);
+    default:
+      return "<unrenderable>";
+  }
+}
+function sanitizeObject(value, depth, seen) {
+  if (seen.has(value)) return "<circular>";
+  if (depth >= MAX_DEPTH) return "<max depth>";
+  if (value instanceof Error) return describeError(value);
+  if (value instanceof Date) return describeDate(value);
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return value.map(
+        (_item, index) => readProperty(value, String(index), depth, seen)
+      );
+    }
+    const out = {};
+    for (const key of ownKeys(value)) {
+      out[key] = readProperty(value, key, depth, seen);
+    }
+    return out;
+  } finally {
+    seen.delete(value);
+  }
+}
+function readProperty(owner, key, depth, seen) {
+  try {
+    return sanitize(owner[key], depth + 1, seen);
+  } catch (_) {
+    return "<unreadable>";
+  }
+}
+function ownKeys(value) {
+  try {
+    return Object.keys(value);
+  } catch (_) {
+    return [];
+  }
+}
+function describeError(error) {
+  return {
+    name: safeRead(() => error.name),
+    message: safeRead(() => error.message),
+    stack: safeRead(() => error.stack)
+  };
+}
+function describeDate(date) {
+  return safeRead(() => date.toISOString());
+}
+function safeRead(read) {
+  try {
+    const value = read();
+    return typeof value === "string" ? value : "<unreadable>";
+  } catch (_) {
+    return "<unreadable>";
+  }
+}
+var SDK_LOGGER_NAME = "@coinlist-co/react";
+function loggerOverPino(sink, level) {
+  return {
+    level: () => level,
+    debug: (event) => emit(sink, "debug", event),
+    info: (event) => emit(sink, "info", event),
+    warn: (event) => emit(sink, "warn", event),
+    error: (event) => emit(sink, "error", event)
+  };
+}
+function emit(sink, method, event) {
+  try {
+    const value = event();
+    sink[method](toPinoRecord(value), value.msg);
+  } catch (error) {
+    reportRenderFailure(sink, error);
+  }
+}
+function reportRenderFailure(sink, error) {
+  try {
+    sink.error(
+      { "error.type": error instanceof Error ? error.name : typeof error },
+      "log event failed to render"
+    );
+  } catch (_) {
+  }
+}
+
+// src/client/core/observability/pino-client-logger.ts
+function pinoClientLogger(options) {
+  return loggerOverPino(
+    // `name` as a child binding rather than pino's `name` option: the option
+    // is honoured by pino's node build and silently dropped by its browser
+    // build, so a binding is the only spelling that identifies the SDK in
+    // both environments.
+    (0, import_pino.pino)({
+      level: PINO_LEVEL[options.level],
+      browser: { asObject: true }
+    }).child({ name: SDK_LOGGER_NAME }),
+    options.level
+  );
+}
+
 // src/client/hooks/auth/useCompleteOAuth.ts
-var import_react41 = require("react");
+var import_react42 = require("react");
 function useCompleteOAuth(options) {
   const { coinlist } = useCoinList();
-  const postOAuthCompleteRef = (0, import_react41.useRef)(options.postOAuthComplete);
-  const onFailureRef = (0, import_react41.useRef)(options.onFailure);
-  const onSuccessRef = (0, import_react41.useRef)(options.onSuccess);
+  const log = useLogger("useCompleteOAuth");
+  const postOAuthCompleteRef = (0, import_react42.useRef)(options.postOAuthComplete);
+  const onFailureRef = (0, import_react42.useRef)(options.onFailure);
+  const onSuccessRef = (0, import_react42.useRef)(options.onSuccess);
   postOAuthCompleteRef.current = options.postOAuthComplete;
   onFailureRef.current = options.onFailure;
   onSuccessRef.current = options.onSuccess;
-  const hasStartedExchangeRef = (0, import_react41.useRef)(false);
-  (0, import_react41.useEffect)(() => {
+  const hasStartedExchangeRef = (0, import_react42.useRef)(false);
+  (0, import_react42.useEffect)(() => {
     if (typeof window === "undefined") return;
     const params = new URLSearchParams(window.location.search);
     if (!params.has("code") && !params.has("error")) return;
     if (hasStartedExchangeRef.current) return;
     const oauthResult = coinlist.auth.completeOAuth();
     if (oauthResult.type === "error") {
+      log.error(() => ({
+        msg: "oauth callback rejected",
+        fields: { reason: oauthResult.reason }
+      }));
       void Promise.resolve(onFailureRef.current(oauthResult.reason)).catch(
-        () => {
+        (error) => {
+          log.failure(
+            () => ({ msg: "the host onFailure handler threw" }),
+            error
+          );
         }
       );
       return;
@@ -11968,15 +12766,27 @@ function useCompleteOAuth(options) {
         });
         if (cancelled) return;
         if (!ok) {
+          log.error(() => ({
+            msg: "the host postOAuthComplete handler reported failure",
+            fields: { reason: "complete_request_failed" }
+          }));
           hasStartedExchangeRef.current = false;
           await onFailureRef.current("complete_request_failed");
           return;
         }
         await coinlist.init();
         if (cancelled) return;
+        log.info(() => ({ msg: "session established" }));
         await onSuccessRef.current();
-      } catch {
+      } catch (error) {
         if (cancelled) return;
+        log.failure(
+          () => ({
+            msg: "settled",
+            fields: { state: "ERROR", reason: "complete_request_failed" }
+          }),
+          error
+        );
         hasStartedExchangeRef.current = false;
         await onFailureRef.current("complete_request_failed");
       }
@@ -11985,19 +12795,20 @@ function useCompleteOAuth(options) {
       cancelled = true;
       hasStartedExchangeRef.current = false;
     };
-  }, [coinlist]);
+  }, [coinlist, log]);
 }
 
 // src/client/hooks/checkout/coin-list/token-sale/data/useParticipations.ts
-var import_react42 = require("react");
+var import_react43 = require("react");
 var LOADING_STATE7 = { type: "LOADING" };
 function useParticipations(offerId, options = {}) {
   const { coinlist, isReady } = useCoinList();
+  const log = useLogger("useParticipations");
   const { data } = options;
-  const [participationsState, setParticipationsState] = (0, import_react42.useState)(
+  const [participationsState, setParticipationsState] = (0, import_react43.useState)(
     data !== void 0 ? { type: "CONTENT", participations: data } : LOADING_STATE7
   );
-  (0, import_react42.useEffect)(() => {
+  (0, import_react43.useEffect)(() => {
     let isCancelled = false;
     if (!isReady) {
       if (data === void 0) {
@@ -12015,31 +12826,40 @@ function useParticipations(offerId, options = {}) {
     setParticipationsState(LOADING_STATE7);
     coinlist.tokenSale.list(offerId).then((participations) => {
       if (!isCancelled) {
+        log.debug(() => ({
+          msg: "settled",
+          fields: { state: "CONTENT", count: participations.length }
+        }));
         setParticipationsState({ type: "CONTENT", participations });
       }
     }).catch((error) => {
       if (!isCancelled) {
         const reason = error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+        log.failure(
+          () => ({ msg: "settled", fields: { state: "ERROR", reason } }),
+          error
+        );
         setParticipationsState({ type: "ERROR", reason });
       }
     });
     return () => {
       isCancelled = true;
     };
-  }, [coinlist, isReady, offerId, data]);
+  }, [coinlist, isReady, offerId, data, log]);
   return { participationsState };
 }
 
 // src/client/hooks/offers/data/useOfferDetails.ts
-var import_react43 = require("react");
+var import_react44 = require("react");
 var LOADING_STATE8 = { type: "LOADING" };
 function useOfferDetails(offerId, options = {}) {
   const { coinlist, isReady } = useCoinList();
+  const log = useLogger("useOfferDetails");
   const { data } = options;
-  const [offerDetailsState, setOfferDetailsState] = (0, import_react43.useState)(
+  const [offerDetailsState, setOfferDetailsState] = (0, import_react44.useState)(
     data !== void 0 ? { type: "CONTENT", offerDetail: data } : LOADING_STATE8
   );
-  (0, import_react43.useEffect)(() => {
+  (0, import_react44.useEffect)(() => {
     let isCancelled = false;
     if (!isReady) {
       if (data === void 0) {
@@ -12057,36 +12877,45 @@ function useOfferDetails(offerId, options = {}) {
     setOfferDetailsState(LOADING_STATE8);
     coinlist.offers.get(offerId).then((offerDetail) => {
       if (!isCancelled) {
+        log.debug(() => ({
+          msg: "settled",
+          fields: { state: "CONTENT", offerId: offerDetail.id }
+        }));
         setOfferDetailsState({ type: "CONTENT", offerDetail });
       }
     }).catch((error) => {
       if (!isCancelled) {
         const reason = error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+        log.failure(
+          () => ({ msg: "settled", fields: { state: "ERROR", reason } }),
+          error
+        );
         setOfferDetailsState({ type: "ERROR", reason });
       }
     });
     return () => {
       isCancelled = true;
     };
-  }, [coinlist, isReady, offerId, data]);
+  }, [coinlist, isReady, offerId, data, log]);
   return { offerDetailsState };
 }
 
 // src/client/hooks/tokens/data/useTokenMetadata.ts
-var import_react44 = require("react");
+var import_react45 = require("react");
 var DISABLED_STATE = { type: "DISABLED" };
 var LOADING_STATE9 = { type: "LOADING" };
 function useTokenMetadata(options) {
   const { chain, address, data, enabled = true } = options;
   const { coinlist, isReady } = useCoinList();
-  const [state, setState] = (0, import_react44.useState)(
+  const log = useLogger("useTokenMetadata");
+  const [state, setState] = (0, import_react45.useState)(
     () => data !== void 0 ? { type: "CONTENT", tokenMetadata: data } : LOADING_STATE9
   );
-  const [refetchCount, setRefetchCount] = (0, import_react44.useState)(0);
-  const refetch = (0, import_react44.useCallback)(() => {
+  const [refetchCount, setRefetchCount] = (0, import_react45.useState)(0);
+  const refetch = (0, import_react45.useCallback)(() => {
     setRefetchCount((count) => count + 1);
   }, []);
-  (0, import_react44.useEffect)(() => {
+  (0, import_react45.useEffect)(() => {
     let isCancelled = false;
     const seedActive = data !== void 0 && refetchCount === 0;
     if (!isReady || !enabled || seedActive) {
@@ -12097,17 +12926,32 @@ function useTokenMetadata(options) {
     setState(LOADING_STATE9);
     coinlist.tokens.get({ chain, address }).then((tokenMetadata) => {
       if (!isCancelled) {
+        log.debug(() => ({
+          msg: "settled",
+          fields: {
+            state: "CONTENT",
+            listed: tokenMetadata !== null,
+            symbol: tokenMetadata?.symbol ?? null
+          }
+        }));
         setState({ type: "CONTENT", tokenMetadata });
       }
-    }).catch(() => {
+    }).catch((error) => {
       if (!isCancelled) {
+        log.failure(
+          () => ({
+            msg: "settled",
+            fields: { state: "ERROR", reason: "generic-error" }
+          }),
+          error
+        );
         setState({ type: "ERROR", reason: "generic-error" });
       }
     });
     return () => {
       isCancelled = true;
     };
-  }, [coinlist, isReady, enabled, chain, address, data, refetchCount]);
+  }, [coinlist, isReady, enabled, chain, address, data, refetchCount, log]);
   return {
     // LOADING would be a lie while disabled: nothing is in flight and nothing
     // will replace it. Settled states (a seed, a previous answer) survive.
@@ -12155,6 +12999,7 @@ function useTokenMetadata(options) {
   OndoReviewView,
   OndoSidebarView,
   OndoWalletSelectView,
+  RedactedWalletError,
   RequirementItem,
   RequirementItemUi,
   RequirementStatus,
@@ -12187,6 +13032,7 @@ function useTokenMetadata(options) {
   formatMonthYear,
   offerIconUrl,
   ondoLoadErrorReason,
+  pinoClientLogger,
   prepareOndoSwap,
   quoteIsStale,
   quoteOverAsks,