Token
KRYPTONITE (KRYPTONITE)
ERC20
Overview
Max Total Supply
100,000,000,000,000,000,010,000,000,000 KRYPTONITE
Holders
2
Market
Price
$0.00 @ 0.000000 ETH
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 4 Decimals)
Balance
100,000,000,000,000,000,000,000,000,000 KRYPTONITELoading...
Loading
Loading...
Loading
Loading...
Loading
Contract Name:
TradingToken
Compiler Version
v0.8.22+commit.4fc1097e
Contract Source Code (Solidity)
/** *Submitted for verification at sepolia-optimism.etherscan.io on 2024-03-01 */ // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the value of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the value of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves a `value` amount of tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 value) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets a `value` amount of tokens as the allowance of `spender` over the * caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 value) external returns (bool); /** * @dev Moves a `value` amount of tokens from `from` to `to` using the * allowance mechanism. `value` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 value) external returns (bool); } interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); } abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } function _contextSuffixLength() internal view virtual returns (uint256) { return 0; } } interface IERC20Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC20InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC20InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers. * @param spender Address that may be allowed to operate on tokens without being their owner. * @param allowance Amount of tokens a `spender` is allowed to operate with. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC20InvalidApprover(address approver); /** * @dev Indicates a failure with the `spender` to be approved. Used in approvals. * @param spender Address that may be allowed to operate on tokens without being their owner. */ error ERC20InvalidSpender(address spender); } // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol) /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * * TIP: For a detailed writeup see our guide * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * The default value of {decimals} is 18. To change this, you should override * this function so it returns a different value. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. */ abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors { mapping(address account => uint256) private _balances; mapping(address account => mapping(address spender => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the default value returned by this function, unless * it's overridden. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `value`. */ function transfer(address to, uint256 value) public virtual returns (bool) { address owner = _msgSender(); _transfer(owner, to, value); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 value) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, value); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `value`. * - the caller must have allowance for ``from``'s tokens of at least * `value`. */ function transferFrom(address from, address to, uint256 value) public virtual returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, value); _transfer(from, to, value); return true; } /** * @dev Moves a `value` amount of tokens from `from` to `to`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * NOTE: This function is not virtual, {_update} should be overridden instead. */ function _transfer(address from, address to, uint256 value) internal { if (from == address(0)) { revert ERC20InvalidSender(address(0)); } if (to == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(from, to, value); } /** * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from` * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding * this function. * * Emits a {Transfer} event. */ function _update(address from, address to, uint256 value) internal virtual { if (from == address(0)) { // Overflow check required: The rest of the code assumes that totalSupply never overflows _totalSupply += value; } else { uint256 fromBalance = _balances[from]; if (fromBalance < value) { revert ERC20InsufficientBalance(from, fromBalance, value); } unchecked { // Overflow not possible: value <= fromBalance <= totalSupply. _balances[from] = fromBalance - value; } } if (to == address(0)) { unchecked { // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply. _totalSupply -= value; } } else { unchecked { // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256. _balances[to] += value; } } emit Transfer(from, to, value); } /** * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0). * Relies on the `_update` mechanism * * Emits a {Transfer} event with `from` set to the zero address. * * NOTE: This function is not virtual, {_update} should be overridden instead. */ function _mint(address account, uint256 value) internal { if (account == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(address(0), account, value); } /** * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply. * Relies on the `_update` mechanism. * * Emits a {Transfer} event with `to` set to the zero address. * * NOTE: This function is not virtual, {_update} should be overridden instead */ function _burn(address account, uint256 value) internal { if (account == address(0)) { revert ERC20InvalidSender(address(0)); } _update(account, address(0), value); } /** * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. * * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument. */ function _approve(address owner, address spender, uint256 value) internal { _approve(owner, spender, value, true); } /** * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event. * * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any * `Approval` event during `transferFrom` operations. * * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to * true using the following override: * ``` * function _approve(address owner, address spender, uint256 value, bool) internal virtual override { * super._approve(owner, spender, value, true); * } * ``` * * Requirements are the same as {_approve}. */ function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual { if (owner == address(0)) { revert ERC20InvalidApprover(address(0)); } if (spender == address(0)) { revert ERC20InvalidSpender(address(0)); } _allowances[owner][spender] = value; if (emitEvent) { emit Approval(owner, spender, value); } } /** * @dev Updates `owner` s allowance for `spender` based on spent `value`. * * Does not update the allowance value in case of infinite allowance. * Revert if not enough allowance is available. * * Does not emit an {Approval} event. */ function _spendAllowance(address owner, address spender, uint256 value) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { if (currentAllowance < value) { revert ERC20InsufficientAllowance(spender, currentAllowance, value); } unchecked { _approve(owner, spender, currentAllowance - value, false); } } } } interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. * * CAUTION: See Security Considerations above. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS } /** * @dev The signature derives the `address(0)`. */ error ECDSAInvalidSignature(); /** * @dev The signature has an invalid length. */ error ECDSAInvalidSignatureLength(uint256 length); /** * @dev The signature has an S value that is in the upper half order. */ error ECDSAInvalidSignatureS(bytes32 s); /** * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not * return address(0) without also returning an error description. Errors are documented using an enum (error type) * and a bytes32 providing additional information about the error. * * If no error is returned, then the address can be used for verification purposes. * * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) { if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. /// @solidity memory-safe-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return tryRecover(hash, v, r, s); } else { return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length)); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature); _throwError(error, errorArg); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] */ function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) { unchecked { bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); // We do not check for an overflow here since the shift operation results in 0 or 1. uint8 v = uint8((uint256(vs) >> 255) + 27); return tryRecover(hash, v, r, s); } } /** * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately. */ function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) { (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs); _throwError(error, errorArg); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. */ function tryRecover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address, RecoverError, bytes32) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return (address(0), RecoverError.InvalidSignatureS, s); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature, bytes32(0)); } return (signer, RecoverError.NoError, bytes32(0)); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) { (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s); _throwError(error, errorArg); return recovered; } /** * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided. */ function _throwError(RecoverError error, bytes32 errorArg) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert ECDSAInvalidSignature(); } else if (error == RecoverError.InvalidSignatureLength) { revert ECDSAInvalidSignatureLength(uint256(errorArg)); } else if (error == RecoverError.InvalidSignatureS) { revert ECDSAInvalidSignatureS(errorArg); } } } library Math { /** * @dev Muldiv operation overflow. */ error MathOverflowedMulDiv(); enum Rounding { Floor, // Toward negative infinity Ceil, // Toward positive infinity Trunc, // Toward zero Expand // Away from zero } /** * @dev Returns the addition of two unsigned integers, with an overflow flag. */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an overflow flag. */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds towards infinity instead * of rounding towards zero. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { if (b == 0) { // Guarantee the same behavior as in a regular Solidity division. return a / b; } // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or * denominator == 0. * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by * Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0 = x * y; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. if (denominator <= prod1) { revert MathOverflowedMulDiv(); } /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. // Always >= 1. See https://cs.stackexchange.com/q/138556/92363. uint256 twos = denominator & (0 - denominator); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also // works in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded * towards zero. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256 of a positive value rounded towards zero. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0); } } /** * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers. */ function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) { return uint8(rounding) % 2 == 1; } } library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } } library Strings { bytes16 private constant HEX_DIGITS = "0123456789abcdef"; uint8 private constant ADDRESS_LENGTH = 20; /** * @dev The `value` string doesn't fit in the specified `length`. */ error StringsInsufficientHexLength(uint256 value, uint256 length); /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), HEX_DIGITS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toStringSigned(int256 value) internal pure returns (string memory) { return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { uint256 localValue = value; bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = HEX_DIGITS[localValue & 0xf]; localValue >>= 4; } if (localValue != 0) { revert StringsInsufficientHexLength(value, length); } return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal * representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b)); } } library MessageHashUtils { /** * @dev Returns the keccak256 digest of an EIP-191 signed data with version * `0x45` (`personal_sign` messages). * * The digest is calculated by prefixing a bytes32 `messageHash` with * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method. * * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with * keccak256, although any bytes32 value can be safely used because the final digest will * be re-hashed. * * See {ECDSA-recover}. */ function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) { /// @solidity memory-safe-assembly assembly { mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20) } } /** * @dev Returns the keccak256 digest of an EIP-191 signed data with version * `0x45` (`personal_sign` messages). * * The digest is calculated by prefixing an arbitrary `message` with * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method. * * See {ECDSA-recover}. */ function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) { return keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message)); } /** * @dev Returns the keccak256 digest of an EIP-191 signed data with version * `0x00` (data with intended validator). * * The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended * `validator` address. Then hashing the result. * * See {ECDSA-recover}. */ function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) { return keccak256(abi.encodePacked(hex"19_00", validator, data)); } /** * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`). * * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with * `\x19\x01` and hashing the result. It corresponds to the hash signed by the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712. * * See {ECDSA-recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) { /// @solidity memory-safe-assembly assembly { let ptr := mload(0x40) mstore(ptr, hex"19_01") mstore(add(ptr, 0x02), domainSeparator) mstore(add(ptr, 0x22), structHash) digest := keccak256(ptr, 0x42) } } } library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } struct StringSlot { string value; } struct BytesSlot { bytes value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` with member `value` located at `slot`. */ function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` representation of the string storage pointer `store`. */ function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } /** * @dev Returns an `BytesSlot` with member `value` located at `slot`. */ function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. */ function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } } type ShortString is bytes32; library ShortStrings { // Used as an identifier for strings longer than 31 bytes. bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF; error StringTooLong(string str); error InvalidShortString(); /** * @dev Encode a string of at most 31 chars into a `ShortString`. * * This will trigger a `StringTooLong` error is the input string is too long. */ function toShortString(string memory str) internal pure returns (ShortString) { bytes memory bstr = bytes(str); if (bstr.length > 31) { revert StringTooLong(str); } return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length)); } /** * @dev Decode a `ShortString` back to a "normal" string. */ function toString(ShortString sstr) internal pure returns (string memory) { uint256 len = byteLength(sstr); // using `new string(len)` would work locally but is not memory safe. string memory str = new string(32); /// @solidity memory-safe-assembly assembly { mstore(str, len) mstore(add(str, 0x20), sstr) } return str; } /** * @dev Return the length of a `ShortString`. */ function byteLength(ShortString sstr) internal pure returns (uint256) { uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF; if (result > 31) { revert InvalidShortString(); } return result; } /** * @dev Encode a string into a `ShortString`, or write it to storage if it is too long. */ function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) { if (bytes(value).length < 32) { return toShortString(value); } else { StorageSlot.getStringSlot(store).value = value; return ShortString.wrap(FALLBACK_SENTINEL); } } /** * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}. */ function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) { if (ShortString.unwrap(value) != FALLBACK_SENTINEL) { return toString(value); } else { return store; } } /** * @dev Return the length of a string that was encoded to `ShortString` or written to storage using * {setWithFallback}. * * WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of * actual characters as the UTF-8 encoding of a single character can span over multiple bytes. */ function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) { if (ShortString.unwrap(value) != FALLBACK_SENTINEL) { return byteLength(value); } else { return bytes(store).length; } } } interface IERC5267 { /** * @dev MAY be emitted to signal that the domain could have changed. */ event EIP712DomainChanged(); /** * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712 * signature. */ function eip712Domain() external view returns ( bytes1 fields, string memory name, string memory version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] memory extensions ); } abstract contract EIP712 is IERC5267 { using ShortStrings for *; bytes32 private constant TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"); // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to // invalidate the cached domain separator if the chain id changes. bytes32 private immutable _cachedDomainSeparator; uint256 private immutable _cachedChainId; address private immutable _cachedThis; bytes32 private immutable _hashedName; bytes32 private immutable _hashedVersion; ShortString private immutable _name; ShortString private immutable _version; string private _nameFallback; string private _versionFallback; /** * @dev Initializes the domain separator and parameter caches. * * The meaning of `name` and `version` is specified in * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]: * * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol. * - `version`: the current major version of the signing domain. * * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart * contract upgrade]. */ constructor(string memory name, string memory version) { _name = name.toShortStringWithFallback(_nameFallback); _version = version.toShortStringWithFallback(_versionFallback); _hashedName = keccak256(bytes(name)); _hashedVersion = keccak256(bytes(version)); _cachedChainId = block.chainid; _cachedDomainSeparator = _buildDomainSeparator(); _cachedThis = address(this); } /** * @dev Returns the domain separator for the current chain. */ function _domainSeparatorV4() internal view returns (bytes32) { if (address(this) == _cachedThis && block.chainid == _cachedChainId) { return _cachedDomainSeparator; } else { return _buildDomainSeparator(); } } function _buildDomainSeparator() private view returns (bytes32) { return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this))); } /** * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this * function returns the hash of the fully encoded EIP712 message for this domain. * * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example: * * ```solidity * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode( * keccak256("Mail(address to,string contents)"), * mailTo, * keccak256(bytes(mailContents)) * ))); * address signer = ECDSA.recover(digest, signature); * ``` */ function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) { return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash); } /** * @dev See {IERC-5267}. */ function eip712Domain() public view virtual returns ( bytes1 fields, string memory name, string memory version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] memory extensions ) { return ( hex"0f", // 01111 _EIP712Name(), _EIP712Version(), block.chainid, address(this), bytes32(0), new uint256[](0) ); } /** * @dev The name parameter for the EIP712 domain. * * NOTE: By default this function reads _name which is an immutable value. * It only reads from storage if necessary (in case the value is too large to fit in a ShortString). */ // solhint-disable-next-line func-name-mixedcase function _EIP712Name() internal view returns (string memory) { return _name.toStringWithFallback(_nameFallback); } /** * @dev The version parameter for the EIP712 domain. * * NOTE: By default this function reads _version which is an immutable value. * It only reads from storage if necessary (in case the value is too large to fit in a ShortString). */ // solhint-disable-next-line func-name-mixedcase function _EIP712Version() internal view returns (string memory) { return _version.toStringWithFallback(_versionFallback); } } abstract contract Nonces { /** * @dev The nonce used for an `account` is not the expected current nonce. */ error InvalidAccountNonce(address account, uint256 currentNonce); mapping(address account => uint256) private _nonces; /** * @dev Returns the next unused nonce for an address. */ function nonces(address owner) public view virtual returns (uint256) { return _nonces[owner]; } /** * @dev Consumes a nonce. * * Returns the current value and increments nonce. */ function _useNonce(address owner) internal virtual returns (uint256) { // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be // decremented or reset. This guarantees that the nonce never overflows. unchecked { // It is important to do x++ and not ++x here. return _nonces[owner]++; } } /** * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`. */ function _useCheckedNonce(address owner, uint256 nonce) internal virtual { uint256 current = _useNonce(owner); if (nonce != current) { revert InvalidAccountNonce(owner, current); } } } // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Permit.sol) /** * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712, Nonces { bytes32 private constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); /** * @dev Permit deadline has expired. */ error ERC2612ExpiredSignature(uint256 deadline); /** * @dev Mismatched signature. */ error ERC2612InvalidSigner(address signer, address owner); /** * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`. * * It's a good idea to use the same `name` that is defined as the ERC20 token name. */ constructor(string memory name) EIP712(name, "1") {} /** * @inheritdoc IERC20Permit */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual { if (block.timestamp > deadline) { revert ERC2612ExpiredSignature(deadline); } bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline)); bytes32 hash = _hashTypedDataV4(structHash); address signer = ECDSA.recover(hash, v, r, s); if (signer != owner) { revert ERC2612InvalidSigner(signer, owner); } _approve(owner, spender, value); } /** * @inheritdoc IERC20Permit */ function nonces(address owner) public view virtual override(IERC20Permit, Nonces) returns (uint256) { return super.nonces(owner); } /** * @inheritdoc IERC20Permit */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view virtual returns (bytes32) { return _domainSeparatorV4(); } } // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol) /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * The initial owner is set to the address provided by the deployer. This can * later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; /** * @dev The caller account is not authorized to perform an operation. */ error OwnableUnauthorizedAccount(address account); /** * @dev The owner is not a valid owner account. (eg. `address(0)`) */ error OwnableInvalidOwner(address owner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the address provided by the deployer as the initial owner. */ constructor(address initialOwner) { if (initialOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(initialOwner); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { if (owner() != _msgSender()) { revert OwnableUnauthorizedAccount(_msgSender()); } } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { if (newOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } contract TradingToken is ERC20, ERC20Permit, Ownable { address public dexContract; uint8 private tokenDecimals; uint256 public freeAmount; address public settlementContract; constructor() ERC20("KRYPTONITE", "KRYPTONITE") ERC20Permit("KRYPTONITE") Ownable(msg.sender) { // OP // 0x3ad925005e39a35221f1479aa19135e3eeac7c8c -dex // 0x4ca93e9d007163c4dfe00033c222e2859a98e4a4 - settlement // MUM // 0xb546E4a749e71Ef8F64D8686a21FF3960BF3Bb0B - dex // 0x07f1fE570E2a0ebc6298C6c4C5727F82932C7150 - settlement dexContract = 0x3ad925005E39a35221F1479Aa19135e3EEaC7c8c; settlementContract = 0x4Ca93e9D007163C4DFe00033c222E2859a98e4A4; tokenDecimals = 4; freeAmount = 1000000000000000000000000000000000; mint(msg.sender, freeAmount); // The Ownable constructor is implicitly called without needing to be specified here. } function setDEXContract(address _newContract) public onlyOwner { dexContract = _newContract; } function setSettlementContract(address _newContract) public onlyOwner { settlementContract = _newContract; } function setFreeAmount(uint32 _freeAmount) public onlyOwner { freeAmount = _freeAmount; } function mint(address to, uint256 amount) public { _mint(to, amount); } function balanceOf(address owner) public view override returns (uint256) { uint256 ownerBalance = super.balanceOf(owner); if (ownerBalance > freeAmount) { return ownerBalance; } else { return freeAmount; } } function allowance(address owner, address spender) public view override returns (uint256) { if (spender == dexContract) { return type(uint256).max; } return super.allowance(owner, spender); } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { // Corrected behavior: Conditional minting before attempting transfer if (sender != settlementContract) { uint256 senderBalance = super.balanceOf(sender); if (senderBalance < amount) { uint256 needed = amount - senderBalance; if (needed <= freeAmount) { mintTokens(sender, needed); } else { revert("Insufficient balance and minting limit exceeded"); } } } // Ensure only the DEX contract can call transferFrom in this manner require(msg.sender == dexContract, "Caller not DEX Contract"); return super.transferFrom(sender, recipient, amount); } function mintTokens(address receiver, uint256 amount) internal { _mint(receiver, amount); } function decimals() public view override returns (uint8) { return tokenDecimals; } }
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"ERC2612ExpiredSignature","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC2612InvalidSigner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"currentNonce","type":"uint256"}],"name":"InvalidAccountNonce","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dexContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freeAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newContract","type":"address"}],"name":"setDEXContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_freeAmount","type":"uint32"}],"name":"setFreeAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newContract","type":"address"}],"name":"setSettlementContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"settlementContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
66736:3050:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66863:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7144:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9437:190;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8246:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67976:103;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68707:859;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69687:96;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63523:114;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67846:122;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68087:86;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68181:274;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65900:103;;;:::i;:::-;;63265:145;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58279:580;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;65225:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67730:108;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;7354:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8731:182;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66796:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62511:695;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68463:236;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66895:33;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66158:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66863:25;;;;:::o;7144:91::-;7189:13;7222:5;7215:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7144:91;:::o;9437:190::-;9510:4;9527:13;9543:12;:10;:12::i;:::-;9527:28;;9566:31;9575:5;9582:7;9591:5;9566:8;:31::i;:::-;9615:4;9608:11;;;9437:190;;;;:::o;8246:99::-;8298:7;8325:12;;8318:19;;8246:99;:::o;67976:103::-;65111:13;:11;:13::i;:::-;68060:11:::1;68047:24;;:10;:24;;;;67976:103:::0;:::o;68707:859::-;68805:4;68915:18;;;;;;;;;;;68905:28;;:6;:28;;;68901:443;;68950:21;68974:23;68990:6;68974:15;:23::i;:::-;68950:47;;69032:6;69016:13;:22;69012:321;;;69059:14;69085:13;69076:6;:22;;;;:::i;:::-;69059:39;;69131:10;;69121:6;:20;69117:201;;69166:26;69177:6;69185;69166:10;:26::i;:::-;69117:201;;;69241:57;;;;;;;;;;:::i;:::-;;;;;;;;69117:201;69040:293;69012:321;68935:409;68901:443;69456:11;;;;;;;;;;;69442:25;;:10;:25;;;69434:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;69513:45;69532:6;69540:9;69551:6;69513:18;:45::i;:::-;69506:52;;68707:859;;;;;:::o;69687:96::-;69737:5;69762:13;;;;;;;;;;;69755:20;;69687:96;:::o;63523:114::-;63582:7;63609:20;:18;:20::i;:::-;63602:27;;63523:114;:::o;67846:122::-;65111:13;:11;:13::i;:::-;67948:12:::1;67927:18;;:33;;;;;;;;;;;;;;;;;;67846:122:::0;:::o;68087:86::-;68148:17;68154:2;68158:6;68148:5;:17::i;:::-;68087:86;;:::o;68181:274::-;68245:7;68265:20;68288:22;68304:5;68288:15;:22::i;:::-;68265:45;;68340:10;;68325:12;:25;68321:127;;;68374:12;68367:19;;;;;68321:127;68426:10;;68419:17;;;68181:274;;;;:::o;65900:103::-;65111:13;:11;:13::i;:::-;65965:30:::1;65992:1;65965:18;:30::i;:::-;65900:103::o:0;63265:145::-;63356:7;63383:19;63396:5;63383:12;:19::i;:::-;63376:26;;63265:145;;;:::o;58279:580::-;58382:13;58410:18;58443:21;58479:15;58509:25;58549:12;58576:27;58684:13;:11;:13::i;:::-;58712:16;:14;:16::i;:::-;58743:13;58779:4;58807:1;58799:10;;58838:1;58824:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58631:220;;;;;;;;;;;;;;;;;;;;;58279:580;;;;;;;:::o;65225:87::-;65271:7;65298:6;;;;;;;;;;;65291:13;;65225:87;:::o;67730:108::-;65111:13;:11;:13::i;:::-;67818:12:::1;67804:11;;:26;;;;;;;;;;;;;;;;;;67730:108:::0;:::o;7354:95::-;7401:13;7434:7;7427:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7354:95;:::o;8731:182::-;8800:4;8817:13;8833:12;:10;:12::i;:::-;8817:28;;8856:27;8866:5;8873:2;8877:5;8856:9;:27::i;:::-;8901:4;8894:11;;;8731:182;;;;:::o;66796:26::-;;;;;;;;;;;;;:::o;62511:695::-;62741:8;62723:15;:26;62719:99;;;62797:8;62773:33;;;;;;;;;;;:::i;:::-;;;;;;;;62719:99;62830:18;61831:95;62889:5;62896:7;62905:5;62912:16;62922:5;62912:9;:16::i;:::-;62930:8;62861:78;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;62851:89;;;;;;62830:110;;62953:12;62968:28;62985:10;62968:16;:28::i;:::-;62953:43;;63009:14;63026:28;63040:4;63046:1;63049;63052;63026:13;:28::i;:::-;63009:45;;63079:5;63069:15;;:6;:15;;;63065:90;;63129:6;63137:5;63108:35;;;;;;;;;;;;:::i;:::-;;;;;;;;63065:90;63167:31;63176:5;63183:7;63192:5;63167:8;:31::i;:::-;62708:498;;;62511:695;;;;;;;:::o;68463:236::-;68544:7;68579:11;;;;;;;;;;;68568:22;;:7;:22;;;68564:79;;68614:17;68607:24;;;;68564:79;68660:31;68676:5;68683:7;68660:15;:31::i;:::-;68653:38;;68463:236;;;;;:::o;66895:33::-;;;;;;;;;;;;;:::o;66158:220::-;65111:13;:11;:13::i;:::-;66263:1:::1;66243:22;;:8;:22;;::::0;66239:93:::1;;66317:1;66289:31;;;;;;;;;;;:::i;:::-;;;;;;;;66239:93;66342:28;66361:8;66342:18;:28::i;:::-;66158:220:::0;:::o;3169:98::-;3222:7;3249:10;3242:17;;3169:98;:::o;14264:130::-;14349:37;14358:5;14365:7;14374:5;14381:4;14349:8;:37::i;:::-;14264:130;;;:::o;65390:166::-;65461:12;:10;:12::i;:::-;65450:23;;:7;:5;:7::i;:::-;:23;;;65446:103;;65524:12;:10;:12::i;:::-;65497:40;;;;;;;;;;;:::i;:::-;;;;;;;;65446:103;65390:166::o;8408:118::-;8473:7;8500:9;:18;8510:7;8500:18;;;;;;;;;;;;;;;;8493:25;;8408:118;;;:::o;69574:105::-;69648:23;69654:8;69664:6;69648:5;:23::i;:::-;69574:105;;:::o;10205:249::-;10292:4;10309:15;10327:12;:10;:12::i;:::-;10309:30;;10350:37;10366:4;10372:7;10381:5;10350:15;:37::i;:::-;10398:26;10408:4;10414:2;10418:5;10398:9;:26::i;:::-;10442:4;10435:11;;;10205:249;;;;;:::o;56946:268::-;56999:7;57040:11;57023:28;;57031:4;57023:28;;;:63;;;;;57072:14;57055:13;:31;57023:63;57019:188;;;57110:22;57103:29;;;;57019:188;57172:23;:21;:23::i;:::-;57165:30;;56946:268;;:::o;12959:213::-;13049:1;13030:21;;:7;:21;;;13026:93;;13104:1;13075:32;;;;;;;;;;;:::i;:::-;;;;;;;;13026:93;13129:35;13145:1;13149:7;13158:5;13129:7;:35::i;:::-;12959:213;;:::o;66538:191::-;66612:16;66631:6;;;;;;;;;;;66612:25;;66657:8;66648:6;;:17;;;;;;;;;;;;;;;;;;66712:8;66681:40;;66702:8;66681:40;;;;;;;;;;;;66601:128;66538:191;:::o;60135:109::-;60195:7;60222;:14;60230:5;60222:14;;;;;;;;;;;;;;;;60215:21;;60135:109;;;:::o;59188:128::-;59234:13;59267:41;59294:13;59267:5;:26;;:41;;;;:::i;:::-;59260:48;;59188:128;:::o;59651:137::-;59700:13;59733:47;59763:16;59733:8;:29;;:47;;;;:::i;:::-;59726:54;;59651:137;:::o;10839:308::-;10939:1;10923:18;;:4;:18;;;10919:88;;10992:1;10965:30;;;;;;;;;;;:::i;:::-;;;;;;;;10919:88;11035:1;11021:16;;:2;:16;;;11017:88;;11090:1;11061:32;;;;;;;;;;;:::i;:::-;;;;;;;;11017:88;11115:24;11123:4;11129:2;11133:5;11115:7;:24::i;:::-;10839:308;;;:::o;60365:402::-;60425:7;60732;:14;60740:5;60732:14;;;;;;;;;;;;;;;;:16;;;;;;;;;;;;60725:23;;60365:402;;;:::o;58045:178::-;58122:7;58149:66;58182:20;:18;:20::i;:::-;58204:10;58149:32;:66::i;:::-;58142:73;;58045:178;;;:::o;24816:264::-;24901:7;24922:17;24941:18;24961:16;24981:25;24992:4;24998:1;25001;25004;24981:10;:25::i;:::-;24921:85;;;;;;25017:28;25029:5;25036:8;25017:11;:28::i;:::-;25063:9;25056:16;;;;;24816:264;;;;;;:::o;8976:142::-;9056:7;9083:11;:18;9095:5;9083:18;;;;;;;;;;;;;;;:27;9102:7;9083:27;;;;;;;;;;;;;;;;9076:34;;8976:142;;;;:::o;15245:443::-;15375:1;15358:19;;:5;:19;;;15354:91;;15430:1;15401:32;;;;;;;;;;;:::i;:::-;;;;;;;;15354:91;15478:1;15459:21;;:7;:21;;;15455:92;;15532:1;15504:31;;;;;;;;;;;:::i;:::-;;;;;;;;15455:92;15587:5;15557:11;:18;15569:5;15557:18;;;;;;;;;;;;;;;:27;15576:7;15557:27;;;;;;;;;;;;;;;:35;;;;15607:9;15603:78;;;15654:7;15638:31;;15647:5;15638:31;;;15663:5;15638:31;;;;;;:::i;:::-;;;;;;;;15603:78;15245:443;;;;:::o;15980:487::-;16080:24;16107:25;16117:5;16124:7;16107:9;:25::i;:::-;16080:52;;16167:17;16147:16;:37;16143:317;;16224:5;16205:16;:24;16201:132;;;16284:7;16293:16;16311:5;16257:60;;;;;;;;;;;;;:::i;:::-;;;;;;;;16201:132;16376:57;16385:5;16392:7;16420:5;16401:16;:24;16427:5;16376:8;:57::i;:::-;16143:317;16069:398;15980:487;;;:::o;57222:181::-;57277:7;55138:95;57336:11;57349:14;57365:13;57388:4;57314:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;57304:91;;;;;;57297:98;;57222:181;:::o;11471:1135::-;11577:1;11561:18;;:4;:18;;;11557:552;;11715:5;11699:12;;:21;;;;;;;:::i;:::-;;;;;;;;11557:552;;;11753:19;11775:9;:15;11785:4;11775:15;;;;;;;;;;;;;;;;11753:37;;11823:5;11809:11;:19;11805:117;;;11881:4;11887:11;11900:5;11856:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;11805:117;12077:5;12063:11;:19;12045:9;:15;12055:4;12045:15;;;;;;;;;;;;;;;:37;;;;11738:371;11557:552;12139:1;12125:16;;:2;:16;;;12121:435;;12307:5;12291:12;;:21;;;;;;;;;;;12121:435;;;12524:5;12507:9;:13;12517:2;12507:13;;;;;;;;;;;;;;;;:22;;;;;;;;;;;12121:435;12588:2;12573:25;;12582:4;12573:25;;;12592:5;12573:25;;;;;;:::i;:::-;;;;;;;;11471:1135;;;:::o;53435:273::-;53529:13;51381:66;53588:17;;53578:5;53559:46;53555:146;;53629:15;53638:5;53629:8;:15::i;:::-;53622:22;;;;53555:146;53684:5;53677:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53435:273;;;;;:::o;48002:410::-;48095:14;48207:4;48201:11;48238:10;48233:3;48226:23;48286:15;48279:4;48274:3;48270:14;48263:39;48339:10;48332:4;48327:3;48323:14;48316:34;48389:4;48384:3;48374:20;48364:30;;48175:230;48002:410;;;;:::o;23121:1556::-;23252:7;23261:12;23275:7;24195:66;24190:1;24182:10;;:79;24178:166;;;24294:1;24298:30;24330:1;24278:54;;;;;;;;24178:166;24441:14;24458:24;24468:4;24474:1;24477;24480;24458:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24441:41;;24515:1;24497:20;;:6;:20;;;24493:115;;24550:1;24554:29;24593:1;24585:10;;24534:62;;;;;;;;;24493:115;24628:6;24636:20;24666:1;24658:10;;24620:49;;;;;;;23121:1556;;;;;;;;;:::o;25218:542::-;25314:20;25305:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;25301:452;25351:7;25301:452;25412:29;25403:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;25399:354;;25465:23;;;;;;;;;;;;;;25399:354;25519:35;25510:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;25506:247;;25614:8;25606:17;;25578:46;;;;;;;;;;;:::i;:::-;;;;;;;;25506:247;25655:30;25646:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;25642:111;;25732:8;25709:32;;;;;;;;;;;:::i;:::-;;;;;;;;25642:111;25218:542;;;:::o;52090:415::-;52149:13;52175:11;52189:16;52200:4;52189:10;:16::i;:::-;52175:30;;52295:17;52326:2;52315:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52295:34;;52420:3;52415;52408:16;52461:4;52454;52449:3;52445:14;52438:28;52494:3;52487:10;;;;52090:415;;;:::o;52582:251::-;52643:7;52663:14;52716:4;52707;52680:33;;:40;52663:57;;52744:2;52735:6;:11;52731:71;;;52770:20;;;;;;;;;;;;;;52731:71;52819:6;52812:13;;;52582:251;;;:::o;7:77:1:-;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;442:99::-;494:6;528:5;522:12;512:22;;442:99;;;:::o;547:169::-;631:11;665:6;660:3;653:19;705:4;700:3;696:14;681:29;;547:169;;;;:::o;722:246::-;803:1;813:113;827:6;824:1;821:13;813:113;;;912:1;907:3;903:11;897:18;893:1;888:3;884:11;877:39;849:2;846:1;842:10;837:15;;813:113;;;960:1;951:6;946:3;942:16;935:27;784:184;722:246;;;:::o;974:102::-;1015:6;1066:2;1062:7;1057:2;1050:5;1046:14;1042:28;1032:38;;974:102;;;:::o;1082:377::-;1170:3;1198:39;1231:5;1198:39;:::i;:::-;1253:71;1317:6;1312:3;1253:71;:::i;:::-;1246:78;;1333:65;1391:6;1386:3;1379:4;1372:5;1368:16;1333:65;:::i;:::-;1423:29;1445:6;1423:29;:::i;:::-;1418:3;1414:39;1407:46;;1174:285;1082:377;;;;:::o;1465:313::-;1578:4;1616:2;1605:9;1601:18;1593:26;;1665:9;1659:4;1655:20;1651:1;1640:9;1636:17;1629:47;1693:78;1766:4;1757:6;1693:78;:::i;:::-;1685:86;;1465:313;;;;:::o;1865:117::-;1974:1;1971;1964:12;2111:126;2148:7;2188:42;2181:5;2177:54;2166:65;;2111:126;;;:::o;2243:96::-;2280:7;2309:24;2327:5;2309:24;:::i;:::-;2298:35;;2243:96;;;:::o;2345:122::-;2418:24;2436:5;2418:24;:::i;:::-;2411:5;2408:35;2398:63;;2457:1;2454;2447:12;2398:63;2345:122;:::o;2473:139::-;2519:5;2557:6;2544:20;2535:29;;2573:33;2600:5;2573:33;:::i;:::-;2473:139;;;;:::o;2618:122::-;2691:24;2709:5;2691:24;:::i;:::-;2684:5;2681:35;2671:63;;2730:1;2727;2720:12;2671:63;2618:122;:::o;2746:139::-;2792:5;2830:6;2817:20;2808:29;;2846:33;2873:5;2846:33;:::i;:::-;2746:139;;;;:::o;2891:474::-;2959:6;2967;3016:2;3004:9;2995:7;2991:23;2987:32;2984:119;;;3022:79;;:::i;:::-;2984:119;3142:1;3167:53;3212:7;3203:6;3192:9;3188:22;3167:53;:::i;:::-;3157:63;;3113:117;3269:2;3295:53;3340:7;3331:6;3320:9;3316:22;3295:53;:::i;:::-;3285:63;;3240:118;2891:474;;;;;:::o;3371:90::-;3405:7;3448:5;3441:13;3434:21;3423:32;;3371:90;;;:::o;3467:109::-;3548:21;3563:5;3548:21;:::i;:::-;3543:3;3536:34;3467:109;;:::o;3582:210::-;3669:4;3707:2;3696:9;3692:18;3684:26;;3720:65;3782:1;3771:9;3767:17;3758:6;3720:65;:::i;:::-;3582:210;;;;:::o;3798:93::-;3834:7;3874:10;3867:5;3863:22;3852:33;;3798:93;;;:::o;3897:120::-;3969:23;3986:5;3969:23;:::i;:::-;3962:5;3959:34;3949:62;;4007:1;4004;3997:12;3949:62;3897:120;:::o;4023:137::-;4068:5;4106:6;4093:20;4084:29;;4122:32;4148:5;4122:32;:::i;:::-;4023:137;;;;:::o;4166:327::-;4224:6;4273:2;4261:9;4252:7;4248:23;4244:32;4241:119;;;4279:79;;:::i;:::-;4241:119;4399:1;4424:52;4468:7;4459:6;4448:9;4444:22;4424:52;:::i;:::-;4414:62;;4370:116;4166:327;;;;:::o;4499:619::-;4576:6;4584;4592;4641:2;4629:9;4620:7;4616:23;4612:32;4609:119;;;4647:79;;:::i;:::-;4609:119;4767:1;4792:53;4837:7;4828:6;4817:9;4813:22;4792:53;:::i;:::-;4782:63;;4738:117;4894:2;4920:53;4965:7;4956:6;4945:9;4941:22;4920:53;:::i;:::-;4910:63;;4865:118;5022:2;5048:53;5093:7;5084:6;5073:9;5069:22;5048:53;:::i;:::-;5038:63;;4993:118;4499:619;;;;;:::o;5124:86::-;5159:7;5199:4;5192:5;5188:16;5177:27;;5124:86;;;:::o;5216:112::-;5299:22;5315:5;5299:22;:::i;:::-;5294:3;5287:35;5216:112;;:::o;5334:214::-;5423:4;5461:2;5450:9;5446:18;5438:26;;5474:67;5538:1;5527:9;5523:17;5514:6;5474:67;:::i;:::-;5334:214;;;;:::o;5554:77::-;5591:7;5620:5;5609:16;;5554:77;;;:::o;5637:118::-;5724:24;5742:5;5724:24;:::i;:::-;5719:3;5712:37;5637:118;;:::o;5761:222::-;5854:4;5892:2;5881:9;5877:18;5869:26;;5905:71;5973:1;5962:9;5958:17;5949:6;5905:71;:::i;:::-;5761:222;;;;:::o;5989:329::-;6048:6;6097:2;6085:9;6076:7;6072:23;6068:32;6065:119;;;6103:79;;:::i;:::-;6065:119;6223:1;6248:53;6293:7;6284:6;6273:9;6269:22;6248:53;:::i;:::-;6238:63;;6194:117;5989:329;;;;:::o;6324:149::-;6360:7;6400:66;6393:5;6389:78;6378:89;;6324:149;;;:::o;6479:115::-;6564:23;6581:5;6564:23;:::i;:::-;6559:3;6552:36;6479:115;;:::o;6600:118::-;6687:24;6705:5;6687:24;:::i;:::-;6682:3;6675:37;6600:118;;:::o;6724:114::-;6791:6;6825:5;6819:12;6809:22;;6724:114;;;:::o;6844:184::-;6943:11;6977:6;6972:3;6965:19;7017:4;7012:3;7008:14;6993:29;;6844:184;;;;:::o;7034:132::-;7101:4;7124:3;7116:11;;7154:4;7149:3;7145:14;7137:22;;7034:132;;;:::o;7172:108::-;7249:24;7267:5;7249:24;:::i;:::-;7244:3;7237:37;7172:108;;:::o;7286:179::-;7355:10;7376:46;7418:3;7410:6;7376:46;:::i;:::-;7454:4;7449:3;7445:14;7431:28;;7286:179;;;;:::o;7471:113::-;7541:4;7573;7568:3;7564:14;7556:22;;7471:113;;;:::o;7620:732::-;7739:3;7768:54;7816:5;7768:54;:::i;:::-;7838:86;7917:6;7912:3;7838:86;:::i;:::-;7831:93;;7948:56;7998:5;7948:56;:::i;:::-;8027:7;8058:1;8043:284;8068:6;8065:1;8062:13;8043:284;;;8144:6;8138:13;8171:63;8230:3;8215:13;8171:63;:::i;:::-;8164:70;;8257:60;8310:6;8257:60;:::i;:::-;8247:70;;8103:224;8090:1;8087;8083:9;8078:14;;8043:284;;;8047:14;8343:3;8336:10;;7744:608;;;7620:732;;;;:::o;8358:1215::-;8707:4;8745:3;8734:9;8730:19;8722:27;;8759:69;8825:1;8814:9;8810:17;8801:6;8759:69;:::i;:::-;8875:9;8869:4;8865:20;8860:2;8849:9;8845:18;8838:48;8903:78;8976:4;8967:6;8903:78;:::i;:::-;8895:86;;9028:9;9022:4;9018:20;9013:2;9002:9;8998:18;8991:48;9056:78;9129:4;9120:6;9056:78;:::i;:::-;9048:86;;9144:72;9212:2;9201:9;9197:18;9188:6;9144:72;:::i;:::-;9226:73;9294:3;9283:9;9279:19;9270:6;9226:73;:::i;:::-;9309;9377:3;9366:9;9362:19;9353:6;9309:73;:::i;:::-;9430:9;9424:4;9420:20;9414:3;9403:9;9399:19;9392:49;9458:108;9561:4;9552:6;9458:108;:::i;:::-;9450:116;;8358:1215;;;;;;;;;;:::o;9579:222::-;9672:4;9710:2;9699:9;9695:18;9687:26;;9723:71;9791:1;9780:9;9776:17;9767:6;9723:71;:::i;:::-;9579:222;;;;:::o;9807:118::-;9878:22;9894:5;9878:22;:::i;:::-;9871:5;9868:33;9858:61;;9915:1;9912;9905:12;9858:61;9807:118;:::o;9931:135::-;9975:5;10013:6;10000:20;9991:29;;10029:31;10054:5;10029:31;:::i;:::-;9931:135;;;;:::o;10072:122::-;10145:24;10163:5;10145:24;:::i;:::-;10138:5;10135:35;10125:63;;10184:1;10181;10174:12;10125:63;10072:122;:::o;10200:139::-;10246:5;10284:6;10271:20;10262:29;;10300:33;10327:5;10300:33;:::i;:::-;10200:139;;;;:::o;10345:1199::-;10456:6;10464;10472;10480;10488;10496;10504;10553:3;10541:9;10532:7;10528:23;10524:33;10521:120;;;10560:79;;:::i;:::-;10521:120;10680:1;10705:53;10750:7;10741:6;10730:9;10726:22;10705:53;:::i;:::-;10695:63;;10651:117;10807:2;10833:53;10878:7;10869:6;10858:9;10854:22;10833:53;:::i;:::-;10823:63;;10778:118;10935:2;10961:53;11006:7;10997:6;10986:9;10982:22;10961:53;:::i;:::-;10951:63;;10906:118;11063:2;11089:53;11134:7;11125:6;11114:9;11110:22;11089:53;:::i;:::-;11079:63;;11034:118;11191:3;11218:51;11261:7;11252:6;11241:9;11237:22;11218:51;:::i;:::-;11208:61;;11162:117;11318:3;11345:53;11390:7;11381:6;11370:9;11366:22;11345:53;:::i;:::-;11335:63;;11289:119;11447:3;11474:53;11519:7;11510:6;11499:9;11495:22;11474:53;:::i;:::-;11464:63;;11418:119;10345:1199;;;;;;;;;;:::o;11550:474::-;11618:6;11626;11675:2;11663:9;11654:7;11650:23;11646:32;11643:119;;;11681:79;;:::i;:::-;11643:119;11801:1;11826:53;11871:7;11862:6;11851:9;11847:22;11826:53;:::i;:::-;11816:63;;11772:117;11928:2;11954:53;11999:7;11990:6;11979:9;11975:22;11954:53;:::i;:::-;11944:63;;11899:118;11550:474;;;;;:::o;12030:180::-;12078:77;12075:1;12068:88;12175:4;12172:1;12165:15;12199:4;12196:1;12189:15;12216:320;12260:6;12297:1;12291:4;12287:12;12277:22;;12344:1;12338:4;12334:12;12365:18;12355:81;;12421:4;12413:6;12409:17;12399:27;;12355:81;12483:2;12475:6;12472:14;12452:18;12449:38;12446:84;;12502:18;;:::i;:::-;12446:84;12267:269;12216:320;;;:::o;12542:180::-;12590:77;12587:1;12580:88;12687:4;12684:1;12677:15;12711:4;12708:1;12701:15;12728:194;12768:4;12788:20;12806:1;12788:20;:::i;:::-;12783:25;;12822:20;12840:1;12822:20;:::i;:::-;12817:25;;12866:1;12863;12859:9;12851:17;;12890:1;12884:4;12881:11;12878:37;;;12895:18;;:::i;:::-;12878:37;12728:194;;;;:::o;12928:234::-;13068:34;13064:1;13056:6;13052:14;13045:58;13137:17;13132:2;13124:6;13120:15;13113:42;12928:234;:::o;13168:366::-;13310:3;13331:67;13395:2;13390:3;13331:67;:::i;:::-;13324:74;;13407:93;13496:3;13407:93;:::i;:::-;13525:2;13520:3;13516:12;13509:19;;13168:366;;;:::o;13540:419::-;13706:4;13744:2;13733:9;13729:18;13721:26;;13793:9;13787:4;13783:20;13779:1;13768:9;13764:17;13757:47;13821:131;13947:4;13821:131;:::i;:::-;13813:139;;13540:419;;;:::o;13965:173::-;14105:25;14101:1;14093:6;14089:14;14082:49;13965:173;:::o;14144:366::-;14286:3;14307:67;14371:2;14366:3;14307:67;:::i;:::-;14300:74;;14383:93;14472:3;14383:93;:::i;:::-;14501:2;14496:3;14492:12;14485:19;;14144:366;;;:::o;14516:419::-;14682:4;14720:2;14709:9;14705:18;14697:26;;14769:9;14763:4;14759:20;14755:1;14744:9;14740:17;14733:47;14797:131;14923:4;14797:131;:::i;:::-;14789:139;;14516:419;;;:::o;14941:180::-;14989:77;14986:1;14979:88;15086:4;15083:1;15076:15;15110:4;15107:1;15100:15;15127:775;15360:4;15398:3;15387:9;15383:19;15375:27;;15412:71;15480:1;15469:9;15465:17;15456:6;15412:71;:::i;:::-;15493:72;15561:2;15550:9;15546:18;15537:6;15493:72;:::i;:::-;15575;15643:2;15632:9;15628:18;15619:6;15575:72;:::i;:::-;15657;15725:2;15714:9;15710:18;15701:6;15657:72;:::i;:::-;15739:73;15807:3;15796:9;15792:19;15783:6;15739:73;:::i;:::-;15822;15890:3;15879:9;15875:19;15866:6;15822:73;:::i;:::-;15127:775;;;;;;;;;:::o;15908:332::-;16029:4;16067:2;16056:9;16052:18;16044:26;;16080:71;16148:1;16137:9;16133:17;16124:6;16080:71;:::i;:::-;16161:72;16229:2;16218:9;16214:18;16205:6;16161:72;:::i;:::-;15908:332;;;;;:::o;16246:442::-;16395:4;16433:2;16422:9;16418:18;16410:26;;16446:71;16514:1;16503:9;16499:17;16490:6;16446:71;:::i;:::-;16527:72;16595:2;16584:9;16580:18;16571:6;16527:72;:::i;:::-;16609;16677:2;16666:9;16662:18;16653:6;16609:72;:::i;:::-;16246:442;;;;;;:::o;16694:664::-;16899:4;16937:3;16926:9;16922:19;16914:27;;16951:71;17019:1;17008:9;17004:17;16995:6;16951:71;:::i;:::-;17032:72;17100:2;17089:9;17085:18;17076:6;17032:72;:::i;:::-;17114;17182:2;17171:9;17167:18;17158:6;17114:72;:::i;:::-;17196;17264:2;17253:9;17249:18;17240:6;17196:72;:::i;:::-;17278:73;17346:3;17335:9;17331:19;17322:6;17278:73;:::i;:::-;16694:664;;;;;;;;:::o;17364:191::-;17404:3;17423:20;17441:1;17423:20;:::i;:::-;17418:25;;17457:20;17475:1;17457:20;:::i;:::-;17452:25;;17500:1;17497;17493:9;17486:16;;17521:3;17518:1;17515:10;17512:36;;;17528:18;;:::i;:::-;17512:36;17364:191;;;;:::o;17561:545::-;17734:4;17772:3;17761:9;17757:19;17749:27;;17786:71;17854:1;17843:9;17839:17;17830:6;17786:71;:::i;:::-;17867:68;17931:2;17920:9;17916:18;17907:6;17867:68;:::i;:::-;17945:72;18013:2;18002:9;17998:18;17989:6;17945:72;:::i;:::-;18027;18095:2;18084:9;18080:18;18071:6;18027:72;:::i;:::-;17561:545;;;;;;;:::o;18112:180::-;18160:77;18157:1;18150:88;18257:4;18254:1;18247:15;18281:4;18278:1;18271:15
Swarm Source
ipfs://a016ca59fcec5432b943ac207bb4246a077082ff551b88f7b8768f720635aec1
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.