@twinsearth/agent-universe 2.3.4

package/index.d.ts

@@ -0,0 +1,108 @@
+// Type definitions for @twinsearth/agent-universe
+
+export const version: string;
+export const MIN_STAKE: number;
+
+export class Keypair {
+  publicKey: string;
+  privateKey: string;
+  did: string;
+  static generate(): Keypair;
+  sign(message: string | Buffer): string;
+  verify(message: string | Buffer, signatureHex: string): boolean;
+}
+
+export class AgentCard {
+  did: string;
+  name: string;
+  capabilities: string[];
+  skills: string[];
+  version: string;
+  stake: number;
+  reputation: number;
+  static new(opts: { did: string; name: string }): AgentCard;
+  withCapability(cap: string): this;
+  withSkill(skill: string): this;
+  hasCapability(cap: string): boolean;
+}
+
+export const TaskStatus: Record<string, string>;
+
+export class Task {
+  taskId: string;
+  goal: string;
+  status: string;
+  assignee: string | null;
+  history: string[];
+  constructor(taskId: string, goal: string);
+  assign(did: string): this;
+  start(): this;
+  complete(): this;
+  verify(passed: boolean): this;
+  settle(): this;
+  readonly isTerminal: boolean;
+}
+
+export class MemoryDHT {
+  put(key: string, value: unknown): void;
+  get(key: string): unknown;
+  has(key: string): boolean;
+  remove(key: string): boolean;
+  readonly size: number;
+}
+
+export class ShardedIndex {
+  constructor(numShards?: number);
+  put(key: string, value: unknown): number;
+  get(key: string): unknown;
+  has(key: string): boolean;
+  remove(key: string): boolean;
+  readonly size: number;
+  distribution(): number[];
+}
+
+export function shardOf(key: string, numShards: number): number;
+
+export class Bid {
+  agentId: string;
+  price: number;
+}
+
+export class Reputation {
+  quality: number;
+  speed: number;
+  honesty: number;
+  availability: number;
+  overall(): number;
+}
+
+export class AgentMarket {
+  agents: Map<string, unknown>;
+  tasks: Map<string, Task>;
+  deposit(account: string, amount: number): void;
+  balance(account: string): number;
+  registerAgent(card: AgentCard, stake: number): boolean;
+  publishTask(taskId: string, goal: string, budget: number, requester: string): Task;
+  submitBid(taskId: string, agentId: string, price: number): boolean;
+  matchTask(taskId: string): Bid;
+  completeTask(taskId: string, passed?: boolean): Task;
+  settle(taskId: string): { paid: number; reason: string };
+  slash(agentId: string, amount: number, reason: string): unknown;
+  discoverBySkill(skill: string): AgentCard[];
+  leaderboard(limit?: number): unknown[];
+  conservationCheck(totalDeposits: number): {
+    conserved: boolean;
+    balanceSum: number;
+    totalSlashed: number;
+    expected: number;
+  };
+}
+
+export class AgentUniverse {
+  identity: Keypair;
+  dht: MemoryDHT;
+  market: AgentMarket;
+  readonly did: string;
+  register(card: AgentCard): AgentCard;
+  discover(capability: string): AgentCard[];
+}

package/index.js

@@ -0,0 +1,52 @@
+// index.js
+// Agent Universe（智能体宇宙）主入口
+// 群众化的 AGI 路线，去中心化的智能体共享 & 开源网络
+
+const { Keypair } = require('./lib/keychain');
+const { AgentCard, Task, TaskStatus } = require('./lib/models');
+const { MemoryDHT, ShardedIndex, shardOf } = require('./lib/dht');
+const { AgentMarket, Bid, Reputation, MIN_STAKE } = require('./lib/market');
+
+const version = '2.3.4';
+
+/**
+ * AgentUniverse 门面：聚合身份、网络、市场能力
+ */
+class AgentUniverse {
+  constructor() {
+    this.identity = Keypair.generate();
+    this.dht = new MemoryDHT();
+    this.market = new AgentMarket();
+  }
+
+  get did() {
+    return this.identity.did;
+  }
+
+  /** 注册一张 AgentCard 到本地网络 */
+  register(card) {
+    this.dht.put(card.did, card);
+    return card;
+  }
+
+  /** 发现某能力的 Agent */
+  discover(capability) {
+    return this.market.discoverBySkill(capability);
+  }
+}
+
+module.exports = {
+  version,
+  AgentUniverse,
+  Keypair,
+  AgentCard,
+  Task,
+  TaskStatus,
+  MemoryDHT,
+  ShardedIndex,
+  shardOf,
+  AgentMarket,
+  Bid,
+  Reputation,
+  MIN_STAKE,
+};

