@crediblemark/buayar 0.4.0 → 0.6.0

package/dist/index.js

@@ -78,6 +78,7 @@ __export(index_exports, {
   PrismalinkProvider: () => PrismalinkProvider,
   RazorpayClient: () => RazorpayClient,
   RazorpayProvider: () => RazorpayProvider,
+  SnapClient: () => SnapClient,
   SquareClient: () => SquareClient,
   SquareProvider: () => SquareProvider,
   StripeClient: () => StripeClient,
@@ -101,6 +102,8 @@ __export(index_exports, {
   generateNicepayToken: () => generateNicepayToken,
   generateOyHeaders: () => generateOyHeaders,
   generatePrismalinkSignature: () => generatePrismalinkSignature,
+  generateSnapAsymmetricSignature: () => generateSnapAsymmetricSignature,
+  generateSnapSymmetricSignature: () => generateSnapSymmetricSignature,
   getDuitkuInquirySignatures: () => getDuitkuInquirySignatures,
   getDuitkuPaymentMethodsSignature: () => getDuitkuPaymentMethodsSignature,
   getDuitkuStatusSignatures: () => getDuitkuStatusSignatures,
@@ -108,6 +111,7 @@ __export(index_exports, {
   getXenditAuthHeader: () => getXenditAuthHeader,
   hmacSha256: () => hmacSha256,
   md5: () => md5,
+  minifyJson: () => minifyJson,
   parseCoreChargeResponse: () => parseCoreChargeResponse,
   paymentManager: () => paymentManager,
   resolveConfigFromEnv: () => resolveConfigFromEnv,
@@ -115,7 +119,10 @@ __export(index_exports, {
   serializePaypalParams: () => serializePaypalParams,
   serializeStripeParams: () => serializeStripeParams,
   sha256: () => sha256,
+  sha256Hex: () => sha256Hex,
   sha512: () => sha512,
+  snapExternalId: () => snapExternalId,
+  snapTimestamp: () => snapTimestamp,
   toCanonicalPaymentMethod: () => toCanonicalPaymentMethod,
   toDokuPaymentMethod: () => toDokuPaymentMethod,
   toDuitkuPaymentMethod: () => toDuitkuPaymentMethod,
@@ -141,6 +148,7 @@ __export(index_exports, {
   verifyPayuWebhook: () => verifyPayuWebhook,
   verifyPrismalinkSignature: () => verifyPrismalinkSignature,
   verifyRazorpayWebhook: () => verifyRazorpayWebhook,
+  verifySnapWebhookSignature: () => verifySnapWebhookSignature,
   verifySquareWebhook: () => verifySquareWebhook,
   verifyStripeWebhook: () => verifyStripeWebhook,
   verifyTwoCheckoutWebhook: () => verifyTwoCheckoutWebhook,
@@ -2130,11 +2138,11 @@ var XenditProvider = class extends BasePaymentProvider {
           amount: integerAmount,
           reference_id: orderId,
           description: productDetails,
-          customer: {
-            given_names: customer.name,
-            email: customer.email,
-            mobile_number: customer.phone || ""
-          },
+          // Xendit Payment Requests API rejects the inline `customer` object
+          // with API_VALIDATION_ERROR. Attribution is only supported via a
+          // pre-created `customer_id` (Customer API), so we forward that when
+          // provided through providerParams and otherwise omit customer data.
+          ...params.providerParams?.customer_id ? { customer_id: params.providerParams.customer_id } : {},
           payment_method: paymentMethodPayload,
           ...params.providerParams
         };
@@ -2563,12 +2571,218 @@ Digest:${digest}`;
   return safeCompare(incomingSignature, expectedSignature);
 }
 
+// src/providers/doku/snap.ts
+var import_crypto8 = __toESM(require("crypto"));
+function snapTimestamp(date = /* @__PURE__ */ new Date()) {
+  const wib = new Date(date.getTime() + 7 * 60 * 60 * 1e3);
+  return wib.toISOString().slice(0, 19) + "+07:00";
+}
+function minifyJson(obj) {
+  return JSON.stringify(obj);
+}
+function sha256Hex(body) {
+  const raw = typeof body === "string" ? body : minifyJson(body);
+  return import_crypto8.default.createHash("sha256").update(raw).digest("hex").toLowerCase();
+}
+function generateSnapSymmetricSignature(clientSecret, method, endpointUrl, accessToken, body, timestamp) {
+  const hash = sha256Hex(body);
+  const stringToSign = `${method}:${endpointUrl}:${accessToken}:${hash}:${timestamp}`;
+  return import_crypto8.default.createHmac("sha512", clientSecret).update(stringToSign).digest("base64");
+}
+function generateSnapAsymmetricSignature(privateKey, clientId, timestamp) {
+  const stringToSign = `${clientId}|${timestamp}`;
+  const key = import_crypto8.default.createPrivateKey(normalizePem(privateKey));
+  return import_crypto8.default.sign("RSA-SHA256", Buffer.from(stringToSign, "utf8"), key).toString("base64");
+}
+function normalizePem(key) {
+  const trimmed = key.trim();
+  if (trimmed.includes("-----BEGIN")) {
+    return trimmed;
+  }
+  return [
+    "-----BEGIN PRIVATE KEY-----",
+    trimmed.replace(/\s+/g, "").match(/.{1,64}/g)?.join("\n") || trimmed,
+    "-----END PRIVATE KEY-----"
+  ].join("\n");
+}
+function snapExternalId(prefix = "") {
+  return `${prefix}${Date.now()}${Math.floor(Math.random() * 1e3)}`;
+}
+function verifySnapWebhookSignature(headers, body, clientSecret, endpointUrl = "/api/payment/webhook") {
+  if (!clientSecret) return false;
+  const incoming = headers["x-signature"] || headers["X-SIGNATURE"] || headers["signature"] || headers["Signature"] || "";
+  if (!incoming) return false;
+  const timestamp = headers["x-timestamp"] || headers["X-TIMESTAMP"] || headers["timestamp"] || headers["Timestamp"] || snapTimestamp();
+  const computed = generateSnapSymmetricSignature(
+    clientSecret,
+    "POST",
+    endpointUrl,
+    "",
+    body,
+    timestamp
+  );
+  return safeCompare(incoming, computed);
+}
+
+// src/clients/snap.ts
+var SnapClient = class {
+  options;
+  token = null;
+  tokenExpiry = 0;
+  constructor(options) {
+    this.options = {
+      clientId: options.clientId || options.merchantCode || "",
+      clientSecret: options.clientSecret || options.apiKey || options.serverKey || options.secretKey || "",
+      privateKey: options.privateKey,
+      sandbox: !!options.sandbox,
+      merchantId: options.merchantId,
+      terminalId: options.terminalId,
+      partnerServiceId: options.partnerServiceId,
+      channelId: options.channelId || "H2H"
+    };
+  }
+  get baseUrl() {
+    return this.options.sandbox ? "https://api-sandbox.doku.com" : "https://api.doku.com";
+  }
+  get isConfigured() {
+    return Boolean(this.options.clientId && this.options.clientSecret);
+  }
+  /**
+   * Get (cached) B2B access token. Mints a new one when expired.
+   */
+  async getAccessToken() {
+    const now = Date.now();
+    if (this.token && now < this.tokenExpiry) {
+      return this.token;
+    }
+    const { clientId, clientSecret, privateKey } = this.options;
+    if (!privateKey) {
+      throw new Error("DOKU SNAP: RSA privateKey required to obtain B2B access token");
+    }
+    const endpoint = "/authorization/v1/access-token/b2b";
+    const timestamp = snapTimestamp();
+    const signature = generateSnapAsymmetricSignature(privateKey, clientId, timestamp);
+    const response = await fetch(this.baseUrl + endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-CLIENT-KEY": clientId,
+        "X-TIMESTAMP": timestamp,
+        "X-SIGNATURE": signature
+      },
+      body: JSON.stringify({ grantType: "client_credentials" })
+    });
+    const text = await response.text();
+    let data = null;
+    try {
+      data = JSON.parse(text);
+    } catch {
+    }
+    if (!response.ok || !data?.accessToken) {
+      throw new Error(data?.responseMessage || data?.message || `DOKU SNAP get-token failed: HTTP ${response.status} - ${text}`);
+    }
+    if (!clientSecret) {
+    }
+    this.token = data.accessToken;
+    const expiresIn = Number(data.expiresIn || 900);
+    this.tokenExpiry = now + (expiresIn - 30) * 1e3;
+    return this.token;
+  }
+  clearToken() {
+    this.token = null;
+    this.tokenExpiry = 0;
+  }
+  /**
+   * Perform a signed SNAP transaction request.
+   * @param method        GET/POST
+   * @param endpoint      request-target path (e.g. /virtual-accounts/...)
+   * @param body          request body (object)
+   * @param opts          extra headers (X-DEVICE-ID, X-IP-ADDRESS, etc.)
+   */
+  async request(method, endpoint, body, opts = {}) {
+    const { clientId, clientSecret, channelId } = this.options;
+    if (!clientSecret) {
+      throw new Error("DOKU SNAP: clientSecret (Secret Key) required for transaction signing");
+    }
+    const accessToken = await this.getAccessToken();
+    const timestamp = snapTimestamp();
+    const externalId = opts.externalId || snapExternalId();
+    const payload = body === void 0 ? "" : body;
+    const signature = generateSnapSymmetricSignature(
+      clientSecret,
+      method,
+      endpoint,
+      accessToken,
+      payload,
+      timestamp
+    );
+    const headers = {
+      "Content-Type": "application/json",
+      "X-PARTNER-ID": clientId,
+      "X-EXTERNAL-ID": externalId,
+      "X-TIMESTAMP": timestamp,
+      "X-SIGNATURE": signature,
+      "CHANNEL-ID": channelId || "H2H",
+      "Authorization": `Bearer ${accessToken}`,
+      ...opts.deviceId ? { "X-DEVICE-ID": opts.deviceId } : {},
+      ...opts.ipAddress ? { "X-IP-ADDRESS": opts.ipAddress } : {},
+      ...opts.extraHeaders || {}
+    };
+    const response = await fetch(this.baseUrl + endpoint, {
+      method,
+      headers,
+      body: method === "POST" && body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    const text = await response.text();
+    let data = null;
+    try {
+      data = JSON.parse(text);
+    } catch {
+    }
+    if (!response.ok) {
+      const err = data?.responseMessage || data?.error?.message || data?.message || `HTTP ${response.status}`;
+      throw new Error(`${err}${data?.responseCode ? ` (${data.responseCode})` : ""}`);
+    }
+    return data;
+  }
+};
+
 // src/providers/doku/provider.ts
 var DokuProvider = class extends BasePaymentProvider {
   name = "doku";
   getBaseUrl(sandbox) {
     return sandbox ? "https://api-sandbox.doku.com" : "https://api.doku.com";
   }
+  /**
+   * DETEKSI mode integrasi DOKU:
+   * - SNAP  : kredensial baru (Client ID `doku_...` + Secret Key `SK-...`) + opsional RSA privateKey
+   *           untuk Get Token B2B. Diaktifkan via extra.snap / extra.dokuMode="snap" / doku_ prefix.
+   * - Legacy: Jokul v2 (Client-Id + Signature HMAC-SHA256), default jika bukan SNAP.
+   */
+  isSnap(config) {
+    if (config.extra?.snap === true || config.extra?.snap === "true") return true;
+    if (config.extra?.dokuMode === "snap") return true;
+    const clientId = String(config.merchantCode || config.merchantId || config.clientKey || "").trim().toLowerCase();
+    return /^doku[_:-]/.test(clientId);
+  }
+  buildSnap(config) {
+    const clientId = config.merchantCode || config.merchantId || config.clientKey || "";
+    const clientSecret = config.apiKey || config.serverKey || config.secretKey || "";
+    return new SnapClient({
+      clientId,
+      clientSecret,
+      privateKey: config.privateKey,
+      sandbox: !!config.sandbox,
+      merchantId: config.extra?.merchantId || config.projectId || "",
+      terminalId: config.extra?.terminalId || "",
+      partnerServiceId: config.extra?.partnerServiceId || "",
+      channelId: config.extra?.channelId || "H2H"
+    });
+  }
+  /** Helper: jumlah integer → format SNAP 2-desimal (".00"). */
+  snapAmount(amount, currency = "IDR") {
+    return { value: amount.toFixed(2), currency };
+  }
   async createInvoice(params, config) {
     const { orderId, amount, productDetails, customer, returnUrl } = params;
     const clientId = config.merchantCode || config.merchantId || config.clientKey || "";
@@ -2579,6 +2793,9 @@ var DokuProvider = class extends BasePaymentProvider {
     const isDirect = !!dokuMethod;
     const baseUrl = this.getBaseUrl(sandbox);
     try {
+      if (this.isSnap(config)) {
+        return await this.createSnapInvoice(params, config, baseUrl);
+      }
       if (isDirect) {
         const endpoint = dokuMethod.endpoint;
         const url = `${baseUrl}${endpoint}`;
@@ -2766,7 +2983,178 @@ var DokuProvider = class extends BasePaymentProvider {
       };
     }
   }
+  /**
+   * DOKU SNAP: buat transaksi (Create VA / Generate QRIS / e-Wallet Payment).
+   * Autentikasi via B2B token + symmetric HMAC-SHA512 signature.
+   */
+  async createSnapInvoice(params, config, baseUrl) {
+    const { orderId, amount, productDetails, customer, returnUrl } = params;
+    const snap = this.buildSnap(config);
+    const integerAmount = Math.round(amount);
+    const method = String(params.paymentMethod || "").toLowerCase();
+    const bankMap = {
+      bca: "VIRTUAL_ACCOUNT_BCA",
+      mandiri: "VIRTUAL_ACCOUNT_BANK_MANDIRI",
+      bri: "VIRTUAL_ACCOUNT_BRI",
+      bni: "VIRTUAL_ACCOUNT_BNI",
+      permata: "VIRTUAL_ACCOUNT_BANK_PERMATA",
+      cimb: "VIRTUAL_ACCOUNT_BANK_CIMB",
+      danamon: "VIRTUAL_ACCOUNT_BANK_DANAMON",
+      bsi: "VIRTUAL_ACCOUNT_BANK_SYARIAH_MANDIRI",
+      sinarmas: "VIRTUAL_ACCOUNT_SINARMAS",
+      bjb: "VIRTUAL_ACCOUNT_BANK_BJB",
+      btn: "VIRTUAL_ACCOUNT_BTN",
+      bnc: "VIRTUAL_ACCOUNT_BNC"
+    };
+    const isVa = method.includes("_va");
+    const isQris = method === "qris" || method.includes("qris");
+    try {
+      if (isVa) {
+        return await this.snapCreateVA(params, config, snap, baseUrl, bankMap);
+      }
+      if (isQris) {
+        return await this.snapGenerateQRIS(params, config, snap, baseUrl);
+      }
+      return await this.snapEWalletPayment(params, config, snap, baseUrl);
+    } catch (e) {
+      return {
+        success: false,
+        provider: "doku",
+        orderId,
+        amount: integerAmount,
+        rawResponse: null,
+        error: e.message || "Failed to make SNAP request to DOKU API"
+      };
+    }
+  }
+  /** Create Virtual Account (SNAP) — DOKU Generate Payment Code. */
+  async snapCreateVA(params, config, snap, baseUrl, bankMap) {
+    const { orderId, amount, productDetails, customer } = params;
+    const method = String(params.paymentMethod || "").toLowerCase();
+    const bankKey = method.replace(/_va$/, "");
+    const channel = config.extra?.vaChannel || bankMap[bankKey] || `VIRTUAL_ACCOUNT_${bankKey.toUpperCase()}`;
+    const partnerServiceId = (config.extra?.partnerServiceId || "").replace(/\s/g, "");
+    const customerNo = (config.extra?.customerNo || "").slice(0, 20) || String(Date.now()).slice(-12);
+    const virtualAccountNo = (partnerServiceId + customerNo).slice(0, 28);
+    const reusable = config.extra?.reusableStatus === true;
+    const currency = params.currency || "IDR";
+    const body = {
+      partnerServiceId,
+      customerNo,
+      virtualAccountNo,
+      virtualAccountName: customer.name || "Customer",
+      virtualAccountEmail: customer.email,
+      virtualAccountPhone: customer.phone,
+      trxId: orderId,
+      totalAmount: this.snapAmount(amount, currency),
+      virtualAccountTrxType: "C",
+      additionalInfo: {
+        channel,
+        virtualAccountConfig: { reusableStatus: reusable }
+      }
+    };
+    if (params.providerParams) {
+      Object.assign(body.additionalInfo.virtualAccountConfig, params.providerParams);
+    }
+    if (config.extra?.expiredDate) body.expiredDate = config.extra.expiredDate;
+    const endpoint = "/virtual-accounts/bi-snap-va/v1.1/transfer-va/create-va";
+    const data = await snap.request("POST", endpoint, body);
+    const vaData = data.virtualAccountData || {};
+    return {
+      success: true,
+      provider: "doku",
+      orderId: vaData.trxId || orderId,
+      amount: Number(vaData.totalAmount?.value || amount) || Math.round(amount),
+      reference: vaData.virtualAccountNo || orderId,
+      vaNumber: vaData.virtualAccountNo,
+      vaBank: bankKey.toUpperCase(),
+      paymentUrl: vaData.additionalInfo?.howToPayPage,
+      expiresAt: vaData.expiredDate ? new Date(vaData.expiredDate) : void 0,
+      rawResponse: data
+    };
+  }
+  /** Generate QRIS (SNAP) — dynamic QRIS MPM. */
+  async snapGenerateQRIS(params, config, snap, baseUrl) {
+    const { orderId, amount } = params;
+    const currency = params.currency || "IDR";
+    const merchantId = config.extra?.merchantId || config.projectId || "";
+    const terminalId = config.extra?.terminalId || "0001";
+    const body = {
+      partnerReferenceNo: orderId,
+      amount: this.snapAmount(amount, currency),
+      merchantId,
+      terminalId,
+      validityPeriod: config.extra?.validityPeriod || new Date(Date.now() + 3600 * 1e3).toISOString(),
+      additionalInfo: {
+        postalCode: config.extra?.postalCode || "10110",
+        feeType: 1
+      }
+    };
+    if (params.providerParams) {
+      Object.assign(body.additionalInfo, params.providerParams);
+    }
+    const endpoint = "/snap-adapter/b2b/v1.0/qr/qr-mpm-generate";
+    const data = await snap.request("POST", endpoint, body);
+    return {
+      success: true,
+      provider: "doku",
+      orderId: data.partnerReferenceNo || orderId,
+      amount: Number(data.amount?.value || amount) || Math.round(amount),
+      reference: data.referenceNo || orderId,
+      qrString: data.qrContent,
+      rawResponse: data
+    };
+  }
+  /** e-Wallet payment (SNAP) — DANA / OVO / ShopeePay via payment-host-to-host. */
+  async snapEWalletPayment(params, config, snap, baseUrl) {
+    const { orderId, amount } = params;
+    const method = String(params.paymentMethod || "").toLowerCase();
+    const currency = params.currency || "IDR";
+    const returnUrl = params.returnUrl || config.returnUrl || "";
+    const channelMap = {
+      dana: "EMONEY_DANA_SNAP",
+      ovo: "EMONEY_OVO_SNAP",
+      shopeepay: "EMONEY_SHOPEEPAY_SNAP"
+    };
+    const channel = config.extra?.ewalletChannel || channelMap[method] || `EMONEY_${method.toUpperCase()}_SNAP`;
+    const body = {
+      partnerReferenceNo: orderId,
+      amount: this.snapAmount(amount, currency),
+      pointOfInitiation: "pc",
+      urlParam: {
+        url: returnUrl || "https://example.com/return",
+        type: "PAY_RETURN",
+        isDeepLink: "N"
+      },
+      additionalInfo: {
+        channel,
+        orderTitle: params.productDetails || `Pembayaran ${orderId}`,
+        supportDeepLinkCheckoutUrl: "false"
+      }
+    };
+    if (params.providerParams) {
+      Object.assign(body.additionalInfo, params.providerParams);
+    }
+    const endpoint = "/direct-debit/core/v1/debit/payment-host-to-host";
+    const data = await snap.request("POST", endpoint, body, {
+      deviceId: config.extra?.deviceId,
+      ipAddress: config.extra?.ipAddress
+    });
+    return {
+      success: true,
+      provider: "doku",
+      orderId: data.partnerReferenceNo || orderId,
+      amount: Number(data.amount?.value || amount) || Math.round(amount),
+      reference: data.partnerReferenceNo || orderId,
+      paymentUrl: data.webRedirectUrl || data.paymentUrl,
+      rawResponse: data
+    };
+  }
   async verifyCallback(body, config) {
+    const headers = config.extra?.headers || {};
+    if (this.isSnap(config)) {
+      return this.verifySnapCallback(body, config, headers);
+    }
     const rawStatus = (body.transaction?.status || body.status || "").toUpperCase();
     const isPaid = rawStatus === "SUCCESS" || rawStatus === "PAID" || rawStatus === "SETTLED";
     const isPending = rawStatus === "PENDING";
@@ -2776,7 +3164,6 @@ var DokuProvider = class extends BasePaymentProvider {
     const amount = body.order?.amount || body.amount || 0;
     const status = isPaid ? "paid" : isPending ? "pending" : isExpired ? "expired" : "failed";
     const secretKey = config.secretKey || config.apiKey || "";
-    const headers = config.extra?.headers || {};
     const signature = headers["signature"] || headers["Signature"] || config.extra?.dokuSignature || config.extra?.signatureHeader;
     const clientId = config.merchantCode || config.clientKey || "";
     let isValid = true;
@@ -2797,6 +3184,40 @@ var DokuProvider = class extends BasePaymentProvider {
       rawPayload: body
     };
   }
+  /**
+   * Verifikasi webhook / notifikasi DOKU SNAP.
+   * Signature dibangun dengan symmetric HMAC-SHA512 (AccessToken kosong).
+   */
+  verifySnapCallback(body, config, headers) {
+    const clientSecret = config.apiKey || config.serverKey || config.secretKey || "";
+    const endpointUrl = config.extra?.notificationPath || headers["x-path"] || config.extra?.headers?.["request-target"] || "/api/payment/webhook";
+    let isValid = true;
+    const incomingSig = headers["x-signature"] || headers["X-SIGNATURE"] || headers["signature"] || headers["Signature"] || "";
+    if (incomingSig && clientSecret) {
+      isValid = verifySnapWebhookSignature(headers, body, clientSecret, endpointUrl);
+    }
+    const explicitStatus = String(body.transactionStatus || body.status || body.latestTransactionStatus || "").toUpperCase();
+    const isPaid = explicitStatus === "SUCCESS" || explicitStatus === "PAID" || explicitStatus === "SETTLED" || explicitStatus === "00" || !explicitStatus && Boolean(body.paidAmount?.value ?? body.totalAmount?.value);
+    const isPending = explicitStatus === "PENDING" || explicitStatus === "11" || explicitStatus === "ONGOING";
+    const isFailed = explicitStatus === "FAILED" || explicitStatus === "DECLINED" || Boolean(explicitStatus) && !isPaid && !isPending && explicitStatus !== "00";
+    const isExpired = explicitStatus === "EXPIRED";
+    const orderId = body.trxId || body.partnerReferenceNo || body.originalPartnerReferenceNo || body.order?.invoice_number || body.invoice_number || body.order_id || "";
+    const paidValue = body.paidAmount?.value ?? body.totalAmount?.value ?? body.amount?.value ?? body.amount ?? 0;
+    const status = isPaid ? "paid" : isPending ? "pending" : isExpired ? "expired" : "failed";
+    return {
+      isValid,
+      provider: "doku",
+      orderId: String(orderId),
+      amount: Number(paidValue) || 0,
+      status,
+      isPaid,
+      isPending,
+      isFailed,
+      isExpired,
+      statusCode: explicitStatus || "SUCCESS",
+      rawPayload: body
+    };
+  }
   async getPaymentMethods(params, config) {
     const staticMethods = [
       {
@@ -2956,6 +3377,9 @@ var DokuProvider = class extends BasePaymentProvider {
     const clientId = config.merchantCode || config.merchantId || config.clientKey || "";
     const secretKey = config.apiKey || config.serverKey || config.secretKey || "";
     const sandbox = !!config.sandbox;
+    if (this.isSnap(config)) {
+      return this.snapCheckTransaction(params, config, clientId);
+    }
     const endpoint = `/orders/v1/status/${merchantOrderId}`;
     const url = `${this.getBaseUrl(sandbox)}${endpoint}`;
     const headers = generateDokuHeaders(clientId, secretKey, endpoint);
@@ -3033,6 +3457,58 @@ var DokuProvider = class extends BasePaymentProvider {
       };
     }
   }
+  /** Cek status transaksi SNAP (menggunakan Query QRIS bila ref berasal dari QRIS). */
+  async snapCheckTransaction(params, config, clientId) {
+    const { merchantOrderId } = params;
+    const snap = this.buildSnap(config);
+    try {
+      const body = {
+        originalPartnerReferenceNo: merchantOrderId,
+        serviceCode: "47",
+        merchantId: config.extra?.merchantId || config.projectId || ""
+      };
+      const data = await snap.request("POST", "/snap-adapter/b2b/v1.0/qr/qr-mpm-query", body);
+      const txStatus = String(data.latestTransactionStatus || "").toUpperCase();
+      const isPaid = txStatus === "SUCCESS" || txStatus === "00" || txStatus === "PAID" || txStatus === "SETTLED";
+      const isPending = txStatus === "PENDING" || txStatus === "ONGOING" || txStatus === "11";
+      const isExpired = txStatus === "EXPIRED";
+      const isFailed = txStatus === "FAILED" || txStatus === "DECLINED" || Boolean(txStatus) && !isPaid && !isPending && !isExpired;
+      const status = isPaid ? "paid" : isPending ? "pending" : isExpired ? "expired" : "failed";
+      return {
+        success: true,
+        provider: "doku",
+        orderId: data.originalPartnerReferenceNo || merchantOrderId,
+        reference: data.originalReferenceNo || "",
+        amount: Number(data.amount?.value || 0),
+        statusCode: txStatus || String(data.responseCode || ""),
+        status,
+        isPaid,
+        isPending,
+        isFailed,
+        isExpired,
+        statusMessage: txStatus || data.responseMessage || "",
+        paymentType: "QRIS",
+        rawResponse: data
+      };
+    } catch (e) {
+      return {
+        success: false,
+        provider: "doku",
+        orderId: merchantOrderId,
+        reference: "",
+        amount: 0,
+        statusCode: "ERROR",
+        status: "failed",
+        isPaid: false,
+        isPending: false,
+        isFailed: true,
+        isExpired: false,
+        statusMessage: e.message || "Failed to check SNAP transaction status",
+        error: e.message || "Failed to check SNAP transaction status",
+        rawResponse: null
+      };
+    }
+  }
 };
 
 // src/providers/prismalink/signature.ts
@@ -3426,15 +3902,15 @@ var PrismalinkProvider = class extends BasePaymentProvider {
 };
 
 // src/providers/faspay/signature.ts
-var import_crypto9 = __toESM(require("crypto"));
+var import_crypto11 = __toESM(require("crypto"));
 function generateFaspaySignature(userId, password, billNo) {
-  const md5Hash = import_crypto9.default.createHash("md5").update(`${userId}${password}${billNo}`).digest("hex");
-  return import_crypto9.default.createHash("sha1").update(md5Hash).digest("hex");
+  const md5Hash = import_crypto11.default.createHash("md5").update(`${userId}${password}${billNo}`).digest("hex");
+  return import_crypto11.default.createHash("sha1").update(md5Hash).digest("hex");
 }
 function verifyFaspaySignature(userId, password, billNo, paymentStatusCode, incomingSignature) {
   if (!incomingSignature || !password) return false;
-  const md5Hash = import_crypto9.default.createHash("md5").update(`${userId}${password}${billNo}${paymentStatusCode}`).digest("hex");
-  const computed = import_crypto9.default.createHash("sha1").update(md5Hash).digest("hex");
+  const md5Hash = import_crypto11.default.createHash("md5").update(`${userId}${password}${billNo}${paymentStatusCode}`).digest("hex");
+  const computed = import_crypto11.default.createHash("sha1").update(md5Hash).digest("hex");
   const simpleComputed = generateFaspaySignature(userId, password, billNo);
   return safeCompare(incomingSignature, computed) || safeCompare(incomingSignature, simpleComputed);
 }
@@ -3847,10 +4323,10 @@ var FaspayProvider = class extends BasePaymentProvider {
 };
 
 // src/providers/finpay/signature.ts
-var import_crypto11 = __toESM(require("crypto"));
+var import_crypto13 = __toESM(require("crypto"));
 function generateFinpaySignature(merchantId, orderId, amount, merchantKey) {
   const data = `${merchantId}%${orderId}%${Math.round(amount)}%${merchantKey}`;
-  return import_crypto11.default.createHmac("sha512", merchantKey).update(data).digest("hex");
+  return import_crypto13.default.createHmac("sha512", merchantKey).update(data).digest("hex");
 }
 function verifyFinpaySignature(merchantId, orderId, amount, merchantKey, incomingSignature) {
   if (!incomingSignature || !merchantKey) return false;
@@ -5747,7 +6223,7 @@ var PaypalProvider = class extends BasePaymentProvider {
 };
 
 // src/providers/adyen/signature.ts
-var import_crypto16 = require("crypto");
+var import_crypto18 = require("crypto");
 function verifyAdyenWebhook(notificationItem, hmacKey) {
   if (!hmacKey || !notificationItem) return false;
   try {
@@ -5764,7 +6240,7 @@ function verifyAdyenWebhook(notificationItem, hmacKey) {
     ];
     const signedData = fields.join(":");
     const keyBytes = Buffer.from(hmacKey, "hex");
-    const expected = (0, import_crypto16.createHmac)("sha256", keyBytes).update(signedData, "utf8").digest("base64");
+    const expected = (0, import_crypto18.createHmac)("sha256", keyBytes).update(signedData, "utf8").digest("base64");
     const provided = notificationItem.additionalData?.hmacSignature || "";
     return safeCompare(expected, provided);
   } catch {
@@ -5997,11 +6473,11 @@ var AdyenProvider = class extends BasePaymentProvider {
 };
 
 // src/providers/checkoutcom/signature.ts
-var import_crypto18 = require("crypto");
+var import_crypto20 = require("crypto");
 function verifyCheckoutComWebhook(body, signatureHeader, secret) {
   if (!secret || !signatureHeader || !body) return false;
   try {
-    const expected = (0, import_crypto18.createHmac)("sha256", secret).update(body, "utf8").digest("hex");
+    const expected = (0, import_crypto20.createHmac)("sha256", secret).update(body, "utf8").digest("hex");
     const provided = signatureHeader.replace(/^sha256=/, "");
     return safeCompare(expected, provided);
   } catch {
@@ -6221,11 +6697,11 @@ var CheckoutComProvider = class extends BasePaymentProvider {
 };
 
 // src/providers/razorpay/signature.ts
-var import_crypto20 = require("crypto");
+var import_crypto22 = require("crypto");
 function verifyRazorpayWebhook(rawBody, signature, webhookSecret) {
   if (!webhookSecret || !signature || !rawBody) return false;
   try {
-    const expected = (0, import_crypto20.createHmac)("sha256", webhookSecret).update(rawBody).digest("hex");
+    const expected = (0, import_crypto22.createHmac)("sha256", webhookSecret).update(rawBody).digest("hex");
     return safeCompare(expected, signature);
   } catch {
     return false;
@@ -6451,12 +6927,12 @@ var RazorpayProvider = class extends BasePaymentProvider {
 };
 
 // src/providers/square/signature.ts
-var import_crypto22 = require("crypto");
+var import_crypto24 = require("crypto");
 function verifySquareWebhook(rawBody, signatureHeader, signatureKey, notificationUrl) {
   if (!signatureKey || !signatureHeader || !rawBody) return false;
   try {
     const payload = notificationUrl + rawBody;
-    const expected = (0, import_crypto22.createHmac)("sha256", signatureKey).update(payload).digest("base64");
+    const expected = (0, import_crypto24.createHmac)("sha256", signatureKey).update(payload).digest("base64");
     return safeCompare(expected, signatureHeader);
   } catch {
     return false;
@@ -6696,7 +7172,7 @@ var SquareProvider = class extends BasePaymentProvider {
 };
 
 // src/providers/payu/signature.ts
-var import_crypto24 = require("crypto");
+var import_crypto26 = require("crypto");
 function verifyPayuWebhook(rawBody, signatureHeader, md5Key) {
   if (!md5Key || !signatureHeader || !rawBody) return false;
   try {
@@ -6709,10 +7185,10 @@ function verifyPayuWebhook(rawBody, signatureHeader, md5Key) {
     const algorithm = (parts["algorithm"] || "MD5").toUpperCase();
     if (!providedSig) return false;
     if (algorithm === "MD5") {
-      const expected = (0, import_crypto24.createHash)("md5").update(rawBody + md5Key).digest("hex");
+      const expected = (0, import_crypto26.createHash)("md5").update(rawBody + md5Key).digest("hex");
       return safeCompare(expected, providedSig);
     } else if (algorithm === "SHA-256") {
-      const expected = (0, import_crypto24.createHash)("sha256").update(rawBody + md5Key).digest("hex");
+      const expected = (0, import_crypto26.createHash)("sha256").update(rawBody + md5Key).digest("hex");
       return safeCompare(expected, providedSig);
     }
     return false;
@@ -6988,7 +7464,7 @@ var PayuProvider = class extends BasePaymentProvider {
 };
 
 // src/providers/braintree/signature.ts
-var import_crypto26 = require("crypto");
+var import_crypto28 = require("crypto");
 function verifyBraintreeWebhook(btSignature, btPayload, privateKey) {
   if (!privateKey || !btSignature || !btPayload) return false;
   try {
@@ -6996,8 +7472,8 @@ function verifyBraintreeWebhook(btSignature, btPayload, privateKey) {
     if (parts.length < 2) return false;
     const providedHmac = parts[1];
     const payload = Buffer.from(btPayload, "base64").toString("utf8");
-    const secretHash = (0, import_crypto26.createHash)("sha1").update(privateKey).digest("hex");
-    const expected = (0, import_crypto26.createHmac)("sha1", secretHash).update(payload).digest("hex");
+    const secretHash = (0, import_crypto28.createHash)("sha1").update(privateKey).digest("hex");
+    const expected = (0, import_crypto28.createHmac)("sha1", secretHash).update(payload).digest("hex");
     return safeCompare(expected, providedHmac);
   } catch {
     return false;
@@ -7224,11 +7700,11 @@ var BraintreeProvider = class extends BasePaymentProvider {
 };
 
 // src/providers/twocheckout/signature.ts
-var import_crypto28 = require("crypto");
+var import_crypto30 = require("crypto");
 function buildTwoCheckoutAuth(merchantCode, secretKey) {
   const date = Math.floor(Date.now() / 1e3).toString();
   const raw = merchantCode + date;
-  const hmac = (0, import_crypto28.createHmac)("sha256", secretKey).update(raw).digest("hex");
+  const hmac = (0, import_crypto30.createHmac)("sha256", secretKey).update(raw).digest("hex");
   const header = `code="${merchantCode}" date="${date}" hash="${hmac}"`;
   return { header, date };
 }
@@ -7236,7 +7712,7 @@ function verifyTwoCheckoutWebhook(secretWord, saleId, productId, invoiceId, prov
   if (!secretWord || !providedHash) return false;
   try {
     const raw = secretWord + saleId + productId + invoiceId;
-    const expected = (0, import_crypto28.createHash)("md5").update(raw).digest("hex");
+    const expected = (0, import_crypto30.createHash)("md5").update(raw).digest("hex");
     return safeCompare(expected, providedHash);
   } catch {
     return false;
@@ -9593,6 +10069,7 @@ var buayar = new Buayar();
   PrismalinkProvider,
   RazorpayClient,
   RazorpayProvider,
+  SnapClient,
   SquareClient,
   SquareProvider,
   StripeClient,
@@ -9616,6 +10093,8 @@ var buayar = new Buayar();
   generateNicepayToken,
   generateOyHeaders,
   generatePrismalinkSignature,
+  generateSnapAsymmetricSignature,
+  generateSnapSymmetricSignature,
   getDuitkuInquirySignatures,
   getDuitkuPaymentMethodsSignature,
   getDuitkuStatusSignatures,
@@ -9623,6 +10102,7 @@ var buayar = new Buayar();
   getXenditAuthHeader,
   hmacSha256,
   md5,
+  minifyJson,
   parseCoreChargeResponse,
   paymentManager,
   resolveConfigFromEnv,
@@ -9630,7 +10110,10 @@ var buayar = new Buayar();
   serializePaypalParams,
   serializeStripeParams,
   sha256,
+  sha256Hex,
   sha512,
+  snapExternalId,
+  snapTimestamp,
   toCanonicalPaymentMethod,
   toDokuPaymentMethod,
   toDuitkuPaymentMethod,
@@ -9656,6 +10139,7 @@ var buayar = new Buayar();
   verifyPayuWebhook,
   verifyPrismalinkSignature,
   verifyRazorpayWebhook,
+  verifySnapWebhookSignature,
   verifySquareWebhook,
   verifyStripeWebhook,
   verifyTwoCheckoutWebhook,