@wowok/agent-mcp 2.3.14 → 2.3.18

package/dist/knowledge/process-model.js

@@ -0,0 +1,160 @@
+export const PERMISSION_TYPES = [
+    {
+        name: "Permission",
+        scope: "organization",
+        definedOn: "Permission Object (standalone on-chain object, referenced by service/machine/etc.)",
+        controls: "Who can modify the bound object's settings, publish it, manage its funds, etc.",
+        grantedBy: "The object's creator (owner) or anyone the creator delegates to",
+        example: "A shop owner creates a Permission allowing only their staff to modify the Service's price.",
+    },
+    {
+        name: "NamedOperator",
+        scope: "order",
+        definedOn: "Per-order (specified in the order creation/modification by the service)",
+        controls: "Who can operate on a specific order: advance progress, settle, refund, etc.",
+        grantedBy: "The service (via its order_allocators or explicit named operators)",
+        example: "A delivery service assigns Alice as the NamedOperator for order #123 — only Alice can mark it delivered.",
+    },
+    {
+        name: "OrderHolder",
+        scope: "order_holder",
+        definedOn: "Per-order (the '' empty string address = the order's current holder)",
+        controls: "Who currently holds the order and can perform holder-specific actions (accept, reject, pay)",
+        grantedBy: "Implicitly assigned when an order is created or transferred",
+        example: "Bob places an order — he becomes the OrderHolder. He can accept delivery or request arbitration.",
+    },
+];
+export const GAME_ELEMENTS = [
+    {
+        id: 1, type: "player", name: "商户 vs 客户",
+        description: "博弈的基本参与方：提供服务的商户和购买服务的客户。",
+        wowokApplication: "Service 创建者（商户）和 Order 创建者（客户）。",
+        onChainMechanism: "Service + Order 对象，各自有独立的 on-chain address。",
+    },
+    {
+        id: 2, type: "player", name: "仲裁员",
+        description: "第三方仲裁员参与争议解决博弈。",
+        wowokApplication: "Arb 对象的 NamedOperator，由 Service 指定。",
+        onChainMechanism: "Arbitration 对象 + NamedOperator 权限。",
+    },
+    {
+        id: 3, type: "strategy", name: "合作 vs 欺骗",
+        description: "商户可以选择诚实履约（合作）或欺诈（欺骗）。客户可以选择信任或拒绝。",
+        wowokApplication: "商户发货 vs 不发货；客户付款 vs 拒付。",
+        onChainMechanism: "Progress 节点推进 + 链上状态不可篡改。",
+    },
+    {
+        id: 4, type: "payoff", name: "履约收益 vs 欺诈收益",
+        description: "诚实履约获得持续收入 + 声誉；欺诈获得一次性收益但损失声誉和补偿金。",
+        wowokApplication: "compensation_fund 作为欺诈的经济惩罚；repeat business 作为合作的长期收益。",
+        onChainMechanism: "Service.compensation_fund + Treasury 锁定资金。",
+    },
+    {
+        id: 5, type: "utility", name: "声誉效用",
+        description: "商户的总效用 = 即期收益 + 声誉折现的未来收益 - 惩罚预期。",
+        wowokApplication: "声誉分高的商户获得更多订单（Demand 匹配优先）。",
+        onChainMechanism: "ReviewRepository (链上公开评价) + Demand 匹配引擎。",
+    },
+    {
+        id: 6, type: "equilibrium", name: "纳什均衡：双方合作",
+        description: "当惩罚足够大、声誉足够重要时，双方合作的策略组合成为纳什均衡。",
+        wowokApplication: "compensation_fund 足够大 + 链上声誉不可篡改 → 合作成为最优策略。",
+        onChainMechanism: "Guard 验证 compensation_fund 金额 + ReviewRepository 公开。",
+    },
+    {
+        id: 7, type: "information", name: "不完全信息",
+        description: "客户不完全了解商户的服务质量；商户不完全了解客户的支付能力。",
+        wowokApplication: "Service.description + Guard 验证作为信号；客户钱包余额链上可查。",
+        onChainMechanism: "Guard + Personal 对象 + 链上交易历史。",
+    },
+    {
+        id: 8, type: "sequence", name: "序贯博弈",
+        description: "客户先下单付款，商户后履约 — 这是典型的序贯博弈。",
+        wowokApplication: "Order 创建 → Progress 推进 → Acceptance/Arbitration。",
+        onChainMechanism: "Machine 节点序列 + Progress 状态机。",
+    },
+    {
+        id: 9, type: "repetition", name: "重复博弈",
+        description: "商户和客户可能多次交易，重复博弈使得合作策略更优。",
+        wowokApplication: "客户的复购 + Demand 匹配优先推荐高声誉商户。",
+        onChainMechanism: "ReviewRepository 累积评价 + Demand 匹配引擎。",
+    },
+    {
+        id: 10, type: "commitment", name: "补偿金承诺",
+        description: "商户通过锁定 compensation_fund 做出可信承诺，降低客户的风险感知。",
+        wowokApplication: "Service.compensation_fund 锁定资金，欺诈时客户可索赔。",
+        onChainMechanism: "Treasury 对象 + Guard 验证金额 + 提取规则。",
+    },
+    {
+        id: 11, type: "punishment", name: "补偿金惩罚",
+        description: "商户欺诈时，补偿金被划给客户，构成经济惩罚。",
+        wowokApplication: "Arbitration 判决 → compensation_fund 提取 → 客户获得赔偿。",
+        onChainMechanism: "Arbitration verdict + Treasury 提取规则。",
+    },
+    {
+        id: 12, type: "reward", name: "Reward 营销激励",
+        description: "商户通过 Reward 对象发放奖励，激励客户行为（首单、裂变、忠诚度）。",
+        wowokApplication: "Reward 对象 + Guard 验证领取条件（如：完成首单）。",
+        onChainMechanism: "Reward 对象 + Guard claim 条件 + Allocation 分发。",
+    },
+    {
+        id: 13, type: "reputation", name: "链上公开声誉",
+        description: "所有交易和评价记录在链上，形成不可篡改的声誉系统。",
+        wowokApplication: "ReviewRepository 存储 like/dislike/评价标签，链上可检测。",
+        onChainMechanism: "Repository 对象 + Guard 防刷 + 地址为 key 的评价记录。",
+    },
+    {
+        id: 14, type: "signaling", name: "质量信号",
+        description: "商户通过 Guard 验证、compensation_fund 金额、Machine 透明度发送质量信号。",
+        wowokApplication: "buy_guard 验证 → 信号；compensation_fund 金额 → 信号；Machine 公开 → 信号。",
+        onChainMechanism: "Guard + Treasury + Machine 对象的链上公开数据。",
+    },
+    {
+        id: 15, type: "screening", name: "客户筛选",
+        description: "商户通过 Guard 筛选客户（如：验证身份、信用分、钱包余额）。",
+        wowokApplication: "Service.buy_guard 验证客户资格。",
+        onChainMechanism: "Guard 对象 + gen_passport 验证凭证。",
+    },
+    {
+        id: 16, type: "bargaining", name: "价格议价",
+        description: "客户和商户可以通过 Messenger 议价，最终价格通过 Demand 提交。",
+        wowokApplication: "Messenger 加密通信 → Demand 提交带 reward 的需求。",
+        onChainMechanism: "Contact + Messenger + Demand 对象。",
+    },
+    {
+        id: 17, type: "auction", name: "Demand 竞标",
+        description: "多个服务商可以竞争同一个 Demand，形成竞标机制。",
+        wowokApplication: "Demand 发布需求 → 多个 Service 提交方案 → 客户选择。",
+        onChainMechanism: "Demand 对象 + order 创建 + Progress 推进。",
+    },
+    {
+        id: 18, type: "mechanism", name: "机制设计",
+        description: "WoWok 的整体架构就是机制设计：通过链上规则激励合作、惩罚欺诈。",
+        wowokApplication: "compensation_fund + Arbitration + ReviewRepository 组合形成信任机制。",
+        onChainMechanism: "Move 合约层面的对象组合 + Guard 验证 + 不可篡改性。",
+    },
+    {
+        id: 19, type: "constraint", name: "资金约束",
+        description: "compensation_fund 和 Reward 资金锁定构成经济约束，限制商户的欺诈动机。",
+        wowokApplication: "资金锁定 > 欺诈收益 → 合作是理性选择。",
+        onChainMechanism: "Treasury + Allocation 资金锁定。",
+    },
+    {
+        id: 20, type: "cooperation", name: "供应链协作",
+        description: "多个商户通过 Machine 组合形成供应链，合作完成复杂订单（子订单）。",
+        wowokApplication: "Service 的 order_allocators 支持多供应商分配；Machine 节点间 forward 组合。",
+        onChainMechanism: "Allocation + Machine Forward + Progress 跨对象组合。",
+    },
+];
+const PERMISSION_INDEX = new Map(PERMISSION_TYPES.map((p) => [p.name, p]));
+const GAME_ELEMENT_INDEX = new Map(GAME_ELEMENTS.map((g) => [g.id, g]));
+export function getPermissionType(name) {
+    return PERMISSION_INDEX.get(name);
+}
+export function getGameElement(id) {
+    return GAME_ELEMENT_INDEX.get(id);
+}
+export function getGameElementsByType(type) {
+    return GAME_ELEMENTS.filter((g) => g.type === type);
+}
+export const PROCESS_MODEL_VERSION = 1;

