Solidity学习

// 数值类型
// bool类型
bool public _bool = true;

// 整型
int public _int = -1;
uint public _uint = 1;
uint256 public _number = 20220930;
// 整数运算
uint256 public _number1 = _number + 1; // +，-，*，/
uint256 public _number2 = 2**2; // 指数
uint256 public _number3 = 7 % 2; // 取余数
bool public _numberbool = _number2 > _number3; // 比大小

// 地址类型，address类型存储一个20字节的值（以太坊地址的大小）。有普通的地址类型和可以转账ETH的地址类型（payable）。payable的地址拥有balance和tranfer()，方便查询和转账。
// 地址
address public _address = 0x7A58c0Be72BE218B41C608b7Fe7C5bB630736C71;
address payable public _address1 = payable(_address); // payable address，可以转账、查余额
// 地址类型的成员
uint256 public balance = _address1.balance; // balance of address

// 定长字节数组
bytes32 public _byte32 = "MiniSolidity";
bytes1 public _byte = _byte32[0];

// 枚举enum，可以显示和uint转换，几乎没人使用。
enum ActionSet { Buy, Hold, Sell }
ActionSet action = ActionSet.Buy;

// 固定长度数组
uint[8] array1;
bytes1[5] array2;
address[100] array3;

// 可变长数组，声明时不指定数组的长度
uint[] array4;
bytes1[] array5;
address[] array6;
bytes array7;

// 注意：bytes比较特殊，是数组，但是不加[]。
// 另外不能用byte[]声明单字节数组，可以使用bytes或bytes1[]

// memory动态数组
uint[] memory array8 = new uint[](3);
bytes memory array9 = new bytes(9);

// 动态数组赋值
array8[0] = 1
array9[1] = 2

// 结构体
struct Student{
    uint256 id;
    uint256 score; 
}

// 初始一个student结构体
Student student; 

//  给结构体赋值
// 方法1:在函数中创建一个storage的struct引用
function initStudent1() external{
    Student storage _student = student; // assign a copy of student
    _student.id = 11;
    _student.score = 100;
}
// 方法2:直接引用状态变量的struct
function initStudent2() external{
    student.id = 1;
    student.score = 80;
}

bool public _bool; // false
string public _string; // ""
int public _int; // 0
uint public _uint; // 0
address public _address; // 0x0000000000000000000000000000000000000000

enum ActionSet { Buy, Hold, Sell}
ActionSet public _enum; // 第1个内容Buy的索引0

function fi() internal{} // internal空白方程 
function fe() external{} // external空白方程 

// Reference Types
uint[8] public _staticArray; // 所有成员设为其默认值的静态数组[0,0,0,0,0,0,0,0]
uint[] public _dynamicArray; // `[]`
mapping(uint => address) public _mapping; // 所有元素都为其默认值的mapping
// 所有成员设为其默认值的结构体 0, 0
struct Student{
    uint256 id;
    uint256 score; 
}
Student public student;

// immutable变量可以在constructor里初始化，之后不能改变
uint256 public immutable IMMUTABLE_NUM = 9999999999;
address public immutable IMMUTABLE_ADDRESS;
uint256 public immutable IMMUTABLE_BLOCK;
uint256 public immutable IMMUTABLE_TEST;

// 利用constructor初始化immutable变量，因此可以利用
constructor(){
    IMMUTABLE_ADDRESS = address(this);
    IMMUTABLE_BLOCK = block.number;
    IMMUTABLE_TEST = test();
}

function test() public pure returns(uint256){
    uint256 what = 9;
    return(what);
}

// 返回多个变量
function returnMultiple() public pure returns(uint256, bool, uint256[3] memory){
    return(1, true, [uint256(1),2,5]);
}

// 命名式返回
function returnNamed() public pure returns(uint256 _number, bool _bool, uint256[3] memory _array){
    _number = 2;
    _bool = false; 
    _array = [uint256(3),2,1];
}

// 解析式赋值
uint256 _number;
bool _bool;
uint256[3] memory _array;
(_number, _bool, _array) = returnNamed();

