@crediblemark/buayar 0.1.5 → 0.1.7

package/dist/index.js

@@ -32,7 +32,10 @@ var index_exports = {};
 __export(index_exports, {
   BasePaymentProvider: () => BasePaymentProvider,
   DuitkuProvider: () => DuitkuProvider,
+  MidtransClient: () => MidtransClient,
+  MidtransProvider: () => MidtransProvider,
   PaymentManager: () => PaymentManager,
+  getPaymentMethodCategory: () => getPaymentMethodCategory,
   paymentManager: () => paymentManager
 });
 module.exports = __toCommonJS(index_exports);
@@ -44,13 +47,30 @@ var import_crypto = __toESM(require("crypto"));
 var BasePaymentProvider = class {
 };
 
+// src/utils.ts
+function getPaymentMethodCategory(code, name = "") {
+  const c = code.toUpperCase();
+  const n = name.toUpperCase();
+  if (c.includes("QR") || n.includes("QRIS")) return "QRIS";
+  if (c.includes("VA") || n.includes("VA") || n.includes("VIRTUAL ACCOUNT") || ["I1", "BT", "A1", "M2", "V1", "B1", "AG", "NC", "BR", "S1", "BS", "MY"].some((p) => c.startsWith(p.slice(0, 2)))) return "Virtual Account";
+  if (["OV", "GO", "SH", "DA", "LA", "OL", "SL", "GP", "OP", "DN", "JA", "JN", "JP"].some((p) => c.startsWith(p.slice(0, 2))) || n.includes("OVO") || n.includes("DANA") || n.includes("GOPAY") || n.includes("LINKAJA") || n.includes("SHOPEEPAY") || n.includes("JENIUS")) return "E-Wallet";
+  if (c.startsWith("FT") || c.startsWith("AL") || n.includes("INDOMARET") || n.includes("ALFAMART") || n.includes("RETAIL")) return "Retail / Gerai";
+  if (c.startsWith("VC") || n.includes("CREDIT CARD") || n.includes("KARTU KREDIT")) return "Kartu Kredit";
+  if (n.includes("PAYLATER") || n.includes("INDODANA") || n.includes("AKULAKU") || n.includes("KREDIVO")) return "Paylater / Cicilan";
+  return "Lainnya";
+}
+
 // src/providers/duitku.ts
 var DuitkuProvider = class extends BasePaymentProvider {
   name = "duitku";
+  getBaseUrl(sandbox) {
+    return sandbox ? "https://api-sandbox.duitku.com" : "https://api-prod.duitku.com";
+  }
   async createInvoice(params, config) {
     const { orderId, amount, productDetails, customer, returnUrl, callbackUrl } = params;
     const { merchantCode, apiKey, sandbox } = config;
-    const url = sandbox ? "https://api-sandbox.duitku.com/api/merchant/createInvoice" : "https://api-prod.duitku.com/api/merchant/createInvoice";
+    const isDirectInquiry = !!params.paymentMethod;
+    const url = isDirectInquiry ? sandbox ? "https://sandbox.duitku.com/webapi/api/merchant/v2/inquiry" : "https://passport.duitku.com/webapi/api/merchant/v2/inquiry" : `${this.getBaseUrl(sandbox)}/api/merchant/createInvoice`;
     const integerAmount = Math.round(amount);
     const rawPayloadSignature = merchantCode + orderId + integerAmount.toString() + apiKey;
     const payloadSignature = import_crypto.default.createHash("md5").update(rawPayloadSignature).digest("hex");
@@ -67,19 +87,23 @@ var DuitkuProvider = class extends BasePaymentProvider {
       signature: payloadSignature,
       callbackUrl,
       returnUrl,
-      expiryPeriod: 1440
+      expiryPeriod: 1440,
       // 24 hours expiry
+      ...params.paymentMethod ? { paymentMethod: params.paymentMethod } : {}
     };
     try {
+      const headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+      };
+      if (!isDirectInquiry) {
+        headers["x-duitku-signature"] = headerSignature;
+        headers["x-duitku-timestamp"] = timestamp;
+        headers["x-duitku-merchantcode"] = merchantCode;
+      }
       const response = await fetch(url, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Accept": "application/json",
-          "x-duitku-signature": headerSignature,
-          "x-duitku-timestamp": timestamp,
-          "x-duitku-merchantcode": merchantCode
-        },
+        headers,
         body: JSON.stringify(payload)
       });
       const text = await response.text();
@@ -100,6 +124,10 @@ var DuitkuProvider = class extends BasePaymentProvider {
           success: true,
           paymentUrl: data.paymentUrl,
           reference: data.reference,
+          vaNumber: data.vaNumber,
+          qrString: data.qrString,
+          qrCodeUrl: data.qrCodeUrl,
+          paymentCode: data.paymentCode,
           rawResponse: data
         };
       } else {
@@ -135,6 +163,936 @@ var DuitkuProvider = class extends BasePaymentProvider {
       rawPayload: body
     };
   }
