@coinlist-co/react 0.12.2-rc.8a0d02a → 0.12.2-rc.8a65e9d

package/dist/{chunk-C6GF7MDF.js → chunk-2FZAXGVH.js}

@@ -1,93 +1,4 @@
-// src/universal/api/internal-access-token-source.ts
-var SentWith = {
-  userToken: (token) => ({
-    type: "user-token",
-    token
-  }),
-  noUserToken: { type: "no-user-token" }
-};
-var TokenTrigger = {
-  beforeRequest: { type: "before-request" },
-  after401: (rejected) => ({
-    type: "after-401",
-    rejected
-  })
-};
-function isRejectedToken(token, rejected) {
-  switch (rejected.type) {
-    case "user-token":
-      return rejected.token.value === token.value;
-    case "no-user-token":
-      return false;
-  }
-}
-
-// src/universal/api/http-attributes.ts
-var empty = {};
-var concat = (left, right) => ({
-  ...left,
-  ...right
-});
-var concatAll = (...items) => {
-  let result = empty;
-  for (const item of items) {
-    result = concat(result, item);
-  }
-  return result;
-};
-var protectedRequest = () => ({ protected: true });
-var userAgent = () => ({ userAgent: true });
-var idempotencyKey = () => ({
-  idempotencyKey: true
-});
-var clientCredentials = (credentials) => ({
-  clientCredentials: credentials
-});
-var retryAttempt = (attempt) => ({
-  retryAttempt: attempt
-});
-var renewAttempted = (value) => ({
-  renewAttempted: value
-});
-var notRetryable = () => ({ retryable: false });
-var sentWith = (token) => ({
-  sentWith: token
-});
-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;
-var getRetryAttempt = (attrs) => attrs?.retryAttempt ?? 0;
-var wasRenewAttempted = (attrs) => attrs?.renewAttempted === true;
-var isRetryable = (attrs) => attrs?.retryable !== false;
-var getSentWith = (attrs) => attrs?.sentWith === void 0 ? SentWith.noUserToken : SentWith.userToken(attrs.sentWith);
-var getClientCredentials = (attrs) => attrs?.clientCredentials;
-var Attributes = {
-  empty,
-  concat,
-  concatAll,
-  protected: protectedRequest,
-  isProtected,
-  userAgent,
-  needUserAgent,
-  idempotencyKey,
-  isIdempotent,
-  retryAttempt,
-  getRetryAttempt,
-  renewAttempted,
-  wasRenewAttempted,
-  notRetryable,
-  isRetryable,
-  sentWith,
-  getSentWith,
-  clientCredentials,
-  getClientCredentials,
-  requestId,
-  getRequestId
-};
-
-// src/universal/api/http.ts
+// src/universal/types/http.ts
 var HttpError = class extends Error {
   constructor(response) {
     super(`Request failed with ${response.status} status`);
@@ -112,104 +23,6 @@ function apiErrorCode(error) {
   const code = body.code;
   return typeof code === "string" ? code : null;
 }
-async function makeRequest(request) {
-  const headers = {
-    Accept: "application/json",
-    ...request.method === "POST" && request.body !== void 0 ? { "Content-Type": "application/json" } : {},
-    ...request.headers ?? {}
-  };
-  const init = {
-    method: request.method,
-    headers,
-    ...request.redirect !== void 0 ? { redirect: request.redirect } : {}
-  };
-  if (request.method === "POST" && request.body !== void 0) {
-    init.body = JSON.stringify(request.body);
-  }
-  const response = await fetch(
-    buildUrlWithQueryParams(request.url, request.queryParams),
-    init
-  );
-  const responseHeaders = headersToRecord(response.headers);
-  if (response.status === 204 || response.status === 205) {
-    return {
-      status: response.status,
-      body: null,
-      headers: responseHeaders
-    };
-  }
-  if (response.status >= 300 && response.status < 400) {
-    await response.text();
-    return {
-      status: response.status,
-      body: null,
-      headers: responseHeaders
-    };
-  }
-  const text = await response.text();
-  let body;
-  try {
-    body = text ? JSON.parse(text) : null;
-  } catch (_) {
-    throw new HttpError({
-      status: response.status,
-      headers: responseHeaders,
-      body: text
-    });
-  }
-  return {
-    status: response.status,
-    body,
-    headers: responseHeaders
-  };
-}
-function buildUrlWithQueryParams(url, queryParams) {
-  if (!queryParams) {
-    return url;
-  }
-  const searchParams = new URLSearchParams();
-  for (const [key, value] of Object.entries(queryParams)) {
-    if (value === void 0 || value === null) {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (item === void 0 || item === null) {
-          continue;
-        }
-        searchParams.append(key, String(item));
-      }
-      continue;
-    }
-    searchParams.append(key, String(value));
-  }
-  const queryString = searchParams.toString();
-  if (!queryString) {
-    return url;
-  }
-  return url.includes("?") ? `${url}&${queryString}` : `${url}?${queryString}`;
-}
-function headersToRecord(headers) {
-  const record = {};
-  headers.forEach((value, key) => {
-    record[key.toLowerCase()] = value;
-  });
-  return record;
-}
-function concatAttributes(request, attrs) {
-  const nextAttributes = Attributes.concat(
-    request.attributes ?? Attributes.empty,
-    attrs
-  );
-  const nextRequest = {
-    ...request,
-    attributes: nextAttributes
-  };
-  return nextRequest;
-}
-var Request = {
-  concatAttributes
-};
 
 // src/universal/types/errors.ts
 var NotImplementedError = class extends Error {
@@ -291,105 +104,74 @@ function isExpired({
   return now >= expiresAt - buffer;
 }
 
-// src/universal/core/shared/blockchain/erc20/abi.ts
-var ERC20_ABI = [
-  {
-    type: "function",
-    name: "allowance",
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "approve",
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "balanceOf",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "decimals",
-    inputs: [],
-    outputs: [{ name: "", type: "uint8" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "name",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "symbol",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "totalSupply",
-    inputs: [],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "transfer",
-    inputs: [
-      { name: "recipient", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "transferFrom",
-    inputs: [
-      { name: "sender", type: "address" },
-      { name: "recipient", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "event",
-    name: "Approval",
-    inputs: [
-      { name: "owner", type: "address", indexed: true },
-      { name: "spender", type: "address", indexed: true },
-      { name: "value", type: "uint256", indexed: false }
-    ],
-    anonymous: false
-  },
-  {
-    type: "event",
-    name: "Transfer",
-    inputs: [
-      { name: "from", type: "address", indexed: true },
-      { name: "to", type: "address", indexed: true },
-      { name: "value", type: "uint256", indexed: false }
-    ],
-    anonymous: false
+// src/universal/types/blockchain/ui.ts
+var FormattedAmountUi = (value) => value;
+var FormattedPercentUi = (value) => value;
+var TxExplorerUrl = (value) => value;
+var ShortenedWalletAddress = (value) => value;
+var FormattedAmountAssetUi = (value) => value;
+var AssetIconUrl = (value) => value;
+
+// src/universal/core/shared/blockchain/chain.ts
+import { base, baseSepolia, mainnet, sepolia } from "viem/chains";
+var VIEM_CHAINS = {
+  ethereum_mainnet: mainnet,
+  ethereum_sepolia: sepolia,
+  base_mainnet: base,
+  base_sepolia: baseSepolia
+};
+function viemChain(chain) {
+  return VIEM_CHAINS[chain];
+}
+function getChainId(chain) {
+  return VIEM_CHAINS[chain].id;
+}
+function chainFromId(chainId) {
+  const chains = Object.keys(VIEM_CHAINS);
+  const chain = chains.find((c) => String(VIEM_CHAINS[c].id) === chainId);
+  if (!chain) {
+    throw new ValidationError(`Unsupported EIP-155 chain id: "${chainId}"`);
   }
-];
+  return chain;
+}
+function contractOn(contracts, chain) {
+  return contracts.find((contract) => contract.chain === chain)?.address ?? null;
+}
+function getNetworkName(chain) {
+  switch (chain) {
+    case "ethereum_mainnet":
+      return "Ethereum";
+    case "ethereum_sepolia":
+      return "Ethereum Sepolia";
+    case "base_mainnet":
+      return "Base";
+    case "base_sepolia":
+      return "Base Sepolia";
+    default: {
+      const _exhaustive = chain;
+      return _exhaustive;
+    }
+  }
+}
+function txExplorerUrl(chain, txHash) {
+  return TxExplorerUrl(`${explorerBaseUrl(chain)}/tx/${txHash}`);
+}
+function explorerBaseUrl(chain) {
+  switch (chain) {
+    case "ethereum_mainnet":
+      return "https://etherscan.io";
+    case "ethereum_sepolia":
+      return "https://sepolia.etherscan.io";
+    case "base_mainnet":
+      return "https://basescan.org";
+    case "base_sepolia":
+      return "https://sepolia-explorer.base.org";
+    default: {
+      const _exhaustive = chain;
+      return _exhaustive;
+    }
+  }
+}
 
 // src/universal/types/blockchain/core.ts
 var ETHEREUM_CHAINS = {
@@ -453,8 +235,18 @@ var BlockchainAmount = Object.assign(
   {
     add: (a, b) => combineAmounts(a, b, (x, y) => x + y),
     sub: (a, b) => combineAmounts(a, b, (x, y) => x - y),
-    mul: multiplyAmounts,
-    div: divideAmounts
+    /**
+     * `a * b`, in `a`'s decimals - a price times a quantity. Multiplies before
+     * it rescales, then truncates towards zero. The exact inverse of `div`.
+     */
+    mul: (a, b) => multiplyAmounts(a, b),
+    /**
+     * `a / b`, in `a`'s decimals - a price, a ratio. Rescales before it
+     * divides, then truncates towards zero.
+     *
+     * @throws MathError when `b` is zero.
+     */
+    div: (a, b) => divideAmounts(a, b)
   }
 );
 function multiplyAmounts(a, b) {
@@ -511,6 +303,36 @@ function blockchainAmountFromRawOrThrow({
     throw new ValidationError(`${label}: out of uint256 bounds (${value})`);
   }
 }
+function positiveAmountFromRawOrThrow({
+  label,
+  raw,
+  decimals,
+  reason
+}) {
+  const amount = blockchainAmountFromRawOrThrow({ label, raw, decimals });
+  if (amount.raw === 0n) {
+    throw new ValidationError(
+      `${label}: must be greater than zero ("${raw}") - ${reason}`
+    );
+  }
+  return amount;
+}
+function pricePerShare({
+  usd,
+  shares
+}) {
+  const price = BlockchainAmount.div(usd, shares);
+  return BlockchainAmount({
+    raw: assertPriceFits(price.raw),
+    decimals: price.decimals
+  });
+}
+function assertPriceFits(raw) {
+  if (raw > MAX_UINT_256) {
+    throw new MathError(`Price per share: out of uint256 bounds (${raw})`);
+  }
+  return raw;
+}
 function parseBlockchainAmount(amount, decimals) {
   const trimmed = amount.trim();
   if (trimmed === "") return { valid: false, reason: { type: "empty" } };
@@ -624,10 +446,13 @@ function requiredDate(value, field) {
   return date;
 }
 function dateOrNull(value, field) {
-  return value === null ? null : requiredDate(value, field);
+  return mapNullish(value, (date) => requiredDate(date, field));
 }
 function decimalOrNull(value) {
-  return value === null ? null : DecimalString(value);
+  return mapNullish(value, DecimalString);
+}
+function mapNullish(value, parse) {
+  return value === null || value === void 0 ? null : parse(value);
 }
 function requiredArray(value, field) {
   if (!Array.isArray(value)) {
@@ -637,6 +462,12 @@ function requiredArray(value, field) {
   }
   return value;
 }
+function txFromWire(wire) {
+  return {
+    to: EvmContractAddress(wire.to),
+    data: HexEncodedTransactionData(wire.data)
+  };
+}
 
 // src/universal/types/providers/centrifuge/centrifuge.ts
 var CentrifugeVaultStatus = {
@@ -665,19 +496,16 @@ var CentrifugeVaultStatus = {
 };
 var CentrifugeVaultBuyTransaction = {
   fromDto: (dto) => {
-    const spendInputAmount = blockchainAmountFromRawOrThrow({
-      label: "spend_input_amount",
-      raw: dto.spend_input_amount,
-      decimals: AssetDecimals(dto.spend_input_decimals)
-    });
-    if (spendInputAmount.raw <= 0n) {
-      throw new ValidationError(
-        `spend_input_amount: must be greater than zero ("${dto.spend_input_amount}") - a deposit of nothing is not a request`
-      );
-    }
     return {
       ...parseTransactionCore(dto, "CentrifugeVaultBuyTransaction"),
-      spendInputAmount
+      spendInputAmount: positiveAmountFromRawOrThrow({
+        label: "spend_input_amount",
+        raw: dto.spend_input_amount,
+        decimals: AssetDecimals(dto.spend_input_decimals),
+        // Frontline refuses an `amount` of zero, so a zero here is a changed
+        // encoding, not a small deposit - and not calldata worth signing.
+        reason: "a deposit of nothing is not a request"
+      })
     };
   }
 };
@@ -691,72 +519,41 @@ var CentrifugeVaultClaimTransaction = {
     })
   })
 };
-var CentrifugeVaultPosition = {
-  fromDto: (dto) => {
-    const assetDecimals = AssetDecimals(dto.asset_decimals);
-    const shareDecimals = AssetDecimals(dto.share_decimals);
-    const asset = (label, raw) => blockchainAmountFromRawOrThrow({ label, raw, decimals: assetDecimals });
-    const shares = (label, raw) => blockchainAmountFromRawOrThrow({ label, raw, decimals: shareDecimals });
+var CentrifugeAssets = (amount) => amount;
+var CentrifugeShares = (amount) => amount;
+var CentrifugeDepositPosition = {
+  fromContract: (raw, context) => {
+    const assets = (label, value) => CentrifugeAssets(contractAmount(label, value, context.assetDecimals));
     return {
-      chain: EthereumChain(dto.chain),
-      symbol: AssetSymbol(dto.symbol),
-      walletAddress: EvmWalletAddress(dto.wallet_address),
-      status: dto.status,
-      requested: asset("requested", dto.requested),
-      pending: asset("pending", dto.pending),
-      filledAssets: asset("filled_assets", dto.filled_assets),
-      earnedShares: shares("earned_shares", dto.earned_shares),
-      claimedShares: shares("claimed_shares", dto.claimed_shares),
-      claimableShares: shares("claimable_shares", dto.claimable_shares),
-      shareBalance: shares("share_balance", dto.share_balance),
-      averagePrice: decimalOrNull(dto.average_price),
-      frozen: dto.frozen,
-      asOf: requiredDate(dto.as_of, "CentrifugeVaultPosition.as_of")
+      chain: context.chain,
+      proxy: context.proxy,
+      walletAddress: context.walletAddress,
+      pending: assets("pendingDepositRequest", raw.pendingDepositRequest),
+      claimable: assets("claimableDepositRequest", raw.claimableDepositRequest)
     };
   }
 };
-var CentrifugeVaultRedeemPosition = {
-  fromDto: (dto) => ({
-    chain: EthereumChain(dto.chain),
-    symbol: AssetSymbol(dto.symbol),
-    walletAddress: EvmWalletAddress(dto.wallet_address),
-    status: dto.status,
-    pending: blockchainAmountFromRawOrThrow({
-      label: "pending",
-      raw: dto.pending,
-      decimals: AssetDecimals(dto.share_decimals)
-    }),
-    claimableAssets: blockchainAmountFromRawOrThrow({
-      label: "claimable_assets",
-      raw: dto.claimable_assets,
-      decimals: AssetDecimals(dto.asset_decimals)
-    }),
-    frozen: dto.frozen,
-    asOf: requiredDate(dto.as_of, "CentrifugeVaultRedeemPosition.as_of")
-  })
+var CentrifugeRedeemPosition = {
+  fromContract: (raw, context) => {
+    const shares = (label, value) => CentrifugeShares(contractAmount(label, value, context.shareDecimals));
+    return {
+      chain: context.chain,
+      proxy: context.proxy,
+      walletAddress: context.walletAddress,
+      pending: shares("pendingRedeemRequest", raw.pendingRedeemRequest),
+      claimable: shares("claimableRedeemRequest", raw.claimableRedeemRequest)
+    };
+  }
 };
 var CentrifugeVaultLeg = {
-  /**
-   * What a claim on the leg would collect: shares for `invest`, the funding
-   * token for `redeem`.
-   */
-  claimable: (leg) => {
-    switch (leg.direction) {
-      case "invest":
-        return leg.position.claimableShares;
-      case "redeem":
-        return leg.position.claimableAssets;
-      default: {
-        const exhaustive = leg;
-        return exhaustive;
-      }
-    }
-  },
   /** Whether the leg has anything queued or anything ready to claim. */
-  isActive: (leg) => leg.position.pending.raw > 0n || CentrifugeVaultLeg.claimable(leg).raw > 0n
+  isActive: (leg) => leg.position.pending.raw > 0n || leg.position.claimable.raw > 0n
 };
+function contractAmount(label, value, decimals) {
+  return BlockchainAmount({ raw: parseUint256(value, label), decimals });
+}
 var CentrifugeVaultLegId = {
-  /** Addresses compare case-insensitively: frontline echoes them lower case. */
+  /** Addresses compare case-insensitively: a host may pass either case. */
   of: (leg) => [
     leg.direction,
     leg.position.chain,
@@ -773,33 +570,133 @@ var CentrifugeVaultClaimProceedsTransaction = {
     })
   })
 };
-function parseOrderability(canOrder, reasons, model) {
-  const [first, ...rest] = reasons;
-  if (canOrder) {
-    if (first !== void 0) {
-      throw new ValidationError(
-        `${model}.reasons: expected none when can_order is true, got ${JSON.stringify(reasons)}`
-      );
-    }
-    return { type: "orderable" };
-  }
-  if (first === void 0) {
-    throw new ValidationError(
-      `${model}.reasons: expected at least one when can_order is false`
-    );
+function parseOrderability(canOrder, reasons, model) {
+  const [first, ...rest] = reasons;
+  if (canOrder) {
+    if (first !== void 0) {
+      throw new ValidationError(
+        `${model}.reasons: expected none when can_order is true, got ${JSON.stringify(reasons)}`
+      );
+    }
+    return { type: "orderable" };
+  }
+  if (first === void 0) {
+    throw new ValidationError(
+      `${model}.reasons: expected at least one when can_order is false`
+    );
+  }
+  return { type: "blocked", reasons: [first, ...rest] };
+}
+function parseTransactionCore(dto, model) {
+  return {
+    tx: txFromWire(dto),
+    expiresAt: dateOrNull(dto.expires_at, `${model}.expires_at`)
+  };
+}
+
+// src/universal/api/frontline/providers/shared/spend-scale.ts
+function assertSpendScaleAgrees({
+  published,
+  sized,
+  trade,
+  note
+}) {
+  if (published === sized.decimals) return;
+  const because = note === void 0 ? "" : ` - ${note}`;
+  throw new ValidationError(
+    `spend_input_decimals: the ${trade} was priced in ${published} decimals but the order was sized in ${sized.decimals}${because}`
+  );
+}
+
+// src/universal/types/access-token-source.ts
+var SentWith = {
+  userToken: (token) => ({
+    type: "user-token",
+    token
+  }),
+  noUserToken: { type: "no-user-token" }
+};
+var TokenTrigger = {
+  beforeRequest: { type: "before-request" },
+  after401: (rejected) => ({
+    type: "after-401",
+    rejected
+  })
+};
+function isRejectedToken(token, rejected) {
+  switch (rejected.type) {
+    case "user-token":
+      return rejected.token.value === token.value;
+    case "no-user-token":
+      return false;
   }
-  return { type: "blocked", reasons: [first, ...rest] };
-}
-function parseTransactionCore(dto, model) {
-  return {
-    tx: {
-      to: EvmContractAddress(dto.to),
-      data: HexEncodedTransactionData(dto.data)
-    },
-    expiresAt: dateOrNull(dto.expires_at, `${model}.expires_at`)
-  };
 }
 
+// src/universal/api/http-attributes.ts
+var empty = {};
+var concat = (left, right) => ({
+  ...left,
+  ...right
+});
+var concatAll = (...items) => {
+  let result = empty;
+  for (const item of items) {
+    result = concat(result, item);
+  }
+  return result;
+};
+var protectedRequest = () => ({ protected: true });
+var userAgent = () => ({ userAgent: true });
+var idempotencyKey = () => ({
+  idempotencyKey: true
+});
+var clientCredentials = (credentials) => ({
+  clientCredentials: credentials
+});
+var retryAttempt = (attempt) => ({
+  retryAttempt: attempt
+});
+var renewAttempted = (value) => ({
+  renewAttempted: value
+});
+var notRetryable = () => ({ retryable: false });
+var sentWith = (token) => ({
+  sentWith: token
+});
+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;
+var getRetryAttempt = (attrs) => attrs?.retryAttempt ?? 0;
+var wasRenewAttempted = (attrs) => attrs?.renewAttempted === true;
+var isRetryable = (attrs) => attrs?.retryable !== false;
+var getSentWith = (attrs) => attrs?.sentWith === void 0 ? SentWith.noUserToken : SentWith.userToken(attrs.sentWith);
+var getClientCredentials = (attrs) => attrs?.clientCredentials;
+var Attributes = {
+  empty,
+  concat,
+  concatAll,
+  protected: protectedRequest,
+  isProtected,
+  userAgent,
+  needUserAgent,
+  idempotencyKey,
+  isIdempotent,
+  retryAttempt,
+  getRetryAttempt,
+  renewAttempted,
+  wasRenewAttempted,
+  notRetryable,
+  isRetryable,
+  sentWith,
+  getSentWith,
+  clientCredentials,
+  getClientCredentials,
+  requestId,
+  getRequestId
+};
+
 // src/universal/api/frontline/providers/centrifuge/centrifuge.ts
 async function getCentrifugeVaultStatus(api, params) {
   const dto = await api.send({
@@ -823,30 +720,12 @@ async function buildCentrifugeVaultBuy(api, params) {
     },
     attributes: Attributes.protected()
   });
-  if (dto.spend_input_decimals !== params.amount.decimals) {
-    throw new ValidationError(
-      `spend_input_decimals: the request was priced in ${dto.spend_input_decimals} decimals but the deposit was sized in ${params.amount.decimals}`
-    );
-  }
-  return CentrifugeVaultBuyTransaction.fromDto(dto);
-}
-async function getCentrifugeVaultPosition(api, params) {
-  const dto = await api.send({
-    method: "GET",
-    url: "/v1/centrifuge/vault/position",
-    queryParams: walletFields(params),
-    attributes: Attributes.protected()
-  });
-  return CentrifugeVaultPosition.fromDto(dto);
-}
-async function getCentrifugeVaultRedeemPosition(api, params) {
-  const dto = await api.send({
-    method: "GET",
-    url: "/v1/centrifuge/vault/redeem-position",
-    queryParams: walletFields(params),
-    attributes: Attributes.protected()
+  assertSpendScaleAgrees({
+    published: dto.spend_input_decimals,
+    sized: params.amount,
+    trade: "deposit"
   });
-  return CentrifugeVaultRedeemPosition.fromDto(dto);
+  return CentrifugeVaultBuyTransaction.fromDto(dto);
 }
 async function createCentrifugeVaultClaim(api, params) {
   const dto = await api.send({
@@ -874,6 +753,86 @@ function walletFields(params) {
   };
 }
 
+// src/universal/core/providers/centrifuge/blockchain/abi.ts
+var CENTRIFUGE_PROXY_ABI = [
+  {
+    type: "function",
+    name: "pendingDepositRequest",
+    inputs: [{ name: "investor", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "claimableDepositRequest",
+    inputs: [{ name: "investor", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pendingRedeemRequest",
+    inputs: [{ name: "investor", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "claimableRedeemRequest",
+    inputs: [{ name: "investor", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+
+// src/universal/api/rpc/providers/centrifuge/position.ts
+async function readCentrifugeDepositPosition(clients, params) {
+  const client = clients(params.vault.chain);
+  const proxy = proxyOf(params);
+  const wallet = params.walletAddress;
+  const [pendingDepositRequest, claimableDepositRequest] = await client.multicall({
+    allowFailure: false,
+    contracts: [
+      { ...proxy, functionName: "pendingDepositRequest", args: [wallet] },
+      { ...proxy, functionName: "claimableDepositRequest", args: [wallet] }
+    ]
+  });
+  return CentrifugeDepositPosition.fromContract(
+    { pendingDepositRequest, claimableDepositRequest },
+    contextOf(params)
+  );
+}
+async function readCentrifugeRedeemPosition(clients, params) {
+  const client = clients(params.vault.chain);
+  const proxy = proxyOf(params);
+  const wallet = params.walletAddress;
+  const [pendingRedeemRequest, claimableRedeemRequest] = await client.multicall(
+    {
+      allowFailure: false,
+      contracts: [
+        { ...proxy, functionName: "pendingRedeemRequest", args: [wallet] },
+        { ...proxy, functionName: "claimableRedeemRequest", args: [wallet] }
+      ]
+    }
+  );
+  return CentrifugeRedeemPosition.fromContract(
+    { pendingRedeemRequest, claimableRedeemRequest },
+    contextOf(params)
+  );
+}
+function proxyOf(params) {
+  return { address: params.vault.proxy, abi: CENTRIFUGE_PROXY_ABI };
+}
+function contextOf(params) {
+  return {
+    chain: params.vault.chain,
+    proxy: params.vault.proxy,
+    walletAddress: params.walletAddress,
+    assetDecimals: params.vault.funding.decimals,
+    shareDecimals: params.vault.share.decimals
+  };
+}
+
 // src/universal/core/shared/observability/log-cause.ts
 import {
   BaseError,
@@ -1057,7 +1016,7 @@ var noopInternalLogger = {
   wrap: (_op, _params, run) => run()
 };
 
-// src/universal/core/checkout/centrifuge/centrifuge-namespace.ts
+// src/universal/core/providers/centrifuge/centrifuge-namespace.ts
 var CentrifugeNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -1069,17 +1028,19 @@ var CentrifugeNamespaceImpl = class {
       return getCentrifugeVaultStatus(this.ctx.api, params);
     });
   }
-  async getPosition(params) {
-    return this.log.wrap("getPosition", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getCentrifugeVaultPosition(this.ctx.api, params);
-    });
+  async readDepositPosition(params) {
+    return this.log.wrap(
+      "readDepositPosition",
+      params,
+      () => readCentrifugeDepositPosition(this.ctx.rpc, params)
+    );
   }
-  async getRedeemPosition(params) {
-    return this.log.wrap("getRedeemPosition", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return getCentrifugeVaultRedeemPosition(this.ctx.api, params);
-    });
+  async readRedeemPosition(params) {
+    return this.log.wrap(
+      "readRedeemPosition",
+      params,
+      () => readCentrifugeRedeemPosition(this.ctx.rpc, params)
+    );
   }
   async createClaim(params) {
     return this.log.wrap("createClaim", params, async () => {
@@ -1101,20 +1062,112 @@ var CentrifugeNamespaceImpl = class {
   }
 };
 
-// src/universal/api/pagination.ts
-async function fetchAllPages(fetchPage, baseParams) {
-  const items = [];
-  let cursor = null;
-  do {
-    const params = {
-      ...baseParams ?? {},
-      after: cursor ?? void 0
-    };
-    const page = await fetchPage(params);
-    items.push(...page.data);
-    cursor = page.startingAfter;
-  } while (cursor);
-  return items;
+// src/universal/core/shared/blockchain/formatters.ts
+import { formatUnits } from "viem";
+function shortenAddress(address) {
+  const short = address.length > 10 ? `${address.slice(0, 6)}\u2026${address.slice(-4)}` : address;
+  return ShortenedWalletAddress(short);
+}
+function formatAmount(amount, locale, options) {
+  const decimal = formatRawAmount(amount);
+  let [integerPart, fractionPart = ""] = decimal.split(".");
+  const maxFractionDigits = options?.maxFractionDigits;
+  const minFractionDigits = Math.min(
+    options?.minFractionDigits ?? (maxFractionDigits !== void 0 ? maxFractionDigits : 2),
+    maxFractionDigits ?? amount.decimals,
+    amount.decimals
+  );
+  if (maxFractionDigits !== void 0 && fractionPart.length > maxFractionDigits) {
+    ({ integerPart, fractionPart } = roundFractionHalfUp(
+      integerPart,
+      fractionPart,
+      maxFractionDigits
+    ));
+  }
+  const trimmed = fractionPart.replace(/0+$/, "");
+  const fraction = trimmed.padEnd(minFractionDigits, "0");
+  const integerFormatted = BigInt(integerPart).toLocaleString(locale);
+  if (minFractionDigits === 0 && fraction === "") {
+    return FormattedAmountUi(integerFormatted);
+  }
+  const decimalSeparator = new Intl.NumberFormat(locale).formatToParts(1.1).find((p) => p.type === "decimal")?.value ?? ".";
+  return FormattedAmountUi(`${integerFormatted}${decimalSeparator}${fraction}`);
+}
+function roundFractionHalfUp(integerPart, fractionPart, maxFractionDigits) {
+  if (fractionPart.length <= maxFractionDigits) {
+    return { integerPart, fractionPart };
+  }
+  if (maxFractionDigits === 0) {
+    const roundUp = fractionPart[0] >= "5";
+    const integer = BigInt(integerPart) + (roundUp ? 1n : 0n);
+    return { integerPart: integer.toString(), fractionPart: "" };
+  }
+  const trimmed = fractionPart.slice(0, maxFractionDigits);
+  if (fractionPart[maxFractionDigits] < "5") {
+    return { integerPart, fractionPart: trimmed };
+  }
+  const digits = trimmed.split("").map((digit) => Number.parseInt(digit, 10));
+  let carry = 1;
+  for (let i = digits.length - 1; i >= 0 && carry > 0; i -= 1) {
+    const sum = digits[i] + carry;
+    if (sum === 10) {
+      digits[i] = 0;
+      carry = 1;
+    } else {
+      digits[i] = sum;
+      carry = 0;
+    }
+  }
+  return {
+    integerPart: carry > 0 ? (BigInt(integerPart) + 1n).toString() : integerPart,
+    fractionPart: digits.join("")
+  };
+}
+function formatRawAmount(amount) {
+  return formatUnits(amount.raw, amount.decimals);
+}
+function formatCompactAmount(amount, locale) {
+  const value = Number(formatRawAmount(amount));
+  const formatted = new Intl.NumberFormat(locale, {
+    notation: "compact",
+    maximumFractionDigits: 2
+  }).format(value);
+  return FormattedAmountUi(formatted);
+}
+function formatBpsAsPercent(bps, locale) {
+  const whole = bps / 100n;
+  const fraction = bps % 100n;
+  const wholeFormatted = whole.toLocaleString(locale);
+  const decimalSeparator = new Intl.NumberFormat(locale).formatToParts(1.1).find((p) => p.type === "decimal")?.value ?? ".";
+  if (fraction === 0n) {
+    return FormattedPercentUi(`${wholeFormatted}%`);
+  }
+  const fractionFormatted = fraction.toString().padStart(2, "0").replace(/0+$/, "");
+  return FormattedPercentUi(
+    `${wholeFormatted}${decimalSeparator}${fractionFormatted}%`
+  );
+}
+function usdAmount(amount) {
+  return FormattedAmountAssetUi(`$${amount}`);
+}
+function assetAmount(amount, symbol) {
+  return FormattedAmountAssetUi(`${amount} ${symbol}`);
+}
+var NA_AMOUNT_ASSET_UI = FormattedAmountAssetUi("-");
+var SHARE_MAX_FRACTION_DIGITS = AssetDecimals(6);
+var SHARE_MIN_FRACTION_DIGITS = AssetDecimals(2);
+function formatShareAmount(amount, locale) {
+  return formatAmount(amount, locale, {
+    maxFractionDigits: SHARE_MAX_FRACTION_DIGITS,
+    minFractionDigits: SHARE_MIN_FRACTION_DIGITS
+  });
+}
+var USD_FRACTION_DIGITS = AssetDecimals(2);
+function formattedUsdPrice(amount, locale) {
+  if (!amount) return NA_AMOUNT_ASSET_UI;
+  return usdAmount(
+    formatAmount(amount, locale, { maxFractionDigits: USD_FRACTION_DIGITS })
+  );
 }
 
 // src/universal/types/pagination.ts
@@ -1258,7 +1311,7 @@ var Isin = (value) => value;
 var AsyncOfferDetail = {
   /**
    * Narrows an offer fetched generically, e.g. on an offer page, to one with
-   * something to claim.
+   * a second leg to show.
    *
    * An exhaustive `switch` rather than a list of async types, so a new offer
    * type is a compile error here until someone decides whether it settles
@@ -1267,10 +1320,10 @@ var AsyncOfferDetail = {
   is: (offer) => {
     switch (offer.type) {
       case "centrifuge::vault":
+      case "coinlist::token_sale":
         return true;
       case "ondo::swap":
       case "superstate::swap":
-      case "coinlist::token_sale":
         return false;
       default: {
         const exhaustive = offer;
@@ -1300,6 +1353,17 @@ var OfferVaultContract = {
    */
   listFromDto: (dtos) => dtos.filter((dto) => isChain(dto.chain)).map(OfferVaultContract.fromDto)
 };
+var OfferFundingContract = {
+  fromDto: (dto) => ({
+    chain: Chain(dto.chain),
+    address: EvmContractAddress(dto.address)
+  }),
+  /**
+   * Drops every contract on a chain this SDK does not name, as
+   * {@link OfferVaultContract.listFromDto} does.
+   */
+  listFromDto: (dtos) => dtos.filter((dto) => isChain(dto.chain)).map(OfferFundingContract.fromDto)
+};
 var OfferDetail = {
   fromDto: (dto) => {
     const fundingAssets = requiredArray(
@@ -1341,7 +1405,15 @@ var OfferDetail = {
           ...base2,
           ...OfferEditorial.fromDto(dto, "OfferDetail"),
           type: dto.type,
-          logoUrl: requiredString(dto.logo_url, "OfferDetail.logo_url")
+          logoUrl: requiredString(dto.logo_url, "OfferDetail.logo_url"),
+          // `[]` is fine and a missing key is not, as for `swap_contracts`:
+          // this is the spender a participation's approval names.
+          fundingContracts: OfferFundingContract.listFromDto(
+            requiredArray(
+              dto.funding_contracts,
+              "OfferDetail.funding_contracts"
+            )
+          )
         };
       case "superstate::swap":
         return {
@@ -1419,8 +1491,6 @@ var Milestone = {
 
 // src/universal/types/providers/coin-list/token-sale.ts
 var ParticipationId = (value) => value;
-var Blockchain = (value) => value;
-var WalletAddress = (value) => value;
 var ParticipationsPaginationParams = {
   toQueryParams: (params) => {
     const queryParams = PaginationParams.toQueryParams(params);
@@ -1444,10 +1514,10 @@ var Participation = {
       amount: dto.amount,
       displayAmount: dto.amount_string,
       asset: Asset.fromDto(dto.asset),
-      chain: Blockchain(dto.chain),
+      chain: isChain(dto.chain) ? dto.chain : null,
       insertedAt: dto.inserted_at ? new Date(dto.inserted_at) : null,
       updatedAt: dto.updated_at ? new Date(dto.updated_at) : null,
-      walletAddress: walletAddress ? WalletAddress(walletAddress) : null
+      walletAddress: walletAddress ? EvmWalletAddress(walletAddress) : null
     };
   }
 };
@@ -1464,6 +1534,22 @@ var CreateParticipationParams = {
   })
 };
 
+// src/universal/api/pagination.ts
+async function fetchAllPages(fetchPage, baseParams) {
+  const items = [];
+  let cursor = null;
+  do {
+    const params = {
+      ...baseParams ?? {},
+      after: cursor ?? void 0
+    };
+    const page = await fetchPage(params);
+    items.push(...page.data);
+    cursor = page.startingAfter;
+  } while (cursor);
+  return items;
+}
+
 // src/universal/api/frontline/providers/coin-list/token-sale.ts
 async function fetchParticipations(api, offerId) {
   return fetchAllPages(
@@ -1498,7 +1584,7 @@ async function createParticipation(api, params) {
   return Participation.fromDto(dto);
 }
 
-// src/universal/core/checkout/coin-list/token-sale-namespace.ts
+// src/universal/core/providers/coin-list/token-sale-namespace.ts
 var CoinListTokenSaleNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -1530,180 +1616,6 @@ var CoinListTokenSaleNamespaceImpl = class {
   }
 };
 
-// src/universal/types/blockchain/ui.ts
-var FormattedAmountUi = (value) => value;
-var FormattedPercentUi = (value) => value;
-var TxExplorerUrl = (value) => value;
-var ShortenedWalletAddress = (value) => value;
-var FormattedAmountAssetUi = (value) => value;
-var AssetIconUrl = (value) => value;
-
-// src/universal/core/shared/blockchain/formatters.ts
-import { formatUnits } from "viem";
-function shortenAddress(address) {
-  const short = address.length > 10 ? `${address.slice(0, 6)}\u2026${address.slice(-4)}` : address;
-  return ShortenedWalletAddress(short);
-}
-function formatAmount(amount, locale, options) {
-  const decimal = formatRawAmount(amount);
-  let [integerPart, fractionPart = ""] = decimal.split(".");
-  const maxFractionDigits = options?.maxFractionDigits;
-  const minFractionDigits = Math.min(
-    options?.minFractionDigits ?? (maxFractionDigits !== void 0 ? maxFractionDigits : 2),
-    maxFractionDigits ?? amount.decimals,
-    amount.decimals
-  );
-  if (maxFractionDigits !== void 0 && fractionPart.length > maxFractionDigits) {
-    ({ integerPart, fractionPart } = roundFractionHalfUp(
-      integerPart,
-      fractionPart,
-      maxFractionDigits
-    ));
-  }
-  const trimmed = fractionPart.replace(/0+$/, "");
-  const fraction = trimmed.padEnd(minFractionDigits, "0");
-  const integerFormatted = BigInt(integerPart).toLocaleString(locale);
-  if (minFractionDigits === 0 && fraction === "") {
-    return FormattedAmountUi(integerFormatted);
-  }
-  const decimalSeparator = new Intl.NumberFormat(locale).formatToParts(1.1).find((p) => p.type === "decimal")?.value ?? ".";
-  return FormattedAmountUi(`${integerFormatted}${decimalSeparator}${fraction}`);
-}
-function roundFractionHalfUp(integerPart, fractionPart, maxFractionDigits) {
-  if (fractionPart.length <= maxFractionDigits) {
-    return { integerPart, fractionPart };
-  }
-  if (maxFractionDigits === 0) {
-    const roundUp = fractionPart[0] >= "5";
-    const integer = BigInt(integerPart) + (roundUp ? 1n : 0n);
-    return { integerPart: integer.toString(), fractionPart: "" };
-  }
-  const trimmed = fractionPart.slice(0, maxFractionDigits);
-  if (fractionPart[maxFractionDigits] < "5") {
-    return { integerPart, fractionPart: trimmed };
-  }
-  const digits = trimmed.split("").map((digit) => Number.parseInt(digit, 10));
-  let carry = 1;
-  for (let i = digits.length - 1; i >= 0 && carry > 0; i -= 1) {
-    const sum = digits[i] + carry;
-    if (sum === 10) {
-      digits[i] = 0;
-      carry = 1;
-    } else {
-      digits[i] = sum;
-      carry = 0;
-    }
-  }
-  return {
-    integerPart: carry > 0 ? (BigInt(integerPart) + 1n).toString() : integerPart,
-    fractionPart: digits.join("")
-  };
-}
-function formatRawAmount(amount) {
-  return formatUnits(amount.raw, amount.decimals);
-}
-function formatCompactAmount(amount, locale) {
-  const value = Number(formatRawAmount(amount));
-  const formatted = new Intl.NumberFormat(locale, {
-    notation: "compact",
-    maximumFractionDigits: 2
-  }).format(value);
-  return FormattedAmountUi(formatted);
-}
-function formatBpsAsPercent(bps, locale) {
-  const whole = bps / 100n;
-  const fraction = bps % 100n;
-  const wholeFormatted = whole.toLocaleString(locale);
-  const decimalSeparator = new Intl.NumberFormat(locale).formatToParts(1.1).find((p) => p.type === "decimal")?.value ?? ".";
-  if (fraction === 0n) {
-    return FormattedPercentUi(`${wholeFormatted}%`);
-  }
-  const fractionFormatted = fraction.toString().padStart(2, "0").replace(/0+$/, "");
-  return FormattedPercentUi(
-    `${wholeFormatted}${decimalSeparator}${fractionFormatted}%`
-  );
-}
-function usdAmount(amount) {
-  return FormattedAmountAssetUi(`$${amount}`);
-}
-function assetAmount(amount, symbol) {
-  return FormattedAmountAssetUi(`${amount} ${symbol}`);
-}
-var NA_AMOUNT_ASSET_UI = FormattedAmountAssetUi("-");
-var SHARE_MAX_FRACTION_DIGITS = AssetDecimals(6);
-var SHARE_MIN_FRACTION_DIGITS = AssetDecimals(2);
-function formatShareAmount(amount, locale) {
-  return formatAmount(amount, locale, {
-    maxFractionDigits: SHARE_MAX_FRACTION_DIGITS,
-    minFractionDigits: SHARE_MIN_FRACTION_DIGITS
-  });
-}
-var USD_FRACTION_DIGITS = AssetDecimals(2);
-function formattedUsdPrice(amount, locale) {
-  if (!amount) return NA_AMOUNT_ASSET_UI;
-  return usdAmount(
-    formatAmount(amount, locale, { maxFractionDigits: USD_FRACTION_DIGITS })
-  );
-}
-
-// src/universal/core/shared/blockchain/chain.ts
-import { base, baseSepolia, mainnet, sepolia } from "viem/chains";
-var VIEM_CHAINS = {
-  ethereum_mainnet: mainnet,
-  ethereum_sepolia: sepolia,
-  base_mainnet: base,
-  base_sepolia: baseSepolia
-};
-function viemChain(chain) {
-  return VIEM_CHAINS[chain];
-}
-function getChainId(chain) {
-  return VIEM_CHAINS[chain].id;
-}
-function chainFromId(chainId) {
-  const chains = Object.keys(VIEM_CHAINS);
-  const chain = chains.find((c) => String(VIEM_CHAINS[c].id) === chainId);
-  if (!chain) {
-    throw new ValidationError(`Unsupported EIP-155 chain id: "${chainId}"`);
-  }
-  return chain;
-}
-function getNetworkName(chain) {
-  switch (chain) {
-    case "ethereum_mainnet":
-      return "Ethereum";
-    case "ethereum_sepolia":
-      return "Ethereum Sepolia";
-    case "base_mainnet":
-      return "Base";
-    case "base_sepolia":
-      return "Base Sepolia";
-    default: {
-      const _exhaustive = chain;
-      return _exhaustive;
-    }
-  }
-}
-function txExplorerUrl(chain, txHash) {
-  return TxExplorerUrl(`${explorerBaseUrl(chain)}/tx/${txHash}`);
-}
-function explorerBaseUrl(chain) {
-  switch (chain) {
-    case "ethereum_mainnet":
-      return "https://etherscan.io";
-    case "ethereum_sepolia":
-      return "https://sepolia.etherscan.io";
-    case "base_mainnet":
-      return "https://basescan.org";
-    case "base_sepolia":
-      return "https://sepolia-explorer.base.org";
-    default: {
-      const _exhaustive = chain;
-      return _exhaustive;
-    }
-  }
-}
-
 // src/universal/types/providers/ondo/ondo.ts
 var OndoTradingStatus = {
   fromDto: (dto) => {
@@ -1758,7 +1670,7 @@ var OndoBuyTransaction = {
         raw: dto.notional_value,
         decimals: spendDecimals
       }),
-      receiveOutputAmount: parsePositiveAmount({
+      receiveOutputAmount: positiveAmountFromRawOrThrow({
         label: "receive_output_amount",
         raw: dto.receive_output_amount,
         decimals: outputDecimals,
@@ -1777,7 +1689,7 @@ var OndoSellTransaction = {
   fromDto: (dto) => {
     const spendDecimals = AssetDecimals(dto.spend_input_decimals);
     const outputDecimals = AssetDecimals(dto.receive_output_decimals);
-    const expectedQuantity = parsePositiveAmount({
+    const expectedQuantity = positiveAmountFromRawOrThrow({
       label: "expected_quantity",
       raw: dto.expected_quantity,
       decimals: outputDecimals,
@@ -1811,12 +1723,12 @@ var OndoSellTransaction = {
 };
 function parseSwapCore(dto, spendDecimals) {
   return {
-    tx: {
-      to: EvmContractAddress(dto.to),
-      data: HexEncodedTransactionData(dto.data)
-    },
-    expiresAt: parseExpiresAt(dto.expires_at),
-    spendInputAmount: parsePositiveAmount({
+    tx: txFromWire(dto),
+    // A transaction whose expiry cannot be read is not safely fillable - the
+    // deadline is encoded in the calldata either way, so broadcasting against
+    // an unknown one only spends gas on a revert.
+    expiresAt: requiredDate(dto.expires_at, "expires_at"),
+    spendInputAmount: positiveAmountFromRawOrThrow({
       label: "spend_input_amount",
       raw: dto.spend_input_amount,
       decimals: spendDecimals,
@@ -1834,7 +1746,7 @@ function parseSwapCore(dto, spendDecimals) {
   };
 }
 function parseMinimumQuantity(raw, decimals, expectedQuantity) {
-  const amount = parsePositiveAmount({
+  const amount = positiveAmountFromRawOrThrow({
     label: "minimum_quantity",
     raw,
     decimals,
@@ -1847,27 +1759,6 @@ function parseMinimumQuantity(raw, decimals, expectedQuantity) {
   }
   return amount;
 }
-function parsePositiveAmount({
-  label,
-  raw,
-  decimals,
-  reason
-}) {
-  const amount = blockchainAmountFromRawOrThrow({ label, raw, decimals });
-  if (amount.raw <= 0n) {
-    throw new ValidationError(
-      `${label}: must be greater than zero ("${raw}") - ${reason}`
-    );
-  }
-  return amount;
-}
-function parseExpiresAt(value) {
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) {
-    throw new ValidationError(`expires_at: not a date ("${value}")`);
-  }
-  return date;
-}
 
 // src/universal/api/frontline/providers/ondo/ondo.ts
 async function getOndoTradingStatus(api, params) {
@@ -1923,27 +1814,15 @@ async function buildOndoSell(api, params) {
     // or a QA run reads as a puzzle rather than a diagnosis.
     note: "the quote resolves the asset on Ethereum mainnet while the swap executes on the chain requested, so these disagree until frontline serves a chain-scoped quote"
   });
-  return OndoSellTransaction.fromDto(dto);
-}
-function swapBody(params) {
-  return {
-    symbol: params.symbol,
-    chain: params.chain,
-    wallet_address: params.walletAddress,
-    amount: params.amount.raw.toString()
-  };
-}
-function assertSpendScaleAgrees({
-  published,
-  sized,
-  trade,
-  note
-}) {
-  if (published === sized.decimals) return;
-  const because = note === void 0 ? "" : ` - ${note}`;
-  throw new ValidationError(
-    `spend_input_decimals: the ${trade} was priced in ${published} decimals but the order was sized in ${sized.decimals}${because}`
-  );
+  return OndoSellTransaction.fromDto(dto);
+}
+function swapBody(params) {
+  return {
+    symbol: params.symbol,
+    chain: params.chain,
+    wallet_address: params.walletAddress,
+    amount: params.amount.raw.toString()
+  };
 }
 function sizeParam(params) {
   const tokenAmount = "tokenAmount" in params ? params.tokenAmount : void 0;
@@ -1964,7 +1843,7 @@ function sizeParam(params) {
   return { notional_value: notionalValue };
 }
 
-// src/universal/core/checkout/ondo/ondo-namespace.ts
+// src/universal/core/providers/ondo/ondo-namespace.ts
 var OndoNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -1996,7 +1875,101 @@ var OndoNamespaceImpl = class {
   }
 };
 
-// src/universal/core/checkout/superstate/blockchain/abi.ts
+// src/universal/types/providers/superstate/swap.ts
+var SwapPreview = {
+  /** Maps the contract's `Preview { input, fee, output }` struct. */
+  fromContract: (preview) => ({
+    inputAmount: parseUint256(preview.input, "SwapPreview.input"),
+    fee: parseUint256(preview.fee, "SwapPreview.fee"),
+    outputAmount: parseUint256(preview.output, "SwapPreview.output")
+  })
+};
+var PauseFlags = (value) => value;
+var SwapStatus = {
+  /**
+   * Maps the contract's `Status { uint32 flags; State state }` struct, where
+   * `State` is `0 = Active | 1 = Paused | 2 = Stopped`.
+   *
+   * `flags` is carried onto the `paused` arm only. On the other two the
+   * contract sets it to a self-identifying marker rather than to information -
+   * so repeating it would invite a caller to read meaning into a constant.
+   *
+   * @throws ValidationError on a `state` outside the enum. A contract that has
+   * grown a fourth state is one the SDK does not model, and guessing `active`
+   * would let a halted swap read as a live one.
+   */
+  fromContract: (status) => {
+    switch (status.state) {
+      case 0:
+        return { state: "active" };
+      case 1:
+        return { state: "paused", pausedLevels: PauseFlags(status.flags) };
+      case 2:
+        return { state: "stopped" };
+      default:
+        throw new ValidationError(
+          `SwapStatus.state: unknown contract state (${status.state})`
+        );
+    }
+  }
+};
+var AllowWalletResponse = {
+  fromDto: (dto) => {
+    switch (dto.action) {
+      case "broadcast_transaction":
+        return {
+          action: "broadcast_transaction",
+          tx: txFromWire(dto)
+        };
+      case "none":
+        return {
+          action: "none",
+          alreadyAllowed: dto.already_allowed
+        };
+      default: {
+        const _exhaustive = dto;
+        return _exhaustive;
+      }
+    }
+  }
+};
+
+// src/universal/core/providers/superstate/blockchain/quote.ts
+var SwapQuote = {
+  /**
+   * Assembles a {@link SwapQuote} from a raw contract {@link SwapPreview}. The
+   * input and fee are denominated in the input token; the output in the output
+   * token.
+   */
+  fromPreview: (preview, inputDecimals, outputDecimals) => ({
+    inputTokenAmount: BlockchainAmount({
+      raw: preview.inputAmount,
+      decimals: inputDecimals
+    }),
+    fee: BlockchainAmount({ raw: preview.fee, decimals: inputDecimals }),
+    outputTokenAmount: BlockchainAmount({
+      raw: preview.outputAmount,
+      decimals: outputDecimals
+    })
+  })
+};
+
+// src/universal/api/frontline/providers/superstate/swap.ts
+async function allowWallet(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: `/v1/offers/${encodeURIComponent(params.offerId)}/allow-wallet`,
+    body: {
+      wallet_address: params.walletAddress,
+      chain: params.chain,
+      signature: params.signature
+    },
+    attributes: Attributes.protected()
+  });
+  return AllowWalletResponse.fromDto(dto);
+}
+
+// src/universal/core/providers/superstate/blockchain/abi.ts
 var SUPERSTATE_SWAP_ABI = [
   {
     type: "function",
@@ -2868,80 +2841,105 @@ var SUPERSTATE_SWAP_ABI = [
   }
 ];
 
-// src/universal/types/providers/superstate/swap.ts
-var SwapPreview = {
-  /** Maps the contract's `Preview { input, fee, output }` struct. */
-  fromContract: (preview) => ({
-    inputAmount: parseUint256(preview.input, "SwapPreview.input"),
-    fee: parseUint256(preview.fee, "SwapPreview.fee"),
-    outputAmount: parseUint256(preview.output, "SwapPreview.output")
-  })
-};
-var PauseFlags = (value) => value;
-var SwapStatus = {
-  /**
-   * Maps the contract's `Status { uint32 flags; State state }` struct, where
-   * `State` is `0 = Active | 1 = Paused | 2 = Stopped`.
-   *
-   * `flags` is carried onto the `paused` arm only. On the other two the
-   * contract sets it to a self-identifying marker rather than to information -
-   * so repeating it would invite a caller to read meaning into a constant.
-   *
-   * @throws ValidationError on a `state` outside the enum. A contract that has
-   * grown a fourth state is one the SDK does not model, and guessing `active`
-   * would let a halted swap read as a live one.
-   */
-  fromContract: (status) => {
-    switch (status.state) {
-      case 0:
-        return { state: "active" };
-      case 1:
-        return { state: "paused", pausedLevels: PauseFlags(status.flags) };
-      case 2:
-        return { state: "stopped" };
-      default:
-        throw new ValidationError(
-          `SwapStatus.state: unknown contract state (${status.state})`
-        );
-    }
-  }
-};
-var AllowWalletResponse = {
-  fromDto: (dto) => {
-    switch (dto.action) {
-      case "broadcast_transaction":
-        return {
-          action: "broadcast_transaction",
-          to: EvmContractAddress(dto.to),
-          data: HexEncodedTransactionData(dto.data)
-        };
-      case "none":
-        return {
-          action: "none",
-          alreadyAllowed: dto.already_allowed
-        };
-      default: {
-        const _exhaustive = dto;
-        return _exhaustive;
-      }
-    }
-  }
-};
-
-// src/universal/api/frontline/providers/superstate/swap.ts
-async function allowWallet(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: `/v1/offers/${encodeURIComponent(params.offerId)}/allow-wallet`,
-    body: {
-      wallet_address: params.walletAddress,
-      chain: params.chain,
-      signature: params.signature
-    },
-    attributes: Attributes.protected()
-  });
-  return AllowWalletResponse.fromDto(dto);
-}
+// src/universal/core/shared/blockchain/erc20/abi.ts
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decimals",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "name",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "symbol",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    inputs: [
+      { name: "sender", type: "address" },
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "spender", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  }
+];
 
 // src/universal/api/rpc/providers/superstate/swap.ts
 async function getSwapAuthorization(clients, params) {
@@ -2992,7 +2990,7 @@ async function getSwapOutputToken(clients, params) {
   };
 }
 
-// src/universal/core/checkout/superstate/swap-namespace.ts
+// src/universal/core/providers/superstate/superstate-namespace.ts
 var SuperstateSwapNamespaceImpl = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -3012,6 +3010,20 @@ var SuperstateSwapNamespaceImpl = class {
       async () => getSwapPreview(this.ctx.rpc, params)
     );
   }
+  async getQuote(params) {
+    return this.log.wrap("getQuote", params, async () => {
+      const { amount, outputTokenDecimals, ...ref } = params;
+      const preview = await getSwapPreview(this.ctx.rpc, {
+        ...ref,
+        amount: amount.raw
+      });
+      return SwapQuote.fromPreview(
+        preview,
+        amount.decimals,
+        outputTokenDecimals
+      );
+    });
+  }
   async getStatus(params) {
     return this.log.wrap(
       "getStatus",
@@ -3209,6 +3221,202 @@ var RequirementsNamespaceImpl = class {
   }
 };
 
+// src/universal/types/offer-option-address.ts
+var OfferOptionAddressId = (value) => value;
+var OfferOptionAddress = {
+  /** Maps the API DTO into the SDK offer-option-address domain model. */
+  fromDto: (dto) => ({
+    id: OfferOptionAddressId(dto.id),
+    offerOptionId: OfferOptionId(dto.offer_option_id),
+    address: EvmWalletAddress(dto.address),
+    protocol: dto.protocol,
+    createdAt: new Date(dto.created_at)
+  })
+};
+var ConnectExternalWalletParams = {
+  /** Maps connect-wallet params into the API DTO payload. */
+  toDto: (params) => ({
+    offer_option_id: params.offerOptionId,
+    wallet_address: params.walletAddress,
+    chain: params.chain,
+    signature: params.signature
+  })
+};
+
+// src/universal/types/wallet-ownership-challenge.ts
+var WalletOwnershipChallenge = {
+  /** Maps the API DTO into the SDK wallet-ownership-challenge domain model. */
+  fromDto: (dto) => ({
+    message: dto.message,
+    expiresAt: new Date(dto.expires_at)
+  })
+};
+var CreateWalletOwnershipChallengeParams = {
+  /**
+   * Maps challenge-request params into the API DTO payload. The discriminated
+   * union guarantees SIWE fields are present exactly when `challengeType` is
+   * `siwe`, so the mapping narrows on the discriminant.
+   */
+  toDto: (params) => {
+    switch (params.challengeType) {
+      case "plain":
+        return {
+          wallet_address: params.walletAddress,
+          chain: params.chain,
+          challenge_type: "plain"
+        };
+      case "siwe":
+        return {
+          wallet_address: params.walletAddress,
+          chain: params.chain,
+          challenge_type: "siwe",
+          domain: params.domain,
+          uri: params.uri,
+          statement: params.statement
+        };
+      default: {
+        const _exhaustive = params;
+        return _exhaustive;
+      }
+    }
+  }
+};
+
+// src/universal/api/frontline/wallet-connect.ts
+async function createWalletOwnershipChallenge(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/wallet-ownership",
+    body: CreateWalletOwnershipChallengeParams.toDto(params),
+    attributes: Attributes.protected()
+  });
+  return WalletOwnershipChallenge.fromDto(dto);
+}
+async function connectExternalWallet(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: `/v1/offers/${params.offerId}/addresses`,
+    body: ConnectExternalWalletParams.toDto(params),
+    attributes: Attributes.protected()
+  });
+  return OfferOptionAddress.fromDto(dto);
+}
+async function listOptionAddresses(api, offerId, offerOptionId) {
+  const { data } = await api.send({
+    method: "GET",
+    url: `/v1/offers/${offerId}/addresses`,
+    queryParams: { offer_option_id: offerOptionId },
+    attributes: Attributes.protected()
+  });
+  return data.map(OfferOptionAddress.fromDto);
+}
+async function removeOptionAddress(api, offerId, addressId) {
+  const dto = await api.send({
+    method: "DELETE",
+    url: `/v1/offers/${offerId}/addresses/${addressId}`,
+    attributes: Attributes.protected()
+  });
+  return OfferOptionAddress.fromDto(dto);
+}
+
+// src/universal/core/wallets/wallets-namespace.ts
+var WalletsNamespaceImpl = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "WALLETS");
+  }
+  async createOwnershipChallenge(params) {
+    return this.log.wrap("createOwnershipChallenge", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createWalletOwnershipChallenge(
+        this.ctx.api,
+        params
+      );
+    });
+  }
+  async connectExternal(params) {
+    return this.log.wrap("connectExternal", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return connectExternalWallet(this.ctx.api, params);
+    });
+  }
+  async list(params) {
+    return this.log.wrap("list", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return listOptionAddresses(
+        this.ctx.api,
+        params.offerId,
+        params.offerOptionId
+      );
+    });
+  }
+  async remove(params) {
+    return this.log.wrap("remove", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return removeOptionAddress(
+        this.ctx.api,
+        params.offerId,
+        params.addressId
+      );
+    });
+  }
+};
+
+// src/universal/api/frontline/offers.ts
+async function fetchOffers(api, clientCreds) {
+  return fetchAllPages((params) => fetchOffersPage(api, params, clientCreds));
+}
+async function fetchOffersPage(api, params, clientCreds) {
+  const queryParams = PaginationParams.toQueryParams(params);
+  const pageDto = await api.send({
+    method: "GET",
+    url: "/v1/offers",
+    queryParams,
+    attributes: Attributes.concat(
+      Attributes.protected(),
+      Attributes.clientCredentials(clientCreds)
+    )
+  });
+  return PaginatedResponse.fromDtoPage(pageDto, Offer.listFromDto);
+}
+async function fetchOfferDetails(api, id, clientCreds) {
+  const dto = await api.send({
+    method: "GET",
+    url: `/v1/offers/${id}`,
+    attributes: Attributes.concat(
+      Attributes.protected(),
+      Attributes.clientCredentials(clientCreds)
+    )
+  });
+  return OfferDetail.fromDto(dto);
+}
+
+// src/universal/core/offers/offers-namespace.ts
+var OffersNamespaceImpl = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "OFFERS");
+  }
+  async list() {
+    return this.log.wrap("list", void 0, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchOffers(this.ctx.api, void 0);
+    });
+  }
+  async listPage(params) {
+    return this.log.wrap("listPage", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchOffersPage(this.ctx.api, params, void 0);
+    });
+  }
+  async get(id) {
+    return this.log.wrap("get", id, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return fetchOfferDetails(this.ctx.api, id, void 0);
+    });
+  }
+};
+
 // src/universal/api/rpc/erc20.ts
 async function getTokenAllowance(clients, params) {
   const allowance = await clients(params.chain).readContract({
@@ -3316,207 +3524,26 @@ function tokensOfChain(chain, assets, baseUrl) {
     decimals: AssetDecimals(asset.decimals),
     logo: TokenLogo.fromDto(asset.logo, baseUrl),
     logoDark: asset.logo_dark === void 0 ? null : TokenLogo.fromDto(asset.logo_dark, baseUrl)
-  }));
-}
-function assertSupportedSchemaVersion(version) {
-  if (version !== 1) {
-    throw new ValidationError(
-      `Unsupported token registry schema_version: ${version}`
-    );
-  }
-}
-var logoImageFromDto = (dto, baseUrl) => ({
-  url: resolveLogoUrl(dto.url, baseUrl),
-  width: dto.width,
-  height: dto.height
-});
-var resolveLogoUrl = (url, baseUrl) => TokenLogoUrl(
-  url.startsWith("http") ? url : `${baseUrl.replace(/\/$/, "")}${url}`
-);
-
-// src/universal/api/nabu/tokens.ts
-import { getAddress } from "viem";
-
-// src/universal/api/frontline/config.ts
-var PUBLIC_API_BASE_URL = "https://api.coinlist.co";
-var HEADER_API_VERSION = "X-API-Version";
-var HEADER_USER_AGENT = "User-Agent";
-var HEADER_IDEMPOTENCY_KEY = "Idempotency-Key";
-var API_VERSION = "2025-10-17";
-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_ACCREDITATION_PATH = "/verify-identity/accreditation_full";
-var WALLET_PATH = "/wallet";
-
-// src/universal/api/http-client.ts
-var HttpClient = class {
-  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);
-  }
-  /**
-   * Runs beforeRequest, executeRequest, then the full afterRequest middleware
-   * chain. Used by send() and by the retry() callback so that when a
-   * middleware calls retry(), the retried response also goes through all
-   * afterRequest middleware (e.g. session renewal, retry). Middleware
-   * must use request.attributes.retryAttempt (or similar) to avoid infinite
-   * recursion when they trigger retries.
-   */
-  async runRequestWithAfterMiddleware(request) {
-    const preparedRequest = await this.runBeforeRequestMiddleware(
-      this.withClientDefaults(request)
-    );
-    let response = await this.executeRequest(preparedRequest);
-    for (const middleware of this.middleware.afterRequest ?? []) {
-      let retried = false;
-      response = await middleware({
-        request: preparedRequest,
-        response,
-        retry: (nextRequest = preparedRequest) => {
-          retried = true;
-          return this.runRequestWithAfterMiddleware(nextRequest);
-        }
-      });
-      if (retried) {
-        return response;
-      }
-    }
-    return response;
-  }
-  withClientDefaults(request) {
-    const url = this.resolveUrl(request.url);
-    const headers = {
-      ...request.headers ?? {},
-      ...this.config.xApiVersion !== void 0 ? { [HEADER_API_VERSION]: this.config.xApiVersion } : {}
-    };
-    return {
-      ...request,
-      url,
-      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
-    };
-  }
-  /**
-   * Resolves a request URL against the client's baseUrl.
-   *
-   * @internal Public only for testing. Do not use in application code; use
-   * {@link HttpClient.send} with a path and the client will resolve the URL.
-   */
-  resolveUrl(url) {
-    if (url.startsWith("http://") || url.startsWith("https://")) {
-      return url;
-    }
-    const base2 = this.config.baseUrl.replace(/\/$/, "");
-    const path = url.startsWith("/") ? url : `/${url}`;
-    return base2 + path;
-  }
-  async runBeforeRequestMiddleware(initialRequest) {
-    let request = initialRequest;
-    for (const middleware of this.middleware.beforeRequest ?? []) {
-      request = await middleware(request);
-    }
-    return 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 } : {}
-  };
+function assertSupportedSchemaVersion(version) {
+  if (version !== 1) {
+    throw new ValidationError(
+      `Unsupported token registry schema_version: ${version}`
+    );
+  }
 }
+var logoImageFromDto = (dto, baseUrl) => ({
+  url: resolveLogoUrl(dto.url, baseUrl),
+  width: dto.width,
+  height: dto.height
+});
+var resolveLogoUrl = (url, baseUrl) => TokenLogoUrl(
+  url.startsWith("http") ? url : `${baseUrl.replace(/\/$/, "")}${url}`
+);
 
 // src/universal/api/nabu/tokens.ts
-function createNabuApiClient(baseUrl, logger = null) {
-  return new HttpClient({ baseUrl }, {}, logger);
-}
+import { getAddress } from "viem";
 async function fetchTokenMetadata(client, token) {
   const address = checksummed(token.address);
   let response;
@@ -3604,254 +3631,64 @@ function checksummed(address) {
   }
 }
 
-// src/universal/core/tokens/tokens-namespace.ts
+// src/universal/core/shared/blockchain/tokens/tokens-namespace.ts
 var TokensNamespaceImpl = class {
-  /**
-   * Takes the registry origin rather than a `UniversalNamespaceContext`: the
-   * registry is unauthenticated and on its own host, so the frontline sender
-   * and the auth check would both be dead weight here.
-   */
-  constructor(baseUrl, logger = null) {
-    this.api = createNabuApiClient(baseUrl, logger);
-    this.log = internalLogger(logger, "TOKENS");
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "TOKENS");
   }
   get(token) {
     return this.log.wrap(
       "get",
       token,
-      () => fetchTokenMetadata(this.api, token)
+      () => fetchTokenMetadata(this.ctx.nabu, token)
     );
   }
   list(chain) {
     return this.log.wrap(
       "list",
       chain,
-      () => chain === void 0 ? fetchAllTokensMetadata(this.api) : fetchTokensMetadata(this.api, chain)
+      () => chain === void 0 ? fetchAllTokensMetadata(this.ctx.nabu) : fetchTokensMetadata(this.ctx.nabu, chain)
     );
   }
 };
 
-// src/universal/types/offer-option-address.ts
-var OfferOptionAddressId = (value) => value;
-var OfferOptionAddress = {
-  /** Maps the API DTO into the SDK offer-option-address domain model. */
-  fromDto: (dto) => ({
-    id: OfferOptionAddressId(dto.id),
-    offerOptionId: OfferOptionId(dto.offer_option_id),
-    address: EvmWalletAddress(dto.address),
-    protocol: dto.protocol,
-    createdAt: new Date(dto.created_at)
-  })
-};
-var ConnectExternalWalletParams = {
-  /** Maps connect-wallet params into the API DTO payload. */
-  toDto: (params) => ({
-    offer_option_id: params.offerOptionId,
-    wallet_address: params.walletAddress,
-    chain: params.chain,
-    signature: params.signature
-  })
-};
-
-// src/universal/types/wallet-ownership-challenge.ts
-var WalletOwnershipChallenge = {
-  /** Maps the API DTO into the SDK wallet-ownership-challenge domain model. */
-  fromDto: (dto) => ({
-    message: dto.message,
-    expiresAt: new Date(dto.expires_at)
-  })
-};
-var CreateWalletOwnershipChallengeParams = {
-  /**
-   * Maps challenge-request params into the API DTO payload. The discriminated
-   * union guarantees SIWE fields are present exactly when `challengeType` is
-   * `siwe`, so the mapping narrows on the discriminant.
-   */
-  toDto: (params) => {
-    switch (params.challengeType) {
-      case "plain":
-        return {
-          wallet_address: params.walletAddress,
-          chain: params.chain,
-          challenge_type: "plain"
-        };
-      case "siwe":
-        return {
-          wallet_address: params.walletAddress,
-          chain: params.chain,
-          challenge_type: "siwe",
-          domain: params.domain,
-          uri: params.uri,
-          statement: params.statement
-        };
-      default: {
-        const _exhaustive = params;
-        return _exhaustive;
-      }
-    }
-  }
-};
-
-// src/universal/api/frontline/wallet-connect.ts
-async function createWalletOwnershipChallenge(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: "/v1/wallet-ownership",
-    body: CreateWalletOwnershipChallengeParams.toDto(params),
-    attributes: Attributes.protected()
-  });
-  return WalletOwnershipChallenge.fromDto(dto);
-}
-async function connectExternalWallet(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: `/v1/offers/${params.offerId}/addresses`,
-    body: ConnectExternalWalletParams.toDto(params),
-    attributes: Attributes.protected()
-  });
-  return OfferOptionAddress.fromDto(dto);
-}
-async function listOptionAddresses(api, offerId, offerOptionId) {
-  const { data } = await api.send({
-    method: "GET",
-    url: `/v1/offers/${offerId}/addresses`,
-    queryParams: { offer_option_id: offerOptionId },
-    attributes: Attributes.protected()
-  });
-  return data.map(OfferOptionAddress.fromDto);
-}
-async function removeOptionAddress(api, offerId, addressId) {
-  const dto = await api.send({
-    method: "DELETE",
-    url: `/v1/offers/${offerId}/addresses/${addressId}`,
-    attributes: Attributes.protected()
-  });
-  return OfferOptionAddress.fromDto(dto);
-}
-
-// src/universal/core/wallets/wallets-namespace.ts
-var WalletsNamespaceImpl = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-    this.log = internalLogger(ctx.logger, "WALLETS");
-  }
-  async createOwnershipChallenge(params) {
-    return this.log.wrap("createOwnershipChallenge", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return createWalletOwnershipChallenge(
-        this.ctx.api,
-        params
-      );
-    });
-  }
-  async connectExternal(params) {
-    return this.log.wrap("connectExternal", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return connectExternalWallet(this.ctx.api, params);
-    });
-  }
-  async list(params) {
-    return this.log.wrap("list", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return listOptionAddresses(
-        this.ctx.api,
-        params.offerId,
-        params.offerOptionId
-      );
-    });
-  }
-  async remove(params) {
-    return this.log.wrap("remove", params, async () => {
-      await this.ctx.ensureUserAuthenticated();
-      return removeOptionAddress(
-        this.ctx.api,
-        params.offerId,
-        params.addressId
-      );
-    });
-  }
-};
-
-// src/universal/types/oauth-session.ts
-var ClientCredentialsOAuth = (value) => value;
-var OAuthRefreshToken = (value) => value;
-var OAuthSession = {
-  fromDto: (dto) => {
-    const expiresAt = new Date(Date.now() + dto.expires_in * 1e3);
-    return {
-      accessToken: {
-        value: dto.access_token,
-        expiresAt
-      },
-      ...dto.refresh_token != null && dto.refresh_token !== "" ? { refreshToken: OAuthRefreshToken(dto.refresh_token) } : void 0
-    };
-  }
-};
-
-// src/universal/api/frontline/offers.ts
-async function fetchOffers(api, clientCreds) {
-  return fetchAllPages((params) => fetchOffersPage(api, params, clientCreds));
-}
-async function fetchOffersPage(api, params, clientCreds) {
-  const queryParams = PaginationParams.toQueryParams(params);
-  const pageDto = await api.send({
-    method: "GET",
-    url: "/v1/offers",
-    queryParams,
-    attributes: Attributes.concat(
-      Attributes.protected(),
-      Attributes.clientCredentials(clientCreds)
-    )
-  });
-  return PaginatedResponse.fromDtoPage(pageDto, Offer.listFromDto);
-}
-async function fetchOfferDetails(api, id, clientCreds) {
-  const dto = await api.send({
-    method: "GET",
-    url: `/v1/offers/${id}`,
-    attributes: Attributes.concat(
-      Attributes.protected(),
-      Attributes.clientCredentials(clientCreds)
-    )
-  });
-  return OfferDetail.fromDto(dto);
-}
-
 export {
   sha256,
   arrayBufferToBase64Url,
   generateSecureRandomBase64Url,
   getUUIDv4,
-  PUBLIC_API_BASE_URL,
-  HEADER_USER_AGENT,
-  HEADER_IDEMPOTENCY_KEY,
-  API_VERSION,
-  COINLIST_BASE_URL,
-  OAUTH_PAGE_PATH,
-  SUPPORT_NEW_TICKET_URL,
-  VERIFY_IDENTITY_PATH,
-  VERIFY_IDENTITY_ACCREDITATION_PATH,
-  WALLET_PATH,
   SentWith,
   TokenTrigger,
   isRejectedToken,
   Attributes,
   HttpError,
   apiErrorCode,
-  Request,
   NotImplementedError,
   NotAuthenticatedError,
   ValidationError,
   InvariantError,
   MathError,
+  classifyLogCause,
   describeErrorUnredacted,
   internalLogger,
-  HttpClient,
   EpochMillis,
   Millis,
   Seconds,
   isExpired,
   ERC20_ABI,
+  FormattedAmountUi,
+  FormattedPercentUi,
+  TxExplorerUrl,
+  ShortenedWalletAddress,
+  FormattedAmountAssetUi,
+  AssetIconUrl,
+  viemChain,
+  getChainId,
+  chainFromId,
+  contractOn,
+  getNetworkName,
+  txExplorerUrl,
   ETHEREUM_CHAINS,
   EthereumChain,
   SOLANA_CHAINS,
@@ -3874,17 +3711,30 @@ export {
   KnownAssetSymbol,
   Bps,
   blockchainAmountFromRawOrThrow,
+  positiveAmountFromRawOrThrow,
+  pricePerShare,
   parseBlockchainAmount,
   CentrifugeVaultStatus,
   CentrifugeVaultBuyTransaction,
   CentrifugeVaultClaimTransaction,
-  CentrifugeVaultPosition,
-  CentrifugeVaultRedeemPosition,
+  CentrifugeAssets,
+  CentrifugeShares,
+  CentrifugeDepositPosition,
+  CentrifugeRedeemPosition,
   CentrifugeVaultLeg,
   CentrifugeVaultLegId,
   CentrifugeVaultClaimProceedsTransaction,
   CentrifugeNamespaceImpl,
-  fetchAllPages,
+  shortenAddress,
+  formatAmount,
+  formatRawAmount,
+  formatCompactAmount,
+  formatBpsAsPercent,
+  usdAmount,
+  assetAmount,
+  NA_AMOUNT_ASSET_UI,
+  formatShareAmount,
+  formattedUsdPrice,
   Cursor,
   PaginatedResponse,
   PaginationParams,
@@ -3904,6 +3754,7 @@ export {
   OfferOptionSlug,
   OfferSwapContract,
   OfferVaultContract,
+  OfferFundingContract,
   OfferDetail,
   OfferOption,
   FaqItem,
@@ -3911,33 +3762,10 @@ export {
   TermItem,
   Milestone,
   ParticipationId,
-  Blockchain,
-  WalletAddress,
   ParticipationsPaginationParams,
   Participation,
   CreateParticipationParams,
   CoinListTokenSaleNamespaceImpl,
-  FormattedAmountUi,
-  FormattedPercentUi,
-  TxExplorerUrl,
-  ShortenedWalletAddress,
-  FormattedAmountAssetUi,
-  AssetIconUrl,
-  shortenAddress,
-  formatAmount,
-  formatRawAmount,
-  formatCompactAmount,
-  formatBpsAsPercent,
-  usdAmount,
-  assetAmount,
-  NA_AMOUNT_ASSET_UI,
-  formatShareAmount,
-  formattedUsdPrice,
-  viemChain,
-  getChainId,
-  chainFromId,
-  getNetworkName,
-  txExplorerUrl,
   OndoTradingStatus,
   OndoQuote,
   OndoBuyTransaction,
@@ -3948,10 +3776,8 @@ export {
   PauseFlags,
   SwapStatus,
   AllowWalletResponse,
+  SwapQuote,
   SuperstateSwapNamespaceImpl,
-  fetchOffers,
-  fetchOffersPage,
-  fetchOfferDetails,
   DocumentSubmission,
   KycToken,
   Iso2CountryCode,
@@ -3963,19 +3789,20 @@ export {
   RequirementStatusInfo,
   fetchOfferRequirements,
   RequirementsNamespaceImpl,
-  Erc20NamespaceImpl,
-  TokenLogoUrl,
-  TokenLogo,
-  TokenMetadata,
-  TokensNamespaceImpl,
   OfferOptionAddressId,
   OfferOptionAddress,
   ConnectExternalWalletParams,
   WalletOwnershipChallenge,
   CreateWalletOwnershipChallengeParams,
   WalletsNamespaceImpl,
-  ClientCredentialsOAuth,
-  OAuthRefreshToken,
-  OAuthSession
+  fetchOffers,
+  fetchOffersPage,
+  fetchOfferDetails,
+  OffersNamespaceImpl,
+  Erc20NamespaceImpl,
+  TokenLogoUrl,
+  TokenLogo,
+  TokenMetadata,
+  TokensNamespaceImpl
 };
-//# sourceMappingURL=chunk-C6GF7MDF.js.map
+//# sourceMappingURL=chunk-2FZAXGVH.js.map