Solidity8.0-03

对应崔棉大师 41-50课程
https://www.bilibili.com/video/BV1yS4y1N7yu/?spm_id_from=333.788&vd_source=c81b130b6f8bb3082bdb42226729d69c

调用其他合约

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract Callee {

    uint public x;

    uint public value;

    function setX(uint _x) public returns (uint) {

        x = _x;

        return x;

    }

    function setXandSendEther(uint _x) public payable returns (uint, uint) {

        x = _x;

        value = msg.value;

        return (x, value);

    }

}

contract Caller {

    function setX(Callee _callee, uint _x) public {

        uint x = _callee.setX(_x);

    }

    function setXFromAddress(address _addr, uint _x) public {

        Callee callee = Callee(_addr);

        callee.setX(_x);

    }

    function setXandSendEther(Callee _callee, uint _x) public payable {

        (uint x, uint value) = _callee.setXandSendEther{value: msg.value}(_x);

    }

}

 

接口合约

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract Counter {

    uint public count;

    function increment() external {

        count += 1;

    }

}

interface ICounter {

    function count() external view returns (uint);

    function increment() external;

}

contract MyContract {

    function incrementCounter(address _counter) external {

        ICounter(_counter).increment();

    }

    function getCount(address _counter) external view returns (uint) {

        return ICounter(_counter).count();

    }

}

// Uniswap example

interface UniswapV2Factory {

    function getPair(address tokenA, address tokenB)

        external

        view

        returns (address pair);

}

interface UniswapV2Pair {

    function getReserves()

        external

        view

        returns (

            uint112 reserve0,

            uint112 reserve1,

            uint32 blockTimestampLast

        );

}

contract UniswapExample {

    address private factory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;

    address private dai = 0x6B175474E89094C44Da98b954EedeAC495271d0F;

    address private weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;

    function getTokenReserves() external view returns (uint, uint) {

        address pair = UniswapV2Factory(factory).getPair(dai, weth);

        (uint reserve0, uint reserve1, ) = UniswapV2Pair(pair).getReserves();

        return (reserve0, reserve1);

    }

}

低级call

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract Receiver {

    event Received(address caller, uint amount, string message);

    fallback() external payable {

        emit Received(msg.sender, msg.value, "Fallback was called");

    }

    function foo(string memory _message, uint _x) public payable returns (uint) {

        emit Received(msg.sender, msg.value, _message);

        return _x + 1;

    }

}

contract Caller {

    event Response(bool success, bytes data);

    // Let's imagine that contract B does not have the source code for

    // contract A, but we do know the address of A and the function to call.

    function testCallFoo(address payable _addr) public payable {

        // You can send ether and specify a custom gas amount 

　　　　　//uint要写成uint256 特殊 ,不指定gas 会带全部gas发送交易

        (bool success, bytes memory data) = _addr.call{value: msg.value, gas: 5000}(

            abi.encodeWithSignature("foo(string,uint256)", "call foo", 123)

        );

        emit Response(success, data);

    }

    // Calling a function that does not exist triggers the fallback function.

    function testCallDoesNotExist(address _addr) public {

        (bool success, bytes memory data) = _addr.call(

            abi.encodeWithSignature("doesNotExist()")

        );

        emit Response(success, data);

    }

}

委托调用

http://www.theblockbeats.info/en/news/31694

https://learnblockchain.cn/article/4125

工厂合约

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract Account{

    address public bank;

    address public owner;

    constructor(address _owner) payable{

            bank = msg.sender;

            owner = _owner;

    }

}

contract Factory{

    Account[] public Accounts;

    function createAccount(address _owner) external payable{

        Account acc = new Account{value:111}(_owner);

        Accounts.push(acc);

    }

}

库合约

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

library SafeMath {

    function add(uint x, uint y) internal pure returns (uint) {

        uint z = x + y;

        require(z >= x, "uint overflow");

        return z;

    }

}

