@coinlist-co/react 0.12.2-rc.a59b344 → 0.12.2-rc.aa91ce3

package/dist/universal/index.cjs

@@ -27,15 +27,22 @@ __export(universal_exports, {
   AssetIconUrl: () => AssetIconUrl,
   AssetId: () => AssetId,
   AssetSymbol: () => AssetSymbol,
+  AsyncOfferDetail: () => AsyncOfferDetail,
   AuthorizationCode: () => AuthorizationCode,
   BPS_DENOM: () => BPS_DENOM,
   Blockchain: () => Blockchain,
   BlockchainAmount: () => BlockchainAmount,
   Bps: () => Bps,
+  CENTRIFUGE_POLL_INTERVAL_MS: () => CENTRIFUGE_POLL_INTERVAL_MS,
+  CentrifugeNamespaceImpl: () => CentrifugeNamespaceImpl,
   CentrifugeVaultBuyTransaction: () => CentrifugeVaultBuyTransaction,
+  CentrifugeVaultClaimProceedsTransaction: () => CentrifugeVaultClaimProceedsTransaction,
   CentrifugeVaultClaimTransaction: () => CentrifugeVaultClaimTransaction,
+  CentrifugeVaultLeg: () => CentrifugeVaultLeg,
+  CentrifugeVaultLegId: () => CentrifugeVaultLegId,
   CentrifugeVaultPosition: () => CentrifugeVaultPosition,
   CentrifugeVaultQuote: () => CentrifugeVaultQuote,
+  CentrifugeVaultRedeemPosition: () => CentrifugeVaultRedeemPosition,
   CentrifugeVaultStatus: () => CentrifugeVaultStatus,
   Chain: () => Chain,
   ClientCredentialsOAuth: () => ClientCredentialsOAuth,
@@ -159,6 +166,7 @@ __export(universal_exports, {
   ValidationError: () => ValidationError,
   WalletAddress: () => WalletAddress,
   WalletOwnershipChallenge: () => WalletOwnershipChallenge,
+  WalletSelection: () => WalletSelection,
   WalletsNamespaceImpl: () => WalletsNamespaceImpl,
   apiErrorCode: () => apiErrorCode,
   applyBps: () => applyBps,
@@ -191,6 +199,7 @@ __export(universal_exports, {
   ondoQuoteOfferDeadline: () => ondoQuoteOfferDeadline,
   parseBlockchainAmount: () => parseBlockchainAmount,
   parseUint256: () => parseUint256,
+  resolveCentrifugeVaults: () => resolveCentrifugeVaults,
   shortenAddress: () => shortenAddress,
   superstateSwapContractAddress: () => superstateSwapContractAddress,
   swapSpender: () => swapSpender,
@@ -462,49 +471,8 @@ async function generatePKCEParams(config) {
   };
 }
 
-// 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/core/shared/blockchain/math.ts
+var import_viem = require("viem");
 
 // src/universal/types/errors.ts
 var NotImplementedError = class extends Error {
@@ -635,6 +603,65 @@ var StablecoinSymbol = (value) => value;
 var KnownAssetSymbol = StablecoinSymbol;
 var Bps = (value) => value;
 
+// src/universal/core/shared/blockchain/math.ts
+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 = (0, import_viem.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/wire.ts
 function unknownTypeError(dto, model) {
   const type = dto.type;
@@ -660,20 +687,588 @@ function requiredDate(value, field) {
   }
   return date;
 }
-function dateOrNull(value, field) {
-  return value === null ? null : requiredDate(value, field);
+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 CentrifugeVaultQuote = {
+  fromDto: (dto) => {
+    const spendDecimals = AssetDecimals(dto.spend_input_decimals);
+    const shareDecimals = AssetDecimals(dto.share_decimals);
+    return {
+      chain: EthereumChain(dto.chain),
+      symbol: AssetSymbol(dto.symbol),
+      spendInputAmount: blockchainAmountFromRawOrThrow({
+        label: "spend_input_amount",
+        raw: dto.spend_input_amount,
+        decimals: spendDecimals
+      }),
+      estimatedShares: blockchainAmountFromRawOrThrow({
+        label: "estimated_shares",
+        raw: dto.estimated_shares,
+        decimals: shareDecimals
+      }),
+      indicativePrice: decimalOrNull(dto.indicative_price),
+      minimumInputAmount: dto.minimum_input_amount === null ? null : blockchainAmountFromRawOrThrow({
+        label: "minimum_input_amount",
+        raw: dto.minimum_input_amount,
+        decimals: spendDecimals
+      }),
+      orderability: parseOrderability(
+        dto.can_order,
+        dto.reasons,
+        "CentrifugeVaultQuote"
+      )
+    };
+  }
+};
+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,
+      estimatedShares: blockchainAmountFromRawOrThrow({
+        label: "estimated_shares",
+        raw: dto.estimated_shares,
+        decimals: AssetDecimals(dto.share_decimals)
+      })
+    };
+  }
+};
+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 getCentrifugeVaultQuote(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/centrifuge/vault/quote",
+    queryParams: {
+      symbol: params.symbol,
+      chain: params.chain,
+      amount: params.amount.raw.toString()
+    },
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultQuote.fromDto(dto);
+}
+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 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
+var import_viem2 = require("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 import_viem2.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 import_viem2.ContractFunctionRevertedError)) {
+    return "reverted";
+  }
+  if (error.walk((e) => e instanceof import_viem2.RpcError)) {
+    return "node-rejected";
+  }
+  if (error.walk(
+    (e) => e instanceof import_viem2.HttpRequestError || e instanceof import_viem2.WebSocketRequestError || e instanceof import_viem2.SocketClosedError || e instanceof import_viem2.TimeoutError
+  )) {
+    return "transport";
+  }
+  if (error instanceof import_viem2.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 getQuote(params) {
+    return this.log.wrap("getQuote", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getCentrifugeVaultQuote(this.ctx.api, params);
+    });
+  }
+  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);
+    });
+  }
+};
+
+// src/universal/core/checkout/centrifuge/constants.ts
+var CENTRIFUGE_POLL_INTERVAL_MS = 15e3;
+
+// src/universal/core/checkout/centrifuge/vaults.ts
+function resolveCentrifugeVaults(offer, lookup) {
+  return offer.vaultContracts.map((contract) => {
+    const { chain } = contract;
+    if (!isEthereumChain(chain)) {
+      return { type: "unresolved", chain, missing: "evm-chain" };
+    }
+    const onChain = (role) => offer.tokens.filter(
+      (token) => token.role === role && token.chain === chain
+    );
+    const share = firstKnown(onChain("vault"), lookup);
+    if (share === null) {
+      return { type: "unresolved", chain, missing: "share-token" };
+    }
+    const funding = firstKnown(onChain("funding"), lookup);
+    if (funding === null) {
+      return { type: "unresolved", chain, missing: "funding-token" };
+    }
+    return {
+      type: "resolved",
+      vault: { chain, proxy: contract.address, share, funding }
+    };
+  });
+}
+function firstKnown(tokens, lookup) {
+  for (const token of tokens) {
+    const metadata = lookup(token);
+    if (metadata !== null) return metadata;
+  }
+  return null;
 }