// 读取部分值
(, _bool2, ) = returnNamed();

   address owner; // 定义owner变量

   // 构造函数
   constructor() {
      owner = msg.sender; // 在部署合约的时候，将owner设置为部署者的地址
   }

 // 定义modifier
 modifier onlyOwner {
    require(msg.sender == owner); // 检查调用者是否为owner地址
    _; // 如果是的话，继续运行函数主体；否则报错并revert交易
 }

 function changeOwner(address _newOwner) external onlyOwner{
    owner = _newOwner; // 只有owner地址运行这个函数，并改变owner
 }

function saySomething() public pure returns(string memory){
    return("Nothing");
}

function saySomething(string memory something) public pure returns(string memory){
    return(something);
}

function f(uint8 _in) public pure returns (uint8 out) {
    out = _in;
}

function f(uint256 _in) public pure returns (uint256 out) {
    out = _in;
}

event Transfer(address indexed from, address indexed to, uint256 value);

// 定义_transfer函数，执行转账逻辑
function _transfer(
    address from,
    address to,
    uint256 amount
) external {

    _balances[from] = 10000000; // 给转账地址一些初始代币

    _balances[from] -=  amount; // from地址减去转账数量
    _balances[to] += amount; // to地址加上转账数量

    // 释放事件
    emit Transfer(from, to, amount);
}

keccak256("Transfer(addrses,address,uint256)")

pragma solidity ^0.8.13;

contract DataLocations {
    struct MyStruct {
        uint foo;
        string bar;
    }

    mapping(address => MyStruct) public myStructs;

    constructor() {
        // init
        myStructs[msg.sender] = MyStruct({foo: 123, bar: "bar"});
    }

    function examples(uint[] memory y, uint[] calldata z) external returns (uint[] memory) {
        // storage可以操作状态变量，修改生效
        MyStruct storage myStruct = myStructs[msg.sender];
        myStruct.foo = 234;

        // memory修改临时内存变量，修改不生效
        MyStruct memory myStruct1 = myStructs[msg.sender];
        myStruct1.foo = 345;

        _internal(y);
        _internal01(z);

        // 内存中数组（局部变量）必须是定长数组，变长数组只能用到状态变量中。
        uint[] memory memArr = new uint[](3);
        memArr[0] = 111;

        return memArr;
    }

    function _internal(uint[] memory y) private pure {
        uint x = y[0];
    }

    function _internal01(uint[] calldata z) private pure {
        uint x = z[0];
    }
}

// if-else
function ifElseTest(uint256 _number) public pure returns(bool){
    if(_number == 0){
	return(true);
    }else{
	return(false);
    }
}

// for
function forLoopTest() public pure returns(uint256){
    uint sum = 0;
    for(uint i = 0; i < 10; i++){
	sum += i;
    }
    return(sum);
}

// while
function whileTest() public pure returns(uint256){
    uint sum = 0;
    uint i = 0;
    while(i < 10){
	sum += i;
	i++;
    }
    return(sum);
}

// do-while
function doWhileTest() public pure returns(uint256){
    uint sum = 0;
    uint i = 0;
    do{
	sum += i;
	i++;
    }while(i < 10);
    return(sum);
}

// 三元运算符
function ternaryTest(uint256 x, uint256 y) public pure returns(uint256){
    // return the max of x and y
    return x >= y ? x: y; 
}

mapping(address => uint256) public override balanceOf;

contract Yeye {
  event Log(string msg);

  function hip() public ‘，{
      emit Log("Yeye");
  }

  function pop() public virtual{
      emit Log("Yeye");
  }

  function yeye() public virtual {
      emit Log("Yeye");
  } 
}

// 重写了Yeye合约的hip()和pop()函数，继承了yeye()函数
contract Baba is Yeye {
  function hip() public virtual override {
      emit Log("Baba");
  }

  function pop() public virtual override {
      emit Log("Baba");
  }

  function baba() public virtual {
      emit Log("Baba");
  } 
}

contract Erzi is Yeye, Baba {
  function hip() public virtual override(Yeye, Baba){
      emit Log("Erzi");
  }

  function pop() public virtual override(Yeye, Baba) {
      emit Log("Erzi");
  }
}