library Math {

    function sqrt(uint y) internal pure returns (uint z) {

        if (y > 3) {

            z = y;

            uint x = y / 2 + 1;

            while (x < z) {

                z = x;

                x = (y / x + x) / 2;

            }

        } else if (y != 0) {

            z = 1;

        }

        // else z = 0 (default value)

    }

}

contract TestSafeMath {

    using SafeMath for uint;

    uint public MAX_UINT = 2**256 - 1;

    function testAdd(uint x, uint y) public pure returns (uint) {

        return x.add(y);

    }

    function testSquareRoot(uint x) public pure returns (uint) {

        return Math.sqrt(x);

    }

}

// Array function to delete element at index and re-organize the array

// so that their are no gaps between the elements.

library Array {

    function remove(uint[] storage arr, uint index) public {

        // Move the last element into the place to delete

        require(arr.length > 0, "Can't remove from empty array");

        arr[index] = arr[arr.length - 1];

        arr.pop();

    }

}

contract TestArray {

    using Array for uint[];

    uint[] public arr;

    function testArrayRemove() public {

        for (uint i = 0; i < 3; i++) {

            arr.push(i);

        }

        arr.remove(1);

        assert(arr.length == 2);

        assert(arr[0] == 0);

        assert(arr[1] == 2);

    }

}

哈希运算

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract HashFunction {

    function hash(string memory _text,uint _num,address _addr) public pure returns (bytes32) {

        return keccak256(abi.encodePacked(_text, _num, _addr));

    }

 

    function encode_keccak256(string memory _text, string memory _text2) public pure returns (bytes32){

        {

            return keccak256(abi.encode(_text, _text2));

        }

    }

    function encode(string memory _text, string memory _text2) public pure returns (bytes memory){

        {

            return abi.encode(_text, _text2);

        }

    }

        /*

            encode 将数据转为16进制并补0到长度64

            encodePacked将数据转为16进制拼接

            当两个字符串使用encodePacked "AAA","BBB" 和 "AA","ABBB"结果相同 特别注意

            当返回非定长数组时 返回类型为  bytes

        */

     function encodePacked(string memory _text,string memory _text2) public pure returns (bytes32) {

        return keccak256(abi.encodePacked(_text, _text2));

    }

    function collision(string memory _text,uint _num,string memory _text2) public pure returns (bytes32) {

        return keccak256(abi.encodePacked(_text, _num, _text2));

    }

}

验证签名

 

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

/* Signature Verification

How to Sign and Verify

# Signing

1. Create message to sign 创建签名

2. Hash the message 对签名hash

3. Sign the hash (off chain, keep your private key secret) 线下对签名hash用私钥加密

# Verify

1. Recreate hash from the original message  取椭圆加密 r s v

2. Recover signer from signature and hash   ecrocver('签名hash',r,s,v) 解密签名的钱包地址

3. Compare recovered signer to claimed signer 比较解密后的地址和加密的钱包地址是否一致

*/

