feat: 扩展奖池、风控与报表能力，新增对账补偿、广播和人工操作接口

app/Services/Ticket/PlayCatalogResolver.php

@@ -144,6 +144,17 @@ final class PlayCatalogResolver
             return (int) $generic->cap_amount;
         }
 
+        $default = RiskCapItem::query()
+            ->where('version_id', $riskVersion->id)
+            ->whereNull('draw_id')
+            ->where('cap_type', 'default')
+            ->orderByDesc('id')
+            ->first();
+
+        if ($default !== null) {
+            return (int) $default->cap_amount;
+        }
+
         return 50_000_000_000;
     }
 }

app/Services/Ticket/RiskPoolService.php

@@ -25,6 +25,10 @@ final class RiskPoolService
         $rows = [];
         foreach ($locks as $lock) {
             $pool = $this->firstOrMakePool($drawId, $lock['number_4d']);
+            if ((int) $pool->sold_out_status === 1) {
+                throw new TicketOperationException('risk_sold_out', ErrorCode::RiskPoolSoldOut->value);
+            }
+
             $remaining = (int) $pool->remaining_amount;
             if ($remaining < (int) $lock['amount']) {
                 throw new TicketOperationException('risk_sold_out', ErrorCode::RiskPoolSoldOut->value);
@@ -82,7 +86,7 @@ final class RiskPoolService
                 }
 
                 $amount = (int) $lock['amount'];
-                if ((int) $pool->remaining_amount < $amount) {
+                if ((int) $pool->sold_out_status === 1 || (int) $pool->remaining_amount < $amount) {
                     throw new TicketOperationException('risk_sold_out', ErrorCode::RiskPoolSoldOut->value);
                 }
 
@@ -229,6 +233,10 @@ LUA;
             ->lockForUpdate()
             ->firstOrFail();
 
+        if ((int) $pool->sold_out_status === 1) {
+            throw new TicketOperationException('risk_sold_out', ErrorCode::RiskPoolSoldOut->value);
+        }
+
         $pool->forceFill([
             'locked_amount' => (int) $pool->locked_amount + $amount,
             'remaining_amount' => (int) $pool->remaining_amount - $amount,
@@ -295,16 +303,16 @@ LUA;
 
     private function firstOrMakePool(int $drawId, string $number4d): RiskPool
     {
-        return RiskPool::query()->firstOrCreate(
-            ['draw_id' => $drawId, 'normalized_number' => $number4d],
-            [
-                'total_cap_amount' => $this->catalogResolver->resolveCapAmount($drawId, $number4d),
-                'locked_amount' => 0,
-                'remaining_amount' => $this->catalogResolver->resolveCapAmount($drawId, $number4d),
-                'sold_out_status' => 0,
-                'version' => 0,
-            ],
-        );
+        $pool = RiskPool::query()
+            ->where('draw_id', $drawId)
+            ->where('normalized_number', $number4d)
+            ->first();
+
+        if ($pool !== null) {
+            return $pool;
+        }
+
+        return $this->createPool($drawId, $number4d);
     }
 
     private function createPool(int $drawId, string $number4d): RiskPool

app/Services/Ticket/TicketPendingConfirmReconcileService.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace App\Services\Ticket;
+
+use App\Models\WalletTxn;
+use App\Models\TicketItem;
+use App\Models\TicketOrder;
+use Illuminate\Support\Facades\DB;
+
+final class TicketPendingConfirmReconcileService
+{
+    public function __construct(
+        private readonly RiskPoolService $riskPool,
+    ) {}
+
+    /**
+     * @return array{scanned:int, confirmed:int, refunded:int}
+     */
+    public function reconcile(int $staleMinutes, int $limit): array
+    {
+        $cutoff = now()->subMinutes($staleMinutes);
+        $orders = TicketOrder::query()
+            ->where('status', 'pending_confirm')
+            ->where('updated_at', '<=', $cutoff)
+            ->orderBy('id')
+            ->limit($limit)
+            ->get();
+
+        $summary = ['scanned' => 0, 'confirmed' => 0, 'refunded' => 0];
+
+        foreach ($orders as $order) {
+            $result = DB::transaction(function () use ($order): string {
+                $lockedOrder = TicketOrder::query()
+                    ->whereKey($order->id)
+                    ->lockForUpdate()
+                    ->first();
+
+                if ($lockedOrder === null || $lockedOrder->status !== 'pending_confirm') {
+                    return 'skipped';
+                }
+
+                $hasPostedDeduct = WalletTxn::query()
+                    ->where('biz_type', 'bet_deduct')
+                    ->where('biz_no', $lockedOrder->order_no)
+                    ->where('status', 'posted')
+                    ->exists();
+
+                if ($hasPostedDeduct) {
+                    TicketItem::query()
+                        ->where('order_id', $lockedOrder->id)
+                        ->where('status', 'pending_confirm')
+                        ->update([
+                            'status' => 'success',
+                            'fail_reason_code' => null,
+                            'fail_reason_text' => null,
+                            'updated_at' => now(),
+                        ]);
+
+                    $lockedOrder->forceFill(['status' => 'placed'])->save();
+
+                    return 'confirmed';
+                }
+
+                $items = TicketItem::query()
+                    ->where('order_id', $lockedOrder->id)
+                    ->where('status', 'pending_confirm')
+                    ->with('combinations')
+                    ->lockForUpdate()
+                    ->get();
+
+                foreach ($items as $item) {
+                    $locks = [];
+                    foreach ($item->combinations as $combo) {
+                        $locks[] = [
+                            'number_4d' => (string) $combo->number_4d,
+                            'amount' => (int) $combo->estimated_payout,
+                        ];
+                    }
+
+                    if ($locks !== []) {
+                        $this->riskPool->release((int) $lockedOrder->draw_id, $item, $locks);
+                    }
+
+                    $item->forceFill([
+                        'status' => 'refunded',
+                        'fail_reason_code' => 'pending_confirm_timeout',
+                        'fail_reason_text' => 'pending_confirm_timeout_refund',
+                        'risk_locked_amount' => 0,
+                    ])->save();
+                }
+
+                $lockedOrder->forceFill(['status' => 'refunded'])->save();
+
+                return 'refunded';
+            });
+
+            if ($result === 'skipped') {
+                continue;
+            }
+
+            $summary['scanned']++;
+            if ($result === 'confirmed') {
+                $summary['confirmed']++;
+            }
+            if ($result === 'refunded') {
+                $summary['refunded']++;
+            }
+        }
+
+        return $summary;
+    }
+}

app/Services/Ticket/TicketPlacementService.php

@@ -8,6 +8,7 @@ use App\Lottery\ErrorCode;
 use App\Models\TicketItem;
 use App\Lottery\DrawStatus;
 use App\Models\TicketOrder;
+use App\Models\PlayerWallet;
 use App\Models\TicketCombination;
 use Illuminate\Support\Facades\DB;
 use App\Exceptions\TicketOperationException;
@@ -114,6 +115,16 @@ final class TicketPlacementService
                 );
             }
 
+            $walletBalance = (int) (PlayerWallet::query()
+                ->where('player_id', $player->id)
+                ->where('wallet_type', 'lottery')
+                ->where('currency_code', $currencyCode)
+                ->lockForUpdate()
+                ->value('balance') ?? 0);
+            if ($walletBalance < $totalActualDeduct) {
+                throw new TicketOperationException('bet_insufficient_balance', ErrorCode::BetInsufficientBalance->value);
+            }
+
             $order = TicketOrder::query()->create([
                 'order_no' => $this->newOrderNo(),
                 'player_id' => $player->id,
@@ -123,14 +134,13 @@ final class TicketPlacementService
                 'total_rebate_amount' => $totalRebate,
                 'total_actual_deduct' => $totalActualDeduct,
                 'total_estimated_payout' => $totalEstimatedPayout,
-                'status' => 'placed',
+                'status' => 'pending',
                 'submit_source' => 'h5',
                 'client_trace_id' => $payload['client_trace_id'] ?? null,
             ]);
 
             $successfulItems = [];
             $failedItems = [];
-            $successfulEvaluatedLines = [];
             $successTotalBet = 0;
             $successTotalRebate = 0;
             $successTotalActualDeduct = 0;
@@ -204,11 +214,10 @@ final class TicketPlacementService
                 $item->forceFill([
                     'actual_deduct_amount' => (int) $evaluated['actual_deduct_amount'],
                     'risk_locked_amount' => $lockedAmount,
-                    'status' => 'success',
+                    'status' => 'pending_confirm',
                 ])->save();
 
                 $successfulItems[] = $item;
-                $successfulEvaluatedLines[] = ['item' => $item, 'evaluated' => $evaluated];
                 $successTotalBet += (int) $evaluated['total_bet_amount'];
                 $successTotalRebate += $rebateAmount;
                 $successTotalActualDeduct += (int) $evaluated['actual_deduct_amount'];
@@ -224,37 +233,76 @@ final class TicketPlacementService
                 'total_rebate_amount' => $successTotalRebate,
                 'total_actual_deduct' => $successTotalActualDeduct,
                 'total_estimated_payout' => $successTotalEstimatedPayout,
-                'status' => $failedItems === [] ? 'placed' : 'partial_failed',
+                'status' => $failedItems === [] ? 'pending_confirm' : 'partial_pending_confirm',
             ])->save();
 