contract Base1 {
    modifier exactDividedBy2And3(uint _a) virtual {
        require(_a % 2 == 0 && _a % 3 == 0);
        _;
    }
}

contract Identifier is Base1 {

    //计算一个数分别被2除和被3除的值，但是传入的参数必须是2和3的倍数
    function getExactDividedBy2And3(uint _dividend) public exactDividedBy2And3(_dividend) pure returns(uint, uint) {
        return getExactDividedBy2And3WithoutModifier(_dividend);
    }

    //计算一个数分别被2除和被3除的值
    function getExactDividedBy2And3WithoutModifier(uint _dividend) public pure returns(uint, uint){
        uint div2 = _dividend / 2;
        uint div3 = _dividend / 3;
        return (div2, div3);
    }
}

modifier exactDividedBy2And3(uint _a) override {
    _;
}

contract S {
  string public name;

  constructor(string memory _name) {
    name = _name;
  }
}

contract T {
  string public text;

  constructor(string memory _text) {
    text = _text;
  }
}

// 方式一：在继承时直接传入参数，但是需要提前知道参数的值
contract U is S("qinyang"), T("love") {
}

// 方式二：在子合约里面实现构造方法时传入
contract V is S, T {
  constructor(string memory _name, string memory _text) S(_name) T(_text) {
  }
}

// 通过合约名字直接调用
function callParent() public {
  Yeye.pop();
}

// super关键字调用
function callParentSuper() public {
  super.pop();
}

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

/* 继承树：
  God
 /  \
Adam Eve
 \  /
people
*/

contract God {
    event Log(string message);

    function foo() public virtual {
        emit Log("God.foo called");
    }

    function bar() public virtual {
        emit Log("God.bar called");
    }
}

contract Adam is God {
    function foo() public virtual override {
        emit Log("Adam.foo called");
        Adam.foo();
    }

    function bar() public virtual override {
        emit Log("Adam.bar called");
        super.bar();
    }
}

contract Eve is God {
    function foo() public virtual override {
        emit Log("Eve.foo called");
        Eve.foo();
    }

    function bar() public virtual override {
        emit Log("Eve.bar called");
        super.bar();
    }
}

contract people is Adam, Eve {
    function foo() public override(Adam, Eve) {
        super.foo();
    }

    function bar() public override(Adam, Eve) {
        super.bar();
    }
}

abstract contract InsertionSort{
    function insertionSort(uint[] memory a) public pure virtual returns(uint[] memory);
}

error TransferNotOwner(); // 自定义error
error TransferNotOwner(address sender); // 自定义的带参数的error
// Error必须和revert命令使用
function transferOwner1(uint256 tokenId, address newOwner) public {
    if(_owners[tokenId] != msg.sender){
        revert TransferNotOwner();
        // revert TransferNotOwner(msg.sender);
    }
    _owners[tokenId] = newOwner;
}

// Require require(检查条件，"异常的描述")，当检查条件不成立的时候，就会抛出异常。
// 缺点就是异常的描述越长，越消耗gas
function transferOwner2(uint256 tokenId, address newOwner) public {
    require(_owners[tokenId] == msg.sender, "Transfer Not Owner");
    _owners[tokenId] = newOwner;
}

// Assert 一般用于编写程序是debug，不能描述异常原因。
function transferOwner3(uint256 tokenId, address newOwner) public {
    assert(_owners[tokenId] == msg.sender);
    _owners[tokenId] = newOwner;
}

// 利用using for指令
using Strings for uint256;
function getString1(uint256 _number) public pure returns(string memory){
    // 库函数会自动添加为uint256型变量的成员
    return _number.toHexString();
}

// 直接通过库合约名调用
function getString2(uint256 _number) public pure returns(string memory){
    return Strings.toHexString(_number);
}

文件结构
├── Import.sol
└── Yeye.sol

// 通过文件相对位置import
import './Yeye.sol';

// 通过网址引用
import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol';

import '@openzeppelin/contracts/access/Ownable.sol';

import {Yeye} from './Yeye.sol';

// 定义事件
event Received(address Sender, uint Value);
// 接收ETH时释放Received事件
receive() external payable {
    emit Received(msg.sender, msg.value);
}