package/dist/knowledge/reputation-rules.d.ts

@@ -0,0 +1,42 @@
+export interface Review {
+    reviewer: string;
+    rating: "like" | "dislike";
+    tags?: string[];
+    comment?: string;
+    orderRef?: string;
+    timestamp?: number;
+    verified: boolean;
+}
+export interface ReviewStats {
+    total: number;
+    likes: number;
+    dislikes: number;
+    likeRate: number;
+    verifiedCount: number;
+    topTags: Array<{
+        tag: string;
+        count: number;
+    }>;
+    recentTrend: "improving" | "declining" | "stable";
+}
+export interface ReviewRepositorySetup {
+    repositoryName: string;
+    guardName: string;
+    guardRules: string;
+    setupSteps: string[];
+}
+export declare const REPUTATION_RULES_VERSION = 1;
+export declare function buildReviewRepositorySetup(serviceName: string): ReviewRepositorySetup;
+export declare function computeReviewStats(reviews: Review[]): ReviewStats;
+export declare function isVerifiedReview(review: Review, orderHistory: Array<{
+    id: string;
+    status: string;
+}>): boolean;
+export declare function filterVerifiedReviews(reviews: Review[], orderHistory: Array<{
+    id: string;
+    status: string;
+}>): Review[];
+export declare function detectReviewManipulation(reviews: Review[]): {
+    suspicious: boolean;
+    reasons: string[];
+};

