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

package/dist/server/index.cjs

@@ -1293,40 +1293,6 @@ async function fetchAllPages(fetchPage, baseParams) {
   return items;
 }
 
-// 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 requiredArray(value, field) {
-  if (!Array.isArray(value)) {
-    throw new ValidationError(
-      `${field}: expected an array, got ${typeof value}`
-    );
-  }
-  return value;
-}
-
 // src/universal/types/blockchain/core.ts
 var ETHEREUM_CHAINS = {
   ethereum_mainnet: true,
@@ -1415,13 +1381,54 @@ function combineAmounts(a, b, op) {
 }
 var AssetSymbol = (value) => 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/offer.ts
 var OfferId = (value) => value;
 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 = {
@@ -1463,6 +1470,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,
@@ -1527,6 +1535,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(
@@ -1589,6 +1610,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");
     }
@@ -2060,6 +2093,282 @@ function transportFor(api, override, chain, logger) {
   return typeof override === "string" ? (0, import_viem3.http)(override) : override;
 }
 
+// src/universal/core/shared/blockchain/math.ts
+var import_viem4 = 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})`);
+  }
+}
+
+// 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 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/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);
+    });
+  }
+  async buildBuyTransaction(params) {
+    return this.log.wrap("buildBuyTransaction", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return buildCentrifugeVaultBuy(this.ctx.api, params);
+    });
+  }
+};
+
 // src/universal/types/providers/coin-list/token-sale.ts
 var ParticipationId = (value) => value;
 var Blockchain = (value) => value;
@@ -2174,39 +2483,15 @@ var CoinListTokenSaleNamespaceImpl = class {
 };
 
 // src/universal/core/shared/blockchain/formatters.ts
-var import_viem4 = require("viem");
+var import_viem5 = require("viem");
 function formatRawAmount(amount) {
-  return (0, import_viem4.formatUnits)(amount.raw, amount.decimals);
+  return (0, import_viem5.formatUnits)(amount.raw, amount.decimals);
 }
 var NA_AMOUNT_ASSET_UI = FormattedAmountAssetUi("-");
 var SHARE_MAX_FRACTION_DIGITS = AssetDecimals(6);
 var SHARE_MIN_FRACTION_DIGITS = AssetDecimals(2);
 var USD_FRACTION_DIGITS = AssetDecimals(2);
 
-// src/universal/core/shared/blockchain/math.ts
-var import_viem5 = 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})`);
-  }
-}
-
 // src/universal/types/providers/ondo/ondo.ts
 var OndoTradingStatus = {
   fromDto: (dto) => {
@@ -2222,7 +2507,6 @@ var OndoTradingStatus = {
     };
   }
 };
-var decimalOrNull = (value) => value === null ? null : DecimalString(value);
 var OndoQuote = {
   fromDto: (dto) => {
     const assetDecimals = AssetDecimals(dto.asset_decimals);
@@ -4060,6 +4344,7 @@ var CoinListServerImpl = class {
     this.tokenSale = new CoinListTokenSaleNamespaceImpl(ctx);
     this.superstate = new SuperstateSwapNamespaceImpl(ctx);
     this.ondo = new OndoNamespaceImpl(ctx);
+    this.centrifuge = new CentrifugeNamespaceImpl(ctx);
     this.tokens = new TokensNamespaceImpl(
       _config.tokensBaseUrl ?? NABU_BASE_URL,
       logger