devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

solidity基础语法与简单案例20221202_solidity allowance

作者：你好赵伟 | 2024-02-16 01:46:43

赞

踩

solidity allowance

1、权限控制合约

核心： 

        嵌套映射 

功能：

        具有多种角色身份时，不同身份具有不同的权限

        角色=>账户=>权限

  1. // SPDX-License-Identifier:MIT
  2. pragma solidity ^0.8.7;
  3.  
  4. contract AccessControl{
  5.     event GrantRole(bytes32 indexed role, address indexed account);
  6.     event RevokeRole(bytes32 indexed role, address indexed account);
  7.     
  8.     //使用bytes代替字符串能够降低消耗的gas
  9.     mapping(bytes32 => mapping(address => bool)) public roles;
  10.  
  11.     //生成主键
  12.     // 0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42
  13.     bytes32 public constant ADMIN = keccak256(abi.encodePacked("ADMIN"));
  14.     //0x2db9fd3d099848027c2383d0a083396f6c41510d7acfd92adc99b6cffcf31e96
  15.     bytes32 public constant USER = keccak256(abi.encodePacked("USER"));
  16.  
  17.     constructor(){
  18.         _grantrole(ADMIN,msg.sender);
  19.     }
  20.  
  21.     modifier onlyRole(bytes32 _role){
  22.         require(roles[_role][msg.sender],"not authorized");
  23.         _;
  24.     }
  25.  
  26.     function _grantrole(bytes32 _role,address _account) internal {
  27.         roles[_role][_account] = true;
  28.         emit GrantRole(_role,_account);
  29.     }
  30.  
  31.     function grantRole(bytes32 _role,address _account) external onlyRole(ADMIN){
  32.         _grantrole(_role,_account);
  33.     }
  34.     function revokeRole(bytes32 _role,address _account) external onlyRole(ADMIN){
  35.         roles[_role][_account] = false;
  36.         emit RevokeRole(_role,_account);
  37.     }
  38. }

2、自毁合约

selfdesctruct(address)

该函数能够强行发送主币 

  1. // SPDX-License-Identifier:MIT
  2. pragma solidity ^0.8.7;
  3.  
  4. contract Kill{
  5.     constructor() payable{}
  6.  
  7.     function kill() external {
  8.         selfdestruct(payable(msg.sender));
  9.     }
  10.  
  11.     function testCall() external pure returns(uint){
  12.         return 123;
  13.     }
  14. }
  15. //测试强制发送主币、通过其他合约调用合约自毁功能，并获取主币
  16. contract Helper{
  17.     function getBalance() external view returns(uint){
  18.         return address(this).balance;
  19.     }
  20.     function kill(Kill _kill) external { 
  21.         _kill.kill();
  22.     }
  23. }

3、IERC20

ERC20代币标准：不是一套代码，而是一套具有目标功能的接口。

功能包括：

铸造代币、销毁代币

发行代币总额查询、记录并查询某地址代币余额；

向某地址发送一定数量代币；

A地址向B地址批准一定数量的代币、用户调用合约，从A地址向B地址发放一定数量的代币

  1. // SPDX-License-Identifier:MIT
  2. pragma solidity ^0.8.7;
  3.  
  4. interface IERC20{
  5.     //合约发布的代币总量
  6.     function totalSupply() external view returns (uint);
  7.     
  8.     //某一个账户的当前余额
  9.     function balanceOf(address account) external view returns (uint);
  10.  
  11.     //把当前账户一部分余额发送至另一个账户中
  12.     function transfer(address recipient, uint amount) external returns (bool);
  13.  
  14.     //查询某个账户中批准了多少金额
  15.     function allowance(address owner, address spender) external view returns (uint);
  16.  
  17.     //为某一个账户批准一定数量的资金 
  18.     function apporve(address spender,uint amount) external returns (bool);
  19.  
  20.     //从一个账户向另一个账户转移一定量资金
  21.     function transferFrom(address spender,address recipient,uint amount) external returns (bool);
  22.  
  23.     event Transfer(address indexed from,address indexed to,uint amount);
  24.     event Approval(address indexed owner, address indexed spender, uint amount);
  25. }
  26.  
  27. //合约ERC20继承IERC20，意味着ERC20用于实现相关接口
  28. contract ERC20 is IERC20 {
  29.     uint public override totalSupply;
  30.     mapping(address => uint) public override balanceOf;
  31.     //allowance:一个地址向另一个地址映射的数字
  32.     mapping(address => mapping(address => uint )) public override allowance;
  33.     //token name
  34.     string public name="Test";
  35.     string public symbol = "TEST";
  36.     //1*10^8代表了一个整数1
  37.     uint public decimals = 18;
  38.  
  39.     //把当前账户一部分余额发送至另一个账户中
  40.     function transfer(address recipient, uint amount) external override returns (bool){
  41.         balanceOf[msg.sender] -= amount;
  42.         balanceOf[recipient] += amount;
  43.         emit Transfer(msg.sender,recipient,amount);
  44.         return true;
  45.     }
  46.  
  47.     //为某一个账户批准一定数量的资金 
  48.     function apporve(address spender,uint amount) external override returns (bool){
  49.         allowance[msg.sender][spender] = amount;
  50.         emit Approval(msg.sender,spender,amount);
  51.         return true;
  52.     }
  53.  
  54.     //合约调用者要求从一个账户向另一个账户转移一定量资金
  55.     function transferFrom(address spender,address recipient,uint amount) external override returns (bool){
  56.         //合约调用者向代币发送者的账户中批准的余额降低
  57.         allowance[spender][msg.sender] -= amount;
  58.         //合约调用者的代币账户余额降低
  59.         balanceOf[spender] += amount;
  60.         //代币接收者的账户余额增加
  61.         balanceOf[recipient] += amount;
  62.         emit Transfer(spender,recipient,amount);
  63.         return true;
  64.     }
  65.  
  66.     //铸币
  67.     function mint(uint amount) external {
  68.         balanceOf[msg.sender] += amount;
  69.         totalSupply += amount;
  70.         emit Transfer(address(0),msg.sender,amount);
  71.     }
  72.  
  73.     //销毁
  74.     function burn(uint amount) external{
  75.         balanceOf[msg.sender] -= amount;
  76.         totalSupply -= amount;
  77.         emit Transfer(msg.sender,address(0),amount);
  78.     }
  79. }

