《双峰：回归》与时间扭曲：25年作为智能合约锁仓期

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract TimeLockVault is Ownable, ReentrancyGuard {
    struct Lockup {
        uint256 id;
        address beneficiary;
        uint256 amount;
        uint256 startTime;
        uint256 duration;
        uint256 cliffDuration;
        bool isRevocable;
        bool isRevoked;
        bool isFullyUnlocked;
        uint256 totalClaimed;
    }
    
    struct VestingSchedule {
        uint256 scheduleId;
        address beneficiary;
        uint256 totalAmount;
        uint256 startTime;
        uint256 duration;
        uint256 cliffDuration;
        uint256 releasedAmount;
        bool isActive;
    }
    
    mapping(uint256 => Lockup) public lockups;
    mapping(uint256 => VestingSchedule) public vestingSchedules;
    
    uint256 public lockupCount;
    uint256 public scheduleCount;
    
    event LockupCreated(uint256 indexed id, address indexed beneficiary, uint256 amount, uint256 duration);
    event TokensClaimed(uint256 indexed id, address indexed beneficiary, uint256 amount);
    event LockupRevoked(uint256 indexed id);
    event VestingCreated(uint256 indexed scheduleId, address indexed beneficiary, uint256 amount);
    
    function createLockup(
        address _beneficiary,
        uint256 _durationDays,
        uint256 _cliffDays,
        bool _revocable
    ) external payable returns (uint256) {
        require(msg.value > 0, "Amount must be > 0");
        
        lockupCount++;
        lockups[lockupCount] = Lockup({
            id: lockupCount,
            beneficiary: _beneficiary,
            amount: msg.value,
            startTime: block.timestamp,
            duration: _durationDays * 1 days,
            cliffDuration: _cliffDays * 1 days,
            isRevocable: _revocable,
            isRevoked: false,
            isFullyUnlocked: false,
            totalClaimed: 0
        });
        
        emit LockupCreated(lockupCount, _beneficiary, msg.value, _durationDays);
        return lockupCount;
    }
    
    function claimTokens(uint256 _lockupId) external nonReentrant {
        Lockup storage lockup = lockups[_lockupId];
        require(msg.sender == lockup.beneficiary, "Not beneficiary");
        require(!lockup.isRevoked, "Lockup revoked");
        
        uint256 claimable = getClaimableAmount(_lockupId);
        require(claimable > 0, "Nothing to claim");
        
        lockup.totalClaimed += claimable;
        payable(msg.sender).transfer(claimable);
        
        if (lockup.totalClaimed >= lockup.amount) {
            lockup.isFullyUnlocked = true;
        }
        
        emit TokensClaimed(_lockupId, msg.sender, claimable);
    }
    
    function getClaimableAmount(uint256 _lockupId) public view returns (uint256) {
        Lockup storage lockup = lockups[_lockupId];
        
        if (block.timestamp < lockup.startTime + lockup.cliffDuration) {
            return 0;
        }
        
        uint256 elapsed = block.timestamp - lockup.startTime;
        if (elapsed >= lockup.duration) {
            return lockup.amount - lockup.totalClaimed;
        }
        
        uint256 vestedAmount = (lockup.amount * elapsed) / lockup.duration;
        return vestedAmount - lockup.totalClaimed;
    }
    
    function revokeLockup(uint256 _lockupId) external onlyOwner {
        Lockup storage lockup = lockups[_lockupId];
        require(lockup.isRevocable, "Not revocable");
        require(!lockup.isRevoked, "Already revoked");
        
        lockup.isRevoked = true;
        uint256 remaining = lockup.amount - lockup.totalClaimed;
        payable(owner()).transfer(remaining);
        
        emit LockupRevoked(_lockupId);
    }
    
    function createVestingSchedule(
        address _beneficiary,
        uint256 _totalAmount,
        uint256 _durationDays,
        uint256 _cliffDays
    ) external payable returns (uint256) {
        require(msg.value >= _totalAmount, "Insufficient amount");
        
        scheduleCount++;
        vestingSchedules[scheduleCount] = VestingSchedule({
            scheduleId: scheduleCount,
            beneficiary: _beneficiary,
            totalAmount: _totalAmount,
            startTime: block.timestamp,
            duration: _durationDays * 1 days,
            cliffDuration: _cliffDays * 1 days,
            releasedAmount: 0,
            isActive: true
        });
        
        emit VestingCreated(scheduleCount, _beneficiary, _totalAmount);
        return scheduleCount;
    }
    
    function getLockupInfo(uint256 _lockupId)
        external view returns (Lockup memory)
    {
        return lockups[_lockupId];
    }
}

import numpy as np
import pandas as pd
from typing import Dict, List
import matplotlib.pyplot as plt

class TimeLockAnalyzer:
    def __init__(self):
        self.lockups = []
        
    def generate_synthetic_data(self, n: int = 100):
        np.random.seed(42)
        durations = [90, 180, 365, 730, 1825, 9125]  # 91天到25年
        
        for i in range(n):
            lockup = {
                'id': i + 1,
                'duration': np.random.choice(durations),
                'amount': np.random.exponential(100000),
                'cliff': np.random.choice([0, 30, 90, 180]),
                'is_vested': np.random.random() > 0.3,
                'claim_rate': np.random.uniform(0, 1)
            }
            self.lockups.append(lockup)
    
    def analyze_time_effects(self) -> Dict:
        df = pd.DataFrame(self.lockups)
        return {
            'total_lockups': len(self.lockups),
            'total_value': df['amount'].sum(),
            'avg_duration': df['duration'].mean(),
            'avg_claim_rate': df['claim_rate'].mean(),
            'duration_buckets': pd.cut(df['duration'], bins=5).value_counts().to_dict()
        }
    
    def generate_report(self) -> str:
        eff = self.analyze_time_effects()
        report = f"""
=== 时间锁分析 ===

总锁仓数: {eff['total_lockups']}
总锁仓价值: ${eff['total_value']:,.2f}
平均锁仓时长: {eff['avg_duration']:.0f} 天
平均领取率: {eff['avg_claim_rate']:.1%}
锁仓时长分布: {eff['duration_buckets']}
"""
        return report


if __name__ == "__main__":
    analyzer = TimeLockAnalyzer()
    analyzer.generate_synthetic_data(100)
    report = analyzer.generate_report()
    print(report)

class TimeLockManager {
    constructor(providerUrl, contractAddress) {
        this.web3 = new Web3(providerUrl);
        this.contract = new this.web3.eth.Contract([], contractAddress);
    }
    
    async createLockup(beneficiary, durationDays, cliffDays, revocable) {
        return await this.contract.methods
            .createLockup(beneficiary, durationDays, cliffDays, revocable)
            .send({ from: this.userAccount, value: this.web3.utils.toWei('1', 'ether') });
    }
    
    async claimTokens(lockupId) {
        return await this.contract.methods
            .claimTokens(lockupId)
            .send({ from: this.userAccount });
    }
    
    async getClaimableAmount(lockupId) {
        return await this.contract.methods.getClaimableAmount(lockupId).call();
    }
}

const manager = new TimeLockManager('https://mainnet.infura.io/v3/YOUR_ID', '0x...');