@coinlist-co/react 0.2.0 → 0.4.0

package/dist/client/index.cjs

@@ -22,6 +22,7 @@ var client_exports = {};
 __export(client_exports, {
   AuthorizationCode: () => AuthorizationCode,
   Blockchain: () => Blockchain,
+  ChecklistStatus: () => ChecklistStatus,
   ClientId: () => ClientId,
   ClientSecret: () => ClientSecret,
   CodeChallenge: () => CodeChallenge,
@@ -45,7 +46,13 @@ __export(client_exports, {
   PaginationParams: () => PaginationParams,
   Participation: () => Participation,
   ParticipationId: () => ParticipationId,
+  ParticipationsPaginationParams: () => ParticipationsPaginationParams,
   RedirectUri: () => RedirectUri,
+  Requirement: () => Requirement,
+  RequirementId: () => RequirementId,
+  RequirementStatus: () => RequirementStatus,
+  RequirementStatusInfo: () => RequirementStatusInfo,
+  RequirementVariant: () => RequirementVariant,
   TermItem: () => TermItem,
   User: () => User,
   UserEmail: () => UserEmail,
@@ -54,13 +61,94 @@ __export(client_exports, {
   createCoinListClient: () => createCoinListClient,
   fetchAllPages: () => fetchAllPages,
   useCoinList: () => useCoinList,
-  useCompleteCoinListOAuth: () => useCompleteCoinListOAuth
+  useCoinListOfferDetails: () => useCoinListOfferDetails,
+  useCoinListOffers: () => useCoinListOffers,
+  useCoinListRequirements: () => useCoinListRequirements,
+  useCompleteCoinListOAuth: () => useCompleteCoinListOAuth,
+  useParticipations: () => useParticipations
 });
 module.exports = __toCommonJS(client_exports);
 
 // src/client/CoinListProvider.tsx
 var import_react = require("react");
 
+// src/shared/utils.ts
+async function sha256(data) {
+  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  const buffer = bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  );
+  return crypto.subtle.digest("SHA-256", buffer);
+}
+function arrayBufferToBase64Url(buffer, padding = true) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  let base64 = btoa(binary);
+  base64 = base64.replace(/\+/g, "-").replace(/\//g, "_");
+  if (!padding) {
+    base64 = base64.replace(/=+$/, "");
+  }
+  return base64;
+}
+function generateSecureRandomBase64Url(byteLength) {
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+  const buffer = bytes.buffer;
+  return arrayBufferToBase64Url(buffer, false);
+}
+function getUUIDv4() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+    return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 12)}`;
+}
+function notBlankStringOrNull(value) {
+  if (value?.trim()) {
+    return value;
+  } else {
+    return null;
+  }
+}
+
+// src/client/core/api/middleware/device-id.ts
+var DEVICE_ID_KEY = "coinlist.device_id";
+function getDeviceId() {
+  let deviceId = localStorage.getItem(DEVICE_ID_KEY);
+  if (!deviceId) {
+    deviceId = getUUIDv4();
+    localStorage.setItem(DEVICE_ID_KEY, deviceId);
+  }
+  return deviceId;
+}
+
+// src/shared/api/frontline/index.ts
+var PUBLIC_API_BASE_URL = "https://api.coinlist.co";
+var HEADER_API_VERSION = "X-API-Version";
+var HEADER_USER_AGENT = "User-Agent";
+var HEADER_IDEMPOTENCY_KEY = "Idempotency-Key";
+var API_VERSION = "2025-10-17";
+var COINLIST_BASE_URL = "https://coinlist.co";
+var OAUTH_PAGE_PATH = "/oauth/authorize";
+var SUPPORT_NEW_TICKET_URL = "https://support.coinlist.co/support/tickets/new";
+var VERIFY_IDENTITY_PATH = "/verify-identity";
+var VERIFY_IDENTITY_VERIFIED_PATH = "/verify-identity/identity_verified";
+var VERIFY_IDENTITY_PROOF_OF_ADDRESS_PATH = "/verify-identity/proof_of_address";
+var VERIFY_IDENTITY_SOURCE_OF_FUNDS_PATH = "/verify-identity/source_of_funds";
+var VERIFY_IDENTITY_ACCREDITATION_PATH = "/verify-identity/accreditation_full";
+var WALLET_PATH = "/wallet";
+
 // src/shared/api/http-attributes.ts
 var empty = {};
 var concat = (left, right) => ({
@@ -106,24 +194,28 @@ var Attributes = {
   wasRenewAttempted
 };
 
-// src/client/core/api/middleware/attach-session-middleware.ts
-function attachSessionMiddleware(fetchAccessToken) {
-  return async (request) => {
-    if (!Attributes.isProtected(request.attributes)) {
-      return request;
-    }
-    const accessToken = await fetchAccessToken(false);
-    if (accessToken === null) {
-      return request;
+// src/client/core/api/middleware/user-agent.ts
+var userAgentMiddleware = async (request) => {
+  if (!Attributes.needUserAgent(request.attributes)) {
+    return request;
+  }
+  const userAgent2 = generateUserAgent();
+  return {
+    ...request,
+    headers: {
+      ...request.headers ?? {},
+      [HEADER_USER_AGENT]: userAgent2
     }
-    return {
-      ...request,
-      headers: {
-        ...request.headers ?? {},
-        Authorization: `Bearer ${accessToken.value}`
-      }
-    };
   };
+};
+function generateUserAgent() {
+  const appInfo = `CoinList/1.0`;
+  const deviceInfo = "Web Browser";
+  const devicePlatform = "DevicePlatform web";
+  const deviceAppId = "DeviceAppID co.coinlist.sdk";
+  const deviceId = getDeviceId();
+  const finalDeviceId = `DeviceID ${deviceId}`;
+  return `${appInfo} (${deviceInfo}; ${devicePlatform}; ${deviceAppId}; ${finalDeviceId})`;
 }
 
 // src/shared/api/http.ts
@@ -224,124 +316,6 @@ var Request = {
   concatAttributes
 };
 
-// src/client/core/api/middleware/session-renewal.ts
-function renewSessionMiddleware(fetchAccessToken) {
-  return async ({ request, response, retry }) => {
-    if (response.status !== 401) {
-      return response;
-    }
-    if (!Attributes.isProtected(request.attributes)) {
-      return response;
-    }
-    if (Attributes.wasRenewAttempted(request.attributes)) {
-      return response;
-    }
-    const newToken = await fetchAccessToken(true);
-    if (newToken) {
-      const nextRequest = Request.concatAttributes(
-        request,
-        Attributes.renewAttempted(true)
-      );
-      return retry(nextRequest);
-    } else {
-      return response;
-    }
-  };
-}
-
-// src/shared/utils.ts
-async function sha256(data) {
-  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
-  const buffer = bytes.buffer.slice(
-    bytes.byteOffset,
-    bytes.byteOffset + bytes.byteLength
-  );
-  return crypto.subtle.digest("SHA-256", buffer);
-}
-function arrayBufferToBase64Url(buffer, padding = true) {
-  const bytes = new Uint8Array(buffer);
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  let base64 = btoa(binary);
-  base64 = base64.replace(/\+/g, "-").replace(/\//g, "_");
-  if (!padding) {
-    base64 = base64.replace(/=+$/, "");
-  }
-  return base64;
-}
-function generateSecureRandomBase64Url(byteLength) {
-  const bytes = new Uint8Array(byteLength);
-  crypto.getRandomValues(bytes);
-  const buffer = bytes.buffer;
-  return arrayBufferToBase64Url(buffer, false);
-}
-function getUUIDv4() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
-    const bytes = new Uint8Array(16);
-    crypto.getRandomValues(bytes);
-    bytes[6] = bytes[6] & 15 | 64;
-    bytes[8] = bytes[8] & 63 | 128;
-    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
-    return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
-  }
-  return `${Date.now()}-${Math.random().toString(36).slice(2, 12)}`;
-}
-function notBlankStringOrNull(value) {
-  if (value?.trim()) {
-    return value;
-  } else {
-    return null;
-  }
-}
-
-// src/client/core/api/middleware/device-id.ts
-var DEVICE_ID_KEY = "coinlist.device_id";
-function getDeviceId() {
-  let deviceId = localStorage.getItem(DEVICE_ID_KEY);
-  if (!deviceId) {
-    deviceId = getUUIDv4();
-    localStorage.setItem(DEVICE_ID_KEY, deviceId);
-  }
-  return deviceId;
-}
-
-// src/shared/api/frontline.ts
-var PUBLIC_API_BASE_URL = "https://api.coinlist.co";
-var HEADER_API_VERSION = "X-API-Version";
-var HEADER_USER_AGENT = "User-Agent";
-var HEADER_IDEMPOTENCY_KEY = "Idempotency-Key";
-var API_VERSION = "2025-10-17";
-var COINLIST_OAUTH_PAGE_URL = "https://coinlist.co/oauth/authorize";
-
-// src/client/core/api/middleware/user-agent.ts
-var userAgentMiddleware = async (request) => {
-  if (!Attributes.needUserAgent(request.attributes)) {
-    return request;
-  }
-  const userAgent2 = generateUserAgent();
-  return {
-    ...request,
-    headers: {
-      ...request.headers ?? {},
-      [HEADER_USER_AGENT]: userAgent2
-    }
-  };
-};
-function generateUserAgent() {
-  const appInfo = `CoinList/1.0`;
-  const deviceInfo = "Web Browser";
-  const devicePlatform = "DevicePlatform web";
-  const deviceAppId = "DeviceAppID co.coinlist.sdk";
-  const deviceId = getDeviceId();
-  const finalDeviceId = `DeviceID ${deviceId}`;
-  return `${appInfo} (${deviceInfo}; ${devicePlatform}; ${deviceAppId}; ${finalDeviceId})`;
-}
-
 // src/shared/api/http-client.ts
 var HttpClient = class {
   constructor(config, middleware = {}) {
@@ -411,6 +385,26 @@ var HttpClient = class {
   }
 };
 
+// src/shared/api/middleware/attach-session-middleware.ts
+function attachSessionMiddleware(fetchAccessToken) {
+  return async (request) => {
+    if (!Attributes.isProtected(request.attributes)) {
+      return request;
+    }
+    const accessToken = await fetchAccessToken(false);
+    if (accessToken === null) {
+      return request;
+    }
+    return {
+      ...request,
+      headers: {
+        ...request.headers ?? {},
+        Authorization: `Bearer ${accessToken.value}`
+      }
+    };
+  };
+}
+
 // src/shared/api/middleware/idempotency-key.ts
 var idempotencyKeyMiddleware = async (request) => {
   if (!Attributes.isIdempotent(request.attributes)) {
@@ -464,19 +458,42 @@ function defaultDelay(ms) {
 }
 var requestRetryMiddleware = createRequestRetryMiddleware();
 
-// src/client/core/api/api-client.ts
-var ApiClient = class {
-  constructor(config, fetchAccessToken) {
-    this.config = config;
-    this.fetchAccessToken = fetchAccessToken;
-    this.httpClient = new HttpClient(this.config, {
+// src/shared/api/middleware/session-renewal.ts
+function renewSessionMiddleware(fetchAccessToken) {
+  return async ({ request, response, retry }) => {
+    if (response.status !== 401) {
+      return response;
+    }
+    if (!Attributes.isProtected(request.attributes)) {
+      return response;
+    }
+    if (Attributes.wasRenewAttempted(request.attributes)) {
+      return response;
+    }
+    const newToken = await fetchAccessToken(true);
+    if (newToken) {
+      const nextRequest = Request.concatAttributes(
+        request,
+        Attributes.renewAttempted(true)
+      );
+      return retry(nextRequest);
+    } else {
+      return response;
+    }
+  };
+}
+
+// src/shared/api/authenticated-api-client.ts
+var AuthenticatedApiClient = class {
+  constructor(config, fetchAccessToken, additionalBeforeRequest = []) {
+    this.httpClient = new HttpClient(config, {
       beforeRequest: [
-        attachSessionMiddleware(this.fetchAccessToken),
-        userAgentMiddleware,
+        attachSessionMiddleware(fetchAccessToken),
+        ...additionalBeforeRequest,
         idempotencyKeyMiddleware
       ],
       afterRequest: [
-        renewSessionMiddleware(this.fetchAccessToken),
+        renewSessionMiddleware(fetchAccessToken),
         requestRetryMiddleware
       ]
     });
@@ -491,15 +508,29 @@ var ApiClient = class {
   }
 };
 
+// src/client/core/api/api-client.ts
+var ApiClient = class {
+  constructor(config, fetchAccessToken) {
+    this.client = new AuthenticatedApiClient(config, fetchAccessToken, [
+      userAgentMiddleware
+    ]);
+  }
+  async send(request) {
+    return this.client.send(request);
+  }
+};
+
 // src/shared/api/pagination.ts
 var Cursor = (value) => value;
-async function fetchAllPages(fetchPage) {
+async function fetchAllPages(fetchPage, baseParams) {
   const items = [];
   let cursor = null;
   do {
-    const page = await fetchPage({
+    const params = {
+      ...baseParams ?? {},
       after: cursor ?? void 0
-    });
+    };
+    const page = await fetchPage(params);
     items.push(...page.data);
     cursor = page.startingAfter;
   } while (cursor);
@@ -528,22 +559,6 @@ var PaginationParams = {
   }
 };
 
-// src/shared/types/errors.ts
-var NotAuthenticatedError = class extends Error {
-  constructor(message = "The user is not authenticated. Go through the OAuth flow first!") {
-    super(message);
-    this.name = "NotAuthenticatedError";
-  }
-};
-
-// src/shared/types/oauth.ts
-var AuthorizationCode = (value) => value;
-var CodeVerifier = (value) => value;
-var CodeChallenge = (value) => value;
-var RedirectUri = (value) => value;
-var ClientId = (value) => value;
-var ClientSecret = (value) => value;
-
 // src/shared/types/offer.ts
 var OfferId = (value) => value;
 var OfferSlug = (value) => value;
@@ -653,10 +668,44 @@ var Milestone = {
   })
 };
 
+// src/shared/api/frontline/offers.ts
+async function fetchAllOffers(api) {
+  return fetchAllPages((params) => fetchOffersPage(api, params));
+}
+async function fetchOffersPage(api, params) {
+  const queryParams = PaginationParams.toQueryParams(params);
+  const pageDto = await api.send({
+    method: "GET",
+    url: "/v1/offers",
+    queryParams,
+    attributes: Attributes.protected()
+  });
+  return PaginatedResponse.fromDto(pageDto, Offer.fromDto);
+}
+async function fetchOfferDetails(api, id) {
+  const dto = await api.send({
+    method: "GET",
+    url: `/v1/offers/${id}`,
+    attributes: Attributes.protected()
+  });
+  return OfferDetail.fromDto(dto);
+}
+
 // src/shared/types/participation.ts
 var ParticipationId = (value) => value;
 var Blockchain = (value) => value;
 var WalletAddress = (value) => value;
+var ParticipationsPaginationParams = {
+  toQueryParams: (params) => {
+    const queryParams = PaginationParams.toQueryParams(params);
+    if (params.offerId) {
+      queryParams["filters[0][field]"] = "offer_id";
+      queryParams["filters[0][op]"] = "==";
+      queryParams["filters[0][value]"] = params.offerId;
+    }
+    return queryParams;
+  }
+};
 var Participation = {
   /** Maps API DTO shape into the SDK participation domain model. */
   fromDto: (dto) => {
@@ -689,6 +738,95 @@ var CreateParticipationParams = {
   })
 };
 
+// src/shared/api/frontline/participations.ts
+async function fetchAllParticipations(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/shared/types/requirement.ts
+var RequirementId = (value) => value;
+var Requirement = {
+  fromDto: (dto) => ({
+    id: RequirementId(dto.id),
+    type: dto.type,
+    details: dto.details
+  })
+};
+var RequirementStatusInfo = {
+  fromStatusesDto: (dto) => Object.entries(dto.statuses).map(([id, status]) => ({
+    id: RequirementId(id),
+    status
+  }))
+};
+
+// src/shared/api/frontline/requirements.ts
+async function fetchOfferRequirements(api, offerId) {
+  const response = await api.send({
+    method: "GET",
+    url: `/v1/offers/${offerId}/requirements`,
+    attributes: Attributes.protected()
+  });
+  return Object.fromEntries(
+    Object.entries(response.options).map(([optionId, list]) => [
+      optionId,
+      list.data.map(Requirement.fromDto)
+    ])
+  );
+}
+async function fetchRequirementStatuses(api, offerId) {
+  const response = await api.send({
+    method: "GET",
+    url: `/v1/offers/${offerId}/requirements/statuses`,
+    attributes: Attributes.protected()
+  });
+  return RequirementStatusInfo.fromStatusesDto(response);
+}
+
+// src/shared/types/errors.ts
+var NotAuthenticatedError = class extends Error {
+  constructor(message = "The user is not authenticated. Go through the OAuth flow first!") {
+    super(message);
+    this.name = "NotAuthenticatedError";
+  }
+};
+
+// src/shared/types/oauth.ts
+var AuthorizationCode = (value) => value;
+var CodeVerifier = (value) => value;
+var CodeChallenge = (value) => value;
+var RedirectUri = (value) => value;
+var ClientId = (value) => value;
+var ClientSecret = (value) => value;
+
 // src/client/core/coinlist-client.ts
 var OAUTH_STATE_KEY = "coinlist.oauth_state";
 var OAUTH_CODE_VERIFIER_KEY = "coinlist.oauth_code_verifier";
@@ -741,8 +879,8 @@ var CoinListClientImpl = class {
       code_challenge_method: "S256",
       state
     });
-    const oauthPageUrl = this._config.authorizationPageUrl ?? COINLIST_OAUTH_PAGE_URL;
-    const url = `${oauthPageUrl}?${params.toString()}`;
+    const baseUrl = this._config.coinlistBaseUrl ?? COINLIST_BASE_URL;
+    const url = `${baseUrl}${OAUTH_PAGE_PATH}?${params.toString()}`;
     window.location.href = url;
   }
   completeOAuth() {
@@ -778,61 +916,76 @@ var CoinListClientImpl = class {
   }
   async fetchAllOffers() {
     this.ensureAuthenticated();
-    return await fetchAllPages(this.fetchOffersPage.bind(this));
+    return fetchAllOffers(this.api);
   }
   async fetchOffersPage(params) {
     this.ensureAuthenticated();
-    const pageDto = await this.api.send({
-      method: "GET",
-      url: "/v1/offers",
-      queryParams: PaginationParams.toQueryParams(params),
-      attributes: Attributes.protected()
-    });
-    return PaginatedResponse.fromDto(pageDto, Offer.fromDto);
+    return fetchOffersPage(this.api, params);
   }
   async fetchOfferDetails(id) {
     this.ensureAuthenticated();
-    const offerDetailDto = await this.api.send({
-      method: "GET",
-      url: `/v1/offers/${id}`,
-      attributes: Attributes.protected()
-    });
-    return OfferDetail.fromDto(offerDetailDto);
+    return fetchOfferDetails(this.api, id);
   }
-  async fetchAllParticipations() {
+  async fetchAllParticipations(offerId) {
     this.ensureAuthenticated();
-    return await fetchAllPages(this.fetchParticipationsPage.bind(this));
+    return fetchAllParticipations(this.api, offerId);
   }
   async fetchParticipationsPage(params) {
     this.ensureAuthenticated();
-    const pageDto = await this.api.send(
-      {
-        method: "GET",
-        url: "/v1/participations",
-        queryParams: PaginationParams.toQueryParams(params),
-        attributes: Attributes.protected()
-      }
-    );
-    return PaginatedResponse.fromDto(pageDto, Participation.fromDto);
+    return fetchParticipationsPage(this.api, params);
   }
   async fetchParticipation(id) {
     this.ensureAuthenticated();
-    const participationDto = await this.api.send({
-      method: "GET",
-      url: `/v1/participations/${id}`,
-      attributes: Attributes.protected()
-    });
-    return Participation.fromDto(participationDto);
+    return fetchParticipation(this.api, id);
   }
   async createParticipation(params) {
     this.ensureAuthenticated();
-    const participationDto = await this.api.send({
-      method: "POST",
-      url: "/v1/participations",
-      body: CreateParticipationParams.toDto(params),
-      attributes: Attributes.protected()
-    });
-    return Participation.fromDto(participationDto);
+    return createParticipation(this.api, params);
+  }
+  async fetchOfferRequirements(offerId) {
+    this.ensureAuthenticated();
+    return fetchOfferRequirements(this.api, offerId);
+  }
+  async fetchRequirementStatuses(offerId) {
+    this.ensureAuthenticated();
+    return fetchRequirementStatuses(this.api, offerId);
+  }
+  handleRequirement(requirement) {
+    const baseUrl = this._config.coinlistBaseUrl ?? COINLIST_BASE_URL;
+    let path;
+    switch (requirement.type) {
+      case "kyc_approved":
+        path = VERIFY_IDENTITY_PATH;
+        break;
+      case "identity_verified":
+        path = VERIFY_IDENTITY_VERIFIED_PATH;
+        break;
+      case "proof_of_address":
+        path = VERIFY_IDENTITY_PROOF_OF_ADDRESS_PATH;
+        break;
+      case "source_of_funds":
+        path = VERIFY_IDENTITY_SOURCE_OF_FUNDS_PATH;
+        break;
+      case "accreditation":
+        path = VERIFY_IDENTITY_ACCREDITATION_PATH;
+        break;
+      case "external_wallet":
+      case "whitelisted_wallet":
+        path = WALLET_PATH;
+        break;
+      case "jurisdiction":
+        path = null;
+        break;
+      default: {
+        const _exhaustive = requirement.type;
+        return;
+      }
+    }
+    if (path === null) return;
+    openInNewTab(new URL(path, baseUrl).toString());
+  }
+  contactSupport() {
+    openInNewTab(SUPPORT_NEW_TICKET_URL);
   }
   ensureAuthenticated() {
     if (this.getAuthState() !== "logged-in") {
@@ -840,6 +993,9 @@ var CoinListClientImpl = class {
     }
   }
 };
+function openInNewTab(url) {
+  window.open(url, "_blank", "noopener,noreferrer");
+}
 function createCoinListClient(config) {
   return new CoinListClientImpl(config);
 }
@@ -873,6 +1029,43 @@ function CoinListProvider({ config, children }) {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CoinListContext.Provider, { value, children });
 }
 
+// src/client/components/requirements/RequirementItem.tsx
+var import_lucide_react = require("lucide-react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var RequirementVariant = {
+  fromType(type) {
+    switch (type) {
+      case "external_wallet":
+      case "whitelisted_wallet":
+        return "wallet";
+      default:
+        return "verification";
+    }
+  }
+};
+var RequirementStatus = {
+  fromStatusValue(status) {
+    switch (status) {
+      case "not_started":
+      case "action_needed":
+        return "required";
+      case "in_progress":
+        return "pending";
+      case "completed":
+        return "completed";
+      case "rejected":
+        return "rejected";
+    }
+  }
+};
+var ChecklistStatus = {
+  derive(statuses) {
+    if (statuses.some((s) => s.status === "rejected")) return "ineligible";
+    if (statuses.every((s) => s.status === "completed")) return "eligible";
+    return "inProgress";
+  }
+};
+
 // src/client/hooks/useCoinList.ts
 var import_react2 = require("react");
 function useCoinList() {
@@ -892,18 +1085,153 @@ var CoinListClientInitializationError = class extends Error {
   }
 };
 
-// src/client/hooks/useCompleteCoinListOAuth.ts
+// src/client/hooks/useCoinListOfferDetails.ts
 var import_react3 = require("react");
+var LOADING_STATE = { type: "LOADING" };
+function useCoinListOfferDetails(offerId, options = {}) {
+  const { coinlist, isReady } = useCoinList();
+  const { serverData } = options;
+  const [offerDetailsState, setOfferDetailsState] = (0, import_react3.useState)(
+    serverData !== void 0 ? { type: "CONTENT", offerDetail: serverData } : LOADING_STATE
+  );
+  (0, import_react3.useEffect)(() => {
+    let isCancelled = false;
+    if (!isReady) {
+      if (serverData === void 0) {
+        setOfferDetailsState(LOADING_STATE);
+      }
+      return () => {
+        isCancelled = true;
+      };
+    }
+    if (serverData !== void 0) {
+      return () => {
+        isCancelled = true;
+      };
+    }
+    setOfferDetailsState(LOADING_STATE);
+    coinlist.fetchOfferDetails(offerId).then((offerDetail) => {
+      if (!isCancelled) {
+        setOfferDetailsState({ type: "CONTENT", offerDetail });
+      }
+    }).catch((error) => {
+      if (!isCancelled) {
+        const reason = error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+        setOfferDetailsState({ type: "ERROR", reason });
+      }
+    });
+    return () => {
+      isCancelled = true;
+    };
+  }, [coinlist, isReady, offerId, serverData]);
+  return { offerDetailsState };
+}
+
+// src/client/hooks/useCoinListOffers.ts
+var import_react4 = require("react");
+var LOADING_STATE2 = { type: "LOADING" };
+function useCoinListOffers(options = {}) {
+  const { coinlist, isReady } = useCoinList();
+  const { serverOffers } = options;
+  const [offersState, setOffersState] = (0, import_react4.useState)(
+    serverOffers !== void 0 ? { type: "CONTENT", offers: serverOffers } : LOADING_STATE2
+  );
+  (0, import_react4.useEffect)(() => {
+    let isCancelled = false;
+    if (!isReady) {
+      if (serverOffers === void 0) {
+        setOffersState(LOADING_STATE2);
+      }
+      return () => {
+        isCancelled = true;
+      };
+    }
+    if (serverOffers !== void 0) {
+      return () => {
+        isCancelled = true;
+      };
+    }
+    setOffersState(LOADING_STATE2);
+    coinlist.fetchAllOffers().then((offers) => {
+      if (!isCancelled) {
+        setOffersState({ type: "CONTENT", offers });
+      }
+    }).catch((error) => {
+      if (!isCancelled) {
+        const reason = error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+        setOffersState({ type: "ERROR", reason });
+      }
+    });
+    return () => {
+      isCancelled = true;
+    };
+  }, [coinlist, isReady, serverOffers]);
+  return { offersState };
+}
+
+// src/client/hooks/useCoinListRequirements.ts
+var import_react5 = require("react");
+var LOADING_STATE3 = { type: "LOADING" };
+function useCoinListRequirements(offerId, options = {}) {
+  const { coinlist, isReady } = useCoinList();
+  const { serverData } = options;
+  const [requirementsState, setRequirementsState] = (0, import_react5.useState)(
+    serverData !== void 0 ? { type: "CONTENT", ...serverData } : LOADING_STATE3
+  );
+  const [fetchKey, setFetchKey] = (0, import_react5.useState)(0);
+  const refetch = (0, import_react5.useCallback)(() => setFetchKey((k) => k + 1), []);
+  (0, import_react5.useEffect)(() => {
+    let isCancelled = false;
+    if (!isReady) {
+      if (serverData === void 0) {
+        setRequirementsState(LOADING_STATE3);
+      }
+      return () => {
+        isCancelled = true;
+      };
+    }
+    if (serverData !== void 0 && fetchKey === 0) {
+      return () => {
+        isCancelled = true;
+      };
+    }
+    setRequirementsState(LOADING_STATE3);
+    Promise.all([
+      coinlist.fetchOfferRequirements(offerId),
+      coinlist.fetchRequirementStatuses(offerId)
+    ]).then(([requirementsByOptionId, statuses]) => {
+      if (!isCancelled) {
+        setRequirementsState({
+          type: "CONTENT",
+          requirementsByOptionId,
+          statuses
+        });
+      }
+    }).catch((error) => {
+      if (!isCancelled) {
+        const reason = error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+        setRequirementsState({ type: "ERROR", reason });
+      }
+    });
+    return () => {
+      isCancelled = true;
+    };
+  }, [coinlist, isReady, offerId, fetchKey]);
+  return { requirementsState, refetch };
+}
+
+// src/client/hooks/useCompleteCoinListOAuth.ts
+var import_react6 = require("react");
 function useCompleteCoinListOAuth(options) {
   const { coinlist } = useCoinList();
-  const postOAuthCompleteRef = (0, import_react3.useRef)(options.postOAuthComplete);
-  const onFailureRef = (0, import_react3.useRef)(options.onFailure);
-  const onSuccessRef = (0, import_react3.useRef)(options.onSuccess);
+  const postOAuthCompleteRef = (0, import_react6.useRef)(options.postOAuthComplete);
+  const onFailureRef = (0, import_react6.useRef)(options.onFailure);
+  const onSuccessRef = (0, import_react6.useRef)(options.onSuccess);
   postOAuthCompleteRef.current = options.postOAuthComplete;
   onFailureRef.current = options.onFailure;
   onSuccessRef.current = options.onSuccess;
-  const hasStartedExchangeRef = (0, import_react3.useRef)(false);
-  (0, import_react3.useEffect)(() => {
+  const hasStartedExchangeRef = (0, import_react6.useRef)(false);
+  (0, import_react6.useEffect)(() => {
     if (typeof window === "undefined") return;
     const params = new URLSearchParams(window.location.search);
     if (!params.has("code") && !params.has("error")) return;
@@ -946,6 +1274,48 @@ function useCompleteCoinListOAuth(options) {
   }, [coinlist]);
 }
 
+// src/client/hooks/useParticipations.ts
+var import_react7 = require("react");
+var LOADING_STATE4 = { type: "LOADING" };
+function useParticipations(offerId, options = {}) {
+  const { coinlist, isReady } = useCoinList();
+  const { serverData } = options;
+  const [participationsState, setParticipationsState] = (0, import_react7.useState)(
+    serverData !== void 0 ? { type: "CONTENT", participations: serverData } : LOADING_STATE4
+  );
+  (0, import_react7.useEffect)(() => {
+    let isCancelled = false;
+    if (!isReady) {
+      if (serverData === void 0) {
+        setParticipationsState(LOADING_STATE4);
+      }
+      return () => {
+        isCancelled = true;
+      };
+    }
+    if (serverData !== void 0) {
+      return () => {
+        isCancelled = true;
+      };
+    }
+    setParticipationsState(LOADING_STATE4);
+    coinlist.fetchAllParticipations(offerId).then((participations) => {
+      if (!isCancelled) {
+        setParticipationsState({ type: "CONTENT", participations });
+      }
+    }).catch((error) => {
+      if (!isCancelled) {
+        const reason = error instanceof NotAuthenticatedError ? "not-authenticated" : "generic-error";
+        setParticipationsState({ type: "ERROR", reason });
+      }
+    });
+    return () => {
+      isCancelled = true;
+    };
+  }, [coinlist, isReady, offerId, serverData]);
+  return { participationsState };
+}
+
 // src/shared/types/oauth-session.ts
 var OAuthRefreshToken = (value) => value;
 var OAuthSession = {
@@ -974,6 +1344,7 @@ var User = {
 0 && (module.exports = {
   AuthorizationCode,
   Blockchain,
+  ChecklistStatus,
   ClientId,
   ClientSecret,
   CodeChallenge,
@@ -997,7 +1368,13 @@ var User = {
   PaginationParams,
   Participation,
   ParticipationId,
+  ParticipationsPaginationParams,
   RedirectUri,
+  Requirement,
+  RequirementId,
+  RequirementStatus,
+  RequirementStatusInfo,
+  RequirementVariant,
   TermItem,
   User,
   UserEmail,
@@ -1006,6 +1383,10 @@ var User = {
   createCoinListClient,
   fetchAllPages,
   useCoinList,
-  useCompleteCoinListOAuth
+  useCoinListOfferDetails,
+  useCoinListOffers,
+  useCoinListRequirements,
+  useCompleteCoinListOAuth,
+  useParticipations
 });
 //# sourceMappingURL=index.cjs.map