feat(billing): 支付 P5.2 —— 微信支付 Native 渠道（扫码充值）

wechatpay-go v0.2.21。凭据全 env 注入(WECHAT_MCHID/MCH_CERT_SERIAL/
MCH_PRIVATE_KEY/APIV3_KEY/APPID/NOTIFY_URL),缺一渠道即隐藏——半配置/假凭据
只打日志不拖垮 gateway(用假私钥实测过降级)。

- internal/payment:Native 下单出 code_url、APIv3 回调验签解密、主动查单,
  三者统一收敛为 QueryResult。
- 下单 POST /billing/orders {pack_id}(≥member+审计):金额/积分按在售包服务端
  锁定进订单行,不信任客户端;渠道下单失败即作废,不留付不了的 pending。
- 到账两条路汇入同一个 MarkOrderPaid 幂等闸(CAS+唯一索引双闸,同 P5.1):
  ①公开回调路由(验签是唯一的门;金额与订单不符不入账);②前端轮询的
  GET /billing/orders/:id 在 pending 时顺路主动查单——本地/内网收不到公网
  回调也能确认到账,回调只是生产更快的通道。pending 超 30 分钟置 expired。
- Web 面:在售包卡片(渠道亮才出现)→扫码弹窗(qrcode 画 code_url,二维码底色
  固定纯白——暗色主题下低对比码扫不出来)→2.5s 轮询→到账 toast+刷余额。

验证:go/tsc/vitest 全绿;无凭据+假凭据两种降级 live 四连
(channels 只剩 redeem/下单 400 引导兑换码/回调 503/兑换码闭环不受影响)。
⚠️ 真通道(prepay→扫码→回调/查单→入账)需真实商户号,未 live——用户配好
env 后用小额包实测,建议先配 ¥0.01 测试包走一单。

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

sundynix-gateway/internal/handler/billing_pay.go

