iLayer

1abstract contract Context {
2    function _msgSender() internal view virtual returns (address payable) {
3        return payable(msg.sender);
4    }
5​
6    function _msgData() internal view virtual returns (bytes memory) {
7        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
8        return msg.data;
9    }
10}
11​
12​
13interface IERC20 {
14​
15    function totalSupply() external view returns (uint256);
16    function balanceOf(address account) external view returns (uint256);
17    function transfer(address recipient, uint256 amount) external returns (bool);
18    function allowance(address owner, address spender) external view returns (uint256);
19    function approve(address spender, uint256 amount) external returns (bool);
20    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
21    event Transfer(address indexed from, address indexed to, uint256 value);
22    event Approval(address indexed owner, address indexed spender, uint256 value);
23    
24​
25}
26​
27library SafeMath {
28​
29    function add(uint256 a, uint256 b) internal pure returns (uint256) {
30        uint256 c = a + b;
31        require(c >= a, "SafeMath: addition overflow");
32​
33        return c;
34    }
35​
36    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
37        return sub(a, b, "SafeMath: subtraction overflow");
38    }
39​
40    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
41        require(b <= a, errorMessage);
42        uint256 c = a - b;
43​
44        return c;
45    }
46​
47    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
48        if (a == 0) {
49            return 0;
50        }
51​
52        uint256 c = a * b;
53        require(c / a == b, "SafeMath: multiplication overflow");
54​
55        return c;
56    }
57​
58​
59    function div(uint256 a, uint256 b) internal pure returns (uint256) {
60        return div(a, b, "SafeMath: division by zero");
61    }
62​
63    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
64        require(b > 0, errorMessage);
65        uint256 c = a / b;
66        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
67​
68        return c;
69    }
70​
71    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
72        return mod(a, b, "SafeMath: modulo by zero");
73    }
74​
75    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
76        require(b != 0, errorMessage);
77        return a % b;
78    }
79}
80​
81library Address {
82​
83    function isContract(address account) internal view returns (bool) {
84        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
85        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
86        / for accounts without code, i.e. `keccak256('')`
87        bytes32 codehash;
88        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
89        / solhint-disable-next-line no-inline-assembly
90        assembly { codehash := extcodehash(account) }
91        return (codehash != accountHash && codehash != 0x0);
92    }
93​
94    function sendValue(address payable recipient, uint256 amount) internal {
95        require(address(this).balance >= amount, "Address: insufficient balance");
96​
97        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
98        (bool success, ) = recipient.call{ value: amount }("");
99        require(success, "Address: unable to send value, recipient may have reverted");
100    }
101​
102​
103    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
104      return functionCall(target, data, "Address: low-level call failed");
105    }
106​
107    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
108        return _functionCallWithValue(target, data, 0, errorMessage);
109    }
110​
111    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
112        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
113    }
114​
115    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
116        require(address(this).balance >= value, "Address: insufficient balance for call");
117        return _functionCallWithValue(target, data, value, errorMessage);
118    }
119​
120    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
121        require(isContract(target), "Address: call to non-contract");
122​
123        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
124        if (success) {
125            return returndata;
126        } else {
127            
128            if (returndata.length > 0) {
129                assembly {
130                    let returndata_size := mload(returndata)
131                    revert(add(32, returndata), returndata_size)
132                }
133            } else {
134                revert(errorMessage);
135            }
136        }
137    }
138}
139​
140contract Ownable is Context {
141    address private _owner;
142    address private _previousOwner;
143    uint256 private _lockTime;
144​
145    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
146​
147    constructor () {
148        address msgSender = _msgSender();
149        _owner = msgSender;
150        emit OwnershipTransferred(address(0), msgSender);
151    }
152​
153    function owner() public view returns (address) {
154        return _owner;
155    }   
156    
157    modifier onlyOwner() {
158        require(_owner == _msgSender(), "Ownable: caller is not the owner");
159        _;
160    }
161    
162    function renounceOwnership() public virtual onlyOwner {
163        emit OwnershipTransferred(_owner, address(0));
164        _owner = address(0);
165    }

Solidity Contracts

JavaScript Tests