@nile-squad/nylonpay-ts 1.0.0

package/dist/index.cjs

@@ -0,0 +1,781 @@
+'use strict';
+
+var crypto = require('crypto');
+var slangTs = require('slang-ts');
+var os = require('os');
+
+// src/sdk.ts
+
+// src/pubsub.ts
+function createEmitter() {
+  const state = {
+    listeners: /* @__PURE__ */ new Map()
+  };
+  function on(event, handler) {
+    if (!state.listeners.has(event)) {
+      state.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    state.listeners.get(event).add(handler);
+    return () => off(event, handler);
+  }
+  function once(event, handler) {
+    const wrapper = (data) => {
+      off(event, wrapper);
+      handler(data);
+    };
+    on(event, wrapper);
+    return emitter;
+  }
+  function off(event, handler) {
+    const handlers = state.listeners.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+  }
+  function emit(event, data) {
+    const handlers = state.listeners.get(event);
+    if (!handlers || handlers.size === 0) return;
+    for (const handler of handlers) {
+      try {
+        handler(data);
+      } catch {
+      }
+    }
+  }
+  function clear(event) {
+    if (event) {
+      state.listeners.delete(event);
+    } else {
+      state.listeners.clear();
+    }
+  }
+  function listenerCount(event) {
+    return state.listeners.get(event)?.size ?? 0;
+  }
+  const emitter = { on, once, off, emit, clear, listenerCount };
+  return emitter;
+}
+
+// src/payment.ts
+var STATUS_TO_EVENT = {
+  successful: "success",
+  failed: "failed",
+  processing: "processing",
+  cancelled: "cancelled"
+};
+function statusToEvent(status) {
+  return STATUS_TO_EVENT[status] ?? null;
+}
+var TERMINAL_STATES = /* @__PURE__ */ new Set([
+  "successful",
+  "failed",
+  "cancelled"
+]);
+function createPaymentInstance(initialResponse, deps) {
+  const state = {
+    reference: initialResponse.reference,
+    status: initialResponse.status,
+    transaction: null,
+    pollingTimer: null,
+    resolved: false,
+    pollAttempts: 0,
+    pollStartTime: Date.now(),
+    emitter: createEmitter(),
+    fetchStatus: deps.fetchStatus,
+    fetchTransaction: deps.fetchTransaction,
+    pollIntervalMs: deps.pollIntervalMs ?? 2e3,
+    maxPollDuration: deps.maxPollDuration ?? 3e5,
+    maxPollAttempts: deps.maxPollAttempts ?? 150
+  };
+  function resolveWithError(error) {
+    state.resolved = true;
+    stopPolling();
+    emitEvent("error", error);
+  }
+  function emitEvent(event, error) {
+    const data = {
+      event,
+      transaction: state.transaction ?? void 0,
+      error,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    state.emitter.emit(event, data);
+  }
+  async function handleTerminalState(status) {
+    const txResult = await state.fetchTransaction({
+      reference: state.reference
+    });
+    if (txResult.isOk) {
+      state.transaction = txResult.value;
+      const event = statusToEvent(status);
+      if (event) {
+        emitEvent(event);
+      }
+    } else {
+      emitEvent("error", `Failed to fetch transaction: ${txResult.error}`);
+    }
+    state.resolved = true;
+    stopPolling();
+  }
+  async function handleStatusUpdate(response) {
+    if (response.reference !== state.reference) {
+      resolveWithError(
+        `Reference mismatch: expected ${state.reference} but got ${response.reference}`
+      );
+      return;
+    }
+    const newStatus = response.status;
+    const oldStatus = state.status;
+    state.status = newStatus;
+    if (newStatus !== oldStatus) {
+      const event = statusToEvent(newStatus);
+      if (event) {
+        if (TERMINAL_STATES.has(newStatus)) {
+          await handleTerminalState(newStatus);
+          return;
+        }
+        emitEvent(event);
+      }
+    }
+  }
+  function handlePollError(error) {
+    const isNotFound = error.includes("not found") || error.includes("NOT_FOUND");
+    if (isNotFound) {
+      return;
+    }
+    emitEvent("error", error);
+    state.resolved = true;
+    stopPolling();
+  }
+  function scheduleNextPoll() {
+    if (state.resolved || state.pollingTimer) {
+      return;
+    }
+    state.pollingTimer = setTimeout(() => {
+      state.pollingTimer = null;
+      void pollStatus();
+    }, state.pollIntervalMs);
+  }
+  async function pollStatus() {
+    if (state.resolved) {
+      stopPolling();
+      return;
+    }
+    if (state.pollAttempts >= state.maxPollAttempts) {
+      resolveWithError("Polling timeout: exceeded maximum attempts");
+      return;
+    }
+    if (Date.now() - state.pollStartTime >= state.maxPollDuration) {
+      resolveWithError("Polling timeout: exceeded maximum duration");
+      return;
+    }
+    state.pollAttempts += 1;
+    const result = await state.fetchStatus({ reference: state.reference });
+    if (result.isOk) {
+      await handleStatusUpdate(result.value);
+    } else {
+      handlePollError(result.error);
+    }
+    if (state.resolved) {
+      stopPolling();
+      return;
+    }
+    scheduleNextPoll();
+  }
+  function startPolling() {
+    scheduleNextPoll();
+  }
+  function stopPolling() {
+    if (state.pollingTimer) {
+      clearTimeout(state.pollingTimer);
+      state.pollingTimer = null;
+    }
+  }
+  function on(event, handler) {
+    state.emitter.on(event, handler);
+    return paymentInstance;
+  }
+  function off(event, handler) {
+    state.emitter.off(event, handler);
+    return paymentInstance;
+  }
+  function once(event, handler) {
+    state.emitter.once(event, handler);
+    return paymentInstance;
+  }
+  function wait() {
+    return new Promise((resolve, reject) => {
+      if (state.resolved) {
+        if (state.status === "successful" && state.transaction) {
+          resolve(state.transaction);
+        } else {
+          reject(new Error(`Payment ${state.status ?? "error"}`));
+        }
+        return;
+      }
+      function onSuccess() {
+        cleanup();
+        if (state.transaction) {
+          resolve(state.transaction);
+        } else {
+          reject(
+            new Error("Payment successful but transaction data unavailable")
+          );
+        }
+      }
+      function onFailed() {
+        cleanup();
+        reject(new Error("Payment failed"));
+      }
+      function onCancelled() {
+        cleanup();
+        reject(new Error("Payment cancelled"));
+      }
+      function onError(data) {
+        cleanup();
+        const eventData = data;
+        reject(new Error(eventData.error ?? "Payment error"));
+      }
+      function cleanup() {
+        state.emitter.off("success", onSuccess);
+        state.emitter.off("failed", onFailed);
+        state.emitter.off("cancelled", onCancelled);
+        state.emitter.off("error", onError);
+      }
+      state.emitter.on("success", onSuccess);
+      state.emitter.on("failed", onFailed);
+      state.emitter.on("cancelled", onCancelled);
+      state.emitter.on("error", onError);
+    });
+  }
+  const paymentInstance = {
+    get reference() {
+      return state.reference;
+    },
+    get status() {
+      return state.status;
+    },
+    on,
+    once,
+    off,
+    wait
+  };
+  startPolling();
+  return paymentInstance;
+}
+
+// src/sdk.config.ts
+var DEFAULT_BASE_URL = "https://api.nylonpay.io/api/services";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_MAX_POLL_INTERVAL_MS = 2e3;
+var DEFAULT_MAX_POLL_DURATION_MS = 3e5;
+var DEFAULT_MAX_POLL_ATTEMPTS = 150;
+var SDK_SERVICE = "sdk";
+var SDK_ACTIONS = {
+  collectPayment: "sdk-collect-payment",
+  collectPaymentAndResolve: "sdk-collect-payment-and-resolve",
+  makePayout: "sdk-make-payout",
+  makePayoutAndResolve: "sdk-make-payout-and-resolve",
+  getStatus: "sdk-get-status",
+  getTransaction: "sdk-get-transaction",
+  verifyPhone: "sdk-verify-phone",
+  createInvoice: "sdk-create-invoice"
+};
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+function generateFingerprint() {
+  const components = [
+    `type:${os.type()}`,
+    `platform:${os.platform()}`,
+    `arch:${os.arch()}`,
+    `release:${os.release()}`,
+    `hostname:${os.hostname()}`,
+    `node:${process.versions.node}`,
+    `v8:${process.versions.v8}`
+  ].join("|");
+  return crypto.createHash("sha256").update(components).digest("hex");
+}
+function generateNonce(length = 16) {
+  return crypto.randomBytes(length).toString("hex");
+}
+function sortValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => sortValue(entry));
+  }
+  if (value && typeof value === "object") {
+    const sortedEntries = Object.entries(value).sort(
+      ([firstKey], [secondKey]) => firstKey.localeCompare(secondKey)
+    );
+    return Object.fromEntries(
+      sortedEntries.map(([entryKey, entryValue]) => [
+        entryKey,
+        sortValue(entryValue)
+      ])
+    );
+  }
+  return value;
+}
+function createCanonicalPayload(payload) {
+  return JSON.stringify(sortValue(payload));
+}
+function createSignaturePayload(input) {
+  return `${input.fingerprint}.${input.nonce}.${input.timestamp}.${createCanonicalPayload(input.payload)}`;
+}
+function createSignature(input) {
+  const payload = createSignaturePayload(input);
+  return crypto.createHmac("sha256", input.secret).update(payload).digest("hex");
+}
+function createTimestamp() {
+  return Date.now().toString();
+}
+function verifyResponseSignature(data, signature, secret) {
+  const expectedSignature = crypto.createHmac("sha256", secret).update(createCanonicalPayload(data)).digest("hex");
+  const providedBuffer = Buffer.from(signature, "hex");
+  const expectedBuffer = Buffer.from(expectedSignature, "hex");
+  if (providedBuffer.length !== expectedBuffer.length) {
+    return false;
+  }
+  return crypto.timingSafeEqual(providedBuffer, expectedBuffer);
+}
+
+// src/transport.ts
+var CACHED_FINGERPRINT = generateFingerprint();
+function calculateBackoff(attempt) {
+  const base = 2 ** attempt * 1e3;
+  const jitter = Math.random() * 500;
+  return base + jitter;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stripResponseSignature(payload) {
+  if (!payload || typeof payload !== "object" || !("_responseSignature" in payload)) {
+    return { data: payload, responseSignature: null };
+  }
+  const { _responseSignature, ...rest } = payload;
+  return {
+    data: rest,
+    responseSignature: typeof _responseSignature === "string" ? _responseSignature : null
+  };
+}
+function buildEnvelope({
+  action,
+  payload
+}) {
+  return {
+    intent: "execute",
+    service: SDK_SERVICE,
+    action,
+    payload: {
+      ...payload,
+      _fingerprint: CACHED_FINGERPRINT
+    }
+  };
+}
+function buildAuthHeaders({
+  apiKey,
+  apiSecret,
+  payload
+}) {
+  const nonce = generateNonce();
+  const timestamp = createTimestamp();
+  const signature = createSignature({
+    fingerprint: CACHED_FINGERPRINT,
+    nonce,
+    timestamp,
+    payload,
+    secret: apiSecret
+  });
+  return {
+    "content-type": "application/json",
+    "x-nylon-key": apiKey,
+    "x-nylon-nonce": nonce,
+    "x-nylon-signature": signature,
+    "x-nylon-timestamp": timestamp
+  };
+}
+function withTimeout(timeoutMs) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  return { controller, cleanup: () => clearTimeout(timeoutId) };
+}
+function createTransport({
+  apiKey,
+  apiSecret,
+  baseUrl = DEFAULT_BASE_URL,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  maxRetries = DEFAULT_MAX_RETRIES,
+  fetch: fetchImpl
+}) {
+  async function send(request) {
+    const envelope = buildEnvelope(request);
+    const signedPayload = envelope.payload;
+    const headers = buildAuthHeaders({
+      apiKey,
+      apiSecret,
+      payload: signedPayload
+    });
+    const bodyString = JSON.stringify(envelope);
+    async function attempt(currentAttempt) {
+      const { controller, cleanup } = withTimeout(timeoutMs);
+      try {
+        const response = await fetchImpl(baseUrl, {
+          method: "POST",
+          headers,
+          body: bodyString,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const statusCode = response.status;
+          const retryable = RETRYABLE_STATUS_CODES.has(statusCode);
+          let errorMessage = `HTTP ${statusCode}`;
+          try {
+            const errorBody = await response.json();
+            if (errorBody && typeof errorBody === "object" && "message" in errorBody) {
+              errorMessage = String(errorBody.message);
+            }
+          } catch {
+            errorMessage = response.statusText || errorMessage;
+          }
+          if (retryable && currentAttempt < maxRetries) {
+            cleanup();
+            await delay(calculateBackoff(currentAttempt));
+            return attempt(currentAttempt + 1);
+          }
+          const sdkError = {
+            code: `HTTP_${statusCode}`,
+            message: errorMessage,
+            statusCode,
+            retryable
+          };
+          cleanup();
+          return slangTs.Err(JSON.stringify(sdkError));
+        }
+        const responseBody = await response.json();
+        if (!responseBody || typeof responseBody !== "object" || !("status" in responseBody)) {
+          cleanup();
+          return slangTs.Err(
+            JSON.stringify({
+              code: "INVALID_RESPONSE",
+              message: "Response missing status field",
+              retryable: false
+            })
+          );
+        }
+        const { status, message, data } = responseBody;
+        if (status === true) {
+          const { data: strippedData, responseSignature } = stripResponseSignature(data);
+          if (responseSignature) {
+            const isValid = verifyResponseSignature(
+              strippedData,
+              responseSignature,
+              apiSecret
+            );
+            if (!isValid) {
+              cleanup();
+              return slangTs.Err(
+                JSON.stringify({
+                  code: "RESPONSE_TAMPERED",
+                  message: "Response signature verification failed",
+                  retryable: false
+                })
+              );
+            }
+          }
+          cleanup();
+          return slangTs.Ok(strippedData);
+        }
+        const parsedError = parseError(message);
+        cleanup();
+        return slangTs.Err(JSON.stringify(parsedError));
+      } catch (error) {
+        cleanup();
+        const isAbort = error instanceof DOMException && error.name === "AbortError";
+        const sdkError = {
+          code: isAbort ? "TIMEOUT" : "NETWORK_ERROR",
+          message: isAbort ? `Request timed out after ${timeoutMs}ms` : String(error),
+          retryable: true
+        };
+        if (currentAttempt < maxRetries) {
+          await delay(calculateBackoff(currentAttempt));
+          return attempt(currentAttempt + 1);
+        }
+        return slangTs.Err(JSON.stringify(sdkError));
+      }
+    }
+    return attempt(0);
+  }
+  return { send, parseError };
+}
+function parseError(error) {
+  try {
+    const parsed = JSON.parse(error);
+    if (parsed && typeof parsed === "object" && "code" in parsed && "message" in parsed && typeof parsed.code === "string" && typeof parsed.message === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return { code: "UNKNOWN", message: error };
+}
+function verifyWebhookSignature(input) {
+  const payloadBytes = typeof input.payload === "string" ? Buffer.from(input.payload, "utf8") : Buffer.from(input.payload);
+  const expectedSignature = crypto.createHmac("sha256", input.secret).update(payloadBytes).digest("hex");
+  const providedBuffer = Buffer.from(input.signature, "hex");
+  const expectedBuffer = Buffer.from(expectedSignature, "hex");
+  if (providedBuffer.length !== expectedBuffer.length) {
+    return false;
+  }
+  return crypto.timingSafeEqual(providedBuffer, expectedBuffer);
+}
+
+// src/sdk.ts
+function generateReference() {
+  return crypto.randomBytes(16).toString("hex").slice(0, 15);
+}
+function validateAmount(amount) {
+  if (!Number.isInteger(amount) || amount <= 0) {
+    throw new Error("amount must be a positive integer");
+  }
+}
+function validateNonEmpty(value, fieldName) {
+  if (!value || value.trim() === "") {
+    throw new Error(`${fieldName} is required`);
+  }
+}
+function createSdkInstance(config) {
+  const transport = createTransport({
+    apiKey: config.apiKey,
+    apiSecret: config.apiSecret,
+    baseUrl: config.baseUrl,
+    timeoutMs: config.timeoutMs,
+    maxRetries: config.maxRetries,
+    fetch: config.fetch
+  });
+  const commonDeps = {
+    fetchStatus: (input) => transport.send({
+      action: SDK_ACTIONS.getStatus,
+      payload: input
+    }),
+    fetchTransaction: (input) => transport.send({
+      action: SDK_ACTIONS.getTransaction,
+      payload: input
+    }),
+    pollIntervalMs: config.maxPollIntervalMs,
+    maxPollDuration: config.maxPollDurationMs,
+    maxPollAttempts: config.maxPollAttempts
+  };
+  async function collectPayment(input) {
+    const reference = input.reference ?? generateReference();
+    validateAmount(input.amount);
+    validateNonEmpty(input.customer.name, "customer.name");
+    validateNonEmpty(input.customer.phoneNumber, "customer.phoneNumber");
+    validateNonEmpty(input.description, "description");
+    if (input.method === "bank" && !input.bank) {
+      throw new Error('bank details are required when method is "bank"');
+    }
+    const payload = { ...input, reference };
+    const result = await transport.send({
+      action: SDK_ACTIONS.collectPayment,
+      payload
+    });
+    if (result.isOk) {
+      return createPaymentInstance(result.value, commonDeps);
+    }
+    return createPaymentInstance(
+      { reference, status: "pending" },
+      {
+        fetchStatus: async () => slangTs.Err(result.error),
+        fetchTransaction: async () => slangTs.Err(result.error),
+        pollIntervalMs: 0,
+        maxPollAttempts: 1,
+        maxPollDuration: Number.MAX_SAFE_INTEGER
+      }
+    );
+  }
+  async function collectPaymentAndResolve(input) {
+    const reference = input.reference ?? generateReference();
+    validateAmount(input.amount);
+    validateNonEmpty(input.customer.name, "customer.name");
+    validateNonEmpty(input.customer.phoneNumber, "customer.phoneNumber");
+    validateNonEmpty(input.description, "description");
+    if (input.method === "bank" && !input.bank) {
+      throw new Error('bank details are required when method is "bank"');
+    }
+    const payload = { ...input, reference };
+    const result = await transport.send({
+      action: SDK_ACTIONS.collectPaymentAndResolve,
+      payload
+    });
+    if (result.isOk) {
+      return slangTs.Ok(result.value);
+    }
+    return slangTs.Err(result.error);
+  }
+  async function makePayout(input) {
+    const reference = input.reference ?? generateReference();
+    validateAmount(input.amount);
+    validateNonEmpty(input.customer.name, "customer.name");
+    validateNonEmpty(input.customer.phoneNumber, "customer.phoneNumber");
+    validateNonEmpty(input.description, "description");
+    validateNonEmpty(
+      input.destination.accountHolderName,
+      "destination.accountHolderName"
+    );
+    validateNonEmpty(
+      input.destination.accountNumber,
+      "destination.accountNumber"
+    );
+    const payload = { ...input, reference };
+    const result = await transport.send({
+      action: SDK_ACTIONS.makePayout,
+      payload
+    });
+    if (result.isOk) {
+      return createPaymentInstance(result.value, commonDeps);
+    }
+    return createPaymentInstance(
+      { reference, status: "pending" },
+      {
+        fetchStatus: async () => slangTs.Err(result.error),
+        fetchTransaction: async () => slangTs.Err(result.error),
+        pollIntervalMs: 0,
+        maxPollAttempts: 1,
+        maxPollDuration: Number.MAX_SAFE_INTEGER
+      }
+    );
+  }
+  async function makePayoutAndResolve(input) {
+    const reference = input.reference ?? generateReference();
+    validateAmount(input.amount);
+    validateNonEmpty(input.customer.name, "customer.name");
+    validateNonEmpty(input.customer.phoneNumber, "customer.phoneNumber");
+    validateNonEmpty(input.description, "description");
+    validateNonEmpty(
+      input.destination.accountHolderName,
+      "destination.accountHolderName"
+    );
+    validateNonEmpty(
+      input.destination.accountNumber,
+      "destination.accountNumber"
+    );
+    const payload = { ...input, reference };
+    const result = await transport.send({
+      action: SDK_ACTIONS.makePayoutAndResolve,
+      payload
+    });
+    if (result.isOk) {
+      return slangTs.Ok(result.value);
+    }
+    return slangTs.Err(result.error);
+  }
+  async function getStatus(input) {
+    validateNonEmpty(input.reference, "reference");
+    const result = await transport.send({
+      action: SDK_ACTIONS.getStatus,
+      payload: input
+    });
+    if (result.isOk) {
+      return slangTs.Ok(result.value);
+    }
+    return slangTs.Err(result.error);
+  }
+  async function getTransaction(input) {
+    if (!input.id && !input.reference) {
+      throw new Error("id or reference is required");
+    }
+    const result = await transport.send({
+      action: SDK_ACTIONS.getTransaction,
+      payload: input
+    });
+    if (result.isOk) {
+      return slangTs.Ok(result.value);
+    }
+    return slangTs.Err(result.error);
+  }
+  async function verifyPhone(input) {
+    validateNonEmpty(input.phoneNumber, "phoneNumber");
+    const result = await transport.send({
+      action: SDK_ACTIONS.verifyPhone,
+      payload: input
+    });
+    if (result.isOk) {
+      return slangTs.Ok(result.value);
+    }
+    return slangTs.Err(result.error);
+  }
+  async function createInvoice(input) {
+    const reference = input.reference ?? generateReference();
+    validateAmount(input.amount);
+    validateNonEmpty(input.description, "description");
+    if (input.items) {
+      if (input.items.length > 50) {
+        throw new Error("items must not exceed 50");
+      }
+      for (const item of input.items) {
+        if (!Number.isInteger(item.quantity) || item.quantity <= 0) {
+          throw new Error("item quantity must be a positive integer");
+        }
+        if (!Number.isInteger(item.unitPrice) || item.unitPrice <= 0) {
+          throw new Error("item unitPrice must be a positive integer");
+        }
+      }
+    }
+    const payload = { ...input, reference };
+    const result = await transport.send({
+      action: SDK_ACTIONS.createInvoice,
+      payload
+    });
+    if (result.isOk) {
+      return slangTs.Ok(result.value);
+    }
+    return slangTs.Err(result.error);
+  }
+  function verifyWebhook(input) {
+    return verifyWebhookSignature(input);
+  }
+  return {
+    collectPayment,
+    collectPaymentAndResolve,
+    makePayout,
+    makePayoutAndResolve,
+    getStatus,
+    getTransaction,
+    verifyPhone,
+    createInvoice,
+    verifyWebhookSignature: verifyWebhook
+  };
+}
+
+// src/create-nylon-pay.ts
+function createNylonPay(config) {
+  if (!config.apiKey) {
+    throw new Error("apiKey is required");
+  }
+  if (!config.apiKey.startsWith("npk_")) {
+    throw new Error('apiKey must start with "npk_"');
+  }
+  if (!config.apiSecret) {
+    throw new Error("apiSecret is required");
+  }
+  if (!config.apiSecret.startsWith("nps_")) {
+    throw new Error('apiSecret must start with "nps_"');
+  }
+  const resolvedConfig = {
+    apiKey: config.apiKey,
+    apiSecret: config.apiSecret,
+    baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+    timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+    maxPollIntervalMs: config.maxPollIntervalMs ?? DEFAULT_MAX_POLL_INTERVAL_MS,
+    maxPollDurationMs: config.maxPollDurationMs ?? DEFAULT_MAX_POLL_DURATION_MS,
+    maxPollAttempts: config.maxPollAttempts ?? DEFAULT_MAX_POLL_ATTEMPTS,
+    fetch: config.fetch ?? globalThis.fetch.bind(globalThis)
+  };
+  return createSdkInstance(resolvedConfig);
+}
+
+exports.createNylonPay = createNylonPay;
+exports.parseError = parseError;
+exports.verifyWebhookSignature = verifyWebhookSignature;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map