// fallback
fallback() external payable{
    emit fallbackCalled(msg.sender, msg.value, msg.data);
}

触发fallback() 还是 receive()?
           接收ETH
              |
         msg.data是空？
            /  \
          是    否
          /      \
receive()存在?   fallback()
        / \
       是  否
      /     \
receive()   fallback()

contract ReceiveETH {
	event Log(uint amount, uint gas);

  // receive方法，接收eth时被触发
  receive() external payable {
    emit Log(msg.value, gasleft());
  }

  // 返回合约中的ETH
  function getBalance() view public returns(uint) {
    return address(this).balance;
  }
}

contract SendETH {
    // 构造函数，payable使得部署的时候可以转eth进去
    constructor() payable{}
    // receive方法，接收eth时被触发
    receive() external payable{}
}

// 用transfer()发送ETH
function transferETH(address payable _to, uint256 amount) external payable{
	_to.transfer(amount);
}

// send()发送ETH
function sendETH(address payable _to, uint256 amount) external payable{
    // 处理下send的返回值，如果失败，revert交易并发送error
    bool success = _to.send(amount);
    if(!success){
    	revert SendFailed();
    }
}

// call()发送ETH
function callETH(address payable _to, uint256 amount) external payable{
    // 处理下call的返回值，如果失败，revert交易并发送error
    (bool success,) = _to.call{value: amount}("");
    if(!success){
    	revert CallFailed();
    }
}

contract OtherContract {
    uint256 private _x = 0; // 状态变量_x
    // 收到eth的事件，记录amount和gas
    event Log(uint amount, uint gas);
    
    // 返回合约ETH余额
    function getBalance() view public returns(uint) {
        return address(this).balance;
    }

    // 可以调整状态变量_x的函数，并且可以往合约转ETH (payable)
    function setX(uint256 x) external payable{
        _x = x;
        // 如果转入ETH，则释放Log事件
        if(msg.value > 0){
            emit Log(msg.value, gasleft());
        }
    }

    // 读取_x
    function getX() external view returns(uint x){
        x = _x;
    }
}

function callSetX(address _Address, uint256 x) external{
    OtherContract(_Address).setX(x);
}

function callGetX(OtherContract _Address) external view returns(uint x){
    x = _Address.getX();
}

function callGetX2(address _Address) external view returns(uint x){
    OtherContract oc = OtherContract(_Address);
    x = oc.getX();
}

function setXTransferETH(address otherContract, uint256 x) payable external{
    OtherContract(otherContract).setX{value: msg.value}(x);
}

目标合约地址.call(二进制编码);

abi.encodeWithSignature("函数签名", arg1, arg2, arg3 ...);

目标合约地址.call{value: 发送数额, gas: gas数额}(二进制编码);

event Response(bool success, bytes data);

function callSetX(address payable _addr, uint256 x) external payable {
  (bool success, bytes memory data) = _addr.call{value: msg.value}(
    abi.encodeWithSignature("setX(uint256)", x)
  );
  emit Response(success, data);
}

function callGetX() external returns(uint256) {
  (bool success, bytes memory data) = _addr.call{value: msg.value}(
    abi.encodeWithSignature("getX()")
  );
  emit Response(success, data);
	return abi.decode(data, (uint256));
}

// 调用不存在的函数
function callNonExist(address _addr) external {
  (bool success, bytes memory data) = _addr.call{value: msg.value}(
    abi.encodeWithSignature("foo(uint256)")
  );
  emit Response(success, data);
}

目标合约地址.delegatecall(二进制编码);

//被调用的合约C 
contract C {
	uint public num;
  address public sender;

  function setVars(uint _num) public payable {
    num = _num;
    sender = msg.sender;
  } 
}

//发起调用的合约B 
contract B {
  uint public num;
  address public sender;

  function callSetVars(uint _num, address _addr) public payable {
    (bool success, bytes data) = _addr.call(
      abi.encodeWithSignature("setVars(uint)", _num)
    );
  } 

  function delegatecallSetVars(uint _num, address _addr) public payable {
    (bool success, bytes data) = _addr.delegatecall(
      abi.encodeWithSignature("setVars(uint)", _num)
    );
  }
}