package/dist/knowledge/reputation-rules.js

@@ -0,0 +1,99 @@
+export const REPUTATION_RULES_VERSION = 1;
+export function buildReviewRepositorySetup(serviceName) {
+    return {
+        repositoryName: `${serviceName}_reviews`,
+        guardName: `${serviceName}_review_guard`,
+        guardRules: "验证提交者有该 Service 的已完成订单（query order history == 已完成）—— 防刷评",
+        setupSteps: [
+            `1. 创建 Guard: name='${serviceName}_review_guard', 规则验证购买者身份`,
+            `2. 创建 Repository: name='${serviceName}_reviews', attach Guard`,
+            `3. 将 Repository 关联到 Service: onchain_operations service modify`,
+            `4. 用户提交评价时: onchain_operations repository write（Guard 自动验证）`,
+            `5. 查询评价: onchain_table_data repository query`,
+        ],
+    };
+}
+export function computeReviewStats(reviews) {
+    if (reviews.length === 0) {
+        return {
+            total: 0,
+            likes: 0,
+            dislikes: 0,
+            likeRate: 0,
+            verifiedCount: 0,
+            topTags: [],
+            recentTrend: "stable",
+        };
+    }
+    const likes = reviews.filter((r) => r.rating === "like").length;
+    const dislikes = reviews.filter((r) => r.rating === "dislike").length;
+    const verifiedCount = reviews.filter((r) => r.verified).length;
+    const tagCounts = new Map();
+    for (const r of reviews) {
+        if (r.tags) {
+            for (const t of r.tags) {
+                tagCounts.set(t, (tagCounts.get(t) ?? 0) + 1);
+            }
+        }
+    }
+    const topTags = Array.from(tagCounts.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([tag, count]) => ({ tag, count }));
+    const sorted = [...reviews].sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
+    const midPoint = Math.floor(sorted.length / 2);
+    const firstHalf = sorted.slice(0, midPoint);
+    const secondHalf = sorted.slice(midPoint);
+    const firstLikeRate = firstHalf.length > 0 ? firstHalf.filter((r) => r.rating === "like").length / firstHalf.length : 0.5;
+    const secondLikeRate = secondHalf.length > 0 ? secondHalf.filter((r) => r.rating === "like").length / secondHalf.length : 0.5;
+    let recentTrend = "stable";
+    if (secondLikeRate > firstLikeRate + 0.15)
+        recentTrend = "improving";
+    else if (secondLikeRate < firstLikeRate - 0.15)
+        recentTrend = "declining";
+    return {
+        total: reviews.length,
+        likes,
+        dislikes,
+        likeRate: likes / reviews.length,
+        verifiedCount,
+        topTags,
+        recentTrend,
+    };
+}
+export function isVerifiedReview(review, orderHistory) {
+    if (!review.orderRef)
+        return false;
+    const order = orderHistory.find((o) => o.id === review.orderRef);
+    return order?.status === "completed" || order?.status === "success";
+}
+export function filterVerifiedReviews(reviews, orderHistory) {
+    return reviews.map((r) => ({
+        ...r,
+        verified: isVerifiedReview(r, orderHistory),
+    }));
+}
+export function detectReviewManipulation(reviews) {
+    const reasons = [];
+    const reviewerCounts = new Map();
+    for (const r of reviews) {
+        reviewerCounts.set(r.reviewer, (reviewerCounts.get(r.reviewer) ?? 0) + 1);
+    }
+    const duplicates = Array.from(reviewerCounts.entries()).filter(([, count]) => count > 1);
+    if (duplicates.length > 0) {
+        reasons.push(`${duplicates.length} 个地址提交了多次评价`);
+    }
+    const allLikes = reviews.every((r) => r.rating === "like");
+    const noneVerified = reviews.every((r) => !r.verified);
+    if (allLikes && reviews.length > 5 && noneVerified) {
+        reasons.push("全部好评但无带凭证评价，可能存在刷评");
+    }
+    if (reviews.length > 10) {
+        const sorted = [...reviews].sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
+        const timeSpan = (sorted[sorted.length - 1].timestamp ?? 0) - (sorted[0].timestamp ?? 0);
+        if (timeSpan > 0 && timeSpan < 3600 * 1000) {
+            reasons.push(`${reviews.length} 条评价在 1 小时内提交，时间异常集中`);
+        }
+    }
+    return { suspicious: reasons.length > 0, reasons };
+}

