@f2a/network 0.1.2

package/src/core/autonomous-economy.ts

@@ -0,0 +1,428 @@
+/**
+ * F2A 自治经济系统
+ * Phase 4: 信誉消耗、评审激励、优先级调度
+ */
+
+import { Logger } from '../utils/logger.js';
+import { ReputationManager } from './reputation.js';
+import { ReviewCommittee, ReviewResult } from './review-committee.js';
+
+// ============================================================================
+// 类型定义
+// ============================================================================
+
+/**
+ * 任务请求
+ */
+export interface TaskRequest {
+  taskId: string;
+  requesterId: string;
+  capability: string;
+  description: string;
+  parameters?: Record<string, unknown>;
+  timeout?: number;
+  estimatedComplexity?: number;
+}
+
+/**
+ * 任务成本估算
+ */
+export interface TaskCost {
+  baseCost: number;
+  discount: number;
+  finalCost: number;
+  priority: number;
+}
+
+/**
+ * 任务奖励
+ */
+export interface TaskReward {
+  executorReward: number;
+  reviewerReward: number;
+  requesterRefund: number;
+}
+
+/**
+ * 经济配置
+ */
+export interface EconomyConfig {
+  /** 基础任务成本 */
+  baseTaskCost: number;
+  /** 复杂度系数 */
+  complexityMultiplier: number;
+  /** 执行者奖励比例 */
+  executorRewardRate: number;
+  /** 评审者奖励比例 */
+  reviewerRewardRate: number;
+  /** 任务超时惩罚 */
+  timeoutPenalty: number;
+  /** 拒绝任务惩罚 */
+  rejectionPenalty: number;
+}
+
+/**
+ * 优先级队列项
+ */
+export interface PriorityQueueItem {
+  task: TaskRequest;
+  priority: number;
+  cost: number;
+  deducted: boolean;
+  timestamp: number;
+}
+
+/**
+ * 任务执行结果
+ */
+export interface TaskExecutionResult {
+  taskId: string;
+  executorId: string;
+  status: 'success' | 'failure' | 'timeout' | 'rejected';
+  result?: unknown;
+  error?: string;
+  reviewResult?: ReviewResult;
+}
+
+// ============================================================================
+// 默认配置
+// ============================================================================
+
+const DEFAULT_ECONOMY_CONFIG: EconomyConfig = {
+  baseTaskCost: 5,
+  complexityMultiplier: 0.1,
+  executorRewardRate: 0.5,
+  reviewerRewardRate: 0.2,
+  timeoutPenalty: 15,
+  rejectionPenalty: 5,
+};
+
+// ============================================================================
+// 自治经济管理器
+// ============================================================================
+
+export class AutonomousEconomy {
+  private config: EconomyConfig;
+  private reputationManager: ReputationManager;
+  private reviewCommittee: ReviewCommittee;
+  private taskQueue: PriorityQueueItem[] = [];
+  private pendingTasks: Map<string, PriorityQueueItem> = new Map();
+  private logger: Logger;
+
+  constructor(
+    reputationManager: ReputationManager,
+    reviewCommittee: ReviewCommittee,
+    config: Partial<EconomyConfig> = {}
+  ) {
+    this.config = { ...DEFAULT_ECONOMY_CONFIG, ...config };
+    this.reputationManager = reputationManager;
+    this.reviewCommittee = reviewCommittee;
+    this.logger = new Logger({ component: 'AutonomousEconomy' });
+  }
+
+  /**
+   * 提交任务（消耗信誉）
+   */
+  submitTask(task: TaskRequest): { success: boolean; cost?: TaskCost; error?: string } {
+    // 检查发布权限
+    if (!this.reputationManager.hasPermission(task.requesterId, 'publish')) {
+      return { success: false, error: 'No permission to publish tasks' };
+    }
+
+    // 计算成本
+    const cost = this.calculateTaskCost(task);
+
+    // 检查信誉是否足够
+    const reputation = this.reputationManager.getReputation(task.requesterId);
+    if (reputation.score < cost.finalCost) {
+      return {
+        success: false,
+        error: `Insufficient reputation: ${reputation.score.toFixed(1)} < ${cost.finalCost.toFixed(1)}`,
+      };
+    }
+
+    // 预扣信誉
+    this.reputationManager.recordFailure(
+      task.requesterId,
+      `task-submit-${task.taskId}`,
+      'Task submission cost',
+      -cost.finalCost
+    );
+
+    // 加入优先级队列
+    const queueItem: PriorityQueueItem = {
+      task,
+      priority: cost.priority,
+      cost: cost.finalCost,
+      deducted: true,
+      timestamp: Date.now(),
+    };
+
+    this.taskQueue.push(queueItem);
+    this.taskQueue.sort((a, b) => b.priority - a.priority);
+    this.pendingTasks.set(task.taskId, queueItem);
+
+    this.logger.info('Task submitted', {
+      taskId: task.taskId,
+      requesterId: task.requesterId.slice(0, 16),
+      cost: cost.finalCost,
+      priority: cost.priority,
+    });
+
+    return { success: true, cost };
+  }
+
+  /**
+   * 计算任务成本
+   */
+  calculateTaskCost(task: TaskRequest): TaskCost {
+    const complexity = task.estimatedComplexity || 1;
+    const baseCost = this.config.baseTaskCost * complexity;
+
+    // 获取折扣
+    const discount = this.reputationManager.getPublishDiscount(task.requesterId);
+    const finalCost = Math.floor(baseCost * discount);
+
+    // 获取优先级
+    const priority = this.reputationManager.getPublishPriority(task.requesterId);
+
+    return {
+      baseCost,
+      discount,
+      finalCost,
+      priority,
+    };
+  }
+
+  /**
+   * 分配任务给执行者
+   */
+  assignTask(taskId: string, executorId: string): boolean {
+    const queueItem = this.pendingTasks.get(taskId);
+    if (!queueItem) return false;
+
+    // 检查执行者权限
+    if (!this.reputationManager.hasPermission(executorId, 'execute')) {
+      this.logger.warn('Executor lacks permission', { executorId: executorId.slice(0, 16) });
+      return false;
+    }
+
+    this.logger.info('Task assigned', {
+      taskId,
+      executorId: executorId.slice(0, 16),
+    });
+
+    return true;
+  }
+
+  /**
+   * 完成任务并结算
+   */
+  completeTask(result: TaskExecutionResult): TaskReward | null {
+    const queueItem = this.pendingTasks.get(result.taskId);
+    if (!queueItem) return null;
+
+    const task = queueItem.task;
+    let reward: TaskReward = {
+      executorReward: 0,
+      reviewerReward: 0,
+      requesterRefund: 0,
+    };
+
+    switch (result.status) {
+      case 'success':
+        // 任务成功
+        if (result.reviewResult) {
+          reward = this.calculateRewardFromReview(
+            task,
+            result.executorId,
+            result.reviewResult
+          );
+        } else {
+          // 无评审结果，使用默认奖励
+          reward.executorReward = queueItem.cost * this.config.executorRewardRate;
+        }
+
+        // 奖励执行者
+        this.reputationManager.recordSuccess(
+          result.executorId,
+          result.taskId,
+          reward.executorReward
+        );
+
+        // 部分返还请求者
+        if (reward.requesterRefund > 0) {
+          this.reputationManager.recordSuccess(
+            task.requesterId,
+            `refund-${result.taskId}`,
+            reward.requesterRefund
+          );
+        }
+
+        this.logger.info('Task completed successfully', {
+          taskId: result.taskId,
+          executorReward: reward.executorReward,
+          requesterRefund: reward.requesterRefund,
+        });
+        break;
+
+      case 'failure':
+        // 任务失败
+        this.reputationManager.recordFailure(
+          result.executorId,
+          result.taskId,
+          result.error || 'Task failed'
+        );
+        this.logger.warn('Task failed', { taskId: result.taskId, error: result.error });
+        break;
+
+      case 'timeout':
+        // 任务超时
+        this.reputationManager.recordFailure(
+          result.executorId,
+          result.taskId,
+          'Task timeout',
+          -this.config.timeoutPenalty
+        );
+        this.logger.warn('Task timeout', { taskId: result.taskId });
+        break;
+
+      case 'rejected':
+        // 任务被拒绝
+        this.reputationManager.recordRejection(
+          result.executorId,
+          result.taskId,
+          result.error || 'Task rejected'
+        );
+        break;
+    }
+
+    // 清理
+    this.pendingTasks.delete(result.taskId);
+    this.taskQueue = this.taskQueue.filter(item => item.task.taskId !== result.taskId);
+
+    return reward;
+  }
+
+  /**
+   * 从评审结果计算奖励
+   */
+  calculateRewardFromReview(
+    task: TaskRequest,
+    executorId: string,
+    reviewResult: ReviewResult
+  ): TaskReward {
+    const { finalWorkload, finalValue } = reviewResult;
+    
+    // 执行者奖励 = 工作量 × 价值系数
+    const valueFactor = (finalValue + 100) / 200; // 归一化到 0-1
+    const executorReward = finalWorkload * valueFactor * this.config.executorRewardRate;
+
+    // 评审者奖励（在 ReviewCommittee 中已处理）
+    const reviewerReward = reviewResult.reviews.length * 3;
+
+    // 请求者返还
+    let requesterRefund = 0;
+    if (finalValue > 0) {
+      // 正价值任务，部分返还
+      requesterRefund = finalWorkload * 0.1;
+    }
+
+    return {
+      executorReward,
+      reviewerReward,
+      requesterRefund,
+    };
+  }
+
+  /**
+   * 获取下一个待处理任务
+   */
+  getNextTask(): PriorityQueueItem | null {
+    return this.taskQueue.length > 0 ? this.taskQueue[0] : null;
+  }
+
+  /**
+   * 获取队列长度
+   */
+  getQueueLength(): number {
+    return this.taskQueue.length;
+  }
+
+  /**
+   * 获取待处理任务
+   */
+  getPendingTask(taskId: string): PriorityQueueItem | null {
+    return this.pendingTasks.get(taskId) || null;
+  }
+
+  /**
+   * 取消任务（返还部分信誉）
+   */
+  cancelTask(taskId: string): boolean {
+    const queueItem = this.pendingTasks.get(taskId);
+    if (!queueItem) return false;
+
+    // 返还部分信誉
+    const refund = queueItem.cost * 0.5;
+    this.reputationManager.recordSuccess(
+      queueItem.task.requesterId,
+      `cancel-${taskId}`,
+      refund
+    );
+
+    // 清理
+    this.pendingTasks.delete(taskId);
+    this.taskQueue = this.taskQueue.filter(item => item.task.taskId !== taskId);
+
+    this.logger.info('Task cancelled', {
+      taskId,
+      refund,
+    });
+
+    return true;
+  }
+
+  /**
+   * 获取经济统计
+   */
+  getEconomyStats(): {
+    pendingTasks: number;
+    queueLength: number;
+    totalCostDeducted: number;
+  } {
+    const totalCostDeducted = Array.from(this.pendingTasks.values())
+      .filter(item => item.deducted)
+      .reduce((sum, item) => sum + item.cost, 0);
+
+    return {
+      pendingTasks: this.pendingTasks.size,
+      queueLength: this.taskQueue.length,
+      totalCostDeducted,
+    };
+  }
+
+  /**
+   * 清理过期任务
+   */
+  cleanupExpiredTasks(maxAge: number = 24 * 60 * 60 * 1000): string[] {
+    const now = Date.now();
+    const expired: string[] = [];
+
+    for (const [taskId, item] of this.pendingTasks) {
+      if (now - item.timestamp > maxAge) {
+        expired.push(taskId);
+        this.cancelTask(taskId);
+      }
+    }
+
+    if (expired.length > 0) {
+      this.logger.info('Cleaned up expired tasks', { count: expired.length });
+    }
+
+    return expired;
+  }
+}
+
+// 默认导出
+export default AutonomousEconomy;