package/lib/dht.js

@@ -0,0 +1,92 @@
+// lib/dht.js
+// MemoryDHT / ShardedIndex / shardOf（SHA-256 分片）
+
+const crypto = require('node:crypto');
+
+/** 计算 key 所属分片：SHA-256(key) 前 8 hex 转整数，对 numShards 取模 */
+function shardOf(key, numShards) {
+  const hash = crypto.createHash('sha256').update(String(key)).digest('hex');
+  const prefix = parseInt(hash.slice(0, 8), 16);
+  return prefix % numShards;
+}
+
+/** 内存 DHT（键值存储） */
+class MemoryDHT {
+  constructor() {
+    this.store = new Map();
+  }
+
+  put(key, value) {
+    this.store.set(String(key), value);
+  }
+
+  get(key) {
+    return this.store.get(String(key));
+  }
+
+  has(key) {
+    return this.store.has(String(key));
+  }
+
+  remove(key) {
+    return this.store.delete(String(key));
+  }
+
+  get size() {
+    return this.store.size;
+  }
+
+  /** 按前缀查找 */
+  findByPrefix(prefix) {
+    const result = [];
+    for (const [k, v] of this.store) {
+      if (k.startsWith(prefix)) result.push({ key: k, value: v });
+    }
+    return result;
+  }
+}
+
+/** 分片索引：把 key 均匀分布到 numShards 个分片 */
+class ShardedIndex {
+  constructor(numShards = 16) {
+    this.numShards = numShards;
+    this.shards = [];
+    for (let i = 0; i < numShards; i++) this.shards.push(new Map());
+  }
+
+  put(key, value) {
+    const s = shardOf(key, this.numShards);
+    this.shards[s].set(String(key), value);
+    return s;
+  }
+
+  get(key) {
+    const s = shardOf(key, this.numShards);
+    return this.shards[s].get(String(key));
+  }
+
+  has(key) {
+    const s = shardOf(key, this.numShards);
+    return this.shards[s].has(String(key));
+  }
+
+  remove(key) {
+    const s = shardOf(key, this.numShards);
+    return this.shards[s].delete(String(key));
+  }
+
+  shardSize(i) {
+    return this.shards[i].size;
+  }
+
+  get size() {
+    return this.shards.reduce((sum, m) => sum + m.size, 0);
+  }
+
+  /** 各分片条目数（用于验证分布均匀性） */
+  distribution() {
+    return this.shards.map((m) => m.size);
+  }
+}
+
+module.exports = { MemoryDHT, ShardedIndex, shardOf };

package/lib/keychain.js

