npm install @sobindigital/pay

1
2
3
4
5
6
7
8
9
10
11
12
13import { SobinPay } from "@sobindigital/pay";

const sobin = new SobinPay({
  aba: {
    merchantId: process.env.ABA_MERCHANT_ID || "your_merchant_id",
    apiKey: process.env.ABA_API_KEY || "your_aba_api_key",
    apiUrl: process.env.ABA_API_URL || "https://checkout-sandbox.payway.com.kh",
    timeoutMs: 15000, // Optional request timeout (default: 15s)
  },
});

// Access the PayWay client via any of these equivalent aliases:
// sobin.aba, sobin.abapay, or sobin.payway

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29import { AbaPaymentOption, AbaViewType } from "@sobindigital/pay";

const purchase = sobin.aba.createPurchase({
  amount: 25.0,
  currency: "USD",
  returnUrl: "https://example.com/checkout/success",
  cancelUrl: "https://example.com/checkout/cancel",
  paymentOption: AbaPaymentOption.ABAPAY_KHQR, // or "cards", "alipay", etc.
  viewType: AbaViewType.POPUP, // or AbaViewType.HOSTED
  customer: {
    firstName: "Dara",
    lastName: "Chan",
    email: "dara@example.com",
    phone: "012345678",
  },
  items: [
    { name: "Pro Developer License", quantity: 1, price: 25.0 },
  ],
});

// Returns:
// {
//   actionUrl: "https://checkout-sandbox.payway.com.kh/api/payment-gateway/v1/payments/purchase",
//   payload: { req_time, merchant_id, tran_id, amount, hash, ... },
//   checkoutUrl: "...",
//   formHtml: "<form method='POST' action='...'>...</form>",
//   hash: "...",
//   tranId: "sb-..."
// }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16const qr = await sobin.aba.createQR({
amount: 10.0,
currency: "USD",
returnUrl: "https://example.com/checkout/success",
customer: {
  firstName: "Sok",
  lastName: "Chan",
  phone: "012345678",
},
});

if (qr.isSuccess) {
console.log("Raw QR String:", qr.qrString);
console.log("ABA Mobile App Deeplink:", qr.abapayDeeplink);
console.log("QR Image URL:", qr.checkoutQrUrl);
}

1
2
3
4
5
6
7
8
9
10
11
12import { AbaPaymentStatus } from "@sobindigital/pay";

const status = await sobin.aba.checkTransaction("sb-n80c75123");

if (status.isApproved) {
  console.log("Payment completed! Status:", status.status); // AbaPaymentStatus.APPROVED
  console.log("Amount paid:", status.originalAmount, status.originalCurrency);
} else if (status.status === AbaPaymentStatus.PENDING) {
  console.log("Payment is still awaiting customer scan/authorization.");
} else {
  console.log("Payment was not approved:", status.status);
}

const details = await sobin.aba.getTransactionDetail("sb-123456");

console.log("Bank Reference:", details.bankRef);
console.log("Payment Status:", details.paymentStatus);
console.log("Gateway Response:", details.rawResponse);

const result = await sobin.aba.closeTransaction("sb-123456");

if (result.isSuccess) {
  console.log("Transaction successfully voided:", result.message);
}

const rate = await sobin.aba.getExchangeRate();

console.log("1 USD =", rate.usdToKhr, "KHR");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15// Inside your webhook route handler (e.g. Next.js, Express, or NestJS)
const payload = req.body; // Incoming JSON pushback payload
const signature = req.headers["x-payway-hmac-sha512"] || payload.hash;

const verification = sobin.aba.verifyWebhook(payload, signature);

if (!verification.isValid) {
  console.error("Untrusted pushback! Cryptographic signature mismatch.");
  return res.status(401).send("Invalid Signature");
}

if (verification.status === "APPROVED") {
  // Safe to credit customer balance or mark order as paid
  await markOrderPaid(verification.tranId);
}

1
2
3
4
5
6
7
8
9
10const refundResult = await sobin.aba.refundTransaction({
  tranId: "sb-123456",
  amount: 10.0, // Amount to refund
  reason: "Customer order cancellation",
  rsaPublicKey: process.env.ABA_RSA_PUBLIC_KEY, // Or configured in client init
});

