@waffo/waffo-node 2.0.4 → 2.2.0

package/dist/index.js

@@ -22,279 +22,242 @@ function _interopNamespace(e) {
 
 var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
 
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
 // src/types/config/environment.ts
-exports.Environment = void 0; exports.EnvironmentBaseUrl = void 0;
-var init_environment = __esm({
-  "src/types/config/environment.ts"() {
-    exports.Environment = /* @__PURE__ */ ((Environment2) => {
-      Environment2["SANDBOX"] = "SANDBOX";
-      Environment2["PRODUCTION"] = "PRODUCTION";
-      return Environment2;
-    })(exports.Environment || {});
-    exports.EnvironmentBaseUrl = {
-      ["SANDBOX" /* SANDBOX */]: "https://api-sandbox.waffo.com/api/v1",
-      ["PRODUCTION" /* PRODUCTION */]: "https://api.waffo.com/api/v1"
-    };
-  }
-});
+var Environment = /* @__PURE__ */ ((Environment2) => {
+  Environment2["SANDBOX"] = "SANDBOX";
+  Environment2["PRODUCTION"] = "PRODUCTION";
+  return Environment2;
+})(Environment || {});
+var EnvironmentBaseUrl = {
+  ["SANDBOX" /* SANDBOX */]: "https://api-sandbox.waffo.com/api/v1",
+  ["PRODUCTION" /* PRODUCTION */]: "https://api.waffo.com/api/v1"
+};
 
 // src/errors/waffo-error.ts
-exports.WaffoError = void 0; exports.WaffoErrorCode = void 0;
-var init_waffo_error = __esm({
-  "src/errors/waffo-error.ts"() {
-    exports.WaffoError = class _WaffoError extends Error {
-      /** Error code identifying the type of error */
-      errorCode;
-      /** The underlying error that caused this error, if any */
-      cause;
-      /**
-       * Creates a new WaffoError.
-       *
-       * @param errorCode - The error code (e.g., "S0003" for signing failure)
-       * @param message - Human-readable error message
-       * @param cause - The underlying error that caused this error
-       */
-      constructor(errorCode, message, cause) {
-        super(message);
-        this.name = "WaffoError";
-        this.errorCode = errorCode;
-        this.cause = cause;
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, _WaffoError);
-        }
-      }
-      /**
-       * Returns a string representation of the error.
-       */
-      toString() {
-        return `[${this.errorCode}] ${this.message}`;
-      }
-    };
-    exports.WaffoErrorCode = {
-      /** Invalid public key */
-      INVALID_PUBLIC_KEY: "S0002",
-      /** Failed to sign data */
-      SIGN_FAILED: "S0003",
-      /** Response signature verification failed */
-      VERIFY_FAILED: "S0004",
-      /** Request serialization failed */
-      SERIALIZE_FAILED: "S0005",
-      /** Unexpected error */
-      UNEXPECTED: "S0006",
-      /** Invalid private key */
-      INVALID_PRIVATE_KEY: "S0007"
-    };
+var WaffoError = class _WaffoError extends Error {
+  /** Error code identifying the type of error */
+  errorCode;
+  /** The underlying error that caused this error, if any */
+  cause;
+  /**
+   * Creates a new WaffoError.
+   *
+   * @param errorCode - The error code (e.g., "S0003" for signing failure)
+   * @param message - Human-readable error message
+   * @param cause - The underlying error that caused this error
+   */
+  constructor(errorCode, message, cause) {
+    super(message);
+    this.name = "WaffoError";
+    this.errorCode = errorCode;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _WaffoError);
+    }
+  }
+  /**
+   * Returns a string representation of the error.
+   */
+  toString() {
+    return `[${this.errorCode}] ${this.message}`;
   }
-});
+};
+var WaffoErrorCode = {
+  /** Invalid public key */
+  INVALID_PUBLIC_KEY: "S0002",
+  /** Failed to sign data */
+  SIGN_FAILED: "S0003",
+  /** Response signature verification failed */
+  VERIFY_FAILED: "S0004",
+  /** Request serialization failed */
+  SERIALIZE_FAILED: "S0005",
+  /** Unexpected error */
+  UNEXPECTED: "S0006",
+  /** Invalid private key */
+  INVALID_PRIVATE_KEY: "S0007"
+};
 
 // src/errors/waffo-unknown-status-error.ts