@@ -3,6 +3,7 @@ package handler
 import (
 	"net/http"
 	"strings"
+	"time"
 
 	"github.com/gin-gonic/gin"
 	"github.com/sundynix/sundynix-gateway/internal/store"
@@ -12,14 +13,140 @@ import (
 // 入账目标一律是「计费租户」（ResolveBillingTenantID）——和消耗记账同一本账，
 // 谁的池子扣钱就往谁的池子充，别让用户充进一个花不到的池。
 
-// BillingPacks: GET /api/v1/billing/packs —— 在售积分包（微信渠道 P5.2 上线前仅展示）。
+// BillingPacks: GET /api/v1/billing/packs —— 在售积分包 + 可用渠道（wechat 配了 env 才亮）。
 func (h *Handler) BillingPacks(c *gin.Context) {
 	packs, err := h.db.ActivePacks(c.Request.Context())
 	if err != nil {
 		c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
 		return
 	}
-	c.JSON(http.StatusOK, gin.H{"packs": packs, "channels": []string{store.ChannelRedeem}})
+	channels := []string{store.ChannelRedeem}
+	if h.wechat != nil {
+		channels = append(channels, store.ChannelWechat)
+	}
+	c.JSON(http.StatusOK, gin.H{"packs": packs, "channels": channels})
+}
+
+// orderTTL 待支付订单的有效期：过期后前端轮询会把它置 expired，不再确认到账。
+// 微信 Native 的 code_url 本身约 2 小时有效，这里收紧到 30 分钟——挂太久的单
+// 价格可能已经改过，不让旧价格的单无限期可付。
+const orderTTL = 30 * time.Minute
+
+// BillingCreateOrder: POST /api/v1/billing/orders {pack_id} —— 微信 Native 下单，返回 code_url。
+// 金额/积分由服务端按在售包锁定进订单行，前端只传包 id，不信任任何客户端金额。
+func (h *Handler) BillingCreateOrder(c *gin.Context) {
+	if h.wechat == nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "微信支付未配置，请用兑换码充值"})
+		return
+	}
+	var b struct {
+		PackID string `json:"pack_id"`
+	}
+	if err := c.ShouldBindJSON(&b); err != nil || strings.TrimSpace(b.PackID) == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "pack_id 必填"})
+		return
+	}
+	ctx := c.Request.Context()
+	uid := userID(c)
+	billing := h.db.ResolveBillingTenantID(ctx, uid, tenantID(c))
+	if billing == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "无计费租户上下文"})
+		return
+	}
+	pk, err := h.db.GetPack(ctx, b.PackID)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "积分包不存在或已下架"})
+		return
+	}
+	o := &store.PaymentOrder{
+		TenantID: billing, UserID: uid, PackID: pk.ID,
+		AmountFen: pk.PriceFen, CreditsMicro: pk.CreditsMicro,
+		Channel: store.ChannelWechat, Status: store.OrderPending,
+	}
+	if err := h.db.CreateOrder(ctx, o); err != nil {
+		c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
+		return
+	}
+	codeURL, err := h.wechat.CreatePay(ctx, o.ID, "sundynix 积分充值 · "+pk.Name, pk.PriceFen)
+	if err != nil {
+		// 渠道下单失败的单直接作废，不留一堆永远付不了的 pending。
+		_ = h.db.ExpireOrder(ctx, o.ID)
+		c.JSON(http.StatusBadGateway, gin.H{"error": "微信下单失败: " + err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"order_id": o.ID, "code_url": codeURL, "amount_fen": o.AmountFen})
+}
+
+// BillingOrderStatus: GET /api/v1/billing/orders/:id —— 前端轮询订单态。
+// pending 时顺路主动查单确认（本地/内网收不到公网回调也能到账——回调只是生产更快的通道，
+// 两条路汇入同一个 MarkOrderPaid 幂等闸）；超过 TTL 置 expired。
+func (h *Handler) BillingOrderStatus(c *gin.Context) {
+	ctx := c.Request.Context()
+	o, err := h.db.GetOrder(ctx, c.Param("id"))
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "订单不存在"})
+		return
+	}
+	// 只允许看自己计费租户的单（订单表未挂租户插件，这里显式校验）。
+	if o.TenantID != h.db.ResolveBillingTenantID(ctx, userID(c), tenantID(c)) {
+		c.JSON(http.StatusNotFound, gin.H{"error": "订单不存在"})
+		return
+	}
+	if o.Status == store.OrderPending && h.wechat != nil {
+		if r, err := h.wechat.QueryOrder(ctx, o.ID); err == nil {
+			switch {
+			case r.Paid && r.AmountFen == o.AmountFen:
+				if _, err := h.db.MarkOrderPaid(ctx, o.ID, r.ChannelTxn); err == nil {
+					o, _ = h.db.GetOrder(ctx, o.ID)
+				}
+			case r.Paid: // 金额对不上：不入账，人工对账（比错账便宜）
+				c.JSON(http.StatusOK, gin.H{"order": o, "warn": "支付金额与订单不符，已挂起待人工核对"})
+				return
+			case r.Closed:
+				_ = h.db.ExpireOrder(ctx, o.ID)
+				o, _ = h.db.GetOrder(ctx, o.ID)
+			}
+		}
+		if o.Status == store.OrderPending && time.Since(o.CreatedAt) > orderTTL {
+			_ = h.db.ExpireOrder(ctx, o.ID)
+			o, _ = h.db.GetOrder(ctx, o.ID)
+		}
+	}
+	c.JSON(http.StatusOK, gin.H{"order": o})
+}
+
+// WechatCallback: POST /api/v1/billing/callback/wechat —— 微信支付回调（公开路由，验签是唯一的门）。
+// 应答契约：入账成功/重复推送都回 200 {code:SUCCESS}；验签失败 4xx；处理失败 5xx 让微信重试。
+func (h *Handler) WechatCallback(c *gin.Context) {
+	if h.wechat == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{"code": "FAIL", "message": "渠道未配置"})
+		return
+	}
+	r, err := h.wechat.VerifyCallback(c.Request)
+	if err != nil {
+		c.JSON(http.StatusUnauthorized, gin.H{"code": "FAIL", "message": "验签失败"})
+		return
+	}
+	if !r.Paid {
+		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS"}) // 非成功态通知：确认收到即可
+		return
+	}
+	ctx := c.Request.Context()
+	o, err := h.db.GetOrder(ctx, r.OrderID)
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS"}) // 不认识的单：可能是别的环境，别让微信无限重试
+		return
+	}
+	if r.AmountFen != o.AmountFen {
+		// 金额不符：不入账、不让重试（重试也不会变对），落审计人工处理。
+		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS"})
+		return
+	}
+	if _, err := h.db.MarkOrderPaid(ctx, o.ID, r.ChannelTxn); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": "FAIL", "message": "入账失败"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"code": "SUCCESS"})
 }
 
 // BillingRedeem: POST /api/v1/billing/redeem {code} —— 核销兑换码，积分入计费租户。