if (refundResult.isSuccess) {
  console.log("Refund processed successfully! Refund ID:", refundResult.refundId);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14import { SobinPay } from "@sobindigital/pay";

// Generate a Dynamic Individual KHQR (with specified amount & invoice)
const qrString = SobinPay.khqr.generateIndividual({
  bakongAccountId: "sobin_digital@aclb", // Recipient Bakong Account ID
  merchantName: "Sobin Digital",        // Payee display name (max 25 chars)
  merchantCity: "Phnom Penh",           // Operational city (default: Phnom Penh)
  amount: 15.50,                        // Amount (USD or KHR)
  currency: "USD",                      // "USD" (code 840) or "KHR" (code 116)
  billNumber: "INV-2026-001",           // Optional invoice number (Tag 62)
});

console.log(qrString);
// Output: 00020101021229300018sobin_digital@aclb520459995303840540515.505802KH5913Sobin Digital6010Phnom Penh62160112INV-2026-0016304...

1
2
3
4
5
6
7
8
9
10
11
12const merchantQr = SobinPay.khqr.generateMerchant({
  bakongAccountId: "sobin_digital@aclb",
  merchantId: "000000001",               // Acquiring Bank Merchant ID
  acquiringBank: "Bakong Bank",          // Acquiring Bank Name
  merchantName: "Sobin Digital Store",
  merchantCity: "Phnom Penh",
  amount: 60000,
  currency: "KHR",
  billNumber: "ORD-9912",
  storeLabel: "Central Branch",
  terminalLabel: "POS-03",
});

1
2
3
4
5
6
7
8
9
10
11
12const parsed = SobinPay.khqr.parse(qrString);

if (!parsed.isValid) {
  throw new Error("Invalid KHQR string or CRC16 checksum mismatch!");
}

console.log("Account ID:", parsed.bakongAccountId); // e.g. "sobin_digital@aclb"
console.log("Payee Name:", parsed.merchantName);    // e.g. "Sobin Digital"
console.log("Amount:", parsed.amount);              // e.g. 15.5
console.log("Currency:", parsed.currency);          // "USD" or "KHR"
console.log("CRC:", parsed.crc);                    // e.g. "E5F2"
console.log("All EMVCo Tags:", parsed.tags);        // { "00": "01", "01": "12", ... }

const deeplink = SobinPay.khqr.deeplink(qrString);

// Returns:
// "https://bakong.nbc.org.kh/deeplink?qr=000201010212..."
// Or native scheme: "bakong://qr?data=000201010212..."

1
2
3
4
5
6
7
8
9
10
11
12
13
14import { SobinPay, SobinPayError, ProviderApiError } from "@sobindigital/pay";

try {
  const status = await sobin.aba.checkTransaction(tranId);
} catch (err: unknown) {
  if (err instanceof ProviderApiError) {
    console.error("Gateway HTTP Status:", err.statusCode);
    console.error("Gateway Message:", err.message);
  } else if (err instanceof SobinPayError) {
    console.error("SobinPay Code:", err.code); // e.g. "INVALID_TRANSACTION_ID"
  } else {
    console.error("Unexpected error:", err);
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27"use server";

import { SobinPay, AbaPaymentOption, AbaViewType } from "@sobindigital/pay";

const sobin = new SobinPay({
  aba: {
    merchantId: process.env.ABA_MERCHANT_ID!,
    apiKey: process.env.ABA_API_KEY!,
    apiUrl: process.env.ABA_API_URL,
  },
});

export async function createCheckoutSession(amount: number) {
  const purchase = sobin.aba.createPurchase({
    amount,
    currency: "USD",
    returnUrl: `${process.env.NEXT_PUBLIC_SITE_URL}/checkout/success`,
    cancelUrl: `${process.env.NEXT_PUBLIC_SITE_URL}/checkout/cancel`,
    paymentOption: AbaPaymentOption.ABAPAY_KHQR,
    viewType: AbaViewType.POPUP,
  });

  return {
    actionUrl: purchase.actionUrl,
    payload: purchase.payload,
  };
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31import { NextResponse } from "next/server";
import { SobinPay } from "@sobindigital/pay";

const sobin = new SobinPay({
  aba: {
    merchantId: process.env.ABA_MERCHANT_ID!,
    apiKey: process.env.ABA_API_KEY!,
  },
});

export async function POST(req: Request) {
  try {
    const payload = await req.json();
    const signature = req.headers.get("x-payway-hmac-sha512") || payload.hash;

    const verification = sobin.aba.verifyWebhook(payload, signature);

    if (!verification.isValid) {
      return NextResponse.json({ error: "Invalid signature" }, { status: 401 });
    }

    if (verification.status === "APPROVED") {
      // Perform database update in constant time
      console.log("Order paid:", verification.tranId);
    }

    return NextResponse.json({ success: true });
  } catch (err: unknown) {
    return NextResponse.json({ error: "Webhook processing error" }, { status: 400 });
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38import express from "express";
import { SobinPay, AbaPaymentOption } from "@sobindigital/pay";

const app = express();
app.use(express.json());

const sobin = new SobinPay({
  aba: {
    merchantId: process.env.ABA_MERCHANT_ID!,
    apiKey: process.env.ABA_API_KEY!,
  },
});

// Create checkout
app.post("/api/checkout", (req, res) => {
  const purchase = sobin.aba.createPurchase({
    amount: req.body.amount,
    currency: "USD",
    returnUrl: "https://example.com/success",
    paymentOption: AbaPaymentOption.ABAPAY_KHQR,
  });
  res.json(purchase);
});

// Receive Pushback Webhook
app.post("/api/payway/webhook", (req, res) => {
  const signature = req.headers["x-payway-hmac-sha512"] as string;
  const verification = sobin.aba.verifyWebhook(req.body, signature);

  if (!verification.isValid) {
    return res.status(401).send("Unauthorized Webhook");
  }

  // Handle successful transaction
  res.status(200).send("OK");
});

app.listen(4000, () => console.log("Server listening on port 4000"));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import { Injectable } from "@nestjs/common";
import { ConfigService } from "@nestjs/config";
import { SobinPay } from "@sobindigital/pay";

@Injectable()
export class SobinPayService {
  public readonly client: SobinPay;

  constructor(private configService: ConfigService) {
    this.client = new SobinPay({
      aba: {
        merchantId: this.configService.getOrThrow<string>("ABA_MERCHANT_ID"),
        apiKey: this.configService.getOrThrow<string>("ABA_API_KEY"),
        apiUrl: this.configService.get<string>("ABA_API_URL"),
      },
    });
  }
}