@vobs/payment 0.3.0 → 1.2.0

package/dist/wechat-official.js

@@ -1,208 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/payment
- */
-/**
- * WeChat Pay official driver (API v3) — Native (PC scan) / JSAPI (official account, miniapp webview) / H5.
- *
- * Covered scenes (web):
- *  - `pc`       → Native payment → `{kind:'qr', qrUrl: code_url}`
- *  - `h5` + openid → JSAPI payment → `{kind:'jsapi', payParams}` (official account / WeChat built-in browser)
- *  - `h5` (no openid) → H5 payment → `{kind:'redirect', payUrl: h5_url}`
- *  - `miniapp` + openid → JSAPI payment (miniapp webview)
- *
- * Security:
- *  - Request signing: Authorization `WECHATPAY2-SHA256-RSA2048` (merchant private key SHA256withRSA)
- *  - Callback: AES-256-GCM decryption (apiV3Key) + optional platform-cert verification (enforced when platformPublicKeyPem is set) + time-window/nonce anti-replay
- *  - Channel self-verification path: callbacks bypass the framework's generic HMAC protocol; this driver verifies the channel itself
- *
- * Dependencies: node:crypto (Node built-in, zero third-party). Sandbox needs sandbox keys/certs from the merchant platform (configure baseUrl per the sandbox docs when integrating).
- */
-import { createDecipheriv, createPrivateKey, createPublicKey, randomBytes, sign, verify, } from 'node:crypto';
-const DEFAULT_BASE = 'https://api.mch.weixin.qq.com';
-function isWxResource(v) {
-    if (typeof v !== 'object' || v === null)
-        return false;
-    const r = v;
-    return typeof r['ciphertext'] === 'string' && typeof r['nonce'] === 'string';
-}
-export function createWechatOfficialDriver(store, options) {
-    const baseUrl = options.baseUrl ?? DEFAULT_BASE;
-    const timeWindowSec = options.timeWindowSec ?? 300;
-    const fetchImpl = options.fetchImpl ?? ((...args) => fetch(...args));
-    const privateKey = createPrivateKey(options.privateKeyPem);
-    const platformKey = options.platformPublicKeyPem
-        ? createPublicKey(options.platformPublicKeyPem)
-        : undefined;
-    /** API v3 request signature header. */
-    function authorizeHeader(method, urlPath, body) {
-        const timestamp = Math.floor(Date.now() / 1000);
-        const nonce = randomBytes(16).toString('hex');
-        const message = `${method}\n${urlPath}\n${timestamp}\n${nonce}\n${body}\n`;
-        const signature = sign('RSA-SHA256', Buffer.from(message), privateKey).toString('base64');
-        return `WECHATPAY2-SHA256-RSA2048 mchid="${options.mchId}",nonce_str="${nonce}",signature="${signature}",timestamp="${timestamp}",serial_no="${options.serialNo}"`;
-    }
-    async function request(method, urlPath, body) {
-        const headers = {
-            Authorization: authorizeHeader(method, urlPath, body ?? ''),
-            Accept: 'application/json',
-        };
-        if (body !== undefined)
-            headers['Content-Type'] = 'application/json';
-        const res = await fetchImpl(`${baseUrl}${urlPath}`, {
-            method,
-            headers,
-            ...(body !== undefined ? { body } : {}),
-        });
-        const text = await res.text();
-        if (!res.ok) {
-            throw new Error(`wechat_api_error:${res.status}:${text}`);
-        }
-        return JSON.parse(text);
-    }
-    /** JSAPI invocation params (for the frontend wx.requestPayment): paySign signed with the merchant private key. */
-    function buildJsapiParams(prepayId) {
-        const timeStamp = String(Math.floor(Date.now() / 1000));
-        const nonceStr = randomBytes(16).toString('hex');
-        const pkg = `prepay_id=${prepayId}`;
-        const message = `${options.appId}\n${timeStamp}\n${nonceStr}\n${pkg}\n`;
-        const paySign = sign('RSA-SHA256', Buffer.from(message), privateKey).toString('base64');
-        return {
-            appId: options.appId,
-            timeStamp,
-            nonceStr,
-            package: pkg,
-            signType: 'RSA',
-            paySign,
-        };
-    }
-    async function createOrder(input) {
-        const base = {
-            appid: options.appId,
-            mchid: options.mchId,
-            description: input.subject,
-            out_trade_no: input.orderId,
-            notify_url: input.notifyUrl,
-            amount: { total: input.amount, currency: 'CNY' },
-        };
-        const openid = input.extras?.['openid'];
-        if (input.scene === 'miniapp' || (input.scene === 'h5' && typeof openid === 'string')) {
-            // JSAPI (official account / miniapp webview; requires openid)
-            const res = await request('POST', '/v3/pay/transactions/jsapi', JSON.stringify({ ...base, payer: { openid } }));
-            return { kind: 'jsapi', payParams: buildJsapiParams(res.prepay_id) };
-        }
-        if (input.scene === 'pc') {
-            // Native scan-to-pay
-            const res = await request('POST', '/v3/pay/transactions/native', JSON.stringify(base));
-            return {
-                kind: 'qr',
-                qrUrl: res.code_url,
-                expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
-            };
-        }
-        // H5 (mobile browser)
-        const h5Input = {
-            ...base,
-            scene_info: {
-                payer_client_ip: input.extras?.['clientIp'] ?? '127.0.0.1',
-                h5_info: { type: 'Wap' },
-            },
-        };
-        const res = await request('POST', '/v3/pay/transactions/h5', JSON.stringify(h5Input));
-        return { kind: 'redirect', payUrl: res.h5_url };
-    }
-    function verifyCallback(payload, headers) {
-        const h = (headers ?? {});
-        const ts = h['wechatpay-timestamp'];
-        const nonce = h['wechatpay-nonce'];
-        const signature = h['wechatpay-signature'];
-        if (!ts || !nonce) {
-            return { ok: false, reason: 'missing_wechatpay_headers' };
-        }
-        // time-window check (anti-replay)
-        if (Math.abs(Date.now() / 1000 - Number(ts)) > timeWindowSec) {
-            return { ok: false, reason: 'timestamp_expired' };
-        }
-        // optional: platform-cert verification (signed string = timestamp\nnonce\nbody\n)
-        if (platformKey) {
-            const rawBody = typeof payload === 'string' ? payload : JSON.stringify(payload);
-            const ok = verify('RSA-SHA256', Buffer.from(`${ts}\n${nonce}\n${rawBody}\n`), platformKey, Buffer.from(signature ?? '', 'base64'));
-            if (!ok) {
-                return { ok: false, reason: 'bad_platform_signature' };
-            }
-        }
-        // AES-256-GCM decrypt (apiV3Key confidentiality → successful decryption proves the message came from WeChat)
-        let obj;
-        try {
-            obj =
-                typeof payload === 'string'
-                    ? JSON.parse(payload)
-                    : payload;
-            const resource = obj['resource'];
-            if (!isWxResource(resource)) {
-                return { ok: false, reason: 'bad_resource' };
-            }
-            // WeChat ciphertext format: ciphertext = encrypted || authTag(16B)
-            const buf = Buffer.from(resource.ciphertext, 'base64');
-            const decipher = createDecipheriv('aes-256-gcm', Buffer.from(options.apiV3Key), Buffer.from(resource.nonce));
-            if (resource.associated_data)
-                decipher.setAAD(Buffer.from(resource.associated_data));
-            decipher.setAuthTag(buf.subarray(buf.length - 16));
-            const plain = Buffer.concat([
-                decipher.update(buf.subarray(0, buf.length - 16)),
-                decipher.final(),
-            ]).toString('utf8');
-            const data = JSON.parse(plain);
-            // Only consume the nonce after platform authentication and AES-GCM decryption succeed.
-            if (!store.addNonce(`wx:${nonce}`)) {
-                return { ok: false, reason: 'nonce_reused' };
-            }
-            if (data['trade_state'] !== 'SUCCESS') {
-                return { ok: false, reason: `trade_state:${String(data['trade_state'])}` };
-            }
-            const amount = data['amount'];
-            const orderId = data['out_trade_no'];
-            const paidAmount = amount?.['total'];
-            if (typeof orderId !== 'string' || typeof paidAmount !== 'number') {
-                return { ok: false, reason: 'bad_payload' };
-            }
-            return {
-                ok: true,
-                orderId,
-                paidAmount,
-                ...(typeof data['transaction_id'] === 'string'
-                    ? { channelTxnId: data['transaction_id'] }
-                    : {}),
-            };
-        }
-        catch {
-            return { ok: false, reason: 'decrypt_failed' };
-        }
-    }
-    async function queryOrder(orderId) {
-        try {
-            const urlPath = `/v3/pay/transactions/out-trade-no/${encodeURIComponent(orderId)}?mchid=${options.mchId}`;
-            const res = await request('GET', urlPath);
-            const state = res.trade_state;
-            if (state === 'SUCCESS') {
-                return { state: 'paid', ...(res.success_time ? { paidAt: res.success_time } : {}) };
-            }
-            if (state === 'CLOSED' || state === 'PAYERROR') {
-                return { state: 'closed' };
-            }
-            return { state: 'created' };
-        }
-        catch {
-            return { state: 'unknown', raw: { error: 'query_failed' } };
-        }
-    }
-    return {
-        name: 'wechat_official',
-        scenes: ['pc', 'h5', 'miniapp'],
-        callbackVerification: 'driver',
-        createOrder,
-        verifyCallback,
-        queryOrder,
-        successResponseText: 'SUCCESS',
-    };
-}