@coinlist-co/react 0.3.0 → 0.4.0

package/dist/server/index.cjs

@@ -21,14 +21,40 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var server_exports = {};
 __export(server_exports, {
   AuthorizationCode: () => AuthorizationCode,
+  Blockchain: () => Blockchain,
   ClientId: () => ClientId,
   ClientSecret: () => ClientSecret,
   CodeChallenge: () => CodeChallenge,
   CodeVerifier: () => CodeVerifier,
+  CreateParticipationParams: () => CreateParticipationParams,
+  Cursor: () => Cursor,
+  FaqItem: () => FaqItem,
+  Link: () => Link,
+  Milestone: () => Milestone,
+  NotAuthenticatedError: () => NotAuthenticatedError,
+  NotImplementedError: () => NotImplementedError,
   OAuthRefreshToken: () => OAuthRefreshToken,
   OAuthSession: () => OAuthSession,
+  Offer: () => Offer,
+  OfferDetail: () => OfferDetail,
+  OfferId: () => OfferId,
+  OfferOption: () => OfferOption,
+  OfferOptionId: () => OfferOptionId,
+  OfferOptionSlug: () => OfferOptionSlug,
+  OfferSlug: () => OfferSlug,
+  PaginatedResponse: () => PaginatedResponse,
+  PaginationParams: () => PaginationParams,
+  Participation: () => Participation,
+  ParticipationId: () => ParticipationId,
+  ParticipationsPaginationParams: () => ParticipationsPaginationParams,
   RedirectUri: () => RedirectUri,
-  createCoinListServer: () => createCoinListServer
+  Requirement: () => Requirement,
+  RequirementId: () => RequirementId,
+  RequirementStatusInfo: () => RequirementStatusInfo,
+  TermItem: () => TermItem,
+  WalletAddress: () => WalletAddress,
+  createCoinListServer: () => createCoinListServer,
+  fetchAllPages: () => fetchAllPages
 });
 module.exports = __toCommonJS(server_exports);
 
@@ -175,9 +201,10 @@ var Request = {
   concatAttributes
 };
 
-// src/shared/api/frontline.ts
+// src/shared/api/frontline/index.ts
 var PUBLIC_API_BASE_URL = "https://api.coinlist.co";
 var HEADER_API_VERSION = "X-API-Version";
+var HEADER_IDEMPOTENCY_KEY = "Idempotency-Key";
 var API_VERSION = "2025-10-17";
 
 // src/shared/api/http-client.ts
@@ -249,6 +276,67 @@ 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/utils.ts
+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/shared/api/middleware/idempotency-key.ts
+var idempotencyKeyMiddleware = async (request) => {
+  if (!Attributes.isIdempotent(request.attributes)) {
+    return request;
+  }
+  const existingHeaders = request.headers ?? {};
+  if (existingHeaders[HEADER_IDEMPOTENCY_KEY]) {
+    return request;
+  }
+  return {
+    ...request,
+    headers: {
+      ...existingHeaders,
+      [HEADER_IDEMPOTENCY_KEY]: getUUIDv4()
+    }
+  };
+};
+
 // src/shared/api/middleware/request-retry.ts
 var MAX_ATTEMPTS = 3;
 var INITIAL_DELAY_MS = 300;
@@ -284,13 +372,44 @@ function defaultDelay(ms) {
 }
 var requestRetryMiddleware = createRequestRetryMiddleware();
 
-// src/server/api/api.server.ts
-var Api = class {
-  constructor(config) {
-    this.config = config;
-    this.httpClient = new HttpClient(this.config, {
-      beforeRequest: [],
-      afterRequest: [requestRetryMiddleware]
+// 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(fetchAccessToken),
+        ...additionalBeforeRequest,
+        idempotencyKeyMiddleware
+      ],
+      afterRequest: [
+        renewSessionMiddleware(fetchAccessToken),
+        requestRetryMiddleware
+      ]
     });
   }
   async send(request) {
@@ -303,6 +422,321 @@ var Api = class {
   }
 };
 