-exports.WaffoUnknownStatusError = void 0;
-var init_waffo_unknown_status_error = __esm({
-  "src/errors/waffo-unknown-status-error.ts"() {
-    exports.WaffoUnknownStatusError = class _WaffoUnknownStatusError extends Error {
-      /** Error code for network errors */
-      static CODE_NETWORK_ERROR = "S0001";
-      /** Error code for unknown server status */
-      static CODE_UNKNOWN_STATUS = "E0001";
-      /** Error code identifying the type of error */
-      errorCode;
-      /** The underlying error that caused this error, if any */
-      cause;
-      /**
-       * Creates a new WaffoUnknownStatusError.
-       *
-       * @param errorCode - The error code (e.g., "S0001" for network error)
-       * @param message - Human-readable error message
-       * @param cause - The underlying error that caused this error
-       */
-      constructor(errorCode, message, cause) {
-        super(message);
-        this.name = "WaffoUnknownStatusError";
-        this.errorCode = errorCode;
-        this.cause = cause;
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, _WaffoUnknownStatusError);
-        }
-      }
-      /**
-       * Returns a string representation of the error.
-       */
-      toString() {
-        return `[${this.errorCode}] ${this.message}`;
-      }
-    };
+var WaffoUnknownStatusError = class _WaffoUnknownStatusError extends Error {
+  /** Error code for network errors */
+  static CODE_NETWORK_ERROR = "S0001";
+  /** Error code for unknown server status */
+  static CODE_UNKNOWN_STATUS = "E0001";
+  /** Error code identifying the type of error */
+  errorCode;
+  /** The underlying error that caused this error, if any */
+  cause;
+  /**
+   * Creates a new WaffoUnknownStatusError.
+   *
+   * @param errorCode - The error code (e.g., "S0001" for network error)
+   * @param message - Human-readable error message
+   * @param cause - The underlying error that caused this error
+   */
+  constructor(errorCode, message, cause) {
+    super(message);
+    this.name = "WaffoUnknownStatusError";
+    this.errorCode = errorCode;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _WaffoUnknownStatusError);
+    }
+  }
+  /**
+   * Returns a string representation of the error.
+   */
+  toString() {
+    return `[${this.errorCode}] ${this.message}`;
   }
-});
+};
 