package/dist/knowledge/reward-templates.d.ts

@@ -0,0 +1,25 @@
+export type RewardTemplateType = "first_order" | "referral" | "loyalty" | "flash_sale" | "bulk_discount" | "milestone" | "cashback";
+export interface RewardTemplate {
+    type: RewardTemplateType;
+    name: string;
+    description: string;
+    guardCondition: string;
+    amountRange: {
+        min: string;
+        max: string;
+    };
+    allocationStrategy: "fixed" | "proportional" | "tiered";
+    parameters: Array<{
+        name: string;
+        type: "string" | "number" | "address";
+        description: string;
+        required: boolean;
+    }>;
+    example: string;
+    relevantGuardOps: string[];
+}
+export declare const REWARD_TEMPLATES: RewardTemplate[];
+export declare function getRewardTemplate(type: string): RewardTemplate | undefined;
+export declare function listRewardTemplates(): RewardTemplate[];
+export declare function suggestRewardTemplate(intent: string): RewardTemplate | undefined;
+export declare const REWARD_TEMPLATES_VERSION = 1;

package/dist/knowledge/reward-templates.js

@@ -0,0 +1,125 @@
+export const REWARD_TEMPLATES = [
+    {
+        type: "first_order",
+        name: "首单奖励",
+        description: "新客户首次下单后获得奖励，降低尝试门槛，促进转化。",
+        guardCondition: "Guard 验证: order_address 的 holder == 当前 claim 者, 且 order.service == 本 Service, 且 order 是该 holder 的第一笔订单 (通过 Repository 查询历史)",
+        amountRange: { min: "0.1WOW", max: "5WOW" },
+        allocationStrategy: "fixed",
+        parameters: [
+            { name: "amount", type: "string", description: "奖励金额 (如 '1WOW')", required: true },
+            { name: "budget", type: "string", description: "总预算 (如 '100WOW')", required: true },
+        ],
+        example: "新客户下单购买摄影服务，首单获得 1 WOW 返还，降低首次尝试成本。",
+        relevantGuardOps: ["query", "repository_read"],
+    },
+    {
+        type: "referral",
+        name: "裂变推荐奖励",
+        description: "老客户推荐新客户下单后，双方各获得奖励，形成口碑传播飞轮。",
+        guardCondition: "Guard 验证: 推荐人地址在 Repository 评价表中标记为 'referred_by', 且被推荐人的订单已完成 (Progress 到达终态)",
+        amountRange: { min: "0.5WOW", max: "10WOW" },
+        allocationStrategy: "proportional",
+        parameters: [
+            { name: "referrer_reward", type: "string", description: "推荐人奖励 (如 '2WOW')", required: true },
+            { name: "referee_reward", type: "string", description: "被推荐人奖励 (如 '1WOW')", required: true },
+            { name: "max_referrals", type: "number", description: "每人最多推荐数 (如 10)", required: false },
+        ],
+        example: "Alice 推荐 Bob 购买服务，Bob 完成首单后 Alice 得 2 WOW、Bob 得 1 WOW。",
+        relevantGuardOps: ["query", "repository_read", "repository_write"],
+    },
+    {
+        type: "loyalty",
+        name: "忠诚度阶梯奖励",
+        description: "客户累计消费达到阶梯后解锁更高奖励，提升复购率和客单价。",
+        guardCondition: "Guard 验证: 通过 Repository 查询该地址历史订单数 >= N, N 为当前阶梯阈值",
+        amountRange: { min: "1WOW", max: "50WOW" },
+        allocationStrategy: "tiered",
+        parameters: [
+            { name: "tier1_orders", type: "number", description: "第一阶梯订单数 (如 3)", required: true },
+            { name: "tier1_reward", type: "string", description: "第一阶梯奖励 (如 '1WOW')", required: true },
+            { name: "tier2_orders", type: "number", description: "第二阶梯订单数 (如 10)", required: true },
+            { name: "tier2_reward", type: "string", description: "第二阶梯奖励 (如 '5WOW')", required: true },
+            { name: "tier3_orders", type: "number", description: "第三阶梯订单数 (如 30)", required: false },
+            { name: "tier3_reward", type: "string", description: "第三阶梯奖励 (如 '20WOW')", required: false },
+        ],
+        example: "客户累计 3 单得 1 WOW，10 单得 5 WOW，30 单得 20 WOW，激励持续消费。",
+        relevantGuardOps: ["query", "repository_read"],
+    },
+    {
+        type: "flash_sale",
+        name: "限时闪购",
+        description: "在限定时间窗口内提供折扣或额外奖励，制造紧迫感促进即时转化。",
+        guardCondition: "Guard 验证: 当前区块时间在 [start_time, end_time] 范围内 (Guard 时间条件)",
+        amountRange: { min: "0.1WOW", max: "20WOW" },
+        allocationStrategy: "fixed",
+        parameters: [
+            { name: "start_time", type: "string", description: "开始时间 (Unix timestamp)", required: true },
+            { name: "end_time", type: "string", description: "结束时间 (Unix timestamp)", required: true },
+            { name: "amount", type: "string", description: "闪购奖励金额", required: true },
+            { name: "max_claims", type: "number", description: "最大领取数 (如 100)", required: true },
+        ],
+        example: "周末限时 48 小时闪购，下单客户额外获得 2 WOW 返还，前 100 名有效。",
+        relevantGuardOps: ["query", "time_condition"],
+    },
+    {
+        type: "cashback",
+        name: "消费返现",
+        description: "客户完成订单后按消费比例返现，提升复购意愿。",
+        guardCondition: "Guard 验证: order 已到达终态 (Progress completed), 且 order.service == 本 Service",
+        amountRange: { min: "0.1WOW", max: "100WOW" },
+        allocationStrategy: "proportional",
+        parameters: [
+            { name: "cashback_rate", type: "string", description: "返现比例 (如 '0.1' = 10%)", required: true },
+            { name: "max_cashback", type: "string", description: "单笔最大返现 (如 '10WOW')", required: true },
+            { name: "budget", type: "string", description: "总预算 (如 '500WOW')", required: true },
+        ],
+        example: "客户消费 10 WOW，按 10% 比例返现 1 WOW，下次消费可抵扣。",
+        relevantGuardOps: ["query"],
+    },
+    {
+        type: "milestone",
+        name: "里程碑奖励",
+        description: "Service 达到特定里程碑（如 100 单、1000 客户）时给早期支持者发放额外奖励。",
+        guardCondition: "Guard 验证: Repository 查询 Service 累计订单数 >= milestone_threshold, 且 claim 者为早期客户 (order_index < milestone)",
+        amountRange: { min: "1WOW", max: "100WOW" },
+        allocationStrategy: "fixed",
+        parameters: [
+            { name: "milestone", type: "number", description: "里程碑值 (如 100)", required: true },
+            { name: "reward_per_user", type: "string", description: "每人奖励 (如 '5WOW')", required: true },
+            { name: "max_recipients", type: "number", description: "最大受益人数 (如 50)", required: true },
+        ],
+        example: "Service 达到 100 单里程碑，前 50 名客户每人获得 5 WOW 额外奖励。",
+        relevantGuardOps: ["query", "repository_read"],
+    },
+];
+const TEMPLATE_INDEX = new Map(REWARD_TEMPLATES.map((t) => [t.type, t]));
+export function getRewardTemplate(type) {
+    return TEMPLATE_INDEX.get(type);
+}
+export function listRewardTemplates() {
+    return REWARD_TEMPLATES;
+}
+export function suggestRewardTemplate(intent) {
+    const lower = intent.toLowerCase();
+    if (lower.includes("首单") || lower.includes("new") || lower.includes("first")) {
+        return getRewardTemplate("first_order");
+    }
+    if (lower.includes("推荐") || lower.includes("裂变") || lower.includes("referral")) {
+        return getRewardTemplate("referral");
+    }
+    if (lower.includes("复购") || lower.includes("忠诚") || lower.includes("loyalty")) {
+        return getRewardTemplate("loyalty");
+    }
+    if (lower.includes("限时") || lower.includes("闪购") || lower.includes("flash")) {
+        return getRewardTemplate("flash_sale");
+    }
+    if (lower.includes("返现") || lower.includes("cashback")) {
+        return getRewardTemplate("cashback");
+    }
+    if (lower.includes("里程碑") || lower.includes("milestone")) {
+        return getRewardTemplate("milestone");
+    }
+    return undefined;
+}
+export const REWARD_TEMPLATES_VERSION = 1;