sundynix-gateway/internal/handler/task_handler.go

@@ -18,21 +18,29 @@ import (
 	"github.com/sundynix/sundynix-gateway/internal/blob"
 	"github.com/sundynix/sundynix-gateway/internal/dsl"
 	"github.com/sundynix/sundynix-gateway/internal/nats"
+	"github.com/sundynix/sundynix-gateway/internal/payment"
 	"github.com/sundynix/sundynix-gateway/internal/store"
 	"github.com/sundynix/sundynix-shared/contract"
 )
 
 type Handler struct {
-	db    *store.Postgres
-	cache *store.Redis
-	bus   *nats.Bus
-	blob  *blob.Store
+	db     *store.Postgres
+	cache  *store.Redis
+	bus    *nats.Bus
+	blob   *blob.Store
+	wechat *payment.Wechat // 微信支付渠道；nil=未配置（渠道隐藏）
 }
 
 func New(db *store.Postgres, cache *store.Redis, bus *nats.Bus, blob *blob.Store) *Handler {
 	return &Handler{db: db, cache: cache, bus: bus, blob: blob}
 }
 
+// WithWechat 注入微信支付渠道（nil 安全：保持隐藏）。
+func (h *Handler) WithWechat(w *payment.Wechat) *Handler {
+	h.wechat = w
+	return h
+}
+
 // preflight 是「会烧钱的执行」提交前的统一关卡：当日 token 预算 → 计费租户 → 积分硬拦截。
 // 返回计费租户；ok=false 表示已写过响应，调用方直接 return。
 //

sundynix-gateway/internal/payment/wechat.go

