区块链编程

简单计算器合约
题目: 实现一个简单的计算器合约，支持加法、减法、乘法和除法操作。分别实现 add(uint256 a, uint256 b)、subtract(uint256 a, uint256 b)、multiply(uint256 a, uint256 b) 和 divide(uint256 a, uint256 b) 函数。

提示:
add(uint256 a, uint256 b)：返回 a 和 b 的和。
subtract(uint256 a, uint256 b)：返回 a 和 b 的差。
multiply(uint256 a, uint256 b)：返回 a 和 b 的积。
divide(uint256 a, uint256 b)：返回 a 除以 b 的商，需检查 b 是否为零。

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

contract SimpleCalculator {
    
    // 加法函数
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }

    // 减法函数
    function subtract(uint256 a, uint256 b) public pure returns (uint256) {
        return a - b;
    }

    // 乘法函数
    function multiply(uint256 a, uint256 b) public pure returns (uint256) {
        return a * b;
    }

    // 除法函数，检查除数是否为零
    function divide(uint256 a, uint256 b) public pure returns (uint256) {
        require(b != 0, "Cannot divide by zero");
        return a / b;
    }
}

存储合约
题目: 创建一个合约，用于存储一个整数。用户可以通过 set(uint256 x) 函数来设置这个整数，通过 get() 函数来查询当前存储的值。

提示:
•    set(uint256 x)：设置存储的整数值。
•    get()：返回当前存储的整数值。

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

contract SimpleStorage {
    uint256 private storedValue;

    // 设置存储的整数值
    function set(uint256 x) public {
        storedValue = x;
    }

    // 返回当前存储的整数值
    function get() public view returns (uint256) {
        return storedValue;
    }
}

简单身份验证合约
题目: 实现一个身份验证合约，允许用户注册和查询注册状态。用户可以通过 register() 函数注册，通过 isRegistered(address user) 函数查询某个地址是否已注册。

提示:
•    register()：用户调用此函数进行注册。
•    isRegistered(address user)：返回指定地址的注册状态。

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

contract SimpleAuth {
    // 用于存储用户注册状态的映射
    mapping(address => bool) private registeredUsers;

    // 用户调用此函数进行注册
    function register() public {
        registeredUsers[msg.sender] = true;
    }

    // 返回指定地址的注册状态
    function isRegistered(address user) public view returns (bool) {
        return registeredUsers[user];
    }
}

简单拍卖合约
题目: 创建一个简单的拍卖合约，允许用户出价。实现 bid() 函数来提交出价，使用 getHighestBid() 函数查询当前最高出价。
提示:
•    bid()：提交出价，需确保出价高于当前最高出价。
•    getHighestBid()：返回当前最高出价。

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

contract SimpleAuction {
    uint256 private highestBid;
    address private highestBidder;

    // 提交出价
    function bid() public payable {
        require(msg.value > highestBid, "Bid must be higher than the current highest bid");

        // 退还先前最高出价用户的金额
        if (highestBidder != address(0)) {
            payable(highestBidder).transfer(highestBid);
        }

        // 更新最高出价和最高出价者
        highestBid = msg.value;
        highestBidder = msg.sender;
    }

    // 返回当前最高出价
    function getHighestBid() public view returns (uint256) {
        return highestBid;
    }

    // 返回当前最高出价者地址
    function getHighestBidder() public view returns (address) {
        return highestBidder;
    }
}

简单奖励合约
题目: 创建一个合约，允许用户存款并根据存款金额给予奖励。实现 deposit() 函数进行存款和 getReward() 函数查询奖励。

提示:
•    deposit()：存入以太，系统给予 10% 的奖励。
•    getReward()：查询当前用户的奖励。

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

contract RewardContract {
    mapping(address => uint256) private balances;
    mapping(address => uint256) private rewards;

    // 存款并计算奖励
    function deposit() public payable {
        require(msg.value > 0, "Deposit amount must be greater than zero");

        // 更新用户的存款余额
        balances[msg.sender] += msg.value;

        // 计算并更新用户的奖励（10% 的存款金额）
        uint256 reward = (msg.value * 10) / 100;
        rewards[msg.sender] += reward;
    }

    // 查询当前用户的奖励
    function getReward() public view returns (uint256) {
        return rewards[msg.sender];
    }
}

投票合约
题目: 创建一个投票合约，允许用户注册候选人并为其投票。实现 addCandidate(string memory name) 和 vote(uint candidateId) 函数。

提示:
•    addCandidate(string memory name)：添加新的候选人。
•    vote(uint candidateId)：为指定候选人投票。

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

contract Voting {
    struct Candidate {
        string name;
        uint256 voteCount;
    }

    // 候选人数组
    Candidate[] public candidates;

    // 记录每个地址是否已投票
    mapping(address => bool) public hasVoted;

    // 添加新的候选人
    function addCandidate(string memory name) public {
        candidates.push(Candidate(name, 0));
    }

    // 为指定候选人投票
    function vote(uint256 candidateId) public {
        require(candidateId < candidates.length, "Invalid candidate ID");
        require(!hasVoted[msg.sender], "You have already voted");

        // 为指定候选人增加票数
        candidates[candidateId].voteCount += 1;
        
        // 记录该地址已投票
        hasVoted[msg.sender] = true;
    }

    // 获取候选人的数量
    function getCandidateCount() public view returns (uint256) {
        return candidates.length;
    }

    // 获取指定候选人的信息
    function getCandidate(uint256 candidateId) public view returns (string memory, uint256) {
        require(candidateId < candidates.length, "Invalid candidate ID");
        Candidate memory candidate = candidates[candidateId];
        return (candidate.name, candidate.voteCount);
    }
}

