Taking website payments in Thailand without a credit or debit card

async function payWithWeChat(amountTHB, orderId) {
  const r = await fetch("/api/checkout", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ amountTHB, orderId }),
  });
  const { qrImageUri, deeplink, chargeId } = await r.json();

  const isMobile = /iPhone|Android/i.test(navigator.userAgent);

  if (isMobile) {
    window.location = deeplink;            // → opens WeChat
  } else {
    document.getElementById("qr").src = qrImageUri;
    pollChargeStatus(chargeId);            // optional UX poll
  }
}

app.post("/webhooks/omise",
  express.raw({ type: "application/json" }),
  async (req, res) => {
    const event = JSON.parse(req.body);

    // Always re-fetch — never trust the webhook body for $
    if (event.key === "charge.complete") {
      const charge = await omise.charges.retrieve(event.data.id);
      if (charge.status === "successful" && charge.paid) {
        await markOrderPaid(charge.metadata.orderId, charge.amount);
      }
    }
    res.sendStatus(200);
  });

# pip install pyjwt requests flask
import jwt, requests, time, uuid
from flask import Flask, request, jsonify

app          = Flask(__name__)
MERCHANT_ID  = "JT01"
SECRET_KEY   = "YOUR_2C2P_SECRET_KEY"
ENDPOINT     = "https://sandbox-pgw.2c2p.com/payment/4.3/paymentToken"

@app.route("/api/checkout", methods=["POST"])
def checkout():
    body = request.json
    payload = {
        "merchantID":    MERCHANT_ID,
        "invoiceNo":     body["orderId"],
        "description":   body["description"],
        "amount":        body["amountTHB"],     # decimal
        "currencyCode":  "THB",
        "paymentChannel": ["WECHAT"],            # lock to WeChat Pay
        "frontendReturnUrl": "https://yoursite.com/pay/return",
        "backendReturnUrl":  "https://yoursite.com/webhooks/2c2p",
        "nonceStr":       uuid.uuid4().hex,
    }
    token = jwt.encode(payload, SECRET_KEY, algorithm="HS256")
    r = requests.post(ENDPOINT, json={"payload": token}).json()
    decoded = jwt.decode(r["payload"], SECRET_KEY, algorithms=["HS256"])

    # Hand back the hosted-payment-page URL — 2C2P shows the WeChat QR there
    return jsonify({
        "redirectUrl": decoded["webPaymentUrl"],
        "paymentToken": decoded["paymentToken"],
    })

@app.route("/webhooks/2c2p", methods=["POST"])
def c2p_webhook():
    token = request.json["payload"]
    try:
        data = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
    except jwt.InvalidSignatureError:
        return ("bad sig", 400)

    # respCode "0000" = success per 2C2P spec
    if data["respCode"] == "0000" and data["channelCode"] == "WECHAT":
        mark_order_paid(data["invoiceNo"], data["amount"])

    return ("", 200)

from typing import Any

FEES = {
    "promptpay":    {"pct": 0.0095, "flat_thb": 2, "settles_to": "thai_bank"},
    "wechat_pay":   {"pct": 0.0290, "flat_thb": 0, "settles_to": "thai_bank"},
    "alipay_plus":  {"pct": 0.0290, "flat_thb": 0, "settles_to": "thai_bank"},
    "truemoney":    {"pct": 0.0175, "flat_thb": 0, "settles_to": "truemoney"},
    "usdt_tron":    {"pct": 0.0080, "flat_thb": 0, "settles_to": "crypto_wallet"},
}

def lookup_fee(rail: str, amount_thb: float) -> dict:
    f = FEES[rail]
    fee = amount_thb * f["pct"] + f["flat_thb"]
    return {"rail": rail, "fee_thb": round(fee, 2), "net_thb": round(amount_thb - fee, 2)}

def pick_rail(visa: str, buyer_country: str, has_thai_bank: bool) -> dict:
    if not has_thai_bank:
        return {"rail": "wise_or_airwallex", "why": "No Thai bank, route through multi-currency account"}
    if visa in {"tourist", "ed", "retirement"}:
        return {"rail": "promptpay_personal", "why": "Commercial use forbidden — personal only"}
    if buyer_country == "CN":
        return {"rail": "wechat_pay", "why": "Chinese buyers; route via Omise WeChat Pay"}
    return {"rail": "promptpay", "why": "Default Thai-resident rail"}