-            try {
-                $balanceAfter = $this->ticketWalletService->deduct($player, $currencyCode, $successTotalActualDeduct, $order);
-
-                foreach ($successfulItems as $item) {
-                    $this->jackpotContribution->recordFromPlacedTicketItem($item, $draw, $currencyCode);
-                }
-            } catch (\Throwable $e) {
-                foreach ($successfulEvaluatedLines as $row) {
-                    $locks = array_map(fn (array $combo): array => [
-                        'number_4d' => $combo['number_4d'],
-                        'amount' => $combo['estimated_payout'],
-                    ], $row['evaluated']['combinations']);
-                    $this->riskPoolService->release((int) $draw->id, $row['item'], $locks);
-                }
-
-                throw $e;
-            }
-
             return [
                 'order' => $order,
-                'balance_after' => $balanceAfter,
+                'draw_id' => (int) $draw->id,
+                'currency_code' => $currencyCode,
+                'successful_item_ids' => array_map(
+                    fn (TicketItem $item): int => (int) $item->id,
+                    $successfulItems,
+                ),
+                'has_failed_items' => $failedItems !== [],
+                'success_total_actual_deduct' => $successTotalActualDeduct,
             ];
         });
 
-        $order = $placement['order'];
-        $balanceAfter = $placement['balance_after'];
+        $order = TicketOrder::query()->whereKey($placement['order']->id)->firstOrFail();
+        $draw = Draw::query()->whereKey((int) $placement['draw_id'])->firstOrFail();
 