package/src/core/e2ee-crypto.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { E2EECrypto } from './e2ee-crypto.js';
+
+describe('E2EECrypto', () => {
+  let cryptoA: E2EECrypto;
+  let cryptoB: E2EECrypto;
+
+  beforeEach(async () => {
+    cryptoA = new E2EECrypto();
+    cryptoB = new E2EECrypto();
+    await cryptoA.initialize();
+    await cryptoB.initialize();
+  });
+
+  describe('initialization', () => {
+    it('should generate key pair on initialize', async () => {
+      const publicKey = cryptoA.getPublicKey();
+      expect(publicKey).not.toBeNull();
+      expect(typeof publicKey).toBe('string');
+      expect(publicKey!.length).toBeGreaterThan(0);
+    });
+
+    it('should generate different keys for different instances', async () => {
+      const keyA = cryptoA.getPublicKey();
+      const keyB = cryptoB.getPublicKey();
+      expect(keyA).not.toBe(keyB);
+    });
+
+    it('should export and import key pair', () => {
+      const exported = cryptoA.exportKeyPair();
+      expect(exported).not.toBeNull();
+      expect(exported!.publicKey).toBeDefined();
+      expect(exported!.privateKey).toBeDefined();
+
+      // Create new instance and import
+      const cryptoC = new E2EECrypto();
+      const privateKey = Buffer.from(exported!.privateKey, 'base64');
+      const publicKey = Buffer.from(exported!.publicKey, 'base64');
+      cryptoC.initializeWithKeyPair(privateKey, publicKey);
+      
+      expect(cryptoC.getPublicKey()).toBe(exported!.publicKey);
+    });
+  });
+
+  describe('peer key registration', () => {
+    it('should register peer public key', () => {
+      const keyB = cryptoB.getPublicKey()!;
+      cryptoA.registerPeerPublicKey('peer-b', keyB);
+      expect(cryptoA.canEncryptTo('peer-b')).toBe(true);
+    });
+
+    it('should track registered peer count', () => {
+      expect(cryptoA.getRegisteredPeerCount()).toBe(0);
+      cryptoA.registerPeerPublicKey('peer-1', cryptoB.getPublicKey()!);
+      expect(cryptoA.getRegisteredPeerCount()).toBe(1);
+    });
+  });
+
+  describe('encryption/decryption', () => {
+    beforeEach(() => {
+      // Exchange public keys
+      cryptoA.registerPeerPublicKey('peer-b', cryptoB.getPublicKey()!);
+      cryptoB.registerPeerPublicKey('peer-a', cryptoA.getPublicKey()!);
+    });
+
+    it('should encrypt and decrypt message', () => {
+      const plaintext = 'Hello, secure world!';
+      const encrypted = cryptoA.encrypt('peer-b', plaintext);
+      
+      expect(encrypted).not.toBeNull();
+      expect(encrypted!.ciphertext).toBeDefined();
+      expect(encrypted!.iv).toBeDefined();
+      expect(encrypted!.authTag).toBeDefined();
+
+      const decrypted = cryptoB.decrypt(encrypted!);
+      expect(decrypted).toBe(plaintext);
+    });
+
+    it('should encrypt with AAD', () => {
+      const plaintext = 'Secret message';
+      const aad = 'message-metadata';
+      
+      const encrypted = cryptoA.encrypt('peer-b', plaintext, aad);
+      expect(encrypted).not.toBeNull();
+      expect(encrypted!.aad).toBe(aad);
+
+      const decrypted = cryptoB.decrypt(encrypted!);
+      expect(decrypted).toBe(plaintext);
+    });
+
+    it('should fail to decrypt tampered ciphertext', () => {
+      const plaintext = 'Original message';
+      const encrypted = cryptoA.encrypt('peer-b', plaintext);
+      
+      // Tamper with ciphertext
+      encrypted!.ciphertext = encrypted!.ciphertext.slice(0, -4) + 'xxxx';
+      
+      const decrypted = cryptoB.decrypt(encrypted!);
+      expect(decrypted).toBeNull(); // Should fail
+    });
+
+    it('should return null when encrypting to unknown peer', async () => {
+      const cryptoC = new E2EECrypto();
+      await cryptoC.initialize();
+      // Don't register any peer keys
+      
+      const result = cryptoC.encrypt('unknown-peer', 'test');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('error handling', () => {
+    it('should return null when decrypting malformed message', () => {
+      const malformed = {
+        senderPublicKey: 'invalid-base64!!!',
+        iv: Buffer.from('invalid').toString('base64'),
+        authTag: Buffer.from('short').toString('base64'),
+        ciphertext: 'garbage'
+      };
+
+      const decrypted = cryptoA.decrypt(malformed as any);
+      expect(decrypted).toBeNull();
+    });
+  });
+});