Contract x = new Contract{value: _value}(params)

新地址 = hash(创建者地址, nonce)

Contract x = new Contract{salt: _salt, value: _value}(params)

新地址 = hash("0xFF",创建者地址, salt, bytecode)

contract Pair{
    address public factory; // 工厂合约地址
    address public token0; // 代币1
    address public token1; // 代币2

    constructor() payable {
        factory = msg.sender;
    }

    // called once by the factory at time of deployment
    function initialize(address _token0, address _token1) external {
        require(msg.sender == factory, 'UniswapV2: FORBIDDEN'); // sufficient check
        token0 = _token0;
        token1 = _token1;
    }
}

contract PairFactory{
    mapping(address => mapping(address => address)) public getPair; // 通过两个代币地址查Pair地址
    address[] public allPairs; // 保存所有Pair地址

    function createPair(address tokenA, address tokenB) external returns (address pairAddr) {
        // 创建新合约
        Pair pair = new Pair(); 
        // 调用新合约的initialize方法
        pair.initialize(tokenA, tokenB);
        // 更新地址map
        pairAddr = address(pair);
        allPairs.push(pairAddr);
        getPair[tokenA][tokenB] = pairAddr;
        getPair[tokenB][tokenA] = pairAddr;
    }
}

//测试参数：
//WBNB地址: 0x2c44b726ADF1963cA47Af88B284C06f30380fC78
//BSC链上的PEOPLE地址:
//0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c

contract Pair{
address public factory; // 工厂合约地址
address public token0; // 代币1
address public token1; // 代币2

constructor() payable {
    factory = msg.sender;
}

// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
    require(msg.sender == factory, 'UniswapV2: FORBIDDEN'); // sufficient check
    token0 = _token0;
    token1 = _token1;
}
}

contract PairFactory2{
    mapping(address => mapping(address => address)) public getPair; // 通过两个代币地址查Pair地址
    address[] public allPairs; // 保存所有Pair地址

    function createPair2(address tokenA, address tokenB) external returns (address pairAddr) {
        require(tokenA != tokenB, 'IDENTICAL_ADDRESSES'); //避免tokenA和tokenB相同产生的冲突
        // 计算用tokenA和tokenB地址计算salt
        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); //将tokenA和tokenB按大小排序
        bytes32 salt = keccak256(abi.encodePacked(token0, token1));
        // 用create2部署新合约
        Pair pair = new Pair{salt: salt}(); 
        // 调用新合约的initialize方法
        pair.initialize(tokenA, tokenB);
        // 更新地址map
        pairAddr = address(pair);
        allPairs.push(pairAddr);
        getPair[tokenA][tokenB] = pairAddr;
        getPair[tokenB][tokenA] = pairAddr;
    }

//测试参数：
//WBNB地址: 0x2c44b726ADF1963cA47Af88B284C06f30380fC78
//BSC链上的PEOPLE地址:
//0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c

// 提前计算pair合约地址
function calculateAddr(address tokenA, address tokenB) public view returns(address predictedAddress){
    require(tokenA != tokenB, 'IDENTICAL_ADDRESSES'); //避免tokenA和tokenB相同产生的冲突
    // 计算用tokenA和tokenB地址计算salt
    (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); //将tokenA和tokenB按大小排序
    bytes32 salt = keccak256(abi.encodePacked(token0, token1));
    // 计算合约地址方法 hash()
    predictedAddress = address(uint160(uint(keccak256(abi.encodePacked(
        bytes1(0xff),
        address(this),
        salt,
        keccak256(type(Pair).creationCode)
    )))));
}

selfdestruct(_addr);

contract DeleteContract {

    uint public value = 10;

    constructor() payable {}

    receive() external payable {}

    function deleteContract() external {
        // 调用selfdestruct销毁合约，并把剩余的ETH转给msg.sender
        selfdestruct(payable(msg.sender));
    }

    function getBalance() external view returns(uint balance){
        balance = address(this).balance;
    }
}

