Solidity 示例指南

Solidity 是以太坊智能合约的编程语言。在这个指南中，我们将通过一些示例来展示如何使用 Solidity 编写智能合约。

示例列表

以下是一些 Solidity 示例：

• 简单的存储合约
• 发送以太坊
• 多重签名钱包

简单的存储合约

这是一个简单的存储合约示例，它允许你存储一个值。

pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 public storedData;

    function set(uint256 x) public {
        storedData = x;
    }

    function get() public view returns (uint256) {
        return storedData;
    }
}

发送以太坊

以下是一个示例，展示如何从合约发送以太坊到另一个地址。

pragma solidity ^0.8.0;

contract SendEther {
    function send(address payable _to, uint256 _amount) public {
        _to.transfer(_amount);
    }
}

多重签名钱包

多重签名钱包需要一个以上的私钥来执行交易。

pragma solidity ^0.8.0;

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

    uint256 public requiredConfirmations;

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

    Transaction[] public transactions;

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

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

        for (uint256 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 submitTransaction(address _to, uint256 _value) public {
        uint256 transactionCount = transactions.length;

        transactions.push(Transaction({
            to: _to,
            value: _value,
            executed: false,
            numConfirmations: 0
        }));
    }

    function confirmTransaction(uint256 _txIndex) public {
        require(isOwner[msg.sender], "Not owner");

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

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

        if (transaction.numConfirmations >= requiredConfirmations) {
            transaction.to.transfer(transaction.value);
            transaction.executed = true;
        }
    }

    function getOwners() public view returns (address[] memory) {
        return owners;
    }

    function getTransactionsCount() public view returns (uint256) {
        return transactions.length;
    }

    function getTransaction(uint256 _txIndex) public view returns (address, uint256, bool, uint256) {
        Transaction storage transaction = transactions[_txIndex];
        return (transaction.to, transaction.value, transaction.executed, transaction.numConfirmations);
    }
}

更多关于 Solidity 的信息，请访问我们的Solidity 教程。