contract VerifySignature {

    /* 1. Unlock MetaMask account

    ethereum.enable()

    */

    /* 2. Get message hash to sign

    getMessageHash(

        0x14723A09ACff6D2A60DcdF7aA4AFf308FDDC160C,

        123,

        "coffee and donuts",

        1

    )

    hash = "0xcf36ac4f97dc10d91fc2cbb20d718e94a8cbfe0f82eaedc6a4aa38946fb797cd"

    */

    function getMessageHash(

        address _to,

        uint _amount,

        string memory _message,

        uint _nonce

    ) public pure returns (bytes32) {

        return keccak256(abi.encodePacked(_to, _amount, _message, _nonce));

    }

    /* 3. Sign message hash

    # using browser

    account = "copy paste account of signer here"

    ethereum.request({ method: "personal_sign", params: [account, hash]}).then(console.log)

    # using web3

    web3.personal.sign(hash, web3.eth.defaultAccount, console.log)

    Signature will be different for different accounts

    0x993dab3dd91f5c6dc28e17439be475478f5635c92a56e17e82349d3fb2f166196f466c0b4e0c146f285204f0dcb13e5ae67bc33f4b888ec32dfe0a063e8f3f781b

    */

    function getEthSignedMessageHash(bytes32 _messageHash)

        public

        pure

        returns (bytes32)

    {

        /*

        Signature is produced by signing a keccak256 hash with the following format:

        "\x19Ethereum Signed Message\n" + len(msg) + msg

        */

        return

            keccak256(

                abi.encodePacked("\x19Ethereum Signed Message:\n32", _messageHash)

            );

    }

    /* 4. Verify signature

    signer = 0xB273216C05A8c0D4F0a4Dd0d7Bae1D2EfFE636dd

    to = 0x14723A09ACff6D2A60DcdF7aA4AFf308FDDC160C

    amount = 123

    message = "coffee and donuts"

    nonce = 1

    signature =

        0x993dab3dd91f5c6dc28e17439be475478f5635c92a56e17e82349d3fb2f166196f466c0b4e0c146f285204f0dcb13e5ae67bc33f4b888ec32dfe0a063e8f3f781b

    */

    function verify(

        address _signer,

        address _to,

        uint _amount,

        string memory _message,

        uint _nonce,

        bytes memory signature

    ) public pure returns (bool) {

        bytes32 messageHash = getMessageHash(_to, _amount, _message, _nonce);

        bytes32 ethSignedMessageHash = getEthSignedMessageHash(messageHash);

        return recoverSigner(ethSignedMessageHash, signature) == _signer;

    }

    function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature)

        public

        pure

        returns (address)

    {

        (bytes32 r, bytes32 s, uint8 v) = splitSignature(_signature);

        return ecrecover(_ethSignedMessageHash, v, r, s);

    }

    function splitSignature(bytes memory sig)

        public

        pure

        returns (

            bytes32 r,

            bytes32 s,

            uint8 v

        )

    {

        require(sig.length == 65, "invalid signature length");

        assembly {

            /*

            First 32 bytes stores the length of the signature

            add(sig, 32) = pointer of sig + 32

            effectively, skips first 32 bytes of signature

            mload(p) loads next 32 bytes starting at the memory address p into memory

            */

            // first 32 bytes, after the length prefix

            r := mload(add(sig, 32))

            // second 32 bytes

            s := mload(add(sig, 64))

            // final byte (first byte of the next 32 bytes)

            v := byte(0, mload(add(sig, 96)))

        }

        // implicitly return (r, s, v)

    }

}

权限控制合约

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract AccessControl{

    event GrantRole(bytes32 indexed role,address indexed account);

    event RevokeRole(bytes32 indexed role,address indexed account);

   

    constructor(){

        _grantRole(ADMIN,msg.sender);

    }

    mapping(bytes32 => mapping(address => bool)) public roles;

    bytes32 public constant ADMIN = keccak256(abi.encodePacked("ADMIN"));

    bytes32 public constant USER = keccak256(abi.encodePacked("USER"));

     modifier onlyAdmin(bytes32 _role){

         require(roles[_role][msg.sender],"not admin");

         _;

     }

    function _grantRole(bytes32 _role,address _account) internal {

        roles[_role][_account] = true;

        emit GrantRole(_role,_account);

    }

    function grantRole(bytes32 _role,address _account) external onlyAdmin(ADMIN){

            _grantRole(_role,_account);

    }

    function revokeRole(bytes32 _role,address _account) external onlyAdmin(ADMIN){

        roles[_role][_account] = false;

        emit RevokeRole(_role,_account);

    }

}

自毁合约

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract Kill{

    constructor() payable {

       

    }

    /*

    1.删除合约

    2.强制发送主币 目标是合约地址没有fallback也可以发送主币

    */

    function kill() external{

        selfdestruct(payable(msg.sender));

    }

    function testCall() external pure returns(uint){

        return 123;

    }

}

contract Helper{

 

    function getBalance() external view returns  (uint){

        return address(this).balance;

    }

    function Killer(Kill _kill) external {

        _kill.kill();

    }

 

}

巴特西

Solidity8.0-03

最新文章

热门文章