/**

 * 去中心化数据市场的核心数据授权与计费系统（零外部依赖纯 TypeScript 实现）

 * 核心抽象：DataOwner 管理 DataAsset，通过 AccessToken 实现按次授权与自动结算

 */

class Address {

  constructor(public value: string) {}

  toString() { return this.value; }

  equals(other: Address) { return this.value === other.value; }

}

class DataAsset {

  constructor(

    public id: string,

    public owner: Address,

    public metadataHash: string,      // 数据元信息哈希（如 IPFS CID）

    public description: string,

    public basePrice: bigint,         // 每次访问的基础费用（wei 单位）

    public totalAccessCount: number = 0,

    public cumulativeRevenue: bigint = 0n

  ) {}

}

class AccessToken {

  constructor(

    public tokenId: string,

    public assetId: string,

    public consumer: Address,

    public maxUses: number,           // 最大可用次数（类似授额）

    public remainingUses: number,

    public grantedAt: number,         // 时间戳

    public expiresAt: number,

    public isValid: boolean = true

  ) {}

}

class DataMarketCore {

  assets: Map<string, DataAsset> = new Map();

  accessTokens: Map<string, AccessToken> = new Map();

  tokenCounter = 0;

  registerAsset(

    from: Address,

    id: string,

    metadataHash: string,

    description: string,

    basePrice: bigint

  ): DataAsset {

    if (this.assets.has(id)) throw new Error(`Asset ${id} already exists`);

    const asset = new DataAsset(id, from, metadataHash, description, basePrice);

    this.assets.set(id, asset);

    return asset;

  }

  validateAccess(

    assetId: string,

    tokenId: string,

    consumer: Address,

    now: number

  ): boolean {

    const asset = this.assets.get(assetId);

    const token = this.accessTokens.get(tokenId);

    if (!asset || !token) return false;

    if (token.assetId !== assetId) return false;

    if (!token.consumer.equals(consumer)) return false;

    if (!token.isValid) return false;

    if (token.remainingUses <= 0) return false;

    if (now > token.expiresAt) return false;

    return true;

  }

  createAccessToken(

    assetId: string,

    consumer: Address,

    maxUses: number,

    now: number,

    duration: number,

    value: bigint

  ): AccessToken {

    const asset = this.assets.get(assetId);

    if (!asset) throw new Error('Asset not found');

    // 模拟链上检查：消费者支付的金额必须 >= 预估所需

    const required = asset.basePrice * BigInt(maxUses);

    if (value < required) throw new Error(`Payment insufficient: ${value} <${required}`);

    this.tokenCounter++;

    const tokenId = `TK-${assetId}-${this.tokenCounter}`;

    const token = new AccessToken(

      tokenId, assetId, consumer, maxUses, maxUses,

      now, now + duration

    );

    this.accessTokens.set(tokenId, token);

    return token;

  }

  consumeAccess(tokenId: string, now: number, consumer: Address): void {

    const token = this.accessTokens.get(tokenId);

    if (!token) throw new Error('Token not found');

    if (!token.isValid) throw new Error('Token already consumed or revoked');

    if (token.remainingUses <= 0) throw new Error('Token uses exhausted');

    if (now > token.expiresAt) throw new Error('Token expired');

    if (!token.consumer.equals(consumer)) throw new Error('Token ownership mismatch');

    // 原子扣减：剩余次数 -1，同时累加到资产持有者的收入

    const asset = this.assets.get(token.assetId)!;

    token.remainingUses--;

    asset.totalAccessCount++;

    asset.cumulativeRevenue += asset.basePrice;

    // 模拟：如果剩余次数为0则自动作废

    if (token.remainingUses === 0) {

      token.isValid = false;

    }

  }

}

// ======== 端到端演示 ========

const market = new DataMarketCore();

const alice = new Address('0xALICE');

const bob = new Address('0xBOB');

// 1. Alice 注册一个医学影像数据集