package/dist/knowledge/safety-rules.d.ts

@@ -0,0 +1,36 @@
+export type ConfirmLevel = "none" | "standard" | "amount" | "publish" | "irreversible";
+export interface OperationPreview {
+    level: ConfirmLevel;
+    operation: string;
+    object?: string;
+    network?: string;
+    account?: string;
+    amount?: {
+        value: string;
+        token: string;
+        human_readable: string;
+        recipient?: string;
+    };
+    immutable_after?: string[];
+    warnings?: string[];
+    irreversible?: boolean;
+}
+export interface ConfirmationRule {
+    id: string;
+    when: (operation_type: string, data: any, env: any) => boolean;
+    level: ConfirmLevel;
+    preview: (operation_type: string, data: any, env: any) => OperationPreview;
+    bypass_on_explicit_intent?: string[];
+}
+export declare const DEFAULT_VALUE_WARNINGS: {
+    readonly defaultAccount: "Using default account (env.account=\"\")";
+    readonly mainnet: "Operating on mainnet — irreversible";
+    readonly replaceExistName: "replaceExistName=true will unbind the existing name (breaking refs)";
+    readonly defaultToken: "Using default token 0x2::wow::WOW";
+};
+export declare const DEFAULT_AMOUNT_THRESHOLD: bigint;
+export declare function getAmountThreshold(): bigint;
+export declare function formatAmount(value: string | bigint, precision?: bigint): string;
+export declare function collectDefaultWarnings(env: any, data: any): string[];
+export declare const CONFIRMATION_RULES: ConfirmationRule[];
+export declare const SAFETY_RULES_VERSION = 1;