Quickswap

1/**
2 *Submitted for verification at Etherscan.io on 2020-09-16
3*/
4
5/**
6 *Submitted for verification at Etherscan.io on 2020-09-15
7*/
8
9pragma solidity ^0.5.16;
10pragma experimental ABIEncoderV2;
11
12// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
13// Subject to the MIT license.
14
15/**
16 * @dev Wrappers over Solidity's arithmetic operations with added overflow
17 * checks.
18 *
19 * Arithmetic operations in Solidity wrap on overflow. This can easily result
20 * in bugs, because programmers usually assume that an overflow raises an
21 * error, which is the standard behavior in high level programming languages.
22 * `SafeMath` restores this intuition by reverting the transaction when an
23 * operation overflows.
24 *
25 * Using this library instead of the unchecked operations eliminates an entire
26 * class of bugs, so it's recommended to use it always.
27 */
28library SafeMath {
29    /**
30     * @dev Returns the addition of two unsigned integers, reverting on overflow.
31     *
32     * Counterpart to Solidity's `+` operator.
33     *
34     * Requirements:
35     * - Addition cannot overflow.
36     */
37    function add(uint256 a, uint256 b) internal pure returns (uint256) {
38        uint256 c = a + b;
39        require(c >= a, "SafeMath: addition overflow");
40
41        return c;
42    }
43
44    /**
45     * @dev Returns the addition of two unsigned integers, reverting with custom message on overflow.
46     *
47     * Counterpart to Solidity's `+` operator.
48     *
49     * Requirements:
50     * - Addition cannot overflow.
51     */
52    function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
53        uint256 c = a + b;
54        require(c >= a, errorMessage);
55
56        return c;
57    }
58
59    /**
60     * @dev Returns the subtraction of two unsigned integers, reverting on underflow (when the result is negative).
61     *
62     * Counterpart to Solidity's `-` operator.
63     *
64     * Requirements:
65     * - Subtraction cannot underflow.
66     */
67    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
68        return sub(a, b, "SafeMath: subtraction underflow");
69    }
70
71    /**
72     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on underflow (when the result is negative).
73     *
74     * Counterpart to Solidity's `-` operator.
75     *
76     * Requirements:
77     * - Subtraction cannot underflow.
78     */
79    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
80        require(b <= a, errorMessage);
81        uint256 c = a - b;
82
83        return c;
84    }
85
86    /**
87     * @dev Returns the multiplication of two unsigned integers, reverting on overflow.
88     *
89     * Counterpart to Solidity's `*` operator.
90     *
91     * Requirements:
92     * - Multiplication cannot overflow.
93     */
94    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
95        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
96        // benefit is lost if 'b' is also tested.
97        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
98        if (a == 0) {
99            return 0;
100        }
101
102        uint256 c = a * b;
103        require(c / a == b, "SafeMath: multiplication overflow");
104
105        return c;
106    }
107
108    /**
109     * @dev Returns the multiplication of two unsigned integers, reverting on overflow.
110     *
111     * Counterpart to Solidity's `*` operator.
112     *
113     * Requirements:
114     * - Multiplication cannot overflow.
115     */
116    function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
117        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
118        // benefit is lost if 'b' is also tested.
119        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
120        if (a == 0) {
121            return 0;
122        }
123
124        uint256 c = a * b;
125        require(c / a == b, errorMessage);
126
127        return c;
128    }
129
130    /**
131     * @dev Returns the integer division of two unsigned integers.
132     * Reverts on division by zero. The result is rounded towards zero.
133     *
134     * Counterpart to Solidity's `/` operator. Note: this function uses a
135     * `revert` opcode (which leaves remaining gas untouched) while Solidity
136     * uses an invalid opcode to revert (consuming all remaining gas).
137     *
138     * Requirements:
139     * - The divisor cannot be zero.
140     */
141    function div(uint256 a, uint256 b) internal pure returns (uint256) {
142        return div(a, b, "SafeMath: division by zero");
143    }
144
145    /**
146     * @dev Returns the integer division of two unsigned integers.
147     * Reverts with custom message on division by zero. The result is rounded towards zero.
148     *
149     * Counterpart to Solidity's `/` operator. Note: this function uses a
150     * `revert` opcode (which leaves remaining gas untouched) while Solidity
151     * uses an invalid opcode to revert (consuming all remaining gas).
152     *
153     * Requirements:
154     * - The divisor cannot be zero.
155     */
156    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
157        // Solidity only automatically asserts when dividing by 0
158        require(b > 0, errorMessage);
159        uint256 c = a / b;
160        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
161
162        return c;
163    }
164
165    /**
166     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
167     * Reverts when dividing by zero.
168     *
169     * Counterpart to Solidity's `%` operator. This function uses a `revert`
170     * opcode (which leaves remaining gas untouched) while Solidity uses an
171     * invalid opcode to revert (consuming all remaining gas).
172     *
173     * Requirements:
174     * - The divisor cannot be zero.
175     */
176    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
177        return mod(a, b, "SafeMath: modulo by zero");
178    }
179
180    /**
181     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
182     * Reverts with custom message when dividing by zero.
183     *
184     * Counterpart to Solidity's `%` operator. This function uses a `revert`
185     * opcode (which leaves remaining gas untouched) while Solidity uses an
186     * invalid opcode to revert (consuming all remaining gas).
187     *
188     * Requirements:
189     * - The divisor cannot be zero.
190     */
191    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
192        require(b != 0, errorMessage);
193        return a % b;
194    }
195}
196
197contract Quick {
198    /// @notice EIP-20 token name for this token
199    string public constant name = "Quickswap";
200
201    /// @notice EIP-20 token symbol for this token
202    string public constant symbol = "QUICK";
203
204    /// @notice EIP-20 token decimals for this token
205    uint8 public constant decimals = 18;
206
207    /// @notice Total number of tokens in circulation
208    uint public totalSupply = 0; // QUICK
209
210    /// @notice Allowance amounts on behalf of others
211    mapping (address => mapping (address => uint96)) internal allowances;
212
213    /// @notice Official record of token balances for each account
214    mapping (address => uint96) internal balances;
215
216    /// @notice A record of each accounts delegate
217    mapping (address => address) public delegates;
218
219    /// @notice A checkpoint for marking number of votes from a given block
220    struct Checkpoint {
221        uint32 fromBlock;
222        uint96 votes;
223    }
224

JavaScript Tests