def create_test_charge(rail: str, amount_thb: float) -> dict:
    # Calls Omise sandbox; returns QR + charge id (omitted for brevity)
    ...

TOOLS: list[dict[str, Any]] = [
    {"type": "function", "function": {
        "name": "lookup_fee",
        "description": "Compute the gateway fee and net amount for a given rail.",
        "parameters": {"type": "object", "properties": {
            "rail":       {"type": "string", "enum": list(FEES.keys())},
            "amount_thb": {"type": "number"}
        }, "required": ["rail", "amount_thb"]}
    }},
    {"type": "function", "function": {
        "name": "pick_rail",
        "description": "Recommend a payment rail given the merchant's visa and target buyer.",
        "parameters": {"type": "object", "properties": {
            "visa":           {"type": "string"},
            "buyer_country":  {"type": "string"},
            "has_thai_bank":  {"type": "boolean"}
        }, "required": ["visa", "buyer_country", "has_thai_bank"]}
    }},
    {"type": "function", "function": {
        "name": "create_test_charge",
        "description": "Create a sandbox charge and return the WeChat QR for preview.",
        "parameters": {"type": "object", "properties": {
            "rail":       {"type": "string"},
            "amount_thb": {"type": "number"}
        }, "required": ["rail", "amount_thb"]}
    }},
]

DISPATCH = {
    "lookup_fee":         lookup_fee,
    "pick_rail":          pick_rail,
    "create_test_charge": create_test_charge,
}

import json, requests
from tools import TOOLS, DISPATCH

OLLAMA = "http://localhost:11434/api/chat"
MODEL  = "qwen3:8b"
SYSTEM = ("You are a payments advisor for Chinese residents in Thailand. "
          "Use the provided tools rather than guessing fees or rails. "
          "Always answer in the user's language (Mandarin, Thai or English).")

def run_agent(user_msg: str, history: list[dict] | None = None) -> dict:
    msgs = [{"role": "system", "content": SYSTEM}, *(history or []),
            {"role": "user", "content": user_msg}]

    for _ in range(6):                              # tool-call budget
        r = requests.post(OLLAMA, json={
            "model": MODEL, "messages": msgs,
            "tools": TOOLS, "stream": False,
        }, timeout=120).json()

        msg = r["message"]
        msgs.append(msg)

        calls = msg.get("tool_calls") or []
        if not calls:
            return {"reply": msg["content"], "history": msgs}

        for call in calls:                            # execute every requested tool
            name = call["function"]["name"]
            args = call["function"]["arguments"]
            result = DISPATCH[name](**args)
            msgs.append({"role": "tool", "name": name,
                         "content": json.dumps(result, ensure_ascii=False)})

    return {"reply": "(tool budget exceeded)", "history": msgs}

# pip install fastapi uvicorn requests
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from agent import run_agent

app = FastAPI()
app.add_middleware(CORSMiddleware, allow_origins=["http://localhost:8080"],
                   allow_methods=["*"], allow_headers=["*"])

class ChatIn(BaseModel):
    message: str
    history: list[dict] = []

@app.post("/chat")
def chat(body: ChatIn):
    return run_agent(body.message, body.history)

@app.get("/health")
def health():
    return {"ok": True, "model": "qwen3:8b"}

# Run with:  uvicorn server:app --reload --port 8000

const WORKER = "http://localhost:8000/chat";
let history = [];

async function ask(message) {
  const r = await fetch(WORKER, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ message, history }),
  });
  const { reply, history: next } = await r.json();
  history = next;                // keep tool-call traces for grounding
  render(reply);
}

// Example user prompts the agent will resolve via tools:
//   "我有 ED 签证，想给云南朋友收 500 baht，应该用哪个？"
//   "Compare Omise WeChat fee vs USDT for 12,000 THB"
//   "Generate a sandbox WeChat QR for 99 baht"