const dataset = market.registerAsset(

  alice,

  'MED-IMG-001',

  'QmHash123...',

  '匿名胸部 CT 扫描（10k 张）',

  1000n // 每次访问 1000 wei

);

// 2. Bob 购买 100 次访问额，支付 1000 * 100 = 100000 wei 价值

const token = market.createAccessToken(

  dataset.id, bob, 100, 1700000000, 86400, 100000n

);

// 3. Bob 使用 1 次

market.consumeAccess(token.tokenId, 1700000010, bob);

// 4. Alice 的收益自动累积

console.log(`Asset revenue: ${dataset.cumulativeRevenue} wei`); // 1000

console.log(`Remaining uses: ${token.remainingUses}`); // 99

console.log(`Valid: ${market.validateAccess(dataset.id, token.tokenId, bob, 1700000010)}`); // true

/**

 * 数据质押市场的智能合约逻辑

 * 数据提供者质押通证以证明真实性

 * 数据消费方面费并接收经确权的数据

 */

interface DataAsset {

  id: string;

  contentHash: string;      // H(data) 

  owner: string;

  price: bigint;

  accessPolicy: "buy" | "subscribe" | "compute-only"; // 仅计算而不泄露原始数据

}

interface DataMarket {

  listings: Map<string, DataAsset>;

  listData(asset: DataAsset): void {

    // 要求 owner 提交内容 Hash 而非原始数据

    // 避免所有者质量控制：假设必须拥有正确数据才能匹配 Hash

    this.listings.set(asset.id, asset);

  }

  accessData(

    buyer: string,

    dataId: string,

    payment: bigint,

    computeOnly: boolean,

  ): { commitment: string; redirectURL: string } {

    const asset = this.listings.get(dataId);

    if (asset.price > payment) throw new Error("Insufficient payment");

    // 只返回承诺（commitment）和离线转移路径

    // 真实数据不经过链上——避免 gas 和数据泄露

    return {

      commitment: `H(${dataId}:${buyer}:${Date.now()})`,

      redirectURL: `ipfs://${asset.contentHash}`,

    };

  }

}

// 数据市场核心不等式：

// 只有同时拥有正确原始数据 && 匹配 contentHash 的人，才能生成有效的 listing

// contentHash 是对数据的承诺

const sampleData: DataAsset = {

  id: "medical-imagery-0429",

  contentHash: "QmX2a...3f9", // IPFS 哈希

  owner: "0x1234...",

  price: 1000000000000000000n, // 1 ETH

  accessPolicy: "compute-only",

};

/**

 * 链上联邦学习协调：用智能合约替换可信聚合者

 */

interface LocalUpdate {

  participant: string;

  round: number;

  gradientHash: string;  // 不直接上链接度（太大），只上链 hash

  stake: bigint;         // 经济质押

}

interface AggregationContract {

  updates: Map<string, LocalUpdate[]>;

  rewards: Map<string, bigint>;

  submitUpdate(update: LocalUpdate, signature: string): void {

    // 验证：参与者签名、质押足够、轮次正确

    // 真正梯度通过 IPFS 传输（经济上链总不可能）

    this.updates.get(update.round)?.push(update);

  }

  finalizeRound(round: number, aggregatedHash: string, proof: string): void {

    // 聚合者在链下完成聚合，上链提交最终哈希和 TEE / zk 证明

    // 智能合约验证 proof 正确

    // 如果正确，解锁质押的奖励

    

    // 参与者奖励与他们 upload 的 hash 的 "数据量证明" 挂钩

    const roundUpdates = this.updates.get(round) || [];

    for (const u of roundUpdates) {

      // 简化的声誉 + 质押机制

      const base = u.stake; 

      this.rewards.set(u.participant, (this.rewards.get(u.participant) || 0n) + base);

    }

  }

}

/**

 * 定点数量化与模拟激活函数的 zk-circuit 兼容版本

 * 将浮点神经网络权重/激活量化到定点数空间

 */

interface FixedPointConfig {

  scale: number;       // 2^k scaling factor

