feat(抽奖): 活动删除按钮 + 格子数可选(8/9,默认8)

- 活动列表加"删除"(ConfirmButton→DELETE /activities/:id)
- activity-form 格子数选项 [8,9]，新建默认 8（原来写死只有 9）
- service: deleteLotteryActivity；i18n 删除文案

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

apps/admin/public/assets/locales/en-US/lottery.json

@@ -0,0 +1,273 @@
+{
+  "activityTime": "Activity Time",
+  "cancel": "Cancel",
+  "confirm": "Confirm",
+  "confirmPause": "Are you sure you want to pause this activity?",
+  "confirmPublish": "Are you sure you want to publish this activity?",
+  "create": "Create",
+  "createActivity": "Create Activity",
+  "createSuccess": "Create Success",
+  "detail": {
+    "prizesTab": "Prizes",
+    "rulesTab": "Rules",
+    "claimsTab": "Claims",
+    "drawsTab": "Draw records"
+  },
+  "edit": "Edit",
+  "editActivity": "Edit Activity",
+  "form": {
+    "cancel": "Cancel",
+    "confirm": "Confirm",
+    "description": "Description",
+    "descriptionPlaceholder": "Activity description (Markdown supported)",
+    "endAt": "End Time",
+    "endAtAfterStartAt": "End time must be later than start time",
+    "endAtRequired": "End time is required",
+    "gridSize": "Grid Size",
+    "selectEndAt": "Select time",
+    "selectGridSize": "Select grid size",
+    "selectStartAt": "Select time",
+    "startAt": "Start Time",
+    "startAtRequired": "Start time is required",
+    "title": "Title",
+    "titlePlaceholder": "Activity title",
+    "titleRequired": "Title is required"
+  },
+  "grant": {
+    "amount": "Amount",
+    "description": "Manually grant draw chances to a user for activity: {{title}}",
+    "sourceRef": "Source Reference",
+    "sourceRefHint": "Idempotency key: the same reference only grants once. Repeated submissions will not grant again.",
+    "sourceRefPlaceholder": "grant-20260709-abc123",
+    "success": "Chances granted",
+    "title": "Grant Chances",
+    "userId": "User ID",
+    "userIdHint": "Enter the numeric user ID. You can find it in the user management list.",
+    "userIdPlaceholder": "e.g. 87433"
+  },
+  "grantChances": "Grant Chances",
+  "gridSize": "Grid Size",
+  "id": "ID",
+  "manage": "Manage",
+  "pause": "Pause",
+  "pauseSuccess": "Pause Success",
+  "pauseWarning": "Users will not be able to draw while the activity is paused.",
+  "prize": {
+    "addPrize": "Add Prize",
+    "amountPrecision": "Amount supports at most 2 decimal places",
+    "amountRequired": "Amount must be greater than 0",
+    "amountUnitHint": "Entered in CNY (yuan), stored as cents; up to 2 decimal places",
+    "amountYuan": "Commission Amount (CNY)",
+    "cancel": "Cancel",
+    "centerSlotHint": "Usually the draw button",
+    "claimTtlHint": "How long the user has to submit claim info. Default 168h (7 days).",
+    "claimTtlHours": "Claim window (hours)",
+    "claimTtlInvalid": "Claim window (hours) must be a positive integer",
+    "confirm": "Confirm",
+    "confirmDelete": "Delete",
+    "createSuccess": "Prize created",
+    "createTitle": "Add Prize",
+    "cryptoAmount": "Amount",
+    "cryptoAmountPlaceholder": "e.g. 0.01",
+    "cryptoAmountRequired": "Amount is required",
+    "cryptoCurrency": "Currency",
+    "cryptoCurrencyRequired": "Currency is required",
+    "cryptoNetworks": "Networks",
+    "cryptoNetworksHint": "Comma-separated. The user picks one of these when claiming.",
+    "cryptoNetworksRequired": "At least one network is required (comma-separated)",
+    "daysSuffix": "days",
+    "delete": "Delete",
+    "deleteDescription": "This prize will be removed from the grid. This action cannot be undone.",
+    "deleteSuccess": "Prize deleted",
+    "deleteTitle": "Delete this prize?",
+    "durationDays": "Duration (days)",
+    "durationDaysPlaceholder": "e.g. 1",
+    "durationDaysRequired": "Duration days must be a positive integer",
+    "durationSummary": "{{days}} days",
+    "editTitle": "Edit Prize",
+    "fallbackBadge": "Fallback",
+    "fallbackIgnoresWeight": "Fallback prize ignores probability (never randomly drawn)",
+    "hoursSuffix": "hours",
+    "iconUrl": "Icon URL",
+    "iconUrlInvalid": "Must be a valid URL",
+    "isFallback": "Fallback Prize",
+    "isFallbackHint": "Awarded when limited prizes are sold out",
+    "manualPrizeHint": "Manual prize: the winner submits claim info, then an operator approves and marks it paid/shipped under the Claims tab.",
+    "name": "Prize Name",
+    "namePlaceholder": "e.g. 1-Day Pass",
+    "nameRequired": "Name is required",
+    "noFallbackHint": "Consider configuring a fallback prize so draws never fail when limited prizes run out.",
+    "noFallbackTitle": "No fallback prize",
+    "noRandomPrizes": "No prizes participate in the random draw yet",
+    "noneHint": "No config needed. Consider enabling fallback so users always land on this prize when limited prizes run out.",
+    "probabilityPreview": "Probability Preview",
+    "probabilityTotal": "Total",
+    "selectType": "Select type",
+    "skuName": "Item name (optional)",
+    "skuNamePlaceholder": "e.g. Limited T-shirt",
+    "slotLabel": "Slot",
+    "soldOutBadge": "Sold Out",
+    "stockShort": "Stock",
+    "subscribePlan": "New-subscription plan",
+    "subscribePlanHint": "When the user has no active subscription, create one on this plan and grant the duration. Leave empty to skip granting.",
+    "subscribePlanPlaceholder": "None — skip if user has no active subscription",
+    "totalNot100Hint": "The drawable prizes currently total {{total}}%. Adjust each prize's win probability so they sum to exactly 100%.",
+    "totalNot100Title": "Probabilities must total 100%",
+    "totalStock": "Total Stock",
+    "totalStockPlaceholder": "e.g. 100",
+    "totalStockRequired": "Total stock must be a positive integer",
+    "type": "Prize Type",
+    "typeCommission": "Commission",
+    "typeCoupon": "Coupon",
+    "typeCrypto": "Crypto",
+    "typeManualOther": "Manual (Other)",
+    "typeNone": "No Prize (Thanks)",
+    "typePhysical": "Physical",
+    "typePoints": "Points",
+    "typeVpnDuration": "VPN Duration",
+    "unlimitedStock": "Unlimited Stock",
+    "updateSuccess": "Prize updated",
+    "weight": "Win probability (%)",
+    "weightHint": "Percent chance in the grid. All drawable prizes must total 100%. 0 = shown but never drawn.",
+    "weightInteger": "Probability must be an integer",
+    "weightMax": "Probability cannot exceed 100",
+    "weightMin": "Probability must be at least 0",
+    "weightShort": "Prob",
+    "yuanSuffix": "CNY"
+  },
+  "publish": "Publish",
+  "publishSuccess": "Publish Success",
+  "publishWarning": "Once published, the activity becomes visible to users.",
+  "rules": {
+    "addCondition": "Add Condition",
+    "addSource": "Add Source",
+    "amount": "Amount",
+    "cannotSimplify": "This rule tree is too complex for simple mode. Please edit it in Advanced mode.",
+    "capsBytesExceeded": "Size {{value}} bytes exceeds limit {{limit}} bytes",
+    "capsDepthExceeded": "Depth {{value}} exceeds limit {{limit}}",
+    "capsExceeded": "Rule tree exceeds limits",
+    "capsNodesExceeded": "Node count {{value}} exceeds limit {{limit}}",
+    "chanceSources": "Chance Sources",
+    "chanceSourcesDescription": "Configure how users earn draw chances. Each source can only appear once.",
+    "conditionType": {
+      "has_subscription": "Has Subscription",
+      "invite_count": "Invite Count",
+      "register_days": "Register Days",
+      "subscription_type": "Subscription Type",
+      "total_recharge": "Total Recharge",
+      "user_tag": "User Tag"
+    },
+    "dailyLimit": "Daily limit (optional)",
+    "duplicateSource": "Duplicate source",
+    "eligibility": "Eligibility",
+    "jsonInvalid": "Invalid JSON: {{error}}",
+    "jsonMustBeObject": "Rule tree must be a JSON object",
+    "jsonPlaceholder": "Rule tree JSON, e.g. {\"op\":\"AND\",\"children\":[...]}. Leave empty for no requirement.",
+    "noConditions": "No conditions. Everyone is eligible to join.",
+    "op": "Combine Conditions With",
+    "opAnd": "AND",
+    "opOr": "OR",
+    "param": {
+      "min": "Min Count",
+      "minDaysRemaining": "Min Days Remaining",
+      "minUsdt": "Min USDT",
+      "planIds": "Plan IDs",
+      "planIdsPlaceholder": "Comma separated, e.g. 1,2,3",
+      "tags": "Tags",
+      "tagsPlaceholder": "Comma separated, e.g. vip,beta",
+      "windowDays": "Window Days (optional)"
+    },
+    "save": "Save Rules",
+    "saveFailed": "Failed to save rules",
+    "saveSuccess": "Rules saved",
+    "selectSource": "Select source",
+    "simpleMode": "Simple",
+    "advancedMode": "Advanced (JSON)",
+    "source": {
+      "dailySignin": "Daily Sign-in",
+      "inviteSuccess": "Invite Success",
+      "manualGrant": "Manual Grant",
+      "newSubscription": "New Subscription"
+    },
+    "stage1Warning": "Stage 1 notice",
+    "stage1WarningDescription": "The rule context is not wired up in the current version (Stage 1). Configuring eligibility will prevent users from joining the lottery. It is recommended to keep it empty."
+  },
+  "status": {
+    "draft": "Draft",
+    "ended": "Ended",
+    "paused": "Paused",
+    "running": "Running"
+  },
+  "statusAll": "All",
+  "statusLabel": "Status",
+  "title": "Title",
+  "updateSuccess": "Update Success",
+  "claim": {
+    "approve": "Approve",
+    "approveDescription": "Approving moves this claim to the paying/shipping stage.",
+    "approveSuccess": "Claim approved",
+    "approveTitle": "Approve this claim?",
+    "cancel": "Cancel",
+    "claimData": "Claim info",
+    "confirm": "Confirm",
+    "confirmMarkPaid": "Confirm",
+    "confirmReject": "Confirm reject",
+    "createdAt": "Won at",
+    "deliveryRef": "Delivery ref",
+    "deliveryRefPlaceholder": "Tracking number",
+    "deliveryRefRequired": "Delivery ref is required for physical",
+    "expiresAt": "Expires",
+    "filterStatus": "Status",
+    "filterType": "Type",
+    "filterUserId": "User ID",
+    "fulfillment": "Tx / Delivery",
+    "markPaid": "Mark fulfilled",
+    "markPaidDescription": "Crypto requires a tx hash; physical requires a delivery ref; manual requires at least one.",
+    "markPaidSuccess": "Marked as fulfilled",
+    "markPaidTitle": "Mark as fulfilled",
+    "oneRefRequired": "Fill at least one field",
+    "prize": "Prize",
+    "reason": "Reason",
+    "reasonPlaceholder": "Reason shown to the user",
+    "reasonRequired": "Please enter a reason",
+    "reasonTooLong": "Reason cannot exceed 512 chars",
+    "reject": "Reject",
+    "rejectDescription": "The reason is shown to the user, who may then resubmit.",
+    "rejectSuccess": "Claim rejected",
+    "rejectTitle": "Reject claim",
+    "status": "Status",
+    "statusExpired": "Expired",
+    "statusPaid": "Fulfilled",
+    "statusPaying": "Paying / Shipping",
+    "statusPending": "Awaiting user",
+    "statusRejected": "Rejected",
+    "statusReviewing": "Reviewing",
+    "tableTitle": "Claims",
+    "txHash": "Tx hash",
+    "txHashRequired": "Tx hash is required for crypto",
+    "user": "User"
+  },
+  "draw": {
+    "dispatchAutoClaimed": "Auto-granted",
+    "dispatchExpired": "Expired",
+    "dispatchFailed": "Failed",
+    "dispatchNone": "Pending",
+    "dispatchPaid": "Fulfilled",
+    "dispatchPendingClaim": "Awaiting claim",
+    "dispatchState": "Dispatch",
+    "drawnAt": "Drawn at",
+    "filterDispatch": "Dispatch",
+    "filterUserId": "User ID",
+    "filterWin": "Won?",
+    "grant": "Grant result",
+    "loseOnly": "Not won",
+    "prize": "Prize",
+    "tableTitle": "Draw records",
+    "user": "User",
+    "winOnly": "Won"
+  },
+  "delete": "Delete",
+  "deleteSuccess": "Deleted",
+  "confirmDeleteActivity": "Delete this activity?",
+  "confirmDeleteActivityDesc": "This permanently deletes the activity and its prizes. A running activity must be paused first. This cannot be undone."
+}

apps/admin/public/assets/locales/en-US/menu.json

@@ -14,6 +14,7 @@
   "Invite Management": "Invite Management",
   "Login": "Login",
   "Logs & Analytics": "Logs & Analytics",
+  "Lottery Management": "Lottery Management",
   "Maintenance": "Maintenance",
   "Marketing Management": "Marketing Management",
   "Mobile": "Mobile",

apps/admin/public/assets/locales/zh-CN/lottery.json

