@payclave/sdk-server 0.1.0

package/dist/index.cjs

@@ -0,0 +1,814 @@
+'use strict';
+
+var buffer = require('buffer');
+var crypto = require('crypto');
+
+// src/index.ts
+var PAYCLAVE_WEBHOOK_EVENT_TYPES = [
+  "invoice.paid",
+  "invoice.expired",
+  "payment.failed",
+  "payment.underpaid",
+  "payment.overpaid"
+];
+var PAYCLAVE_API_ERROR_CODES = [
+  "API_KEY_FORBIDDEN",
+  "API_KEY_REQUIRED",
+  "AUTH_FORBIDDEN",
+  "AUTH_REQUIRED",
+  "DEFAULT_WALLET_REQUIRED",
+  "INTERNAL_JOB_UNAUTHORIZED",
+  "INTERNAL_SERVER_ERROR",
+  "INVALID_AMOUNT",
+  "INVALID_API_KEY",
+  "INVALID_EXPIRY",
+  "INVALID_IDEMPOTENCY_KEY",
+  "INVALID_DEPOSIT_NETWORK",
+  "INVALID_WALLET_PAYMENT_ATTEMPT",
+  "INVALID_TX_HASH",
+  "INVALID_WALLET_ADDRESS",
+  "NOT_FOUND",
+  "RATE_LIMIT_EXCEEDED",
+  "REQUEST_ERROR",
+  "SCAN_OR_COPY_UNAVAILABLE",
+  "WALLET_PAYMENTS_UNAVAILABLE",
+  "UNSUPPORTED_DEFAULT_WALLET",
+  "VALIDATION_ERROR",
+  "WEBHOOK_DELIVERY_NOT_FOUND",
+  "WEBHOOK_ENDPOINT_NOT_FOUND",
+  "WEBHOOK_EVENT_UNSUPPORTED",
+  "WEBHOOK_SIGNATURE_INVALID",
+  "CHECKOUT_SESSION_NOT_PAYABLE",
+  "INVOICE_NOT_FOUND",
+  "INVOICE_STATE_MISMATCH",
+  "INVOICE_TRANSITION_GUARD_FAILED",
+  "IDEMPOTENCY_KEY_CONFLICT"
+];
+var PAYCLAVE_SERVER_SDK_ERROR_CODES = [
+  "INVALID_SECRET_KEY",
+  "INVALID_API_BASE_URL",
+  "INVALID_TIMEOUT",
+  "INVALID_ID",
+  "INVALID_AMOUNT",
+  "INVALID_EXPIRY",
+  "INVALID_METADATA",
+  "INVALID_IDEMPOTENCY_KEY",
+  "INVALID_LIMIT",
+  "INVALID_WEBHOOK_URL",
+  "INVALID_REQUEST_BODY",
+  "INVALID_RESPONSE",
+  "NETWORK_ERROR",
+  "TIMEOUT",
+  "ABORTED"
+];
+var PAYCLAVE_WEBHOOK_VERIFICATION_ERROR_CODES = [
+  "WEBHOOK_SIGNATURE_INVALID",
+  "WEBHOOK_TIMESTAMP_INVALID",
+  "WEBHOOK_TIMESTAMP_OUTSIDE_TOLERANCE",
+  "WEBHOOK_TOLERANCE_INVALID",
+  "WEBHOOK_PAYLOAD_INVALID"
+];
+var PayclaveError = class extends Error {
+  code;
+  status;
+  requestId;
+  details;
+  constructor({
+    message,
+    code,
+    status,
+    requestId,
+    details,
+    cause
+  }) {
+    super(message, cause === void 0 ? void 0 : { cause });
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "PayclaveError";
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId ?? null;
+    this.details = details;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      status: this.status,
+      requestId: this.requestId,
+      details: this.details
+    };
+  }
+};
+var PAYCLAVE_SERVER_SDK_NAME = "payclave-sdk-server";
+var PAYCLAVE_SERVER_SDK_VERSION = "0.1.0";
+var defaultApiBaseUrl = "https://api.payclave.com";
+var defaultFetcher = (input, init) => fetch(input, init);
+var secretKeyPattern = /^sk_(test|live)_[A-Za-z0-9_-]+$/;
+var amountPattern = /^(0|[1-9]\d*)(\.\d{1,6})?$/;
+var webhookUrlMessage = "Webhook URL must be a valid http or https URL.";
+var defaultWebhookToleranceSeconds = 300;
+var minExpiryMinutes = 5;
+var maxExpiryMinutes = 24 * 60;
+var supportedWebhookEventTypes = new Set(PAYCLAVE_WEBHOOK_EVENT_TYPES);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPlainObject = (value) => {
+  if (!isRecord(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+var isStringOrNull = (value) => typeof value === "string" || value === null;
+var isMetadata = (value) => isPlainObject(value);
+var isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+var joinUrl = (baseUrl, path) => `${baseUrl.replace(/\/+$/, "")}${path}`;
+var buildClientHeader = () => `${PAYCLAVE_SERVER_SDK_NAME}/${PAYCLAVE_SERVER_SDK_VERSION}`;
+var assertSecretKey = (secretKey) => {
+  if (typeof secretKey !== "string" || !secretKeyPattern.test(secretKey)) {
+    throw new PayclaveError({
+      message: "A valid Payclave secret key is required.",
+      code: "INVALID_SECRET_KEY",
+      status: 0
+    });
+  }
+};
+var normalizeApiBaseUrl = (apiBaseUrl) => {
+  if (typeof apiBaseUrl !== "string") {
+    throw new PayclaveError({
+      message: "Payclave API base URL must be a valid HTTP or HTTPS URL.",
+      code: "INVALID_API_BASE_URL",
+      status: 0
+    });
+  }
+  const value = apiBaseUrl.trim();
+  let url;
+  try {
+    url = new URL(value);
+  } catch (error) {
+    throw new PayclaveError({
+      message: "Payclave API base URL must be a valid HTTP or HTTPS URL.",
+      code: "INVALID_API_BASE_URL",
+      status: 0,
+      cause: error
+    });
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new PayclaveError({
+      message: "Payclave API base URL must use http or https.",
+      code: "INVALID_API_BASE_URL",
+      status: 0
+    });
+  }
+  if (url.search || url.hash) {
+    throw new PayclaveError({
+      message: "Payclave API base URL must not include query or hash parts.",
+      code: "INVALID_API_BASE_URL",
+      status: 0
+    });
+  }
+  return value.replace(/\/+$/, "");
+};
+var assertTimeoutMs = (timeoutMs) => {
+  if (timeoutMs !== void 0 && (!Number.isInteger(timeoutMs) || timeoutMs < 1)) {
+    throw new PayclaveError({
+      message: "Timeout must be a positive integer number of milliseconds.",
+      code: "INVALID_TIMEOUT",
+      status: 0
+    });
+  }
+};
+var assertAmount = (amount) => {
+  if (typeof amount !== "string" || !amountPattern.test(amount) || Number(amount) <= 0) {
+    throw new PayclaveError({
+      message: "Amount must be a positive USDT value with up to 6 decimals.",
+      code: "INVALID_AMOUNT",
+      status: 0
+    });
+  }
+};
+var assertOptionalExpiry = (expiresInMinutes) => {
+  if (expiresInMinutes !== void 0 && (!Number.isInteger(expiresInMinutes) || expiresInMinutes < minExpiryMinutes || expiresInMinutes > maxExpiryMinutes)) {
+    throw new PayclaveError({
+      message: "Expiry must be between 5 minutes and 24 hours.",
+      code: "INVALID_EXPIRY",
+      status: 0
+    });
+  }
+};
+var assertIdentifier = (value, label) => {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new PayclaveError({
+      message: `${label} is required.`,
+      code: "INVALID_ID",
+      status: 0
+    });
+  }
+};
+var assertOptionalMetadata = (metadata) => {
+  if (metadata !== void 0 && !isPlainObject(metadata)) {
+    throw new PayclaveError({
+      message: "Metadata must be a JSON object.",
+      code: "INVALID_METADATA",
+      status: 0
+    });
+  }
+};
+var assertIdempotencyKey = (key) => {
+  if (typeof key !== "string" || key.length === 0) {
+    throw new PayclaveError({
+      message: "Idempotency key must not be empty.",
+      code: "INVALID_IDEMPOTENCY_KEY",
+      status: 0
+    });
+  }
+  if (key.length > 255) {
+    throw new PayclaveError({
+      message: "Idempotency key must be 255 characters or fewer.",
+      code: "INVALID_IDEMPOTENCY_KEY",
+      status: 0
+    });
+  }
+  for (const character of key) {
+    const codePoint = character.charCodeAt(0);
+    if (codePoint < 33 || codePoint > 126) {
+      throw new PayclaveError({
+        message: "Idempotency key must contain visible ASCII characters only.",
+        code: "INVALID_IDEMPOTENCY_KEY",
+        status: 0
+      });
+    }
+  }
+};
+var normalizeWebhookUrl = (url) => {
+  if (typeof url !== "string") {
+    throw new PayclaveError({
+      message: webhookUrlMessage,
+      code: "INVALID_WEBHOOK_URL",
+      status: 0
+    });
+  }
+  const value = url.trim();
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch (error) {
+    throw new PayclaveError({
+      message: webhookUrlMessage,
+      code: "INVALID_WEBHOOK_URL",
+      status: 0,
+      cause: error
+    });
+  }
+  if (parsed.host === "" || parsed.username !== "" || parsed.password !== "" || parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw new PayclaveError({
+      message: webhookUrlMessage,
+      code: "INVALID_WEBHOOK_URL",
+      status: 0
+    });
+  }
+  return value;
+};
+var assertWebhookEventTypes = (eventTypes) => {
+  if (eventTypes === void 0) {
+    return;
+  }
+  if (!Array.isArray(eventTypes)) {
+    throw new PayclaveError({
+      message: "Webhook event types must be an array.",
+      code: "WEBHOOK_EVENT_UNSUPPORTED",
+      status: 0
+    });
+  }
+  for (const eventType of eventTypes) {
+    if (!supportedWebhookEventTypes.has(eventType)) {
+      throw new PayclaveError({
+        message: "Webhook event type is not supported.",
+        code: "WEBHOOK_EVENT_UNSUPPORTED",
+        status: 0
+      });
+    }
+  }
+};
+var assertPositiveIntegerLimit = (limit) => {
+  if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > 100) {
+    throw new PayclaveError({
+      message: "Limit must be an integer from 1 to 100.",
+      code: "INVALID_LIMIT",
+      status: 0
+    });
+  }
+};
+var serializeBody = (body) => {
+  try {
+    return JSON.stringify(body);
+  } catch (error) {
+    throw new PayclaveError({
+      message: "Request body could not be serialized as JSON.",
+      code: "INVALID_REQUEST_BODY",
+      status: 0,
+      cause: error
+    });
+  }
+};
+var compact = (input) => {
+  const out = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0) {
+      out[key] = value;
+    }
+  }
+  return out;
+};
+var encodePathSegment = (value) => encodeURIComponent(value);
+var isFailureResponse = (value) => {
+  if (!isRecord(value) || value.success !== false || !isRecord(value.error)) {
+    return false;
+  }
+  const meta = value.meta;
+  return typeof value.error.code === "string" && value.error.code.trim() !== "" && typeof value.error.message === "string" && value.error.message.trim() !== "" && (meta === void 0 || isRecord(meta) && (meta.requestId === void 0 || typeof meta.requestId === "string"));
+};
+var isSuccessResponse = (value, guard) => isRecord(value) && value.success === true && guard(value.data);
+var parseResponse = async (response, guard) => {
+  const body = await response.json().catch(() => null);
+  const fallbackRequestId = response.headers.get("X-Request-ID");
+  if (isFailureResponse(body)) {
+    throw new PayclaveError({
+      message: body.error.message,
+      code: body.error.code,
+      status: response.status,
+      requestId: body.meta?.requestId ?? fallbackRequestId,
+      details: body.error.details
+    });
+  }
+  if (!response.ok || !isSuccessResponse(body, guard)) {
+    throw new PayclaveError({
+      message: "Payclave returned an invalid response.",
+      code: "INVALID_RESPONSE",
+      status: response.status,
+      requestId: fallbackRequestId
+    });
+  }
+  return body.data;
+};
+var runFetch = async ({
+  fetcher,
+  url,
+  init,
+  externalSignal,
+  timeoutMs
+}) => {
+  if (externalSignal?.aborted) {
+    throw new PayclaveError({
+      message: "Payclave request was aborted before it started.",
+      code: "ABORTED",
+      status: 0,
+      cause: externalSignal.reason
+    });
+  }
+  const controller = new AbortController();
+  const onExternalAbort = () => {
+    controller.abort(externalSignal?.reason);
+  };
+  if (externalSignal) {
+    externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+  }
+  let timeoutHandle;
+  let timedOut = false;
+  if (typeof timeoutMs === "number" && timeoutMs > 0) {
+    timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      controller.abort(
+        new DOMException(
+          `Payclave request timed out after ${timeoutMs}ms.`,
+          "TimeoutError"
+        )
+      );
+    }, timeoutMs);
+  }
+  try {
+    return await fetcher(url, { ...init, signal: controller.signal });
+  } catch (error) {
+    if (timedOut) {
+      throw new PayclaveError({
+        message: `Payclave request timed out after ${timeoutMs}ms.`,
+        code: "TIMEOUT",
+        status: 0,
+        cause: error
+      });
+    }
+    if (externalSignal?.aborted || controller.signal.aborted) {
+      throw new PayclaveError({
+        message: "Payclave request was aborted.",
+        code: "ABORTED",
+        status: 0,
+        cause: externalSignal?.reason ?? error
+      });
+    }
+    throw new PayclaveError({
+      message: error instanceof Error ? error.message : "Network request failed.",
+      code: "NETWORK_ERROR",
+      status: 0,
+      cause: error
+    });
+  } finally {
+    if (timeoutHandle !== void 0) {
+      clearTimeout(timeoutHandle);
+    }
+    if (externalSignal) {
+      externalSignal.removeEventListener("abort", onExternalAbort);
+    }
+  }
+};
+var isCreatedCheckoutSession = (value) => {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.checkoutId === "string" && value.object === "checkout_session" && typeof value.mode === "string" && value.status === "pending" && typeof value.invoiceId === "string" && typeof value.invoiceNumber === "string" && typeof value.amountDue === "string" && typeof value.currencyCode === "string" && typeof value.chainId === "number" && typeof value.tokenSymbol === "string" && typeof value.tokenContract === "string" && typeof value.settlementWalletAddress === "string" && isStringOrNull(value.externalReference) && isStringOrNull(value.customerEmail) && isMetadata(value.metadata) && typeof value.checkoutUrl === "string" && typeof value.expiresAt === "string" && typeof value.createdAt === "string";
+};
+var isCheckoutSession = (value) => {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.checkoutId === "string" && value.object === "checkout_session" && typeof value.mode === "string" && typeof value.status === "string" && isStringOrNull(value.invoiceId) && isStringOrNull(value.invoiceNumber) && isStringOrNull(value.externalReference) && isStringOrNull(value.customerEmail) && isMetadata(value.metadata) && typeof value.checkoutUrl === "string" && typeof value.expiresAt === "string" && isStringOrNull(value.completedAt) && typeof value.createdAt === "string";
+};
+var isInvoice = (value) => {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.invoiceNumber === "string" && value.object === "invoice" && typeof value.mode === "string" && typeof value.status === "string" && typeof value.amountDue === "string" && typeof value.amountReceived === "string" && typeof value.currencyCode === "string" && typeof value.chainId === "number" && typeof value.tokenContract === "string" && typeof value.settlementWalletAddress === "string" && isStringOrNull(value.externalReference) && isMetadata(value.metadata) && typeof value.expiresAt === "string" && isStringOrNull(value.paidAt) && isStringOrNull(value.cancelledAt) && typeof value.createdAt === "string";
+};
+var isPayment = (value) => {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && value.object === "payment" && typeof value.invoiceId === "string" && typeof value.invoiceNumber === "string" && isStringOrNull(value.transactionId) && typeof value.mode === "string" && typeof value.status === "string" && typeof value.amountExpected === "string" && typeof value.amountReceived === "string" && typeof value.chainId === "number" && typeof value.settlementWalletAddress === "string" && isStringOrNull(value.failureReason) && isStringOrNull(value.confirmedAt) && typeof value.createdAt === "string";
+};
+var isWebhookEndpoint = (value) => {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && value.object === "webhook_endpoint" && typeof value.mode === "string" && typeof value.url === "string" && typeof value.enabled === "boolean" && isStringArray(value.eventTypes) && typeof value.signingSecret === "string" && typeof value.createdAt === "string";
+};
+var isWebhookEvent = (value) => {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && value.object === "event" && typeof value.type === "string" && typeof value.mode === "string" && typeof value.createdAt === "string" && isRecord(value.data);
+};
+var isWebhookDeliveryAttemptSummary = (value) => {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return (typeof value.responseStatusCode === "number" || value.responseStatusCode === null) && isStringOrNull(value.errorMessage) && typeof value.attemptedAt === "string";
+};
+var isWebhookDelivery = (value) => {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && value.object === "webhook_delivery" && typeof value.endpointId === "string" && isStringOrNull(value.invoiceId) && typeof value.eventType === "string" && typeof value.status === "string" && typeof value.idempotencyKey === "string" && isWebhookEvent(value.payload) && typeof value.nextAttemptAt === "string" && isStringOrNull(value.deliveredAt) && typeof value.attemptCount === "number" && (value.latestAttempt === null || isWebhookDeliveryAttemptSummary(value.latestAttempt)) && typeof value.createdAt === "string";
+};
+var isWebhookDeliveryArray = (value) => Array.isArray(value) && value.every(isWebhookDelivery);
+var normalizePayloadBytes = (payload) => {
+  if (typeof payload === "string") {
+    return buffer.Buffer.from(payload, "utf8");
+  }
+  if (buffer.Buffer.isBuffer(payload)) {
+    return payload;
+  }
+  if (!(payload instanceof Uint8Array)) {
+    throw new PayclaveError({
+      message: "Payclave webhook payload must be a string, Buffer, or Uint8Array.",
+      code: "WEBHOOK_PAYLOAD_INVALID",
+      status: 0
+    });
+  }
+  return buffer.Buffer.from(payload);
+};
+var currentUnixTimestamp = (now) => {
+  if (now instanceof Date) {
+    return Math.floor(now.getTime() / 1e3);
+  }
+  if (typeof now === "number") {
+    return Math.floor(now);
+  }
+  if (now !== void 0) {
+    return Number.NaN;
+  }
+  return Math.floor(Date.now() / 1e3);
+};
+var parseSignatureHeader = (signature) => {
+  if (typeof signature !== "string" || signature.trim() === "") {
+    throw new PayclaveError({
+      message: "Payclave webhook signature is missing.",
+      code: "WEBHOOK_SIGNATURE_INVALID",
+      status: 0
+    });
+  }
+  const parts = signature.split(",").map((part) => part.trim()).filter(Boolean);
+  let timestamp = null;
+  const signatures = [];
+  for (const part of parts) {
+    const separator = part.indexOf("=");
+    if (separator === -1) {
+      continue;
+    }
+    const key = part.slice(0, separator);
+    const value = part.slice(separator + 1);
+    if (key === "t") {
+      timestamp = /^\d+$/.test(value) ? Number(value) : Number.NaN;
+    } else if (key === "v1" && value) {
+      signatures.push(value);
+    }
+  }
+  if (!Number.isSafeInteger(timestamp) || timestamp === null) {
+    throw new PayclaveError({
+      message: "Payclave webhook timestamp is invalid.",
+      code: "WEBHOOK_TIMESTAMP_INVALID",
+      status: 0
+    });
+  }
+  if (signatures.length === 0) {
+    throw new PayclaveError({
+      message: "Payclave webhook signature is missing.",
+      code: "WEBHOOK_SIGNATURE_INVALID",
+      status: 0
+    });
+  }
+  return { timestamp, signatures };
+};
+var expectedWebhookSignature = (payload, secret, timestamp) => {
+  const mac = crypto.createHmac("sha256", secret);
+  mac.update(String(timestamp));
+  mac.update(".");
+  mac.update(normalizePayloadBytes(payload));
+  return mac.digest("hex");
+};
+var timingSafeHexEqual = (actual, expected) => {
+  if (actual.length !== expected.length || !/^[a-fA-F0-9]+$/.test(actual)) {
+    return false;
+  }
+  const actualBytes = buffer.Buffer.from(actual, "hex");
+  const expectedBytes = buffer.Buffer.from(expected, "hex");
+  return actualBytes.length === expectedBytes.length && crypto.timingSafeEqual(actualBytes, expectedBytes);
+};
+function assertPayclaveWebhookSignature({
+  payload,
+  signature,
+  secret,
+  toleranceSeconds = defaultWebhookToleranceSeconds,
+  now
+}) {
+  if (!Number.isFinite(toleranceSeconds) || toleranceSeconds < 0) {
+    throw new PayclaveError({
+      message: "Payclave webhook tolerance must be a non-negative number.",
+      code: "WEBHOOK_TOLERANCE_INVALID",
+      status: 0
+    });
+  }
+  if (typeof secret !== "string") {
+    throw new PayclaveError({
+      message: "Payclave webhook secret is required.",
+      code: "WEBHOOK_SIGNATURE_INVALID",
+      status: 0
+    });
+  }
+  const trimmedSecret = secret.trim();
+  if (!trimmedSecret) {
+    throw new PayclaveError({
+      message: "Payclave webhook secret is required.",
+      code: "WEBHOOK_SIGNATURE_INVALID",
+      status: 0
+    });
+  }
+  const parsed = parseSignatureHeader(signature);
+  const nowTimestamp = currentUnixTimestamp(now);
+  if (!Number.isSafeInteger(nowTimestamp)) {
+    throw new PayclaveError({
+      message: "Payclave webhook current timestamp is invalid.",
+      code: "WEBHOOK_TIMESTAMP_INVALID",
+      status: 0
+    });
+  }
+  if (toleranceSeconds > 0 && Math.abs(nowTimestamp - parsed.timestamp) > toleranceSeconds) {
+    throw new PayclaveError({
+      message: "Payclave webhook timestamp is outside the allowed tolerance.",
+      code: "WEBHOOK_TIMESTAMP_OUTSIDE_TOLERANCE",
+      status: 0
+    });
+  }
+  const expected = expectedWebhookSignature(payload, trimmedSecret, parsed.timestamp);
+  if (!parsed.signatures.some(
+    (candidate) => timingSafeHexEqual(candidate, expected)
+  )) {
+    throw new PayclaveError({
+      message: "Payclave webhook signature is invalid.",
+      code: "WEBHOOK_SIGNATURE_INVALID",
+      status: 0
+    });
+  }
+}
+function verifyPayclaveWebhookSignature(input) {
+  try {
+    assertPayclaveWebhookSignature(input);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function constructPayclaveWebhookEvent(input) {
+  assertPayclaveWebhookSignature(input);
+  let parsed;
+  try {
+    parsed = JSON.parse(normalizePayloadBytes(input.payload).toString("utf8"));
+  } catch (error) {
+    throw new PayclaveError({
+      message: "Payclave webhook payload is not valid JSON.",
+      code: "WEBHOOK_PAYLOAD_INVALID",
+      status: 0,
+      cause: error
+    });
+  }
+  if (!isWebhookEvent(parsed)) {
+    throw new PayclaveError({
+      message: "Payclave webhook payload is not a valid event.",
+      code: "WEBHOOK_PAYLOAD_INVALID",
+      status: 0
+    });
+  }
+  return parsed;
+}
+function createPayclaveServerClient({
+  secretKey,
+  apiBaseUrl = defaultApiBaseUrl,
+  fetcher = defaultFetcher,
+  timeoutMs
+}) {
+  assertSecretKey(secretKey);
+  assertTimeoutMs(timeoutMs);
+  const normalizedApiBaseUrl = normalizeApiBaseUrl(apiBaseUrl);
+  const request = async ({
+    method,
+    path,
+    body,
+    idempotencyKey,
+    signal,
+    guard
+  }) => {
+    const headers = {
+      Accept: "application/json",
+      Authorization: `Bearer ${secretKey}`,
+      "X-Payclave-Client": buildClientHeader()
+    };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (idempotencyKey !== void 0) {
+      assertIdempotencyKey(idempotencyKey);
+      headers["Idempotency-Key"] = idempotencyKey;
+    }
+    const response = await runFetch({
+      fetcher,
+      url: joinUrl(normalizedApiBaseUrl, path),
+      init: {
+        method,
+        headers,
+        body: body === void 0 ? void 0 : serializeBody(body)
+      },
+      externalSignal: signal,
+      timeoutMs
+    });
+    return parseResponse(response, guard);
+  };
+  const createCheckoutSession = (input) => {
+    assertAmount(input.amount);
+    assertOptionalExpiry(input.expiresInMinutes);
+    assertOptionalMetadata(input.metadata);
+    return request({
+      method: "POST",
+      path: "/v1/checkout-sessions",
+      body: compact({
+        amount: input.amount,
+        customerEmail: input.customerEmail,
+        externalReference: input.externalReference,
+        successUrl: input.successUrl,
+        cancelUrl: input.cancelUrl,
+        metadata: input.metadata,
+        expiresInMinutes: input.expiresInMinutes
+      }),
+      idempotencyKey: input.idempotencyKey,
+      signal: input.signal,
+      guard: isCreatedCheckoutSession
+    });
+  };
+  const getCheckoutSession = (id, options = {}) => {
+    assertIdentifier(id, "Checkout session id");
+    return request({
+      method: "GET",
+      path: `/v1/checkout-sessions/${encodePathSegment(id)}`,
+      signal: options.signal,
+      guard: isCheckoutSession
+    });
+  };
+  const createInvoice = (input) => {
+    assertAmount(input.amount);
+    assertOptionalExpiry(input.expiresInMinutes);
+    assertOptionalMetadata(input.metadata);
+    return request({
+      method: "POST",
+      path: "/v1/invoices",
+      body: compact({
+        amount: input.amount,
+        externalReference: input.externalReference,
+        metadata: input.metadata,
+        expiresInMinutes: input.expiresInMinutes
+      }),
+      idempotencyKey: input.idempotencyKey,
+      signal: input.signal,
+      guard: isInvoice
+    });
+  };
+  const getInvoice = (id, options = {}) => {
+    assertIdentifier(id, "Invoice id");
+    return request({
+      method: "GET",
+      path: `/v1/invoices/${encodePathSegment(id)}`,
+      signal: options.signal,
+      guard: isInvoice
+    });
+  };
+  const getPayment = (id, options = {}) => {
+    assertIdentifier(id, "Payment id");
+    return request({
+      method: "GET",
+      path: `/v1/payments/${encodePathSegment(id)}`,
+      signal: options.signal,
+      guard: isPayment
+    });
+  };
+  const createWebhookEndpoint = (input) => {
+    const url = normalizeWebhookUrl(input.url);
+    assertWebhookEventTypes(input.eventTypes);
+    return request({
+      method: "POST",
+      path: "/v1/webhook-endpoints",
+      body: compact({
+        url,
+        eventTypes: input.eventTypes
+      }),
+      signal: input.signal,
+      guard: isWebhookEndpoint
+    });
+  };
+  const createTestWebhook = (input) => {
+    assertIdentifier(input.endpointId, "Webhook endpoint id");
+    assertWebhookEventTypes(
+      input.eventType === void 0 ? void 0 : [input.eventType]
+    );
+    return request({
+      method: "POST",
+      path: "/v1/webhooks/test",
+      body: compact({
+        endpointId: input.endpointId,
+        eventType: input.eventType
+      }),
+      signal: input.signal,
+      guard: isWebhookDelivery
+    });
+  };
+  const listWebhookDeliveries = (input = {}) => {
+    const limit = input.limit;
+    if (limit !== void 0) {
+      assertPositiveIntegerLimit(limit);
+    }
+    const query = limit !== void 0 ? `?limit=${encodeURIComponent(String(limit))}` : "";
+    return request({
+      method: "GET",
+      path: `/v1/webhook-deliveries${query}`,
+      signal: input.signal,
+      guard: isWebhookDeliveryArray
+    });
+  };
+  return {
+    createCheckoutSession,
+    getCheckoutSession,
+    createInvoice,
+    getInvoice,
+    getPayment,
+    createWebhookEndpoint,
+    createTestWebhook,
+    listWebhookDeliveries
+  };
+}
+
+exports.PAYCLAVE_API_ERROR_CODES = PAYCLAVE_API_ERROR_CODES;
+exports.PAYCLAVE_SERVER_SDK_ERROR_CODES = PAYCLAVE_SERVER_SDK_ERROR_CODES;
+exports.PAYCLAVE_SERVER_SDK_NAME = PAYCLAVE_SERVER_SDK_NAME;
+exports.PAYCLAVE_SERVER_SDK_VERSION = PAYCLAVE_SERVER_SDK_VERSION;
+exports.PAYCLAVE_WEBHOOK_EVENT_TYPES = PAYCLAVE_WEBHOOK_EVENT_TYPES;
+exports.PAYCLAVE_WEBHOOK_VERIFICATION_ERROR_CODES = PAYCLAVE_WEBHOOK_VERIFICATION_ERROR_CODES;
+exports.PayclaveError = PayclaveError;
+exports.assertPayclaveWebhookSignature = assertPayclaveWebhookSignature;
+exports.constructPayclaveWebhookEvent = constructPayclaveWebhookEvent;
+exports.createPayclaveServerClient = createPayclaveServerClient;
+exports.verifyPayclaveWebhookSignature = verifyPayclaveWebhookSignature;