@@ -0,0 +1,74 @@
+// lib/keychain.js
+// Ed25519 密钥对 + DID 身份（零依赖，使用 node:crypto）
+
+const crypto = require('node:crypto');
+
+/**
+ * 密钥对与去中心化身份
+ */
+class Keypair {
+  constructor(publicKey, privateKey, did) {
+    this.publicKey = publicKey;   // hex
+    this.privateKey = privateKey; // hex（node KeyObject 可导出的形式）
+    this.did = did;               // did:au:<hash>
+  }
+
+  /** 生成新的 Ed25519 密钥对与 DID */
+  static generate() {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
+    const pubHex = publicKey.export({ format: 'der', type: 'spki' })
+      .toString('hex');
+    // DID 由公钥的 SHA-256 哈希（取前 32 字符）派生
+    const didHash = crypto.createHash('sha256')
+      .update(publicKey.export({ format: 'der', type: 'spki' }))
+      .digest('hex')
+      .slice(0, 32);
+    const did = `did:au:${didHash}`;
+
+    // 私钥以 PKCS8 DER hex 保存，便于重建 KeyObject
+    const privHex = privateKey.export({ format: 'der', type: 'pkcs8' })
+      .toString('hex');
+
+    const kp = new Keypair(pubHex, privHex, did);
+    kp._pubKeyObj = publicKey;
+    kp._privKeyObj = privateKey;
+    return kp;
+  }
+
+  /** 获取可用于签名的私钥 KeyObject */
+  _privateKeyObject() {
+    if (this._privKeyObj) return this._privKeyObj;
+    this._privKeyObj = crypto.createPrivateKey({
+      key: Buffer.from(this.privateKey, 'hex'),
+      format: 'der',
+      type: 'pkcs8',
+    });
+    return this._privKeyObj;
+  }
+
+  /** 获取公钥 KeyObject */
+  _publicKeyObject() {
+    if (this._pubKeyObj) return this._pubKeyObj;
+    this._pubKeyObj = crypto.createPublicKey({
+      key: Buffer.from(this.publicKey, 'hex'),
+      format: 'der',
+      type: 'spki',
+    });
+    return this._pubKeyObj;
+  }
+
+  /** 对消息签名，返回 hex */
+  sign(message) {
+    const data = Buffer.isBuffer(message) ? message : Buffer.from(message);
+    return crypto.sign(null, data, this._privateKeyObject()).toString('hex');
+  }
+
+  /** 验证签名（默认用本密钥对的公钥） */
+  verify(message, signatureHex) {
+    const data = Buffer.isBuffer(message) ? message : Buffer.from(message);
+    const sig = Buffer.from(signatureHex, 'hex');
+    return crypto.verify(null, data, this._publicKeyObject(), sig);
+  }
+}
+
+module.exports = { Keypair };

package/lib/market.js

