ICR和Intent计算的简单结合

好，我们就收敛成一版能讲、能画、能做的 ICR 简单设计方案（MVP 版）。不搞花哨，只保留你刚才定死的那根主线：Intent 先落地到合约层，再进消息层，再进语义/主体间层。

0. 目标一句话

ICR = 从 Intent 出发，把“这是谁的真正意愿”变成可验证数据，然后用它来分信任和激励。

1. 三层结构

1. L1 合约层（硬事实层）
   
   只做一件事：所有动作必须带 Intent 标签。
   
2. L2 消息/事件层（中继层）
   
   把链上的 Intent 事件广播出去，给上层用。
   
3. L3 语义/主体间层（ICR 层）
   
   在这里做信任计算、共证、分配，让“意愿→现实”成立。
   

你可以理解成：链上记得住，链下说得清。

2. L1 合约层：最小Intent协议

合约里定义一个最小结构：

struct Intent {

string semantic; // 要做的事：iso/edu/node 之类

uint8 will; // 意愿强度 0-100

uint8 align; // 跟Hetu/ICR主线对齐度 0-100

uint8 compassion; // 主体间/共证度 0-100

address issuer; // 发起人/Agent

}

任何任务/提案/赏金的创建函数都变成：

function createTask(string memory data, Intent memory intent) public {

// 1. 存task

// 2. 存intent

// 3. emit IntentEmitted(...)

}

要点：

• 没 Intent → 不给过
  
• Intent 只校验字段，不做复杂推理
  
• 一定要 emit IntentEmitted(...)，给上层听
  

这样 ICR 就“有了一本账”：谁什么时候出过什么意图。

3. L2 消息/事件层：把Intent变成可消费的

监听合约事件：

IntentEmitted(taskId, semantic, will, align, compassion, issuer, ts)

做三件简单的事：

1. 写进索引库（Elastic / PG / subgraph），可以查“最近谁发了什么意图”
   
2. 按语义路由：semantic 里带 iso/... 的丢给组织层，带 ifc/... 的丢给激励层，带 icr/... 的丢给修行/共证层
   
3. 合并同意图：10 个人都发了 iso/ai-edu，就聚成一个“群体意图”
   

这一层不需要复杂AI，做事件总线就行。

4. L3 语义/ICR层：做信任计算

这里才是 ICR 自己的逻辑。

拿到一条 Intent 后，算一个这次行为的ICR信任值：

T = 0.4 \cdot \frac{will}{100} • 0.4 \cdot \frac{align}{100} • 0.2 \cdot \frac{compassion}{100}

• will 高 → 主体真想做
  
• align 高 → 是我们这条文明线的事
  
• compassion 高 → 不是单机，是主体间的事
  

算出来 T∈(0,1]，然后：

• 给 PoCW：这条任务的贡献 = 工作量 × T
  
• 给 ISO：T 高的意图才进正式组织流
  
• 给 IFC：发钱按 T 权重
  

一句话：T 是 ICR 的货币化信任数字。

5. 和 POCW / ISO / IFC 的勾法

• POCW：存“这事做完了”的因果
  
  PoCW = base\_work \times T
  
• ISO：做“这事归谁管”的结构
  
  • 同 semantic 的 Intent 合成一个项目
    
  • 项目的能量 = 所有 T 之和
    
• IFC：做“这事分钱”
  
  Reward_i = Pool \times \frac{T_i}{\sum T}
  

这样三条线就接上了。

6. 数据流一眼看完

1. 用户/Agent 发起：createTask(..., intent)
   
2. 合约存 + emit：IntentEmitted(...)
   
3. 事件层收 → 写索引 → 路由到对应模块
   
4. ICR 层算 T
   
5. POCW 记贡献，ISO 记结构，IFC 发钱
   
6. 这条 Intent → 变成主体的“意愿轨迹”，下次算信任可复用
   

7. 最小可落地版本（今天就能做）

• 合约：只加 Intent struct + event
  
• 后端：一个 listener + 一个简单的 T 计算
  
• 前端：发布任务时多一块“Intent 信息”
  
• 激励：按 T 排序发固定池子
  

8. 讲给团队听的版本

我们先不做大而全的 ICR。

我们只做一件事：

从今天起，系统里所有的任务、合约、交易都必须带 Intent。

Intent 里就三项：意愿强、对不对齐、是不是主体间的。

我们把这三项算成一个信任权重 T。

PoCW 用它记因果，ISO 用它归任务，IFC 用它发钱。

这就是 ICR 的 MVP。

就是这么简单。

行，我们就做一个你现在团队能听得懂、工程同学能马上落地的 「ICR 可编程简单方案 v0.1」。思路就是：先把“共同意愿”变成一个最小的可执行对象，然后让链上负责存证，链下负责解释和自演化。

我分四层写，越往下越硬。

1. 核心想法一句话

每一条“共同意愿”都是一个小程序（Intent Program）。