@@ -0,0 +1,273 @@
+{
+  "activityTime": "活动时间",
+  "cancel": "取消",
+  "confirm": "确认",
+  "confirmPause": "确定要暂停该活动吗？",
+  "confirmPublish": "确定要上架该活动吗？",
+  "create": "创建",
+  "createActivity": "创建活动",
+  "createSuccess": "创建成功",
+  "detail": {
+    "prizesTab": "奖品",
+    "rulesTab": "规则",
+    "claimsTab": "领奖工单",
+    "drawsTab": "抽奖记录"
+  },
+  "edit": "编辑",
+  "editActivity": "编辑活动",
+  "form": {
+    "cancel": "取消",
+    "confirm": "确认",
+    "description": "活动描述",
+    "descriptionPlaceholder": "活动描述（支持 Markdown）",
+    "endAt": "结束时间",
+    "endAtAfterStartAt": "结束时间必须晚于开始时间",
+    "endAtRequired": "请选择结束时间",
+    "gridSize": "格子数",
+    "selectEndAt": "选择时间",
+    "selectGridSize": "选择格子数",
+    "selectStartAt": "选择时间",
+    "startAt": "开始时间",
+    "startAtRequired": "请选择开始时间",
+    "title": "标题",
+    "titlePlaceholder": "活动标题",
+    "titleRequired": "请输入活动标题"
+  },
+  "grant": {
+    "amount": "发放数量",
+    "description": "为用户手动发放活动「{{title}}」的抽奖次数",
+    "sourceRef": "来源引用号",
+    "sourceRefHint": "幂等键：相同的引用号只会发放一次，重复提交不会重复发放。",
+    "sourceRefPlaceholder": "grant-20260709-abc123",
+    "success": "次数发放成功",
+    "title": "发放次数",
+    "userId": "用户 ID",
+    "userIdHint": "请输入用户的数字 ID，可在用户管理列表中查看。",
+    "userIdPlaceholder": "例如：87433"
+  },
+  "grantChances": "发放次数",
+  "gridSize": "格子数",
+  "id": "ID",
+  "manage": "管理",
+  "pause": "暂停",
+  "pauseSuccess": "暂停成功",
+  "pauseWarning": "活动暂停期间，用户将无法抽奖。",
+  "prize": {
+    "addPrize": "添加奖品",
+    "amountPrecision": "金额最多支持 2 位小数",
+    "amountRequired": "金额必须大于 0",
+    "amountUnitHint": "以元为单位输入，按分存储；最多支持 2 位小数",
+    "amountYuan": "佣金金额（元）",
+    "cancel": "取消",
+    "centerSlotHint": "通常为抽奖按钮",
+    "claimTtlHint": "用户提交领奖信息的时限，缺省 168 小时（7 天）。",
+    "claimTtlHours": "领奖窗口（小时）",
+    "claimTtlInvalid": "领奖窗口（小时）必须为正整数",
+    "confirm": "确认",
+    "confirmDelete": "删除",
+    "createSuccess": "奖品创建成功",
+    "createTitle": "添加奖品",
+    "cryptoAmount": "金额",
+    "cryptoAmountPlaceholder": "例如：0.01",
+    "cryptoAmountRequired": "请输入金额",
+    "cryptoCurrency": "币种",
+    "cryptoCurrencyRequired": "请输入币种",
+    "cryptoNetworks": "网络",
+    "cryptoNetworksHint": "逗号分隔，用户领奖时从中选择一个网络。",
+    "cryptoNetworksRequired": "至少填写一个网络（逗号分隔）",
+    "daysSuffix": "天",
+    "delete": "删除",
+    "deleteDescription": "该奖品将从九宫格中移除，此操作不可撤销。",
+    "deleteSuccess": "奖品删除成功",
+    "deleteTitle": "确定删除该奖品吗？",
+    "durationDays": "时长（天）",
+    "durationDaysPlaceholder": "例如：1",
+    "durationDaysRequired": "时长天数必须为正整数",
+    "durationSummary": "{{days}} 天",
+    "editTitle": "编辑奖品",
+    "fallbackBadge": "保底",
+    "fallbackIgnoresWeight": "保底奖品不参与概率（永不被随机抽中）",
+    "hoursSuffix": "小时",
+    "iconUrl": "图标 URL",
+    "iconUrlInvalid": "请输入有效的 URL",
+    "isFallback": "保底奖品",
+    "isFallbackHint": "限量奖品抽完后发放该奖品",
+    "manualPrizeHint": "人工奖：用户先提交领奖信息，运营在「领奖工单」页审核并标记发放/发货。",
+    "name": "奖品名称",
+    "namePlaceholder": "例如：1 天时长卡",
+    "nameRequired": "请输入奖品名称",
+    "noFallbackHint": "建议配置一个保底奖品，避免限量奖品抽完后抽奖失败。",
+    "noFallbackTitle": "未配置保底奖品",
+    "noRandomPrizes": "暂无参与随机抽取的奖品",
+    "noneHint": "无需额外配置。建议开启保底，限量奖品抽完后用户将始终抽中该奖品。",
+    "probabilityPreview": "概率预览",
+    "probabilityTotal": "合计",
+    "selectType": "选择类型",
+    "skuName": "物品名称（可选）",
+    "skuNamePlaceholder": "例如：限量 T 恤",
+    "slotLabel": "格子",
+    "soldOutBadge": "已抽完",
+    "stockShort": "库存",
+    "subscribePlan": "无订阅时新建套餐",
+    "subscribePlanHint": "当用户无活跃订阅时，按该套餐新建订阅并发放时长；留空则跳过发放。",
+    "subscribePlanPlaceholder": "不选：用户无活跃订阅时跳过发放",
+    "totalNot100Hint": "当前可抽奖品概率合计 {{total}}%。请调整各奖品的中奖概率，使其精确等于 100%。",
+    "totalNot100Title": "概率合计必须为 100%",
+    "totalStock": "总库存",
+    "totalStockPlaceholder": "例如：100",
+    "totalStockRequired": "总库存必须为正整数",
+    "type": "奖品类型",
+    "typeCommission": "佣金",
+    "typeCoupon": "优惠券",
+    "typeCrypto": "加密货币",
+    "typeManualOther": "人工发放（其他）",
+    "typeNone": "谢谢参与",
+    "typePhysical": "实物奖品",
+    "typePoints": "积分",
+    "typeVpnDuration": "免费时长",
+    "unlimitedStock": "无限库存",
+    "updateSuccess": "奖品更新成功",
+    "weight": "中奖概率（%）",
+    "weightHint": "九宫格内的中奖概率。所有参与随机的奖品合计须为 100%。0 = 展示但不参与随机。",
+    "weightInteger": "概率必须为整数",
+    "weightMax": "概率不能超过 100",
+    "weightMin": "概率不能小于 0",
+    "weightShort": "概率",
+    "yuanSuffix": "元"
+  },
+  "publish": "上架",
+  "publishSuccess": "上架成功",
+  "publishWarning": "上架后活动将对用户可见。",
+  "rules": {
+    "addCondition": "添加条件",
+    "addSource": "添加来源",
+    "amount": "次数",
+    "cannotSimplify": "规则树结构较复杂，无法用简单模式编辑，请在高级(JSON)模式下修改",
+    "capsBytesExceeded": "大小 {{value}} 字节超过上限 {{limit}} 字节",
+    "capsDepthExceeded": "深度 {{value}} 超过上限 {{limit}}",
+    "capsExceeded": "规则树超出限制",
+    "capsNodesExceeded": "节点数 {{value}} 超过上限 {{limit}}",
+    "chanceSources": "次数来源",
+    "chanceSourcesDescription": "配置用户获取抽奖次数的方式，每种来源只能配置一次。",
+    "conditionType": {
+      "has_subscription": "持有订阅",
+      "invite_count": "邀请人数",
+      "register_days": "注册天数",
+      "subscription_type": "订阅套餐类型",
+      "total_recharge": "累计充值",
+      "user_tag": "用户标签"
+    },
+    "dailyLimit": "每日上限（可选）",
+    "duplicateSource": "来源不能重复",
+    "eligibility": "参与门槛",
+    "jsonInvalid": "JSON 无效：{{error}}",
+    "jsonMustBeObject": "规则树必须是 JSON 对象",
+    "jsonPlaceholder": "规则树 JSON，例如 {\"op\":\"AND\",\"children\":[...]}，留空表示无门槛。",
+    "noConditions": "暂无条件，所有用户均可参与。",
+    "op": "条件组合方式",
+    "opAnd": "且（AND）",
+    "opOr": "或（OR）",
+    "param": {
+      "min": "最小数量",
+      "minDaysRemaining": "剩余天数下限",
+      "minUsdt": "最低 USDT 金额",
+      "planIds": "套餐 ID",
+      "planIdsPlaceholder": "逗号分隔，例如 1,2,3",
+      "tags": "标签",
+      "tagsPlaceholder": "逗号分隔，例如 vip,beta",
+      "windowDays": "时间窗口天数（可选）"
+    },
+    "save": "保存规则",
+    "saveFailed": "规则保存失败",
+    "saveSuccess": "规则保存成功",
+    "selectSource": "选择来源",
+    "simpleMode": "简单模式",
+    "advancedMode": "高级模式（JSON）",
+    "source": {
+      "dailySignin": "每日签到",
+      "inviteSuccess": "邀请成功",
+      "manualGrant": "手动发放",
+      "newSubscription": "新订阅"
+    },
+    "stage1Warning": "Stage 1 提示",
+    "stage1WarningDescription": "当前版本（Stage 1）规则上下文尚未接线，配置门槛将导致用户无法参与抽奖，建议保持为空。"
+  },
+  "status": {
+    "draft": "草稿",
+    "ended": "已结束",
+    "paused": "已暂停",
+    "running": "进行中"
+  },
+  "statusAll": "全部",
+  "statusLabel": "状态",
+  "title": "标题",
+  "updateSuccess": "更新成功",
+  "claim": {
+    "approve": "通过",
+    "approveDescription": "通过后工单进入待发放/发货阶段。",
+    "approveSuccess": "工单已通过",
+    "approveTitle": "确认通过该工单？",
+    "cancel": "取消",
+    "claimData": "领奖信息",
+    "confirm": "确认",
+    "confirmMarkPaid": "确认",
+    "confirmReject": "确认驳回",
+    "createdAt": "中奖时间",
+    "deliveryRef": "物流单号",
+    "deliveryRefPlaceholder": "快递单号",
+    "deliveryRefRequired": "实物奖品必须填写物流单号",
+    "expiresAt": "过期时间",
+    "filterStatus": "状态",
+    "filterType": "类型",
+    "filterUserId": "用户 ID",
+    "fulfillment": "交易/物流单号",
+    "markPaid": "标记发放",
+    "markPaidDescription": "加密货币需填交易哈希；实物需填物流单号；人工其他至少填一项。",
+    "markPaidSuccess": "已标记发放",
+    "markPaidTitle": "标记为已发放",
+    "oneRefRequired": "至少填写一项",
+    "prize": "奖品",
+    "reason": "驳回原因",
+    "reasonPlaceholder": "填写驳回原因，用户端会看到",
+    "reasonRequired": "请填写驳回原因",
+    "reasonTooLong": "驳回原因不能超过 512 字",
+    "reject": "驳回",
+    "rejectDescription": "驳回原因会展示给用户，用户可重新提交。",
+    "rejectSuccess": "工单已驳回",
+    "rejectTitle": "驳回工单",
+    "status": "状态",
+    "statusExpired": "已过期",
+    "statusPaid": "已发放",
+    "statusPaying": "待发放/发货",
+    "statusPending": "待用户填写",
+    "statusRejected": "已驳回",
+    "statusReviewing": "待审核",
+    "tableTitle": "领奖工单",
+    "txHash": "交易哈希",
+    "txHashRequired": "加密货币奖品必须填写交易哈希",
+    "user": "用户"
+  },
+  "draw": {
+    "dispatchAutoClaimed": "已自动发放",
+    "dispatchExpired": "已过期",
+    "dispatchFailed": "发放失败",
+    "dispatchNone": "待发放",
+    "dispatchPaid": "已发放",
+    "dispatchPendingClaim": "待领取",
+    "dispatchState": "发放状态",
+    "drawnAt": "抽奖时间",
+    "filterDispatch": "发放状态",
+    "filterUserId": "用户 ID",
+    "filterWin": "是否中奖",
+    "grant": "发放结果",
+    "loseOnly": "未中奖",
+    "prize": "奖品",
+    "tableTitle": "抽奖记录",
+    "user": "用户",
+    "winOnly": "已中奖"
+  },
+  "delete": "删除",
+  "deleteSuccess": "删除成功",
+  "confirmDeleteActivity": "确定删除该活动吗？",
+  "confirmDeleteActivityDesc": "将永久删除该活动及其奖品。运行中的活动请先暂停。此操作不可撤销。"
+}

apps/admin/public/assets/locales/zh-CN/menu.json

@@ -14,6 +14,7 @@
   "Invite Management": "邀请管理",
   "Login": "登录",
   "Logs & Analytics": "日志与分析",
+  "Lottery Management": "抽奖管理",
   "Maintenance": "维护",
   "Marketing Management": "营销管理",
   "Mobile": "短信",

apps/admin/src/layout/navs.ts

@@ -81,6 +81,11 @@ export function useNavs() {
             url: "/dashboard/marketing",
             icon: "flat-color-icons:bullish",
           },
+          {
+            title: t("Lottery Management", "Lottery Management"),
+            url: "/dashboard/lottery",
+            icon: "flat-color-icons:ratings",
+          },
           {
             title: t("Announcement Management", "Announcement Management"),
             url: "/dashboard/announcement",

apps/admin/src/routeTree.gen.ts

@@ -47,6 +47,9 @@ const DashboardOrderIndexLazyRouteImport =
 const DashboardMarketingIndexLazyRouteImport = createFileRoute(
   '/dashboard/marketing/',
 )()
+const DashboardLotteryIndexLazyRouteImport = createFileRoute(
+  '/dashboard/lottery/',
+)()
 const DashboardInviteManagementIndexLazyRouteImport = createFileRoute(
   '/dashboard/invite-management/',
 )()
@@ -226,6 +229,14 @@ const DashboardMarketingIndexLazyRoute =
   } as any).lazy(() =>
     import('./routes/dashboard/marketing/index.lazy').then((d) => d.Route),
   )
