@coinlist-co/react 0.12.2-rc.abd9d38 → 0.12.2-rc.bc20f5b

package/dist/{chunk-HDJEDOS4.js → chunk-C6GF7MDF.js}

@@ -391,66 +391,6 @@ var ERC20_ABI = [
   }
 ];
 
-// 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/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;
-var Asset = {
-  fromDto: (dto) => ({
-    id: AssetId(dto.id),
-    code: AssetCode(dto.code),
-    name: dto.name,
-    fractionalDigits: dto.fractional_digits
-  })
-};
-
 // src/universal/types/blockchain/core.ts
 var ETHEREUM_CHAINS = {
   ethereum_mainnet: true,
@@ -548,6 +488,66 @@ var StablecoinSymbol = (value) => value;
 var KnownAssetSymbol = StablecoinSymbol;
 var Bps = (value) => value;
 
+// src/universal/core/shared/blockchain/math.ts
+import { parseUnits } from "viem";
+function blockchainAmountFromRawOrThrow({
+  label,
+  raw,
+  decimals
+}) {
+  const trimmed = raw.trim();
+  if (trimmed === "") {
+    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
+  }
+  let value;
+  try {
+    value = BigInt(trimmed);
+  } catch {
+    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
+  }
+  try {
+    return BlockchainAmount({ raw: assertUint256(value), decimals });
+  } catch {
+    throw new ValidationError(`${label}: out of uint256 bounds (${value})`);
+  }
+}
+function parseBlockchainAmount(amount, decimals) {
+  const trimmed = amount.trim();
+  if (trimmed === "") return { valid: false, reason: { type: "empty" } };
+  if (trimmed.startsWith("-")) {
+    return { valid: false, reason: { type: "negative" } };
+  }
+  if (/[eE]/.test(trimmed)) {
+    return { valid: false, reason: { type: "invalid-format" } };
+  }
+  if (trimmed === ".") {
+    return { valid: false, reason: { type: "invalid-format" } };
+  }
+  const normalised = trimmed.replace(/^\./, "0.").replace(/\.$/, "");
+  if (!/^\d+(\.\d+)?$/.test(normalised)) {
+    return { valid: false, reason: { type: "invalid-format" } };
+  }
+  const [, fraction = ""] = normalised.split(".");
+  if (fraction.length > decimals) {
+    return {
+      valid: false,
+      reason: { type: "too-many-decimals", maxDecimals: decimals }
+    };
+  }
+  try {
+    const raw = parseUnits(normalised, decimals);
+    if (raw > MAX_UINT_256) {
+      return { valid: false, reason: { type: "overflow" } };
+    }
+    return {
+      valid: true,
+      amount: BlockchainAmount({ raw, decimals })
+    };
+  } catch {
+    return { valid: false, reason: { type: "invalid-format" } };
+  }
+}
+
 // src/universal/core/shared/utils/crypto.ts
 async function sha256(data) {
   const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
@@ -596,41 +596,570 @@ function notBlankStringOrNull(value) {
   } else {
     return null;
   }
-}
-
-// src/universal/core/shared/utils/wire.ts
-function unknownTypeError(dto, model) {
-  const type = dto.type;
-  throw new ValidationError(
-    `${model}.type: unknown type ${JSON.stringify(type)}`
-  );
-}
-function requiredString(value, field) {
-  const text = notBlankStringOrNull(value);
-  if (text === null) {
-    throw new ValidationError(
-      `${field}: expected a non-blank string, got ${typeof value === "string" ? "a blank string" : String(value)}`
-    );
+}
+
+// src/universal/core/shared/utils/wire.ts
+function unknownTypeError(dto, model) {
+  const type = dto.type;
+  throw new ValidationError(
+    `${model}.type: unknown type ${JSON.stringify(type)}`
+  );
+}
+function requiredString(value, field) {
+  const text = notBlankStringOrNull(value);
+  if (text === null) {
+    throw new ValidationError(
+      `${field}: expected a non-blank string, got ${typeof value === "string" ? "a blank string" : String(value)}`
+    );
+  }
+  return text;
+}
+function requiredDate(value, field) {
+  const date = typeof value === "string" ? new Date(value) : null;
+  if (date === null || Number.isNaN(date.getTime())) {
+    throw new ValidationError(
+      `${field}: expected a date, got ${JSON.stringify(value)}`
+    );
+  }
+  return date;
+}
+function dateOrNull(value, field) {
+  return value === null ? null : requiredDate(value, field);
+}
+function decimalOrNull(value) {
+  return value === null ? null : DecimalString(value);
+}
+function requiredArray(value, field) {
+  if (!Array.isArray(value)) {
+    throw new ValidationError(
+      `${field}: expected an array, got ${typeof value}`
+    );
+  }
+  return value;
+}
+
+// src/universal/types/providers/centrifuge/centrifuge.ts
+var CentrifugeVaultStatus = {
+  fromDto: (dto) => ({
+    chain: EthereumChain(dto.chain),
+    symbol: AssetSymbol(dto.symbol),
+    vaultAddress: EvmContractAddress(dto.vault_address),
+    linked: dto.linked,
+    permissioned: dto.permissioned,
+    membershipValidUntil: dateOrNull(
+      dto.membership_valid_until,
+      "CentrifugeVaultStatus.membership_valid_until"
+    ),
+    halted: dto.halted,
+    priceUpdatedAt: dateOrNull(
+      dto.price_updated_at,
+      "CentrifugeVaultStatus.price_updated_at"
+    ),
+    orderability: parseOrderability(
+      dto.can_order,
+      dto.reasons,
+      "CentrifugeVaultStatus"
+    ),
+    asOf: requiredDate(dto.as_of, "CentrifugeVaultStatus.as_of")
+  })
+};
+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
+    };
+  }
+};
+var CentrifugeVaultClaimTransaction = {
+  fromDto: (dto) => ({
+    ...parseTransactionCore(dto, "CentrifugeVaultClaimTransaction"),
+    claimableShares: blockchainAmountFromRawOrThrow({
+      label: "claimable_shares",
+      raw: dto.claimable_shares,
+      decimals: AssetDecimals(dto.share_decimals)
+    })
+  })
+};
+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 });
+    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")
+    };
+  }
+};
+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 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
+};
+var CentrifugeVaultLegId = {
+  /** Addresses compare case-insensitively: frontline echoes them lower case. */
+  of: (leg) => [
+    leg.direction,
+    leg.position.chain,
+    leg.position.walletAddress.toLowerCase()
+  ].join(":")
+};
+var CentrifugeVaultClaimProceedsTransaction = {
+  fromDto: (dto) => ({
+    ...parseTransactionCore(dto, "CentrifugeVaultClaimProceedsTransaction"),
+    claimableAssets: blockchainAmountFromRawOrThrow({
+      label: "claimable_assets",
+      raw: dto.claimable_assets,
+      decimals: AssetDecimals(dto.asset_decimals)
+    })
+  })
+};
+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: {
+      to: EvmContractAddress(dto.to),
+      data: HexEncodedTransactionData(dto.data)
+    },
+    expiresAt: dateOrNull(dto.expires_at, `${model}.expires_at`)
+  };
+}
+
+// src/universal/api/frontline/providers/centrifuge/centrifuge.ts
+async function getCentrifugeVaultStatus(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/centrifuge/vault/status",
+    queryParams: {
+      symbol: params.symbol,
+      chain: params.chain
+    },
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultStatus.fromDto(dto);
+}
+async function buildCentrifugeVaultBuy(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/centrifuge/vault/invest",
+    body: {
+      ...walletFields(params),
+      amount: params.amount.raw.toString()
+    },
+    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()
+  });
+  return CentrifugeVaultRedeemPosition.fromDto(dto);
+}
+async function createCentrifugeVaultClaim(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/centrifuge/vault/claim",
+    body: walletFields(params),
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultClaimTransaction.fromDto(dto);
+}
+async function createCentrifugeVaultClaimProceeds(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/centrifuge/vault/claim-proceeds",
+    body: walletFields(params),
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultClaimProceedsTransaction.fromDto(dto);
+}
+function walletFields(params) {
+  return {
+    symbol: params.symbol,
+    chain: params.chain,
+    wallet_address: params.walletAddress
+  };
+}
+
+// src/universal/core/shared/observability/log-cause.ts
+import {
+  BaseError,
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  HttpRequestError,
+  RpcError,
+  SocketClosedError,
+  TimeoutError,
+  WebSocketRequestError
+} from "viem";
+function classifyLogCause(error) {
+  if (error instanceof HttpError) {
+    return httpCause(error);
+  }
+  if (error instanceof ValidationError) {
+    return { type: "validation", message: error.message };
+  }
+  if (error instanceof InvariantError) {
+    return { type: "invariant", message: error.message };
+  }
+  if (error instanceof MathError) {
+    return { type: "math", message: error.message };
+  }
+  if (error instanceof NotAuthenticatedError) {
+    return { type: "not-authenticated" };
+  }
+  if (error instanceof NotImplementedError) {
+    return { type: "not-implemented" };
+  }
+  if (error instanceof BaseError) {
+    const http = error.walk((e) => e instanceof HttpError);
+    if (http instanceof HttpError) {
+      return httpCause(http);
+    }
+    return { type: "rpc", reason: rpcFailureReason(error) };
+  }
+  return { type: "generic-error", name: errorName(error) };
+}
+function rpcFailureReason(error) {
+  if (error.walk((e) => e instanceof ContractFunctionRevertedError)) {
+    return "reverted";
+  }
+  if (error.walk((e) => e instanceof RpcError)) {
+    return "node-rejected";
+  }
+  if (error.walk(
+    (e) => e instanceof HttpRequestError || e instanceof WebSocketRequestError || e instanceof SocketClosedError || e instanceof TimeoutError
+  )) {
+    return "transport";
+  }
+  if (error instanceof ContractFunctionExecutionError) {
+    return "malformed-response";
+  }
+  return "unknown";
+}
+function describeErrorUnredacted(error) {
+  if (error instanceof HttpError) {
+    return describeHttpErrorRedacted(error);
+  }
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return `thrown non-error: ${stringifyUnredacted(error)}`;
+}
+function stringifyUnredacted(value) {
+  if (value === void 0) return "";
+  try {
+    return JSON.stringify(
+      value,
+      (_key, item) => typeof item === "bigint" ? `${item}` : item
+    ) ?? String(value);
+  } catch (_) {
+    return "<unserializable>";
+  }
+}
+function describeHttpErrorRedacted(error) {
+  const code = apiErrorCode(error);
+  const status = error.response.status;
+  return code === null ? `HttpError ${status}` : `HttpError ${status} (${code})`;
+}
+function errorName(error) {
+  return error instanceof Error ? error.name : `non-error ${typeof error}`;
+}
+function httpCause(error) {
+  return {
+    type: "http",
+    requestId: error.requestId,
+    status: error.response.status,
+    code: apiErrorCode(error),
+    eventId: apiErrorEventId(error)
+  };
+}
+function apiErrorEventId(error) {
+  const body = error.response.body;
+  if (typeof body !== "object" || body === null) return null;
+  const eventId = body.event_id;
+  return typeof eventId === "string" ? eventId : null;
+}
+
+// src/universal/core/shared/observability/internal-logger.ts
+function internalLogger(logger, scope) {
+  return logger ? scopedLogger(logger, scope, {}) : noopInternalLogger;
+}
+var LEVEL_RANK = {
+  none: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+function scopedLogger(logger, scope, bindings) {
+  const admits = (level) => LEVEL_RANK[logger.level()] >= LEVEL_RANK[level];
+  const safe = (event) => ({
+    msg: event.msg,
+    scope,
+    bindings,
+    fields: event.fields ?? {},
+    ...event.cause === void 0 ? {} : { cause: event.cause }
+  });
+  const unredacted = (event) => ({
+    msg: event.msg,
+    scope,
+    bindings,
+    fields: event.fields ?? {}
+  });
+  const self = {
+    child: (binding) => scopedLogger(logger, scope, { ...bindings, ...binding }),
+    debug: (event) => {
+      if (admits("debug")) logger.debug(() => unredacted(event()));
+    },
+    info: (event) => {
+      if (admits("info")) logger.info(() => safe(event()));
+    },
+    warn: (event) => {
+      if (admits("warn")) logger.warn(() => safe(event()));
+    },
+    error: (event) => {
+      if (admits("error")) logger.error(() => safe(event()));
+    },
+    failure: (event, error) => {
+      if (admits("debug"))
+        logger.debug(() => unredacted(verbatim(event(), error)));
+      if (admits("error")) logger.error(() => safe(classified(event(), error)));
+    },
+    warning: (event, error) => {
+      if (admits("debug"))
+        logger.debug(() => unredacted(verbatim(event(), error)));
+      if (admits("warn")) logger.warn(() => safe(classified(event(), error)));
+    },
+    wrap: async (op, params, run) => {
+      const opLog = self.child({ op });
+      opLog.debug(() => ({ msg: "call", fields: { params } }));
+      try {
+        return await run();
+      } catch (error) {
+        opLog.failure(() => ({ msg: "call failed" }), error);
+        throw error;
+      }
+    }
+  };
+  return self;
+}
+function verbatim(event, error) {
+  return {
+    msg: event.msg,
+    fields: { ...event.fields, error: describeErrorUnredacted(error) }
+  };
+}
+function classified(event, error) {
+  return { ...event, cause: event.cause ?? classifyLogCause(error) };
+}
+var noopInternalLogger = {
+  child: () => noopInternalLogger,
+  debug: () => void 0,
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0,
+  failure: () => void 0,
+  warning: () => void 0,
+  wrap: (_op, _params, run) => run()
+};
+
+// src/universal/core/checkout/centrifuge/centrifuge-namespace.ts
+var CentrifugeNamespaceImpl = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "CENTRIFUGE");
+  }
+  async getVaultStatus(params) {
+    return this.log.wrap("getVaultStatus", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      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 getRedeemPosition(params) {
+    return this.log.wrap("getRedeemPosition", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getCentrifugeVaultRedeemPosition(this.ctx.api, params);
+    });
+  }
+  async createClaim(params) {
+    return this.log.wrap("createClaim", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createCentrifugeVaultClaim(this.ctx.api, params);
+    });
+  }
+  async createClaimProceeds(params) {
+    return this.log.wrap("createClaimProceeds", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createCentrifugeVaultClaimProceeds(this.ctx.api, params);
+    });
   }