uint x = 10;
address addr = 0x7A58c0Be72BE218B41C608b7Fe7C5bB630736C71;
string name = "0xAA";
uint[2] array = [5, 6]; 

//  ABI被设计出来和合约交互，它将每个参数填充为32字节的数据，并拼接在一起。
function encode() public view returns(bytes memory result) {
    result = abi.encode(x, addr, name, array);
}

// 编码的结果为0x000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000007a58c0be72be218b41c608b7fe7c5bb630736c7100000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000005000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000043078414100000000000000000000000000000000000000000000000000000000，由于abi.encode将每个数据都填充为32字节，中间有很多0。

// 将给定参数根据其所需空间编码。类似abi.encode，但是会把很多0省略。
function encodePacked() public view returns(bytes memory result) {
    result = abi.encodePacked(x, addr, name, array);
}

// 编码的结果为0x000000000000000000000000000000000000000000000000000000000000000a7a58c0be72be218b41c608b7fe7c5bb630736c713078414100000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006，由于abi.encodePacked对编码进行了压缩，长度比abi.encode短很多。

//和abi.encode功能类似，只不过第一个参数为函数签名，比如"foo(uint256, address)"
function encodeWithSignature() public view returns(bytes memory result) {
    result = abi.encodeWithSignature("foo(uint256,address,string,uint256[2])", x, addr, name, array);
}

// 编码的结果为0xe87082f1000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000007a58c0be72be218b41c608b7fe7c5bb630736c7100000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000005000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000043078414100000000000000000000000000000000000000000000000000000000，等同于在abi.encode编码结果前加上了4字节的函数选择器1。

//和abi.encodeWithSignature功能类似，只不过第一个参数为函数选择器，为函数签名keccak哈希的前4个字节
function encodeWithSelector() public view returns(bytes memory result) {
    result = abi.encodeWithSelector(bytes4(keccak256("foo(uint256,address,string,uint256[2])")), x, addr, name, array);
}

// 0xe87082f1000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000007a58c0be72be218b41c608b7fe7c5bb630736c7100000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000005000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000043078414100000000000000000000000000000000000000000000000000000000，与abi.encodeWithSignature结果一样。

// abi.decode用于解码abi.encode生成的二进制编码，将它还原成原本的参数。
function decode(bytes memory data) public pure returns(uint dx, address daddr, string memory dname, uint[2] memory darray) {
    (dx, daddr, dname, darray) = abi.decode(data, (uint, address, string, uint[2]));
}

bytes4 selector = contract.getValue.selector;

bytes memory data = abi.encodeWithSelector(selector, _x);
(bool success, bytes memory returnedData) = address(contract).staticcall(data);
require(success);

return abi.decode(returnedData, (uint256));

const wavePortalContract = new ethers.Contract(contractAddress, contractABI, signer);
/*
* Call the getAllWaves method from your Smart Contract
*/
const waves = await wavePortalContract.getAllWaves();

bytes memory data = abi.encodeWithSelector(bytes4(0x533ba33a));

(bool success, bytes memory returnedData) = address(contract).staticcall(data);
require(success);

return abi.decode(returnedData, (uint256));

// event 返回msg.data
event Log(bytes data);

function mint(address to) external{
    emit Log(msg.data);
}

//当参数为0x2c44b726ADF1963cA47Af88B284C06f30380fC78时，输出的calldata为:
//0x6a6278420000000000000000000000002c44b726adf1963ca47af88b284c06f30380fc78

function mintSelector() external pure returns(bytes4 mSelector){
    return bytes4(keccak256("mint(address)"));
}

结果正是0x6a627842

function callWithSignature() external returns(bool, bytes memory){
    (bool success, bytes memory data) = address(this).call(abi.encodeWithSelector(0x6a627842, "0x2c44b726ADF1963cA47Af88B284C06f30380fC78"));
    return(success, data);
}

hash = keccak256(数据);

// 生成数据唯一标识
function hash(uint _num, string memory _string, address _addr) public pure returns(bytes32){
  return keccak256(abi.encodePacked(_num, _string, _addr));
}

try externalContract.f() {
    // call成功的情况下 运行一些代码
} catch {
    // call失败的情况下 运行一些代码
}