-        $draw = Draw::query()->whereKey($order->draw_id)->firstOrFail();
+        try {
+            $balanceAfter = $this->ticketWalletService->deduct($player, (string) $placement['currency_code'], (int) $placement['success_total_actual_deduct'], $order);
+
+            DB::transaction(function () use ($order, $draw, $placement): void {
+                $successfulItems = TicketItem::query()
+                    ->whereIn('id', $placement['successful_item_ids'])
+                    ->lockForUpdate()
+                    ->get();
+
+                foreach ($successfulItems as $item) {
+                    $item->forceFill(['status' => 'success'])->save();
+                    $this->jackpotContribution->recordFromPlacedTicketItem($item, $draw, (string) $placement['currency_code']);
+                }
+
+                $order->forceFill([
+                    'status' => $placement['has_failed_items'] ? 'partial_failed' : 'placed',
+                ])->save();
+            });
+        } catch (\Throwable $e) {
+            DB::transaction(function () use ($order): void {
+                $items = TicketItem::query()
+                    ->where('order_id', $order->id)
+                    ->where('status', 'pending_confirm')
+                    ->with('combinations')
+                    ->lockForUpdate()
+                    ->get();
+
+                foreach ($items as $item) {
+                    $locks = [];
+                    foreach ($item->combinations as $combo) {
+                        $locks[] = [
+                            'number_4d' => (string) $combo->number_4d,
+                            'amount' => (int) $combo->estimated_payout,
+                        ];
+                    }
+                    $this->riskPoolService->release((int) $order->draw_id, $item, $locks);
+                    $item->forceFill([
+                        'status' => 'refunded',
+                        'fail_reason_code' => (string) ErrorCode::BetInsufficientBalance->value,
+                        'fail_reason_text' => 'wallet_deduct_failed_refund',
+                        'risk_locked_amount' => 0,
+                    ])->save();
+                }
+
+                $order->forceFill(['status' => 'refunded'])->save();
+            });
+
+            throw $e;
+        }
+
+        $order = TicketOrder::query()->whereKey($order->id)->firstOrFail();
 
         return [
             'order_no' => $order->order_no,