-  return text;
-}
-function requiredDate(value, field) {
-  const date = typeof value === "string" ? new Date(value) : null;
-  if (date === null || Number.isNaN(date.getTime())) {
-    throw new ValidationError(
-      `${field}: expected a date, got ${JSON.stringify(value)}`
-    );
+  async buildBuyTransaction(params) {
+    return this.log.wrap("buildBuyTransaction", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return buildCentrifugeVaultBuy(this.ctx.api, params);
+    });
   }
-  return date;
+};
+
+// 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;
 }
-function requiredArray(value, field) {
-  if (!Array.isArray(value)) {
-    throw new ValidationError(
-      `${field}: expected an array, got ${typeof value}`
-    );
+
+// 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;
   }
-  return value;
-}
+};
+
+// src/universal/types/asset.ts
+var AssetId = (value) => value;
+var AssetCode = (value) => value;
+var Asset = {
+  fromDto: (dto) => ({
+    id: AssetId(dto.id),
+    code: AssetCode(dto.code),
+    name: dto.name,
+    fractionalDigits: dto.fractional_digits
+  })
+};
 
 // src/universal/types/offer.ts
 var OfferId = (value) => value;
@@ -638,7 +1167,8 @@ var OfferSlug = (value) => value;
 var OFFER_TYPES = {
   "coinlist::token_sale": true,
   "superstate::swap": true,
-  "ondo::swap": true
+  "ondo::swap": true,
+  "centrifuge::vault": true
 };
 var isOfferType = (value) => Object.keys(OFFER_TYPES).includes(value);
 var OfferEditorial = {
@@ -680,6 +1210,7 @@ var Offer = {
       // on the wire: copying them would hand every consumer a `startsAt` that
       // is 1970 for one variant and a date for the others.
       case "ondo::swap":
+      case "centrifuge::vault":
         return {
           ...base2,
           type: dto.type,
@@ -724,6 +1255,30 @@ var Ticker = (value) => value;
 var Isin = (value) => value;
 
 // src/universal/types/offer-detail.ts
+var AsyncOfferDetail = {
+  /**
+   * Narrows an offer fetched generically, e.g. on an offer page, to one with
+   * something to claim.
+   *
+   * 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
+   * later.
+   */
+  is: (offer) => {
+    switch (offer.type) {
+      case "centrifuge::vault":
+        return true;
+      case "ondo::swap":
+      case "superstate::swap":
+      case "coinlist::token_sale":
+        return false;
+      default: {
+        const exhaustive = offer;
+        return exhaustive;
+      }
+    }
+  }
+};
 var OfferOptionId = (value) => value;
 var OfferOptionSlug = (value) => value;
 var OfferSwapContract = {
@@ -732,6 +1287,19 @@ var OfferSwapContract = {
     address: EvmContractAddress(dto.address)
   })
 };
+var OfferVaultContract = {
+  fromDto: (dto) => ({
+    chain: Chain(dto.chain),
+    address: EvmContractAddress(dto.address)
+  }),
+  /**
+   * Drops every proxy on a chain this SDK does not name, as
+   * `OfferToken.listFromDto` does: frontline publishes the full offer-token
+   * chain list, which runs ahead of {@link Chain}, and one unmodelled chain
+   * should not throw away the proxies the SDK can use.
+   */
+  listFromDto: (dtos) => dtos.filter((dto) => isChain(dto.chain)).map(OfferVaultContract.fromDto)
+};
 var OfferDetail = {
   fromDto: (dto) => {
     const fundingAssets = requiredArray(
@@ -794,6 +1362,18 @@ var OfferDetail = {
             "OfferDetail.swap_contracts"
           ).map(OfferSwapContract.fromDto)
         };
+      // No editorial, as for Ondo. `[]` is fine and a missing key is not, for
+      // the same reason as `swap_contracts`: this is the spender a user
+      // approves.
+      case "centrifuge::vault":
+        return {
+          ...base2,
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url),
+          vaultContracts: OfferVaultContract.listFromDto(
+            requiredArray(dto.vault_contracts, "OfferDetail.vault_contracts")
+          )
+        };
       default:
         return unknownTypeError(dto, "OfferDetail");
     }
@@ -843,263 +1423,80 @@ var Blockchain = (value) => value;
 var WalletAddress = (value) => value;
 var ParticipationsPaginationParams = {
   toQueryParams: (params) => {
-    const queryParams = PaginationParams.toQueryParams(params);
-    if (params.offerId) {
-      queryParams["filters[0][field]"] = "offer_id";
-      queryParams["filters[0][op]"] = "==";
-      queryParams["filters[0][value]"] = params.offerId;
-    }
-    return queryParams;
-  }
-};
-var Participation = {
-  /** Maps API DTO shape into the SDK participation domain model. */
-  fromDto: (dto) => {
-    const walletAddress = notBlankStringOrNull(dto.wallet_address);
-    return {
-      id: ParticipationId(dto.id),
-      offerId: OfferId(dto.offer_id),
-      offerOptionId: OfferOptionId(dto.offer_option_id),
-      status: dto.status,
-      amount: dto.amount,
-      displayAmount: dto.amount_string,
-      asset: Asset.fromDto(dto.asset),
-      chain: Blockchain(dto.chain),
-      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
-    };
-  }
-};
-var CreateParticipationParams = {
-  /** Maps participation creation params into API DTO payload. */
-  toDto: (params) => ({
-    offer_id: params.offerId,
-    offer_option_id: params.offerOptionId,
-    chain: params.chain,
-    wallet_address: params.walletAddress,
-    amount: params.amount,
-    asset_id: params.assetId,
-    approval_transaction_hash: params.approvalTransactionHash
-  })
-};
-
-// src/universal/api/frontline/providers/coin-list/token-sale.ts
-async function fetchParticipations(api, offerId) {
-  return fetchAllPages(
-    (params) => fetchParticipationsPage(api, params),
-    { offerId }
-  );
-}
-async function fetchParticipationsPage(api, params) {
-  const pageDto = await api.send({
-    method: "GET",
-    url: "/v1/participations",
-    queryParams: ParticipationsPaginationParams.toQueryParams(params),
-    attributes: Attributes.protected()
-  });
-  return PaginatedResponse.fromDto(pageDto, Participation.fromDto);
-}
-async function fetchParticipation(api, id) {
-  const dto = await api.send({
-    method: "GET",
-    url: `/v1/participations/${id}`,
-    attributes: Attributes.protected()
-  });
-  return Participation.fromDto(dto);
-}
-async function createParticipation(api, params) {
-  const dto = await api.send({
-    method: "POST",
-    url: "/v1/participations",
-    body: CreateParticipationParams.toDto(params),
-    attributes: Attributes.protected()
-  });
-  return Participation.fromDto(dto);
-}
-
-// src/universal/core/shared/observability/log-cause.ts
-import {
-  BaseError,
-  ContractFunctionExecutionError,
-  ContractFunctionRevertedError,
-  HttpRequestError,
-  RpcError,
-  SocketClosedError,
-  TimeoutError,
-  WebSocketRequestError
-} from "viem";
-function classifyLogCause(error) {
-  if (error instanceof HttpError) {
-    return httpCause(error);
-  }
-  if (error instanceof ValidationError) {
-    return { type: "validation", message: error.message };
-  }
-  if (error instanceof InvariantError) {
-    return { type: "invariant", message: error.message };
-  }
-  if (error instanceof MathError) {
-    return { type: "math", message: error.message };
-  }
-  if (error instanceof NotAuthenticatedError) {
-    return { type: "not-authenticated" };
-  }
-  if (error instanceof NotImplementedError) {
-    return { type: "not-implemented" };
-  }
-  if (error instanceof BaseError) {
-    const http = error.walk((e) => e instanceof HttpError);
-    if (http instanceof HttpError) {
-      return httpCause(http);
-    }
-    return { type: "rpc", reason: rpcFailureReason(error) };
-  }
-  return { type: "generic-error", name: errorName(error) };
-}
-function rpcFailureReason(error) {
-  if (error.walk((e) => e instanceof ContractFunctionRevertedError)) {
-    return "reverted";
-  }
-  if (error.walk((e) => e instanceof RpcError)) {
-    return "node-rejected";
-  }
-  if (error.walk(
-    (e) => e instanceof HttpRequestError || e instanceof WebSocketRequestError || e instanceof SocketClosedError || e instanceof TimeoutError
-  )) {
-    return "transport";
-  }
-  if (error instanceof ContractFunctionExecutionError) {
-    return "malformed-response";
-  }
-  return "unknown";
-}
-function describeErrorUnredacted(error) {
-  if (error instanceof HttpError) {
-    return describeHttpErrorRedacted(error);
-  }
-  if (error instanceof Error) {
-    return `${error.name}: ${error.message}`;
+    const queryParams = PaginationParams.toQueryParams(params);
+    if (params.offerId) {
+      queryParams["filters[0][field]"] = "offer_id";
+      queryParams["filters[0][op]"] = "==";
+      queryParams["filters[0][value]"] = params.offerId;
+    }
+    return queryParams;
   }
-  return `thrown non-error: ${stringifyUnredacted(error)}`;
-}
-function stringifyUnredacted(value) {
-  if (value === void 0) return "";
-  try {
-    return JSON.stringify(
-      value,
-      (_key, item) => typeof item === "bigint" ? `${item}` : item
-    ) ?? String(value);
-  } catch (_) {
-    return "<unserializable>";
+};
+var Participation = {
+  /** Maps API DTO shape into the SDK participation domain model. */
+  fromDto: (dto) => {
+    const walletAddress = notBlankStringOrNull(dto.wallet_address);
+    return {
+      id: ParticipationId(dto.id),
+      offerId: OfferId(dto.offer_id),
+      offerOptionId: OfferOptionId(dto.offer_option_id),
+      status: dto.status,
+      amount: dto.amount,
+      displayAmount: dto.amount_string,
+      asset: Asset.fromDto(dto.asset),
+      chain: Blockchain(dto.chain),
+      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
+    };
   }
-}
-function describeHttpErrorRedacted(error) {
-  const code = apiErrorCode(error);
-  const status = error.response.status;
-  return code === null ? `HttpError ${status}` : `HttpError ${status} (${code})`;
-}
-function errorName(error) {
-  return error instanceof Error ? error.name : `non-error ${typeof error}`;
-}
-function httpCause(error) {
-  return {
-    type: "http",
-    requestId: error.requestId,
-    status: error.response.status,
-    code: apiErrorCode(error),
-    eventId: apiErrorEventId(error)
-  };
-}
-function apiErrorEventId(error) {
-  const body = error.response.body;
-  if (typeof body !== "object" || body === null) return null;
-  const eventId = body.event_id;
-  return typeof eventId === "string" ? eventId : null;
-}
+};
+var CreateParticipationParams = {
+  /** Maps participation creation params into API DTO payload. */
+  toDto: (params) => ({
+    offer_id: params.offerId,
+    offer_option_id: params.offerOptionId,
+    chain: params.chain,
+    wallet_address: params.walletAddress,
+    amount: params.amount,
+    asset_id: params.assetId,
+    approval_transaction_hash: params.approvalTransactionHash
+  })
+};
 
-// src/universal/core/shared/observability/internal-logger.ts
-function internalLogger(logger, scope) {
-  return logger ? scopedLogger(logger, scope, {}) : noopInternalLogger;
+// src/universal/api/frontline/providers/coin-list/token-sale.ts
+async function fetchParticipations(api, offerId) {
+  return fetchAllPages(
+    (params) => fetchParticipationsPage(api, params),
+    { offerId }
+  );
 }
-var LEVEL_RANK = {
-  none: 0,
-  error: 1,
-  warn: 2,
-  info: 3,
-  debug: 4
-};
-function scopedLogger(logger, scope, bindings) {
-  const admits = (level) => LEVEL_RANK[logger.level()] >= LEVEL_RANK[level];
-  const safe = (event) => ({
-    msg: event.msg,
-    scope,
-    bindings,
-    fields: event.fields ?? {},
-    ...event.cause === void 0 ? {} : { cause: event.cause }
-  });
-  const unredacted = (event) => ({
-    msg: event.msg,
-    scope,
-    bindings,
-    fields: event.fields ?? {}
+async function fetchParticipationsPage(api, params) {
+  const pageDto = await api.send({
+    method: "GET",
+    url: "/v1/participations",
+    queryParams: ParticipationsPaginationParams.toQueryParams(params),
+    attributes: Attributes.protected()
   });
-  const self = {
-    child: (binding) => scopedLogger(logger, scope, { ...bindings, ...binding }),
-    debug: (event) => {
-      if (admits("debug")) logger.debug(() => unredacted(event()));
-    },
-    info: (event) => {
-      if (admits("info")) logger.info(() => safe(event()));
-    },
-    warn: (event) => {
-      if (admits("warn")) logger.warn(() => safe(event()));
-    },
-    error: (event) => {
-      if (admits("error")) logger.error(() => safe(event()));
-    },
-    failure: (event, error) => {
-      if (admits("debug"))
-        logger.debug(() => unredacted(verbatim(event(), error)));
-      if (admits("error")) logger.error(() => safe(classified(event(), error)));
-    },
-    warning: (event, error) => {
-      if (admits("debug"))
-        logger.debug(() => unredacted(verbatim(event(), error)));
-      if (admits("warn")) logger.warn(() => safe(classified(event(), error)));
-    },
-    wrap: async (op, params, run) => {
-      const opLog = self.child({ op });
-      opLog.debug(() => ({ msg: "call", fields: { params } }));
-      try {
-        return await run();
-      } catch (error) {
-        opLog.failure(() => ({ msg: "call failed" }), error);
-        throw error;
-      }
-    }
-  };
-  return self;
+  return PaginatedResponse.fromDto(pageDto, Participation.fromDto);
 }
-function verbatim(event, error) {
-  return {
-    msg: event.msg,
-    fields: { ...event.fields, error: describeErrorUnredacted(error) }
-  };
+async function fetchParticipation(api, id) {
+  const dto = await api.send({
+    method: "GET",
+    url: `/v1/participations/${id}`,
+    attributes: Attributes.protected()
+  });
+  return Participation.fromDto(dto);
 }
-function classified(event, error) {
-  return { ...event, cause: event.cause ?? classifyLogCause(error) };
+async function createParticipation(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/participations",
+    body: CreateParticipationParams.toDto(params),
+    attributes: Attributes.protected()
+  });
+  return Participation.fromDto(dto);
 }
-var noopInternalLogger = {
-  child: () => noopInternalLogger,
-  debug: () => void 0,
-  info: () => void 0,
-  warn: () => void 0,
-  error: () => void 0,
-  failure: () => void 0,
-  warning: () => void 0,
-  wrap: (_op, _params, run) => run()
-};
 
 // src/universal/core/checkout/coin-list/token-sale-namespace.ts
 var CoinListTokenSaleNamespaceImpl = class {
@@ -1307,66 +1704,6 @@ function explorerBaseUrl(chain) {
   }
 }
 
-// src/universal/core/shared/blockchain/math.ts
-import { parseUnits } from "viem";
-function blockchainAmountFromRawOrThrow({
-  label,
-  raw,
-  decimals
-}) {
-  const trimmed = raw.trim();
-  if (trimmed === "") {
-    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
-  }
-  let value;
-  try {
-    value = BigInt(trimmed);
-  } catch {
-    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
-  }
-  try {
-    return BlockchainAmount({ raw: assertUint256(value), decimals });
-  } catch {
-    throw new ValidationError(`${label}: out of uint256 bounds (${value})`);
-  }
-}
-function parseBlockchainAmount(amount, decimals) {
-  const trimmed = amount.trim();
-  if (trimmed === "") return { valid: false, reason: { type: "empty" } };
-  if (trimmed.startsWith("-")) {
-    return { valid: false, reason: { type: "negative" } };
-  }
-  if (/[eE]/.test(trimmed)) {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-  if (trimmed === ".") {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-  const normalised = trimmed.replace(/^\./, "0.").replace(/\.$/, "");
-  if (!/^\d+(\.\d+)?$/.test(normalised)) {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-  const [, fraction = ""] = normalised.split(".");
-  if (fraction.length > decimals) {
-    return {
-      valid: false,
-      reason: { type: "too-many-decimals", maxDecimals: decimals }
-    };
-  }
-  try {
-    const raw = parseUnits(normalised, decimals);
-    if (raw > MAX_UINT_256) {
-      return { valid: false, reason: { type: "overflow" } };
-    }
-    return {
-      valid: true,
-      amount: BlockchainAmount({ raw, decimals })
-    };
-  } catch {
-    return { valid: false, reason: { type: "invalid-format" } };
-  }
-}
-
 // src/universal/types/providers/ondo/ondo.ts
 var OndoTradingStatus = {
   fromDto: (dto) => {
@@ -1382,7 +1719,6 @@ var OndoTradingStatus = {
     };
   }
 };
-var decimalOrNull = (value) => value === null ? null : DecimalString(value);
 var OndoQuote = {
   fromDto: (dto) => {
     const assetDecimals = AssetDecimals(dto.asset_decimals);
@@ -3516,13 +3852,6 @@ export {
   Seconds,
   isExpired,
   ERC20_ABI,
-  fetchAllPages,
-  Cursor,
-  PaginatedResponse,
-  PaginationParams,
-  AssetId,
-  AssetCode,
-  Asset,
   ETHEREUM_CHAINS,
   EthereumChain,
   SOLANA_CHAINS,
@@ -3544,6 +3873,24 @@ export {
   StablecoinSymbol,
   KnownAssetSymbol,
   Bps,
+  blockchainAmountFromRawOrThrow,
+  parseBlockchainAmount,
+  CentrifugeVaultStatus,
+  CentrifugeVaultBuyTransaction,
+  CentrifugeVaultClaimTransaction,
+  CentrifugeVaultPosition,
+  CentrifugeVaultRedeemPosition,
+  CentrifugeVaultLeg,
+  CentrifugeVaultLegId,
+  CentrifugeVaultClaimProceedsTransaction,
+  CentrifugeNamespaceImpl,
+  fetchAllPages,
+  Cursor,
+  PaginatedResponse,
+  PaginationParams,
+  AssetId,
+  AssetCode,
+  Asset,
   OfferId,
   OfferSlug,
   isOfferType,
@@ -3552,9 +3899,11 @@ export {
   OfferToken,
   Ticker,
   Isin,
+  AsyncOfferDetail,
   OfferOptionId,
   OfferOptionSlug,
   OfferSwapContract,
+  OfferVaultContract,
   OfferDetail,
   OfferOption,
   FaqItem,
@@ -3589,8 +3938,6 @@ export {
   chainFromId,
   getNetworkName,
   txExplorerUrl,
-  blockchainAmountFromRawOrThrow,
-  parseBlockchainAmount,
   OndoTradingStatus,
   OndoQuote,
   OndoBuyTransaction,
@@ -3631,4 +3978,4 @@ export {
   OAuthRefreshToken,
   OAuthSession
 };
-//# sourceMappingURL=chunk-HDJEDOS4.js.map
+//# sourceMappingURL=chunk-C6GF7MDF.js.map