-// src/errors/index.ts
-var init_errors = __esm({
-  "src/errors/index.ts"() {
-    init_waffo_error();
-    init_waffo_unknown_status_error();
-  }
-});
-exports.RsaUtils = void 0;
-var init_rsa_utils = __esm({
-  "src/utils/rsa-utils.ts"() {
-    init_errors();
-    ((RsaUtils2) => {
-      const ALGORITHM = "RSA-SHA256";
-      const KEY_SIZE = 2048;
-      function sign(data, base64PrivateKey) {
-        try {
-          const privateKeyBuffer = Buffer.from(base64PrivateKey, "base64");
-          const signer = crypto__namespace.createSign(ALGORITHM);
-          signer.update(data, "utf8");
-          const signature = signer.sign({
-            key: privateKeyBuffer,
-            format: "der",
-            type: "pkcs8"
-          });
-          return signature.toString("base64");
-        } catch (error) {
-          throw new exports.WaffoError(
-            exports.WaffoErrorCode.SIGN_FAILED,
-            `Failed to sign data: ${error instanceof Error ? error.message : String(error)}`,
-            error instanceof Error ? error : void 0
-          );
-        }
-      }
-      RsaUtils2.sign = sign;
-      function verify(data, base64Signature, base64PublicKey) {
-        try {
-          const publicKeyBuffer = Buffer.from(base64PublicKey, "base64");
-          const signatureBuffer = Buffer.from(base64Signature, "base64");
-          const verifier = crypto__namespace.createVerify(ALGORITHM);
-          verifier.update(data, "utf8");
-          return verifier.verify(
-            {
-              key: publicKeyBuffer,
-              format: "der",
-              type: "spki"
-            },
-            signatureBuffer
-          );
-        } catch {
-          return false;
-        }
-      }
-      RsaUtils2.verify = verify;
-      function validatePrivateKey(base64PrivateKey) {
-        if (!base64PrivateKey || base64PrivateKey.trim() === "") {
-          throw new exports.WaffoError(
-            exports.WaffoErrorCode.INVALID_PRIVATE_KEY,
-            "Private key is null or empty"
-          );
-        }
-        try {
-          const keyBuffer = Buffer.from(base64PrivateKey, "base64");
-          crypto__namespace.createPrivateKey({
-            key: keyBuffer,
-            format: "der",
-            type: "pkcs8"
-          });
-        } catch (error) {
-          if (error instanceof exports.WaffoError) throw error;
-          const message = error instanceof Error ? error.message : String(error);
-          if (message.includes("bad base64")) {
-            throw new exports.WaffoError(
-              exports.WaffoErrorCode.INVALID_PRIVATE_KEY,
-              "Invalid private key: not valid Base64 encoding",
-              error instanceof Error ? error : void 0
-            );
-          }
-          throw new exports.WaffoError(
-            exports.WaffoErrorCode.INVALID_PRIVATE_KEY,
-            `Invalid private key: ${message}`,
-            error instanceof Error ? error : void 0
-          );
-        }
-      }
-      RsaUtils2.validatePrivateKey = validatePrivateKey;
-      function validatePublicKey(base64PublicKey) {
-        if (!base64PublicKey || base64PublicKey.trim() === "") {
-          throw new exports.WaffoError(
-            exports.WaffoErrorCode.INVALID_PUBLIC_KEY,
-            "Public key is null or empty"
-          );
-        }
-        try {
-          const keyBuffer = Buffer.from(base64PublicKey, "base64");
-          crypto__namespace.createPublicKey({
-            key: keyBuffer,
-            format: "der",
-            type: "spki"
-          });
-        } catch (error) {
-          if (error instanceof exports.WaffoError) throw error;
-          const message = error instanceof Error ? error.message : String(error);
-          if (message.includes("bad base64")) {
-            throw new exports.WaffoError(
-              exports.WaffoErrorCode.INVALID_PUBLIC_KEY,
-              "Invalid public key: not valid Base64 encoding",
-              error instanceof Error ? error : void 0
-            );
-          }
-          throw new exports.WaffoError(
-            exports.WaffoErrorCode.INVALID_PUBLIC_KEY,
-            `Invalid public key: ${message}`,
-            error instanceof Error ? error : void 0
-          );
-        }
-      }
-      RsaUtils2.validatePublicKey = validatePublicKey;
-      function generateKeyPair() {
-        try {
-          const { privateKey, publicKey } = crypto__namespace.generateKeyPairSync("rsa", {
-            modulusLength: KEY_SIZE,
-            publicKeyEncoding: {
-              type: "spki",
-              format: "der"
-            },
-            privateKeyEncoding: {
-              type: "pkcs8",
-              format: "der"
-            }
-          });
-          return {
-            privateKey: privateKey.toString("base64"),
-            publicKey: publicKey.toString("base64")
-          };
-        } catch (error) {
-          throw new exports.WaffoError(
-            exports.WaffoErrorCode.SIGN_FAILED,
-            `Failed to generate key pair: ${error instanceof Error ? error.message : String(error)}`,
-            error instanceof Error ? error : void 0
-          );
-        }
+// src/utils/rsa-utils.ts
+var ALGORITHM = "RSA-SHA256";
+var KEY_SIZE = 2048;
+function sign(data, base64PrivateKey) {
+  try {
+    const privateKeyBuffer = Buffer.from(base64PrivateKey, "base64");
+    const signer = crypto__namespace.createSign(ALGORITHM);
+    signer.update(data, "utf8");
+    const signature = signer.sign({
+      key: privateKeyBuffer,
+      format: "der",
+      type: "pkcs8"
+    });
+    return signature.toString("base64");
+  } catch (error) {
+    throw new WaffoError(
+      WaffoErrorCode.SIGN_FAILED,
+      `Failed to sign data: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function verify(data, base64Signature, base64PublicKey) {
+  try {
+    const publicKeyBuffer = Buffer.from(base64PublicKey, "base64");
+    const signatureBuffer = Buffer.from(base64Signature, "base64");
+    const verifier = crypto__namespace.createVerify(ALGORITHM);
+    verifier.update(data, "utf8");
+    return verifier.verify(
+      {
+        key: publicKeyBuffer,
+        format: "der",
+        type: "spki"
+      },
+      signatureBuffer
+    );
+  } catch {
+    return false;
+  }
+}
+function validatePrivateKey(base64PrivateKey) {
+  if (!base64PrivateKey || base64PrivateKey.trim() === "") {
+    throw new WaffoError(
+      WaffoErrorCode.INVALID_PRIVATE_KEY,
+      "Private key is null or empty"
+    );
+  }
+  try {
+    const keyBuffer = Buffer.from(base64PrivateKey, "base64");
+    crypto__namespace.createPrivateKey({
+      key: keyBuffer,
+      format: "der",
+      type: "pkcs8"
+    });
+  } catch (error) {
+    if (error instanceof WaffoError) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("bad base64")) {
+      throw new WaffoError(
+        WaffoErrorCode.INVALID_PRIVATE_KEY,
+        "Invalid private key: not valid Base64 encoding",
+        error instanceof Error ? error : void 0
+      );
+    }
+    throw new WaffoError(
+      WaffoErrorCode.INVALID_PRIVATE_KEY,
+      `Invalid private key: ${message}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function validatePublicKey(base64PublicKey) {
+  if (!base64PublicKey || base64PublicKey.trim() === "") {
+    throw new WaffoError(
+      WaffoErrorCode.INVALID_PUBLIC_KEY,
+      "Public key is null or empty"
+    );
+  }
+  try {
+    const keyBuffer = Buffer.from(base64PublicKey, "base64");
+    crypto__namespace.createPublicKey({
+      key: keyBuffer,
+      format: "der",
+      type: "spki"
+    });
+  } catch (error) {
+    if (error instanceof WaffoError) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("bad base64")) {
+      throw new WaffoError(
+        WaffoErrorCode.INVALID_PUBLIC_KEY,
+        "Invalid public key: not valid Base64 encoding",
+        error instanceof Error ? error : void 0
+      );
+    }
+    throw new WaffoError(
+      WaffoErrorCode.INVALID_PUBLIC_KEY,
+      `Invalid public key: ${message}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function generateKeyPair() {
+  try {
+    const { privateKey, publicKey } = crypto__namespace.generateKeyPairSync("rsa", {
+      modulusLength: KEY_SIZE,
+      publicKeyEncoding: {
+        type: "spki",
+        format: "der"
+      },
+      privateKeyEncoding: {
+        type: "pkcs8",
+        format: "der"
       }
-      RsaUtils2.generateKeyPair = generateKeyPair;
-    })(exports.RsaUtils || (exports.RsaUtils = {}));
+    });
+    return {
+      privateKey: privateKey.toString("base64"),
+      publicKey: publicKey.toString("base64")
+    };
+  } catch (error) {
+    throw new WaffoError(
+      WaffoErrorCode.SIGN_FAILED,
+      `Failed to generate key pair: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
   }
-});
+}
+var RsaUtils = {
+  sign,
+  verify,
+  validatePrivateKey,
+  validatePublicKey,
+  generateKeyPair
+};
 
 // src/types/config/waffo-config.ts
+var WaffoConfigEnvVars = {
+  API_KEY: "WAFFO_API_KEY",
+  PRIVATE_KEY: "WAFFO_PRIVATE_KEY",
+  PUBLIC_KEY: "WAFFO_PUBLIC_KEY",
+  MERCHANT_ID: "WAFFO_MERCHANT_ID",
+  ENVIRONMENT: "WAFFO_ENVIRONMENT"
+};
+var WaffoConfigDefaults = {
+  CONNECT_TIMEOUT: 1e4,
+  READ_TIMEOUT: 3e4
+};
 function createWaffoConfig(config) {
   if (!config.apiKey) {
     throw new Error("apiKey is required");
@@ -311,12 +274,12 @@ function createWaffoConfig(config) {
   if (!config.merchantId) {
     throw new Error("merchantId is required");
   }
-  exports.RsaUtils.validatePrivateKey(config.privateKey);
-  exports.RsaUtils.validatePublicKey(config.waffoPublicKey);
+  RsaUtils.validatePrivateKey(config.privateKey);
+  RsaUtils.validatePublicKey(config.waffoPublicKey);
   return {
     ...config,
-    connectTimeout: config.connectTimeout ?? exports.WaffoConfigDefaults.CONNECT_TIMEOUT,
-    readTimeout: config.readTimeout ?? exports.WaffoConfigDefaults.READ_TIMEOUT
+    connectTimeout: config.connectTimeout ?? WaffoConfigDefaults.CONNECT_TIMEOUT,
+    readTimeout: config.readTimeout ?? WaffoConfigDefaults.READ_TIMEOUT
   };
 }
 function fromEnv() {
@@ -346,44 +309,6 @@ function fromEnv() {
     merchantId
   });
 }
-var WaffoConfigEnvVars; exports.WaffoConfigDefaults = void 0;
-var init_waffo_config = __esm({
-  "src/types/config/waffo-config.ts"() {
-    init_environment();
-    init_rsa_utils();
-    WaffoConfigEnvVars = {
-      API_KEY: "WAFFO_API_KEY",
-      PRIVATE_KEY: "WAFFO_PRIVATE_KEY",
-      PUBLIC_KEY: "WAFFO_PUBLIC_KEY",
-      MERCHANT_ID: "WAFFO_MERCHANT_ID",
-      ENVIRONMENT: "WAFFO_ENVIRONMENT"
-    };
-    exports.WaffoConfigDefaults = {
-      CONNECT_TIMEOUT: 1e4,
-      READ_TIMEOUT: 3e4
-    };
-  }
-});
-
-// src/types/config/index.ts
-var config_exports = {};
-__export(config_exports, {
-  Environment: () => exports.Environment,
-  EnvironmentBaseUrl: () => exports.EnvironmentBaseUrl,
-  WaffoConfigDefaults: () => exports.WaffoConfigDefaults,
-  WaffoConfigEnvVars: () => WaffoConfigEnvVars,
-  createWaffoConfig: () => createWaffoConfig,
-  fromEnv: () => fromEnv
-});
-var init_config = __esm({
-  "src/types/config/index.ts"() {
-    init_environment();
-    init_waffo_config();
-  }
-});
-
-// src/core/waffo-http-client.ts
-init_config();
 
 // src/types/api-response.ts
 var ApiResponse = class _ApiResponse {
@@ -531,9 +456,6 @@ var DefaultHttpTransport = class {
 };
 
 // src/core/waffo-http-client.ts
-init_rsa_utils();
-init_waffo_error();
-init_waffo_unknown_status_error();
 var HEADER_API_KEY = "x-api-key";
 var HEADER_SIGNATURE = "x-signature";
 var HEADER_API_VERSION = "x-api-version";
@@ -541,7 +463,7 @@ var HEADER_SDK_VERSION = "x-sdk-version";
 var HEADER_CONTENT_TYPE = "content-type";
 var CONTENT_TYPE_JSON = "application/json";
 var API_VERSION = "1.0.0";
-var SDK_VERSION = "waffo-node/1.0.0";
+var SDK_VERSION = "waffo-node/2.2.0";
 var WaffoHttpClient = class {
   baseUrl;
   apiKey;
@@ -553,13 +475,13 @@ var WaffoHttpClient = class {
   logger;
   httpTransport;
   constructor(config) {
-    this.baseUrl = exports.EnvironmentBaseUrl[config.environment];
+    this.baseUrl = EnvironmentBaseUrl[config.environment];
     this.apiKey = config.apiKey;
     this.privateKey = config.privateKey;
     this.waffoPublicKey = config.waffoPublicKey;
     this.merchantId = config.merchantId;
-    this.connectTimeout = config.connectTimeout ?? exports.WaffoConfigDefaults.CONNECT_TIMEOUT;
-    this.readTimeout = config.readTimeout ?? exports.WaffoConfigDefaults.READ_TIMEOUT;
+    this.connectTimeout = config.connectTimeout ?? WaffoConfigDefaults.CONNECT_TIMEOUT;
+    this.readTimeout = config.readTimeout ?? WaffoConfigDefaults.READ_TIMEOUT;
     this.logger = config.logger;
     this.httpTransport = config.httpTransport ?? new DefaultHttpTransport();
   }
@@ -579,7 +501,7 @@ var WaffoHttpClient = class {
     try {
       this.injectMerchantIdIfNeeded(request);
       const requestBody = JSON.stringify(request);
-      const signature = exports.RsaUtils.sign(requestBody, this.privateKey);
+      const signature = RsaUtils.sign(requestBody, this.privateKey);
       this.logger?.debug(`Request URL: ${url}`);
       this.logger?.debug(`Request Body: ${requestBody}`);
       const httpResponse = await this.httpTransport.send({
@@ -600,7 +522,7 @@ var WaffoHttpClient = class {
       this.logger?.debug(`Response Body: ${httpResponse.body}`);
       const responseSignature = httpResponse.headers[HEADER_SIGNATURE];
       if (responseSignature) {
-        const isValid = exports.RsaUtils.verify(
+        const isValid = RsaUtils.verify(
           httpResponse.body,
           responseSignature,
           this.waffoPublicKey
@@ -608,27 +530,27 @@ var WaffoHttpClient = class {
         if (!isValid) {
           this.logger?.error("Response signature verification failed");
           return ApiResponse.error(
-            exports.WaffoErrorCode.VERIFY_FAILED,
+            WaffoErrorCode.VERIFY_FAILED,
             "Response signature verification failed"
           );
         }
       }
       const response = this.parseResponse(httpResponse.body);
       if (response.code === "E0001") {
-        throw new exports.WaffoUnknownStatusError(
-          exports.WaffoUnknownStatusError.CODE_UNKNOWN_STATUS,
+        throw new WaffoUnknownStatusError(
+          WaffoUnknownStatusError.CODE_UNKNOWN_STATUS,
           response.getMessage() ?? "Unknown status from server"
         );
       }
       return response;
     } catch (error) {
-      if (error instanceof exports.WaffoUnknownStatusError) {
+      if (error instanceof WaffoUnknownStatusError) {
         throw error;
       }
       if (this.isNetworkError(error)) {
         this.logger?.error("Network error", error);
-        throw new exports.WaffoUnknownStatusError(
-          exports.WaffoUnknownStatusError.CODE_NETWORK_ERROR,
+        throw new WaffoUnknownStatusError(
+          WaffoUnknownStatusError.CODE_NETWORK_ERROR,
           `Network error, payment status unknown: ${error instanceof Error ? error.message : String(error)}`,
           error instanceof Error ? error : void 0
         );
@@ -636,13 +558,13 @@ var WaffoHttpClient = class {
       if (error instanceof SyntaxError) {
         this.logger?.error("JSON serialization error", error);
         return ApiResponse.error(
-          exports.WaffoErrorCode.SERIALIZE_FAILED,
+          WaffoErrorCode.SERIALIZE_FAILED,
           `Request serialization failed: ${error.message}`
         );
       }
       this.logger?.error("Unexpected error", error);
       return ApiResponse.error(
-        exports.WaffoErrorCode.UNEXPECTED,
+        WaffoErrorCode.UNEXPECTED,
         `Unexpected error: ${error instanceof Error ? error.message : String(error)}`
       );
     }
@@ -690,12 +612,10 @@ var WaffoHttpClient = class {
 };
 
 // src/core/webhook-handler.ts
-init_rsa_utils();
 var WebhookEventType = /* @__PURE__ */ ((WebhookEventType2) => {
   WebhookEventType2["PAYMENT_NOTIFICATION"] = "PAYMENT_NOTIFICATION";
   WebhookEventType2["REFUND_NOTIFICATION"] = "REFUND_NOTIFICATION";
   WebhookEventType2["SUBSCRIPTION_STATUS_NOTIFICATION"] = "SUBSCRIPTION_STATUS_NOTIFICATION";
-  WebhookEventType2["SUBSCRIPTION_PAYMENT_NOTIFICATION"] = "SUBSCRIPTION_PAYMENT_NOTIFICATION";
   WebhookEventType2["SUBSCRIPTION_PERIOD_CHANGED_NOTIFICATION"] = "SUBSCRIPTION_PERIOD_CHANGED_NOTIFICATION";
   return WebhookEventType2;
 })(WebhookEventType || {});
@@ -735,7 +655,8 @@ var WebhookHandler = class {
     return this;
   }
   /**
-   * Registers a handler for subscription payment notifications.
+   * Registers a fallback handler for SUBSCRIPTION_STATUS_NOTIFICATION events.
+   * Only called when onSubscriptionStatus handler is not registered.
    */
   onSubscriptionPayment(handler) {
     this.subscriptionPaymentHandler = handler;
@@ -761,7 +682,7 @@ var WebhookHandler = class {
         this.logger?.warn("Missing webhook signature");
         return this.createFailedResult("Missing signature");
       }
-      const isValid = exports.RsaUtils.verify(body, signature, this.waffoPublicKey);
+      const isValid = RsaUtils.verify(body, signature, this.waffoPublicKey);
       if (!isValid) {
         this.logger?.error("Invalid webhook signature");
         return this.createFailedResult("Invalid signature");
@@ -782,10 +703,7 @@ var WebhookHandler = class {
         case "SUBSCRIPTION_STATUS_NOTIFICATION" /* SUBSCRIPTION_STATUS_NOTIFICATION */:
           if (this.subscriptionStatusHandler) {
             await this.subscriptionStatusHandler(parsed);
-          }
-          break;
-        case "SUBSCRIPTION_PAYMENT_NOTIFICATION" /* SUBSCRIPTION_PAYMENT_NOTIFICATION */:
-          if (this.subscriptionPaymentHandler) {
+          } else if (this.subscriptionPaymentHandler) {
             await this.subscriptionPaymentHandler(parsed);
           }
           break;
@@ -814,14 +732,14 @@ var WebhookHandler = class {
    * @returns true if signature is valid
    */
   verifySignature(body, signature) {
-    return exports.RsaUtils.verify(body, signature, this.waffoPublicKey);
+    return RsaUtils.verify(body, signature, this.waffoPublicKey);
   }
   /**
    * Builds a success response with signature.
    */
   buildSuccessResponse() {
     const body = JSON.stringify({ status: "success" });
-    const signature = exports.RsaUtils.sign(body, this.privateKey);
+    const signature = RsaUtils.sign(body, this.privateKey);
     return { body, signature };
   }
   /**
@@ -829,7 +747,7 @@ var WebhookHandler = class {
    */
   buildFailedResponse(message) {
     const body = JSON.stringify({ status: "failed", message });
-    const signature = exports.RsaUtils.sign(body, this.privateKey);
+    const signature = RsaUtils.sign(body, this.privateKey);
     return { body, signature };
   }
   createSuccessResult() {
@@ -1205,8 +1123,7 @@ var Waffo = class _Waffo {
    * @returns Waffo SDK instance
    */
   static fromEnv() {
-    const { WaffoConfig } = (init_config(), __toCommonJS(config_exports));
-    return new _Waffo(WaffoConfig.fromEnv());
+    return new _Waffo(fromEnv());
   }
   /**
    * Returns the order resource for managing payment orders.
@@ -1273,13 +1190,13 @@ var Waffo = class _Waffo {
    * // Setup webhook handler
    * const handler = waffo.webhook()
    *   .onPayment((notification) => {
-   *     console.log('Payment:', notification.orderStatus);
+   *     console.log('Payment:', notification.result?.orderStatus);
    *   })
    *   .onRefund((notification) => {
-   *     console.log('Refund:', notification.refundStatus);
+   *     console.log('Refund:', notification.result?.refundStatus);
    *   })
    *   .onSubscriptionStatus((notification) => {
-   *     console.log('Subscription:', notification.subscriptionStatus);
+   *     console.log('Subscription:', notification.result?.subscriptionStatus);
    *   });
    *
    * // In Express.js route handler
@@ -1306,20 +1223,21 @@ var Waffo = class _Waffo {
   }
 };
 
-// src/index.ts
-init_config();
-init_waffo_error();
-init_waffo_unknown_status_error();
-init_rsa_utils();
-
 exports.ApiResponse = ApiResponse;
+exports.Environment = Environment;
+exports.EnvironmentBaseUrl = EnvironmentBaseUrl;
 exports.MerchantConfigResource = MerchantConfigResource;
 exports.OrderResource = OrderResource;
 exports.PayMethodConfigResource = PayMethodConfigResource;
 exports.RefundResource = RefundResource;
+exports.RsaUtils = RsaUtils;
 exports.SubscriptionResource = SubscriptionResource;
 exports.Waffo = Waffo;
+exports.WaffoConfigDefaults = WaffoConfigDefaults;
+exports.WaffoError = WaffoError;
+exports.WaffoErrorCode = WaffoErrorCode;
 exports.WaffoHttpClient = WaffoHttpClient;
+exports.WaffoUnknownStatusError = WaffoUnknownStatusError;
 exports.WebhookEventType = WebhookEventType;
 exports.WebhookHandler = WebhookHandler;
 //# sourceMappingURL=index.js.map