Solidity 智能合约示例

智能合约是区块链技术中的一项重要应用，而 Solidity 是目前最流行的智能合约编程语言。以下是一些 Solidity 智能合约的示例，帮助您更好地理解和使用 Solidity。

示例 1: 简单的余额合约

pragma solidity ^0.8.0;

contract SimpleBalance {
    uint public balance;

    function deposit() external payable {
        balance += msg.value;
    }

    function withdraw() external {
        require(balance >= msg.value, "Balance not sufficient");
        payable(msg.sender).transfer(msg.value);
        balance -= msg.value;
    }
}

在这个示例中，我们创建了一个简单的余额合约，允许用户存入和提取余额。

示例 2: 多重签名钱包

pragma solidity ^0.8.0;

contract MultiSigWallet {
    address[] public owners;
    mapping(address => bool) public isOwner;

    uint public requiredConfirmations;

    struct Transaction {
        address to;
        uint value;
        bool executed;
        uint numConfirmations;
    }

    Transaction[] public transactions;

    mapping(uint => mapping(address => bool)) public isConfirmed;

    event Deposit(address indexed sender, uint amount);
    event Withdraw(address indexed receiver, uint amount);
    event ConfirmTransaction(address indexed owner, uint transactionId);
    event ExecuteTransaction(address indexed owner, uint transactionId);

    constructor(address[] memory _owners, uint _requiredConfirmations) {
        require(_owners.length > 0, "Owners required");
        require(_requiredConfirmations > 0 && _requiredConfirmations <= _owners.length, "Invalid number of required confirmations");

        for (uint i = 0; i < _owners.length; i++) {
            address owner = _owners[i];

            require(owner != address(0), "Invalid owner");
            require(!isOwner[owner], "Owner already added");

            owners.push(owner);
            isOwner[owner] = true;
        }

        requiredConfirmations = _requiredConfirmations;
    }

    function deposit() external payable {
        emit Deposit(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) external {
        require(amount <= address(this).balance, "Insufficient balance");

        transactions.push(Transaction({
            to: msg.sender,
            value: amount,
            executed: false,
            numConfirmations: 0
        }));

        emit Withdraw(msg.sender, amount);
    }

    function confirmTransaction(uint transactionId) external {
        require(isOwner[msg.sender], "Not owner");

        Transaction storage transaction = transactions[transactionId];
        require(!transaction.executed, "Transaction already executed");
        require(!isConfirmed[transactionId][msg.sender], "Transaction already confirmed");

        transaction.numConfirmations += 1;
        isConfirmed[transactionId][msg.sender] = true;

        emit ConfirmTransaction(msg.sender, transactionId);

        if (transaction.numConfirmations >= requiredConfirmations) {
            transaction.executed = true;
            payable(transaction.to).transfer(transaction.value);
            emit ExecuteTransaction(msg.sender, transactionId);
        }
    }
}

在这个示例中，我们创建了一个多重签名钱包，需要多个所有者确认才能执行提款操作。

扩展阅读

想要了解更多关于 Solidity 和智能合约的知识，请访问我们的 Solidity 教程 页面。

Solidity Logo