@coinlist-co/react 0.12.2-rc.31c2f50 → 0.12.2-rc.3de3751

package/dist/{chunk-UJYSXXJF.js → chunk-RLOYYAMO.js}

@@ -1,35 +1,28 @@
 import {
   AssetDecimals,
-  AssetSymbol,
   BlockchainAmount,
   Bps,
   DecimalString,
-  EthereumChain,
+  ETHEREUM_CHAINS,
   EvmContractAddress,
-  EvmWalletAddress,
-  HexEncodedTransactionData,
   InvariantError,
   MAX_UINT_256,
   MathError,
   NA_AMOUNT_ASSET_UI,
-  SUPERSTATE_SWAP_ABI,
   StablecoinSymbol,
-  ValidationError,
   apiErrorCode,
   arrayBufferToBase64Url,
   assertUint256,
-  blockchainAmountFromRawOrThrow,
-  dateOrNull,
-  decimalOrNull,
+  contractOn,
   fetchOfferDetails,
   fetchOffers,
   fetchOffersPage,
   formattedUsdPrice,
   generateSecureRandomBase64Url,
   internalLogger,
-  requiredDate,
+  pricePerShare,
   sha256
-} from "./chunk-NBO5E2RO.js";
+} from "./chunk-HMLWCXAP.js";
 
 // src/universal/types/oauth.ts
 var AuthorizationCode = (value) => value;
@@ -57,6 +50,127 @@ async function generatePKCEParams(config) {
   };
 }
 