+  async getPaymentMethods(params, config) {
+    const { amount } = params;
+    const { merchantCode, apiKey, sandbox } = config;
+    const url = sandbox ? "https://sandbox.duitku.com/webapi/api/merchant/paymentmethod/getpaymentmethod" : "https://passport.duitku.com/webapi/api/merchant/paymentmethod/getpaymentmethod";
+    const integerAmount = Math.round(amount);
+    const datetime = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+    const stringToSign = merchantCode + integerAmount.toString() + datetime;
+    const signature = import_crypto.default.createHmac("sha256", apiKey).update(stringToSign).digest("hex");
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          merchantcode: merchantCode,
+          amount: integerAmount,
+          datetime,
+          signature
+        })
+      });
+      const text = await response.text();
+      let data = null;
+      try {
+        data = JSON.parse(text);
+      } catch (e) {
+      }
+      if (!response.ok || !data) {
+        return {
+          success: false,
+          methods: [],
+          rawResponse: data,
+          error: data?.responseMessage || `HTTP error! Status: ${response.status}`
+        };
+      }
+      if (data.responseCode === "00") {
+        const rawMethods = data.paymentFee || [];
+        const methods = rawMethods.map((m) => ({
+          paymentMethod: m.paymentMethod,
+          paymentName: m.paymentName,
+          paymentImage: m.paymentImage,
+          totalFee: m.totalFee,
+          category: getPaymentMethodCategory(m.paymentMethod, m.paymentName)
+        }));
+        return {
+          success: true,
+          methods,
+          rawResponse: data
+        };
+      } else {
+        return {
+          success: false,
+          methods: [],
+          rawResponse: data,
+          error: data.responseMessage || `Duitku Error: ${data.responseCode}`
+        };
+      }
+    } catch (e) {
+      return {
+        success: false,
+        methods: [],
+        rawResponse: null,
+        error: e.message || "Failed to get payment methods from Duitku"
+      };
+    }
+  }
+  async checkTransaction(params, config) {
+    const { merchantOrderId } = params;
+    const { merchantCode, apiKey, sandbox } = config;
+    const url = sandbox ? "https://api-sandbox.duitku.com/api/merchant/transactionStatus" : "https://api-prod.duitku.com/api/merchant/transactionStatus";
+    const timestamp = Date.now().toString();
+    const rawHeaderSignature = merchantCode + timestamp + apiKey;
+    const headerSignature = import_crypto.default.createHash("sha256").update(rawHeaderSignature).digest("hex");
+    const rawBodySignature = merchantCode + merchantOrderId + apiKey;
+    const bodySignature = import_crypto.default.createHash("md5").update(rawBodySignature).digest("hex");
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "application/json",
+          "x-duitku-signature": headerSignature,
+          "x-duitku-timestamp": timestamp,
+          "x-duitku-merchantcode": merchantCode
+        },
+        body: JSON.stringify({
+          merchantCode,
+          merchantOrderId,
+          signature: bodySignature
+        })
+      });
+      const text = await response.text();
+      let data = null;
+      try {
+        data = JSON.parse(text);
+      } catch (e) {
+      }
+      if (!response.ok || !data) {
+        return {
+          success: false,
+          orderId: merchantOrderId,
+          reference: "",
+          amount: 0,
+          statusCode: "",
+          status: "failed",
+          statusMessage: `HTTP error! Status: ${response.status}`,
+          error: `HTTP ${response.status}`,
+          rawResponse: data
+        };
+      }
+      const statusCode = data.statusCode || "";
+      let status;
+      if (statusCode === "00") {
+        status = "paid";
+      } else if (statusCode === "01") {
+        status = "pending";
+      } else {
+        status = "failed";
+      }
+      return {
+        success: true,
+        orderId: data.merchantOrderId || merchantOrderId,
+        reference: data.reference || "",
+        amount: data.amount ? Number(data.amount) : 0,
+        statusCode,
+        status,
+        statusMessage: data.statusMessage || "",
+        rawResponse: data
+      };
+    } catch (e) {
+      return {
+        success: false,
+        orderId: merchantOrderId,
+        reference: "",
+        amount: 0,
+        statusCode: "",
+        status: "failed",
+        statusMessage: "Network error",
+        error: e.message || "Failed to check transaction status",
+        rawResponse: null
+      };
+    }
+  }
+  async probePaymentMethods(config) {
+    const res = await this.getPaymentMethods({ amount: 1e4 }, config);
+    if (res.success) {
+      return { success: true, enabled: res.methods.map((m) => m.paymentMethod) };
+    }
+    return { success: false, enabled: [], error: res.error };
+  }
+};
+
+// src/providers/midtrans.ts
+var import_crypto2 = __toESM(require("crypto"));
+
+// src/clients/midtrans.ts
+var MidtransClient = class {
+  apiKey;
+  sandbox;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.sandbox = config.sandbox;
+  }
+  getApiBaseUrl() {
+    return this.sandbox ? "https://api.sandbox.midtrans.com/v2" : "https://api.midtrans.com/v2";
+  }
+  async request(method, path, body) {
+    let url = path.startsWith("http") ? path : `${this.getApiBaseUrl()}${path}`;
+    if (!path.startsWith("http") && (path.startsWith("/v1/") || path.startsWith("/v2/"))) {
+      url = `${this.sandbox ? "https://api.sandbox.midtrans.com" : "https://api.midtrans.com"}${path}`;
+    }
+    const authHeader = `Basic ${Buffer.from(this.apiKey + ":").toString("base64")}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "Authorization": authHeader
+    };
+    const fetchOptions = {
+      method,
+      headers
+    };
+    if (body) {
+      fetchOptions.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, fetchOptions);
+    const text = await response.text();
+    let data = null;
+    try {
+      data = JSON.parse(text);
+    } catch (e) {
+    }
+    if (!response.ok) {
+      throw new Error(data?.message || data?.status_message || `HTTP error! Status: ${response.status} - ${text}`);
+    }
+    return data || text;
+  }
+  // ─── TRANSACTION ACTIONS ─────────────────────────────────────────────────────
+  async cancelTransaction(orderId) {
+    return this.request("POST", `/${orderId}/cancel`, null);
+  }
+  async refundTransaction(orderId, payload) {
+    return this.request("POST", `/${orderId}/refund`, payload);
+  }
+  async expireTransaction(orderId) {
+    return this.request("POST", `/${orderId}/expire`, null);
+  }
+  async approveTransaction(orderId) {
+    return this.request("POST", `/${orderId}/approve`, null);
+  }
+  async denyTransaction(orderId) {
+    return this.request("POST", `/${orderId}/deny`, null);
+  }
+  async captureTransaction(transactionId, amount) {
+    const payload = amount ? { transaction_id: transactionId, gross_amount: Math.round(amount) } : { transaction_id: transactionId };
+    return this.request("POST", "/capture", payload);
+  }
+  // ─── GOPAY TOKENIZATION API ──────────────────────────────────────────────────
+  async linkPayAccount(payload) {
+    return this.request("POST", "/v2/pay/account", payload);
+  }
+  async getPayAccount(accountId) {
+    return this.request("GET", `/v2/pay/account/${accountId}`, null);
+  }
+  async unbindPayAccount(accountId) {
+    return this.request("POST", `/v2/pay/account/${accountId}/unbind`, null);
+  }
+  async getGoPayPromo(accountId, grossAmount, currency = "IDR") {
+    return this.request("GET", `/v2/gopay/promo/${accountId}?gross_amount=${grossAmount}&currency=${currency}`, null);
+  }
+  // ─── SUBSCRIPTION API ────────────────────────────────────────────────────────
+  async createSubscription(payload) {
+    return this.request("POST", "/v1/subscriptions", payload);
+  }
+  async getSubscription(subscriptionId) {
+    return this.request("GET", `/v1/subscriptions/${subscriptionId}`, null);
+  }
+  async updateSubscription(subscriptionId, payload) {
+    return this.request("PATCH", `/v1/subscriptions/${subscriptionId}`, payload);
+  }
+  async disableSubscription(subscriptionId) {
+    return this.request("POST", `/v1/subscriptions/${subscriptionId}/disable`, null);
+  }
+  async enableSubscription(subscriptionId) {
+    return this.request("POST", `/v1/subscriptions/${subscriptionId}/enable`, null);
+  }
+  // ─── PAYMENT LINK API ────────────────────────────────────────────────────────
+  async createPaymentLink(payload) {
+    return this.request("POST", "/v1/payment-links", payload);
+  }
+  async getPaymentLink(paymentLinkId) {
+    return this.request("GET", `/v1/payment-links/${paymentLinkId}`, null);
+  }
+  async deletePaymentLink(paymentLinkId) {
+    return this.request("DELETE", `/v1/payment-links/${paymentLinkId}`, null);
+  }
+  // ─── BALANCE API ─────────────────────────────────────────────────────────────
+  async getBalance() {
+    try {
+      return await this.request("GET", "/v1/balance", null);
+    } catch (e) {
+      try {
+        const irisUrl = `${this.sandbox ? "https://api.sandbox.midtrans.com" : "https://api.midtrans.com"}/iris/api/v1/balance`;
+        const authHeader = `Basic ${Buffer.from(this.apiKey + ":").toString("base64")}`;
+        const response = await fetch(irisUrl, {
+          method: "GET",
+          headers: {
+            "Accept": "application/json",
+            "Authorization": authHeader
+          }
+        });
+        const text = await response.text();
+        let data = null;
+        try {
+          data = JSON.parse(text);
+        } catch (err) {
+        }
+        if (response.ok) return data || text;
+      } catch (irisErr) {
+      }
+      throw e;
+    }
+  }
+  // ─── INVOICING API ───────────────────────────────────────────────────────────
+  async createBillingInvoice(payload) {
+    return this.request("POST", "/v1/invoices", payload);
+  }
+  async getBillingInvoice(invoiceId) {
+    return this.request("GET", `/v1/invoices/${invoiceId}`, null);
+  }
+  async voidBillingInvoice(invoiceId) {
+    return this.request("PATCH", `/v1/invoices/${invoiceId}/void`, null);
+  }
+  async convertBillingInvoice(invoiceId) {
+    return this.request("PATCH", `/v1/invoices/${invoiceId}/convert`, null);
+  }
+};
+
+// src/providers/midtrans.ts
+var MidtransProvider = class extends BasePaymentProvider {
+  name = "midtrans";
+  getSnapBaseUrl(sandbox) {
+    return sandbox ? "https://app.sandbox.midtrans.com/snap/v1/transactions" : "https://app.midtrans.com/snap/v1/transactions";
+  }
+  getApiBaseUrl(sandbox) {
+    return sandbox ? "https://api.sandbox.midtrans.com/v2" : "https://api.midtrans.com/v2";
+  }
+  async createInvoice(params, config) {
+    const { orderId, amount, productDetails, customer, returnUrl } = params;
+    const { apiKey, sandbox } = config;
+    const integerAmount = Math.round(amount);
+    const method = params.paymentMethod?.toLowerCase() || "";
+    const coreApiMethods = [
+      "bca_va",
+      "bni_va",
+      "bri_va",
+      "permata_va",
+      "cimb_va",
+      "danamon_va",
+      "bsi_va",
+      "seabank_va",
+      "mandiri_va",
+      "qris",
+      "gopay",
+      "shopeepay",
+      "ovo",
+      "dana",
+      "linkaja",
+      "alfamart",
+      "indomaret",
+      "credit_card",
+      "googlepay",
+      "kredivo",
+      "akulaku"
+    ];
+    if (method && coreApiMethods.includes(method)) {
+      const url2 = `${this.getApiBaseUrl(sandbox)}/charge`;
+      let payload2 = {
+        transaction_details: {
+          order_id: orderId,
+          gross_amount: integerAmount
+        },
+        customer_details: {
+          first_name: customer.name,
+          email: customer.email,
+          phone: customer.phone || ""
+        },
+        item_details: [
+          {
+            id: orderId,
+            price: integerAmount,
+            quantity: 1,
+            name: productDetails.length > 50 ? productDetails.substring(0, 47) + "..." : productDetails
+          }
+        ],
+        ...params.providerParams
+      };
+      if (["bca_va", "bni_va", "bri_va", "cimb_va", "permata_va", "danamon_va", "bsi_va", "seabank_va"].includes(method)) {
+        const bankName = method.split("_")[0];
+        payload2.payment_type = "bank_transfer";
+        payload2.bank_transfer = {
+          bank: bankName
+        };
+      } else if (method === "mandiri_va") {
+        payload2.payment_type = "echannel";
+        payload2.echannel = {
+          bill_info1: "Payment for",
+          bill_info2: productDetails.length > 30 ? productDetails.substring(0, 27) + "..." : productDetails
+        };
+      } else if (method === "qris") {
+        payload2.payment_type = "qris";
+      } else if (method === "gopay") {
+        payload2.payment_type = "gopay";
+        payload2.gopay = {
+          enable_callback: true,
+          callback_url: returnUrl
+        };
+      } else if (method === "shopeepay") {
+        payload2.payment_type = "shopeepay";
+        payload2.shopeepay = {
+          callback_url: returnUrl
+        };
+      } else if (method === "ovo") {
+        if (!customer.phone) {
+          return {
+            success: false,
+            rawResponse: null,
+            error: "OVO payment method requires a customer phone number in customer.phone"
+          };
+        }
+        payload2.payment_type = "ovo";
+        payload2.ovo = {
+          phone: customer.phone
+        };
+      } else if (method === "dana") {
+        payload2.payment_type = "dana";
+      } else if (method === "linkaja") {
+        payload2.payment_type = "linkaja";
+      } else if (method === "credit_card") {
+        const token = params.providerParams?.credit_card?.token_id || params.providerParams?.tokenId;
+        if (!token) {
+          return {
+            success: false,
+            rawResponse: null,
+            error: "Credit Card payment method requires token_id (passed via providerParams.credit_card.token_id or providerParams.tokenId)"
+          };
+        }
+        payload2.payment_type = "credit_card";
+        payload2.credit_card = {
+          token_id: token,
+          authentication: params.providerParams?.credit_card?.authentication ?? true,
+          save_card: params.providerParams?.credit_card?.save_card,
+          bank: params.providerParams?.credit_card?.bank,
+          installment_term: params.providerParams?.credit_card?.installment_term,
+          bins: params.providerParams?.credit_card?.bins,
+          type: params.providerParams?.credit_card?.type
+        };
+      } else if (method === "googlepay") {
+        const token = params.providerParams?.googlepay?.token_id || params.providerParams?.tokenId;
+        if (!token) {
+          return {
+            success: false,
+            rawResponse: null,
+            error: "Google Pay payment method requires token_id (passed via providerParams.googlepay.token_id or providerParams.tokenId)"
+          };
+        }
+        payload2.payment_type = "googlepay";
+        payload2.googlepay = {
+          token_id: token
+        };
+      } else if (method === "kredivo") {
+        payload2.payment_type = "kredivo";
+        payload2.kredivo = {
+          address: params.providerParams?.kredivo?.address,
+          first_name: params.providerParams?.kredivo?.first_name || customer.name.split(" ")[0],
+          last_name: params.providerParams?.kredivo?.last_name || customer.name.split(" ").slice(1).join(" "),
+          email: params.providerParams?.kredivo?.email || customer.email,
+          phone: params.providerParams?.kredivo?.phone || customer.phone || ""
+        };
+      } else if (method === "akulaku") {
+        payload2.payment_type = "akulaku";
+      } else if (["alfamart", "indomaret"].includes(method)) {
+        payload2.payment_type = "cstore";
+        payload2.cstore = {
+          store: method,
+          message: productDetails.length > 30 ? productDetails.substring(0, 27) + "..." : productDetails
+        };
+      }
+      try {
+        const authHeader = `Basic ${Buffer.from(apiKey + ":").toString("base64")}`;
+        const response = await fetch(url2, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Authorization": authHeader
+          },
+          body: JSON.stringify(payload2)
+        });
+        const text = await response.text();
+        let data = null;
+        try {
+          data = JSON.parse(text);
+        } catch (e) {
+        }
+        if (!response.ok || !data) {
+          return {
+            success: false,
+            rawResponse: data || text,
+            error: data?.status_message || `HTTP error! Status: ${response.status} - ${text}`
+          };
+        }
+        if (data.status_code === "201" || data.status_code === "200") {
+          const res = {
+            success: true,
+            reference: data.transaction_id || data.order_id,
+            rawResponse: data
+          };
+          if (["bca_va", "bni_va", "bri_va", "cimb_va", "danamon_va", "bsi_va", "seabank_va"].includes(method)) {
+            res.vaNumber = data.va_numbers?.[0]?.va_number;
+          } else if (method === "permata_va") {
+            res.vaNumber = data.permata_va_number;
+          } else if (method === "mandiri_va") {
+            res.vaNumber = `${data.biller_code}-${data.bill_key}`;
+          } else if (method === "qris") {
+            res.qrString = data.qr_string;
+            res.qrCodeUrl = data.actions?.find((a) => a.name === "generate-qr-code")?.url;
+          } else if (["gopay", "shopeepay", "dana", "linkaja", "kredivo", "akulaku", "googlepay"].includes(method)) {
+            res.paymentUrl = data.actions?.find((a) => a.name === "deeplink-redirect")?.url || data.actions?.find((a) => a.name === "web-redirect")?.url || data.actions?.find((a) => a.name === "generate-qr-code")?.url || data.redirect_url;
+            res.qrCodeUrl = data.actions?.find((a) => a.name === "generate-qr-code")?.url;
+          } else if (method === "credit_card") {
+            res.paymentUrl = data.redirect_url || data.actions?.find((a) => a.name === "redirect")?.url;
+          } else if (method === "ovo") {
+            res.paymentUrl = "";
+          } else if (["alfamart", "indomaret"].includes(method)) {
+            res.paymentCode = data.payment_code;
+          }
+          return res;
+        } else {
+          return {
+            success: false,
+            rawResponse: data,
+            error: data.status_message || `Midtrans Core Error: ${data.status_code}`
+          };
+        }
+      } catch (e) {
+        return {
+          success: false,
+          rawResponse: null,
+          error: e.message || "Failed to make request to Midtrans Core API"
+        };
+      }
+    }
+    const url = this.getSnapBaseUrl(sandbox);
+    const payload = {
+      transaction_details: {
+        order_id: orderId,
+        gross_amount: integerAmount
+      },
+      customer_details: {
+        first_name: customer.name,
+        email: customer.email,
+        phone: customer.phone || ""
+      },
+      item_details: [
+        {
+          id: orderId,
+          price: integerAmount,
+          quantity: 1,
+          name: productDetails.length > 50 ? productDetails.substring(0, 47) + "..." : productDetails
+        }
+      ],
+      callbacks: {
+        finish: returnUrl
+      },
+      ...params.paymentMethod ? { enabled_payments: [params.paymentMethod] } : {},
+      ...params.providerParams
+    };
+    try {
+      const authHeader = `Basic ${Buffer.from(apiKey + ":").toString("base64")}`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "application/json",
+          "Authorization": authHeader
+        },
+        body: JSON.stringify(payload)
+      });
+      const text = await response.text();
+      let data = null;
+      try {
+        data = JSON.parse(text);
+      } catch (e) {
+      }
+      if (!response.ok || !data) {
+        return {
+          success: false,
+          rawResponse: data || text,
+          error: data?.error_messages?.[0] || `HTTP error! Status: ${response.status} - ${text}`
+        };
+      }
+      if (data.token) {
+        return {
+          success: true,
+          paymentUrl: data.redirect_url,
+          reference: data.token,
+          rawResponse: data
+        };
+      } else {
+        return {
+          success: false,
+          rawResponse: data,
+          error: data.error_messages?.[0] || "Failed to create Midtrans Snap transaction"
+        };
+      }
+    } catch (e) {
+      return {
+        success: false,
+        rawResponse: null,
+        error: e.message || "Failed to make request to Midtrans Snap API"
+      };
+    }
+  }
+  async verifyCallback(body, config) {
+    const { apiKey } = config;
+    const orderId = body.order_id || "";
+    const statusCode = body.status_code || "";
+    const grossAmount = body.gross_amount || "";
+    const signatureKey = body.signature_key || "";
+    const rawSignature = orderId + statusCode + grossAmount + apiKey;
+    const computedSignature = import_crypto2.default.createHash("sha512").update(rawSignature).digest("hex");
+    const isValid = signatureKey.toLowerCase() === computedSignature.toLowerCase();
+    const transactionStatus = body.transaction_status || "";
+    const fraudStatus = body.fraud_status || "";
+    let status = "pending";
+    if (transactionStatus === "capture" || transactionStatus === "settlement") {
+      if (fraudStatus === "accept" || !fraudStatus) {
+        status = "paid";
+      } else if (fraudStatus === "challenge") {
+        status = "pending";
+      } else {
+        status = "failed";
+      }
+    } else if (transactionStatus === "pending") {
+      status = "pending";
+    } else if (["deny", "cancel", "expire"].includes(transactionStatus)) {
+      status = "failed";
+    }
+    return {
+      isValid,
+      orderId,
+      amount: grossAmount ? Number(grossAmount) : 0,
+      status: isValid ? status : "failed",
+      rawPayload: body
+    };
+  }
+  async getPaymentMethods(params, config) {
+    const staticMethods = [
+      {
+        paymentMethod: "credit_card",
+        paymentName: "Credit / Debit Card",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/credit_card.png",
+        totalFee: "2.9% + IDR 2,000",
+        category: "Kartu Kredit"
+      },
+      {
+        paymentMethod: "googlepay",
+        paymentName: "Google Pay\u2122",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/googlepay.png",
+        totalFee: "2.9% + IDR 2,000",
+        category: "Kartu Kredit"
+      },
+      {
+        paymentMethod: "bca_va",
+        paymentName: "BCA Virtual Account",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/bca_va.png",
+        totalFee: "IDR 4,000",
+        category: "Virtual Account"
+      },
+      {
+        paymentMethod: "bni_va",
+        paymentName: "BNI Virtual Account",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/bni_va.png",
+        totalFee: "IDR 4,000",
+        category: "Virtual Account"
+      },
+      {
+        paymentMethod: "bri_va",
+        paymentName: "BRI Virtual Account",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/bri_va.png",
+        totalFee: "IDR 4,000",
+        category: "Virtual Account"
+      },
+      {
+        paymentMethod: "mandiri_va",
+        paymentName: "Mandiri Bill Payment / VA",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/mandiri_va.png",
+        totalFee: "IDR 4,000",
+        category: "Virtual Account"
+      },
+      {
+        paymentMethod: "permata_va",
+        paymentName: "Permata Virtual Account",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/permata_va.png",
+        totalFee: "IDR 4,000",
+        category: "Virtual Account"
+      },
+      {
+        paymentMethod: "cimb_va",
+        paymentName: "CIMB Virtual Account",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/cimb_va.png",
+        totalFee: "IDR 4,000",
+        category: "Virtual Account"
+      },
+      {
+        paymentMethod: "danamon_va",
+        paymentName: "Danamon Virtual Account",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/danamon_va.png",
+        totalFee: "IDR 4,000",
+        category: "Virtual Account"
+      },
+      {
+        paymentMethod: "bsi_va",
+        paymentName: "BSI Virtual Account",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/bsi_va.png",
+        totalFee: "IDR 4,000",
+        category: "Virtual Account"
+      },
+      {
+        paymentMethod: "seabank_va",
+        paymentName: "SeaBank Virtual Account",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/seabank_va.png",
+        totalFee: "IDR 4,000",
+        category: "Virtual Account"
+      },
+      {
+        paymentMethod: "other_va",
+        paymentName: "Other Banks (ATM Bersama, Prima, Alto)",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/other_va.png",
+        totalFee: "IDR 4,000",
+        category: "Virtual Account"
+      },
+      {
+        paymentMethod: "qris",
+        paymentName: "QRIS (GoPay, ShopeePay, Dana, LinkAja)",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/qris.png",
+        totalFee: "0.7%",
+        category: "QRIS"
+      },
+      {
+        paymentMethod: "other_qris",
+        paymentName: "Other QRIS",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/other_qris.png",
+        totalFee: "0.7%",
+        category: "QRIS"
+      },
+      {
+        paymentMethod: "gopay",
+        paymentName: "GoPay E-Wallet",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/gopay.png",
+        totalFee: "2.0%",
+        category: "E-Wallet"
+      },
+      {
+        paymentMethod: "shopeepay",
+        paymentName: "ShopeePay E-Wallet",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/shopeepay.png",
+        totalFee: "2.0%",
+        category: "E-Wallet"
+      },
+      {
+        paymentMethod: "ovo",
+        paymentName: "OVO E-Wallet",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/ovo.png",
+        totalFee: "1.5%",
+        category: "E-Wallet"
+      },
+      {
+        paymentMethod: "dana",
+        paymentName: "DANA E-Wallet",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/dana.png",
+        totalFee: "1.7%",
+        category: "E-Wallet"
+      },
+      {
+        paymentMethod: "linkaja",
+        paymentName: "LinkAja E-Wallet",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/linkaja.png",
+        totalFee: "1.7%",
+        category: "E-Wallet"
+      },
+      {
+        paymentMethod: "indomaret",
+        paymentName: "Indomaret",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/indomaret.png",
+        totalFee: "IDR 5,000",
+        category: "Retail / Gerai"
+      },
+      {
+        paymentMethod: "alfamart",
+        paymentName: "Alfamart / Alfamidi",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/alfamart.png",
+        totalFee: "IDR 5,000",
+        category: "Retail / Gerai"
+      },
+      {
+        paymentMethod: "kredivo",
+        paymentName: "Kredivo Paylater",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/kredivo.png",
+        totalFee: "2.3%",
+        category: "Paylater / Cicilan"
+      },
+      {
+        paymentMethod: "akulaku",
+        paymentName: "Akulaku Paylater",
+        paymentImage: "https://docs.midtrans.com/asset/payment_methods/akulaku.png",
+        totalFee: "1.7%",
+        category: "Paylater / Cicilan"
+      }
+    ];
+    return {
+      success: true,
+      methods: staticMethods,
+      rawResponse: staticMethods
+    };
+  }
+  async checkTransaction(params, config) {
+    const { merchantOrderId } = params;
+    const { apiKey, sandbox } = config;
+    const url = `${this.getApiBaseUrl(sandbox)}/${merchantOrderId}/status`;
+    try {
+      const authHeader = `Basic ${Buffer.from(apiKey + ":").toString("base64")}`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "application/json",
+          "Authorization": authHeader
+        }
+      });
+      const text = await response.text();
+      let data = null;
+      try {
+        data = JSON.parse(text);
+      } catch (e) {
+      }
+      if (!response.ok || !data) {
+        return {
+          success: false,
+          orderId: merchantOrderId,
+          reference: "",
+          amount: 0,
+          statusCode: "",
+          status: "failed",
+          statusMessage: `HTTP error! Status: ${response.status}`,
+          error: `HTTP ${response.status} - ${text}`,
+          rawResponse: data || text
+        };
+      }
+      const transactionStatus = data.transaction_status || "";
+      const fraudStatus = data.fraud_status || "";
+      let status = "pending";
+      if (transactionStatus === "capture" || transactionStatus === "settlement") {
+        if (fraudStatus === "accept" || !fraudStatus) {
+          status = "paid";
+        } else if (fraudStatus === "challenge") {
+          status = "pending";
+        } else {
+          status = "failed";
+        }
+      } else if (transactionStatus === "pending") {
+        status = "pending";
+      } else if (["deny", "cancel", "expire"].includes(transactionStatus)) {
+        status = "failed";
+      }
+      return {
+        success: true,
+        orderId: data.order_id || merchantOrderId,
+        reference: data.transaction_id || "",
+        amount: data.gross_amount ? Number(data.gross_amount) : 0,
+        statusCode: data.status_code || "",
+        status,
+        statusMessage: data.status_message || "",
+        rawResponse: data
+      };
+    } catch (e) {
+      return {
+        success: false,
+        orderId: merchantOrderId,
+        reference: "",
+        amount: 0,
+        statusCode: "",
+        status: "failed",
+        statusMessage: "Network error",
+        error: e.message || "Failed to check transaction status with Midtrans",
+        rawResponse: null
+      };
+    }
+  }
+  /**
+   * Get an instance of MidtransClient to perform transaction actions, subscriptions, invoicing, etc.
+   */
+  getClient(config) {
+    return new MidtransClient(config);
+  }
+  async probePaymentMethods(config) {
+    const { apiKey, sandbox } = config;
+    const baseUrl = sandbox ? "https://api.sandbox.midtrans.com/v2" : "https://api.midtrans.com/v2";
+    const auth = Buffer.from(apiKey + ":").toString("base64");
+    const probePayloads = {
+      qris: { payment_type: "qris", qris: { acquirer: "gopay" } },
+      gopay: { payment_type: "gopay", gopay: { enable_callback: true, callback_url: "https://example.com" } },
+      shopeepay: { payment_type: "shopeepay", shopeepay: { callback_url: "https://example.com" } },
+      bca: { payment_type: "bank_transfer", bank_transfer: { bank: "bca" } },
+      bni: { payment_type: "bank_transfer", bank_transfer: { bank: "bni" } },
+      bri: { payment_type: "bank_transfer", bank_transfer: { bank: "bri" } },
+      cimb: { payment_type: "bank_transfer", bank_transfer: { bank: "cimb" } },
+      mandiri: { payment_type: "echannel", echannel: { bill_info1: "Payment", bill_info2: "Probe" } },
+      permata: { payment_type: "permata" },
+      alfamart: { payment_type: "cstore", cstore: { store: "alfamart", message: "Probe" } },
+      indomaret: { payment_type: "cstore", cstore: { store: "indomaret", message: "Probe" } },
+      akulaku: { payment_type: "akulaku" },
+      kredivo: {
+        payment_type: "kredivo",
+        seller_details: { address: { city: "Jakarta" } }
+      }
+    };
+    const enabled = [];
+    for (const [methodId, specificPayload] of Object.entries(probePayloads)) {
+      try {
+        const probeOrderId = `PROBE-${methodId}-${Date.now()}`;
+        const probeBody = {
+          ...specificPayload,
+          transaction_details: { order_id: probeOrderId, gross_amount: 15e3 },
+          item_details: [{ id: probeOrderId, name: "Probe", price: 15e3, quantity: 1 }],
+          customer_details: { first_name: "Probe", email: "probe@test.com" }
+        };
+        const res = await fetch(`${baseUrl}/charge`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Authorization": `Basic ${auth}`
+          },
+          body: JSON.stringify(probeBody)
+        });
+        const text = await res.text();
+        let result = null;
+        try {
+          result = JSON.parse(text);
+        } catch (e) {
+        }
+        if (result && ["200", "201", "202"].includes(result.status_code)) {
+          enabled.push(methodId);
+          try {
+            await fetch(`${baseUrl}/${probeOrderId}/cancel`, {
+              method: "POST",
+              headers: {
+                "Accept": "application/json",
+                "Authorization": `Basic ${auth}`
+              }
+            });
+          } catch (e) {
+          }
+        }
+      } catch (e) {
+      }
+    }
+    return { success: true, enabled };
+  }
 };
 
 // src/index.ts
@@ -142,6 +1100,7 @@ var PaymentManager = class {
   providers = /* @__PURE__ */ new Map();
   constructor() {
     this.registerProvider(new DuitkuProvider());
+    this.registerProvider(new MidtransProvider());
   }
   registerProvider(provider) {
     this.providers.set(provider.name.toLowerCase(), provider);
@@ -153,6 +1112,12 @@ var PaymentManager = class {
     }
     return provider;
   }
+  getMidtransProvider() {
+    return this.getProvider("midtrans");
+  }
+  getMidtransClient(config) {
+    return new MidtransClient(config);
+  }
   async createInvoice(providerName, params, config) {
     const provider = this.getProvider(providerName);
     return provider.createInvoice(params, config);
@@ -161,12 +1126,30 @@ var PaymentManager = class {
     const provider = this.getProvider(providerName);
     return provider.verifyCallback(body, config);
   }
+  async getPaymentMethods(providerName, params, config) {
+    const provider = this.getProvider(providerName);
+    return provider.getPaymentMethods(params, config);
+  }
+  async checkTransaction(providerName, params, config) {
+    const provider = this.getProvider(providerName);
+    return provider.checkTransaction(params, config);
+  }
+  async probePaymentMethods(providerName, config) {
+    const provider = this.getProvider(providerName);
+    if (provider.probePaymentMethods) {
+      return provider.probePaymentMethods(config);
+    }
+    return { success: false, enabled: [], error: `Provider '${providerName}' does not support payment methods probing` };
+  }
 };
 var paymentManager = new PaymentManager();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BasePaymentProvider,
   DuitkuProvider,
+  MidtransClient,
+  MidtransProvider,
   PaymentManager,
+  getPaymentMethodCategory,
   paymentManager
 });