@coinlist-co/react 0.6.0 → 0.9.0

package/dist/server/index.cjs

@@ -43,6 +43,9 @@ var userAgent = () => ({ userAgent: true });
 var idempotencyKey = () => ({
   idempotencyKey: true
 });
+var clientCredentials = (credentials) => ({
+  clientCredentials: credentials
+});
 var retryAttempt = (attempt) => ({
   retryAttempt: attempt
 });
@@ -54,6 +57,7 @@ var needUserAgent = (attrs) => attrs?.userAgent === true;
 var isIdempotent = (attrs) => attrs?.idempotencyKey === true;
 var getRetryAttempt = (attrs) => attrs?.retryAttempt ?? 0;
 var wasRenewAttempted = (attrs) => attrs?.renewAttempted === true;
+var getClientCredentials = (attrs) => attrs?.clientCredentials;
 var Attributes = {
   empty,
   concat,
@@ -67,7 +71,9 @@ var Attributes = {
   retryAttempt,
   getRetryAttempt,
   renewAttempted,
-  wasRenewAttempted
+  wasRenewAttempted,
+  clientCredentials,
+  getClientCredentials
 };
 
 // src/shared/api/http.ts
@@ -249,7 +255,13 @@ function attachSessionMiddleware(fetchAccessToken) {
     if (!Attributes.isProtected(request.attributes)) {
       return request;
     }
-    const accessToken = await fetchAccessToken(false);
+    let accessToken = await fetchAccessToken(false);
+    if (!accessToken) {
+      const clientCreds = Attributes.getClientCredentials(request.attributes);
+      if (clientCreds) {
+        accessToken = clientCreds;
+      }
+    }
     if (accessToken === null) {
       return request;
     }
@@ -407,6 +419,46 @@ var WritableSessionStoreRequiredError = class extends Error {
   }
 };
 
+// src/shared/types/document-submission.ts
+var DocumentSubmission = {
+  fromDto: (dto) => ({
+    status: dto.status,
+    formType: dto.form_type
+  })
+};
+
+// src/shared/api/frontline/documents.ts
+async function submitDocument(api, documentType, fields) {
+  const dto = await api.send({
+    method: "POST",
+    url: `/v1/documents/${documentType}/submission`,
+    body: fields,
+    attributes: Attributes.protected()
+  });
+  return DocumentSubmission.fromDto(dto);
+}
+
+// src/shared/types/kyc.ts
+var KycToken = {
+  fromDto: (dto) => ({
+    token: dto.token
+  })
+};
+
+// src/shared/api/frontline/kyc.ts
+async function createKycToken(api, levelName, reset) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/kyc-token",
+    body: {
+      ...levelName === void 0 ? {} : { level_name: levelName },
+      ...reset === void 0 ? {} : { reset }
+    },
+    attributes: Attributes.protected()
+  });
+  return KycToken.fromDto(dto);
+}
+
 // src/shared/api/pagination.ts
 var Cursor = (value) => value;
 async function fetchAllPages(fetchPage, baseParams) {
@@ -556,24 +608,30 @@ var Milestone = {
 };
 
 // src/shared/api/frontline/offers.ts
-async function fetchOffers(api) {
-  return fetchAllPages((params) => fetchOffersPage(api, params));
+async function fetchOffers(api, clientCreds) {
+  return fetchAllPages((params) => fetchOffersPage(api, params, clientCreds));
 }
-async function fetchOffersPage(api, params) {
+async function fetchOffersPage(api, params, clientCreds) {
   const queryParams = PaginationParams.toQueryParams(params);
   const pageDto = await api.send({
     method: "GET",
     url: "/v1/offers",
     queryParams,
-    attributes: Attributes.protected()
+    attributes: Attributes.concat(
+      Attributes.protected(),
+      Attributes.clientCredentials(clientCreds)
+    )
   });
   return PaginatedResponse.fromDto(pageDto, Offer.fromDto);
 }
-async function fetchOfferDetails(api, id) {
+async function fetchOfferDetails(api, id, clientCreds) {
   const dto = await api.send({
     method: "GET",
     url: `/v1/offers/${id}`,
-    attributes: Attributes.protected()
+    attributes: Attributes.concat(
+      Attributes.protected(),
+      Attributes.clientCredentials(clientCreds)
+    )
   });
   return OfferDetail.fromDto(dto);
 }
@@ -659,6 +717,44 @@ async function createParticipation(api, params) {
   return Participation.fromDto(dto);
 }
 
+// src/shared/types/pii.ts
+var Iso2CountryCode = (value) => value;
+var PiiJurisdiction = {
+  fromDto: (dto) => ({
+    iso2: Iso2CountryCode(dto.iso_2),
+    name: dto.name
+  })
+};
+var PiiAddress = {
+  fromDto: (dto) => ({
+    street: dto.street,
+    city: dto.city,
+    state: dto.state,
+    postalCode: dto.postal_code,
+    country: dto.country
+  })
+};
+var Pii = {
+  fromDto: (dto) => ({
+    kind: dto.kind,
+    fullLegalName: dto.full_legal_name,
+    dateOfBirth: dto.date_of_birth,
+    jurisdiction: dto.jurisdiction ? PiiJurisdiction.fromDto(dto.jurisdiction) : null,
+    taxId: dto.tax_id,
+    permanentAddress: PiiAddress.fromDto(dto.permanent_address)
+  })
+};
+
+// src/shared/api/frontline/pii.ts
+async function fetchPii(api) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/pii",
+    attributes: Attributes.protected()
+  });
+  return Pii.fromDto(dto);
+}
+
 // src/shared/types/requirement.ts
 var RequirementId = (value) => value;
 var Requirement = {
@@ -669,18 +765,26 @@ var Requirement = {
   })
 };
 var RequirementStatusInfo = {
-  fromStatusesDto: (dto) => Object.entries(dto.statuses).map(([id, status]) => ({
-    id: RequirementId(id),
-    status
-  }))
+  fromStatusesDto: (dto) => Object.entries(dto.statuses).map(
+    ([id, value]) => typeof value === "string" ? { id: RequirementId(id), status: value, action: null } : {
+      id: RequirementId(id),
+      status: value.status,
+      action: value.action ?? null,
+      kycLevel: value.kyc_level,
+      kycReset: value.kyc_reset
+    }
+  )
 };
 
 // src/shared/api/frontline/requirements.ts