  bitWidth: number;    // 总位宽

  isSigned: boolean;

}

class QuantizedNeuralNet {

  private weights: bigint[][][];  // [layer][neuron][input] 定点权重

  private scale: number;

  private fieldPrime: bigint = 21888242871839275222246405745257275088548364400416034343698204186575808495617n; // BN254

  constructor(weights: number[][][], config: FixedPointConfig) {

    this.scale = config.scale;

    this.weights = weights.map(layer =>

      layer.map(neuron =>

        neuron.map(w => this.toFixedPoint(w))

      )

    );

  }

  toFixedPoint(x: number): bigint {

    // x as Q_k: original value * scale, rounded, modulo field prime

    return BigInt(Math.round(x * this.scale)) % this.fieldPrime;

  }

  fromFixedPoint(x: bigint): number {

    // 必须有符号处理，这里简化

    const halfP = this.fieldPrime / 2n;

    const signed = x >= halfP ? x - this.fieldPrime : x;

    return Number(signed) / this.scale;

  }

  /**

   * 电路兼容的 ReLU：y = max(0, x)

   * 在 zk 电路中实现为三路约束：

   *   (1) y >= 0

   *   (2) y - x >= 0

   *   (3) y * (y - x) = 0

   */

  circuitReLU(x: bigint): bigint {

    // 直接模拟：实际电路中用约束表示

    return x > this.fieldPrime / 2n ? 0n : x; // 简化 unsigned 版本

  }

  // 前向传播（量子化 + 激活 = 定点数）

  forward(input: number[]): bigint[] {

    let current = input.map(x => this.toFixedPoint(x));

    for (const layer of this.weights) {

      const next = layer.map(neuron => {

        const sum = neuron.reduce((s, w, i) => {

          const prod = (w * current[i]) % this.fieldPrime;

          // 缩放回燃：由于 w 和 x 都是 scaled 的，乘积有 scale^2

          // 需要除以 scale 进行重规范化

          const rescaled = prod / BigInt(this.scale);

          return (s + rescaled) % this.fieldPrime;

        }, 0n);

        return this.circuitReLU(sum);

      });

      current = next;

    }

    return current;

  }

}

// 安全量化限制：

// scale^2 * max(|w|) * max(|x|) < fieldPrime/2

const net = new QuantizedNeuralNet(

  [ // 2层, 3-2-1

    [[1.5, -0.5, 0.3], [-0.2, 1.0, -0.1]],       // 层1: 3->2

    [[0.8, -1.2]],                                    // 层2: 2->1

  ],

  { scale: 1000, bitWidth: 16, isSigned: true }

);

console.log("定点前向:", net.forward([2.0, 1.0, -0.5]).map(o => net.fromFixedPoint(o)));

// 输出与浮点版本接近（量化误差范围内）

/**

 * 链上 AI 代理的会话密钥模型

 * 用户通过 session key 授予代理有限权限

 */

interface SessionKey {

  owner: string;            // 主账户

  agent: string;            // AI 代理地址

  expiry: number;           // 过期时间戳

  spendingCap: bigint;      // 最大可花金额

  allowedContracts: string[]; // 允许交互的合约白名单

  signature: string;        // 主人的 ECDSA 签名

}

interface SessionContract {

  sessions: Map<string, SessionKey>;

  spent: Map<string, bigint>;

  authorize(session: SessionKey): void {

    // 验证 owner 签名

    // 检查 session 的有效性

    this.sessions.set(session.agent, session);

    this.spent.set(session.agent, 0n);

  }

  execute(

    agent: string,

    callData: string,

    target: string,

  ): void {

    const s = this.sessions.get(agent);

    if (!s || Date.now() > s.expiry) throw new Error("Session expired");

    if (!s.allowedContracts.includes(target)) throw new Error("Not allowed");

    

    const callValue = 0n; // 简化

    const newSpent = (this.spent.get(agent) || 0n) + callValue;

    if (newSpent > s.spendingCap) throw new Error("Over spending cap");

    

    this.spent.set(agent, newSpent);

    // 执行 call...

  }

}