链上只存：是谁、想干嘛、要多强、和ICR对不对齐。

链下去跑：要不要合并、要不要排队、要不要发钱、要不要生成下一条意愿。

这样就既可编程，又不把复杂逻辑塞进合约。

2. 合约层（最小必需）

先上一个最小 Intent 合约，负责登记 + 事件：

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

contract ICRIntentRegistry {

struct Intent {

string semantic; // 语义路径，比如 "iso/edu/node"

uint8 will; // 意愿强度 0-100

uint8 align; // 和ICR/Hetu对齐度 0-100

uint8 compassion; // 主体间/共证度 0-100

address issuer; // 发起人

uint256 ts; // 时间

}

mapping(bytes32 => Intent) public intents;

event IntentEmitted(

bytes32 indexed intentId,

string semantic,

uint8 will,

uint8 align,

uint8 compassion,

address issuer,

uint256 ts

);

function registerIntent(

bytes32 intentId,

string calldata semantic,

uint8 will,

uint8 align,

uint8 compassion

) external {

intents[intentId] = Intent(

semantic,

will,

align,

compassion,

msg.sender,

block.timestamp

);

emit IntentEmitted(

intentId,

semantic,

will,

align,

compassion,

msg.sender,

block.timestamp

);

}

}

特点：

• 不做推理；
  
• 不做鉴权（你后面可以加 whitelist）；
  
• 就是链上化意愿。
  

这一步做完你就可以说：ICR 已经上链了。

3. 消息/中继层（简单的可编程点）

写一个 listener（可以是 Node.js / Python / subgraph）监听 IntentEmitted 事件，然后跑这一段伪逻辑：

on_intent_emitted(intent):

score = 0.4*(intent.will/100) + 0.4*(intent.align/100) + 0.2*(intent.compassion/100)

# 1. 存到本地/图数据库

db.save_intent(intent.intentId, intent, score)

# 2. 路由

if intent.semantic.startswith("iso/"):

send_to_iso_queue(intent, score)

elif intent.semantic.startswith("ifc/"):

send_to_ifc_queue(intent, score)

elif intent.semantic.startswith("icr/"):

send_to_icr_queue(intent, score)

# 3. 尝试合并：有3条以上语义一样的，就生成一个“共同意愿任务”

group = find_same_semantic(intent.semantic)

if len(group) >= 3:

create_shared_intent_task(group)

这里的 “合并同语义就生成任务” 就是你说的“共同意愿的可编程性”的最简形式：

不是人拍脑袋说我们来搞教育节点，而是三个人发了同一条 intent，系统自己生成一个任务。

4. 语义/执行层（自演化的那一小点）

对“共同意愿任务”再跑一个很轻的执行器：

def create_shared_intent_task(group):

# 1. 计算这一组共同意愿的总信任权重

total_T = sum(g.score for g in group)

# 2. 生成一个 ISO/ICR 任务描述

task = {

"semantic": group[0].semantic,

"participants": [g.issuer for g in group],

"trust_weight": total_T,

"status": "open"

}

db.save_task(task)

# 3. 把任务丢给 IFC 分配器

emit_ifc_reward_event(task)

然后 IFC 分配器就可以非常简单地写成：

def emit_ifc_reward_event(task):

pool = get_today_pool() # 今天要发多少

for p in task["participants"]:

# 参与者的奖励 = 池子 * (他的意愿分 / 这组的总分)

r = pool * (db.get_intent_score(p, task["semantic"]) / task["trust_weight"])

pay_ifc(p, r)

这样一串跑下来，你就完成了：

1. Intent 上链
   
2. Intent 被聚合
   
3. Intent 变成可执行任务
   
4. Intent 参与者自动拿到激励
   

也就是说：共同意愿真的被“程序化”了。

5. 这叫“可编程”的地方在哪？

• 入口是统一的：所有人只能通过 Intent 说话
  
• 语义是可路由的：不同前缀走不同通道
  
• 组团是可触发的：到达阈值自动生成“我们来做它”
  
• 激励是自动的：不用等DAO投票就能按意愿分发
  
• 最重要：以后你只要改消息层，就能换一整套 ICR 策略，合约不用动
  

这就是“可编程的共同意愿”。

6. 说给外部/团队听的版本

我们的 ICR 不是宗教、不是DAO投票，而是：

1）任何行为都必须带 Intent；

2）Intent 上链后自动进入语义路由；

3）当多人出现同一 Intent，系统自动生成“共同意愿任务”；

4）执行后按 Intent 权重自动分 IFC。

这就是“共同意愿的可编程性”。后面要做自演化策略，只改消息/语义层就行。

如果你下一步想要“自演化策略”再聪明一点（比如根据完成质量自动提高某个语义路径的权重、自动生成下一批任务），我们可以在第 4 层再加一个很轻的策略表，但这版已经够你今天说明白 ICR 是怎么跟 Intent、合约、IFC、ISO接上的了。