4、多签钱包

必须有多个人同意的情况下才能把钱包里的钱转出。

  1. // SPDX-License-Identifier:MIT
  2. pragma solidity ^0.8.7;
  3.  
  4. contract MultiSigWallet{
  5.     event Deposit(address indexed sender,uint amount); //存款
  6.     event Submit(uint indexed txID); //提交一个交易申请
  7.     event Apporve(address indexed owner,uint indexed txId); //合约签名人进行批准
  8.     event Revoke(address indexed owner,uint indexed txID); //撤销批准
  9.     event Execute(uint indexed txID); //执行批准
  10.  
  11.     address[] public owners; //合约的拥有者
  12.     mapping(address => bool) public isOwner; //用于查找某用户是否是签名人
  13.     uint public required; //确认数，最少同意进行交易的人数
  14.  
  15.     struct Transaction {
  16.         address to;//发送的地址
  17.         uint value;//发送的主币数量
  18.         bytes data; //如果地址为合约地址，那么还能够执行一些合约中的函数
  19.         bool executed; // 标记交易是否执行成功
  20.     }
  21.  
  22.     Transaction[] public transactions;//构建一个交易数组，索引值即为ID号
  23.     mapping(uint => mapping(address => bool)) public approved; //某一个交易ID下，某一个地址是否批准了该交易
  24.     
  25.     modifier onlyOwner{
  26.         require(isOwner[msg.sender],"only owner!");
  27.         _;
  28.     }
  29.  
  30.     //判断交易id是否存在，由于id即索引，只要交易id小于数组长度，那么判断该交易存在
  31.     modifier txExists(uint _txId){
  32.         require(0<_txId && _txId< transactions.length,"tx does not exist");
  33.         _;
  34.     }
  35.  
  36.     //判断签字者是否已经同意
  37.     modifier notApproved(uint _txId){
  38.         require(!approved[_txId][msg.sender],"tx already approved");
  39.         _;
  40.     }
  41.  
  42.     //判断是否已经执行交易
  43.     modifier notExecuted(uint _txId){
  44.         require(!transactions[_txId].executed,"tx already executed");
  45.         _;
  46.     }
  47.  
  48.     //建立构造函数，用于添加管理者和最小批准人数
  49.     constructor(address[] memory _owners,uint _required){
  50.         require(_owners.length >0 ,"owner required");//要求管理者数量大于0
  51.         require( _required <= _owners.length,//要求最小批准人数大于0且小于等于管理者数量
  52.         "invaled required num"
  53.         );
  54.         //判断地址是否有效：无效地址判断：1、0地址；2、重复地址
  55.         for (uint i;i <_owners.length;i++){
  56.             address owner = _owners[i];
  57.             require(owner != address(0),"invaled owner");
  58.             require(!isOwner[owner],"owner is not unique"); //如果地址已经存在过，那么判断为无效地址
  59.         
  60.             isOwner[owner] = true;
  61.             owners.push(owner);
  62.         }
  63.  
  64.         required=_required;
  65.     }
  66.  
  67.     receive() external payable{
  68.         emit Deposit(msg.sender,msg.value);
  69.     }
  70.     
  71.     //构建交易事件提交函数
  72.     function submit(address _to, uint _value, bytes calldata _data) external onlyOwner{
  73.         transactions.push(Transaction({
  74.             to: _to,
  75.             value: _value,
  76.             data: _data,
  77.             executed: false
  78.         }));
  79.         emit Submit(transactions.length - 1);//交易it为数组-1
  80.     } 
  81.  
  82.     //构建交易事件批准函数
  83.     function approve(uint _txId)
  84.         external
  85.         onlyOwner
  86.         txExists(_txId)
  87.         notApproved(_txId)
  88.         notExecuted(_txId)
  89.     {
  90.         approved[_txId][msg.sender] = true;
  91.         emit Apporve(msg.sender,_txId);
  92.     }
  93.  
  94.     //计算事件有多少人批准了，获取事件批准数量
  95.     function _getApprocalCount(uint _txId) private view returns(uint count){
  96.        for(uint i;i<owners.length;i++){
  97.            if(approved[_txId][owners[i]]){
  98.                count += 1;
  99.            }
  100.        } 
  101.     }
  102.     function execute(uint _txId) external txExists(_txId) notExecuted(_txId){
  103.         require(_getApprocalCount(_txId)>required,"approvals < required");
  104.         Transaction storage transaction = transactions[_txId];
  105.         transaction.executed = true;
  106.  
  107.         (bool success,) = transaction.to.call{value:transaction.value}(
  108.             transaction.data
  109.         );
  110.         require(success,"tx failed");
  111.         emit Execute(_txId);
  112.     }
  113.     function revoke(uint _txId)
  114.         external
  115.         onlyOwner
  116.         txExists(_txId)
  117.         notExecuted(_txId)
  118.     {
  119.         require(approved[_txId][msg.sender],"tx not approved");
  120.         approved[_txId][msg.sender] = false;
  121.         emit Revoke(msg.sender,_txId);
  122.     }
  123.  
  124. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/89515
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号