/**

 * 量子威胁时间线评估模型

 * 评估不同密码学基元在量子计算下的预计"安全期"

 */

interface Cryptosystem {

  name: string;

  classicalSecurity: number;  // 经典安全位数

  quantumResistance: "broken" | "halved" | "intact";

  threatModel: string;

  migrationUrgency: "critical" | "high" | "medium" | "low";

}

function assessQuantumThreat(cs: Cryptosystem): {

  safeYears: number;       // 预计安全年限

  recommendedAction: string;

} {

  const threatYears = {

    "critical": { min: 15, max: 25, action: "立即开始迁移，历史数据暴露不可逆" },

    "high": { min: 20, max: 35, action: "制定迁移路线图，预留充足时间" },

    "medium": { min: 30, max: 50, action: "关注标准进展，准备基础设施" },

    "low": { min: 50, max: 100, action: "持续监控，无需立即行动" },

  };

  

  const urgency = threatYears[cs.migrationUrgency];

  return {

    safeYears: Math.round((urgency.min + urgency.max) / 2),

    recommendedAction: urgency.action,

  };

}

const systems: Cryptosystem[] = [

  { name: "ECDSA (secp256k1)", classicalSecurity: 128, quantumResistance: "broken", threatModel: "Shor 算法多项式破解", migrationUrgency: "critical" },

  { name: "RSA-2048", classicalSecurity: 112, quantumResistance: "broken", threatModel: "Shor 多项式破解", migrationUrgency: "critical" },

  { name: "SHA-256 哈希", classicalSecurity: 256, quantumResistance: "halved", threatModel: "Grover 二次加速", migrationUrgency: "medium" },

  { name: "EdDSA (Ed25519)", classicalSecurity: 128, quantumResistance: "broken", threatModel: "Shor 变种", migrationUrgency: "critical" },

  { name: "ECC 密钥交换 (TLS)", classicalSecurity: 128, quantumResistance: "broken", threatModel: "Shor 破解", migrationUrgency: "critical" },

  { name: "AES-256-GCM", classicalSecurity: 256, quantumResistance: "halved", threatModel: "Grover 降至 128 位", migrationUrgency: "medium" },

  { name: "zk-SNARK (配对)", classicalSecurity: 128, quantumResistance: "broken", threatModel: "配对被量子破解", migrationUrgency: "high" },

  { name: "zk-STARK (哈希)", classicalSecurity: 128, quantumResistance: "intact", threatModel: "哈希抗碰撞假设", migrationUrgency: "low" },

];

console.log("量子威胁评估");

console.log("系统 | 经典安全 | 量子状态 | 安全期 | 建议");

for (const s of systems) {

  const a = assessQuantumThreat(s);

  console.log(`${s.name.padEnd(25)} |${s.classicalSecurity.toString().padStart(4)} | ${s.quantumResistance.padStart(8)} |${a.safeYears.toString().padStart(5)}年 | ${a.recommendedAction}`);

}

/**

 * 格密码学核心操作简化模拟

 * 展示 Module-LWE 的矩阵-向量运算和短向量检查

 */

function modQ(n: bigint, Q: bigint): bigint {

  return ((n % Q) + Q) % Q;

}

function vectorAdd(a: bigint[], b: bigint[], Q: bigint): bigint[] {

  return a.map((v, i) => modQ(v + b[i], Q));

}

function matrixVectorMul(M: bigint[][], v: bigint[], Q: bigint): bigint[] {

  return M.map(row => modQ(row.reduce((s, mij, j) => s + mij * v[j], 0n), Q));

}

/**

 * 小模数示例：真实 Dilithium 使用 n=256, q=8380417, k=6, l=5

 * 这里用 n=4 演示核心数学

 */

interface LWEKey {

  A: bigint[][];    // 公开矩阵

  s: bigint[];      // 短秘密向量