@@ -0,0 +1,154 @@
+// Package payment 是充值渠道适配层（设计见 PAYMENT_DESIGN.md §3/§5）。
+// P5.1 的兑换码不走这里（无「待支付」态，核销即入账）；本包面向真渠道：
+// 下单出支付凭据 → 回调/查单确认 → 上层 MarkOrderPaid 幂等入账。
+package payment
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/wechatpay-apiv3/wechatpay-go/core"
+	"github.com/wechatpay-apiv3/wechatpay-go/core/auth/verifiers"
+	"github.com/wechatpay-apiv3/wechatpay-go/core/downloader"
+	"github.com/wechatpay-apiv3/wechatpay-go/core/notify"
+	"github.com/wechatpay-apiv3/wechatpay-go/core/option"
+	"github.com/wechatpay-apiv3/wechatpay-go/services/payments"
+	"github.com/wechatpay-apiv3/wechatpay-go/services/payments/native"
+	"github.com/wechatpay-apiv3/wechatpay-go/utils"
+)
+
+// Wechat 微信支付 Native（扫码）适配器。凭据一律 env 注入：
+//
+//	WECHAT_MCHID              商户号
+//	WECHAT_MCH_CERT_SERIAL    商户 API 证书序列号
+//	WECHAT_MCH_PRIVATE_KEY    商户 API 私钥文件路径（apiclient_key.pem）
+//	WECHAT_APIV3_KEY          APIv3 密钥（32 字节）
+//	WECHAT_APPID              关联的公众号/小程序/APP 的 appid
+//	WECHAT_NOTIFY_URL         支付回调地址（须公网 https，如 https://api.example.com/api/v1/billing/callback/wechat）
+//
+// 任一缺失 → NewWechatFromEnv 返回 nil，渠道自动隐藏（半配置状态不许把下单路由搞出 5xx）。
+// 本地开发收不到公网回调没关系：前端轮询的 GET /billing/orders/:id 会主动查单确认，
+// 回调只是生产环境更快的到账通道，两条路都汇入同一个幂等入账闸。
+type Wechat struct {
+	mchID     string
+	appID     string
+	notifyURL string
+	apiv3Key  string
+	client    *core.Client
+	svc       native.NativeApiService
+}
+
+// NewWechatFromEnv 依据环境变量装配微信渠道；未配置（或配置不全/私钥读不了）返回 nil。
+func NewWechatFromEnv(ctx context.Context) *Wechat {
+	mchID := os.Getenv("WECHAT_MCHID")
+	serial := os.Getenv("WECHAT_MCH_CERT_SERIAL")
+	keyPath := os.Getenv("WECHAT_MCH_PRIVATE_KEY")
+	apiv3 := os.Getenv("WECHAT_APIV3_KEY")
+	appID := os.Getenv("WECHAT_APPID")
+	notifyURL := os.Getenv("WECHAT_NOTIFY_URL")
+	if mchID == "" && serial == "" && keyPath == "" && apiv3 == "" {
+		return nil // 完全未配置：静默（大多数开发环境）
+	}
+	if mchID == "" || serial == "" || keyPath == "" || apiv3 == "" || appID == "" || notifyURL == "" {
+		log.Printf("[payment] 微信支付配置不全（MCHID/CERT_SERIAL/PRIVATE_KEY/APIV3_KEY/APPID/NOTIFY_URL 缺一不可），渠道保持隐藏")
+		return nil
+	}
+	priv, err := utils.LoadPrivateKeyWithPath(keyPath)
+	if err != nil {
+		log.Printf("[payment] 微信商户私钥加载失败(%s)，渠道保持隐藏: %v", keyPath, err)
+		return nil
+	}
+	client, err := core.NewClient(ctx, option.WithWechatPayAutoAuthCipher(mchID, serial, priv, apiv3))
+	if err != nil {
+		log.Printf("[payment] 微信支付客户端初始化失败，渠道保持隐藏: %v", err)
+		return nil
+	}
+	log.Printf("[payment] 微信支付 Native 渠道已启用 (mchid=%s)", mchID)
+	return &Wechat{
+		mchID: mchID, appID: appID, notifyURL: notifyURL, apiv3Key: apiv3,
+		client: client, svc: native.NativeApiService{Client: client},
+	}
+}
+
+// CreatePay Native 下单：返回 code_url（前端渲染成二维码）。金额取订单锁定值。
+func (w *Wechat) CreatePay(ctx context.Context, orderID, description string, amountFen int64) (string, error) {
+	resp, _, err := w.svc.Prepay(ctx, native.PrepayRequest{
+		Appid:       core.String(w.appID),
+		Mchid:       core.String(w.mchID),
+		Description: core.String(description),
+		OutTradeNo:  core.String(orderID),
+		NotifyUrl:   core.String(w.notifyURL),
+		Amount:      &native.Amount{Total: core.Int64(amountFen), Currency: core.String("CNY")},
+	})
+	if err != nil {
+		return "", err
+	}
+	if resp.CodeUrl == nil || *resp.CodeUrl == "" {
+		return "", errors.New("微信未返回 code_url")
+	}
+	return *resp.CodeUrl, nil
+}
+
+// QueryResult 查单/回调解析后的统一结果。
+type QueryResult struct {
+	OrderID    string // out_trade_no
+	ChannelTxn string // transaction_id
+	Paid       bool   // TradeState == SUCCESS
+	Closed     bool   // CLOSED/REVOKED/PAYERROR 等终态失败
+	AmountFen  int64  // 用户实付（分）；回调/查单都带，供金额核对
+}
+
+func fromTransaction(t *payments.Transaction) QueryResult {
+	r := QueryResult{}
+	if t.OutTradeNo != nil {
+		r.OrderID = *t.OutTradeNo
+	}
+	if t.TransactionId != nil {
+		r.ChannelTxn = *t.TransactionId
+	}
+	if t.Amount != nil && t.Amount.PayerTotal != nil {
+		r.AmountFen = *t.Amount.PayerTotal
+	} else if t.Amount != nil && t.Amount.Total != nil {
+		r.AmountFen = *t.Amount.Total
+	}
+	if t.TradeState != nil {
+		switch *t.TradeState {
+		case "SUCCESS":
+			r.Paid = true
+		case "CLOSED", "REVOKED", "PAYERROR":
+			r.Closed = true
+		}
+	}
+	return r
+}
+
+// QueryOrder 主动查单（本地开发确认到账、生产掉单补偿共用）。
+func (w *Wechat) QueryOrder(ctx context.Context, orderID string) (QueryResult, error) {
+	t, _, err := w.svc.QueryOrderByOutTradeNo(ctx, native.QueryOrderByOutTradeNoRequest{
+		OutTradeNo: core.String(orderID),
+		Mchid:      core.String(w.mchID),
+	})
+	if err != nil {
+		return QueryResult{}, err
+	}
+	return fromTransaction(t), nil
+}
+
+// VerifyCallback 验签 + 解密支付回调（APIv3：平台证书验签、AES-GCM 解密资源）。
+// 验签失败一律拒绝——回调路由是公开的，签名是唯一的门。
+func (w *Wechat) VerifyCallback(req *http.Request) (QueryResult, error) {
+	certVisitor := downloader.MgrInstance().GetCertificateVisitor(w.mchID)
+	h, err := notify.NewRSANotifyHandler(w.apiv3Key, verifiers.NewSHA256WithRSAVerifier(certVisitor))
+	if err != nil {
+		return QueryResult{}, fmt.Errorf("回调处理器初始化失败: %w", err)
+	}
+	txn := new(payments.Transaction)
+	if _, err := h.ParseNotifyRequest(req.Context(), req, txn); err != nil {
+		return QueryResult{}, err
+	}
+	return fromTransaction(txn), nil
+}

