// 质押激励引擎：从零实现（纯 TS + BigInt，无外部库）
// 计算：每 epoch 按质押份额分配奖励；提前解锁需罚没部分本金
class StakingEngine {
  epochDurationSeconds: bigint; // 每个 epoch 时长
  totalStaked: bigint;          // 当前总质押额
  rewardPerEpoch: bigint;       // 每 epoch 奖励总量（协议补贴）
  positions: Map<string, { amount: bigint; lockUntil: bigint; entered: bigint }>;

  constructor(epochDur: bigint, reward: bigint) {
    this.epochDurationSeconds = epochDur;
    this.totalStaked = 0n;
    this.rewardPerEpoch = reward;
    this.positions = new Map();
  }

  stake(user: string, amount: bigint, now: bigint, lockEpochs: bigint): void {
    const until = now + lockEpochs * this.epochDurationSeconds;
    const pos = this.positions.get(user);
    if (pos) {
      pos.amount += amount;
      pos.lockUntil = pos.lockUntil > until ? pos.lockUntil : until;
    } else {
      this.positions.set(user, { amount, lockUntil: until, entered: now });
    }
    this.totalStaked += amount;
  }

  // 每 epoch 由协议触发：奖励按各质押者份额分配
  distributeRewards(now: bigint): void {
    if (this.totalStaked === 0n) return;
    for (const [user, pos] of this.positions) {
      const share = (pos.amount * this.rewardPerEpoch) / this.totalStaked;
      pos.amount += share;            // 复利：奖励自动再质押
      this.totalStaked += share;
    }
  }

  // 提前解冻：罚没 penaltyBps（万分比）
  unstake(user: string, now: bigint, penaltyBps: bigint): bigint {
    const pos = this.positions.get(user);
    if (!pos) throw new Error("无质押");
    let payout = pos.amount;
    if (now < pos.lockUntil) {
      const penalty = (payout * penaltyBps) / 10000n; // 提前赎回罚金（部分销毁）
      payout -= penalty;
    }
    this.totalStaked -= pos.amount;
    this.positions.delete(user);
    return payout; // 返回实际可提取金额
  }
}

// 验证：2 个质押者 share epochs 奖励（整数单位，简化演示）
// 注意：distributeRewards 按 Map 插入序遍历，A 先分后 totalStaked 增大，
//       故 B 的份额分母变大（2000→2050），B 实得 1048（顺序复利特性）
const s = new StakingEngine(1n, 100n);
s.stake("0xA", 1000n, 0n, 10n);   // A 质押 1000，锁 10 epoch
s.stake("0xB", 1000n, 0n, 1n);    // B 质押 1000，锁 1 epoch
s.distributeRewards(1n);          // A 先分 50，B 后分 48（分母变大）
const bEarly = s.unstake("0xB", 2n, 500n); // now=2 已过 B 锁定期(1)，不罚没
console.log("B 实得 =", bEarly.toString(), "（A 先分→B 份额减少，1048 符合顺序复利）");
console.log("锁定期内解冻示例(罚5%)：", (1050n * 9500n / 10000n).toString()); // 997