Payment Verification API

POST https://pay.darvizlabs.com/api/v1/public/transactions/submit

Authorization: Bearer YOUR_API_KEY

{
  "transaction_ref": "INV-2026-00482",
  "amount": 1499,
  "currency": "BDT",
  "method": "bkash",
  "business_name": "Nerdy",
  "external_user_id": "user_8821",
  "source": "web-checkout",
  "occurred_at": "2026-05-27T10:00:00Z"
}

POST https://pay.darvizlabs.com/api/v1/public/transactions/verify

Authorization: Bearer YOUR_API_KEY

{
  "transaction_ref": "INV-2026-00482",
  "business_name": "Nerdy",
  "external_user_id": "user_8821",
  "date": "2026-05-27",
  "amount": 1499,
  "source": "web-checkout"
}

POST https://pay.darvizlabs.com/api/v1/public/transactions/review

Authorization: Bearer YOUR_API_KEY

{
  "transaction_id": "jf3m2k9x1p",
  "amount": 1499,
  "note": "Payment confirmed by customer — project setup fee."
}

POST <your callback_url>
Content-Type: application/json
X-GatePay-Signature: sha256=<hex hmac>
User-Agent: GatePay-Verify/1.0

{
  "business_name": "Nerdy",
  "sent_at": "2026-05-27T16:30:00.000Z",
  "transactions": [
    {
      "transaction_ref": "INV-2026-00482",
      "amount": 1499.00,
      "currency": "BDT",
      "occurred_at": "2026-05-27T10:00:00.000Z",
      "method": "bkash",
      "external_user_id": "user_8821",
      "source": "web-checkout"
    }
  ]
}

GET https://pay.darvizlabs.com/api/v1/public/health

{"status":"ok"}

POST https://pay.darvizlabs.com/api/v1/public/transactions/refund

Authorization: Bearer YOUR_API_KEY

{
  "transaction_ref": "INV-2026-00482",
  "amount": 1499,
  "method": "bKash",
  "receiver_name": "Rafid Mahim",
  "receiver_number": "01712345678",
  "notes": "Customer requested full refund"
}

// gatepay.ts
import crypto from "node:crypto";

interface GatePayConfig {
  apiKey: string;
  signingSecret: string;
  baseUrl?: string;
}

class GatePayError extends Error {
  constructor(public status: number, public code: string, public details?: any) {
    super(code);
    this.name = "GatePayError";
  }
}

class GatePay {
  private baseUrl: string;
  private apiKey: string;
  private signingSecret: string;

  constructor(config: GatePayConfig) {
    this.apiKey = config.apiKey;
    this.signingSecret = config.signingSecret;
    this.baseUrl = config.baseUrl ?? "https://pay.darvizlabs.com/api/v1/public";
  }

  private async request<T>(path: string, body: unknown): Promise<T> {
    const res = await fetch(`${this.baseUrl}${path}`, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${this.apiKey}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(body),
    });
    const data = await res.json();
    if (!res.ok) throw new GatePayError(res.status, data.error ?? "unknown_error");
    return data as T;
  }

  async submit(payload: any) { return this.request("/transactions/submit", payload); }
  async verify(payload: any) { return this.request("/transactions/verify", payload); }
  async refund(payload: any) { return this.request("/transactions/refund", payload); }
  async review(payload: any) { return this.request("/transactions/review", payload); }
}

// Usage
const gp = new GatePay({
  apiKey: process.env.GATEKEEPR_API_KEY!,
  signingSecret: process.env.GATEKEEPR_SIGNING_SECRET!,
});
const { status } = await gp.submit({
  transaction_ref: "INV-2026-00482",
  amount: 1499.00,
  currency: "BDT",
  method: "bkash",
  business_name: "Nerdy",
});
console.log(status); // "unverified"

# gatepay.py
import hmac, hashlib
from dataclasses import dataclass
import httpx

class GatePayError(Exception):
    def __init__(self, status: int, code: str, details: dict = None):
        self.status = status
        self.code = code
        self.details = details
        super().__init__(code)

@dataclass
class GatePayConfig:
    api_key: str
    signing_secret: str
    base_url: str = "https://pay.darvizlabs.com/api/v1/public"

class GatePay:
    def __init__(self, config: GatePayConfig):
        self.config = config
        self._client = httpx.Client(base_url=self.config.base_url)

    def _headers(self):
        return {"Authorization": f"Bearer {self.config.api_key}", "Content-Type": "application/json"}

    def submit(self, transaction_ref: str, amount: float, **kwargs):
        payload = {"transaction_ref": transaction_ref, "amount": amount, **kwargs}
        resp = self._client.post("/transactions/submit", json=payload, headers=self._headers())
        data = resp.json()
        if not resp.is_success:
            raise GatePayError(resp.status_code, data.get("error", "unknown"))
        return data

    def verify(self, transaction_ref: str, business_name: str):
        resp = self._client.post("/transactions/verify", json={
            "transaction_ref": transaction_ref, "business_name": business_name,
        }, headers=self._headers())
        return resp.json()

# Usage
gp = GatePay(GatePayConfig(api_key="gk_xxxx", signing_secret="xxxx"))
result = gp.submit("INV-001", 1499.00, business_name="Nerdy", method="bkash")
print(result["status"])  # "unverified"
verify = gp.verify("INV-001", "Nerdy")
print(verify["verified"])  # True/False

import { Router } from "express";
import crypto from "node:crypto";

const router = Router();

router.post("/checkout", async (req, res) => {
  const { amount, userId } = req.body;
  const ref = `INV-${Date.now()}`;
  const submit = await fetch("https://pay.darvizlabs.com/api/v1/public/transactions/submit", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.GATEKEEPR_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      transaction_ref: ref, amount, currency: "BDT",
      method: "bkash", business_name: "Nerdy", external_user_id: userId,
    }),
  }).then(r => r.json());
  res.json({ ref, gatepay_id: submit.id });
});

router.post("/gatepay/callback", async (req, res) => {
  const signature = req.headers["x-gatepay-signature"];
  const rawBody = JSON.stringify(req.body);
  const expected = crypto.createHmac("sha256", process.env.GATEKEEPR_SIGNING_SECRET!)
    .update(rawBody).digest("hex");
  if (`sha256=${expected}` !== signature) return res.status(401).json({ error: "invalid signature" });
  for (const tx of req.body.transactions) console.log(`Verified: ${tx.transaction_ref}`);
  res.sendStatus(200);
});

export { router as paymentRouter };

// Integration checklist:
// ☐ Set GATEKEEPR_API_KEY and GATEKEEPR_SIGNING_SECRET
// ☐ Add callback URL to API key
// ☐ Call POST /submit on order placement
// ☐ Handle callback with HMAC verification

class GatePaySubscription {
  private baseUrl = "https://pay.darvizlabs.com";
  getPayLink(payCode: string): string {
    return `${this.baseUrl}/pay/${payCode}`;
  }
}

// 1. Admin creates project with billing config in dashboard
// 2. Share link with client
const link = new GatePaySubscription().getPayLink("DNKX4U");
// → https://pay.darvizlabs.com/pay/DNKX4U

// 3. Client opens link, selects month, pays via bKash
// 4. Transaction auto-verified as subscription payment
// 5. Confirmation email sent to client automatically