链下数据与预言机

// 不安全: 中心化预言机
contract CentralizedOracle {
    address public oracle;
    mapping(string => uint256) public prices;

    // 只有预言机可以更新价格
    function updatePrice(string memory symbol, uint256 price) external {
        require(msg.sender == oracle, "Not oracle");
        prices[symbol] = price;
    }

    // 问题:
    // 1. 如果oracle账户被盗，攻击者可以操纵价格
    // 2. oracle下线，价格无法更新
    // 3. oracle作恶，提供虚假数据
}

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

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract PriceConsumer {
    AggregatorV3Interface internal priceFeed;

    /**
     * Network: Ethereum Mainnet
     * Aggregator: ETH/USD
     * Address: 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419
     */
    constructor() {
        priceFeed = AggregatorV3Interface(
            0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419
        );
    }

    /**
     * 获取最新价格
     */
    function getLatestPrice() public view returns (int) {
        (
            uint80 roundId,
            int price,
            uint startedAt,
            uint updatedAt,
            uint80 answeredInRound
        ) = priceFeed.latestRoundData();

        // price有8位小数
        // 例如: 2000.12345678 USD = 200012345678
        return price;
    }

    /**
     * 获取价格(带小数点)
     */
    function getLatestPriceWithDecimals() public view returns (uint256) {
        (, int price, , ,) = priceFeed.latestRoundData();
        uint8 decimals = priceFeed.decimals();

        // 转换为18位小数
        return uint256(price) * 10 ** (18 - decimals);
    }

    /**
     * 获取历史价格
     */
    function getHistoricalPrice(uint80 roundId) public view returns (int) {
        (
            uint80 id,
            int price,
            uint startedAt,
            uint updatedAt,
            uint80 answeredInRound
        ) = priceFeed.getRoundData(roundId);

        return price;
    }
}

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

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract SimpleLending {
    AggregatorV3Interface public priceFeed;

    // 抵押品(ETH) -> 借款(USDC)
    struct Position {
        uint256 collateral; // ETH数量
        uint256 debt;       // USDC数量
    }

    mapping(address => Position) public positions;

    // 抵押率要求(150%)
    uint256 public constant COLLATERAL_RATIO = 150;

    // 清算奖励(10%)
    uint256 public constant LIQUIDATION_BONUS = 10;

    event Deposited(address indexed user, uint256 amount);
    event Borrowed(address indexed user, uint256 amount);
    event Liquidated(address indexed user, address indexed liquidator, uint256 amount);

    constructor(address _priceFeed) {
        priceFeed = AggregatorV3Interface(_priceFeed);
    }

    // 存入ETH作为抵押品
    function deposit() external payable {
        require(msg.value > 0, "Cannot deposit 0");
        positions[msg.sender].collateral += msg.value;
        emit Deposited(msg.sender, msg.value);
    }

    // 借出USDC
    function borrow(uint256 usdcAmount) external {
        Position storage position = positions[msg.sender];
        require(position.collateral > 0, "No collateral");

        // 检查抵押率
        uint256 maxBorrow = getMaxBorrow(msg.sender);
        require(position.debt + usdcAmount <= maxBorrow, "Insufficient collateral");

        position.debt += usdcAmount;

        // 实际应该转移USDC给用户
        // IERC20(usdc).transfer(msg.sender, usdcAmount);

        emit Borrowed(msg.sender, usdcAmount);
    }

    // 计算最大可借金额
    function getMaxBorrow(address user) public view returns (uint256) {
        Position memory position = positions[user];

        // 获取ETH价格
        (, int price, , ,) = priceFeed.latestRoundData();
        require(price > 0, "Invalid price");

        // ETH价格(8位小数) * ETH数量(18位小数) / 抵押率
        // 结果单位: USDC(6位小数)
        uint256 collateralValue = uint256(price) * position.collateral / 1e8; // USD value
        uint256 maxBorrow = collateralValue * 100 / COLLATERAL_RATIO / 1e12; // Convert to USDC decimals

        if (maxBorrow > position.debt) {
            return maxBorrow - position.debt;
        }
        return 0;
    }

    // 检查是否可被清算
    function isLiquidatable(address user) public view returns (bool) {
        Position memory position = positions[user];
        if (position.debt == 0) return false;

        // 当前抵押率
        (, int price, , ,) = priceFeed.latestRoundData();
        uint256 collateralValue = uint256(price) * position.collateral / 1e8;
        uint256 currentRatio = collateralValue * 100 / (position.debt * 1e12);

        // 抵押率低于150%可被清算
        return currentRatio < COLLATERAL_RATIO;
    }

    // 清算
    function liquidate(address user) external {
        require(isLiquidatable(user), "Cannot liquidate");

        Position storage position = positions[user];
        uint256 debt = position.debt;
        uint256 collateral = position.collateral;

        // 清空仓位
        position.debt = 0;
        position.collateral = 0;

        // 计算清算奖励
        (, int price, , ,) = priceFeed.latestRoundData();
        uint256 debtInEth = debt * 1e12 * 1e8 / uint256(price);
        uint256 bonus = debtInEth * LIQUIDATION_BONUS / 100;
        uint256 totalPayment = debtInEth + bonus;

        // 转移抵押品给清算者
        payable(msg.sender).transfer(totalPayment);

        // 剩余抵押品返还给用户
        if (collateral > totalPayment) {
            payable(user).transfer(collateral - totalPayment);
        }

        emit Liquidated(user, msg.sender, debt);
    }
}

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

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract MultiSourcePriceOracle {
    AggregatorV3Interface[] public priceFeeds;

    // 价格偏差阈值(5%)
    uint256 public constant MAX_DEVIATION = 5;

    constructor(address[] memory _priceFeeds) {
        for (uint i = 0; i < _priceFeeds.length; i++) {
            priceFeeds.push(AggregatorV3Interface(_priceFeeds[i]));
        }
    }

    // 获取聚合价格(中位数)
    function getAggregatedPrice() public view returns (uint256) {
        require(priceFeeds.length > 0, "No price feeds");

        uint256[] memory prices = new uint256[](priceFeeds.length);

        // 获取所有价格
        for (uint i = 0; i < priceFeeds.length; i++) {
            (, int price, , uint updatedAt,) = priceFeeds[i].latestRoundData();

            // 检查价格更新时间(不超过1小时)
            require(block.timestamp - updatedAt < 3600, "Stale price");
            require(price > 0, "Invalid price");

            prices[i] = uint256(price);
        }

        // 计算中位数
        uint256 median = getMedian(prices);

        // 检查所有价格与中位数的偏差
        for (uint i = 0; i < prices.length; i++) {
            uint256 deviation = prices[i] > median
                ? (prices[i] - median) * 100 / median
                : (median - prices[i]) * 100 / median;

            require(deviation <= MAX_DEVIATION, "Price deviation too large");
        }

        return median;
    }

    // 计算中位数
    function getMedian(uint256[] memory array) internal pure returns (uint256) {
        // 排序
        for (uint i = 0; i < array.length; i++) {
            for (uint j = i + 1; j < array.length; j++) {
                if (array[i] > array[j]) {
                    uint256 temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }

        // 返回中位数
        if (array.length % 2 == 0) {
            return (array[array.length / 2 - 1] + array[array.length / 2]) / 2;
        } else {
            return array[array.length / 2];
        }
    }
}

// 不安全: 矿工可以操纵
function unsafeRandom() public view returns (uint256) {
    return uint256(keccak256(abi.encodePacked(
        block.timestamp,
        block.difficulty,
        msg.sender
    )));
}

// 问题:
// 1. 矿工可以选择性地包含/排除交易
// 2. 矿工可以操纵block.timestamp(±15秒)
// 3. 可预测(攻击者可以在同一个区块内模拟)

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

import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";

contract RandomNumberConsumer is VRFConsumerBaseV2 {
    VRFCoordinatorV2Interface COORDINATOR;

    // VRF配置
    uint64 subscriptionId;
    bytes32 keyHash;
    uint32 callbackGasLimit = 200000;
    uint16 requestConfirmations = 3;
    uint32 numWords = 1; // 请求的随机数数量

    // 请求ID -> 用户地址
    mapping(uint256 => address) public requestIdToSender;

    // 用户地址 -> 随机数
    mapping(address => uint256) public randomResults;

    event RandomRequested(uint256 requestId, address requester);
    event RandomFulfilled(uint256 requestId, uint256 randomNumber);

    /**
     * Network: Ethereum Sepolia Testnet
     * VRF Coordinator: 0x8103B0A8A00be2DDC778e6e7eaa21791Cd364625
     * Key Hash: 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c
     */
    constructor(uint64 _subscriptionId)
        VRFConsumerBaseV2(0x8103B0A8A00be2DDC778e6e7eaa21791Cd364625)
    {
        COORDINATOR = VRFCoordinatorV2Interface(
            0x8103B0A8A00be2DDC778e6e7eaa21791Cd364625
        );
        subscriptionId = _subscriptionId;
        keyHash = 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c;
    }

    // 请求随机数
    function requestRandomWords() external returns (uint256 requestId) {
        requestId = COORDINATOR.requestRandomWords(
            keyHash,
            subscriptionId,
            requestConfirmations,
            callbackGasLimit,
            numWords
        );

        requestIdToSender[requestId] = msg.sender;

        emit RandomRequested(requestId, msg.sender);
    }

    // VRF回调函数
    function fulfillRandomWords(
        uint256 requestId,
        uint256[] memory randomWords
    ) internal override {
        address sender = requestIdToSender[requestId];
        randomResults[sender] = randomWords[0];

        emit RandomFulfilled(requestId, randomWords[0]);
    }

    // 获取随机数
    function getRandomResult(address user) external view returns (uint256) {
        return randomResults[user];
    }
}

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

import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";

contract Lottery is VRFConsumerBaseV2 {
    VRFCoordinatorV2Interface COORDINATOR;

    uint64 subscriptionId;
    bytes32 keyHash;
    uint32 callbackGasLimit = 300000;
    uint16 requestConfirmations = 3;
    uint32 numWords = 1;

    address public owner;
    address[] public players;
    address public recentWinner;

    enum LotteryState { OPEN, CALCULATING }
    LotteryState public lotteryState;

    uint256 public entranceFee = 0.01 ether;

    event LotteryEntered(address indexed player);
    event WinnerPicked(address indexed winner, uint256 amount);

    constructor(uint64 _subscriptionId, address _vrfCoordinator, bytes32 _keyHash)
        VRFConsumerBaseV2(_vrfCoordinator)
    {
        owner = msg.sender;
        COORDINATOR = VRFCoordinatorV2Interface(_vrfCoordinator);
        subscriptionId = _subscriptionId;
        keyHash = _keyHash;
        lotteryState = LotteryState.OPEN;
    }

    // 参与抽奖
    function enterLottery() external payable {
        require(lotteryState == LotteryState.OPEN, "Lottery not open");
        require(msg.value >= entranceFee, "Not enough ETH");

        players.push(msg.sender);

        emit LotteryEntered(msg.sender);
    }

    // 开始抽奖(只有owner可以调用)
    function pickWinner() external {
        require(msg.sender == owner, "Not owner");
        require(lotteryState == LotteryState.OPEN, "Already calculating");
        require(players.length > 0, "No players");

        lotteryState = LotteryState.CALCULATING;

        // 请求随机数
        COORDINATOR.requestRandomWords(
            keyHash,
            subscriptionId,
            requestConfirmations,
            callbackGasLimit,
            numWords
        );
    }

    // VRF回调
    function fulfillRandomWords(
        uint256 /* requestId */,
        uint256[] memory randomWords
    ) internal override {
        // 选择获奖者
        uint256 indexOfWinner = randomWords[0] % players.length;
        address winner = players[indexOfWinner];
        recentWinner = winner;

        // 转账奖金
        uint256 prize = address(this).balance;
        (bool success, ) = winner.call{value: prize}("");
        require(success, "Transfer failed");

        // 重置
        players = new address[](0);
        lotteryState = LotteryState.OPEN;

        emit WinnerPicked(winner, prize);
    }

    // 查询参与者数量
    function getNumberOfPlayers() external view returns (uint256) {
        return players.length;
    }

    // 查询奖池金额
    function getPrizePool() external view returns (uint256) {
        return address(this).balance;
    }
}

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

import "@chainlink/contracts/src/v0.8/AutomationCompatible.sol";

contract AutoLiquidation is AutomationCompatibleInterface {
    address[] public positions;
    mapping(address => Position) public userPositions;

    struct Position {
        uint256 collateral;
        uint256 debt;
        bool active;
    }

    // Chainlink Automation调用此函数检查是否需要执行
    function checkUpkeep(bytes calldata /* checkData */)
        external
        view
        override
        returns (bool upkeepNeeded, bytes memory performData)
    {
        // 查找需要清算的仓位
        address[] memory toLiquidate = new address[](positions.length);
        uint256 count = 0;

        for (uint i = 0; i < positions.length; i++) {
            address user = positions[i];
            if (isLiquidatable(user)) {
                toLiquidate[count] = user;
                count++;
            }
        }

        if (count > 0) {
            // 返回需要清算的地址列表
            address[] memory result = new address[](count);
            for (uint i = 0; i < count; i++) {
                result[i] = toLiquidate[i];
            }

            upkeepNeeded = true;
            performData = abi.encode(result);
        } else {
            upkeepNeeded = false;
        }
    }

    // Chainlink Automation调用此函数执行任务
    function performUpkeep(bytes calldata performData) external override {
        address[] memory toLiquidate = abi.decode(performData, (address[]));

        for (uint i = 0; i < toLiquidate.length; i++) {
            if (isLiquidatable(toLiquidate[i])) {
                liquidate(toLiquidate[i]);
            }
        }
    }

    // 检查是否可清算
    function isLiquidatable(address user) public view returns (bool) {
        Position memory pos = userPositions[user];
        if (!pos.active || pos.debt == 0) return false;

        // 简化: 假设抵押率低于150%可清算
        return pos.collateral * 100 / pos.debt < 150;
    }

    // 清算
    function liquidate(address user) internal {
        Position storage pos = userPositions[user];
        pos.active = false;
        // 清算逻辑...
    }

    // 其他函数...
}

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

import "@chainlink/contracts/src/v0.8/functions/FunctionsClient.sol";
import "@chainlink/contracts/src/v0.8/ConfirmedOwner.sol";

contract WeatherInsurance is FunctionsClient, ConfirmedOwner {
    using Functions for Functions.Request;

    bytes32 public latestRequestId;
    bytes public latestResponse;
    bytes public latestError;

    event ResponseReceived(bytes32 indexed requestId, bytes response, bytes err);

    constructor(address oracle) FunctionsClient(oracle) ConfirmedOwner(msg.sender) {}

    // JavaScript代码(在Chainlink节点上执行)
    string constant source =
        "const location = args[0];"
        "const apiKey = secrets.apiKey;"
        "const url = `https://api.weather.com/v3/wx/conditions/current?location=${location}&apiKey=${apiKey}`;"
        "const response = await Functions.makeHttpRequest({ url });"
        "if (response.error) { throw Error('Request failed'); }"
        "const temp = response.data.temperature;"
        "return Functions.encodeUint256(temp * 100);"; // 返回温度*100

    // 发起请求
    function requestWeatherData(
        string memory location,
        uint64 subscriptionId,
        uint32 gasLimit
    ) public onlyOwner returns (bytes32) {
        Functions.Request memory req;
        req.initializeRequestForInlineJavaScript(source);

        string[] memory args = new string[](1);
        args[0] = location;
        req.setArgs(args);

        latestRequestId = _sendRequest(
            req.encodeCBOR(),
            subscriptionId,
            gasLimit,
            0x66756e2d6574682d6d61696e6e65742d31000000000000 // jobId
        );

        return latestRequestId;
    }

    // 接收响应
    function fulfillRequest(
        bytes32 requestId,
        bytes memory response,
        bytes memory err
    ) internal override {
        latestResponse = response;
        latestError = err;

        emit ResponseReceived(requestId, response, err);

        // 解码温度
        uint256 temp = abi.decode(response, (uint256));

        // 如果温度低于0度,触发保险赔付
        if (temp < 0) {
            // 执行赔付逻辑
            payInsurance();
        }
    }

    function payInsurance() internal {
        // 赔付逻辑
    }
}

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

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract PriceBet {
    AggregatorV3Interface public priceFeed;

    struct Bet {
        address player;
        uint256 amount;
        int targetPrice;
        uint256 deadline;
        bool settled;
        bool won;
    }

    Bet[] public bets;

    event BetPlaced(
        uint256 indexed betId,
        address indexed player,
        int targetPrice,
        uint256 amount,
        uint256 deadline
    );

    event BetSettled(uint256 indexed betId, bool won);

    constructor(address _priceFeed) {
        priceFeed = AggregatorV3Interface(_priceFeed);
    }

    // 下注: 预测ETH价格
    function placeBet(int targetPrice, uint256 durationInHours) external payable {
        require(msg.value > 0, "Bet amount must be positive");
        require(durationInHours > 0 && durationInHours <= 24, "Invalid duration");

        uint256 deadline = block.timestamp + durationInHours * 1 hours;

        bets.push(Bet({
            player: msg.sender,
            amount: msg.value,
            targetPrice: targetPrice,
            deadline: deadline,
            settled: false,
            won: false
        }));

        emit BetPlaced(bets.length - 1, msg.sender, targetPrice, msg.value, deadline);
    }

    // 结算赌注
    function settleBet(uint256 betId) external {
        Bet storage bet = bets[betId];
        require(!bet.settled, "Already settled");
        require(block.timestamp >= bet.deadline, "Bet not expired");

        bet.settled = true;

        // 获取当前价格
        (, int price, , ,) = priceFeed.latestRoundData();

        // 计算误差(百分比)
        int diff = price > bet.targetPrice ? price - bet.targetPrice : bet.targetPrice - price;
        int errorPercent = diff * 100 / price;

        // 如果误差 <= 5%, 赢得2倍奖励
        if (errorPercent <= 5) {
            bet.won = true;
            payable(bet.player).transfer(bet.amount * 2);
        }

        emit BetSettled(betId, bet.won);
    }

    // 查询当前价格
    function getCurrentPrice() external view returns (int) {
        (, int price, , ,) = priceFeed.latestRoundData();
        return price;
    }

    // 查询用户的所有赌注
    function getUserBets(address user) external view returns (uint256[] memory) {
        uint256 count = 0;
        for (uint i = 0; i < bets.length; i++) {
            if (bets[i].player == user) {
                count++;
            }
        }

        uint256[] memory userBetIds = new uint256[](count);
        uint256 index = 0;
        for (uint i = 0; i < bets.length; i++) {
            if (bets[i].player == user) {
                userBetIds[index] = i;
                index++;
            }
        }

        return userBetIds;
    }
}