-async function fetchOfferRequirements(api, offerId) {
+async function fetchOfferRequirements(api, offerId, clientCreds) {
   const response = await api.send({
     method: "GET",
     url: `/v1/offers/${offerId}/requirements`,
-    attributes: Attributes.protected()
+    attributes: Attributes.concat(
+      Attributes.protected(),
+      Attributes.clientCredentials(clientCreds)
+    )
   });
   return Object.fromEntries(
     Object.entries(response.options).map(([optionId, list]) => [
@@ -698,6 +802,327 @@ async function fetchRequirementStatuses(api, offerId) {
   return RequirementStatusInfo.fromStatusesDto(response);
 }
 
+// src/shared/types/blockchain/core.ts
+var EvmWalletAddress = (value) => value;
+var EvmContractAddress = (value) => value;
+var HexEncodedTransactionData = (value) => value;
+var AssetDecimals = (value) => value;
+var MAX_UINT_256 = 2n ** 256n - 1n;
+var assertUint256 = (value) => {
+  if (value < 0n || value > MAX_UINT_256) {
+    throw new Error(`Value out of uint256 bounds: ${value}`);
+  }
+  return value;
+};
+var BlockchainAmount = Object.assign(
+  (value) => value,
+  {
+    add: (a, b) => combineAmounts(a, b, (x, y) => x + y),
+    sub: (a, b) => combineAmounts(a, b, (x, y) => x - y)
+  }
+);
+function combineAmounts(a, b, op) {
+  if (a.decimals !== b.decimals) {
+    throw new Error(
+      `Cannot combine BlockchainAmounts with different decimals: ${a.decimals} vs ${b.decimals}`
+    );
+  }
+  const raw = op(a.raw, b.raw);
+  if (raw < 0n || raw > MAX_UINT_256) {
+    throw new Error(`BlockchainAmount out of uint256 bounds: ${raw}`);
+  }
+  return BlockchainAmount({ raw, decimals: a.decimals });
+}
+var AssetSymbol = (value) => value;
+
+// src/shared/types/offer-option-address.ts
+var OfferOptionAddressId = (value) => value;
+var OfferOptionAddress = {
+  /** Maps the API DTO into the SDK offer-option-address domain model. */
+  fromDto: (dto) => ({
+    id: OfferOptionAddressId(dto.id),
+    offerOptionId: OfferOptionId(dto.offer_option_id),
+    address: EvmWalletAddress(dto.address),
+    protocol: dto.protocol,
+    createdAt: new Date(dto.created_at)
+  })
+};
+var ConnectExternalWalletParams = {
+  /** Maps connect-wallet params into the API DTO payload. */
+  toDto: (params) => ({
+    offer_option_id: params.offerOptionId,
+    wallet_address: params.walletAddress,
+    chain: params.chain,
+    signature: params.signature
+  })
+};
+
+// src/shared/types/wallet-ownership-challenge.ts
+var WalletOwnershipChallenge = {
+  /** Maps the API DTO into the SDK wallet-ownership-challenge domain model. */
+  fromDto: (dto) => ({
+    message: dto.message,
+    expiresAt: new Date(dto.expires_at)
+  })
+};
+var CreateWalletOwnershipChallengeParams = {
+  /**
+   * Maps challenge-request params into the API DTO payload. The discriminated
+   * union guarantees SIWE fields are present exactly when `challengeType` is
+   * `siwe`, so the mapping narrows on the discriminant.
+   */
+  toDto: (params) => {
+    switch (params.challengeType) {
+      case "plain":
+        return {
+          wallet_address: params.walletAddress,
+          chain: params.chain,
+          challenge_type: "plain"
+        };
+      case "siwe":
+        return {
+          wallet_address: params.walletAddress,
+          chain: params.chain,
+          challenge_type: "siwe",
+          domain: params.domain,
+          uri: params.uri,
+          statement: params.statement
+        };
+      default: {
+        const _exhaustive = params;
+        return _exhaustive;
+      }
+    }
+  }
+};
+
+// src/shared/api/frontline/wallet-connect.ts
+async function createWalletOwnershipChallenge(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/wallet-ownership",
+    body: CreateWalletOwnershipChallengeParams.toDto(params),
+    attributes: Attributes.protected()
+  });
+  return WalletOwnershipChallenge.fromDto(dto);
+}
+async function connectExternalWallet(api, offerId, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: `/v1/offers/${offerId}/addresses`,
+    body: ConnectExternalWalletParams.toDto(params),
+    attributes: Attributes.protected()
+  });
+  return OfferOptionAddress.fromDto(dto);
+}
+async function listOptionAddresses(api, offerId, offerOptionId) {
+  const { data } = await api.send({
+    method: "GET",
+    url: `/v1/offers/${offerId}/addresses`,
+    queryParams: { offer_option_id: offerOptionId },
+    attributes: Attributes.protected()
+  });
+  return data.map(OfferOptionAddress.fromDto);
+}
+async function removeOptionAddress(api, offerId, addressId) {
+  const dto = await api.send({
+    method: "DELETE",
+    url: `/v1/offers/${offerId}/addresses/${addressId}`,
+    attributes: Attributes.protected()
+  });
+  return OfferOptionAddress.fromDto(dto);
+}
+
+// src/shared/types/swap.ts
+var SwapAuthorization = {
+  fromDto: (dto) => ({
+    authorized: dto.authorized
+  })
+};
+var SwapPreview = {
+  fromDto: (dto) => ({
+    inputAmount: assertUint256(BigInt(dto.pay_input_amount)),
+    fee: assertUint256(BigInt(dto.fee)),
+    outputAmount: assertUint256(BigInt(dto.receive_output_amount))
+  })
+};
+var SwapStatus = {
+  fromDto: (dto) => ({
+    stopped: assertUint256(BigInt(dto.stopped)),
+    swapLevel: assertUint256(BigInt(dto.swap_level))
+  })
+};
+var TokenAllowance = {
+  fromDto: (dto) => ({
+    allowance: assertUint256(BigInt(dto.allowance))
+  })
+};
+var TokenBalance = {
+  fromDto: (dto) => ({
+    balance: assertUint256(BigInt(dto.balance))
+  })
+};
+var AllowWalletResponse = {
+  fromDto: (dto) => {
+    switch (dto.action) {
+      case "broadcast_transaction":
+        return {
+          action: "broadcast_transaction",
+          to: EvmContractAddress(dto.to),
+          data: HexEncodedTransactionData(dto.data)
+        };
+      case "none":
+        return {
+          action: "none",
+          alreadyAllowed: dto.already_allowed
+        };
+      default: {
+        const _exhaustive = dto;
+        return _exhaustive;
+      }
+    }
+  }
+};
+
+// src/shared/api/frontline/swap.ts
+async function getSwapAuthorization(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/wallet/authorized",
+    queryParams: {
+      chain: params.chain,
+      contract_address: params.contractAddress,
+      wallet_address: params.walletAddress
+    },
+    attributes: Attributes.protected()
+  });
+  return SwapAuthorization.fromDto(dto);
+}
+async function getSwapOutputToken(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/swap/output-token",
+    queryParams: {
+      chain: params.chain,
+      contract_address: params.contractAddress
+    },
+    attributes: Attributes.protected()
+  });
+  return toErc20Asset(dto);
+}
+async function getSwapPreview(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/swap/preview",
+    queryParams: {
+      chain: params.chain,
+      contract_address: params.contractAddress,
+      input_token: params.inputToken,
+      amount: params.amount.toString()
+    },
+    attributes: Attributes.protected()
+  });
+  return SwapPreview.fromDto(dto);
+}
+async function getSwapStatus(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/swap/status",
+    queryParams: {
+      chain: params.chain,
+      contract_address: params.contractAddress
+    },
+    attributes: Attributes.protected()
+  });
+  return SwapStatus.fromDto(dto);
+}
+async function getTokenAllowance(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/token/allowance",
+    queryParams: {
+      chain: params.chain,
+      token_address: params.tokenAddress,
+      owner: params.owner,
+      spender: params.spender
+    },
+    attributes: Attributes.protected()
+  });
+  return TokenAllowance.fromDto(dto);
+}
+async function getTokenBalance(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/token/balance",
+    queryParams: {
+      chain: params.chain,
+      token_address: params.tokenAddress,
+      owner: params.owner
+    },
+    attributes: Attributes.protected()
+  });
+  return TokenBalance.fromDto(dto);
+}
+async function allowWallet(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: `/v1/offers/${encodeURIComponent(params.offerId)}/allow-wallet`,
+    body: {
+      wallet_address: params.walletAddress,
+      chain: params.chain,
+      signature: params.signature
+    },
+    attributes: Attributes.protected()
+  });
+  return AllowWalletResponse.fromDto(dto);
+}
+function toErc20Asset(dto) {
+  return {
+    name: dto.name,
+    symbol: AssetSymbol(dto.symbol),
+    decimals: AssetDecimals(dto.decimals)
+  };
+}
+
+// src/shared/core/swap-namespace.ts
+var SwapNamespaceImpl = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async getAuthorization(params) {
+    await this.ctx.ensureUserAuthenticated();
+    return getSwapAuthorization(this.ctx.api, params);
+  }
+  async getPreview(params) {
+    await this.ctx.ensureUserAuthenticated();
+    return getSwapPreview(this.ctx.api, params);
+  }
+  async getStatus(params) {
+    await this.ctx.ensureUserAuthenticated();
+    return getSwapStatus(this.ctx.api, params);
+  }
+  async getTokenAllowance(params) {
+    await this.ctx.ensureUserAuthenticated();
+    return getTokenAllowance(this.ctx.api, params);
+  }
+  async getTokenBalance(params) {
+    await this.ctx.ensureUserAuthenticated();
+    return getTokenBalance(this.ctx.api, params);
+  }
+  async getOutputToken(params) {
+    await this.ctx.ensureUserAuthenticated();
+    return getSwapOutputToken(this.ctx.api, params);
+  }
+  async requestWalletOwnershipChallenge(params) {
+    await this.ctx.ensureUserAuthenticated();
+    return createWalletOwnershipChallenge(this.ctx.api, params);
+  }
+  async allowWallet(params) {
+    await this.ctx.ensureUserAuthenticated();
+    return allowWallet(this.ctx.api, params);
+  }
+};
+
 // src/shared/types/errors.ts
 var NotAuthenticatedError = class extends Error {
   constructor(message = "The user is not authenticated. Go through the OAuth flow first!") {
@@ -707,6 +1132,7 @@ var NotAuthenticatedError = class extends Error {
 };
 
 // src/shared/types/oauth-session.ts
+var ClientCredentialsOAuth = (value) => value;
 var OAuthRefreshToken = (value) => value;
 var OAuthSession = {
   fromDto: (dto) => {
@@ -740,6 +1166,10 @@ var CoinListServerImpl = class {
       // than re-sending with the same expired token and wasting a round-trip.
       (refresh) => refresh && !this._config.sessionStore.setSession ? Promise.resolve(null) : this.accessToken()
     );
+    this.swap = new SwapNamespaceImpl({
+      api: this.api,
+      ensureUserAuthenticated: () => this.ensureUserAuthenticated()
+    });
   }
   async completeOAuth(code, codeVerifier) {
     const sessionStore = this._config.sessionStore;
@@ -763,6 +1193,19 @@ var CoinListServerImpl = class {
     await setSession(session);
     return session;
   }
+  async clientCredentialsOAuth() {
+    const sessionDto = await this.api.send({
+      method: "POST",
+      url: `/oauth/token`,
+      body: {
+        grant_type: "client_credentials",
+        client_id: this._config.clientId,
+        client_secret: this._config.clientSecret
+      }
+    });
+    const session = OAuthSession.fromDto(sessionDto);
+    return ClientCredentialsOAuth(session.accessToken);
+  }
   async accessToken() {
     const sessionStore = this._config.sessionStore;
     const session = await sessionStore.getSession();
@@ -835,48 +1278,89 @@ var CoinListServerImpl = class {
       await setSession(null);
     }
   }
-  async ensureAuthenticated() {
-    const token = await this.accessToken();
-    if (token === null) {
-      throw new NotAuthenticatedError();
-    }
-  }
-  async fetchOffers() {
-    await this.ensureAuthenticated();
-    return fetchOffers(this.api);
+  async fetchOffers(clientCreds) {
+    await this.ensureAuthenticated(clientCreds);
+    return fetchOffers(this.api, clientCreds);
   }
-  async fetchOffersPage(params) {
-    await this.ensureAuthenticated();
-    return fetchOffersPage(this.api, params);
+  async fetchOffersPage(params, clientCreds) {
+    await this.ensureAuthenticated(clientCreds);
+    return fetchOffersPage(this.api, params, clientCreds);
   }
-  async fetchOfferDetails(id) {
-    await this.ensureAuthenticated();
-    return fetchOfferDetails(this.api, id);
+  async fetchOfferDetails(id, clientCreds) {
+    await this.ensureAuthenticated(clientCreds);
+    return fetchOfferDetails(this.api, id, clientCreds);
   }
   async fetchParticipations(offerId) {
-    await this.ensureAuthenticated();
+    await this.ensureUserAuthenticated();
     return fetchParticipations(this.api, offerId);
   }
   async fetchParticipationsPage(params) {
-    await this.ensureAuthenticated();
+    await this.ensureUserAuthenticated();
     return fetchParticipationsPage(this.api, params);
   }
   async fetchParticipation(id) {
-    await this.ensureAuthenticated();
+    await this.ensureUserAuthenticated();
     return fetchParticipation(this.api, id);
   }
   async createParticipation(params) {
-    await this.ensureAuthenticated();
+    await this.ensureUserAuthenticated();
     return createParticipation(this.api, params);
   }
-  async fetchOfferRequirements(offerId) {
-    await this.ensureAuthenticated();
-    return fetchOfferRequirements(this.api, offerId);
+  async createWalletOwnershipChallenge(params) {
+    await this.ensureUserAuthenticated();
+    return createWalletOwnershipChallenge(this.api, params);
+  }
+  async connectExternalWallet(offerId, params) {
+    await this.ensureUserAuthenticated();
+    return connectExternalWallet(this.api, offerId, params);
+  }
+  async listOptionAddresses(offerId, offerOptionId) {
+    await this.ensureUserAuthenticated();
+    return listOptionAddresses(
+      this.api,
+      offerId,
+      offerOptionId
+    );
+  }
+  async removeOptionAddress(offerId, addressId) {
+    await this.ensureUserAuthenticated();
+    return removeOptionAddress(this.api, offerId, addressId);
+  }
+  async fetchOfferRequirements(offerId, clientCreds) {
+    await this.ensureAuthenticated(clientCreds);
+    return fetchOfferRequirements(
+      this.api,
+      offerId,
+      clientCreds
+    );
   }
   async fetchRequirementStatuses(offerId) {
-    await this.ensureAuthenticated();
+    await this.ensureUserAuthenticated();
     return fetchRequirementStatuses(this.api, offerId);
   }
+  async ensureAuthenticated(clientCreds) {
+    if (!clientCreds) {
+      await this.ensureUserAuthenticated();
+    }
+  }
+  async ensureUserAuthenticated() {
+    const token = await this.accessToken();
+    if (token === null) {
+      throw new NotAuthenticatedError();
+    }
+  }
+  async fetchPii() {
+    await this.ensureUserAuthenticated();
+    return fetchPii(this.api);
+  }
+  async submitDocument(documentType, fields) {
+    await this.ensureUserAuthenticated();
+    return submitDocument(this.api, documentType, fields);
+  }
+  async createKycToken(levelName, reset) {
+    await this.ensureUserAuthenticated();
+    return createKycToken(this.api, levelName, reset);
+  }
 };
 function createCoinListServer(config) {
   return new CoinListServerImpl(config);