+// src/universal/types/blockchain/wallet-error.ts
+var RedactedWalletError = {
+  fromWalletError: (error) => error.type === "unknown" ? { type: "unknown" } : error
+};
+
+// src/universal/core/offers/swap-contracts.ts
+function swapSpender(swapContracts, chain) {
+  return contractOn(swapContracts, chain);
+}
+
+// src/universal/core/shared/blockchain/bps.ts
+var BPS_DENOM = Bps(10000n);
+function applyBps(amount, bps) {
+  return assertUint256(amount * bps / BPS_DENOM);
+}
+
+// src/universal/core/providers/checkout/superstate/blockchain/math.ts
+function computePrice({
+  inputTokenAmount,
+  outputTokenAmount
+}) {
+  if (outputTokenAmount.raw === 0n) return null;
+  return pricePerShare({ usd: inputTokenAmount, shares: outputTokenAmount });
+}
+function computeSlip(amount, slippage) {
+  const retained = Bps(assertUint256(BPS_DENOM - slippage));
+  const slipRaw = applyBps(amount.raw, retained);
+  return BlockchainAmount({ raw: slipRaw, decimals: amount.decimals });
+}
+
+// src/universal/core/providers/checkout/superstate/blockchain/status.ts
+var SWAP_LEVEL = 2;
+function isSwapAvailable(status) {
+  switch (status.state) {
+    case "active":
+      return true;
+    case "stopped":
+      return false;
+    case "paused":
+      return (status.pausedLevels & SWAP_LEVEL) === 0;
+    default: {
+      const _exhaustive = status;
+      return _exhaustive;
+    }
+  }
+}
+
+// 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/core/tokens/token-registry-snapshot.ts
+var TokenRegistrySnapshot = {
+  /** Indexes a `tokens.list()` result. `[]` is a valid, empty snapshot. */
+  fromTokens: (tokens) => ({
+    tokens,
+    byKey: new Map(
+      tokens.map((token) => [registryKey(token.identifier), token])
+    )
+  }),
+  /**
+   * The registry's entry for one token, or `null` when it lists none. The
+   * registry is curated, so `null` is an ordinary answer rather than an
+   * error, and callers fall back to their own display defaults.
+   */
+  get: (snapshot, token) => snapshot.byKey.get(registryKey(token)) ?? null,
+  /**
+   * The registry's entry for the token an offer is *about*, or `null` when
+   * it lists none of them.
+   *
+   * Resolution follows {@link offerDisplayTokens}: the token a sale
+   * distributes or a swap hands over, never the funding token the user pays
+   * with. An offer deployed on several chains carries one such token per
+   * chain, and the first the registry knows wins - they are the same asset,
+   * so any listed one answers for the offer.
+   */
+  forOffer: (snapshot, offer) => {
+    for (const token of offerDisplayTokens(offer)) {
+      const metadata = TokenRegistrySnapshot.get(snapshot, token);
+      if (metadata !== null) {
+        return metadata;
+      }
+    }
+    return null;
+  }
+};
+function offerDisplayTokens(offer) {
+  const swaps = offer.tokens.filter(
+    (token) => token.role === "swap" || token.role === "vault"
+  );
+  const distributions = offer.tokens.filter(
+    (token) => token.role === "distribution"
+  );
+  return [...swaps, ...distributions];
+}
+function registryKey(token) {
+  return `${token.chain}:${token.address.toLowerCase()}`;
+}
+
 // src/universal/core/shared/blockchain/token-registry.ts
 var USDC_SYMBOL = StablecoinSymbol("USDC");
 var USDC = {
@@ -120,7 +234,13 @@ var TOKEN_REGISTRY = {
   usdtAddress: (chain) => USDT_ADDRESSES[chain]
 };
 
-// src/universal/core/checkout/ondo/constants.ts
+// src/universal/core/providers/checkout/ondo/not-tradable.ts
+var ONDO_NOT_TRADABLE_CODE = "not_tradable";
+function isOndoNotTradableError(error) {
+  return apiErrorCode(error) === ONDO_NOT_TRADABLE_CODE;
+}
+
+// src/universal/core/providers/checkout/ondo/constants.ts
 var ONDO_POLL_INTERVAL_MS = 15e3;
 var ONDO_QUOTE_MAX_TTL_MS = 15e3;
 var DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE = DecimalString("1000");
@@ -130,7 +250,7 @@ var ONDO_SUPPORTED_INPUT_ASSETS = [
   USDC_SYMBOL
 ];
 
-// src/universal/core/checkout/ondo/math.ts
+// src/universal/core/providers/checkout/ondo/math.ts
 function computeOndoBuyPrice(transaction) {
   const { notionalValue, receiveOutputAmount } = transaction;
   return pricePerShare({
@@ -155,110 +275,8 @@ function grossProceeds(expected) {
   }
   return BlockchainAmount.add(expected.quantity, expected.fee);
 }
-function pricePerShare({
-  usd,
-  shares
-}) {
-  const price = BlockchainAmount.div(usd, shares);
-  return BlockchainAmount({
-    raw: assertPriceFits(price.raw),
-    decimals: price.decimals
-  });
-}
-function assertPriceFits(raw) {
-  try {
-    return assertUint256(raw);
-  } catch {
-    throw new MathError(`Ondo price: out of uint256 bounds (${raw})`);
-  }
-}
-
-// src/universal/core/checkout/ondo/not-tradable.ts
-var ONDO_NOT_TRADABLE_CODE = "not_tradable";
-function isOndoNotTradableError(error) {
-  return apiErrorCode(error) === ONDO_NOT_TRADABLE_CODE;
-}
-
-// src/universal/core/shared/blockchain/bps.ts
-var BPS_DENOM = Bps(10000n);
-function applyBps(amount, bps) {
-  return assertUint256(amount * bps / BPS_DENOM);
-}
 
-// src/universal/core/checkout/superstate/blockchain/math.ts
-function computePrice({
-  inputTokenAmount,
-  outputTokenAmount
-}) {
-  if (outputTokenAmount.raw === 0n) return null;
-  const scale = 10n ** BigInt(outputTokenAmount.decimals);
-  const raw = assertUint256(
-    inputTokenAmount.raw * scale / outputTokenAmount.raw
-  );
-  return BlockchainAmount({ raw, decimals: inputTokenAmount.decimals });
-}
-function computeSlip(amount, slippage) {
-  const retained = Bps(assertUint256(BPS_DENOM - slippage));
-  const slipRaw = applyBps(amount.raw, retained);
-  return BlockchainAmount({ raw: slipRaw, decimals: amount.decimals });
-}
-
-// src/universal/core/checkout/superstate/blockchain/quote.ts
-var SwapQuote = {
-  /**
-   * Assembles a {@link SwapQuote} from a raw contract {@link SwapPreview}. The
-   * input and fee are denominated in the input token; the output in the output
-   * token.
-   */
-  fromPreview: (preview, inputDecimals, outputDecimals) => ({
-    inputTokenAmount: BlockchainAmount({
-      raw: preview.inputAmount,
-      decimals: inputDecimals
-    }),
-    fee: BlockchainAmount({ raw: preview.fee, decimals: inputDecimals }),
-    outputTokenAmount: BlockchainAmount({
-      raw: preview.outputAmount,
-      decimals: outputDecimals
-    })
-  })
-};
-
-// src/universal/core/checkout/superstate/blockchain/status.ts
-var SWAP_LEVEL = 2;
-function isSwapAvailable(status) {
-  switch (status.state) {
-    case "active":
-      return true;
-    case "stopped":
-      return false;
-    case "paused":
-      return (status.pausedLevels & SWAP_LEVEL) === 0;
-    default: {
-      const _exhaustive = status;
-      return _exhaustive;
-    }
-  }
-}
-
-// src/universal/core/checkout/superstate/blockchain/swapped-event.ts
-import { parseEventLogs } from "viem";
-function decodeSwappedOutputAmount(receipt, outputDecimals) {
-  try {
-    const [swapped] = parseEventLogs({
-      abi: SUPERSTATE_SWAP_ABI,
-      eventName: "Swapped",
-      logs: receipt.logs
-    });
-    if (!swapped) return null;
-    const raw = swapped.args.outputAmount;
-    if (raw < 0n || raw > MAX_UINT_256) return null;
-    return BlockchainAmount({ raw, decimals: outputDecimals });
-  } catch {
-    return null;
-  }
-}
-
-// src/universal/core/checkout/superstate/constants.ts
+// src/universal/core/providers/checkout/superstate/constants.ts
 var SUPERSTATE_ISSUER_NAME = "Superstate";
 var SUPERSTATE_SUPPORTED_INPUT_ASSETS = [USDC_SYMBOL];
 var SWAP_POLL_INTERVAL_MS = 15e3;
@@ -275,246 +293,68 @@ function superstateSwapContractAddress(chain) {
   return SUPERSTATE_SWAP_CONTRACT_ADDRESSES[chain] ?? null;
 }
 
-// src/universal/core/checkout/superstate/formatters.ts
+// src/universal/core/providers/checkout/superstate/formatters.ts
 function formattedPricePerShare(quote, locale) {
   if (!quote) return NA_AMOUNT_ASSET_UI;
   return formattedUsdPrice(computePrice(quote), locale);
 }
 
-// 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/core/offers/swap-contracts.ts
-function swapSpender(swapContracts, chain) {
-  return swapContracts.find((contract) => contract.chain === chain)?.address ?? null;
-}
-
-// src/universal/core/tokens/token-registry-snapshot.ts
-var TokenRegistrySnapshot = {
-  /** Indexes a `tokens.list()` result. `[]` is a valid, empty snapshot. */
-  fromTokens: (tokens) => ({
-    tokens,
-    byKey: new Map(
-      tokens.map((token) => [registryKey(token.identifier), token])
-    )
-  }),
+// src/universal/types/blockchain/wallet-selection.ts
+var WalletSelection = {
   /**
-   * The registry's entry for one token, or `null` when it lists none. The
-   * registry is curated, so `null` is an ordinary answer rather than an
-   * error, and callers fall back to their own display defaults.
+   * 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.
    */
-  get: (snapshot, token) => snapshot.byKey.get(registryKey(token)) ?? null,
-  /**
-   * The registry's entry for the token an offer is *about*, or `null` when
-   * it lists none of them.
-   *
-   * Resolution follows {@link offerDisplayTokens}: the token a sale
-   * distributes or a swap hands over, never the funding token the user pays
-   * with. An offer deployed on several chains carries one such token per
-   * chain, and the first the registry knows wins - they are the same asset,
-   * so any listed one answers for the offer.
-   */
-  forOffer: (snapshot, offer) => {
-    for (const token of offerDisplayTokens(offer)) {
-      const metadata = TokenRegistrySnapshot.get(snapshot, token);
-      if (metadata !== null) {
-        return metadata;
-      }
-    }
-    return null;
+  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;
+    });
   }
 };
-function offerDisplayTokens(offer) {
-  const swaps = offer.tokens.filter(
-    (token) => token.role === "swap" || token.role === "vault"
-  );
-  const distributions = offer.tokens.filter(
-    (token) => token.role === "distribution"
-  );
-  return [...swaps, ...distributions];
-}
-function registryKey(token) {
-  return `${token.chain}:${token.address.toLowerCase()}`;
-}
-
-// src/universal/types/blockchain/wallet-error.ts
-var RedactedWalletError = {
-  fromWalletError: (error) => error.type === "unknown" ? { type: "unknown" } : error
-};
 
-// 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`
-      );
+// src/universal/core/providers/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 {
-      ...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")
+      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;
   }