+const DashboardLotteryIndexLazyRoute =
+  DashboardLotteryIndexLazyRouteImport.update({
+    id: '/lottery/',
+    path: '/lottery/',
+    getParentRoute: () => DashboardRouteLazyRoute,
+  } as any).lazy(() =>
+    import('./routes/dashboard/lottery/index.lazy').then((d) => d.Route),
+  )
 const DashboardInviteManagementIndexLazyRoute =
   DashboardInviteManagementIndexLazyRouteImport.update({
     id: '/invite-management/',
@@ -411,6 +422,7 @@ export interface FileRoutesByFullPath {
   '/dashboard/family': typeof DashboardFamilyIndexLazyRoute
   '/dashboard/group': typeof DashboardGroupIndexLazyRoute
   '/dashboard/invite-management': typeof DashboardInviteManagementIndexLazyRoute
+  '/dashboard/lottery': typeof DashboardLotteryIndexLazyRoute
   '/dashboard/marketing': typeof DashboardMarketingIndexLazyRoute
   '/dashboard/order': typeof DashboardOrderIndexLazyRoute
   '/dashboard/payment': typeof DashboardPaymentIndexLazyRoute
@@ -448,6 +460,7 @@ export interface FileRoutesByTo {
   '/dashboard/family': typeof DashboardFamilyIndexLazyRoute
   '/dashboard/group': typeof DashboardGroupIndexLazyRoute
   '/dashboard/invite-management': typeof DashboardInviteManagementIndexLazyRoute
+  '/dashboard/lottery': typeof DashboardLotteryIndexLazyRoute
   '/dashboard/marketing': typeof DashboardMarketingIndexLazyRoute
   '/dashboard/order': typeof DashboardOrderIndexLazyRoute
   '/dashboard/payment': typeof DashboardPaymentIndexLazyRoute
@@ -488,6 +501,7 @@ export interface FileRoutesById {
   '/dashboard/family/': typeof DashboardFamilyIndexLazyRoute
   '/dashboard/group/': typeof DashboardGroupIndexLazyRoute
   '/dashboard/invite-management/': typeof DashboardInviteManagementIndexLazyRoute
+  '/dashboard/lottery/': typeof DashboardLotteryIndexLazyRoute
   '/dashboard/marketing/': typeof DashboardMarketingIndexLazyRoute
   '/dashboard/order/': typeof DashboardOrderIndexLazyRoute
   '/dashboard/payment/': typeof DashboardPaymentIndexLazyRoute
@@ -529,6 +543,7 @@ export interface FileRouteTypes {
     | '/dashboard/family'
     | '/dashboard/group'
     | '/dashboard/invite-management'
+    | '/dashboard/lottery'
     | '/dashboard/marketing'
     | '/dashboard/order'
     | '/dashboard/payment'
@@ -566,6 +581,7 @@ export interface FileRouteTypes {
     | '/dashboard/family'
     | '/dashboard/group'
     | '/dashboard/invite-management'
+    | '/dashboard/lottery'
     | '/dashboard/marketing'
     | '/dashboard/order'
     | '/dashboard/payment'
@@ -605,6 +621,7 @@ export interface FileRouteTypes {
     | '/dashboard/family/'
     | '/dashboard/group/'
     | '/dashboard/invite-management/'
+    | '/dashboard/lottery/'
     | '/dashboard/marketing/'
     | '/dashboard/order/'
     | '/dashboard/payment/'
@@ -744,6 +761,13 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof DashboardMarketingIndexLazyRouteImport
       parentRoute: typeof DashboardRouteLazyRoute
     }
+    '/dashboard/lottery/': {
+      id: '/dashboard/lottery/'
+      path: '/lottery'
+      fullPath: '/dashboard/lottery'
+      preLoaderRoute: typeof DashboardLotteryIndexLazyRouteImport
+      parentRoute: typeof DashboardRouteLazyRoute
+    }
     '/dashboard/invite-management/': {
       id: '/dashboard/invite-management/'
       path: '/invite-management'
@@ -926,6 +950,7 @@ interface DashboardRouteLazyRouteChildren {
   DashboardFamilyIndexLazyRoute: typeof DashboardFamilyIndexLazyRoute
   DashboardGroupIndexLazyRoute: typeof DashboardGroupIndexLazyRoute
   DashboardInviteManagementIndexLazyRoute: typeof DashboardInviteManagementIndexLazyRoute
+  DashboardLotteryIndexLazyRoute: typeof DashboardLotteryIndexLazyRoute
   DashboardMarketingIndexLazyRoute: typeof DashboardMarketingIndexLazyRoute
   DashboardOrderIndexLazyRoute: typeof DashboardOrderIndexLazyRoute
   DashboardPaymentIndexLazyRoute: typeof DashboardPaymentIndexLazyRoute
@@ -964,6 +989,7 @@ const DashboardRouteLazyRouteChildren: DashboardRouteLazyRouteChildren = {
   DashboardGroupIndexLazyRoute: DashboardGroupIndexLazyRoute,
   DashboardInviteManagementIndexLazyRoute:
     DashboardInviteManagementIndexLazyRoute,
+  DashboardLotteryIndexLazyRoute: DashboardLotteryIndexLazyRoute,
   DashboardMarketingIndexLazyRoute: DashboardMarketingIndexLazyRoute,
   DashboardOrderIndexLazyRoute: DashboardOrderIndexLazyRoute,
   DashboardPaymentIndexLazyRoute: DashboardPaymentIndexLazyRoute,

apps/admin/src/routes/dashboard/lottery/index.lazy.tsx

@@ -0,0 +1,6 @@
+import { createLazyFileRoute } from "@tanstack/react-router";
+import Lottery from "@/sections/lottery";
+
+export const Route = createLazyFileRoute("/dashboard/lottery/")({
+  component: Lottery,
+});

apps/admin/src/sections/lottery/activity-detail.tsx

@@ -0,0 +1,133 @@
+import { Badge } from "@workspace/ui/components/badge";
+import {
+  Sheet,
+  SheetContent,
+  SheetHeader,
+  SheetTitle,
+} from "@workspace/ui/components/sheet";
+import {
+  Tabs,
+  TabsContent,
+  TabsList,
+  TabsTrigger,
+} from "@workspace/ui/components/tabs";
+import { getLotteryActivityDetail } from "@workspace/ui/services/admin/lottery";
+import { useEffect, useState } from "react";
+import { useTranslation } from "react-i18next";
+import ClaimsPanel from "./claims-panel";
+import DrawsPanel from "./draws-panel";
+import PrizeGrid from "./prize-grid";
+import RuleEditor from "./rule-editor";
+
+interface ActivityDetailProps {
+  activity: API.LotteryActivity | null;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  onChanged?: () => void;
+}
+
+type TranslateFn = (key: string, defaultValue: string) => string;
+
+const STATUS_BADGE_VARIANTS: Record<
+  API.LotteryActivityStatus,
+  "default" | "secondary" | "destructive" | "outline"
+> = {
+  draft: "secondary",
+  running: "default",
+  paused: "outline",
+  ended: "destructive",
+};
+
+function statusLabel(
+  status: API.LotteryActivityStatus,
+  t: TranslateFn
+): string {
+  const labels: Record<API.LotteryActivityStatus, string> = {
+    draft: t("status.draft", "Draft"),
+    running: t("status.running", "Running"),
+    paused: t("status.paused", "Paused"),
+    ended: t("status.ended", "Ended"),
+  };
+  return labels[status] ?? status;
+}
+
+export default function ActivityDetail({
+  activity,
+  open,
+  onOpenChange,
+  onChanged,
+}: ActivityDetailProps) {
+  const { t } = useTranslation("lottery");
+  // 抽屉打开时拉取详情作为数据源，避免列表行数据不完整时被全量 PUT 覆盖
+  const [detail, setDetail] = useState<API.LotteryActivity | null>(null);
+  const activityId = activity?.id;
+
+  useEffect(() => {
+    setDetail(null);
+    if (!(open && activityId)) return;
+    let cancelled = false;
+    getLotteryActivityDetail({ id: activityId })
+      .then(({ data }) => {
+        if (!cancelled && data.data) setDetail(data.data);
+      })
+      .catch(() => {
+        // Request layer already surfaces the error toast; fall back to prop data
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [open, activityId]);
+
+  const current = detail ?? activity;
+
+  return (
+    <Sheet onOpenChange={onOpenChange} open={open}>
+      <SheetContent className="w-[800px] max-w-full sm:max-w-3xl" side="right">
+        {current && (
+          <>
+            <SheetHeader>
+              <SheetTitle className="flex items-center gap-2">
+                <span className="truncate">{current.title}</span>
+                <Badge
+                  variant={STATUS_BADGE_VARIANTS[current.status] ?? "outline"}
+                >
+                  {statusLabel(current.status, t)}
+                </Badge>
+              </SheetTitle>
+            </SheetHeader>
+            <div className="max-h-[calc(100dvh-88px)] overflow-y-auto px-6 pb-6">
+              <Tabs defaultValue="prizes">
+                <TabsList className="mb-4">
+                  <TabsTrigger value="prizes">
+                    {t("detail.prizesTab", "Prizes")}
+                  </TabsTrigger>
+                  <TabsTrigger value="rules">
+                    {t("detail.rulesTab", "Rules")}
+                  </TabsTrigger>
+                  <TabsTrigger value="claims">
+                    {t("detail.claimsTab", "Claims")}
+                  </TabsTrigger>
+                  <TabsTrigger value="draws">
+                    {t("detail.drawsTab", "Draw records")}
+                  </TabsTrigger>
+                </TabsList>
+                <TabsContent value="prizes">
+                  <PrizeGrid activity={current} />
+                </TabsContent>
+                <TabsContent value="rules">
+                  <RuleEditor activity={current} onSaved={onChanged} />
+                </TabsContent>
+                <TabsContent value="claims">
+                  <ClaimsPanel activity={current} />
+                </TabsContent>
+                <TabsContent value="draws">
+                  <DrawsPanel activity={current} />
+                </TabsContent>
+              </Tabs>
+            </div>
+          </>
+        )}
+      </SheetContent>
+    </Sheet>
+  );
+}

apps/admin/src/sections/lottery/activity-form.tsx

@@ -0,0 +1,286 @@
+import { zodResolver } from "@hookform/resolvers/zod";
+import { Button } from "@workspace/ui/components/button";
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from "@workspace/ui/components/form";
+import { ScrollArea } from "@workspace/ui/components/scroll-area";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@workspace/ui/components/select";
+import {
+  Sheet,
+  SheetContent,
+  SheetFooter,
+  SheetHeader,
+  SheetTitle,
+  SheetTrigger,
+} from "@workspace/ui/components/sheet";
+import { Textarea } from "@workspace/ui/components/textarea";
+import { DatePicker } from "@workspace/ui/composed/date-picker";
+import { EnhancedInput } from "@workspace/ui/composed/enhanced-input";
+import { Icon } from "@workspace/ui/composed/icon";
+import { useEffect, useState } from "react";
+import { useForm } from "react-hook-form";
+import { useTranslation } from "react-i18next";
+import { z } from "zod";
+
+const GRID_SIZE_OPTIONS = [8, 9] as const;
+
+const getFormSchema = (t: (key: string, defaultValue: string) => string) =>
+  z
+    .object({
+      title: z.string().min(1, t("form.titleRequired", "Title is required")),
+      description: z.string().optional(),
+      // DatePicker works in milliseconds; converted to Unix seconds on submit
+      start_at: z
+        .number()
+        .min(1, t("form.startAtRequired", "Start time is required")),
+      end_at: z
+        .number()
+        .min(1, t("form.endAtRequired", "End time is required")),
+      grid_size: z.number(),
+    })
+    .superRefine((data, ctx) => {
+      if (
+        data.start_at > 0 &&
+        data.end_at > 0 &&
+        data.end_at <= data.start_at
+      ) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: t(
+            "form.endAtAfterStartAt",
+            "End time must be later than start time"
+          ),
+          path: ["end_at"],
+        });
+      }
+    });
+
+type ActivityFormValues = z.infer<ReturnType<typeof getFormSchema>>;
+
+interface ActivityFormProps {
+  trigger: React.ReactNode;
+  title: string;
+  loading?: boolean;
+  initialValues?: Partial<API.LotteryActivity>;
+  onSubmit: (values: API.CreateLotteryActivityRequest) => Promise<boolean>;
+}
+
+function toFormValues(
+  activity?: Partial<API.LotteryActivity>
+): ActivityFormValues {
+  return {
+    title: activity?.title ?? "",
+    description: activity?.description ?? "",
+    start_at: activity?.start_at ? activity.start_at * 1000 : 0,
+    end_at: activity?.end_at ? activity.end_at * 1000 : 0,
+    grid_size: activity?.grid_size ?? GRID_SIZE_OPTIONS[0],
+  };
+}
+
+export default function ActivityForm({
+  trigger,
+  title,
+  loading,
+  initialValues,
+  onSubmit,
+}: ActivityFormProps) {
+  const { t } = useTranslation("lottery");
+  const formSchema = getFormSchema(t);
+
+  const [open, setOpen] = useState(false);
+  const form = useForm<ActivityFormValues>({
+    resolver: zodResolver(formSchema),
+    defaultValues: toFormValues(initialValues),
+  });
+
+  useEffect(() => {
+    form.reset(toFormValues(initialValues));
+  }, [form, initialValues]);
+
+  async function handleSubmit(values: ActivityFormValues) {
+    const success = await onSubmit({
+      title: values.title.trim(),
+      description: values.description ?? "",
+      start_at: Math.floor(values.start_at / 1000),
+      end_at: Math.floor(values.end_at / 1000),
+      grid_size: values.grid_size,
+      eligibility: initialValues?.eligibility ?? {},
+      chance_sources: initialValues?.chance_sources ?? [],
+      unmet_action: "block",
+    });
+    if (success) {
+      setOpen(false);
+      form.reset(toFormValues(initialValues));
+    }
+  }
+
+  return (
+    <Sheet onOpenChange={setOpen} open={open}>
+      <SheetTrigger asChild>
+        <Button
+          onClick={() => {
+            form.reset(toFormValues(initialValues));
+            setOpen(true);
+          }}
+          size="sm"
+        >
+          {trigger}
+        </Button>
+      </SheetTrigger>
+      <SheetContent className="w-[520px] max-w-full md:max-w-screen-md">
+        <SheetHeader>
+          <SheetTitle>{title}</SheetTitle>
+        </SheetHeader>
+        <ScrollArea className="h-[calc(100vh-48px-36px-36px-env(safe-area-inset-top))]">
+          <Form {...form}>
+            <form
+              className="space-y-4 px-6 pt-4"
+              id="lottery-activity-form"
+              onSubmit={form.handleSubmit(handleSubmit)}
+            >
+              <FormField
+                control={form.control}
+                name="title"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t("form.title", "Title")}</FormLabel>
+                    <FormControl>
+                      <EnhancedInput
+                        onValueChange={(value) => field.onChange(value)}
+                        placeholder={t(
+                          "form.titlePlaceholder",
+                          "Activity title"
+                        )}
+                        value={field.value}
+                      />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              <FormField
+                control={form.control}
+                name="description"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>
+                      {t("form.description", "Description")}
+                    </FormLabel>
+                    <FormControl>
+                      <Textarea
+                        onChange={(event) => field.onChange(event.target.value)}
+                        placeholder={t(
+                          "form.descriptionPlaceholder",
+                          "Activity description (Markdown supported)"
+                        )}
+                        rows={5}
+                        value={field.value}
+                      />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              <div className="grid gap-4 sm:grid-cols-2">
+                <FormField
+                  control={form.control}
+                  name="start_at"
+                  render={({ field }) => (
+                    <FormItem>
+                      <FormLabel>{t("form.startAt", "Start Time")}</FormLabel>
+                      <FormControl>
+                        <DatePicker
+                          onChange={(value) => field.onChange(value ?? 0)}
+                          placeholder={t("form.selectStartAt", "Select time")}
+                          value={field.value || undefined}
+                        />
+                      </FormControl>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
+                <FormField
+                  control={form.control}
+                  name="end_at"
+                  render={({ field }) => (
+                    <FormItem>
+                      <FormLabel>{t("form.endAt", "End Time")}</FormLabel>
+                      <FormControl>
+                        <DatePicker
+                          onChange={(value) => field.onChange(value ?? 0)}
+                          placeholder={t("form.selectEndAt", "Select time")}
+                          value={field.value || undefined}
+                        />
+                      </FormControl>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
+              </div>
+              <FormField
+                control={form.control}
+                name="grid_size"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t("form.gridSize", "Grid Size")}</FormLabel>
+                    <Select
+                      onValueChange={(value) => field.onChange(Number(value))}
+                      value={String(field.value)}
+                    >
+                      <FormControl>
+                        <SelectTrigger>
+                          <SelectValue
+                            placeholder={t(
+                              "form.selectGridSize",
+                              "Select grid size"
+                            )}
+                          />
+                        </SelectTrigger>
+                      </FormControl>
+                      <SelectContent>
+                        {GRID_SIZE_OPTIONS.map((size) => (
+                          <SelectItem key={size} value={String(size)}>
+                            {size}
+                          </SelectItem>
+                        ))}
+                      </SelectContent>
+                    </Select>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+            </form>
+          </Form>
+        </ScrollArea>
+        <SheetFooter className="flex-row justify-end gap-2 pt-3">
+          <Button
+            disabled={loading}
+            onClick={() => {
+              setOpen(false);
+            }}
+            variant="outline"
+          >
+            {t("form.cancel", "Cancel")}
+          </Button>
+          <Button disabled={loading} form="lottery-activity-form" type="submit">
+            {loading && (
+              <Icon className="mr-2 animate-spin" icon="mdi:loading" />
+            )}{" "}
+            {t("form.confirm", "Confirm")}
+          </Button>
+        </SheetFooter>
+      </SheetContent>
+    </Sheet>
+  );
+}

apps/admin/src/sections/lottery/claims-panel.tsx

@@ -0,0 +1,555 @@
+import { zodResolver } from "@hookform/resolvers/zod";
+import { useMutation } from "@tanstack/react-query";
+import { Badge } from "@workspace/ui/components/badge";
+import { Button } from "@workspace/ui/components/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@workspace/ui/components/dialog";
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from "@workspace/ui/components/form";
+import { Input } from "@workspace/ui/components/input";
+import { Textarea } from "@workspace/ui/components/textarea";
+import { ConfirmButton } from "@workspace/ui/composed/confirm-button";
+import {
+  ProTable,
+  type ProTableActions,
+} from "@workspace/ui/composed/pro-table/pro-table";
+import {
+  approveLotteryClaim,
+  getLotteryClaimList,
+  markPaidLotteryClaim,
+  rejectLotteryClaim,
+} from "@workspace/ui/services/admin/lottery";
+import { type ReactNode, useRef, useState } from "react";
+import { useForm } from "react-hook-form";
+import { useTranslation } from "react-i18next";
+import { toast } from "sonner";
+import { z } from "zod";
+import { formatDate } from "@/utils/common";
+
+interface ClaimsPanelProps {
+  activity: API.LotteryActivity;
+}
+
+type TranslateFn = (key: string, defaultValue: string) => string;
+
+const STATUS_META: Record<
+  API.LotteryClaimStatus,
+  { labelKey: string; labelDefault: string; className: string }
+> = {
+  pending_claim: {
+    labelKey: "claim.statusPending",
+    labelDefault: "Awaiting user",
+    className: "bg-gray-100 text-gray-600 border-gray-200",
+  },
+  reviewing: {
+    labelKey: "claim.statusReviewing",
+    labelDefault: "Reviewing",
+    className: "bg-amber-100 text-amber-700 border-amber-200",
+  },
+  paying: {
+    labelKey: "claim.statusPaying",
+    labelDefault: "Paying / Shipping",
+    className: "bg-blue-100 text-blue-700 border-blue-200",
+  },
+  paid: {
+    labelKey: "claim.statusPaid",
+    labelDefault: "Fulfilled",
+    className: "bg-emerald-100 text-emerald-700 border-emerald-200",
+  },
+  rejected: {
+    labelKey: "claim.statusRejected",
+    labelDefault: "Rejected",
+    className: "bg-rose-100 text-rose-700 border-rose-200",
+  },
+  expired: {
+    labelKey: "claim.statusExpired",
+    labelDefault: "Expired",
+    className: "bg-gray-100 text-gray-500 border-gray-200",
+  },
+};
+
+function prizeTypeLabel(type: API.LotteryPrizeType, t: TranslateFn): string {
+  const labels: Record<string, string> = {
+    crypto: t("prize.typeCrypto", "Crypto"),
+    physical: t("prize.typePhysical", "Physical"),
+    manual_other: t("prize.typeManualOther", "Manual (Other)"),
+  };
+  return labels[type] ?? type;
+}
+
+function ClaimDataCell({ data }: { data?: Record<string, any> }) {
+  if (!data || Object.keys(data).length === 0) {
+    return <span className="text-muted-foreground">--</span>;
+  }
+  return (
+    <div className="max-w-[240px] space-y-0.5 text-xs">
+      {Object.entries(data).map(([key, value]) => (
+        <div className="break-all" key={key}>
+          <span className="text-muted-foreground">{key}:</span>{" "}
+          <span className="font-medium">{String(value)}</span>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+const rejectSchema = (t: TranslateFn) =>
+  z.object({
+    reason: z
+      .string()
+      .trim()
+      .min(2, t("claim.reasonRequired", "Please enter a reason"))
+      .max(512, t("claim.reasonTooLong", "Reason cannot exceed 512 chars")),
+  });
+
+const markPaidSchema = z.object({
+  tx_hash: z.string().trim().max(128).optional(),
+  delivery_ref: z.string().trim().max(128).optional(),
+});
+
+export default function ClaimsPanel({ activity }: ClaimsPanelProps) {
+  const { t } = useTranslation("lottery");
+  const ref = useRef<ProTableActions>(null);
+  const [rejectOpen, setRejectOpen] = useState(false);
+  const [paidOpen, setPaidOpen] = useState(false);
+  const [currentRow, setCurrentRow] = useState<API.AdminLotteryClaim | null>(
+    null
+  );
+
+  const rejectForm = useForm<{ reason: string }>({
+    resolver: zodResolver(rejectSchema(t)),
+    defaultValues: { reason: "" },
+  });
+  const paidForm = useForm<z.infer<typeof markPaidSchema>>({
+    resolver: zodResolver(markPaidSchema),
+    defaultValues: { tx_hash: "", delivery_ref: "" },
+  });
+
+  const approveMutation = useMutation({
+    mutationFn: (id: number) => approveLotteryClaim({ id }),
+    onSuccess: () => {
+      toast.success(t("claim.approveSuccess", "Claim approved"));
+      ref.current?.refresh();
+    },
+  });
+
+  const rejectMutation = useMutation({
+    mutationFn: (body: API.RejectLotteryClaimRequest) =>
+      rejectLotteryClaim(body),
+    onSuccess: () => {
+      toast.success(t("claim.rejectSuccess", "Claim rejected"));
+      setRejectOpen(false);
+      setCurrentRow(null);
+      rejectForm.reset({ reason: "" });
+      ref.current?.refresh();
+    },
+  });
+
+  const paidMutation = useMutation({
+    mutationFn: (body: API.MarkPaidLotteryClaimRequest) =>
+      markPaidLotteryClaim(body),
+    onSuccess: () => {
+      toast.success(t("claim.markPaidSuccess", "Marked as fulfilled"));
+      setPaidOpen(false);
+      setCurrentRow(null);
+      paidForm.reset({ tx_hash: "", delivery_ref: "" });
+      ref.current?.refresh();
+    },
+  });
+
+  const statusOptions = (
+    Object.keys(STATUS_META) as API.LotteryClaimStatus[]
+  ).map((value) => ({
+    value,
+    label: t(STATUS_META[value].labelKey, STATUS_META[value].labelDefault),
+  }));
+
+  const typeOptions = [
+    { value: "crypto", label: t("prize.typeCrypto", "Crypto") },
+    { value: "physical", label: t("prize.typePhysical", "Physical") },
+    {
+      value: "manual_other",
+      label: t("prize.typeManualOther", "Manual (Other)"),
+    },
+  ];
+
+  const openReject = (row: API.AdminLotteryClaim) => {
+    setCurrentRow(row);
+    rejectForm.reset({ reason: "" });
+    setRejectOpen(true);
+  };
+  const openPaid = (row: API.AdminLotteryClaim) => {
+    setCurrentRow(row);
+    paidForm.reset({ tx_hash: "", delivery_ref: "" });
+    setPaidOpen(true);
+  };
+
+  return (
+    <>
+      <ProTable<
+        API.AdminLotteryClaim,
+        { type?: string; status?: string; user_id?: string }
+      >
+        action={ref}
+        actions={{
+          render: (row) => {
+            const actions: ReactNode[] = [];
+            if (row.status === "reviewing") {
+              actions.push(
+                <ConfirmButton
+                  cancelText={t("claim.cancel", "Cancel")}
+                  confirmText={t("claim.confirm", "Confirm")}
+                  description={t(
+                    "claim.approveDescription",
+                    "Approving moves this claim to the paying/shipping stage."
+                  )}
+                  key="approve"
+                  onConfirm={async () => {
+                    await approveMutation.mutateAsync(row.id);
+                  }}
+                  title={t("claim.approveTitle", "Approve this claim?")}
+                  trigger={
+                    <Button size="sm" variant="default">
+                      {t("claim.approve", "Approve")}
+                    </Button>
+                  }
+                />
+              );
+            }
+            if (row.status === "paying") {
+              actions.push(
+                <Button
+                  key="mark-paid"
+                  onClick={() => openPaid(row)}
+                  size="sm"
+                  variant="default"
+                >
+                  {t("claim.markPaid", "Mark fulfilled")}
+                </Button>
+              );
+            }
+            if (row.status === "reviewing" || row.status === "paying") {
+              actions.push(
+                <Button
+                  key="reject"
+                  onClick={() => openReject(row)}
+                  size="sm"
+                  variant="destructive"
+                >
+                  {t("claim.reject", "Reject")}
+                </Button>
+              );
+            }
+            return actions;
+          },
+        }}
+        columns={[
+          { accessorKey: "id", header: "ID" },
+          {
+            accessorKey: "user",
+            header: t("claim.user", "User"),
+            cell: ({ row }) => (
+              <div className="text-sm">
+                <div>#{row.original.user.id}</div>
+                {row.original.user.email && (
+                  <div className="text-muted-foreground text-xs">
+                    {row.original.user.email}
+                  </div>
+                )}
+              </div>
+            ),
+          },
+          {
+            accessorKey: "prize",
+            header: t("claim.prize", "Prize"),
+            cell: ({ row }) => (
+              <div className="text-sm">
+                <div className="font-medium">{row.original.prize.name}</div>
+                <Badge className="mt-0.5" variant="secondary">
+                  {prizeTypeLabel(row.original.prize.type, t)}
+                </Badge>
+              </div>
+            ),
+          },
+          {
+            accessorKey: "claim_data",
+            header: t("claim.claimData", "Claim info"),
+            cell: ({ row }) => <ClaimDataCell data={row.original.claim_data} />,
+          },
+          {
+            accessorKey: "status",
+            header: t("claim.status", "Status"),
+            cell: ({ row }) => {
+              const meta = STATUS_META[row.original.status];
+              return (
+                <Badge className={meta?.className} variant="outline">
+                  {meta
+                    ? t(meta.labelKey, meta.labelDefault)
+                    : row.original.status}
+                </Badge>
+              );
+            },
+          },
+          {
+            accessorKey: "fulfillment",
+            header: t("claim.fulfillment", "Tx / Delivery"),
+            cell: ({ row }) => (
+              <div className="max-w-[180px] break-all text-xs">
+                {row.original.tx_hash || row.original.delivery_ref || "--"}
+                {row.original.reject_reason && (
+                  <div className="text-rose-600">
+                    {row.original.reject_reason}
+                  </div>
+                )}
+              </div>
+            ),
+          },
+          {
+            accessorKey: "expires_at",
+            header: t("claim.expiresAt", "Expires"),
+            cell: ({ row }) =>
+              row.original.expires_at
+                ? formatDate(row.original.expires_at)
+                : "--",
+          },
+          {
+            accessorKey: "created_at",
+            header: t("claim.createdAt", "Won at"),
+            cell: ({ row }) =>
+              row.original.created_at
+                ? formatDate(row.original.created_at)
+                : "--",
+          },
+        ]}
+        header={{ title: t("claim.tableTitle", "Claims") }}
+        params={[
+          {
+            key: "type",
+            options: typeOptions,
+            placeholder: t("claim.filterType", "Type"),
+          },
+          {
+            key: "status",
+            options: statusOptions,
+            placeholder: t("claim.filterStatus", "Status"),
+          },
+          {
+            key: "user_id",
+            placeholder: t("claim.filterUserId", "User ID"),
+          },
+        ]}
+        request={async (pagination, filter) => {
+          const { data } = await getLotteryClaimList({
+            page: pagination.page,
+            size: pagination.size,
+            activity_id: activity.id,
+            type: (filter.type as API.LotteryPrizeType) || undefined,
+            status: (filter.status as API.LotteryClaimStatus) || undefined,
+            user_id: filter.user_id ? Number(filter.user_id) : undefined,
+          });
+          return {
+            list: data.data?.claims || [],
+            total: data.data?.total || 0,
+          };
+        }}
+      />
+
+      {/* Reject dialog */}
+      <Dialog
+        onOpenChange={(open) => {
+          setRejectOpen(open);
+          if (!open) {
+            setCurrentRow(null);
+            rejectForm.reset({ reason: "" });
+          }
+        }}
+        open={rejectOpen}
+      >
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle>{t("claim.rejectTitle", "Reject claim")}</DialogTitle>
+            <DialogDescription>
+              {t(
+                "claim.rejectDescription",
+                "The reason is shown to the user, who may then resubmit."
+              )}
+            </DialogDescription>
+          </DialogHeader>
+          <Form {...rejectForm}>
+            <form
+              className="space-y-4"
+              onSubmit={rejectForm.handleSubmit(async (values) => {
+                if (!currentRow) return;
+                await rejectMutation.mutateAsync({
+                  id: currentRow.id,
+                  reason: values.reason.trim(),
+                });
+              })}
+            >
+              <FormField
+                control={rejectForm.control}
+                name="reason"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t("claim.reason", "Reason")}</FormLabel>
+                    <FormControl>
+                      <Textarea
+                        placeholder={t(
+                          "claim.reasonPlaceholder",
+                          "Reason shown to the user"
+                        )}
+                        rows={4}
+                        {...field}
+                      />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              <DialogFooter>
+                <Button
+                  onClick={() => setRejectOpen(false)}
+                  type="button"
+                  variant="outline"
+                >
+                  {t("claim.cancel", "Cancel")}
+                </Button>
+                <Button disabled={rejectMutation.isPending} type="submit">
+                  {t("claim.confirmReject", "Confirm reject")}
+                </Button>
+              </DialogFooter>
+            </form>
+          </Form>
+        </DialogContent>
+      </Dialog>
+
+      {/* Mark-paid dialog */}
+      <Dialog
+        onOpenChange={(open) => {
+          setPaidOpen(open);
+          if (!open) {
+            setCurrentRow(null);
+            paidForm.reset({ tx_hash: "", delivery_ref: "" });
+          }
+        }}
+        open={paidOpen}
+      >
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle>
+              {t("claim.markPaidTitle", "Mark as fulfilled")}
+            </DialogTitle>
+            <DialogDescription>
+              {t(
+                "claim.markPaidDescription",
+                "Crypto requires a tx hash; physical requires a delivery ref; manual requires at least one."
+              )}
+            </DialogDescription>
+          </DialogHeader>
+          <Form {...paidForm}>
+            <form
+              className="space-y-4"
+              onSubmit={paidForm.handleSubmit(async (values) => {
+                if (!currentRow) return;
+                const txHash = values.tx_hash?.trim();
+                const deliveryRef = values.delivery_ref?.trim();
+                const prizeType = currentRow.prize.type;
+                if (prizeType === "crypto" && !txHash) {
+                  paidForm.setError("tx_hash", {
+                    message: t(
+                      "claim.txHashRequired",
+                      "Tx hash is required for crypto"
+                    ),
+                  });
+                  return;
+                }
+                if (prizeType === "physical" && !deliveryRef) {
+                  paidForm.setError("delivery_ref", {
+                    message: t(
+                      "claim.deliveryRefRequired",
+                      "Delivery ref is required for physical"
+                    ),
+                  });
+                  return;
+                }
+                if (!(txHash || deliveryRef)) {
+                  paidForm.setError("tx_hash", {
+                    message: t(
+                      "claim.oneRefRequired",
+                      "Fill at least one field"
+                    ),
+                  });
+                  return;
+                }
+                await paidMutation.mutateAsync({
+                  id: currentRow.id,
+                  tx_hash: txHash || undefined,
+                  delivery_ref: deliveryRef || undefined,
+                });
+              })}
+            >
+              <FormField
+                control={paidForm.control}
+                name="tx_hash"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t("claim.txHash", "Tx hash")}</FormLabel>
+                    <FormControl>
+                      <Input placeholder="0x..." {...field} />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              <FormField
+                control={paidForm.control}
+                name="delivery_ref"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>
+                      {t("claim.deliveryRef", "Delivery ref")}
+                    </FormLabel>
+                    <FormControl>
+                      <Input
+                        placeholder={t(
+                          "claim.deliveryRefPlaceholder",
+                          "Tracking number"
+                        )}
+                        {...field}
+                      />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              <DialogFooter>
+                <Button
+                  onClick={() => setPaidOpen(false)}
+                  type="button"
+                  variant="outline"
+                >
+                  {t("claim.cancel", "Cancel")}
+                </Button>
+                <Button disabled={paidMutation.isPending} type="submit">
+                  {t("claim.confirmMarkPaid", "Confirm")}
+                </Button>
+              </DialogFooter>
+            </form>
+          </Form>
+        </DialogContent>
+      </Dialog>
+    </>
+  );
+}

apps/admin/src/sections/lottery/draws-panel.tsx

@@ -0,0 +1,193 @@
+import { Badge } from "@workspace/ui/components/badge";
+import {
+  ProTable,
+  type ProTableActions,
+} from "@workspace/ui/composed/pro-table/pro-table";
+import { getLotteryDrawList } from "@workspace/ui/services/admin/lottery";
+import { useRef } from "react";
+import { useTranslation } from "react-i18next";
+import { formatDate } from "@/utils/common";
+
+interface DrawsPanelProps {
+  activity: API.LotteryActivity;
+}
+
+type TranslateFn = (key: string, defaultValue: string) => string;
+
+const DISPATCH_META: Record<
+  string,
+  { labelKey: string; labelDefault: string; className: string }
+> = {
+  none: {
+    labelKey: "draw.dispatchNone",
+    labelDefault: "Pending",
+    className: "bg-gray-100 text-gray-500 border-gray-200",
+  },
+  auto_claimed: {
+    labelKey: "draw.dispatchAutoClaimed",
+    labelDefault: "Auto-granted",
+    className: "bg-emerald-100 text-emerald-700 border-emerald-200",
+  },
+  pending_claim: {
+    labelKey: "draw.dispatchPendingClaim",
+    labelDefault: "Awaiting claim",
+    className: "bg-amber-100 text-amber-700 border-amber-200",
+  },
+  paid: {
+    labelKey: "draw.dispatchPaid",
+    labelDefault: "Fulfilled",
+    className: "bg-emerald-100 text-emerald-700 border-emerald-200",
+  },
+  expired: {
+    labelKey: "draw.dispatchExpired",
+    labelDefault: "Expired",
+    className: "bg-gray-100 text-gray-500 border-gray-200",
+  },
+  failed: {
+    labelKey: "draw.dispatchFailed",
+    labelDefault: "Failed",
+    className: "bg-rose-100 text-rose-700 border-rose-200",
+  },
+};
+
+function prizeTypeLabel(type: API.LotteryPrizeType, t: TranslateFn): string {
+  const labels: Record<string, string> = {
+    vpn_duration: t("prize.typeVpnDuration", "VPN Duration"),
+    commission: t("prize.typeCommission", "Commission"),
+    none: t("prize.typeNone", "No Prize (Thanks)"),
+    crypto: t("prize.typeCrypto", "Crypto"),
+    physical: t("prize.typePhysical", "Physical"),
+    manual_other: t("prize.typeManualOther", "Manual (Other)"),
+  };
+  return labels[type] ?? type;
+}
+
+export default function DrawsPanel({ activity }: DrawsPanelProps) {
+  const { t } = useTranslation("lottery");
+  const ref = useRef<ProTableActions>(null);
+
+  const dispatchOptions = Object.entries(DISPATCH_META).map(
+    ([value, meta]) => ({
+      value,
+      label: t(meta.labelKey, meta.labelDefault),
+    })
+  );
+
+  const winOptions = [
+    { value: "1", label: t("draw.winOnly", "Won") },
+    { value: "0", label: t("draw.loseOnly", "Not won") },
+  ];
+
+  return (
+    <ProTable<
+      API.AdminLotteryDraw,
+      { win?: string; dispatch_state?: string; user_id?: string }
+    >
+      action={ref}
+      columns={[
+        { accessorKey: "draw_id", header: "ID" },
+        {
+          accessorKey: "user",
+          header: t("draw.user", "User"),
+          cell: ({ row }) => (
+            <div className="text-sm">
+              <div>#{row.original.user.id}</div>
+              {row.original.user.email && (
+                <div className="text-muted-foreground text-xs">
+                  {row.original.user.email}
+                </div>
+              )}
+            </div>
+          ),
+        },
+        {
+          accessorKey: "prize",
+          header: t("draw.prize", "Prize"),
+          cell: ({ row }) => {
+            const prize = row.original.prize;
+            if (!(row.original.is_win && prize)) {
+              return (
+                <span className="text-muted-foreground">
+                  {t("prize.typeNone", "No Prize (Thanks)")}
+                </span>
+              );
+            }
+            return (
+              <div className="text-sm">
+                <div className="font-medium">{prize.name}</div>
+                <Badge className="mt-0.5" variant="secondary">
+                  {prizeTypeLabel(prize.type, t)}
+                </Badge>
+              </div>
+            );
+          },
+        },
+        {
+          accessorKey: "dispatch_state",
+          header: t("draw.dispatchState", "Dispatch"),
+          cell: ({ row }) => {
+            const meta = DISPATCH_META[row.original.dispatch_state];
+            return (
+              <Badge className={meta?.className} variant="outline">
+                {meta
+                  ? t(meta.labelKey, meta.labelDefault)
+                  : row.original.dispatch_state}
+              </Badge>
+            );
+          },
+        },
+        {
+          accessorKey: "grant_message",
+          header: t("draw.grant", "Grant result"),
+          cell: ({ row }) => (
+            <div className="max-w-[220px] break-all text-xs">
+              {row.original.grant_message || "--"}
+              {row.original.dispatch_error && (
+                <div className="text-rose-600">
+                  {row.original.dispatch_error}
+                </div>
+              )}
+            </div>
+          ),
+        },
+        {
+          accessorKey: "drawn_at",
+          header: t("draw.drawnAt", "Drawn at"),
+          cell: ({ row }) =>
+            row.original.drawn_at ? formatDate(row.original.drawn_at) : "--",
+        },
+      ]}
+      header={{ title: t("draw.tableTitle", "Draw records") }}
+      params={[
+        {
+          key: "win",
+          options: winOptions,
+          placeholder: t("draw.filterWin", "Won?"),
+        },
+        {
+          key: "dispatch_state",
+          options: dispatchOptions,
+          placeholder: t("draw.filterDispatch", "Dispatch"),
+        },
+        {
+          key: "user_id",
+          placeholder: t("draw.filterUserId", "User ID"),
+        },
+      ]}
+      request={async (pagination, filter) => {
+        const { data } = await getLotteryDrawList({
+          page: pagination.page,
+          size: pagination.size,
+          activity_id: activity.id,
+          win: (filter.win as "1" | "0") || undefined,
+          dispatch_state: filter.dispatch_state || undefined,
+          user_id: filter.user_id ? Number(filter.user_id) : undefined,
+        });
+        return {
+          list: data.data?.list || [],
+          total: data.data?.total || 0,
+        };
+      }}
+    />
+  );
+}

apps/admin/src/sections/lottery/grant-dialog.tsx

@@ -0,0 +1,207 @@
+import { zodResolver } from "@hookform/resolvers/zod";
+import { Button } from "@workspace/ui/components/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@workspace/ui/components/dialog";
+import {
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from "@workspace/ui/components/form";
+import { EnhancedInput } from "@workspace/ui/composed/enhanced-input";
+import { grantLotteryChances } from "@workspace/ui/services/admin/lottery";
+import { useEffect, useState } from "react";
+import { useForm } from "react-hook-form";
+import { useTranslation } from "react-i18next";
+import { toast } from "sonner";
+import { z } from "zod";
+
+const grantSchema = z.object({
+  user_id: z.number().int().min(1),
+  amount: z.number().int().min(1),
+  source_ref: z.string().trim().min(1),
+});
+
+type GrantFormValues = z.infer<typeof grantSchema>;
+
+const SOURCE_REF_RANDOM_LENGTH = 6;
+
+function generateSourceRef(): string {
+  const now = new Date();
+  const ymd = [
+    now.getFullYear(),
+    String(now.getMonth() + 1).padStart(2, "0"),
+    String(now.getDate()).padStart(2, "0"),
+  ].join("");
+  const random = Math.random()
+    .toString(36)
+    .slice(2, 2 + SOURCE_REF_RANDOM_LENGTH)
+    .padEnd(SOURCE_REF_RANDOM_LENGTH, "0");
+  return `grant-${ymd}-${random}`;
+}
+
+interface GrantDialogProps {
+  activity: API.LotteryActivity | null;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+}
+
+export default function GrantDialog({
+  activity,
+  open,
+  onOpenChange,
+}: GrantDialogProps) {
+  const { t } = useTranslation("lottery");
+  const [loading, setLoading] = useState(false);
+  const form = useForm<GrantFormValues>({
+    resolver: zodResolver(grantSchema),
+    defaultValues: { amount: 1, source_ref: "" },
+  });
+
+  useEffect(() => {
+    if (open) {
+      form.reset({
+        user_id: undefined,
+        amount: 1,
+        source_ref: generateSourceRef(),
+      });
+    }
+  }, [open, form]);
+
+  async function handleSubmit(values: GrantFormValues) {
+    if (!activity) return;
+    setLoading(true);
+    try {
+      await grantLotteryChances({
+        activity_id: activity.id,
+        user_id: values.user_id,
+        amount: values.amount,
+        source_ref: values.source_ref.trim(),
+      });
+      toast.success(t("grant.success", "Chances granted"));
+      onOpenChange(false);
+      form.reset({ user_id: undefined, amount: 1, source_ref: "" });
+    } catch {
+      // Request layer already surfaces the error toast
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return (
+    <Dialog onOpenChange={onOpenChange} open={open}>
+      <DialogContent className="max-w-md">
+        <DialogHeader>
+          <DialogTitle>{t("grant.title", "Grant Chances")}</DialogTitle>
+          <DialogDescription>
+            {t(
+              "grant.description",
+              "Manually grant draw chances to a user for activity: {{title}}"
+            ).replace("{{title}}", activity?.title ?? "")}
+          </DialogDescription>
+        </DialogHeader>
+        <Form {...form}>
+          <form
+            className="space-y-4"
+            id="lottery-grant-form"
+            onSubmit={form.handleSubmit(handleSubmit)}
+          >
+            <FormField
+              control={form.control}
+              name="user_id"
+              render={({ field }) => (
+                <FormItem>
+                  <FormLabel>{t("grant.userId", "User ID")}</FormLabel>
+                  <FormControl>
+                    <EnhancedInput
+                      min={1}
+                      onValueChange={(value) => field.onChange(value)}
+                      placeholder={t("grant.userIdPlaceholder", "e.g. 87433")}
+                      type="number"
+                      value={field.value}
+                    />
+                  </FormControl>
+                  <FormDescription>
+                    {t(
+                      "grant.userIdHint",
+                      "Enter the numeric user ID. You can find it in the user management list."
+                    )}
+                  </FormDescription>
+                  <FormMessage />
+                </FormItem>
+              )}
+            />
+            <FormField
+              control={form.control}
+              name="amount"
+              render={({ field }) => (
+                <FormItem>
+                  <FormLabel>{t("grant.amount", "Amount")}</FormLabel>
+                  <FormControl>
+                    <EnhancedInput
+                      min={1}
+                      onValueChange={(value) => field.onChange(value)}
+                      placeholder="1"
+                      type="number"
+                      value={field.value}
+                    />
+                  </FormControl>
+                  <FormMessage />
+                </FormItem>
+              )}
+            />
+            <FormField
+              control={form.control}
+              name="source_ref"
+              render={({ field }) => (
+                <FormItem>
+                  <FormLabel>
+                    {t("grant.sourceRef", "Source Reference")}
+                  </FormLabel>
+                  <FormControl>
+                    <EnhancedInput
+                      onValueChange={(value) => field.onChange(value)}
+                      placeholder={t(
+                        "grant.sourceRefPlaceholder",
+                        "grant-20260709-abc123"
+                      )}
+                      value={field.value}
+                    />
+                  </FormControl>
+                  <FormDescription>
+                    {t(
+                      "grant.sourceRefHint",
+                      "Idempotency key: the same reference only grants once. Repeated submissions will not grant again."
+                    )}
+                  </FormDescription>
+                  <FormMessage />
+                </FormItem>
+              )}
+            />
+          </form>
+        </Form>
+        <DialogFooter>
+          <Button
+            onClick={() => onOpenChange(false)}
+            type="button"
+            variant="outline"
+          >
+            {t("cancel", "Cancel")}
+          </Button>
+          <Button disabled={loading} form="lottery-grant-form" type="submit">
+            {t("confirm", "Confirm")}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

apps/admin/src/sections/lottery/index.tsx

@@ -0,0 +1,290 @@
+import { Badge } from "@workspace/ui/components/badge";
+import { Button } from "@workspace/ui/components/button";
+import { ConfirmButton } from "@workspace/ui/composed/confirm-button";
+import {
+  ProTable,
+  type ProTableActions,
+} from "@workspace/ui/composed/pro-table/pro-table";
+import {
+  createLotteryActivity,
+  deleteLotteryActivity,
+  getLotteryActivityList,
+  pauseLotteryActivity,
+  publishLotteryActivity,
+  updateLotteryActivity,
+} from "@workspace/ui/services/admin/lottery";
+import { useRef, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { toast } from "sonner";
+import { formatDate } from "@/utils/common";
+import ActivityDetail from "./activity-detail";
+import ActivityForm from "./activity-form";
+import GrantDialog from "./grant-dialog";
+
+export default function Lottery() {
+  const { t } = useTranslation("lottery");
+  const [loading, setLoading] = useState(false);
+  const [detailOpen, setDetailOpen] = useState(false);
+  const [grantOpen, setGrantOpen] = useState(false);
+  const [selectedActivity, setSelectedActivity] =
+    useState<API.LotteryActivity | null>(null);
+  const ref = useRef<ProTableActions>(null);
+
+  const statusConfig: Record<
+    API.LotteryActivityStatus,
+    {
+      label: string;
+      variant: "secondary" | "destructive" | "outline";
+      className?: string;
+    }
+  > = {
+    draft: { label: t("status.draft", "Draft"), variant: "secondary" },
+    running: {
+      label: t("status.running", "Running"),
+      variant: "outline",
+      className: "border-transparent bg-green-500 text-white",
+    },
+    paused: {
+      label: t("status.paused", "Paused"),
+      variant: "outline",
+      className: "border-transparent bg-yellow-500 text-white",
+    },
+    ended: { label: t("status.ended", "Ended"), variant: "destructive" },
+  };
+
+  const statusOptions = [
+    { label: t("statusAll", "All"), value: "all" },
+    { label: t("status.draft", "Draft"), value: "draft" },
+    { label: t("status.running", "Running"), value: "running" },
+    { label: t("status.paused", "Paused"), value: "paused" },
+    { label: t("status.ended", "Ended"), value: "ended" },
+  ];
+
+  return (
+    <>
+      <ProTable<API.LotteryActivity, { status: string }>
+        action={ref}
+        actions={{
+          render: (row) => {
+            const rowActions: React.ReactNode[] = [];
+            if (row.status === "draft") {
+              rowActions.push(
+                <ConfirmButton
+                  cancelText={t("cancel", "Cancel")}
+                  confirmText={t("confirm", "Confirm")}
+                  description={t(
+                    "publishWarning",
+                    "Once published, the activity becomes visible to users."
+                  )}
+                  key="publish"
+                  onConfirm={async () => {
+                    try {
+                      await publishLotteryActivity({ id: row.id });
+                      toast.success(t("publishSuccess", "Publish Success"));
+                      ref.current?.refresh();
+                    } catch {
+                      // Request layer already surfaces the error toast
+                    }
+                  }}
+                  title={t(
+                    "confirmPublish",
+                    "Are you sure you want to publish this activity?"
+                  )}
+                  trigger={<Button size="sm">{t("publish", "Publish")}</Button>}
+                />
+              );
+            }
+            if (row.status === "running") {
+              rowActions.push(
+                <ConfirmButton
+                  cancelText={t("cancel", "Cancel")}
+                  confirmText={t("confirm", "Confirm")}
+                  description={t(
+                    "pauseWarning",
+                    "Users will not be able to draw while the activity is paused."
+                  )}
+                  key="pause"
+                  onConfirm={async () => {
+                    try {
+                      await pauseLotteryActivity({ id: row.id });
+                      toast.success(t("pauseSuccess", "Pause Success"));
+                      ref.current?.refresh();
+                    } catch {
+                      // Request layer already surfaces the error toast
+                    }
+                  }}
+                  title={t(
+                    "confirmPause",
+                    "Are you sure you want to pause this activity?"
+                  )}
+                  trigger={
+                    <Button size="sm" variant="destructive">
+                      {t("pause", "Pause")}
+                    </Button>
+                  }
+                />
+              );
+            }
+            rowActions.push(
+              <ActivityForm
+                initialValues={row}
+                key="edit"
+                loading={loading}
+                onSubmit={async (values) => {
+                  setLoading(true);
+                  try {
+                    await updateLotteryActivity({ ...values, id: row.id });
+                    toast.success(t("updateSuccess", "Update Success"));
+                    ref.current?.refresh();
+                    setLoading(false);
+                    return true;
+                  } catch (_error) {
+                    setLoading(false);
+                    return false;
+                  }
+                }}
+                title={t("editActivity", "Edit Activity")}
+                trigger={t("edit", "Edit")}
+              />,
+              <Button
+                key="manage"
+                onClick={() => {
+                  setSelectedActivity(row);
+                  setDetailOpen(true);
+                }}
+                size="sm"
+                variant="outline"
+              >
+                {t("manage", "Manage")}
+              </Button>,
+              <Button
+                key="grant"
+                onClick={() => {
+                  setSelectedActivity(row);
+                  setGrantOpen(true);
+                }}
+                size="sm"
+                variant="outline"
+              >
+                {t("grantChances", "Grant Chances")}
+              </Button>,
+              <ConfirmButton
+                cancelText={t("cancel", "Cancel")}
+                confirmText={t("delete", "Delete")}
+                description={t(
+                  "confirmDeleteActivityDesc",
+                  "This permanently deletes the activity and its prizes. A running activity must be paused first. This cannot be undone."
+                )}
+                key="delete"
+                onConfirm={async () => {
+                  try {
+                    await deleteLotteryActivity({ id: row.id });
+                    toast.success(t("deleteSuccess", "Deleted"));
+                    ref.current?.refresh();
+                  } catch {
+                    // Request layer already surfaces the error toast
+                  }
+                }}
+                title={t("confirmDeleteActivity", "Delete this activity?")}
+                trigger={
+                  <Button size="sm" variant="destructive">
+                    {t("delete", "Delete")}
+                  </Button>
+                }
+              />
+            );
+            return rowActions;
+          },
+        }}
+        columns={[
+          {
+            accessorKey: "id",
+            header: t("id", "ID"),
+          },
+          {
+            accessorKey: "title",
+            header: t("title", "Title"),
+          },
+          {
+            accessorKey: "status",
+            header: t("statusLabel", "Status"),
+            cell: ({ row }) => {
+              const status = statusConfig[row.original.status];
+              return (
+                <Badge className={status.className} variant={status.variant}>
+                  {status.label}
+                </Badge>
+              );
+            },
+          },
+          {
+            accessorKey: "start_at",
+            header: t("activityTime", "Activity Time"),
+            cell: ({ row }) =>
+              `${formatDate(row.original.start_at)} - ${formatDate(
+                row.original.end_at
+              )}`,
+          },
+          {
+            accessorKey: "grid_size",
+            header: t("gridSize", "Grid Size"),
+          },
+        ]}
+        header={{
+          toolbar: (
+            <ActivityForm
+              loading={loading}
+              onSubmit={async (values) => {
+                setLoading(true);
+                try {
+                  await createLotteryActivity(values);
+                  toast.success(t("createSuccess", "Create Success"));
+                  ref.current?.refresh();
+                  setLoading(false);
+                  return true;
+                } catch (_error) {
+                  setLoading(false);
+                  return false;
+                }
+              }}
+              title={t("createActivity", "Create Activity")}
+              trigger={t("create", "Create")}
+            />
+          ),
+        }}
+        params={[
+          {
+            key: "status",
+            placeholder: t("statusLabel", "Status"),
+            options: statusOptions,
+          },
+        ]}
+        request={async (pagination, filters) => {
+          const { data } = await getLotteryActivityList({
+            ...pagination,
+            ...filters,
+            status:
+              filters?.status && filters.status !== "all"
+                ? filters.status
+                : undefined,
+          });
+          return {
+            list: data.data?.list || [],
+            total: data.data?.total || 0,
+          };
+        }}
+      />
+      <ActivityDetail
+        activity={selectedActivity}
+        onChanged={() => ref.current?.refresh()}
+        onOpenChange={setDetailOpen}
+        open={detailOpen}
+      />
+      <GrantDialog
+        activity={selectedActivity}
+        onOpenChange={setGrantOpen}
+        open={grantOpen}
+      />
+    </>
+  );
+}

apps/admin/src/sections/lottery/prize-form.tsx

@@ -0,0 +1,728 @@
+import { zodResolver } from "@hookform/resolvers/zod";
+import { Button } from "@workspace/ui/components/button";
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from "@workspace/ui/components/form";
+import { ScrollArea } from "@workspace/ui/components/scroll-area";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@workspace/ui/components/select";
+import {
+  Sheet,
+  SheetContent,
+  SheetFooter,
+  SheetHeader,
+  SheetTitle,
+} from "@workspace/ui/components/sheet";
+import { Switch } from "@workspace/ui/components/switch";
+import { ConfirmButton } from "@workspace/ui/composed/confirm-button";
+import {
+  EnhancedInput,
+  type EnhancedInputProps,
+} from "@workspace/ui/composed/enhanced-input";
+import { Icon } from "@workspace/ui/composed/icon";
+import {
+  createLotteryPrize,
+  deleteLotteryPrize,
+  updateLotteryPrize,
+} from "@workspace/ui/services/admin/lottery";
+import { getSubscribeList } from "@workspace/ui/services/admin/subscribe";
+import { useEffect, useState } from "react";
+import { useForm } from "react-hook-form";
+import { useTranslation } from "react-i18next";
+import { toast } from "sonner";
+import { z } from "zod";
+
+const CENTS_PER_YUAN = 100;
+// 概率单位约定：weight 1000 = 1%（支持 3 位小数概率，总权重 100000 = 100%）。
+const WEIGHT_PER_PERCENT = 1000;
+
+type TranslateFn = (key: string, defaultValue: string) => string;
+
+const PRIZE_TYPE_OPTIONS: {
+  value: API.LotteryPrizeType;
+  labelKey: string;
+  labelDefault: string;
+}[] = [
+  {
+    value: "vpn_duration",
+    labelKey: "prize.typeVpnDuration",
+    labelDefault: "VPN Duration",
+  },
+  {
+    value: "commission",
+    labelKey: "prize.typeCommission",
+    labelDefault: "Commission",
+  },
+  {
+    value: "none",
+    labelKey: "prize.typeNone",
+    labelDefault: "No Prize (Thanks)",
+  },
+  {
+    value: "crypto",
+    labelKey: "prize.typeCrypto",
+    labelDefault: "Crypto",
+  },
+  {
+    value: "physical",
+    labelKey: "prize.typePhysical",
+    labelDefault: "Physical",
+  },
+  {
+    value: "manual_other",
+    labelKey: "prize.typeManualOther",
+    labelDefault: "Manual (Other)",
+  },
+];
+
+const getPrizeSchema = (t: TranslateFn) =>
+  z
+    .object({
+      type: z.enum([
+        "vpn_duration",
+        "commission",
+        "none",
+        "crypto",
+        "physical",
+        "manual_other",
+      ]),
+      name: z.string().min(1, t("prize.nameRequired", "Name is required")),
+      icon_url: z
+        .string()
+        .url(t("prize.iconUrlInvalid", "Must be a valid URL"))
+        .or(z.literal(""))
+        .optional(),
+      weight: z
+        .number()
+        .min(0, t("prize.weightMin", "Probability must be at least 0"))
+        .max(100, t("prize.weightMax", "Probability cannot exceed 100")),
+      unlimited_stock: z.boolean(),
+      total_stock: z.number().optional(),
+      is_fallback: z.boolean(),
+      duration_days: z.number().optional(),
+      subscribe_id: z.number().optional(),
+      amount_yuan: z.number().optional(),
+      // 人工奖（crypto / physical / manual_other）通用/专属字段
+      crypto_amount: z.string().optional(),
+      crypto_currency: z.string().optional(),
+      crypto_networks: z.string().optional(), // 逗号分隔，提交时 split 成 string[]
+      sku_name: z.string().optional(),
+      claim_ttl_hours: z.number().optional(),
+    })
+    .superRefine((data, ctx) => {
+      const issue = (path: string, message: string) => {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message, path: [path] });
+      };
+      const isPositiveInt = (value?: number) =>
+        !!value && value > 0 && Number.isInteger(value);
+      if (data.type === "vpn_duration" && !isPositiveInt(data.duration_days)) {
+        issue(
+          "duration_days",
+          t(
+            "prize.durationDaysRequired",
+            "Duration days must be a positive integer"
+          )
+        );
+      }
+      if (data.type === "commission") {
+        const yuan = data.amount_yuan ?? 0;
+        const cents = yuan * CENTS_PER_YUAN;
+        if (yuan <= 0) {
+          issue(
+            "amount_yuan",
+            t("prize.amountRequired", "Amount must be greater than 0")
+          );
+        } else if (Math.abs(Math.round(cents) - cents) > 1e-6) {
+          issue(
+            "amount_yuan",
+            t(
+              "prize.amountPrecision",
+              "Amount supports at most 2 decimal places"
+            )
+          );
+        }
+      }
+      if (data.type === "crypto") {
+        if (!data.crypto_amount?.trim()) {
+          issue(
+            "crypto_amount",
+            t("prize.cryptoAmountRequired", "Amount is required")
+          );
+        }
+        if (!data.crypto_currency?.trim()) {
+          issue(
+            "crypto_currency",
+            t("prize.cryptoCurrencyRequired", "Currency is required")
+          );
+        }
+        const networks = (data.crypto_networks ?? "")
+          .split(",")
+          .map((n) => n.trim())
+          .filter(Boolean);
+        if (networks.length === 0) {
+          issue(
+            "crypto_networks",
+            t(
+              "prize.cryptoNetworksRequired",
+              "At least one network is required (comma-separated)"
+            )
+          );
+        }
+      }
+      if (
+        data.claim_ttl_hours !== undefined &&
+        (!Number.isInteger(data.claim_ttl_hours) || data.claim_ttl_hours <= 0)
+      ) {
+        issue(
+          "claim_ttl_hours",
+          t(
+            "prize.claimTtlInvalid",
+            "Claim window (hours) must be a positive integer"
+          )
+        );
+      }
+      if (!(data.unlimited_stock || isPositiveInt(data.total_stock))) {
+        issue(
+          "total_stock",
+          t(
+            "prize.totalStockRequired",
+            "Total stock must be a positive integer"
+          )
+        );
+      }
+    });
+
+type PrizeFormValues = z.infer<ReturnType<typeof getPrizeSchema>>;
+
+interface PrizeFormProps {
+  activityId: number;
+  slot: number;
+  initialValues?: API.LotteryPrize;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  onSuccess: () => void;
+}
+
+function toFormValues(prize?: API.LotteryPrize): PrizeFormValues {
+  const config = prize?.config ?? {};
+  const networks = Array.isArray(config.networks)
+    ? (config.networks as string[]).join(", ")
+    : undefined;
+  return {
+    type: (prize?.type as PrizeFormValues["type"]) ?? "vpn_duration",
+    name: prize?.name ?? "",
+    icon_url: prize?.icon_url ?? "",
+    weight: (prize?.weight ?? 0) / WEIGHT_PER_PERCENT,
+    unlimited_stock: prize ? prize.total_stock === null : true,
+    total_stock: prize?.total_stock ?? undefined,
+    is_fallback: prize?.is_fallback ?? false,
+    duration_days: config.duration_days as number | undefined,
+    subscribe_id: config.subscribe_id as number | undefined,
+    amount_yuan:
+      typeof config.amount_cents === "number"
+        ? config.amount_cents / CENTS_PER_YUAN
+        : undefined,
+    crypto_amount: config.amount as string | undefined,
+    crypto_currency: config.currency as string | undefined,
+    crypto_networks: networks,
+    sku_name: config.sku_name as string | undefined,
+    claim_ttl_hours: config.claim_ttl_hours as number | undefined,
+  };
+}
+
+function toConfig(values: PrizeFormValues): Record<string, any> {
+  // claim_ttl_hours 对所有人工奖通用：控制领奖窗口（缺省后端默认 7 天）。
+  const withTtl = (base: Record<string, any>): Record<string, any> => {
+    if (values.claim_ttl_hours && values.claim_ttl_hours > 0) {
+      base.claim_ttl_hours = values.claim_ttl_hours;
+    }
+    return base;
+  };
+  if (values.type === "vpn_duration") {
+    const config: Record<string, any> = { duration_days: values.duration_days };
+    // 可选：无活跃订阅时按该套餐新建订阅发放时长。0/未选则沿用旧行为（跳过发放）。
+    if (values.subscribe_id && values.subscribe_id > 0) {
+      config.subscribe_id = values.subscribe_id;
+    }
+    return config;
+  }
+  if (values.type === "commission") {
+    return {
+      amount_cents: Math.round((values.amount_yuan ?? 0) * CENTS_PER_YUAN),
+    };
+  }
+  if (values.type === "crypto") {
+    return withTtl({
+      amount: values.crypto_amount?.trim() ?? "",
+      currency: values.crypto_currency?.trim() ?? "",
+      networks: (values.crypto_networks ?? "")
+        .split(",")
+        .map((n) => n.trim())
+        .filter(Boolean),
+    });
+  }
+  if (values.type === "physical" || values.type === "manual_other") {
+    const config: Record<string, any> = {};
+    if (values.sku_name?.trim()) {
+      config.sku_name = values.sku_name.trim();
+    }
+    return withTtl(config);
+  }
+  return {};
+}
+
+export default function PrizeForm({
+  activityId,
+  slot,
+  initialValues,
+  open,
+  onOpenChange,
+  onSuccess,
+}: PrizeFormProps) {
+  const { t } = useTranslation("lottery");
+  const [loading, setLoading] = useState(false);
+  const [plans, setPlans] = useState<API.SubscribeItem[]>([]);
+  const form = useForm<PrizeFormValues>({
+    resolver: zodResolver(getPrizeSchema(t)),
+    defaultValues: toFormValues(initialValues),
+  });
+  const type = form.watch("type");
+  const unlimitedStock = form.watch("unlimited_stock");
+  const isFallback = form.watch("is_fallback");
+  const isEdit = !!initialValues?.id;
+  const targetSlot = initialValues?.slot ?? slot;
+
+  useEffect(() => {
+    if (open) form.reset(toFormValues(initialValues));
+  }, [form, initialValues, open]);
+
+  // vpn_duration 需要一个可选的“新建订阅套餐”下拉，仅在面板打开且类型匹配时拉取。
+  useEffect(() => {
+    if (!(open && type === "vpn_duration") || plans.length > 0) return;
+    getSubscribeList({ page: 1, size: 100 })
+      .then(({ data }) => setPlans(data?.data?.list ?? []))
+      .catch(() => {
+        // Request layer already surfaces the error toast
+      });
+  }, [open, type, plans.length]);
+
+  async function handleSubmit(values: PrizeFormValues) {
+    setLoading(true);
+    try {
+      const body: API.CreateLotteryPrizeRequest = {
+        activity_id: activityId,
+        slot: targetSlot,
+        type: values.type,
+        name: values.name.trim(),
+        icon_url: values.icon_url?.trim() ?? "",
+        config: toConfig(values),
+        weight: values.is_fallback
+          ? 0
+          : Math.round(values.weight * WEIGHT_PER_PERCENT),
+        total_stock: values.unlimited_stock
+          ? null
+          : (values.total_stock ?? null),
+        is_fallback: values.is_fallback,
+      };
+      if (isEdit) {
+        await updateLotteryPrize({ ...body, id: initialValues!.id });
+        toast.success(t("prize.updateSuccess", "Prize updated"));
+      } else {
+        await createLotteryPrize(body);
+        toast.success(t("prize.createSuccess", "Prize created"));
+      }
+      onSuccess();
+      onOpenChange(false);
+    } catch {
+      // Request layer already surfaces the error toast
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  async function handleDelete() {
+    if (!initialValues?.id) return;
+    setLoading(true);
+    try {
+      await deleteLotteryPrize({ id: initialValues.id });
+      toast.success(t("prize.deleteSuccess", "Prize deleted"));
+      onSuccess();
+      onOpenChange(false);
+    } catch {
+      // Request layer already surfaces the error toast
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  const renderInput = (
+    name:
+      | "name"
+      | "icon_url"
+      | "weight"
+      | "total_stock"
+      | "duration_days"
+      | "amount_yuan"
+      | "crypto_amount"
+      | "crypto_currency"
+      | "crypto_networks"
+      | "sku_name"
+      | "claim_ttl_hours",
+    label: string,
+    inputProps: Partial<EnhancedInputProps<any>>,
+    description?: string
+  ) => (
+    <FormField
+      control={form.control}
+      name={name}
+      render={({ field }) => (
+        <FormItem>
+          <FormLabel>{label}</FormLabel>
+          <FormControl>
+            <EnhancedInput
+              onValueChange={(value) => form.setValue(name, value)}
+              value={field.value}
+              {...inputProps}
+            />
+          </FormControl>
+          {description && (
+            <p className="text-muted-foreground text-xs">{description}</p>
+          )}
+          <FormMessage />
+        </FormItem>
+      )}
+    />
+  );
+
+  const renderSwitch = (
+    name: "unlimited_stock" | "is_fallback",
+    label: string,
+    description?: string
+  ) => (
+    <FormField
+      control={form.control}
+      name={name}
+      render={({ field }) => (
+        <FormItem className="flex items-center justify-between rounded-md border p-3">
+          <div className="space-y-1">
+            <FormLabel>{label}</FormLabel>
+            {description && (
+              <p className="text-muted-foreground text-xs">{description}</p>
+            )}
+          </div>
+          <FormControl>
+            <Switch
+              checked={field.value}
+              onCheckedChange={(checked) => form.setValue(name, checked)}
+            />
+          </FormControl>
+        </FormItem>
+      )}
+    />
+  );
+
+  return (
+    <Sheet onOpenChange={onOpenChange} open={open}>
+      <SheetContent className="w-[520px] max-w-full md:max-w-screen-md">
+        <SheetHeader>
+          <SheetTitle>
+            {isEdit
+              ? t("prize.editTitle", "Edit Prize")
+              : t("prize.createTitle", "Add Prize")}
+            {" · "}
+            {t("prize.slotLabel", "Slot")} {targetSlot}
+          </SheetTitle>
+        </SheetHeader>
+        <ScrollArea className="h-[calc(100vh-48px-36px-36px-env(safe-area-inset-top))]">
+          <Form {...form}>
+            <form
+              className="space-y-4 px-6 pt-4"
+              onSubmit={form.handleSubmit(handleSubmit)}
+            >
+              <FormField
+                control={form.control}
+                name="type"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t("prize.type", "Prize Type")}</FormLabel>
+                    <FormControl>
+                      <Select
+                        onValueChange={(value) =>
+                          form.setValue(
+                            field.name,
+                            value as PrizeFormValues["type"]
+                          )
+                        }
+                        value={field.value}
+                      >
+                        <SelectTrigger className="w-full">
+                          <SelectValue
+                            placeholder={t("prize.selectType", "Select type")}
+                          />
+                        </SelectTrigger>
+                        <SelectContent>
+                          {PRIZE_TYPE_OPTIONS.map((option) => (
+                            <SelectItem key={option.value} value={option.value}>
+                              {t(option.labelKey, option.labelDefault)}
+                            </SelectItem>
+                          ))}
+                        </SelectContent>
+                      </Select>
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              {renderInput("name", t("prize.name", "Prize Name"), {
+                placeholder: t("prize.namePlaceholder", "e.g. 1-Day Pass"),
+              })}
+              {renderInput("icon_url", t("prize.iconUrl", "Icon URL"), {
+                placeholder: "https://",
+              })}
+              {type === "vpn_duration" &&
+                renderInput(
+                  "duration_days",
+                  t("prize.durationDays", "Duration (days)"),
+                  {
+                    type: "number",
+                    min: 1,
+                    step: 1,
+                    placeholder: t("prize.durationDaysPlaceholder", "e.g. 1"),
+                    suffix: t("prize.daysSuffix", "days"),
+                  }
+                )}
+              {type === "vpn_duration" && (
+                <FormField
+                  control={form.control}
+                  name="subscribe_id"
+                  render={({ field }) => (
+                    <FormItem>
+                      <FormLabel>
+                        {t("prize.subscribePlan", "New-subscription plan")}
+                      </FormLabel>
+                      <FormControl>
+                        <Select
+                          onValueChange={(value) =>
+                            form.setValue(
+                              "subscribe_id",
+                              value ? Number(value) : undefined
+                            )
+                          }
+                          value={field.value ? String(field.value) : undefined}
+                        >
+                          <SelectTrigger className="w-full">
+                            <SelectValue
+                              placeholder={t(
+                                "prize.subscribePlanPlaceholder",
+                                "None — skip if user has no active subscription"
+                              )}
+                            />
+                          </SelectTrigger>
+                          <SelectContent>
+                            {plans.map((plan) => (
+                              <SelectItem key={plan.id} value={String(plan.id)}>
+                                {plan.name ?? `#${plan.id}`}
+                              </SelectItem>
+                            ))}
+                          </SelectContent>
+                        </Select>
+                      </FormControl>
+                      <p className="text-muted-foreground text-xs">
+                        {t(
+                          "prize.subscribePlanHint",
+                          "When the user has no active subscription, create one on this plan and grant the duration. Leave empty to skip granting."
+                        )}
+                      </p>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
+              )}
+              {type === "commission" &&
+                renderInput(
+                  "amount_yuan",
+                  t("prize.amountYuan", "Commission Amount (CNY)"),
+                  {
+                    type: "number",
+                    min: 0,
+                    step: 0.01,
+                    placeholder: "0.00",
+                    prefix: "¥",
+                    suffix: t("prize.yuanSuffix", "CNY"),
+                  },
+                  t(
+                    "prize.amountUnitHint",
+                    "Entered in CNY (yuan), stored as cents; up to 2 decimal places"
+                  )
+                )}
+              {type === "none" && (
+                <p className="rounded-md bg-muted/50 p-3 text-muted-foreground text-xs">
+                  {t(
+                    "prize.noneHint",
+                    "No config needed. Consider enabling fallback so users always land on this prize when limited prizes run out."
+                  )}
+                </p>
+              )}
+              {type === "crypto" && (
+                <>
+                  {renderInput(
+                    "crypto_amount",
+                    t("prize.cryptoAmount", "Amount"),
+                    {
+                      placeholder: t(
+                        "prize.cryptoAmountPlaceholder",
+                        "e.g. 0.01"
+                      ),
+                    }
+                  )}
+                  {renderInput(
+                    "crypto_currency",
+                    t("prize.cryptoCurrency", "Currency"),
+                    { placeholder: "USDT / BTC / ETH" }
+                  )}
+                  {renderInput(
+                    "crypto_networks",
+                    t("prize.cryptoNetworks", "Networks"),
+                    { placeholder: "TRC20, ERC20, BTC" },
+                    t(
+                      "prize.cryptoNetworksHint",
+                      "Comma-separated. The user picks one of these when claiming."
+                    )
+                  )}
+                </>
+              )}
+              {(type === "physical" || type === "manual_other") &&
+                renderInput(
+                  "sku_name",
+                  t("prize.skuName", "Item name (optional)"),
+                  {
+                    placeholder: t(
+                      "prize.skuNamePlaceholder",
+                      "e.g. Limited T-shirt"
+                    ),
+                  }
+                )}
+              {(type === "crypto" ||
+                type === "physical" ||
+                type === "manual_other") && (
+                <>
+                  {renderInput(
+                    "claim_ttl_hours",
+                    t("prize.claimTtlHours", "Claim window (hours)"),
+                    {
+                      type: "number",
+                      min: 1,
+                      step: 1,
+                      placeholder: "168",
+                      suffix: t("prize.hoursSuffix", "hours"),
+                    },
+                    t(
+                      "prize.claimTtlHint",
+                      "How long the user has to submit claim info. Default 168h (7 days)."
+                    )
+                  )}
+                  <p className="rounded-md bg-muted/50 p-3 text-muted-foreground text-xs">
+                    {t(
+                      "prize.manualPrizeHint",
+                      "Manual prize: the winner submits claim info, then an operator approves and marks it paid/shipped under the Claims tab."
+                    )}
+                  </p>
+                </>
+              )}
+              {renderInput(
+                "weight",
+                t("prize.weight", "Win probability (%)"),
+                {
+                  type: "number",
+                  min: 0,
+                  max: 100,
+                  step: 0.001,
+                  suffix: "%",
+                  disabled: isFallback,
+                },
+                isFallback
+                  ? t(
+                      "prize.fallbackIgnoresWeight",
+                      "Fallback prize ignores probability (never randomly drawn)"
+                    )
+                  : t(
+                      "prize.weightHint",
+                      "Percent chance in the grid. All drawable prizes must total 100%. 0 = shown but never drawn."
+                    )
+              )}
+              {renderSwitch(
+                "unlimited_stock",
+                t("prize.unlimitedStock", "Unlimited Stock")
+              )}
+              {!unlimitedStock &&
+                renderInput(
+                  "total_stock",
+                  t("prize.totalStock", "Total Stock"),
+                  {
+                    type: "number",
+                    min: 1,
+                    step: 1,
+                    placeholder: t("prize.totalStockPlaceholder", "e.g. 100"),
+                  }
+                )}
+              {renderSwitch(
+                "is_fallback",
+                t("prize.isFallback", "Fallback Prize"),
+                t(
+                  "prize.isFallbackHint",
+                  "Awarded when limited prizes are sold out"
+                )
+              )}
+            </form>
+          </Form>
+        </ScrollArea>
+        <SheetFooter className="flex-row justify-end gap-2 pt-3">
+          {isEdit && (
+            <ConfirmButton
+              cancelText={t("prize.cancel", "Cancel")}
+              confirmText={t("prize.confirmDelete", "Delete")}
+              description={t(
+                "prize.deleteDescription",
+                "This prize will be removed from the grid. This action cannot be undone."
+              )}
+              onConfirm={handleDelete}
+              title={t("prize.deleteTitle", "Delete this prize?")}
+              trigger={
+                <Button
+                  className="mr-auto"
+                  disabled={loading}
+                  variant="destructive"
+                >
+                  {t("prize.delete", "Delete")}
+                </Button>
+              }
+            />
+          )}
+          <Button
+            disabled={loading}
+            onClick={() => onOpenChange(false)}
+            variant="outline"
+          >
+            {t("prize.cancel", "Cancel")}
+          </Button>
+          <Button disabled={loading} onClick={form.handleSubmit(handleSubmit)}>
+            {loading && (
+              <Icon className="mr-2 animate-spin" icon="mdi:loading" />
+            )}
+            {t("prize.confirm", "Confirm")}
+          </Button>
+        </SheetFooter>
+      </SheetContent>
+    </Sheet>
+  );
+}

apps/admin/src/sections/lottery/prize-grid.tsx

@@ -0,0 +1,294 @@
+import {
+  Alert,
+  AlertDescription,
+  AlertTitle,
+} from "@workspace/ui/components/alert";
+import { Badge } from "@workspace/ui/components/badge";
+import { Skeleton } from "@workspace/ui/components/skeleton";
+import { cn } from "@workspace/ui/lib/utils";
+import { getLotteryPrizeList } from "@workspace/ui/services/admin/lottery";
+import { AlertTriangle, Plus } from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useTranslation } from "react-i18next";
+import PrizeForm from "./prize-form";
+
+const DEFAULT_GRID_SIZE = 9;
+const CENTER_SLOT = 4;
+const CENTS_PER_YUAN = 100;
+// 概率单位约定：weight 1000 = 1%，总权重 100000 = 100.000%（支持 3 位小数概率）。
+const WEIGHT_PER_PERCENT = 1000;
+const FULL_TOTAL_WEIGHT = 100 * WEIGHT_PER_PERCENT;
+
+// weightToPercent 把原始 weight 转成百分比字符串（最多 3 位小数，去尾零）。
+function weightToPercent(weight: number): string {
+  const pct = weight / WEIGHT_PER_PERCENT;
+  return `${Number.parseFloat(pct.toFixed(3))}`;
+}
+
+interface PrizeGridProps {
+  activity: API.LotteryActivity;
+}
+
+type TranslateFn = (key: string, defaultValue: string) => string;
+
+function prizeTypeLabel(type: API.LotteryPrizeType, t: TranslateFn): string {
+  const labels: Record<string, string> = {
+    vpn_duration: t("prize.typeVpnDuration", "VPN Duration"),
+    commission: t("prize.typeCommission", "Commission"),
+    none: t("prize.typeNone", "No Prize (Thanks)"),
+    crypto: t("prize.typeCrypto", "Crypto"),
+    physical: t("prize.typePhysical", "Physical"),
+    manual_other: t("prize.typeManualOther", "Manual (Other)"),
+    coupon: t("prize.typeCoupon", "Coupon"),
+    points: t("prize.typePoints", "Points"),
+  };
+  return labels[type] ?? type;
+}
+
+// prizeConfigSummary 把奖品的类型专属 config 渲染成一行可读文本，
+// 让九宫格卡片显示真实配置值（免费时长天数 / 佣金金额），而不是只有类型徽章。
+function prizeConfigSummary(
+  prize: API.LotteryPrize,
+  t: TranslateFn
+): string | null {
+  const config = prize.config ?? {};
+  if (prize.type === "vpn_duration") {
+    const days = config.duration_days as number | undefined;
+    if (typeof days === "number" && days > 0) {
+      return `${days} ${t("prize.daysSuffix", "days")}`;
+    }
+    return null;
+  }
+  if (prize.type === "commission") {
+    const cents = config.amount_cents as number | undefined;
+    if (typeof cents === "number" && cents > 0) {
+      return `¥${(cents / CENTS_PER_YUAN).toFixed(2)}`;
+    }
+    return null;
+  }
+  return null;
+}
+
+interface FormState {
+  open: boolean;
+  slot: number;
+  prize?: API.LotteryPrize;
+}
+
+export default function PrizeGrid({ activity }: PrizeGridProps) {
+  const { t } = useTranslation("lottery");
+  const [prizes, setPrizes] = useState<API.LotteryPrize[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [formState, setFormState] = useState<FormState>({
+    open: false,
+    slot: 0,
+  });
+
+  const fetchPrizes = useCallback(async () => {
+    setLoading(true);
+    try {
+      const { data } = await getLotteryPrizeList({ activity_id: activity.id });
+      setPrizes(data?.data?.list ?? []);
+    } catch {
+      // Request layer already surfaces the error toast
+    } finally {
+      setLoading(false);
+    }
+  }, [activity.id]);
+
+  useEffect(() => {
+    fetchPrizes();
+  }, [fetchPrizes]);
+
+  const prizeBySlot = useMemo(() => {
+    const map = new Map<number, API.LotteryPrize>();
+    for (const prize of prizes) {
+      map.set(prize.slot, prize);
+    }
+    return map;
+  }, [prizes]);
+
+  const randomPrizes = useMemo(
+    () => prizes.filter((prize) => prize.weight > 0 && !prize.is_fallback),
+    [prizes]
+  );
+  const totalWeight = useMemo(
+    () => randomPrizes.reduce((sum, prize) => sum + prize.weight, 0),
+    [randomPrizes]
+  );
+  const hasFallback = prizes.some((prize) => prize.is_fallback);
+  const totalIsValid = totalWeight === FULL_TOTAL_WEIGHT;
+  const gridSize = activity.grid_size || DEFAULT_GRID_SIZE;
+  const slots = Array.from({ length: gridSize }, (_, index) => index);
+
+  const openForm = (slot: number, prize?: API.LotteryPrize) => {
+    setFormState({ open: true, slot, prize });
+  };
+
+  if (loading && prizes.length === 0) {
+    return (
+      <div className="grid grid-cols-3 gap-3">
+        {slots.map((slot) => (
+          <Skeleton className="min-h-[132px] rounded-lg" key={slot} />
+        ))}
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-4">
+      <div className="rounded-lg border bg-muted/30 p-3">
+        <div className="mb-2 flex items-center justify-between">
+          <p className="font-medium text-sm">
+            {t("prize.probabilityPreview", "Probability Preview")}
+          </p>
+          {randomPrizes.length > 0 && (
+            <Badge variant={totalIsValid ? "secondary" : "destructive"}>
+              {t("prize.probabilityTotal", "Total")}:{" "}
+              {weightToPercent(totalWeight)}%
+            </Badge>
+          )}
+        </div>
+        {randomPrizes.length > 0 ? (
+          <div className="flex flex-wrap gap-2">
+            {randomPrizes.map((prize) => (
+              <Badge key={prize.id} variant="secondary">
+                {prize.name}: {weightToPercent(prize.weight)}%
+              </Badge>
+            ))}
+          </div>
+        ) : (
+          <p className="text-muted-foreground text-xs">
+            {t(
+              "prize.noRandomPrizes",
+              "No prizes participate in the random draw yet"
+            )}
+          </p>
+        )}
+      </div>
+      {randomPrizes.length > 0 && !totalIsValid && (
+        <Alert variant="destructive">
+          <AlertTriangle className="h-4 w-4" />
+          <AlertTitle>
+            {t("prize.totalNot100Title", "Probabilities must total 100%")}
+          </AlertTitle>
+          <AlertDescription>
+            {t(
+              "prize.totalNot100Hint",
+              "The drawable prizes currently total {{total}}%. Adjust each prize's win probability so they sum to exactly 100%.",
+              { total: weightToPercent(totalWeight) }
+            )}
+          </AlertDescription>
+        </Alert>
+      )}
+      {!hasFallback && (
+        <Alert>
+          <AlertTriangle className="h-4 w-4" />
+          <AlertTitle>
+            {t("prize.noFallbackTitle", "No fallback prize")}
+          </AlertTitle>
+          <AlertDescription>
+            {t(
+              "prize.noFallbackHint",
+              "Consider configuring a fallback prize so draws never fail when limited prizes run out."
+            )}
+          </AlertDescription>
+        </Alert>
+      )}
+      <div className="grid grid-cols-3 gap-3">
+        {slots.map((slot) => {
+          const prize = prizeBySlot.get(slot);
+          return (
+            <button
+              className={cn(
+                "relative flex min-h-[132px] flex-col items-center justify-center gap-1 rounded-lg border p-3 text-center transition-colors hover:border-primary",
+                prize ? "bg-card" : "border-dashed text-muted-foreground"
+              )}
+              key={slot}
+              onClick={() => openForm(slot, prize)}
+              type="button"
+            >
+              <span className="absolute top-1 left-1.5 text-[10px] text-muted-foreground">
+                #{slot}
+              </span>
+              {slot === CENTER_SLOT && (
+                <Badge
+                  className="absolute top-1 right-1 px-1.5 text-[10px]"
+                  variant="outline"
+                >
+                  {t("prize.centerSlotHint", "Usually the draw button")}
+                </Badge>
+              )}
+              {prize ? (
+                <>
+                  {prize.icon_url ? (
+                    <img
+                      alt={prize.name}
+                      className="h-8 w-8 rounded object-cover"
+                      height={32}
+                      src={prize.icon_url}
+                      width={32}
+                    />
+                  ) : (
+                    <span aria-hidden className="text-2xl">
+                      🎁
+                    </span>
+                  )}
+                  <span className="line-clamp-1 font-medium text-sm">
+                    {prize.name}
+                  </span>
+                  <Badge variant="secondary">
+                    {prizeTypeLabel(prize.type, t)}
+                  </Badge>
+                  {(() => {
+                    const summary = prizeConfigSummary(prize, t);
+                    return summary ? (
+                      <span className="line-clamp-1 font-medium text-primary text-xs">
+                        {summary}
+                      </span>
+                    ) : null;
+                  })()}
+                  <span className="text-muted-foreground text-xs">
+                    {t("prize.weightShort", "Prob")}:{" "}
+                    {prize.is_fallback
+                      ? "—"
+                      : `${weightToPercent(prize.weight)}%`}{" "}
+                    · {t("prize.stockShort", "Stock")}:{" "}
+                    {prize.total_stock === null ? "∞" : prize.total_stock}
+                  </span>
+                  <div className="flex flex-wrap justify-center gap-1">
+                    {prize.is_fallback && (
+                      <Badge variant="outline">
+                        {t("prize.fallbackBadge", "Fallback")}
+                      </Badge>
+                    )}
+                    {prize.sold_out && (
+                      <Badge variant="destructive">
+                        {t("prize.soldOutBadge", "Sold Out")}
+                      </Badge>
+                    )}
+                  </div>
+                </>
+              ) : (
+                <>
+                  <Plus className="h-5 w-5" />
+                  <span className="text-xs">
+                    {t("prize.addPrize", "Add Prize")}
+                  </span>
+                </>
+              )}
+            </button>
+          );
+        })}
+      </div>
+      <PrizeForm
+        activityId={activity.id}
+        initialValues={formState.prize}
+        onOpenChange={(open) => setFormState((prev) => ({ ...prev, open }))}
+        onSuccess={fetchPrizes}
+        open={formState.open}
+        slot={formState.slot}
+      />
+    </div>
+  );
+}

apps/admin/src/sections/lottery/rule-editor-utils.ts

@@ -0,0 +1,448 @@
+import { z } from "zod";
+
+export const RULE_CAPS = { maxDepth: 8, maxNodes: 64, maxBytes: 8192 } as const;
+
+export const CHANCE_SOURCE_OPTIONS: {
+  value: API.LotteryChanceSourceType;
+  labelKey: string;
+  labelDefault: string;
+}[] = [
+  {
+    value: "daily_signin",
+    labelKey: "rules.source.dailySignin",
+    labelDefault: "Daily Sign-in",
+  },
+  {
+    value: "new_subscription",
+    labelKey: "rules.source.newSubscription",
+    labelDefault: "New Subscription",
+  },
+  {
+    value: "invite_success",
+    labelKey: "rules.source.inviteSuccess",
+    labelDefault: "Invite Success",
+  },
+  {
+    value: "manual_grant",
+    labelKey: "rules.source.manualGrant",
+    labelDefault: "Manual Grant",
+  },
+];
+
+export const CONDITION_TYPES = [
+  "has_subscription",
+  "subscription_type",
+  "invite_count",
+  "total_recharge",
+  "register_days",
+  "user_tag",
+] as const;
+
+export type ConditionType = (typeof CONDITION_TYPES)[number];
+
+export interface ConditionRow {
+  type: ConditionType;
+  minDaysRemaining?: number;
+  planIds?: string;
+  min?: number;
+  windowDays?: number;
+  minUsdt?: number;
+  tags?: string;
+}
+
+export interface ConditionParamField {
+  key: keyof Omit<ConditionRow, "type">;
+  inputType: "number" | "text";
+  labelKey: string;
+  labelDefault: string;
+  placeholderKey?: string;
+  placeholderDefault?: string;
+}
+
+export const CONDITION_PARAM_FIELDS: Record<
+  ConditionType,
+  ConditionParamField[]
+> = {
+  has_subscription: [
+    {
+      key: "minDaysRemaining",
+      inputType: "number",
+      labelKey: "rules.param.minDaysRemaining",
+      labelDefault: "Min Days Remaining",
+    },
+  ],
+  subscription_type: [
+    {
+      key: "planIds",
+      inputType: "text",
+      labelKey: "rules.param.planIds",
+      labelDefault: "Plan IDs",
+      placeholderKey: "rules.param.planIdsPlaceholder",
+      placeholderDefault: "Comma separated, e.g. 1,2,3",
+    },
+  ],
+  invite_count: [
+    {
+      key: "min",
+      inputType: "number",
+      labelKey: "rules.param.min",
+      labelDefault: "Min Count",
+    },
+    {
+      key: "windowDays",
+      inputType: "number",
+      labelKey: "rules.param.windowDays",
+      labelDefault: "Window Days (optional)",
+    },
+  ],
+  total_recharge: [
+    {
+      key: "minUsdt",
+      inputType: "number",
+      labelKey: "rules.param.minUsdt",
+      labelDefault: "Min USDT",
+    },
+  ],
+  register_days: [
+    {
+      key: "min",
+      inputType: "number",
+      labelKey: "rules.param.min",
+      labelDefault: "Min Count",
+    },
+  ],
+  user_tag: [
+    {
+      key: "tags",
+      inputType: "text",
+      labelKey: "rules.param.tags",
+      labelDefault: "Tags",
+      placeholderKey: "rules.param.tagsPlaceholder",
+      placeholderDefault: "Comma separated, e.g. vip,beta",
+    },
+  ],
+};
+
+export function parseIntList(input?: string): number[] {
+  if (!input) return [];
+  return input
+    .split(/[,，\s]+/)
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .map((item) => Number.parseInt(item, 10))
+    .filter((item) => Number.isFinite(item));
+}
+
+export function parseStringList(input?: string): string[] {
+  if (!input) return [];
+  return input
+    .split(/[,，]+/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function conditionToNode(row: ConditionRow): API.LotteryEligibilityNode {
+  switch (row.type) {
+    case "has_subscription":
+      return {
+        type: row.type,
+        params: { min_days_remaining: row.minDaysRemaining ?? 0 },
+      };
+    case "subscription_type":
+      return {
+        type: row.type,
+        params: { plan_ids: parseIntList(row.planIds) },
+      };
+    case "invite_count": {
+      const params: Record<string, number> = { min: row.min ?? 0 };
+      if (row.windowDays) params.window_days = row.windowDays;
+      return { type: row.type, params };
+    }
+    case "total_recharge":
+      return { type: row.type, params: { min_usdt: row.minUsdt ?? 0 } };
+    case "register_days":
+      return { type: row.type, params: { min: row.min ?? 0 } };
+    case "user_tag":
+      return { type: row.type, params: { tags: parseStringList(row.tags) } };
+  }
+}
+
+export function buildEligibility(
+  op: "AND" | "OR",
+  rows: ConditionRow[]
+): API.LotteryEligibilityNode | Record<string, never> {
+  if (rows.length === 0) return {};
+  return { op, children: rows.map(conditionToNode) };
+}
+
+function isLeafNode(node: API.LotteryEligibilityNode): boolean {
+  return Boolean(node.type) && !node.op && !node.children?.length;
+}
+
+function nodeToCondition(
+  node: API.LotteryEligibilityNode
+): ConditionRow | null {
+  const type = CONDITION_TYPES.find((item) => item === node.type);
+  if (!type) return null;
+  const params = node.params ?? {};
+  switch (type) {
+    case "has_subscription":
+      return { type, minDaysRemaining: params.min_days_remaining };
+    case "subscription_type":
+      return {
+        type,
+        planIds: Array.isArray(params.plan_ids)
+          ? params.plan_ids.join(",")
+          : "",
+      };
+    case "invite_count":
+      return { type, min: params.min, windowDays: params.window_days };
+    case "total_recharge":
+      return { type, minUsdt: params.min_usdt };
+    case "register_days":
+      return { type, min: params.min };
+    case "user_tag":
+      return {
+        type,
+        tags: Array.isArray(params.tags) ? params.tags.join(",") : "",
+      };
+  }
+}
+
+export function isEmptyEligibility(
+  eligibility: API.LotteryActivity["eligibility"]
+): boolean {
+  return (
+    eligibility === null ||
+    eligibility === undefined ||
+    Object.keys(eligibility).length === 0
+  );
+}
+
+/**
+ * 尝试把规则树还原成「一层 op + children 全是叶子」的简单模式；
+ * 结构更复杂时返回 null（调用方应切到高级模式）。
+ */
+export function treeToSimple(
+  eligibility: API.LotteryActivity["eligibility"]
+): { op: "AND" | "OR"; rows: ConditionRow[] } | null {
+  if (isEmptyEligibility(eligibility)) return { op: "AND", rows: [] };
+  const tree = eligibility as API.LotteryEligibilityNode;
+  if (
+    (tree.op !== "AND" && tree.op !== "OR") ||
+    !Array.isArray(tree.children) ||
+    !tree.children.every(isLeafNode)
+  ) {
+    return null;
+  }
+  const rows: ConditionRow[] = [];
+  for (const child of tree.children) {
+    const row = nodeToCondition(child);
+    if (!row) return null;
+    rows.push(row);
+  }
+  return { op: tree.op, rows };
+}
+
+export interface RuleCapsResult {
+  depth: number;
+  nodes: number;
+  bytes: number;
+  depthExceeded: boolean;
+  nodesExceeded: boolean;
+  bytesExceeded: boolean;
+  ok: boolean;
+}
+
+export function checkRuleCaps(
+  tree: API.LotteryEligibilityNode | Record<string, never>
+): RuleCapsResult {
+  function walk(node: API.LotteryEligibilityNode): {
+    depth: number;
+    nodes: number;
+  } {
+    const children = Array.isArray(node.children) ? node.children : [];
+    let maxChildDepth = 0;
+    let nodes = 1;
+    for (const child of children) {
+      const result = walk(child);
+      maxChildDepth = Math.max(maxChildDepth, result.depth);
+      nodes += result.nodes;
+    }
+    return { depth: maxChildDepth + 1, nodes };
+  }
+
+  const { depth, nodes } = walk(tree);
+  const bytes = new TextEncoder().encode(JSON.stringify(tree)).length;
+  const depthExceeded = depth > RULE_CAPS.maxDepth;
+  const nodesExceeded = nodes > RULE_CAPS.maxNodes;
+  const bytesExceeded = bytes > RULE_CAPS.maxBytes;
+  return {
+    depth,
+    nodes,
+    bytes,
+    depthExceeded,
+    nodesExceeded,
+    bytesExceeded,
+    ok: !(depthExceeded || nodesExceeded || bytesExceeded),
+  };
+}
+
+export type TranslateFn = (key: string, defaultValue: string) => string;
+
+/** 规则树超限时返回具体超限项的提示文案，未超限返回 null。 */
+export function buildCapsErrorMessage(
+  t: TranslateFn,
+  eligibility: API.LotteryEligibilityNode | Record<string, never>
+): string | null {
+  if (isEmptyEligibility(eligibility)) return null;
+  const caps = checkRuleCaps(eligibility);
+  if (caps.ok) return null;
+  const fill = (template: string, value: number, limit: number) =>
+    template
+      .replace("{{value}}", String(value))
+      .replace("{{limit}}", String(limit));
+  const parts: string[] = [];
+  if (caps.depthExceeded) {
+    parts.push(
+      fill(
+        t("rules.capsDepthExceeded", "Depth {{value}} exceeds limit {{limit}}"),
+        caps.depth,
+        RULE_CAPS.maxDepth
+      )
+    );
+  }
+  if (caps.nodesExceeded) {
+    parts.push(
+      fill(
+        t(
+          "rules.capsNodesExceeded",
+          "Node count {{value}} exceeds limit {{limit}}"
+        ),
+        caps.nodes,
+        RULE_CAPS.maxNodes
+      )
+    );
+  }
+  if (caps.bytesExceeded) {
+    parts.push(
+      fill(
+        t(
+          "rules.capsBytesExceeded",
+          "Size {{value}} bytes exceeds limit {{limit}} bytes"
+        ),
+        caps.bytes,
+        RULE_CAPS.maxBytes
+      )
+    );
+  }
+  return parts.join("; ");
+}
+
+export function validateJsonTree(input: string, t: TranslateFn): string | null {
+  try {
+    const parsed: unknown = JSON.parse(input);
+    if (parsed === null) return null;
+    if (typeof parsed !== "object" || Array.isArray(parsed)) {
+      return t("rules.jsonMustBeObject", "Rule tree must be a JSON object");
+    }
+    return null;
+  } catch (error: unknown) {
+    return error instanceof Error ? error.message : "Invalid JSON";
+  }
+}
+
+const chanceSourceSchema = z.object({
+  source: z.enum([
+    "daily_signin",
+    "new_subscription",
+    "invite_success",
+    "manual_grant",
+  ]),
+  amount: z.number().int().min(0),
+  daily_limit: z.number().int().min(0).optional(),
+});
+
+const conditionSchema = z.object({
+  type: z.enum(CONDITION_TYPES),
+  minDaysRemaining: z.number().int().min(0).optional(),
+  planIds: z.string().optional(),
+  min: z.number().int().min(0).optional(),
+  windowDays: z.number().int().min(0).optional(),
+  minUsdt: z.number().min(0).optional(),
+  tags: z.string().optional(),
+});
+
+export const getRuleEditorSchema = (t: TranslateFn) =>
+  z
+    .object({
+      chanceSources: z.array(chanceSourceSchema),
+      mode: z.enum(["simple", "advanced"]),
+      op: z.enum(["AND", "OR"]),
+      conditions: z.array(conditionSchema),
+      advancedJson: z.string(),
+    })
+    .superRefine((data, ctx) => {
+      const seen = new Set<string>();
+      data.chanceSources.forEach((row, index) => {
+        if (seen.has(row.source)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: t("rules.duplicateSource", "Duplicate source"),
+            path: ["chanceSources", index, "source"],
+          });
+        }
+        seen.add(row.source);
+      });
+      if (data.mode === "advanced" && data.advancedJson.trim()) {
+        const error = validateJsonTree(data.advancedJson, t);
+        if (error) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: error,
+            path: ["advancedJson"],
+          });
+        }
+      }
+    });
+
+export type RuleEditorValues = z.infer<ReturnType<typeof getRuleEditorSchema>>;
+
+export function toRuleEditorValues(
+  activity: API.LotteryActivity
+): RuleEditorValues {
+  const chanceSources = (activity.chance_sources ?? []).map((row) => ({
+    source: row.source,
+    amount: row.amount,
+    daily_limit: row.daily_limit ?? undefined,
+  }));
+  const simple = treeToSimple(activity.eligibility);
+  if (simple) {
+    return {
+      chanceSources,
+      mode: "simple",
+      op: simple.op,
+      conditions: simple.rows,
+      advancedJson: "",
+    };
+  }
+  return {
+    chanceSources,
+    mode: "advanced",
+    op: "AND",
+    conditions: [],
+    advancedJson: JSON.stringify(activity.eligibility, null, 2),
+  };
+}
+
+export function resolveEligibility(
+  values: RuleEditorValues
+): API.LotteryEligibilityNode | Record<string, never> {
+  if (values.mode === "simple") {
+    return buildEligibility(values.op, values.conditions);
+  }
+  const text = values.advancedJson.trim();
+  if (!text) return {};
+  const parsed = JSON.parse(text) as API.LotteryEligibilityNode | null;
+  return parsed ?? {};
+}

apps/admin/src/sections/lottery/rule-editor.tsx

@@ -0,0 +1,453 @@
+import { zodResolver } from "@hookform/resolvers/zod";
+import {
+  Alert,
+  AlertDescription,
+  AlertTitle,
+} from "@workspace/ui/components/alert";
+import { Button } from "@workspace/ui/components/button";
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from "@workspace/ui/components/form";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@workspace/ui/components/select";
+import {
+  Tabs,
+  TabsContent,
+  TabsList,
+  TabsTrigger,
+} from "@workspace/ui/components/tabs";
+import { Textarea } from "@workspace/ui/components/textarea";
+import { EnhancedInput } from "@workspace/ui/composed/enhanced-input";
+import { updateLotteryActivityRules } from "@workspace/ui/services/admin/lottery";
+import { PlusIcon, Trash2Icon, TriangleAlertIcon } from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+import { useFieldArray, useForm } from "react-hook-form";
+import { useTranslation } from "react-i18next";
+import { toast } from "sonner";
+import {
+  buildCapsErrorMessage,
+  buildEligibility,
+  CHANCE_SOURCE_OPTIONS,
+  CONDITION_PARAM_FIELDS,
+  CONDITION_TYPES,
+  getRuleEditorSchema,
+  isEmptyEligibility,
+  type RuleEditorValues,
+  resolveEligibility,
+  toRuleEditorValues,
+  treeToSimple,
+  validateJsonTree,
+} from "./rule-editor-utils";
+
+interface RuleEditorProps {
+  activity: API.LotteryActivity;
+  onSaved?: () => void;
+}
+
+export default function RuleEditor({ activity, onSaved }: RuleEditorProps) {
+  const { t } = useTranslation("lottery");
+  const [loading, setLoading] = useState(false);
+  const [capsError, setCapsError] = useState<string | null>(null);
+  const form = useForm<RuleEditorValues>({
+    resolver: zodResolver(getRuleEditorSchema(t)),
+    defaultValues: toRuleEditorValues(activity),
+  });
+  const sourceRows = useFieldArray({
+    control: form.control,
+    name: "chanceSources",
+  });
+  const conditionRows = useFieldArray({
+    control: form.control,
+    name: "conditions",
+  });
+  const mode = form.watch("mode");
+  const advancedJson = form.watch("advancedJson");
+
+  useEffect(() => {
+    form.reset(toRuleEditorValues(activity));
+    setCapsError(null);
+  }, [form, activity]);
+
+  const jsonError = useMemo(
+    () => (advancedJson.trim() ? validateJsonTree(advancedJson, t) : null),
+    [advancedJson, t]
+  );
+
+  async function handleSubmit(values: RuleEditorValues) {
+    const eligibility = resolveEligibility(values);
+    const capsMessage = buildCapsErrorMessage(t, eligibility);
+    setCapsError(capsMessage);
+    if (capsMessage) return;
+    setLoading(true);
+    try {
+      await updateLotteryActivityRules({
+        id: activity.id,
+        eligibility,
+        chance_sources: values.chanceSources.map((row) => ({
+          source: row.source,
+          amount: row.amount,
+          daily_limit: row.daily_limit || undefined,
+        })),
+      });
+      toast.success(t("rules.saveSuccess", "Rules saved"));
+      onSaved?.();
+    } catch (_error) {
+      toast.error(t("rules.saveFailed", "Failed to save rules"));
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  function handleModeChange(value: string) {
+    if (value === "advanced" && !form.getValues("advancedJson").trim()) {
+      const tree = buildEligibility(
+        form.getValues("op"),
+        form.getValues("conditions")
+      );
+      form.setValue(
+        "advancedJson",
+        isEmptyEligibility(tree) ? "" : JSON.stringify(tree, null, 2)
+      );
+    }
+    if (value === "simple") {
+      const text = form.getValues("advancedJson").trim();
+      let simple: ReturnType<typeof treeToSimple> = { op: "AND", rows: [] };
+      if (text) {
+        try {
+          simple = treeToSimple(
+            JSON.parse(text) as API.LotteryActivity["eligibility"]
+          );
+        } catch {
+          simple = null;
+        }
+      }
+      if (!simple) {
+        toast.error(
+          t(
+            "rules.cannotSimplify",
+            "This rule tree is too complex for simple mode. Please edit it in Advanced mode."
+          )
+        );
+        return;
+      }
+      form.setValue("op", simple.op);
+      form.setValue("conditions", simple.rows);
+      form.setValue("advancedJson", "");
+    }
+    form.setValue("mode", value as RuleEditorValues["mode"]);
+  }
+
+  return (
+    <Form {...form}>
+      <form className="space-y-6" onSubmit={form.handleSubmit(handleSubmit)}>
+        <section className="space-y-3">
+          <h3 className="font-medium text-base">
+            {t("rules.chanceSources", "Chance Sources")}
+          </h3>
+          <p className="text-muted-foreground text-sm">
+            {t(
+              "rules.chanceSourcesDescription",
+              "Configure how users earn draw chances. Each source can only appear once."
+            )}
+          </p>
+          {sourceRows.fields.map((row, index) => (
+            <div className="flex items-start gap-2" key={row.id}>
+              <FormField
+                control={form.control}
+                name={`chanceSources.${index}.source`}
+                render={({ field }) => (
+                  <FormItem className="flex-1">
+                    <Select onValueChange={field.onChange} value={field.value}>
+                      <FormControl>
+                        <SelectTrigger>
+                          <SelectValue
+                            placeholder={t(
+                              "rules.selectSource",
+                              "Select source"
+                            )}
+                          />
+                        </SelectTrigger>
+                      </FormControl>
+                      <SelectContent>
+                        {CHANCE_SOURCE_OPTIONS.map((option) => (
+                          <SelectItem key={option.value} value={option.value}>
+                            {t(option.labelKey, option.labelDefault)}
+                          </SelectItem>
+                        ))}
+                      </SelectContent>
+                    </Select>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              <FormField
+                control={form.control}
+                name={`chanceSources.${index}.amount`}
+                render={({ field }) => (
+                  <FormItem className="w-32">
+                    <FormControl>
+                      <EnhancedInput
+                        min={0}
+                        onValueChange={(value) => field.onChange(value)}
+                        placeholder={t("rules.amount", "Amount")}
+                        type="number"
+                        value={field.value}
+                      />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              <FormField
+                control={form.control}
+                name={`chanceSources.${index}.daily_limit`}
+                render={({ field }) => (
+                  <FormItem className="w-44">
+                    <FormControl>
+                      <EnhancedInput
+                        min={0}
+                        onValueChange={(value) => field.onChange(value)}
+                        placeholder={t(
+                          "rules.dailyLimit",
+                          "Daily limit (optional)"
+                        )}
+                        type="number"
+                        value={field.value}
+                      />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              <Button
+                onClick={() => sourceRows.remove(index)}
+                size="icon"
+                type="button"
+                variant="ghost"
+              >
+                <Trash2Icon className="size-4" />
+              </Button>
+            </div>
+          ))}
+          <Button
+            onClick={() =>
+              sourceRows.append({ source: "daily_signin", amount: 1 })
+            }
+            size="sm"
+            type="button"
+            variant="outline"
+          >
+            <PlusIcon className="size-4" />
+            {t("rules.addSource", "Add Source")}
+          </Button>
+        </section>
+
+        <section className="space-y-3">
+          <h3 className="font-medium text-base">
+            {t("rules.eligibility", "Eligibility")}
+          </h3>
+          <Alert className="border-yellow-500/50 bg-yellow-50 text-yellow-800 dark:bg-yellow-900/20 dark:text-yellow-400">
+            <TriangleAlertIcon />
+            <AlertTitle>
+              {t("rules.stage1Warning", "Stage 1 notice")}
+            </AlertTitle>
+            <AlertDescription className="text-inherit">
+              {t(
+                "rules.stage1WarningDescription",
+                "The rule context is not wired up in the current version (Stage 1). Configuring eligibility will prevent users from joining the lottery. It is recommended to keep it empty."
+              )}
+            </AlertDescription>
+          </Alert>
+          <Tabs onValueChange={handleModeChange} value={mode}>
+            <TabsList>
+              <TabsTrigger value="simple">
+                {t("rules.simpleMode", "Simple")}
+              </TabsTrigger>
+              <TabsTrigger value="advanced">
+                {t("rules.advancedMode", "Advanced (JSON)")}
+              </TabsTrigger>
+            </TabsList>
+            <TabsContent className="space-y-3 pt-2" value="simple">
+              <FormField
+                control={form.control}
+                name="op"
+                render={({ field }) => (
+                  <FormItem className="w-48">
+                    <FormLabel>
+                      {t("rules.op", "Combine Conditions With")}
+                    </FormLabel>
+                    <Select onValueChange={field.onChange} value={field.value}>
+                      <FormControl>
+                        <SelectTrigger>
+                          <SelectValue />
+                        </SelectTrigger>
+                      </FormControl>
+                      <SelectContent>
+                        <SelectItem value="AND">
+                          {t("rules.opAnd", "AND")}
+                        </SelectItem>
+                        <SelectItem value="OR">
+                          {t("rules.opOr", "OR")}
+                        </SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </FormItem>
+                )}
+              />
+              {conditionRows.fields.length === 0 && (
+                <p className="text-muted-foreground text-sm">
+                  {t(
+                    "rules.noConditions",
+                    "No conditions. Everyone is eligible to join."
+                  )}
+                </p>
+              )}
+              {conditionRows.fields.map((row, index) => {
+                const type = form.watch(`conditions.${index}.type`);
+                return (
+                  <div
+                    className="flex flex-wrap items-start gap-2 rounded-md border p-3"
+                    key={row.id}
+                  >
+                    <FormField
+                      control={form.control}
+                      name={`conditions.${index}.type`}
+                      render={({ field }) => (
+                        <FormItem className="w-56">
+                          <Select
+                            onValueChange={field.onChange}
+                            value={field.value}
+                          >
+                            <FormControl>
+                              <SelectTrigger>
+                                <SelectValue />
+                              </SelectTrigger>
+                            </FormControl>
+                            <SelectContent>
+                              {CONDITION_TYPES.map((item) => (
+                                <SelectItem key={item} value={item}>
+                                  {t(`rules.conditionType.${item}`, item)}
+                                </SelectItem>
+                              ))}
+                            </SelectContent>
+                          </Select>
+                          <FormMessage />
+                        </FormItem>
+                      )}
+                    />
+                    {CONDITION_PARAM_FIELDS[type].map((param) => (
+                      <FormField
+                        control={form.control}
+                        key={param.key}
+                        name={`conditions.${index}.${param.key}`}
+                        render={({ field }) => (
+                          <FormItem className="w-52">
+                            <FormControl>
+                              <EnhancedInput
+                                min={
+                                  param.inputType === "number" ? 0 : undefined
+                                }
+                                onValueChange={(value) => field.onChange(value)}
+                                placeholder={
+                                  param.placeholderKey &&
+                                  param.placeholderDefault
+                                    ? t(
+                                        param.placeholderKey,
+                                        param.placeholderDefault
+                                      )
+                                    : t(param.labelKey, param.labelDefault)
+                                }
+                                type={param.inputType}
+                                value={field.value}
+                              />
+                            </FormControl>
+                            <FormMessage />
+                          </FormItem>
+                        )}
+                      />
+                    ))}
+                    <Button
+                      onClick={() => conditionRows.remove(index)}
+                      size="icon"
+                      type="button"
+                      variant="ghost"
+                    >
+                      <Trash2Icon className="size-4" />
+                    </Button>
+                  </div>
+                );
+              })}
+              <Button
+                onClick={() =>
+                  conditionRows.append({ type: "has_subscription" })
+                }
+                size="sm"
+                type="button"
+                variant="outline"
+              >
+                <PlusIcon className="size-4" />
+                {t("rules.addCondition", "Add Condition")}
+              </Button>
+            </TabsContent>
+            <TabsContent className="space-y-2 pt-2" value="advanced">
+              <FormField
+                control={form.control}
+                name="advancedJson"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormControl>
+                      <Textarea
+                        className="min-h-56 font-mono text-sm"
+                        onChange={field.onChange}
+                        placeholder={t(
+                          "rules.jsonPlaceholder",
+                          'Rule tree JSON, e.g. {"op":"AND","children":[...]}. Leave empty for no requirement.'
+                        )}
+                        value={field.value}
+                      />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              {jsonError && (
+                <p className="text-destructive text-sm">
+                  {t("rules.jsonInvalid", "Invalid JSON: {{error}}").replace(
+                    "{{error}}",
+                    jsonError
+                  )}
+                </p>
+              )}
+            </TabsContent>
+          </Tabs>
+        </section>
+
+        {capsError && (
+          <Alert variant="destructive">
+            <TriangleAlertIcon />
+            <AlertTitle>
+              {t("rules.capsExceeded", "Rule tree exceeds limits")}
+            </AlertTitle>
+            <AlertDescription>{capsError}</AlertDescription>
+          </Alert>
+        )}
+
+        <div className="flex justify-end">
+          <Button disabled={loading} type="submit">
+            {t("rules.save", "Save Rules")}
+          </Button>
+        </div>
+      </form>
+    </Form>
+  );
+}

packages/ui/src/services/admin/lottery.ts

@@ -0,0 +1,410 @@
+/* eslint-disable */
+import request from "@workspace/ui/lib/request";
+
+/**
+ * 创建抽奖活动
+ * POST /v1/admin/lottery/activities
+ * @param body - 创建抽奖活动请求参数
+ * @param options - 可选的请求配置
+ * @returns 创建结果
+ */
+export async function createLotteryActivity(
+  body: API.CreateLotteryActivityRequest,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: API.LotteryActivity }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/activities`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      data: body,
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 更新抽奖活动
+ * PUT /v1/admin/lottery/activities
+ * @param body - 更新抽奖活动请求参数
+ * @param options - 可选的请求配置
+ * @returns 更新结果
+ */
+export async function updateLotteryActivity(
+  body: API.UpdateLotteryActivityRequest,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: API.LotteryActivity }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/activities`,
+    {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      data: body,
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 获取抽奖活动分页列表
+ * GET /v1/admin/lottery/activities
+ * @param params - 分页及筛选参数
+ * @param options - 可选的请求配置
+ * @returns 抽奖活动列表及总数
+ */
+export async function getLotteryActivityList(
+  params: API.GetLotteryActivityListParams,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: API.GetLotteryActivityListResponse }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/activities`,
+    {
+      method: "GET",
+      params: {
+        ...params,
+      },
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 获取抽奖活动详情
+ * GET /v1/admin/lottery/activities/detail
+ * @param params - 活动 ID 参数
+ * @param options - 可选的请求配置
+ * @returns 抽奖活动详情
+ */
+export async function getLotteryActivityDetail(
+  params: API.GetLotteryActivityDetailParams,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: API.LotteryActivity }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/activities/detail`,
+    {
+      method: "GET",
+      params: {
+        ...params,
+      },
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 上架抽奖活动（draft → running）
+ * POST /v1/admin/lottery/activities/publish
+ * @param body - 上架活动请求参数
+ * @param options - 可选的请求配置
+ * @returns 上架结果
+ */
+export async function publishLotteryActivity(
+  body: API.PublishLotteryActivityRequest,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: any }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/activities/publish`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      data: body,
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 暂停抽奖活动
+ * POST /v1/admin/lottery/activities/pause
+ * @param body - 暂停活动请求参数
+ * @param options - 可选的请求配置
+ * @returns 暂停结果
+ */
+export async function pauseLotteryActivity(
+  body: API.PauseLotteryActivityRequest,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: any }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/activities/pause`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      data: body,
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 更新抽奖活动规则（eligibility + chance_sources）
+ * PUT /v1/admin/lottery/activities/rules
+ * @param body - 更新活动规则请求参数
+ * @param options - 可选的请求配置
+ * @returns 更新结果
+ */
+export async function updateLotteryActivityRules(
+  body: API.UpdateLotteryActivityRulesRequest,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: any }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/activities/rules`,
+    {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      data: body,
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 创建抽奖奖品
+ * POST /v1/admin/lottery/prizes
+ * @param body - 创建奖品请求参数
+ * @param options - 可选的请求配置
+ * @returns 创建结果
+ */
+export async function createLotteryPrize(
+  body: API.CreateLotteryPrizeRequest,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: API.LotteryPrize }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/prizes`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      data: body,
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 更新抽奖奖品
+ * PUT /v1/admin/lottery/prizes
+ * @param body - 更新奖品请求参数
+ * @param options - 可选的请求配置
+ * @returns 更新结果
+ */
+export async function updateLotteryPrize(
+  body: API.UpdateLotteryPrizeRequest,
+  options?: { [key: string]: any }
+) {
+  const { id, ...rest } = body;
+  return request<API.Response & { data?: API.LotteryPrize }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/prizes/${id}`,
+    {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      data: rest,
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 删除抽奖奖品
+ * DELETE /v1/admin/lottery/prizes
+ * @param body - 删除奖品请求参数
+ * @param options - 可选的请求配置
+ * @returns 删除结果
+ */
+export async function deleteLotteryPrize(
+  body: API.DeleteLotteryPrizeRequest,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: any }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/prizes/${body.id}`,
+    {
+      method: "DELETE",
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 获取抽奖奖品列表
+ * GET /v1/admin/lottery/prizes
+ * @param params - 活动 ID 筛选参数
+ * @param options - 可选的请求配置
+ * @returns 奖品列表
+ */
+export async function getLotteryPrizeList(
+  params: API.GetLotteryPrizeListParams,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: API.GetLotteryPrizeListResponse }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/prizes`,
+    {
+      method: "GET",
+      params: {
+        ...params,
+      },
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 手动发放抽奖次数
+ * POST /v1/admin/lottery/chances/grant
+ * @param body - 发放次数请求参数（source_ref 为幂等键）
+ * @param options - 可选的请求配置
+ * @returns 发放结果
+ */
+export async function grantLotteryChances(
+  body: API.GrantLotteryChancesRequest,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: any }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/chances/grant`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      data: body,
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 领奖工单列表（Stage 2 人工奖）
+ * GET /v1/admin/lottery/claims
+ */
+export async function getLotteryClaimList(
+  params: API.GetLotteryClaimListParams,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: API.ListLotteryClaimsResponse }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/claims`,
+    {
+      method: "GET",
+      params: { ...params },
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 领奖工单统计（各类型 reviewing/paying + 逾期）
+ * GET /v1/admin/lottery/claims/summary
+ */
+export async function getLotteryClaimsSummary(options?: {
+  [key: string]: any;
+}) {
+  return request<API.Response & { data?: API.LotteryClaimsSummary }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/claims/summary`,
+    {
+      method: "GET",
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 审核通过领奖工单（reviewing → paying）
+ * POST /v1/admin/lottery/claims/approve
+ */
+export async function approveLotteryClaim(
+  body: API.ApproveLotteryClaimRequest,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: any }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/claims/approve`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: body,
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 驳回领奖工单（reviewing/paying → rejected，reason 必填）
+ * POST /v1/admin/lottery/claims/reject
+ */
+export async function rejectLotteryClaim(
+  body: API.RejectLotteryClaimRequest,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: any }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/claims/reject`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: body,
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 标记已发放（paying → paid），填 tx_hash / delivery_ref
+ * POST /v1/admin/lottery/claims/mark-paid
+ */
+export async function markPaidLotteryClaim(
+  body: API.MarkPaidLotteryClaimRequest,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: any }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/claims/mark-paid`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: body,
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 抽奖记录（发放流水）
+ * GET /v1/admin/lottery/draws
+ */
+export async function getLotteryDrawList(
+  params: API.GetLotteryDrawListParams,
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: API.ListLotteryDrawsResponse }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/draws`,
+    {
+      method: "GET",
+      params: { ...params },
+      ...(options || {}),
+    }
+  );
+}
+
+/**
+ * 删除抽奖活动（软删；运行中需先暂停）
+ * DELETE /v1/admin/lottery/activities/:id
+ */
+export async function deleteLotteryActivity(
+  body: { id: number },
+  options?: { [key: string]: any }
+) {
+  return request<API.Response & { data?: any }>(
+    `${import.meta.env.VITE_API_PREFIX || ""}/v1/admin/lottery/activities/${body.id}`,
+    {
+      method: "DELETE",
+      ...(options || {}),
+    }
+  );
+}

packages/ui/src/services/admin/typings.d.ts

@@ -3293,4 +3293,253 @@ declare namespace API {
   };
 
   type AdminWithdrawalLog = WithdrawalLog;
+
+  type LotteryPrizeType =
+    | "vpn_duration"
+    | "commission"
+    | "none"
+    | "crypto"
+    | "physical"
+    | "manual_other"
+    | "coupon"
+    | "points";
+
+  type LotteryActivityStatus = "draft" | "running" | "paused" | "ended";
+
+  type LotteryChanceSourceType =
+    | "daily_signin"
+    | "new_subscription"
+    | "invite_success"
+    | "manual_grant";
+
+  type LotteryEligibilityNode = {
+    op?: "AND" | "OR";
+    children?: LotteryEligibilityNode[];
+    type?: string;
+    params?: Record<string, any>;
+  };
+
+  type LotteryChanceSource = {
+    source: LotteryChanceSourceType;
+    amount: number;
+    daily_limit?: number;
+  };
+
+  type LotteryPrize = {
+    id: number;
+    activity_id: number;
+    slot: number;
+    type: LotteryPrizeType;
+    name: string;
+    icon_url: string;
+    config: Record<string, any>;
+    weight: number;
+    total_stock: number | null;
+    is_fallback: boolean;
+    sold_out?: boolean;
+  };
+
+  type LotteryActivity = {
+    id: number;
+    title: string;
+    description: string;
+    start_at: number; // Unix 秒
+    end_at: number; // Unix 秒
+    status: LotteryActivityStatus;
+    grid_size: number;
+    eligibility?: LotteryEligibilityNode | Record<string, never> | null;
+    chance_sources?: LotteryChanceSource[];
+    unmet_action?: string;
+    prizes?: LotteryPrize[];
+  };
+
+  type CreateLotteryActivityRequest = {
+    title: string;
+    description: string;
+    start_at: number;
+    end_at: number;
+    grid_size: number;
+    eligibility: LotteryEligibilityNode | Record<string, never> | null;
+    chance_sources: LotteryChanceSource[];
+    unmet_action: string;
+  };
+
+  type UpdateLotteryActivityRequest = CreateLotteryActivityRequest & {
+    id: number;
+  };
+
+  type GetLotteryActivityListParams = {
+    page: number;
+    size: number;
+    status?: string;
+  };
+
+  type GetLotteryActivityListResponse = {
+    total: number;
+    list: LotteryActivity[];
+  };
+
+  type GetLotteryActivityDetailParams = { id: number };
+
+  type PublishLotteryActivityRequest = { id: number };
+
+  type PauseLotteryActivityRequest = { id: number };
+
+  type UpdateLotteryActivityRulesRequest = {
+    id: number;
+    eligibility: LotteryEligibilityNode | Record<string, never> | null;
+    chance_sources: LotteryChanceSource[];
+  };
+
+  type CreateLotteryPrizeRequest = {
+    activity_id: number;
+    slot: number;
+    type: LotteryPrizeType;
+    name: string;
+    icon_url: string;
+    config: Record<string, any>;
+    weight: number;
+    total_stock: number | null;
+    is_fallback: boolean;
+  };
+
+  type UpdateLotteryPrizeRequest = CreateLotteryPrizeRequest & { id: number };
+
+  type DeleteLotteryPrizeRequest = { id: number };
+
+  type GetLotteryPrizeListParams = { activity_id: number };
+
+  type GetLotteryPrizeListResponse = { total?: number; list: LotteryPrize[] };
+
+  type GrantLotteryChancesRequest = {
+    activity_id: number;
+    user_id: number;
+    amount: number;
+    source_ref: string;
+  };
+
+  // ---- Stage 2 领奖工单（人工奖）--------------------------------------------
+
+  type LotteryClaimStatus =
+    | "pending_claim"
+    | "reviewing"
+    | "paying"
+    | "paid"
+    | "rejected"
+    | "expired";
+
+  type GetLotteryClaimListParams = {
+    type?: LotteryPrizeType;
+    status?: LotteryClaimStatus;
+    activity_id?: number;
+    user_id?: number;
+    from?: number;
+    to?: number;
+    page: number;
+    size: number;
+  };
+
+  type AdminLotteryClaimUser = {
+    id: number;
+    email?: string;
+  };
+
+  type AdminLotteryClaimPrize = {
+    type: LotteryPrizeType;
+    name: string;
+    config: Record<string, any>;
+  };
+
+  type AdminLotteryClaim = {
+    id: number;
+    draw_id: number;
+    activity_id: number;
+    user: AdminLotteryClaimUser;
+    prize: AdminLotteryClaimPrize;
+    status: LotteryClaimStatus;
+    claim_data?: Record<string, any>;
+    submitted_at?: number;
+    expires_at: number;
+    reviewed_by?: number;
+    reviewed_at?: number;
+    reject_reason?: string;
+    tx_hash?: string;
+    delivery_ref?: string;
+    paid_at?: number;
+    created_at: number;
+  };
+
+  type ListLotteryClaimsResponse = {
+    total: number;
+    claims: AdminLotteryClaim[];
+  };
+
+  type LotteryClaimsStatusCount = {
+    reviewing: number;
+    paying: number;
+  };
+
+  type LotteryClaimsSummary = {
+    crypto: LotteryClaimsStatusCount;
+    physical: LotteryClaimsStatusCount;
+    manual_other: LotteryClaimsStatusCount;
+    overdue: number;
+  };
+
+  type ApproveLotteryClaimRequest = { id: number };
+
+  type RejectLotteryClaimRequest = { id: number; reason: string };
+
+  type MarkPaidLotteryClaimRequest = {
+    id: number;
+    tx_hash?: string;
+    delivery_ref?: string;
+    paid_at?: number;
+  };
+
+  // ---- Stage 3 抽奖记录（发放流水）-----------------------------------------
+
+  type GetLotteryDrawListParams = {
+    activity_id?: number;
+    user_id?: number;
+    prize_type?: LotteryPrizeType;
+    dispatch_state?: string;
+    win?: "1" | "0";
+    from?: number;
+    to?: number;
+    page: number;
+    size: number;
+  };
+
+  type AdminLotteryDrawUser = {
+    id: number;
+    email?: string;
+  };
+
+  type AdminLotteryDrawPrize = {
+    slot: number;
+    type: LotteryPrizeType;
+    name: string;
+    config: Record<string, any>;
+  };
+
+  type AdminLotteryDraw = {
+    draw_id: number;
+    activity_id: number;
+    user: AdminLotteryDrawUser;
+    is_win: boolean;
+    prize?: AdminLotteryDrawPrize;
+    dispatch_state: string;
+    dispatch_error?: string;
+    grant_amount?: number;
+    grant_message?: string;
+    drawn_at: number;
+    dispatched_at?: number;
+    created_at: number;
+  };
+
+  type ListLotteryDrawsResponse = {
+    total: number;
+    list: AdminLotteryDraw[];
+  };
 }