众筹合约
题目: 创建一个众筹合约，允许用户出资并达到目标后提取资金。实现 contribute() 和 withdraw() 函数。

提示:
•    contribute()：允许用户捐款并记录贡献金额。
•    withdraw()：允许众筹目标达成后提取资金。

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

contract Crowdfunding {
    address public owner;
    uint256 public goal;
    uint256 public totalFunds;
    bool public goalReached;

    mapping(address => uint256) public contributions;

    // 初始化合约，设置众筹目标
    constructor(uint256 _goal) {
        owner = msg.sender;
        goal = _goal;
        goalReached = false;
    }

    // 用户捐款并记录贡献金额
    function contribute() public payable {
        require(msg.value > 0, "Contribution must be greater than zero");
        require(!goalReached, "The goal has already been reached");

        contributions[msg.sender] += msg.value;
        totalFunds += msg.value;

        // 检查是否达成目标
        if (totalFunds >= goal) {
            goalReached = true;
        }
    }

    // 达到目标后允许合约所有者提取资金
    function withdraw() public {
        require(msg.sender == owner, "Only the owner can withdraw funds");
        require(goalReached, "Goal has not been reached yet");

        uint256 amount = address(this).balance;
        payable(owner).transfer(amount);
    }

    // 查询用户的贡献金额
    function getContribution(address contributor) public view returns (uint256) {
        return contributions[contributor];
    }
}

资产管理合约
题目: 开发一个合约，允许用户存款、取款并查询余额。实现 deposit()、withdraw(uint amount) 和 getBalance() 函数。

提示:
•    deposit()：存入以太。
•    withdraw(uint amount)：提取指定金额。
•    getBalance()：查询当前余额。

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

contract AssetManagement {
    mapping(address => uint256) private balances;

    // 存款函数
    function deposit() public payable {
        require(msg.value > 0, "Deposit amount must be greater than zero");
        balances[msg.sender] += msg.value;
    }

    // 提取指定金额的以太
    function withdraw(uint256 amount) public {
        require(amount <= balances[msg.sender], "Insufficient balance");
        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }

    // 查询当前余额
    function getBalance() public view returns (uint256) {
        return balances[msg.sender];
    }
}

合约升级示例
题目: 创建一个可升级的合约。初始合约实现 setValue(uint value) 和 getValue()，升级合约添加 incrementValue()。

提示:
•    setValue(uint value)：设置一个值。
•    getValue()：获取当前值。
•    incrementValue()：将当前值加一（在升级合约中实现）。

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

contract LogicV1 {
    uint256 private value;

    // 设置值
    function setValue(uint256 _value) public {
        value = _value;
    }

    // 获取当前值
    function getValue() public view returns (uint256) {
        return value;
    }
}

contract LogicV2 is LogicV1 {
    // 在现有的基础上新增 incrementValue 函数
    function incrementValue() public {
        setValue(getValue() + 1);
    }
}

contract Proxy {
    address public logicContract;
    address public owner;

    constructor(address _logicContract) {
        logicContract = _logicContract;
        owner = msg.sender;
    }

    // 升级逻辑合约
    function upgradeTo(address _newLogicContract) public {
        require(msg.sender == owner, "Only the owner can upgrade the contract");
        logicContract = _newLogicContract;
    }

    // 委托调用逻辑合约
    fallback() external payable {
        (bool success, ) = logicContract.delegatecall(msg.data);
        require(success, "Delegatecall failed");
    }

    receive() external payable {}
}

时间锁合约
题目: 实现一个时间锁合约，允许用户存入资金并设置锁定时间。实现 deposit(uint unlockTime) 和 withdraw() 函数。

提示:
•    deposit(uint unlockTime)：存入以太并设置解锁时间。
•    withdraw()：在解锁后提取资金。

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

contract TimeLock {
    // 存储每个用户的存款余额和解锁时间
    mapping(address => uint256) private balances;
    mapping(address => uint256) private unlockTimes;

    // 构造函数，标记为payable，以便接受以太币
    constructor() payable {
        // 在部署时可以发送一些初始的以太币
    }

    // 存入资金并设置解锁时间
    function deposit(uint256 unlockTime) public payable {
        require(msg.value > 0, "Deposit amount must be greater than zero");
        require(unlockTime > block.timestamp, "Unlock time must be in the future");

        // 更新用户存款余额和解锁时间
        balances[msg.sender] += msg.value;
        unlockTimes[msg.sender] = unlockTime;
    }

    // 提取资金（只能在解锁时间后）
    function withdraw() public {
        require(block.timestamp >= unlockTimes[msg.sender], "Funds are locked");
        require(balances[msg.sender] > 0, "No funds to withdraw");

        uint256 amount = balances[msg.sender];
        balances[msg.sender] = 0; // 清空余额
        payable(msg.sender).transfer(amount); // 转账给用户
    }

    // 查询当前用户的余额
    function getBalance() public view returns (uint256) {
        return balances[msg.sender];
    }

    // 查询当前用户的解锁时间
    function getUnlockTime() public view returns (uint256) {
        return unlockTimes[msg.sender];
    }
}