Wonderland

1// SPDX-License-Identifier: AGPL-3.0-or-later
2pragma solidity 0.7.5;
3​
4library SafeMath {
5    /**
6     * @dev Returns the addition of two unsigned integers, reverting on
7     * overflow.
8     *
9     * Counterpart to Solidity's `+` operator.
10     *
11     * Requirements:
12     *
13     * - Addition cannot overflow.
14     */
15    function add(uint256 a, uint256 b) internal pure returns (uint256) {
16        uint256 c = a + b;
17        require(c >= a, "SafeMath: addition overflow");
18​
19        return c;
20    }
21    function add32(uint32 a, uint32 b) internal pure returns (uint32) {
22        uint32 c = a + b;
23        require(c >= a, "SafeMath: addition overflow");
24​
25        return c;
26    }
27​
28    /**
29     * @dev Returns the subtraction of two unsigned integers, reverting on
30     * overflow (when the result is negative).
31     *
32     * Counterpart to Solidity's `-` operator.
33     *
34     * Requirements:
35     *
36     * - Subtraction cannot overflow.
37     */
38    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
39        return sub(a, b, "SafeMath: subtraction overflow");
40    }
41​
42    /**
43     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
44     * overflow (when the result is negative).
45     *
46     * Counterpart to Solidity's `-` operator.
47     *
48     * Requirements:
49     *
50     * - Subtraction cannot overflow.
51     */
52    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
53        require(b <= a, errorMessage);
54        uint256 c = a - b;
55​
56        return c;
57    }
58​
59    /**
60     * @dev Returns the multiplication of two unsigned integers, reverting on
61     * overflow.
62     *
63     * Counterpart to Solidity's `*` operator.
64     *
65     * Requirements:
66     *
67     * - Multiplication cannot overflow.
68     */
69    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
70        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
71        // benefit is lost if 'b' is also tested.
72        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
73        if (a == 0) {
74            return 0;
75        }
76​
77        uint256 c = a * b;
78        require(c / a == b, "SafeMath: multiplication overflow");
79​
80        return c;
81    }
82​
83    /**
84     * @dev Returns the integer division of two unsigned integers. Reverts on
85     * division by zero. The result is rounded towards zero.
86     *
87     * Counterpart to Solidity's `/` operator. Note: this function uses a
88     * `revert` opcode (which leaves remaining gas untouched) while Solidity
89     * uses an invalid opcode to revert (consuming all remaining gas).
90     *
91     * Requirements:
92     *
93     * - The divisor cannot be zero.
94     */
95    function div(uint256 a, uint256 b) internal pure returns (uint256) {
96        return div(a, b, "SafeMath: division by zero");
97    }
98​
99    /**
100     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
101     * division by zero. The result is rounded towards zero.
102     *
103     * Counterpart to Solidity's `/` operator. Note: this function uses a
104     * `revert` opcode (which leaves remaining gas untouched) while Solidity
105     * uses an invalid opcode to revert (consuming all remaining gas).
106     *
107     * Requirements:
108     *
109     * - The divisor cannot be zero.
110     */
111    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
112        require(b > 0, errorMessage);
113        uint256 c = a / b;
114        assert(a == b * c + a % b); // There is no case in which this doesn't hold
115​
116        return c;
117    }
118}
119​
120interface IERC20 {
121    function decimals() external view returns (uint8);
122  /**
123   * @dev Returns the amount of tokens in existence.
124   */
125  function totalSupply() external view returns (uint256);
126​
127  /**
128   * @dev Returns the amount of tokens owned by `account`.
129   */
130  function balanceOf(address account) external view returns (uint256);
131​
132  /**
133   * @dev Moves `amount` tokens from the caller's account to `recipient`.
134   *
135   * Returns a boolean value indicating whether the operation succeeded.
136   *
137   * Emits a {Transfer} event.
138   */
139  function transfer(address recipient, uint256 amount) external returns (bool);
140​
141  /**
142   * @dev Returns the remaining number of tokens that `spender` will be
143   * allowed to spend on behalf of `owner` through {transferFrom}. This is
144   * zero by default.
145   *
146   * This value changes when {approve} or {transferFrom} are called.
147   */
148  function allowance(address owner, address spender) external view returns (uint256);
149​
150  /**
151   * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
152   *
153   * Returns a boolean value indicating whether the operation succeeded.
154   *
155   * IMPORTANT: Beware that changing an allowance with this method brings the risk
156   * that someone may use both the old and the new allowance by unfortunate
157   * transaction ordering. One possible solution to mitigate this race
158   * condition is to first reduce the spender's allowance to 0 and set the
159   * desired value afterwards:
160   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
161   *
162   * Emits an {Approval} event.
163   */
164  function approve(address spender, uint256 amount) external returns (bool);
165​
166  /**
167   * @dev Moves `amount` tokens from `sender` to `recipient` using the
168   * allowance mechanism. `amount` is then deducted from the caller's
169   * allowance.
170   *
171   * Returns a boolean value indicating whether the operation succeeded.
172   *
173   * Emits a {Transfer} event.
174   */
175  function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
176​
177  /*
178   * @dev Emitted when `value` tokens are moved from one account (`from`) to
179   * another (`to`).
180   *
181   * Note that `value` may be zero.
182   */
183  event Transfer(address indexed from, address indexed to, uint256 value);
184​
185  /*
186   * @dev Emitted when the allowance of a `spender` for an `owner` is set by
187   * a call to {approve}. `value` is the new allowance.
188   */
189  event Approval(address indexed owner, address indexed spender, uint256 value);
190}
191​
192library Address {
193    /**
194     * @dev Returns true if `account` is a contract.
195     *
196     * [IMPORTANT]
197     * ====
198     * It is unsafe to assume that an address for which this function returns
199     * false is an externally-owned account (EOA) and not a contract.
200     *

Solidity Contracts