@coinlist-co/react 0.12.2-rc.4851c6a → 0.12.2-rc.4cc3d7e

package/dist/{chunk-GOUUYOPZ.js → chunk-ANPPXFXD.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,6 +104,75 @@ function isExpired({
   return now >= expiresAt - buffer;
 }
 
+// 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 = {
   ethereum_mainnet: true,
@@ -421,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" } };
@@ -534,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)) {
@@ -547,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 = {
@@ -575,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"
+      })
     };
   }
 };
@@ -601,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,
@@ -702,14 +589,114 @@ function parseOrderability(canOrder, reasons, model) {
 }
 function parseTransactionCore(dto, model) {
   return {
-    tx: {
-      to: EvmContractAddress(dto.to),
-      data: HexEncodedTransactionData(dto.data)
-    },
+    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;
+  }
+}
+
+// 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({
@@ -733,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({
@@ -784,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,
@@ -967,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;
@@ -979,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 () => {
@@ -1011,14 +1062,6 @@ var CentrifugeNamespaceImpl = 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) {
@@ -1127,6 +1170,38 @@ function formattedUsdPrice(amount, locale) {
   );
 }
 
+// src/universal/types/pagination.ts
+var Cursor = (value) => value;
+var PaginatedResponse = {
+  fromDto: (dto, itemMapper) => PaginatedResponse.fromDtoPage(dto, (items) => items.map(itemMapper)),
+  /**
+   * For a mapper that decides the page as a whole - one that drops items it
+   * cannot map, such as `Offer.listFromDto` - rather than item by item. The
+   * cursors are the wire's either way: dropping an item changes what the
+   * page holds, not where the next page starts.
+   */
+  fromDtoPage: (dto, pageMapper) => ({
+    data: pageMapper(dto.data),
+    startingAfter: dto.starting_after ? Cursor(dto.starting_after) : null,
+    startingBefore: dto.starting_before ? Cursor(dto.starting_before) : null
+  })
+};
+var PaginationParams = {
+  toQueryParams: (params) => {
+    const queryParams = {};
+    if (params.after) {
+      queryParams.starting_after = params.after;
+    }
+    if (params.before) {
+      queryParams.starting_before = params.before;
+    }
+    if (params.limit) {
+      queryParams.limit = params.limit;
+    }
+    return queryParams;
+  }
+};
+
 // src/universal/types/asset.ts
 var AssetId = (value) => value;
 var AssetCode = (value) => value;
@@ -1278,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(
@@ -1319,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 {
@@ -1390,47 +1484,13 @@ var TermItem = {
 var Milestone = {
   fromDto: (dto) => ({
     name: notBlankStringOrNull(dto.name),
-    schedule: notBlankStringOrNull(dto.schedule),
-    status: dto.status
-  })
-};
-
-// src/universal/types/pagination.ts
-var Cursor = (value) => value;
-var PaginatedResponse = {
-  fromDto: (dto, itemMapper) => PaginatedResponse.fromDtoPage(dto, (items) => items.map(itemMapper)),
-  /**
-   * For a mapper that decides the page as a whole - one that drops items it
-   * cannot map, such as `Offer.listFromDto` - rather than item by item. The
-   * cursors are the wire's either way: dropping an item changes what the
-   * page holds, not where the next page starts.
-   */
-  fromDtoPage: (dto, pageMapper) => ({
-    data: pageMapper(dto.data),
-    startingAfter: dto.starting_after ? Cursor(dto.starting_after) : null,
-    startingBefore: dto.starting_before ? Cursor(dto.starting_before) : null
+    schedule: notBlankStringOrNull(dto.schedule),
+    status: dto.status
   })
 };
-var PaginationParams = {
-  toQueryParams: (params) => {
-    const queryParams = {};
-    if (params.after) {
-      queryParams.starting_after = params.after;
-    }
-    if (params.before) {
-      queryParams.starting_before = params.before;
-    }
-    if (params.limit) {
-      queryParams.limit = params.limit;
-    }
-    return queryParams;
-  }
-};
 
 // 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);
@@ -1454,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
     };
   }
 };
@@ -1524,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;
@@ -1556,64 +1616,6 @@ var CoinListTokenSaleNamespaceImpl = class {
   }
 };
 
-// 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) => {
@@ -1668,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,
@@ -1687,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,
@@ -1721,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,
@@ -1744,7 +1746,7 @@ function parseSwapCore(dto, spendDecimals) {
   };
 }
 function parseMinimumQuantity(raw, decimals, expectedQuantity) {
-  const amount = parsePositiveAmount({
+  const amount = positiveAmountFromRawOrThrow({
     label: "minimum_quantity",
     raw,
     decimals,
@@ -1757,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) {
@@ -1843,18 +1824,6 @@ function swapBody(params) {
     amount: params.amount.raw.toString()
   };
 }
-function assertSpendScaleAgrees({
-  published,
-  sized,
-  trade,
-  note
-}) {
-  if (published === sized.decimals) return;
-  const because = note === void 0 ? "" : ` - ${note}`;
-  throw new ValidationError(
-    `spend_input_decimals: the ${trade} was priced in ${published} decimals but the order was sized in ${sized.decimals}${because}`
-  );
-}
 function sizeParam(params) {
   const tokenAmount = "tokenAmount" in params ? params.tokenAmount : void 0;
   const notionalValue = "notionalValue" in params ? params.notionalValue : void 0;
@@ -1874,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;
@@ -1950,8 +1919,7 @@ var AllowWalletResponse = {
       case "broadcast_transaction":
         return {
           action: "broadcast_transaction",
-          to: EvmContractAddress(dto.to),
-          data: HexEncodedTransactionData(dto.data)
+          tx: txFromWire(dto)
         };
       case "none":
         return {
@@ -1966,7 +1934,7 @@ var AllowWalletResponse = {
   }
 };
 
-// src/universal/core/checkout/superstate/blockchain/quote.ts
+// src/universal/core/providers/superstate/blockchain/quote.ts
 var SwapQuote = {
   /**
    * Assembles a {@link SwapQuote} from a raw contract {@link SwapPreview}. The
@@ -2001,7 +1969,7 @@ async function allowWallet(api, params) {
   return AllowWalletResponse.fromDto(dto);
 }
 
-// src/universal/core/checkout/superstate/blockchain/abi.ts
+// src/universal/core/providers/superstate/blockchain/abi.ts
 var SUPERSTATE_SWAP_ABI = [
   {
     type: "function",
@@ -3022,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;
@@ -3394,6 +3362,61 @@ var WalletsNamespaceImpl = class {
   }
 };
 
+// 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({
@@ -3521,187 +3544,6 @@ var resolveLogoUrl = (url, baseUrl) => TokenLogoUrl(
 
 // 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 } : {}
-  };
-}
-
-// src/universal/api/nabu/tokens.ts
-function createNabuApiClient(baseUrl, logger = null) {
-  return new HttpClient({ baseUrl }, {}, logger);
-}
 async function fetchTokenMetadata(client, token) {
   const address = checksummed(token.address);
   let response;
@@ -3789,97 +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/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,
@@ -3902,22 +3711,20 @@ export {
   KnownAssetSymbol,
   Bps,
   blockchainAmountFromRawOrThrow,
+  positiveAmountFromRawOrThrow,
+  pricePerShare,
   parseBlockchainAmount,
   CentrifugeVaultStatus,
   CentrifugeVaultBuyTransaction,
   CentrifugeVaultClaimTransaction,
-  CentrifugeVaultPosition,
-  CentrifugeVaultRedeemPosition,
+  CentrifugeAssets,
+  CentrifugeShares,
+  CentrifugeDepositPosition,
+  CentrifugeRedeemPosition,
   CentrifugeVaultLeg,
   CentrifugeVaultLegId,
   CentrifugeVaultClaimProceedsTransaction,
   CentrifugeNamespaceImpl,
-  FormattedAmountUi,
-  FormattedPercentUi,
-  TxExplorerUrl,
-  ShortenedWalletAddress,
-  FormattedAmountAssetUi,
-  AssetIconUrl,
   shortenAddress,
   formatAmount,
   formatRawAmount,
@@ -3928,6 +3735,9 @@ export {
   NA_AMOUNT_ASSET_UI,
   formatShareAmount,
   formattedUsdPrice,
+  Cursor,
+  PaginatedResponse,
+  PaginationParams,
   AssetId,
   AssetCode,
   Asset,
@@ -3944,27 +3754,18 @@ export {
   OfferOptionSlug,
   OfferSwapContract,
   OfferVaultContract,
+  OfferFundingContract,
   OfferDetail,
   OfferOption,
   FaqItem,
   Link,
   TermItem,
   Milestone,
-  Cursor,
-  PaginatedResponse,
-  PaginationParams,
   ParticipationId,
-  Blockchain,
-  WalletAddress,
   ParticipationsPaginationParams,
   Participation,
   CreateParticipationParams,
   CoinListTokenSaleNamespaceImpl,
-  viemChain,
-  getChainId,
-  chainFromId,
-  getNetworkName,
-  txExplorerUrl,
   OndoTradingStatus,
   OndoQuote,
   OndoBuyTransaction,
@@ -3997,10 +3798,11 @@ export {
   fetchOffers,
   fetchOffersPage,
   fetchOfferDetails,
+  OffersNamespaceImpl,
   Erc20NamespaceImpl,
   TokenLogoUrl,
   TokenLogo,
   TokenMetadata,
   TokensNamespaceImpl
 };
-//# sourceMappingURL=chunk-GOUUYOPZ.js.map
+//# sourceMappingURL=chunk-ANPPXFXD.js.map