sundynix-gateway/internal/router/router.go

@@ -2,6 +2,7 @@
 package router
 
 import (
+	"context"
 	"log"
 	"os"
 	"strings"
@@ -14,6 +15,7 @@ import (
 	"github.com/sundynix/sundynix-gateway/internal/handler"
 	"github.com/sundynix/sundynix-gateway/internal/middleware"
 	"github.com/sundynix/sundynix-gateway/internal/nats"
+	"github.com/sundynix/sundynix-gateway/internal/payment"
 	"github.com/sundynix/sundynix-gateway/internal/store"
 )
 
@@ -31,7 +33,8 @@ func New(db *store.Postgres, cache *store.Redis, bus *nats.Bus, blobStore *blob.
 	r.Use(middleware.RateLimit(cache))  // 已认证按用户限流，否则按 IP（企业网多人共享 IP 不再互相拖累）
 	r.Use(middleware.Guardrail(db))     // Harness: Input Guardrail（命中落库 guardrail_event）
 
-	h := handler.New(db, cache, bus, blobStore)
+	// 微信支付渠道按 env 装配；未配置返回 nil → 渠道自动隐藏，下单路由 400 引导用兑换码。
+	h := handler.New(db, cache, bus, blobStore).WithWechat(payment.NewWechatFromEnv(context.Background()))
 
 	// 可观测性根端点：Prometheus 抓取 + k8s 存活/就绪探针（不挂业务中间件鉴权）。
 	r.GET("/metrics", gin.WrapH(promhttp.Handler()))
@@ -50,6 +53,7 @@ func New(db *store.Postgres, cache *store.Redis, bus *nats.Bus, blobStore *blob.
 		api.GET("/kb/ingest/:id/stream", h.KbIngestStream) // 入库进度 SSE（job_id 寻址）
 		api.GET("/reports/:id/export", h.ExportReport)     // 按需导出（report_id 寻址）
 		api.GET("/reports/:id/download", h.ExportReport)   // 兼容旧入口（默认 docx）
+		api.POST("/billing/callback/wechat", h.WechatCallback) // 支付回调（渠道服务器带不了 Bearer；APIv3 验签是唯一的门）
 
 		// —— 受保护：owner 作用域业务，必须携带有效 JWT ——
 		p := api.Group("", middleware.RequireAuth())
@@ -105,10 +109,12 @@ func New(db *store.Postgres, cache *store.Redis, bus *nats.Bus, blobStore *blob.
 			p.POST("/spaces/:id/archive", h.SpaceArchive)             // 归档空间
 			p.POST("/reports", middleware.RequireTenantRole(db, store.RoleMember), h.GenerateReport) // 报告生成(同样烧租户积分)：viewer 只读拦下
 			p.GET("/billing", h.Billing)
-			// 充值（P5.1 兑换码）：核销会动钱，≥member + 审计；查询全员可看。
+			// 充值（P5.1 兑换码 + P5.2 微信 Native）：动钱的 ≥member + 审计；查询全员可看。
 			p.GET("/billing/packs", h.BillingPacks)
 			p.GET("/billing/orders", h.BillingOrders)
+			p.GET("/billing/orders/:id", h.BillingOrderStatus) // 轮询单态（pending 时顺路主动查单确认）
 			p.POST("/billing/redeem", middleware.RequireTenantRole(db, store.RoleMember), middleware.Audit(db), h.BillingRedeem)
+			p.POST("/billing/orders", middleware.RequireTenantRole(db, store.RoleMember), middleware.Audit(db), h.BillingCreateOrder)
 			p.GET("/stats/overview", h.StatsOverview) // 工作台仪表盘聚合
 			p.GET("/runs", h.Runs)                    // 运行历史（复盘）
 			p.GET("/tasks/:id/replay", h.TaskReplay)  // 历史运行复盘（持久化输出+轨迹，免 Redis TTL）

sundynix-gateway/internal/store/payment.go

@@ -191,6 +191,86 @@ func (p *Postgres) Redeem(ctx context.Context, code, tenantID, userID string) (*
 	return order, nil
 }
 
+// CreateOrder 落一张 pending 订单（价与积分由服务端按包锁定后传入）。
+func (p *Postgres) CreateOrder(ctx context.Context, o *PaymentOrder) error {
+	if p.db == nil {
+		return errStoreDisabled
+	}
+	return p.db.WithContext(WithoutTenant(ctx)).Create(o).Error
+}
+
+// GetOrder 按 id 取订单。
+func (p *Postgres) GetOrder(ctx context.Context, id string) (*PaymentOrder, error) {
+	if p.db == nil {
+		return nil, errStoreDisabled
+	}
+	var o PaymentOrder
+	if err := p.db.WithContext(WithoutTenant(ctx)).First(&o, "id = ?", id).Error; err != nil {
+		return nil, err
+	}
+	return &o, nil
+}
+
+// MarkOrderPaid 渠道确认已支付后的入账：一个事务里「订单 CAS(pending→paid) → 分录 → 物化余额」。
+// 返回 changed=false 表示这单已被处理过（回调重复推送/回调与主动查单赛跑），幂等直接成功。
+// 双闸：CAS 是主闸；credit_ledger (kind,ref=订单号) 唯一索引兜底。
+func (p *Postgres) MarkOrderPaid(ctx context.Context, orderID, channelTxn string) (bool, error) {
+	if p.db == nil {
+		return false, errStoreDisabled
+	}
+	changed := false
+	err := p.db.WithContext(WithoutTenant(ctx)).Transaction(func(tx *gorm.DB) error {
+		now := time.Now()
+		res := tx.Model(&PaymentOrder{}).
+			Where("id = ? AND status = ?", orderID, OrderPending).
+			Updates(map[string]any{"status": OrderPaid, "channel_txn": channelTxn, "paid_at": now})
+		if res.Error != nil {
+			return res.Error
+		}
+		if res.RowsAffected == 0 {
+			return nil // 已处理过（或订单不存在/已过期）——幂等，不重复入账
+		}
+		var o PaymentOrder
+		if err := tx.First(&o, "id = ?", orderID).Error; err != nil {
+			return err
+		}
+		if err := tx.Create(&CreditLedger{
+			TenantID: o.TenantID, Kind: LedgerGrant, CreditsMicro: o.CreditsMicro, Ref: o.ID, Memo: "充值 " + o.Channel,
+		}).Error; err != nil {
+			return err
+		}
+		if err := tx.Model(&Tenant{}).Where("id = ?", o.TenantID).
+			UpdateColumn("credit_balance_micro", gorm.Expr("credit_balance_micro + ?", o.CreditsMicro)).Error; err != nil {
+			return err
+		}
+		changed = true
+		return nil
+	})
+	return changed, err
+}
+
+// ExpireOrder 把超时未付的 pending 单置为 expired（CAS，已 paid 的不动）。
+func (p *Postgres) ExpireOrder(ctx context.Context, orderID string) error {
+	if p.db == nil {
+		return errStoreDisabled
+	}
+	return p.db.WithContext(WithoutTenant(ctx)).Model(&PaymentOrder{}).
+		Where("id = ? AND status = ?", orderID, OrderPending).
+		Update("status", OrderExpired).Error
+}
+
+// GetPack 按 id 取在售积分包（下单锁价用；下架的包不可下单）。
+func (p *Postgres) GetPack(ctx context.Context, id string) (*CreditPack, error) {
+	if p.db == nil {
+		return nil, errStoreDisabled
+	}
+	var pk CreditPack
+	if err := p.db.WithContext(WithoutTenant(ctx)).First(&pk, "id = ? AND active = ?", id, true).Error; err != nil {
+		return nil, err
+	}
+	return &pk, nil
+}
+
 // ActivePacks 在售积分包（用户侧展示）。
 func (p *Postgres) ActivePacks(ctx context.Context) ([]CreditPack, error) {
 	if p.db == nil {