-};
-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] };
+  return null;
 }
-function parseTransactionCore(dto, model) {
-  return {
-    tx: {
-      to: EvmContractAddress(dto.to),
-      data: HexEncodedTransactionData(dto.data)
-    },
-    expiresAt: dateOrNull(dto.expires_at, `${model}.expires_at`)
-  };
+function isEthereumChain(chain) {
+  return chain in ETHEREUM_CHAINS;
 }
 
-// src/universal/types/user.ts
-var UserId = (value) => value;
-var UserEmail = (value) => value;
-var User = {
-  fromDto: (dto) => ({
-    id: UserId(dto.id),
-    email: UserEmail(dto.email)
-  })
-};
-
 export {
   AuthorizationCode,
   CodeVerifier,
@@ -524,30 +364,30 @@ export {
   ClientId,
   ClientSecret,
   generatePKCEParams,
+  RedactedWalletError,
+  swapSpender,
+  computePrice,
+  computeSlip,
+  SWAP_LEVEL,
+  isSwapAvailable,
+  OffersNamespaceImpl,
+  TokenRegistrySnapshot,
+  offerDisplayTokens,
   USDC_SYMBOL,
   USDC,
   USDT_SYMBOL,
   USDT,
   TOKEN_REGISTRY,
   ONDO_POLL_INTERVAL_MS,
-  ONDO_QUOTE_MAX_TTL_MS,
   DEFAULT_ONDO_AMOUNT_TO_COMPUTE_PRICE,
   ONDO_SETTLEMENT_ASSET,
   DEFAULT_ONDO_SELL_TOKENS_TO_COMPUTE_PRICE,
   ONDO_SUPPORTED_INPUT_ASSETS,
+  ONDO_NOT_TRADABLE_CODE,
+  isOndoNotTradableError,
   computeOndoBuyPrice,
   computeOndoSellPrice,
   ondoQuoteOfferDeadline,
-  ONDO_NOT_TRADABLE_CODE,
-  isOndoNotTradableError,
-  BPS_DENOM,
-  applyBps,
-  computePrice,
-  computeSlip,
-  SwapQuote,
-  SWAP_LEVEL,
-  isSwapAvailable,
-  decodeSwappedOutputAmount,
   SUPERSTATE_ISSUER_NAME,
   SUPERSTATE_SUPPORTED_INPUT_ASSETS,
   SWAP_POLL_INTERVAL_MS,
@@ -557,18 +397,7 @@ export {
   SUPERSTATE_SWAP_CONTRACT_ADDRESS_SEPOLIA,
   superstateSwapContractAddress,
   formattedPricePerShare,
-  OffersNamespaceImpl,
-  swapSpender,
-  TokenRegistrySnapshot,
-  offerDisplayTokens,
-  RedactedWalletError,
-  CentrifugeVaultQuote,
-  CentrifugeVaultStatus,
-  CentrifugeVaultBuyTransaction,
-  CentrifugeVaultClaimTransaction,
-  CentrifugeVaultPosition,
-  UserId,
-  UserEmail,
-  User
+  WalletSelection,
+  resolveCentrifugeVaults
 };
-//# sourceMappingURL=chunk-UJYSXXJF.js.map
+//# sourceMappingURL=chunk-RLOYYAMO.js.map