kryptoexpress-sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,653 @@
+// src/core/config.ts
+var DEFAULT_RETRY_STATUS_CODES = [408, 409, 429, 500, 502, 503, 504];
+function resolveClientOptions(options = {}) {
+  const normalizedBaseUrl = (options.baseUrl ?? "https://kryptoexpress.pro/api").replace(/\/+$/, "");
+  return {
+    apiKey: options.apiKey,
+    baseUrl: normalizedBaseUrl,
+    timeoutMs: options.timeoutMs ?? 1e4,
+    retry: {
+      maxRetries: options.retry?.maxRetries ?? 2,
+      retryStatusCodes: options.retry?.retryStatusCodes ?? DEFAULT_RETRY_STATUS_CODES
+    },
+    fetch: options.fetch ?? globalThis.fetch,
+    fiatConverter: options.fiatConverter
+  };
+}
+
+// src/domain/errors.ts
+var SDKError = class extends Error {
+  cause;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = new.target.name;
+    this.cause = options.cause;
+  }
+};
+var ValidationError = class extends SDKError {
+  details;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.details = options.details;
+  }
+};
+var UnsupportedPaymentModeError = class extends ValidationError {
+};
+var MinimumAmountError = class extends ValidationError {
+  minimumUsdAmount;
+  constructor(message, minimumUsdAmount = 1, options = {}) {
+    super(message, options);
+    this.minimumUsdAmount = minimumUsdAmount;
+  }
+};
+var CurrencyConversionError = class extends ValidationError {
+};
+var APIError = class extends SDKError {
+  statusCode;
+  code;
+  details;
+  constructor(message, statusCode, options = {}) {
+    super(message, options);
+    this.statusCode = statusCode;
+    this.code = options.code;
+    this.details = options.details;
+  }
+};
+var AuthError = class extends APIError {
+};
+var RateLimitError = class extends APIError {
+};
+var NotFoundError = class extends APIError {
+};
+
+// src/core/http.ts
+var HttpClient = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async request(request) {
+    const url = buildUrl(this.options.baseUrl, request.path, request.query);
+    for (let attempt = 0; ; attempt += 1) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs);
+      try {
+        const requestInit = {
+          method: request.method ?? "GET",
+          headers: this.buildHeaders(request.requiresAuth ?? false, request.body !== void 0),
+          signal: controller.signal
+        };
+        if (request.body !== void 0) {
+          requestInit.body = JSON.stringify(request.body);
+        }
+        const response = await this.options.fetch(url, requestInit);
+        clearTimeout(timeout);
+        if (!response.ok) {
+          if (attempt < this.options.retry.maxRetries && this.options.retry.retryStatusCodes.includes(response.status)) {
+            continue;
+          }
+          throw await toApiError(response);
+        }
+        if (response.status === 204) {
+          return void 0;
+        }
+        return await response.json();
+      } catch (error) {
+        clearTimeout(timeout);
+        if (!(error instanceof APIError) && attempt < this.options.retry.maxRetries) {
+          continue;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new SDKError(`Request timed out after ${this.options.timeoutMs}ms.`, { cause: error });
+        }
+        if (error instanceof SDKError) {
+          throw error;
+        }
+        throw new SDKError("Unexpected HTTP client error.", { cause: error });
+      }
+    }
+  }
+  buildHeaders(requiresAuth, hasJsonBody) {
+    const headers = new Headers();
+    headers.set("Accept", "application/json");
+    if (hasJsonBody) {
+      headers.set("Content-Type", "application/json");
+    }
+    if (requiresAuth) {
+      if (!this.options.apiKey) {
+        throw new AuthError("This endpoint requires an API key.", 401);
+      }
+      headers.set("X-Api-Key", this.options.apiKey);
+    }
+    return headers;
+  }
+};
+function buildUrl(baseUrl, path, query = {}) {
+  const url = new URL(`${baseUrl}${path}`);
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0) {
+      continue;
+    }
+    url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+async function toApiError(response) {
+  const bodyText = await response.text();
+  let payload;
+  try {
+    payload = bodyText ? JSON.parse(bodyText) : void 0;
+  } catch {
+    payload = void 0;
+  }
+  const message = typeof payload?.message === "string" && payload.message || typeof payload?.error === "string" && payload.error || `Request failed with status ${response.status}.`;
+  const code = typeof payload?.code === "string" ? payload.code : void 0;
+  const options = code === void 0 ? { details: payload ?? bodyText } : { code, details: payload ?? bodyText };
+  if (response.status === 401 || response.status === 403) {
+    return new AuthError(message, response.status, options);
+  }
+  if (response.status === 404) {
+    return new NotFoundError(message, response.status, options);
+  }
+  if (response.status === 429) {
+    return new RateLimitError(message, response.status, options);
+  }
+  return new APIError(message, response.status, options);
+}
+
+// src/domain/enums.ts
+var FIAT_CURRENCIES = [
+  "USD",
+  "EUR",
+  "GBP",
+  "JPY",
+  "CHF",
+  "AUD",
+  "CAD",
+  "CNY",
+  "HKD",
+  "SGD",
+  "SEK",
+  "NOK",
+  "DKK",
+  "PLN",
+  "CZK",
+  "HUF",
+  "TRY",
+  "INR",
+  "KRW",
+  "THB",
+  "IDR",
+  "MYR",
+  "PHP",
+  "VND",
+  "AED",
+  "SAR",
+  "ZAR",
+  "NGN",
+  "KES",
+  "GHS",
+  "BRL",
+  "MXN",
+  "ARS",
+  "CLP",
+  "COP",
+  "PEN",
+  "RUB",
+  "UAH",
+  "ILS",
+  "PKR",
+  "BDT",
+  "LKR",
+  "TWD",
+  "BHD",
+  "KWD",
+  "RON",
+  "NZD"
+];
+var NATIVE_CRYPTO_CURRENCIES = ["BTC", "LTC", "ETH", "SOL", "BNB", "DOGE"];
+var STABLE_CRYPTO_CURRENCIES = [
+  "USDC_ERC20",
+  "USDT_ERC20",
+  "USDT_BEP20",
+  "USDC_BEP20",
+  "USDT_SOL",
+  "USDC_SOL"
+];
+var ALL_CRYPTO_CURRENCIES = [
+  ...NATIVE_CRYPTO_CURRENCIES,
+  ...STABLE_CRYPTO_CURRENCIES
+];
+var PAYMENT_TYPES = ["PAYMENT", "DEPOSIT"];
+var WITHDRAW_TYPES = ["ALL", "SINGLE"];
+var stableCurrencySet = new Set(STABLE_CRYPTO_CURRENCIES);
+function isStableCryptoCurrency(value) {
+  return stableCurrencySet.has(value);
+}
+
+// src/domain/conversion.ts
+var StaticRateFiatConverter = class {
+  rates = /* @__PURE__ */ new Map();
+  constructor(quotes) {
+    for (const quote of quotes) {
+      this.rates.set(`${quote.from}:${quote.to}`, quote.rate);
+    }
+  }
+  convert(amount, from, to) {
+    if (from === to) {
+      return Promise.resolve(amount);
+    }
+    const direct = this.rates.get(`${from}:${to}`);
+    if (direct !== void 0) {
+      return Promise.resolve(amount * direct);
+    }
+    const inverse = this.rates.get(`${to}:${from}`);
+    if (inverse !== void 0 && inverse !== 0) {
+      return Promise.resolve(amount / inverse);
+    }
+    throw new CurrencyConversionError(`No fiat conversion rate available for ${from} -> ${to}.`);
+  }
+};
+var MinimumAmountPolicy = class {
+  converter;
+  minimumUsdAmount;
+  constructor(options = {}) {
+    this.converter = options.converter;
+    this.minimumUsdAmount = options.minimumUsdAmount ?? 1;
+  }
+  async assertFiatAmountEligible(amount, fiatCurrency) {
+    if (amount <= 0) {
+      throw new MinimumAmountError("Payment amount must be greater than zero.", this.minimumUsdAmount);
+    }
+    if (fiatCurrency !== "USD") {
+      return;
+    }
+    const amountInUsd = amount;
+    if (amountInUsd < this.minimumUsdAmount) {
+      throw new MinimumAmountError(
+        `Payment amount must be at least the fiat equivalent of ${this.minimumUsdAmount} USD.`,
+        this.minimumUsdAmount,
+        { details: { amount, fiatCurrency, amountInUsd } }
+      );
+    }
+  }
+};
+function assertPaymentModeSupported(paymentType, cryptoCurrency) {
+  if (paymentType === "DEPOSIT" && isStableCryptoCurrency(cryptoCurrency)) {
+    throw new UnsupportedPaymentModeError(
+      `Stablecoin ${cryptoCurrency} is not supported for DEPOSIT payments.`
+    );
+  }
+}
+
+// src/core/validation.ts
+function assertObject(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ValidationError(`${label} must be an object.`, { details: value });
+  }
+  return value;
+}
+function assertString(value, label) {
+  if (typeof value !== "string") {
+    throw new ValidationError(`${label} must be a string.`, { details: value });
+  }
+  return value;
+}
+function assertNumberOrNull(value, label) {
+  if (value === null) {
+    return null;
+  }
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new ValidationError(`${label} must be a number or null.`, { details: value });
+  }
+  return value;
+}
+function assertNumber(value, label) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new ValidationError(`${label} must be a number.`, { details: value });
+  }
+  return value;
+}
+function assertBoolean(value, label) {
+  if (typeof value !== "boolean") {
+    throw new ValidationError(`${label} must be a boolean.`, { details: value });
+  }
+  return value;
+}
+function parsePaymentRecord(value) {
+  const record = assertObject(value, "payment");
+  const paymentType = assertString(record.paymentType, "payment.paymentType");
+  if (!PAYMENT_TYPES.includes(paymentType)) {
+    throw new ValidationError("payment.paymentType is invalid.", { details: paymentType });
+  }
+  return {
+    id: assertNumber(record.id, "payment.id"),
+    paymentType,
+    fiatCurrency: assertString(record.fiatCurrency, "payment.fiatCurrency"),
+    fiatAmount: assertNumberOrNull(record.fiatAmount, "payment.fiatAmount"),
+    cryptoAmount: assertNumberOrNull(record.cryptoAmount, "payment.cryptoAmount"),
+    cryptoCurrency: assertString(
+      record.cryptoCurrency,
+      "payment.cryptoCurrency"
+    ),
+    expireDatetime: assertNumber(record.expireDatetime, "payment.expireDatetime"),
+    createDatetime: assertNumber(record.createDatetime, "payment.createDatetime"),
+    paidAt: assertNumberOrNull(record.paidAt, "payment.paidAt"),
+    address: assertString(record.address, "payment.address"),
+    isPaid: assertBoolean(record.isPaid, "payment.isPaid"),
+    isWithdrawn: assertBoolean(record.isWithdrawn, "payment.isWithdrawn"),
+    hash: assertString(record.hash, "payment.hash"),
+    callbackUrl: record.callbackUrl === null ? null : assertString(record.callbackUrl, "payment.callbackUrl")
+  };
+}
+function parseWalletBalances(value) {
+  const record = assertObject(value, "wallet");
+  const result = {};
+  for (const [currency, amount] of Object.entries(record)) {
+    result[currency] = assertNumber(amount, `wallet.${currency}`);
+  }
+  return result;
+}
+function parseWithdrawalResponse(value) {
+  const record = assertObject(value, "withdrawal");
+  const withdrawType = assertString(record.withdrawType, "withdrawal.withdrawType");
+  if (!WITHDRAW_TYPES.includes(withdrawType)) {
+    throw new ValidationError("withdrawal.withdrawType is invalid.", { details: withdrawType });
+  }
+  const txIdList = record.txIdList;
+  if (!Array.isArray(txIdList) || txIdList.some((item) => typeof item !== "string")) {
+    throw new ValidationError("withdrawal.txIdList must be a string array.", { details: txIdList });
+  }
+  return {
+    id: assertNumber(record.id, "withdrawal.id"),
+    withdrawType,
+    paymentId: record.paymentId === null ? null : assertNumber(record.paymentId, "withdrawal.paymentId"),
+    cryptoCurrency: assertString(
+      record.cryptoCurrency,
+      "withdrawal.cryptoCurrency"
+    ),
+    toAddress: assertString(record.toAddress, "withdrawal.toAddress"),
+    txIdList,
+    receivingAmount: assertNumber(record.receivingAmount, "withdrawal.receivingAmount"),
+    blockchainFeeAmount: assertNumber(
+      record.blockchainFeeAmount,
+      "withdrawal.blockchainFeeAmount"
+    ),
+    serviceFeeAmount: assertNumber(record.serviceFeeAmount, "withdrawal.serviceFeeAmount"),
+    onlyCalculate: assertBoolean(record.onlyCalculate, "withdrawal.onlyCalculate"),
+    totalWithdrawalAmount: assertNumber(
+      record.totalWithdrawalAmount,
+      "withdrawal.totalWithdrawalAmount"
+    ),
+    createDatetime: assertNumber(record.createDatetime, "withdrawal.createDatetime")
+  };
+}
+function parseStringArray(value, label) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new ValidationError(`${label} must be a string array.`, { details: value });
+  }
+  return value;
+}
+function parseCryptoPrices(value) {
+  if (!Array.isArray(value)) {
+    throw new ValidationError("prices must be an array.", { details: value });
+  }
+  const items = value;
+  return items.map((item, index) => {
+    const record = assertObject(item, `prices[${index}]`);
+    return {
+      cryptoCurrency: assertString(record.cryptoCurrency, `prices[${index}].cryptoCurrency`),
+      fiatCurrency: assertString(record.fiatCurrency, `prices[${index}].fiatCurrency`),
+      price: assertNumber(record.price, `prices[${index}].price`)
+    };
+  });
+}
+
+// src/resources/currencies.ts
+var CurrenciesResource = class {
+  httpClient;
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async listNative() {
+    const response = await this.httpClient.request({
+      path: "/cryptocurrency"
+    });
+    return parseStringArray(response, "cryptocurrency");
+  }
+  async listAll() {
+    const response = await this.httpClient.request({
+      path: "/cryptocurrency/all"
+    });
+    return parseStringArray(response, "cryptocurrency/all");
+  }
+  async listStable() {
+    const response = await this.httpClient.request({
+      path: "/cryptocurrency/stable"
+    });
+    return parseStringArray(response, "cryptocurrency/stable");
+  }
+  async getPrices(input) {
+    if (input.cryptoCurrency.length === 0) {
+      throw new ValidationError("At least one cryptoCurrency is required.", { details: input });
+    }
+    const response = await this.httpClient.request({
+      path: "/cryptocurrency/price",
+      query: {
+        cryptoCurrency: input.cryptoCurrency.join(","),
+        fiatCurrency: input.fiatCurrency
+      }
+    });
+    return parseCryptoPrices(response);
+  }
+};
+
+// src/resources/fiat.ts
+var FiatResource = class {
+  httpClient;
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async list() {
+    const response = await this.httpClient.request({
+      path: "/currency"
+    });
+    return parseStringArray(response, "currency");
+  }
+};
+
+// src/resources/payments.ts
+var PaymentsResource = class {
+  httpClient;
+  minimumAmountPolicy;
+  constructor(httpClient, minimumAmountPolicy) {
+    this.httpClient = httpClient;
+    this.minimumAmountPolicy = minimumAmountPolicy;
+  }
+  async create(input) {
+    if (input.paymentType === "PAYMENT") {
+      return this.createPayment(input);
+    }
+    return this.createDeposit(input);
+  }
+  async createPayment(input) {
+    const request = {
+      ...input,
+      paymentType: "PAYMENT"
+    };
+    if (request.fiatAmount <= 0) {
+      throw new ValidationError("fiatAmount must be greater than zero.", { details: request });
+    }
+    assertPaymentModeSupported(request.paymentType, request.cryptoCurrency);
+    await this.minimumAmountPolicy.assertFiatAmountEligible(request.fiatAmount, request.fiatCurrency);
+    const response = await this.httpClient.request({
+      path: "/payment",
+      method: "POST",
+      body: request,
+      requiresAuth: true
+    });
+    return parsePaymentRecord(response);
+  }
+  async createDeposit(input) {
+    const request = {
+      ...input,
+      paymentType: "DEPOSIT"
+    };
+    if (isStableCryptoCurrency(request.cryptoCurrency)) {
+      throw new UnsupportedPaymentModeError(
+        `Stablecoin ${request.cryptoCurrency} supports only PAYMENT, not DEPOSIT.`,
+        { details: request }
+      );
+    }
+    const response = await this.httpClient.request({
+      path: "/payment",
+      method: "POST",
+      body: request,
+      requiresAuth: true
+    });
+    return parsePaymentRecord(response);
+  }
+  async getByHash(hash) {
+    if (!hash) {
+      throw new ValidationError("hash is required.");
+    }
+    const response = await this.httpClient.request({
+      path: "/payment",
+      query: { hash },
+      requiresAuth: false
+    });
+    return parsePaymentRecord(response);
+  }
+};
+
+// src/resources/wallet.ts
+var WalletResource = class {
+  httpClient;
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async get() {
+    const response = await this.httpClient.request({
+      path: "/wallet",
+      requiresAuth: true
+    });
+    return parseWalletBalances(response);
+  }
+  async withdraw(input) {
+    this.assertWithdrawalInput(input);
+    const response = await this.httpClient.request({
+      path: "/wallet/withdrawal",
+      method: "POST",
+      body: input,
+      requiresAuth: true
+    });
+    return parseWithdrawalResponse(response);
+  }
+  async calculate(input) {
+    return this.withdraw({
+      ...input,
+      onlyCalculate: true
+    });
+  }
+  async withdrawAll(input) {
+    return this.withdraw({
+      ...input,
+      withdrawType: "ALL",
+      onlyCalculate: false
+    });
+  }
+  async withdrawSingle(input) {
+    return this.withdraw({
+      ...input,
+      withdrawType: "SINGLE",
+      onlyCalculate: false
+    });
+  }
+  async calculateAll(input) {
+    return this.calculate({
+      ...input,
+      withdrawType: "ALL"
+    });
+  }
+  async calculateSingle(input) {
+    return this.calculate({
+      ...input,
+      withdrawType: "SINGLE"
+    });
+  }
+  assertWithdrawalInput(input) {
+    if (!input.toAddress) {
+      throw new ValidationError("toAddress is required.", { details: input });
+    }
+    if (input.withdrawType === "SINGLE" && typeof input.paymentId !== "number") {
+      throw new ValidationError("paymentId is required for SINGLE withdrawals.", {
+        details: input
+      });
+    }
+  }
+};
+
+// src/client.ts
+var KryptoExpressClient = class {
+  payments;
+  wallet;
+  currencies;
+  fiat;
+  constructor(options = {}) {
+    const resolved = resolveClientOptions(options);
+    const httpClient = new HttpClient(resolved);
+    const minimumAmountPolicy = resolved.fiatConverter ? new MinimumAmountPolicy({ converter: resolved.fiatConverter }) : new MinimumAmountPolicy();
+    this.payments = new PaymentsResource(httpClient, minimumAmountPolicy);
+    this.wallet = new WalletResource(httpClient);
+    this.currencies = new CurrenciesResource(httpClient);
+    this.fiat = new FiatResource(httpClient);
+  }
+};
+
+// src/webhooks/signature.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function compactJson(rawBody) {
+  return JSON.stringify(JSON.parse(rawBody));
+}
+function computeCallbackSignature(rawBody, callbackSecret) {
+  const compactBody = compactJson(rawBody);
+  return createHmac("sha512", callbackSecret).update(compactBody).digest("hex");
+}
+function verifyCallbackSignature(input) {
+  if (!input.signature) {
+    return false;
+  }
+  const expectedSignature = computeCallbackSignature(input.rawBody, input.callbackSecret);
+  const actual = Buffer.from(input.signature, "hex");
+  const expected = Buffer.from(expectedSignature, "hex");
+  if (actual.length !== expected.length) {
+    return false;
+  }
+  return timingSafeEqual(actual, expected);
+}
+export {
+  ALL_CRYPTO_CURRENCIES,
+  APIError,
+  AuthError,
+  CurrencyConversionError,
+  FIAT_CURRENCIES,
+  KryptoExpressClient,
+  MinimumAmountError,
+  MinimumAmountPolicy,
+  NATIVE_CRYPTO_CURRENCIES,
+  NotFoundError,
+  PAYMENT_TYPES,
+  RateLimitError,
+  SDKError,
+  STABLE_CRYPTO_CURRENCIES,
+  StaticRateFiatConverter,
+  UnsupportedPaymentModeError,
+  ValidationError,
+  WITHDRAW_TYPES,
+  assertPaymentModeSupported,
+  compactJson,
+  computeCallbackSignature,
+  isStableCryptoCurrency,
+  verifyCallbackSignature
+};
+//# sourceMappingURL=index.js.map