@h-ai/payment 0.1.0-alpha5

package/dist/index.js

@@ -0,0 +1,854 @@
+import { paymentM, HaiPaymentError } from './chunk-4IUARFWH.js';
+export { HaiPaymentError } from './chunk-4IUARFWH.js';
+import { z } from 'zod';
+import { core, err, ok } from '@h-ai/core';
+import { audit } from '@h-ai/audit';
+import { createVerify, createDecipheriv, randomBytes, createSign, createHmac } from 'crypto';
+import { Buffer } from 'buffer';
+
+var WechatPayConfigSchema = z.object({
+  mchId: z.string().min(1, paymentM("payment_configFieldRequired")),
+  apiV3Key: z.string().min(1, paymentM("payment_configFieldRequired")),
+  serialNo: z.string().min(1, paymentM("payment_configFieldRequired")),
+  privateKey: z.string().min(1, paymentM("payment_configFieldRequired")),
+  platformCert: z.string().optional(),
+  appId: z.string().min(1, paymentM("payment_configFieldRequired"))
+});
+var AlipayConfigSchema = z.object({
+  appId: z.string().min(1, paymentM("payment_configFieldRequired")),
+  privateKey: z.string().min(1, paymentM("payment_configFieldRequired")),
+  alipayPublicKey: z.string().min(1, paymentM("payment_configFieldRequired")),
+  signType: z.enum(["RSA2", "RSA"]).default("RSA2"),
+  sandbox: z.boolean().default(false)
+});
+var StripeConfigSchema = z.object({
+  secretKey: z.string().min(1, paymentM("payment_configFieldRequired")),
+  webhookSecret: z.string().min(1, paymentM("payment_configFieldRequired"))
+});
+var PaymentConfigSchema = z.object({
+  wechat: WechatPayConfigSchema.optional(),
+  alipay: AlipayConfigSchema.optional(),
+  stripe: StripeConfigSchema.optional()
+});
+var logger = core.logger.child({ module: "payment", scope: "functions" });
+var providers = /* @__PURE__ */ new Map();
+async function auditLog(input) {
+  const result = await audit.log(input);
+  if (!result.success) {
+    logger.warn("Failed to write payment audit log", { action: input.action, error: result.error.message });
+  }
+}
+function registerProvider(provider) {
+  providers.set(provider.name, provider);
+}
+function getProvider(name) {
+  return providers.get(name);
+}
+function requireProvider(name) {
+  const provider = providers.get(name);
+  if (!provider) {
+    return err(
+      HaiPaymentError.PROVIDER_NOT_FOUND,
+      paymentM("payment_providerNotFound")
+    );
+  }
+  return ok(provider);
+}
+async function createOrder(providerName, input) {
+  const result = requireProvider(providerName);
+  if (!result.success)
+    return result;
+  const orderResult = await result.data.createOrder(input);
+  if (orderResult.success) {
+    await auditLog({
+      action: "create_order",
+      resource: "payment",
+      resourceId: input.orderNo,
+      details: { provider: providerName, amount: input.amount, tradeType: input.tradeType }
+    });
+  }
+  return orderResult;
+}
+async function handleNotify(providerName, request) {
+  const result = requireProvider(providerName);
+  if (!result.success)
+    return result;
+  const notifyResult = await result.data.handleNotify(request);
+  if (notifyResult.success) {
+    await auditLog({
+      action: "payment_notify",
+      resource: "payment",
+      resourceId: notifyResult.data.orderNo,
+      details: { provider: providerName, transactionId: notifyResult.data.transactionId, status: notifyResult.data.status, amount: notifyResult.data.amount }
+    });
+  }
+  return notifyResult;
+}
+async function queryOrder(providerName, orderNo) {
+  const result = requireProvider(providerName);
+  if (!result.success)
+    return result;
+  return result.data.queryOrder(orderNo);
+}
+async function refund(providerName, input) {
+  const result = requireProvider(providerName);
+  if (!result.success)
+    return result;
+  const refundResult = await result.data.refund(input);
+  if (refundResult.success) {
+    await auditLog({
+      action: "refund",
+      resource: "payment",
+      resourceId: input.orderNo,
+      details: { provider: providerName, refundNo: input.refundNo, amount: input.amount }
+    });
+  }
+  return refundResult;
+}
+async function closeOrder(providerName, orderNo) {
+  const result = requireProvider(providerName);
+  if (!result.success)
+    return result;
+  const closeResult = await result.data.closeOrder(orderNo);
+  if (closeResult.success) {
+    await auditLog({
+      action: "close_order",
+      resource: "payment",
+      resourceId: orderNo,
+      details: { provider: providerName }
+    });
+  }
+  return closeResult;
+}
+function clearProviders() {
+  providers.clear();
+}
+function signAlipayParams(params, privateKey, signType = "RSA2") {
+  const sorted = Object.keys(params).filter((k) => params[k] !== void 0 && params[k] !== "").sort().map((k) => `${k}=${params[k]}`).join("&");
+  const algorithm = signType === "RSA2" ? "RSA-SHA256" : "RSA-SHA1";
+  const sign = createSign(algorithm);
+  sign.update(sorted);
+  return sign.sign(privateKey, "base64");
+}
+function verifyAlipayNotify(params, alipayPublicKey) {
+  const sign = params.sign ?? "";
+  const signType = params.sign_type ?? "RSA2";
+  const sorted = Object.keys(params).filter((k) => k !== "sign" && k !== "sign_type" && params[k] !== void 0 && params[k] !== "").sort().map((k) => `${k}=${params[k]}`).join("&");
+  const algorithm = signType === "RSA2" ? "RSA-SHA256" : "RSA-SHA1";
+  const verify = createVerify(algorithm);
+  verify.update(sorted);
+  return verify.verify(alipayPublicKey, sign, "base64");
+}
+
+// src/providers/alipay/alipay-provider.ts
+var ALIPAY_GATEWAY = "https://openapi.alipay.com/gateway.do";
+var ALIPAY_SANDBOX_GATEWAY = "https://openapi-sandbox.dl.alipaydev.com/gateway.do";
+function createAlipayProvider(config) {
+  const gateway = config.sandbox ? ALIPAY_SANDBOX_GATEWAY : ALIPAY_GATEWAY;
+  const signType = config.signType ?? "RSA2";
+  function buildCommonParams(method, notifyUrl) {
+    return {
+      app_id: config.appId,
+      method,
+      charset: "utf-8",
+      sign_type: signType,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19),
+      version: "1.0",
+      notify_url: notifyUrl
+    };
+  }
+  function getTradeConfig(tradeType) {
+    const map = {
+      jsapi: { method: "alipay.trade.create", productCode: "JSAPI_PAY" },
+      h5: { method: "alipay.trade.wap.pay", productCode: "QUICK_WAP_WAY" },
+      app: { method: "alipay.trade.app.pay", productCode: "QUICK_MSECURITY_PAY" },
+      native: { method: "alipay.trade.precreate", productCode: "FACE_TO_FACE_PAYMENT" }
+    };
+    return map[tradeType] ?? map.h5;
+  }
+  async function alipayRequest(params) {
+    const sign = signAlipayParams(params, config.privateKey, signType);
+    const allParams = { ...params, sign };
+    const queryString = Object.entries(allParams).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+    const response = await fetch(`${gateway}?${queryString}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" }
+    });
+    if (!response.ok) {
+      throw new Error(`Alipay API failed: ${response.status}`);
+    }
+    return response.json();
+  }
+  return {
+    name: "alipay",
+    async createOrder(input) {
+      try {
+        const { method, productCode } = getTradeConfig(input.tradeType);
+        const bizContent = JSON.stringify({
+          out_trade_no: input.orderNo,
+          total_amount: (input.amount / 100).toFixed(2),
+          // 分 → 元
+          subject: input.description,
+          product_code: productCode,
+          passback_params: input.metadata ? JSON.stringify(input.metadata) : void 0
+        });
+        const params = {
+          ...buildCommonParams(method, input.notifyUrl),
+          biz_content: bizContent
+        };
+        const response = await alipayRequest(params);
+        const key = `${method.replace(/\./g, "_")}_response`;
+        const data = response[key];
+        return ok({
+          provider: "alipay",
+          tradeType: input.tradeType,
+          clientParams: data ?? {},
+          prepayId: data?.trade_no
+        });
+      } catch (cause) {
+        return err(
+          HaiPaymentError.CREATE_ORDER_FAILED,
+          paymentM("payment_createOrderFailed"),
+          cause
+        );
+      }
+    },
+    async handleNotify(request) {
+      try {
+        const params = {};
+        const pairs = request.body.split("&");
+        for (const pair of pairs) {
+          const [key, ...rest] = pair.split("=");
+          params[decodeURIComponent(key)] = decodeURIComponent(rest.join("="));
+        }
+        const valid = verifyAlipayNotify(params, config.alipayPublicKey);
+        if (!valid) {
+          return err(
+            HaiPaymentError.NOTIFY_VERIFY_FAILED,
+            paymentM("payment_notifyVerifyFailed")
+          );
+        }
+        const statusMap = {
+          TRADE_SUCCESS: "paid",
+          TRADE_CLOSED: "closed",
+          TRADE_FINISHED: "paid",
+          WAIT_BUYER_PAY: "pending"
+        };
+        return ok({
+          orderNo: params.out_trade_no,
+          transactionId: params.trade_no,
+          amount: Math.round(Number.parseFloat(params.total_amount) * 100),
+          // 元 → 分
+          status: statusMap[params.trade_status] ?? "pending",
+          paidAt: params.gmt_payment ? new Date(params.gmt_payment) : void 0,
+          raw: params
+        });
+      } catch (cause) {
+        return err(
+          HaiPaymentError.NOTIFY_PARSE_FAILED,
+          paymentM("payment_notifyParseFailed"),
+          cause
+        );
+      }
+    },
+    async queryOrder(orderNo) {
+      try {
+        const method = "alipay.trade.query";
+        const params = {
+          ...buildCommonParams(method, ""),
+          biz_content: JSON.stringify({ out_trade_no: orderNo })
+        };
+        const response = await alipayRequest(params);
+        const data = response.alipay_trade_query_response;
+        const statusMap = {
+          TRADE_SUCCESS: "paid",
+          TRADE_CLOSED: "closed",
+          TRADE_FINISHED: "paid",
+          WAIT_BUYER_PAY: "pending"
+        };
+        return ok({
+          orderNo,
+          transactionId: data?.trade_no,
+          status: statusMap[data?.trade_status] ?? "pending",
+          amount: Math.round(Number.parseFloat(data?.total_amount ?? "0") * 100),
+          paidAt: data?.send_pay_date ? new Date(data.send_pay_date) : void 0
+        });
+      } catch (cause) {
+        return err(
+          HaiPaymentError.QUERY_ORDER_FAILED,
+          paymentM("payment_queryOrderFailed"),
+          cause
+        );
+      }
+    },
+    async refund(input) {
+      try {
+        const method = "alipay.trade.refund";
+        const params = {
+          ...buildCommonParams(method, ""),
+          biz_content: JSON.stringify({
+            out_trade_no: input.orderNo,
+            out_request_no: input.refundNo,
+            refund_amount: (input.amount / 100).toFixed(2),
+            refund_reason: input.reason
+          })
+        };
+        const response = await alipayRequest(params);
+        const data = response.alipay_trade_refund_response;
+        return ok({
+          refundNo: input.refundNo,
+          refundId: data?.trade_no ?? "",
+          status: data?.fund_change === "Y" ? "success" : "processing"
+        });
+      } catch (cause) {
+        return err(
+          HaiPaymentError.REFUND_FAILED,
+          paymentM("payment_refundFailed"),
+          cause
+        );
+      }
+    },
+    async closeOrder(orderNo) {
+      try {
+        const method = "alipay.trade.close";
+        const params = {
+          ...buildCommonParams(method, ""),
+          biz_content: JSON.stringify({ out_trade_no: orderNo })
+        };
+        await alipayRequest(params);
+        return ok(void 0);
+      } catch (cause) {
+        return err(
+          HaiPaymentError.CLOSE_ORDER_FAILED,
+          paymentM("payment_closeOrderFailed"),
+          cause
+        );
+      }
+    }
+  };
+}
+var STRIPE_API_BASE = "https://api.stripe.com/v1";
+function createStripeProvider(config) {
+  async function stripeRequest(method, path, body) {
+    const response = await fetch(`${STRIPE_API_BASE}${path}`, {
+      method,
+      headers: {
+        "Authorization": `Bearer ${config.secretKey}`,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: body ? Object.entries(body).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&") : void 0
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Stripe API ${method} ${path} failed: ${response.status} ${errorText}`);
+    }
+    return response.json();
+  }
+  const TIMESTAMP_TOLERANCE = 300;
+  function verifyWebhookSignature(payload, signature) {
+    const parts = signature.split(",");
+    const timestamp = parts.find((p) => p.startsWith("t="))?.slice(2) ?? "";
+    const v1 = parts.find((p) => p.startsWith("v1="))?.slice(3) ?? "";
+    const ts = Number.parseInt(timestamp, 10);
+    if (Number.isNaN(ts) || Math.abs(Math.floor(Date.now() / 1e3) - ts) > TIMESTAMP_TOLERANCE) {
+      return false;
+    }
+    const signedPayload = `${timestamp}.${payload}`;
+    const expected = createHmac("sha256", config.webhookSecret).update(signedPayload).digest("hex");
+    try {
+      return core.string.constantTimeEqual(v1, expected);
+    } catch {
+      return false;
+    }
+  }
+  return {
+    name: "stripe",
+    async createOrder(input) {
+      try {
+        const params = {
+          "mode": "payment",
+          "line_items[0][price_data][currency]": input.currency?.toLowerCase() ?? "usd",
+          "line_items[0][price_data][product_data][name]": input.description,
+          "line_items[0][price_data][unit_amount]": input.amount.toString(),
+          "line_items[0][quantity]": "1"
+        };
+        params["metadata[orderNo]"] = input.orderNo;
+        if (input.metadata) {
+          for (const [k, v] of Object.entries(input.metadata)) {
+            params[`metadata[${k}]`] = v;
+          }
+        }
+        const session = await stripeRequest("POST", "/checkout/sessions", params);
+        return ok({
+          provider: "stripe",
+          tradeType: input.tradeType,
+          clientParams: {
+            sessionId: session.id,
+            checkoutUrl: session.url
+          }
+        });
+      } catch (cause) {
+        return err(
+          HaiPaymentError.CREATE_ORDER_FAILED,
+          paymentM("payment_createOrderFailed"),
+          cause
+        );
+      }
+    },
+    async handleNotify(request) {
+      try {
+        const signature = request.headers["stripe-signature"] ?? "";
+        const valid = verifyWebhookSignature(request.body, signature);
+        if (!valid) {
+          return err(
+            HaiPaymentError.NOTIFY_VERIFY_FAILED,
+            paymentM("payment_notifyVerifyFailed")
+          );
+        }
+        const event = JSON.parse(request.body);
+        const obj = event.data.object;
+        const orderNo = obj.metadata?.orderNo ?? "";
+        const statusMap = {
+          "checkout.session.completed": "paid",
+          "payment_intent.payment_failed": "failed"
+        };
+        return ok({
+          orderNo,
+          transactionId: obj.id,
+          amount: obj.amount_total ?? 0,
+          status: statusMap[event.type] ?? "pending",
+          paidAt: /* @__PURE__ */ new Date(),
+          raw: event
+        });
+      } catch (cause) {
+        return err(
+          HaiPaymentError.NOTIFY_PARSE_FAILED,
+          paymentM("payment_notifyParseFailed"),
+          cause
+        );
+      }
+    },
+    async queryOrder(orderNo) {
+      try {
+        const sessions = await stripeRequest("GET", `/checkout/sessions?limit=1&metadata[orderNo]=${encodeURIComponent(orderNo)}`);
+        const session = sessions.data[0];
+        if (!session) {
+          return ok({
+            orderNo,
+            status: "pending",
+            amount: 0
+          });
+        }
+        const statusMap = {
+          paid: "paid",
+          unpaid: "pending",
+          no_payment_required: "paid"
+        };
+        return ok({
+          orderNo,
+          transactionId: session.id,
+          status: statusMap[session.payment_status] ?? "pending",
+          amount: session.amount_total
+        });
+      } catch (cause) {
+        return err(
+          HaiPaymentError.QUERY_ORDER_FAILED,
+          paymentM("payment_queryOrderFailed"),
+          cause
+        );
+      }
+    },
+    async refund(input) {
+      try {
+        const sessions = await stripeRequest("GET", `/checkout/sessions?limit=1&metadata[orderNo]=${encodeURIComponent(input.orderNo)}`);
+        const paymentIntent = sessions.data[0]?.payment_intent;
+        if (!paymentIntent) {
+          return err(
+            HaiPaymentError.REFUND_FAILED,
+            paymentM("payment_refundFailed")
+          );
+        }
+        const refund2 = await stripeRequest("POST", "/refunds", {
+          payment_intent: paymentIntent,
+          amount: input.amount.toString(),
+          reason: input.reason ?? "requested_by_customer"
+        });
+        return ok({
+          refundNo: input.refundNo,
+          refundId: refund2.id,
+          status: refund2.status === "succeeded" ? "success" : "processing"
+        });
+      } catch (cause) {
+        return err(
+          HaiPaymentError.REFUND_FAILED,
+          paymentM("payment_refundFailed"),
+          cause
+        );
+      }
+    },
+    async closeOrder(_orderNo) {
+      return ok(void 0);
+    }
+  };
+}
+function generateNonce(length = 32) {
+  return randomBytes(length).toString("hex").slice(0, length);
+}
+function getTimestamp() {
+  return Math.floor(Date.now() / 1e3).toString();
+}
+function signRequest(method, url, timestamp, nonce, body, privateKey) {
+  const message = `${method}
+${url}
+${timestamp}
+${nonce}
+${body}
+`;
+  const sign = createSign("RSA-SHA256");
+  sign.update(message);
+  return sign.sign(privateKey, "base64");
+}
+function signJsapi(appId, timestamp, nonce, prepayId, privateKey) {
+  const message = `${appId}
+${timestamp}
+${nonce}
+prepay_id=${prepayId}
+`;
+  const sign = createSign("RSA-SHA256");
+  sign.update(message);
+  return sign.sign(privateKey, "base64");
+}
+function verifyNotifySignature(timestamp, nonce, body, signature, platformCert) {
+  const message = `${timestamp}
+${nonce}
+${body}
+`;
+  const verify = createVerify("RSA-SHA256");
+  verify.update(message);
+  return verify.verify(platformCert, signature, "base64");
+}
+function decryptResource(ciphertext, nonce, associatedData, apiV3Key) {
+  const buf = Buffer.from(ciphertext, "base64");
+  const authTag = buf.subarray(buf.length - 16);
+  const data = buf.subarray(0, buf.length - 16);
+  const decipher = createDecipheriv("aes-256-gcm", apiV3Key, nonce);
+  decipher.setAuthTag(authTag);
+  decipher.setAAD(Buffer.from(associatedData));
+  const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+  return decrypted.toString("utf-8");
+}
+
+// src/providers/wechat/wechat-pay-provider.ts
+var WECHAT_API_BASE = "https://api.mch.weixin.qq.com";
+function createWechatPayProvider(config) {
+  async function wechatRequest(method, path, body) {
+    const timestamp = getTimestamp();
+    const nonce = generateNonce();
+    const bodyStr = body ? JSON.stringify(body) : "";
+    const signature = signRequest(method, path, timestamp, nonce, bodyStr, config.privateKey);
+    const authorization = `WECHATPAY2-SHA256-RSA2048 mchid="${config.mchId}",nonce_str="${nonce}",timestamp="${timestamp}",serial_no="${config.serialNo}",signature="${signature}"`;
+    const response = await fetch(`${WECHAT_API_BASE}${path}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": authorization,
+        "Accept": "application/json"
+      },
+      body: bodyStr || void 0
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Wechat API ${method} ${path} failed: ${response.status} ${errorText}`);
+    }
+    return response.json();
+  }
+  function getOrderPath(tradeType) {
+    const map = {
+      jsapi: "/v3/pay/transactions/jsapi",
+      h5: "/v3/pay/transactions/h5",
+      app: "/v3/pay/transactions/app",
+      native: "/v3/pay/transactions/native"
+    };
+    return map[tradeType] ?? "/v3/pay/transactions/jsapi";
+  }
+  return {
+    name: "wechat",
+    async createOrder(input) {
+      try {
+        const requestBody = {
+          appid: config.appId,
+          mchid: config.mchId,
+          description: input.description,
+          out_trade_no: input.orderNo,
+          notify_url: input.notifyUrl,
+          amount: {
+            total: input.amount,
+            currency: input.currency ?? "CNY"
+          }
+        };
+        if (input.tradeType === "jsapi" && input.userId) {
+          requestBody.payer = { openid: input.userId };
+        }
+        if (input.metadata) {
+          requestBody.attach = JSON.stringify(input.metadata);
+        }
+        const path = getOrderPath(input.tradeType);
+        const response = await wechatRequest("POST", path, requestBody);
+        let clientParams = {};
+        if (input.tradeType === "jsapi") {
+          const timestamp = getTimestamp();
+          const nonce = generateNonce();
+          const paySign = signJsapi(config.appId, timestamp, nonce, response.prepay_id, config.privateKey);
+          clientParams = {
+            appId: config.appId,
+            timeStamp: timestamp,
+            nonceStr: nonce,
+            package: `prepay_id=${response.prepay_id}`,
+            signType: "RSA",
+            paySign
+          };
+        } else if (input.tradeType === "h5") {
+          clientParams = { h5Url: response.h5_url };
+        } else if (input.tradeType === "native") {
+          clientParams = { codeUrl: response.code_url };
+        }
+        return ok({
+          provider: "wechat",
+          tradeType: input.tradeType,
+          clientParams,
+          prepayId: response.prepay_id
+        });
+      } catch (cause) {
+        return err(
+          HaiPaymentError.CREATE_ORDER_FAILED,
+          paymentM("payment_createOrderFailed"),
+          cause
+        );
+      }
+    },
+    async handleNotify(request) {
+      try {
+        const timestamp = request.headers["wechatpay-timestamp"] ?? "";
+        const nonce = request.headers["wechatpay-nonce"] ?? "";
+        const signature = request.headers["wechatpay-signature"] ?? "";
+        if (!config.platformCert) {
+          return err(
+            HaiPaymentError.NOTIFY_VERIFY_FAILED,
+            paymentM("payment_notifyVerifyFailed")
+          );
+        }
+        const valid = verifyNotifySignature(timestamp, nonce, request.body, signature, config.platformCert);
+        if (!valid) {
+          return err(
+            HaiPaymentError.NOTIFY_VERIFY_FAILED,
+            paymentM("payment_notifyVerifyFailed")
+          );
+        }
+        const body = JSON.parse(request.body);
+        const decrypted = decryptResource(
+          body.resource.ciphertext,
+          body.resource.nonce,
+          body.resource.associated_data,
+          config.apiV3Key
+        );
+        const resource = JSON.parse(decrypted);
+        return ok({
+          orderNo: resource.out_trade_no,
+          transactionId: resource.transaction_id,
+          amount: resource.amount.total,
+          status: resource.trade_state === "SUCCESS" ? "paid" : "failed",
+          paidAt: resource.success_time ? new Date(resource.success_time) : void 0,
+          raw: resource
+        });
+      } catch (cause) {
+        return err(
+          HaiPaymentError.NOTIFY_PARSE_FAILED,
+          paymentM("payment_notifyParseFailed"),
+          cause
+        );
+      }
+    },
+    async queryOrder(orderNo) {
+      try {
+        const path = `/v3/pay/transactions/out-trade-no/${encodeURIComponent(orderNo)}?mchid=${encodeURIComponent(config.mchId)}`;
+        const response = await wechatRequest("GET", path);
+        const statusMap = {
+          SUCCESS: "paid",
+          CLOSED: "closed",
+          REFUND: "refunded",
+          NOTPAY: "pending",
+          PAYERROR: "failed"
+        };
+        return ok({
+          orderNo: response.out_trade_no,
+          transactionId: response.transaction_id,
+          status: statusMap[response.trade_state] ?? "pending",
+          amount: response.amount.total,
+          paidAt: response.success_time ? new Date(response.success_time) : void 0
+        });
+      } catch (cause) {
+        return err(
+          HaiPaymentError.QUERY_ORDER_FAILED,
+          paymentM("payment_queryOrderFailed"),
+          cause
+        );
+      }
+    },
+    async refund(input) {
+      try {
+        const response = await wechatRequest("POST", "/v3/refund/domestic/refunds", {
+          out_trade_no: input.orderNo,
+          out_refund_no: input.refundNo,
+          amount: {
+            refund: input.amount,
+            total: input.totalAmount ?? input.amount,
+            currency: "CNY"
+          },
+          reason: input.reason
+        });
+        const statusMap = {
+          SUCCESS: "success",
+          PROCESSING: "processing",
+          ABNORMAL: "failed"
+        };
+        return ok({
+          refundNo: input.refundNo,
+          refundId: response.refund_id,
+          status: statusMap[response.status] ?? "processing"
+        });
+      } catch (cause) {
+        return err(
+          HaiPaymentError.REFUND_FAILED,
+          paymentM("payment_refundFailed"),
+          cause
+        );
+      }
+    },
+    async closeOrder(orderNo) {
+      try {
+        await wechatRequest("POST", `/v3/pay/transactions/out-trade-no/${encodeURIComponent(orderNo)}/close`, {
+          mchid: config.mchId
+        });
+        return ok(void 0);
+      } catch (cause) {
+        return err(
+          HaiPaymentError.CLOSE_ORDER_FAILED,
+          paymentM("payment_closeOrderFailed"),
+          cause
+        );
+      }
+    }
+  };
+}
+
+// src/payment-main.ts
+var logger2 = core.logger.child({ module: "payment", scope: "main" });
+var currentConfig = null;
+var initInProgress = false;
+var notInitialized = core.module.createNotInitializedKit(
+  HaiPaymentError.NOT_INITIALIZED,
+  () => paymentM("payment_notInitialized")
+);
+var payment = {
+  /**
+   * 初始化支付模块
+   *
+   * 根据提供的配置自动注册对应的 Provider。
+   *
+   * @param config - 支付配置
+   */
+  async init(config) {
+    if (initInProgress) {
+      logger2.warn("Payment module init already in progress, skipping");
+      return err(
+        HaiPaymentError.CONFIG_ERROR,
+        paymentM("payment_configError", { params: { error: "init already in progress" } })
+      );
+    }
+    initInProgress = true;
+    try {
+      if (currentConfig !== null) {
+        logger2.warn("Payment module is already initialized, reinitializing");
+        await payment.close();
+      }
+      logger2.info("Initializing payment module");
+      const parseResult = PaymentConfigSchema.safeParse(config);
+      if (!parseResult.success) {
+        logger2.error("Payment config validation failed", { error: parseResult.error.message });
+        return err(
+          HaiPaymentError.CONFIG_ERROR,
+          paymentM("payment_configError", { params: { error: parseResult.error.message } }),
+          parseResult.error
+        );
+      }
+      const parsed = parseResult.data;
+      clearProviders();
+      if (parsed.wechat) {
+        registerProvider(createWechatPayProvider(parsed.wechat));
+      }
+      if (parsed.alipay) {
+        registerProvider(createAlipayProvider(parsed.alipay));
+      }
+      if (parsed.stripe) {
+        registerProvider(createStripeProvider(parsed.stripe));
+      }
+      currentConfig = parsed;
+      logger2.info("Payment module initialized", {
+        providers: [
+          parsed.wechat ? "wechat" : null,
+          parsed.alipay ? "alipay" : null,
+          parsed.stripe ? "stripe" : null
+        ].filter(Boolean)
+      });
+      return ok(void 0);
+    } catch (error) {
+      logger2.error("Payment module initialization failed", { error });
+      return err(
+        HaiPaymentError.CONFIG_ERROR,
+        paymentM("payment_initFailed", {
+          params: { error: error instanceof Error ? error.message : String(error) }
+        }),
+        error
+      );
+    } finally {
+      initInProgress = false;
+    }
+  },
+  /**
+   * 关闭模块、清除所有 Provider
+   */
+  async close() {
+    if (!currentConfig) {
+      logger2.info("Payment module already closed, skipping");
+      return;
+    }
+    logger2.info("Closing payment module");
+    clearProviders();
+    currentConfig = null;
+    logger2.info("Payment module closed");
+  },
+  get config() {
+    return currentConfig;
+  },
+  get isInitialized() {
+    return currentConfig !== null;
+  },
+  /** 创建支付订单 */
+  createOrder: (...args) => currentConfig ? createOrder(...args) : Promise.resolve(notInitialized.result()),
+  /** 处理异步回调通知 */
+  handleNotify: (...args) => currentConfig ? handleNotify(...args) : Promise.resolve(notInitialized.result()),
+  /** 查询订单状态 */
+  queryOrder: (...args) => currentConfig ? queryOrder(...args) : Promise.resolve(notInitialized.result()),
+  /** 发起退款 */
+  refund: (...args) => currentConfig ? refund(...args) : Promise.resolve(notInitialized.result()),
+  /** 关闭订单 */
+  closeOrder: (...args) => currentConfig ? closeOrder(...args) : Promise.resolve(notInitialized.result()),
+  /** 获取已注册的 Provider */
+  getProvider,
+  /** 手动注册 Provider（自定义渠道） */
+  registerProvider
+};
+
+export { AlipayConfigSchema, PaymentConfigSchema, StripeConfigSchema, WechatPayConfigSchema, payment };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map