@coinlist-co/react 0.12.1-rc.6b77fc6 → 0.12.1-rc.9aec85a

package/dist/{chunk-DOSABR7Q.js → chunk-DCW7NQXH.js}

@@ -7,7 +7,7 @@ import {
   getUUIDv4,
   internalLogger,
   viemChain
-} from "./chunk-2YEJXE2V.js";
+} from "./chunk-MOE5S6CE.js";
 
 // src/universal/api/nabu/config.ts
 var NABU_BASE_URL = "https://asset.coinlist.co";
@@ -402,4 +402,4 @@ export {
   SDK_LOGGER_NAME,
   loggerOverPino
 };
-//# sourceMappingURL=chunk-DOSABR7Q.js.map
+//# sourceMappingURL=chunk-DCW7NQXH.js.map

package/dist/{chunk-2YEJXE2V.js → chunk-MOE5S6CE.js}

@@ -328,8 +328,15 @@ async function fetchAllPages(fetchPage, baseParams) {
 // src/universal/types/pagination.ts
 var Cursor = (value) => value;
 var PaginatedResponse = {
-  fromDto: (dto, itemMapper) => ({
-    data: dto.data.map(itemMapper),
+  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
   })
@@ -459,53 +466,6 @@ var StablecoinSymbol = (value) => value;
 var KnownAssetSymbol = StablecoinSymbol;
 var Bps = (value) => value;
 
-// src/universal/types/offer.ts
-var OfferId = (value) => value;
-var OfferSlug = (value) => value;
-var Offer = {
-  fromDto: (dto) => {
-    if (!Array.isArray(dto.tokens)) {
-      throw new ValidationError(
-        `Offer.tokens: expected an array, got ${typeof dto.tokens}`
-      );
-    }
-    return {
-      id: OfferId(dto.id),
-      slug: OfferSlug(dto.slug),
-      type: dto.type,
-      tagline: dto.tagline,
-      bannerUrl: dto.banner_url,
-      logoUrl: dto.logo_url,
-      startsAt: new Date(dto.starts_at),
-      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
-      tokens: OfferToken.listFromDto(dto.tokens)
-    };
-  }
-};
-var OfferToken = {
-  fromDto: (dto) => ({
-    role: dto.role,
-    chain: Chain(dto.chain),
-    address: EvmContractAddress(dto.address)
-  }),
-  /**
-   * Maps an offer's token list, dropping every token on a chain this SDK does
-   * not name. Frontline's chain registry runs ahead of {@link Chain}, and a
-   * plain `.map` would throw out of `Offer.fromDto` and, through
-   * `PaginatedResponse.fromDto`, reject the whole offers page - which is how
-   * one Base token blanked production's offers list. Dropping costs that
-   * token's metadata alone: `coinlist.tokens.get` takes an `EthereumChain`,
-   * so nobody could have looked it up anyway.
-   *
-   * Same shape as `TokenMetadata.fromRegistryDto`.
-   */
-  listFromDto: (dtos) => dtos.filter((dto) => isChain(dto.chain)).map(OfferToken.fromDto)
-};
-
-// src/universal/types/trading.ts
-var Ticker = (value) => value;
-var Isin = (value) => value;
-
 // src/universal/core/shared/utils/crypto.ts
 async function sha256(data) {
   const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
@@ -556,6 +516,131 @@ function notBlankStringOrNull(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 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
+};
+var isOfferType = (value) => Object.keys(OFFER_TYPES).includes(value);
+var OfferEditorial = {
+  /**
+   * `model` prefixes the field in the error (`'Offer'`, `'OfferDetail'`), so
+   * the same three checks name the payload that failed them.
+   */
+  fromDto: (dto, model) => ({
+    tagline: requiredString(dto.tagline, `${model}.tagline`),
+    bannerUrl: requiredString(dto.banner_url, `${model}.banner_url`),
+    startsAt: requiredDate(dto.starts_at, `${model}.starts_at`)
+  })
+};
+var Offer = {
+  fromDto: (dto) => {
+    const tokens = requiredArray(dto.tokens, "Offer.tokens");
+    const base2 = {
+      id: OfferId(dto.id),
+      slug: OfferSlug(dto.slug),
+      endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
+      tokens: OfferToken.listFromDto(tokens)
+    };
+    switch (dto.type) {
+      case "coinlist::token_sale":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "Offer"),
+          type: dto.type,
+          logoUrl: requiredString(dto.logo_url, "Offer.logo_url")
+        };
+      case "superstate::swap":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "Offer"),
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      // `tagline`, `banner_url` and `starts_at` arrive as `null` and are left
+      // 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":
+        return {
+          ...base2,
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      default:
+        return unknownTypeError(dto, "Offer");
+    }
+  },
+  /**
+   * Maps a page of offers, dropping every offer whose `type` this SDK does not
+   * name. The same reasoning as {@link OfferToken.listFromDto}: a plain `.map`
+   * would throw out of `fromDto` and, through `PaginatedResponse.fromDto`,
+   * reject the whole page, so one offer of an unknown type would blank the
+   * grid for every offer beside it. A single offer fetched by id still
+   * throws, because there is nothing beside it to keep.
+   */
+  listFromDto: (dtos) => dtos.filter((dto) => isOfferType(dto.type)).map(Offer.fromDto)
+};
+var OfferToken = {
+  fromDto: (dto) => ({
+    role: dto.role,
+    chain: Chain(dto.chain),
+    address: EvmContractAddress(dto.address)
+  }),
+  /**
+   * Maps an offer's token list, dropping every token on a chain this SDK does
+   * not name. Frontline's chain registry runs ahead of {@link Chain}, and a
+   * plain `.map` would throw out of `Offer.fromDto` and, through
+   * `PaginatedResponse.fromDto`, reject the whole offers page - which is how
+   * one Base token blanked production's offers list. Dropping costs that
+   * token's metadata alone: `coinlist.tokens.get` takes an `EthereumChain`,
+   * so nobody could have looked it up anyway.
+   *
+   * Same shape as `TokenMetadata.fromRegistryDto`.
+   */
+  listFromDto: (dtos) => dtos.filter((dto) => isChain(dto.chain)).map(OfferToken.fromDto)
+};
+
+// src/universal/types/trading.ts
+var Ticker = (value) => value;
+var Isin = (value) => value;
+
 // src/universal/types/offer-detail.ts
 var OfferOptionId = (value) => value;
 var OfferOptionSlug = (value) => value;
@@ -567,76 +652,69 @@ var OfferSwapContract = {
 };
 var OfferDetail = {
   fromDto: (dto) => {
-    if (!Array.isArray(dto.funding_assets)) {
-      throw new ValidationError(
-        `OfferDetail.funding_assets: expected an array, got ${typeof dto.funding_assets}`
-      );
-    }
-    if (!Array.isArray(dto.options)) {
-      throw new ValidationError(
-        `OfferDetail.options: expected an array, got ${typeof dto.options}`
-      );
-    }
-    if (!Array.isArray(dto.terms)) {
-      throw new ValidationError(
-        `OfferDetail.terms: expected an array, got ${typeof dto.terms}`
-      );
-    }
-    if (!Array.isArray(dto.links)) {
-      throw new ValidationError(
-        `OfferDetail.links: expected an array, got ${typeof dto.links}`
-      );
-    }
-    if (!Array.isArray(dto.faqs)) {
-      throw new ValidationError(
-        `OfferDetail.faqs: expected an array, got ${typeof dto.faqs}`
-      );
-    }
-    if (!Array.isArray(dto.milestones)) {
-      throw new ValidationError(
-        `OfferDetail.milestones: expected an array, got ${typeof dto.milestones}`
-      );
-    }
-    if (!Array.isArray(dto.tokens)) {
-      throw new ValidationError(
-        `OfferDetail.tokens: expected an array, got ${typeof dto.tokens}`
-      );
-    }
-    const swapContracts = dto.swap_contracts === void 0 ? [] : dto.swap_contracts;
-    if (!Array.isArray(swapContracts)) {
-      throw new ValidationError(
-        `OfferDetail.swap_contracts: expected an array, got ${typeof swapContracts}`
-      );
-    }
+    const fundingAssets = requiredArray(
+      dto.funding_assets,
+      "OfferDetail.funding_assets"
+    );
+    const options = requiredArray(dto.options, "OfferDetail.options");
+    const terms = requiredArray(dto.terms, "OfferDetail.terms");
+    const links = requiredArray(dto.links, "OfferDetail.links");
+    const faqs = requiredArray(dto.faqs, "OfferDetail.faqs");
+    const milestones = requiredArray(dto.milestones, "OfferDetail.milestones");
+    const tokens = requiredArray(dto.tokens, "OfferDetail.tokens");
     const isin = notBlankStringOrNull(dto.isin);
     const ticker = notBlankStringOrNull(dto.ticker);
-    return {
+    const base2 = {
       id: OfferId(dto.id),
       slug: OfferSlug(dto.slug),
-      type: dto.type,
       name: dto.name,
       asset: Asset.fromDto(dto.asset),
-      fundingAssets: dto.funding_assets.map(Asset.fromDto),
-      tokens: OfferToken.listFromDto(dto.tokens),
-      swapContracts: swapContracts.map(OfferSwapContract.fromDto),
+      fundingAssets: fundingAssets.map(Asset.fromDto),
+      tokens: OfferToken.listFromDto(tokens),
       about: notBlankStringOrNull(dto.about),
-      tagline: dto.tagline,
-      bannerUrl: dto.banner_url,
-      logoUrl: dto.logo_url,
       category: dto.category,
       issuer: notBlankStringOrNull(dto.issuer),
       isin: isin === null ? null : Isin(isin),
       ticker: ticker === null ? null : Ticker(ticker),
       instrumentType: notBlankStringOrNull(dto.instrument_type),
       listingVenue: notBlankStringOrNull(dto.listing_venue),
-      startsAt: new Date(dto.starts_at),
       endsAt: dto.ends_at ? new Date(dto.ends_at) : null,
-      faqs: dto.faqs.map(FaqItem.fromDto),
-      links: dto.links.map(Link.fromDto),
-      milestones: dto.milestones.map(Milestone.fromDto),
-      options: dto.options.map(OfferOption.fromDto),
-      terms: dto.terms.map(TermItem.fromDto)
+      faqs: faqs.map(FaqItem.fromDto),
+      links: links.map(Link.fromDto),
+      milestones: milestones.map(Milestone.fromDto),
+      options: options.map(OfferOption.fromDto),
+      terms: terms.map(TermItem.fromDto)
     };
+    switch (dto.type) {
+      case "coinlist::token_sale":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "OfferDetail"),
+          type: dto.type,
+          logoUrl: requiredString(dto.logo_url, "OfferDetail.logo_url")
+        };
+      case "superstate::swap":
+        return {
+          ...base2,
+          ...OfferEditorial.fromDto(dto, "OfferDetail"),
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url)
+        };
+      // `tagline`, `banner_url` and `starts_at` arrive as `null` and are left
+      // on the wire, as in `Offer.fromDto`.
+      case "ondo::swap":
+        return {
+          ...base2,
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url),
+          swapContracts: requiredArray(
+            dto.swap_contracts,
+            "OfferDetail.swap_contracts"
+          ).map(OfferSwapContract.fromDto)
+        };
+      default:
+        return unknownTypeError(dto, "OfferDetail");
+    }
   }
 };
 var OfferOption = {
@@ -1166,10 +1244,14 @@ function parseBlockchainAmount(amount, decimals) {
   if (/[eE]/.test(trimmed)) {
     return { valid: false, reason: { type: "invalid-format" } };
   }
-  if (!/^\d+(\.\d+)?$/.test(trimmed)) {
+  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 = ""] = trimmed.split(".");
+  const [, fraction = ""] = normalised.split(".");
   if (fraction.length > decimals) {
     return {
       valid: false,
@@ -1177,7 +1259,7 @@ function parseBlockchainAmount(amount, decimals) {
     };
   }
   try {
-    const raw = parseUnits(trimmed, decimals);
+    const raw = parseUnits(normalised, decimals);
     if (raw > MAX_UINT_256) {
       return { valid: false, reason: { type: "overflow" } };
     }
@@ -3283,7 +3365,7 @@ async function fetchOffersPage(api, params, clientCreds) {
       Attributes.clientCredentials(clientCreds)
     )
   });
-  return PaginatedResponse.fromDto(pageDto, Offer.fromDto);
+  return PaginatedResponse.fromDtoPage(pageDto, Offer.listFromDto);
 }
 async function fetchOfferDetails(api, id, clientCreds) {
   const dto = await api.send({
@@ -3355,6 +3437,8 @@ export {
   Bps,
   OfferId,
   OfferSlug,
+  isOfferType,
+  OfferEditorial,
   Offer,
   OfferToken,
   Ticker,
@@ -3437,4 +3521,4 @@ export {
   OAuthRefreshToken,
   OAuthSession
 };
-//# sourceMappingURL=chunk-2YEJXE2V.js.map
+//# sourceMappingURL=chunk-MOE5S6CE.js.map