@@ -0,0 +1,240 @@
+// lib/market.js
+// v2.3.4 Agent Market：注册 / 发布 / 投标 / 匹配 / 结算 / 罚没 / 守恒
+
+const { Task, TaskStatus } = require('./models');
+
+const MIN_STAKE = 100;
+
+/** 投标 */
+class Bid {
+  constructor(agentId, price) {
+    this.agentId = agentId;
+    this.price = price;
+  }
+}
+
+/** 信誉档案（简化四维） */
+class Reputation {
+  constructor() {
+    this.quality = 0;
+    this.speed = 0;
+    this.honesty = 0;
+    this.availability = 0;
+  }
+
+  overall() {
+    return this.quality * 0.35 + this.speed * 0.20 +
+      this.honesty * 0.30 + this.availability * 0.15;
+  }
+}
+
+/**
+ * 智能体市场
+ */
+class AgentMarket {
+  constructor() {
+    this.agents = new Map();      // agentId → { card, stake, reputation }
+    this.tasks = new Map();       // taskId → Task
+    this.bids = new Map();        // taskId → Bid[]
+    this.balances = new Map();    // 账户 → 余额
+    this.totalSlashed = 0;
+    this.paidTasks = new Set();   // 已结算任务（防重复支付）
+  }
+
+  /** 充值 / 质押金进入账户 */
+  deposit(account, amount) {
+    if (amount < 0) throw new Error('金额不能为负');
+    const cur = this.balances.get(account) || 0;
+    this.balances.set(account, cur + amount);
+  }
+
+  balance(account) {
+    return this.balances.get(account) || 0;
+  }
+
+  /** 质押锁定账户（仍计入系统总余额，只是不可流动） */
+  _stakeAccount(agentId) {
+    return `__stake__:${agentId}`;
+  }
+
+  /** 注册 Agent（需质押 ≥ MIN_STAKE） */
+  registerAgent(card, stake) {
+    if (!card || !card.did) throw new Error('agent_id 不能为空');
+    if (!card.name) throw new Error('name 不能为空');
+    if (this.agents.has(card.did)) throw new Error('Agent 已存在');
+    if (stake < MIN_STAKE) {
+      throw new Error(`质押不足，最低 ${MIN_STAKE}`);
+    }
+    // 质押金从发布者账户转入锁定账户（不退出系统，仍计入总余额）
+    const owner = card.did;
+    if (this.balance(owner) < stake) {
+      throw new Error('质押账户余额不足，请先 deposit');
+    }
+    const stakeAcc = this._stakeAccount(owner);
+    this.balances.set(owner, this.balance(owner) - stake);
+    this.balances.set(stakeAcc, this.balance(stakeAcc) + stake);
+
+    this.agents.set(card.did, {
+      card,
+      stake,
+      reputation: new Reputation(),
+      status: 'active',
+    });
+    return true;
+  }
+
+  /** 发布任务 */
+  publishTask(taskId, goal, budget, requester) {
+    if (!goal) throw new Error('goal 不能为空');
+    if (budget <= 0) throw new Error('预算必须为正');
+    if (this.balance(requester) < budget) {
+      throw new Error('需求方余额不足以覆盖预算');
+    }
+    // 预算锁定
+    this.balances.set(requester, this.balance(requester) - budget);
+
+    const task = new Task(taskId, goal);
+    task.transition(TaskStatus.OPEN);
+    task.requester = requester;
+    task.budget = budget;
+    this.tasks.set(taskId, task);
+    this.bids.set(taskId, []);
+    return task;
+  }
+
+  /** 提交投标 */
+  submitBid(taskId, agentId, price) {
+    if (!this.agents.has(agentId)) throw new Error('Agent 未注册');
+    const task = this.tasks.get(taskId);
+    if (!task || task.status !== TaskStatus.OPEN) {
+      throw new Error('任务不在开放状态');
+    }
+    this.bids.get(taskId).push(new Bid(agentId, price));
+    return true;
+  }
+
+  /** 匹配：选性价比最高（信誉/价格）的投标，平局选价格低者 */
+  matchTask(taskId) {
+    const bids = this.bids.get(taskId) || [];
+    if (bids.length === 0) throw new Error('无投标，无法匹配');
+
+    let best = bids[0];
+    let bestScore = this._bidScore(best);
+    for (let i = 1; i < bids.length; i++) {
+      const score = this._bidScore(bids[i]);
+      if (score > bestScore ||
+        (score === bestScore && bids[i].price < best.price)) {
+        best = bids[i];
+        bestScore = score;
+      }
+    }
+
+    const task = this.tasks.get(taskId);
+    task.assign(best.agentId);
+    task.winnerPrice = best.price;
+    return best;
+  }
+
+  _bidScore(bid) {
+    const agent = this.agents.get(bid.agentId);
+    const rep = agent.reputation.overall();
+    // 性价比 = 信誉 / 价格（价格为 0 时退化为只看信誉）
+    return bid.price > 0 ? rep / bid.price : rep;
+  }
+
+  /** 执行 → 完成 → 验证 */
+  completeTask(taskId, passed = true) {
+    const task = this.tasks.get(taskId);
+    task.start();
+    task.complete();
+    task.verify(passed);
+    return task;
+  }
+
+  /** 结算（验收通过才支付） */
+  settle(taskId) {
+    const task = this.tasks.get(taskId);
+
+    // 结算优先级短路
+    if (this.paidTasks.has(taskId)) {
+      return { paid: 0, reason: 'already_paid' };
+    }
+    if (task.status !== TaskStatus.VERIFIED) {
+      return { paid: 0, reason: 'rejected' };
+    }
+
+    const price = task.winnerPrice || task.budget;
+    const pay = Math.min(price, task.budget);
+
+    // 从任务锁定预算中支付给执行者（账户间转账，系统总余额不变）
+    const assignee = task.assignee;
+    this.balances.set(assignee, this.balance(assignee) + pay);
+    // 未用完的预算退还需求方
+    const refund = task.budget - pay;
+    if (refund > 0) {
+      this.balances.set(task.requester, this.balance(task.requester) + refund);
+    }
+
+    task.settle();
+    this.paidTasks.add(taskId);
+    return { paid: pay, reason: 'settled' };
+  }
+
+  /** 罚没（作恶）：从质押锁定账户扣除，罚没部分退出系统（总余额减少） */
+  slash(agentId, amount, reason) {
+    const entry = this.agents.get(agentId);
+    if (!entry) throw new Error('Agent 不存在');
+    const actual = Math.min(amount, entry.stake);
+    entry.stake -= actual;
+    // 从锁定账户实际扣除（退出系统）
+    const stakeAcc = this._stakeAccount(agentId);
+    this.balances.set(stakeAcc, this.balance(stakeAcc) - actual);
+    this.totalSlashed += actual;
+    entry.status = entry.stake < MIN_STAKE ? 'suspended' : entry.status;
+    return { slashed: actual, reason, remainingStake: entry.stake };
+  }
+
+  /** 按技能发现 Agent */
+  discoverBySkill(skill) {
+    const target = String(skill).toLowerCase();
+    const result = [];
+    for (const [id, entry] of this.agents) {
+      const skills = (entry.card.skills || [])
+        .map((s) => String(s).toLowerCase());
+      const caps = (entry.card.capabilities || [])
+        .map((s) => String(s).toLowerCase());
+      if (skills.includes(target) || caps.includes(target)) {
+        result.push(entry.card);
+      }
+    }
+    return result;
+  }
+
+  /** 排行榜（按信誉综合分） */
+  leaderboard(limit = 10) {
+    const entries = [...this.agents.values()]
+      .filter((e) => e.status === 'active')
+      .map((e) => ({ agentId: e.card.did, score: e.reputation.overall() }))
+      .sort((a, b) => b.score - a.score);
+    return entries.slice(0, limit);
+  }
+
+  /**
+   * 守恒检查
+   * 支付是账户间转账（系统总余额不变），只有罚没减少系统总余额。
+   * 总充值（预算/质押）− 总罚没 = 当前全部账户余额之和
+   */
+  conservationCheck(totalDeposits) {
+    let balanceSum = 0;
+    for (const v of this.balances.values()) balanceSum += v;
+    const expected = totalDeposits - this.totalSlashed;
+    return {
+      conserved: Math.abs(balanceSum - expected) < 1e-9,
+      balanceSum,
+      totalSlashed: this.totalSlashed,
+      expected,
+    };
+  }
+}
+
+module.exports = { AgentMarket, Bid, Reputation, MIN_STAKE };