-function decimalOrNull(value) {
-  return value === null ? null : DecimalString(value);
+function isEthereumChain(chain) {
+  return chain in ETHEREUM_CHAINS;
 }
-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;
@@ -769,6 +1364,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 = {
@@ -953,214 +1572,40 @@ var CreateParticipationParams = {
     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
-var import_viem = require("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 import_viem.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 import_viem.ContractFunctionRevertedError)) {
-    return "reverted";
-  }
-  if (error.walk((e) => e instanceof import_viem.RpcError)) {
-    return "node-rejected";
-  }
-  if (error.walk(
-    (e) => e instanceof import_viem.HttpRequestError || e instanceof import_viem.WebSocketRequestError || e instanceof import_viem.SocketClosedError || e instanceof import_viem.TimeoutError
-  )) {
-    return "transport";
-  }
-  if (error instanceof import_viem.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;
+
+// src/universal/api/frontline/providers/coin-list/token-sale.ts
+async function fetchParticipations(api, offerId) {
+  return fetchAllPages(
+    (params) => fetchParticipationsPage(api, params),
+    { offerId }
+  );
 }
-function verbatim(event, error) {
-  return {
-    msg: event.msg,
-    fields: { ...event.fields, error: describeErrorUnredacted(error) }
-  };
+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);
 }
-function classified(event, error) {
-  return { ...event, cause: event.cause ?? classifyLogCause(error) };
+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);
 }
-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 {
@@ -1317,7 +1762,7 @@ function isOndoNotTradableError(error) {
 }
 
 // src/universal/core/shared/blockchain/formatters.ts
-var import_viem2 = require("viem");
+var import_viem3 = require("viem");
 
 // src/universal/types/blockchain/ui.ts
 var FormattedAmountUi = (value) => value;
@@ -1388,7 +1833,7 @@ function roundFractionHalfUp(integerPart, fractionPart, maxFractionDigits) {
   };
 }
 function formatRawAmount(amount) {
-  return (0, import_viem2.formatUnits)(amount.raw, amount.decimals);
+  return (0, import_viem3.formatUnits)(amount.raw, amount.decimals);
 }
 function formatCompactAmount(amount, locale) {
   const value = Number(formatRawAmount(amount));
@@ -1492,66 +1937,6 @@ function explorerBaseUrl(chain) {
   }
 }
 
-// src/universal/core/shared/blockchain/math.ts
-var import_viem3 = require("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 = (0, import_viem3.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) => {
@@ -3925,6 +4310,27 @@ var RedactedWalletError = {
   fromWalletError: (error) => error.type === "unknown" ? { type: "unknown" } : error
 };
 
+// src/universal/types/blockchain/wallet-selection.ts
+var WalletSelection = {
+  /**
+   * Every wallet in display order - embedded first, then the external one -
+   * each address once. Addresses compare case-insensitively, so a host that
+   * hands the same wallet over as both embedded and external sees it once.
+   */
+  all: (selection) => {
+    const seen = /* @__PURE__ */ new Set();
+    return [
+      ...selection.embedded,
+      ...selection.external === null ? [] : [selection.external]
+    ].filter((wallet) => {
+      const key = wallet.address.toLowerCase();
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+};
+
 // src/universal/types/oauth-session.ts
 var ClientCredentialsOAuth = (value) => value;
 var OAuthRefreshToken = (value) => value;
@@ -3941,146 +4347,6 @@ var OAuthSession = {
   }
 };
 
-// src/universal/types/providers/centrifuge/centrifuge.ts
-var CentrifugeVaultQuote = {
-  fromDto: (dto) => {
-    const spendDecimals = AssetDecimals(dto.spend_input_decimals);
-    const shareDecimals = AssetDecimals(dto.share_decimals);
-    return {
-      chain: EthereumChain(dto.chain),
-      symbol: AssetSymbol(dto.symbol),
-      spendInputAmount: blockchainAmountFromRawOrThrow({
-        label: "spend_input_amount",
-        raw: dto.spend_input_amount,
-        decimals: spendDecimals
-      }),
-      estimatedShares: blockchainAmountFromRawOrThrow({
-        label: "estimated_shares",
-        raw: dto.estimated_shares,
-        decimals: shareDecimals
-      }),
-      indicativePrice: decimalOrNull(dto.indicative_price),
-      minimumInputAmount: dto.minimum_input_amount === null ? null : blockchainAmountFromRawOrThrow({
-        label: "minimum_input_amount",
-        raw: dto.minimum_input_amount,
-        decimals: spendDecimals
-      }),
-      orderability: parseOrderability(
-        dto.can_order,
-        dto.reasons,
-        "CentrifugeVaultQuote"
-      )
-    };
-  }
-};
-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,
-      estimatedShares: blockchainAmountFromRawOrThrow({
-        label: "estimated_shares",
-        raw: dto.estimated_shares,
-        decimals: AssetDecimals(dto.share_decimals)
-      })
-    };
-  }
-};
-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")
-    };
-  }
-};
-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/types/time.ts
 var MAX_EPOCH_MILLIS = 864e13;
 var EpochMillis = {
@@ -4147,15 +4413,22 @@ var User = {
   AssetIconUrl,
   AssetId,
   AssetSymbol,
+  AsyncOfferDetail,
   AuthorizationCode,
   BPS_DENOM,
   Blockchain,
   BlockchainAmount,
   Bps,
+  CENTRIFUGE_POLL_INTERVAL_MS,
+  CentrifugeNamespaceImpl,
   CentrifugeVaultBuyTransaction,
+  CentrifugeVaultClaimProceedsTransaction,
   CentrifugeVaultClaimTransaction,
+  CentrifugeVaultLeg,
+  CentrifugeVaultLegId,
   CentrifugeVaultPosition,
   CentrifugeVaultQuote,
+  CentrifugeVaultRedeemPosition,
   CentrifugeVaultStatus,
   Chain,
   ClientCredentialsOAuth,
@@ -4279,6 +4552,7 @@ var User = {
   ValidationError,
   WalletAddress,
   WalletOwnershipChallenge,
+  WalletSelection,
   WalletsNamespaceImpl,
   apiErrorCode,
   applyBps,
@@ -4311,6 +4585,7 @@ var User = {
   ondoQuoteOfferDeadline,
   parseBlockchainAmount,
   parseUint256,
+  resolveCentrifugeVaults,
   shortenAddress,
   superstateSwapContractAddress,
   swapSpender,