  b: bigint[];      // 公开: A*s + e

  q: bigint;

}

function generateLWEKey(n: number, q: bigint): LWEKey {

  // 生成随机短秘密 s（真实中来自中心化二项分布）

  const s = Array.from({ length: n }, () => modQ(BigInt(Math.floor(Math.random() * 3) - 1), q));

  // 随机矩阵 A

  const A = Array.from({ length: n }, () =>

    Array.from({ length: n }, () => modQ(BigInt(Math.floor(Math.random() * Number(q))), q))

  );

  // 小噪声 e

  const e = Array.from({ length: n }, () => modQ(BigInt(Math.floor(Math.random() * 3) - 1), q));

  const b = vectorAdd(matrixVectorMul(A, s, q), e, q);

  return { A, s, b, q };

}

function lweSampleEncrypt(

  key: LWEKey,

  messageBit: 0 | 1,

  errorBound: bigint,

): { u: bigint[]; v: bigint } {

  // 加密：随机短向量 r, 计算 u = A^T*r, v = b^T*r + m*q/2 + e'

  const r = Array.from({ length: key.s.length }, () => modQ(BigInt(Math.floor(Math.random() * 3) - 1), key.q));

  const u = matrixVectorMul(key.A.map((_, i) => key.A.map(row => row[i]), key.q), r, key.q);

  const v = modQ(

    u.reduce((s, ui, i) => s + ui * r[i], 0n) + (messageBit === 1 ? key.q / 2n : 0n),

    key.q,

  );

  return { u, v };

}

function lweSampleDecrypt(

  key: LWEKey,

  cipher: { u: bigint[]; v: bigint },

): 0 | 1 {

  const sTu = key.s.reduce((s, si, i) => s + si * cipher.u[i], 0n);

  const diff = modQ(cipher.v - sTu, key.q);

  // 如果 v ≈ q/2 (消息=1), diff ≈ q/2; 否则 ≈ 0

  return Number(diff > key.q / 4n && diff < (3n * key.q) / 4n) as 0 | 1;

}

// --- 演示 ---

const Q_demo = 17n;  // 小质数便于观察

const n4 = 4;

const key4 = generateLWEKey(n4, Q_demo);

const enc0 = lweSampleEncrypt(key4, 0, 1n);

const enc1 = lweSampleEncrypt(key4, 1, 1n);

console.log("bit=0 解密:", lweSampleDecrypt(key4, enc0)); // 应输出 0

console.log("bit=1 解密:", lweSampleDecrypt(key4, enc1)); // 应输出 1

console.log("秘密向量 s:", key4.s); // 短向量，值小

console.log("公钥 b = A*s+e mod 17:", key4.b); // 表面随机

/**

 * 迁移准备度评分模型

 */

function assessMigrationReadiness(chain: {

  supportsAccountAbstraction: boolean;

  governanceAgility: "high" | "medium" | "low";

  hasPQCPrecompile: boolean;

  userBaseSize: number;  // 百万级

  avgTxPerDay: number;

}): {

  readiness: number;  // 0-100

  estimatedYears: number;

  biggestRisk: string;

} {

  let score = 0;

  if (chain.supportsAccountAbstraction) score += 30;

  if (chain.hasPQCPrecompile) score += 20;

  score += { high: 20, medium: 10, low: 0 }[chain.governanceAgility];

  score += Math.min(30, chain.userBaseSize * 3); // 小链反而更快

  

  return {

    readiness: score,

    estimatedYears: score > 70 ? 5 : score > 40 ? 10 : 15,

    biggestRisk: chain.userBaseSize > 100 ? "用户惰性迁移" : "治理碎片化",

  };

}

console.log(assessMigrationReadiness({

  supportsAccountAbstraction: true,

  governanceAgility: "medium",

  hasPQCPrecompile: false,

  userBaseSize: 5, // 5000 万

  avgTxPerDay: 1000000,

}));

// 预期: 准备度 ~45, 预计 10 年, 最大风险: 用户惰性迁移