package/lib/models.js

@@ -0,0 +1,124 @@
+// lib/models.js
+// AgentCard / Task / TaskStatus 状态机
+
+/** 任务状态枚举 */
+const TaskStatus = {
+  PENDING: 'pending',
+  OPEN: 'open',
+  MATCHED: 'matched',
+  ASSIGNED: 'assigned',
+  RUNNING: 'running',
+  VERIFYING: 'verifying',
+  COMPLETED: 'completed',
+  VERIFIED: 'verified',
+  SETTLED: 'settled',
+  REWORK: 'rework',
+  DISPUTED: 'disputed',
+  REJECTED: 'rejected',
+};
+
+// 合法状态转移表
+const TRANSITIONS = {
+  [TaskStatus.PENDING]: [TaskStatus.OPEN],
+  [TaskStatus.OPEN]: [TaskStatus.MATCHED, TaskStatus.ASSIGNED],
+  [TaskStatus.MATCHED]: [TaskStatus.ASSIGNED],
+  [TaskStatus.ASSIGNED]: [TaskStatus.RUNNING],
+  [TaskStatus.RUNNING]: [TaskStatus.COMPLETED, TaskStatus.REWORK],
+  [TaskStatus.COMPLETED]: [TaskStatus.VERIFIED, TaskStatus.DISPUTED, TaskStatus.REWORK],
+  [TaskStatus.VERIFIED]: [TaskStatus.SETTLED],
+  [TaskStatus.REWORK]: [TaskStatus.RUNNING],
+  [TaskStatus.DISPUTED]: [TaskStatus.SETTLED, TaskStatus.REJECTED],
+  [TaskStatus.SETTLED]: [],
+  [TaskStatus.REJECTED]: [],
+};
+
+/** 智能体卡片 */
+class AgentCard {
+  constructor(did, name) {
+    this.did = did;
+    this.name = name;
+    this.capabilities = [];
+    this.skills = [];
+    this.version = '1.0.0';
+    this.stake = 0;
+    this.reputation = 0;
+  }
+
+  static new({ did, name }) {
+    return new AgentCard(did, name);
+  }
+
+  withCapability(cap) {
+    if (!this.capabilities.includes(cap)) this.capabilities.push(cap);
+    return this;
+  }
+
+  withSkill(skill) {
+    if (!this.skills.includes(skill)) this.skills.push(skill);
+    return this;
+  }
+
+  hasCapability(cap) {
+    return this.capabilities.includes(cap);
+  }
+
+  toJSON() {
+    return {
+      did: this.did, name: this.name,
+      capabilities: this.capabilities, skills: this.skills,
+      version: this.version, stake: this.stake, reputation: this.reputation,
+    };
+  }
+}
+
+/** 任务与状态机 */
+class Task {
+  constructor(taskId, goal) {
+    this.taskId = taskId;
+    this.goal = goal;
+    this.status = TaskStatus.PENDING;
+    this.assignee = null;
+    this.history = [TaskStatus.PENDING];
+  }
+
+  transition(next) {
+    const allowed = TRANSITIONS[this.status] || [];
+    if (!allowed.includes(next)) {
+      throw new Error(`非法状态转移: ${this.status} → ${next}`);
+    }
+    this.status = next;
+    this.history.push(next);
+    return this;
+  }
+
+  assign(did) {
+    if (this.status === TaskStatus.OPEN) this.transition(TaskStatus.MATCHED);
+    if (this.status === TaskStatus.MATCHED) this.transition(TaskStatus.ASSIGNED);
+    this.assignee = did;
+    return this;
+  }
+
+  start() {
+    return this.transition(TaskStatus.RUNNING);
+  }
+
+  complete() {
+    return this.transition(TaskStatus.COMPLETED);
+  }
+
+  verify(passed) {
+    if (passed) return this.transition(TaskStatus.VERIFIED);
+    return this.transition(TaskStatus.DISPUTED);
+  }
+
+  settle() {
+    if (this.status === TaskStatus.VERIFIED) return this.transition(TaskStatus.SETTLED);
+    throw new Error('只有验证通过的任务才能结算');
+  }
+
+  get isTerminal() {
+    return this.status === TaskStatus.SETTLED || this.status === TaskStatus.REJECTED;
+  }
+}
+
+module.exports = { AgentCard, Task, TaskStatus, TRANSITIONS };

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@twinsearth/agent-universe",
+  "version": "2.3.4",
+  "description": "Agent Universe - 群众化的 AGI 路线，去中心化的智能体共享 & 开源网络。使命：让科技造福全人类！",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "keywords": [
+    "agi",
+    "agent",
+    "p2p",
+    "decentralized",
+    "swarm",
+    "dht",
+    "mcp",
+    "a2a",
+    "agent-market"
+  ],
+  "author": "TwinsEarth",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TwinsEarth/agent-universe.git",
+    "directory": "js"
+  },
+  "homepage": "https://github.com/TwinsEarth/agent-universe#readme",
+  "bugs": {
+    "url": "https://github.com/TwinsEarth/agent-universe/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "lib"
+  ]
+}