+// src/server/api/api.server.ts
+var Api = class {
+  constructor(config, fetchAccessToken) {
+    this.client = new AuthenticatedApiClient(config, fetchAccessToken);
+  }
+  async send(request) {
+    return this.client.send(request);
+  }
+};
+
+// src/shared/api/pagination.ts
+var Cursor = (value) => value;
+async function fetchAllPages(fetchPage, baseParams) {
+  const items = [];
+  let cursor = null;
+  do {
+    const params = {
+      ...baseParams ?? {},
+      after: cursor ?? void 0
+    };
+    const page = await fetchPage(params);
+    items.push(...page.data);
+    cursor = page.startingAfter;
+  } while (cursor);
+  return items;
+}
+var PaginatedResponse = {
+  fromDto: (dto, itemMapper) => ({
+    data: dto.data.map(itemMapper),
+    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/shared/types/offer.ts
+var OfferId = (value) => value;
+var OfferSlug = (value) => value;
+var Offer = {
+  fromDto: (dto) => ({
+    id: OfferId(dto.id),
+    slug: OfferSlug(dto.slug),
+    tagline: notBlankStringOrNull(dto.tagline),
+    bannerUrl: notBlankStringOrNull(dto.banner_url),
+    logoUrl: notBlankStringOrNull(dto.logo_url),
+    startsAt: new Date(dto.starts_at),
+    endsAt: new Date(dto.ends_at)
+  })
+};
+
+// src/shared/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/shared/types/offer-detail.ts
+var OfferOptionId = (value) => value;
+var OfferOptionSlug = (value) => value;
+var OfferDetail = {
+  fromDto: (dto) => {
+    if (!Array.isArray(dto.funding_assets)) {
+      throw new Error(`funding_assets must be an array`);
+    }
+    if (!Array.isArray(dto.options)) {
+      throw new Error(`options must be an array`);
+    }
+    if (!Array.isArray(dto.terms)) {
+      throw new Error(`terms must be an array`);
+    }
+    if (!Array.isArray(dto.links)) {
+      throw new Error(`links must be an array`);
+    }
+    if (!Array.isArray(dto.faqs)) {
+      throw new Error(`faqs must be an array`);
+    }
+    if (!Array.isArray(dto.milestones)) {
+      throw new Error(`milestones must be an array`);
+    }
+    return {
+      id: OfferId(dto.id),
+      slug: OfferSlug(dto.slug),
+      name: dto.name,
+      asset: Asset.fromDto(dto.asset),
+      fundingAssets: dto.funding_assets.map(Asset.fromDto),
+      about: notBlankStringOrNull(dto.about),
+      tagline: notBlankStringOrNull(dto.tagline),
+      bannerUrl: notBlankStringOrNull(dto.banner_url),
+      logoUrl: notBlankStringOrNull(dto.logo_url),
+      category: notBlankStringOrNull(dto.category),
+      startsAt: new Date(dto.starts_at),
+      endsAt: new Date(dto.ends_at),
+      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)
+    };
+  }
+};
+var OfferOption = {
+  fromDto: (dto) => ({
+    id: OfferOptionId(dto.id),
+    slug: OfferOptionSlug(dto.slug),
+    bidIncrement: dto.bid_increment,
+    floorPriceUsd: dto.floor_price_usd,
+    minimumPurchaseUsd: dto.minimum_purchase_usd,
+    priceUsd: dto.price_usd,
+    saleAgreementUrl: notBlankStringOrNull(dto.sale_agreement_url),
+    totalTokenSupply: dto.total_token_supply
+  })
+};
+var FaqItem = {
+  fromDto: (dto) => ({
+    question: notBlankStringOrNull(dto.question),
+    answer: notBlankStringOrNull(dto.answer)
+  })
+};
+var Link = {
+  fromDto: (dto) => ({
+    label: notBlankStringOrNull(dto.label),
+    url: notBlankStringOrNull(dto.url)
+  })
+};
+var TermItem = {
+  fromDto: (dto) => ({
+    key: notBlankStringOrNull(dto.key),
+    value: notBlankStringOrNull(dto.value)
+  })
+};
+var Milestone = {
+  fromDto: (dto) => ({
+    name: notBlankStringOrNull(dto.name),
+    schedule: notBlankStringOrNull(dto.schedule),
+    status: dto.status
+  })
+};
+
+// 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) => {
+    const walletAddress = notBlankStringOrNull(dto.wallet_address);
+    return {
+      id: ParticipationId(dto.id),
+      offerId: OfferId(dto.offer_id),
+      offerOptionId: OfferOptionId(dto.offer_option_id),
+      status: dto.status,
+      amount: dto.amount,
+      displayAmount: dto.amount_string,
+      asset: Asset.fromDto(dto.asset),
+      chain: Blockchain(dto.chain),
+      insertedAt: dto.inserted_at ? new Date(dto.inserted_at) : null,
+      updatedAt: dto.updated_at ? new Date(dto.updated_at) : null,
+      walletAddress: walletAddress ? WalletAddress(walletAddress) : null
+    };
+  }
+};
+var CreateParticipationParams = {
+  /** Maps participation creation params into API DTO payload. */
+  toDto: (params) => ({
+    offer_id: params.offerId,
+    offer_option_id: params.offerOptionId,
+    chain: params.chain,
+    wallet_address: params.walletAddress,
+    amount: params.amount,
+    asset_id: params.assetId,
+    approval_transaction_hash: params.approvalTransactionHash
+  })
+};
+
+// 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 NotImplementedError = class extends Error {
+  constructor(message = "Not implemented yet") {
+    super(message);
+    this.name = "NotImplementedError";
+  }
+};
+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-session.ts
 var OAuthRefreshToken = (value) => value;
 var OAuthSession = {
@@ -326,10 +760,13 @@ var CoinListServerImpl = class {
     this.baseUrl = _config.baseUrl ?? PUBLIC_API_BASE_URL;
     this.accessTokenExpiryBufferSeconds = _config.accessTokenExpiryBufferSeconds ?? ACCESS_TOKEN_EXPIRY_BUFFER_SECONDS;
     this.strict = _config.strict ?? false;
-    this.api = new Api({
-      baseUrl: this.baseUrl,
-      xApiVersion: API_VERSION
-    });
+    this.api = new Api(
+      {
+        baseUrl: this.baseUrl,
+        xApiVersion: API_VERSION
+      },
+      (_refresh) => this.accessToken()
+    );
   }
   async completeOAuth(code, codeVerifier) {
     const sessionDto = await this.api.send({
@@ -407,6 +844,48 @@ var CoinListServerImpl = class {
       await this._config.sessionStore.setSession(null);
     }
   }
+  async ensureAuthenticated() {
+    const token = await this.accessToken();
+    if (token === null) {
+      throw new NotAuthenticatedError();
+    }
+  }
+  async fetchAllOffers() {
+    await this.ensureAuthenticated();
+    return fetchAllOffers(this.api);
+  }
+  async fetchOffersPage(params) {
+    await this.ensureAuthenticated();
+    return fetchOffersPage(this.api, params);
+  }
+  async fetchOfferDetails(id) {
+    await this.ensureAuthenticated();
+    return fetchOfferDetails(this.api, id);
+  }
+  async fetchAllParticipations(offerId) {
+    await this.ensureAuthenticated();
+    return fetchAllParticipations(this.api, offerId);
+  }
+  async fetchParticipationsPage(params) {
+    await this.ensureAuthenticated();
+    return fetchParticipationsPage(this.api, params);
+  }
+  async fetchParticipation(id) {
+    await this.ensureAuthenticated();
+    return fetchParticipation(this.api, id);
+  }
+  async createParticipation(params) {
+    await this.ensureAuthenticated();
+    return createParticipation(this.api, params);
+  }
+  async fetchOfferRequirements(offerId) {
+    await this.ensureAuthenticated();
+    return fetchOfferRequirements(this.api, offerId);
+  }
+  async fetchRequirementStatuses(offerId) {
+    await this.ensureAuthenticated();
+    return fetchRequirementStatuses(this.api, offerId);
+  }
 };
 function createCoinListServer(config) {
   return new CoinListServerImpl(config);
@@ -422,13 +901,39 @@ var ClientSecret = (value) => value;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthorizationCode,
+  Blockchain,
   ClientId,
   ClientSecret,
   CodeChallenge,
   CodeVerifier,
+  CreateParticipationParams,
+  Cursor,
+  FaqItem,
+  Link,
+  Milestone,
+  NotAuthenticatedError,
+  NotImplementedError,
   OAuthRefreshToken,
   OAuthSession,
+  Offer,
+  OfferDetail,
+  OfferId,
+  OfferOption,
+  OfferOptionId,
+  OfferOptionSlug,
+  OfferSlug,
+  PaginatedResponse,
+  PaginationParams,
+  Participation,
+  ParticipationId,
+  ParticipationsPaginationParams,
   RedirectUri,
-  createCoinListServer
+  Requirement,
+  RequirementId,
+  RequirementStatusInfo,
+  TermItem,
+  WalletAddress,
+  createCoinListServer,
+  fetchAllPages
 });
 //# sourceMappingURL=index.cjs.map