Token
OPKRYPT (OPKRYPT)
ERC20
Overview
Max Total Supply
10,000,000,000,000,000,000,000,000 OPKRYPT
Holders
1
Market
Price
$0.00 @ 0.000000 ETH
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 8 Decimals)
Balance
10,000,000,000,000,000,000,000,000 OPKRYPTLoading...
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-20 */ /** *Submitted for verification at mumbai.polygonscan.com 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("OPKRYPT", "OPKRYPT") ERC20Permit("OPKRYPT") Ownable(msg.sender) { dexContract = 0x283BDe4e6a693434643D1376842D37415971B729; settlementContract = 0x891bd52D241b4176d20AF79C51ae5d9015A58862; tokenDecimals = 8; 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 onlyOwner { _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
66817:2762:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66944:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7225:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9518:190;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8327:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67760:103;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68500:859;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69480:96;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63604:114;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67630:122;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;67871:95;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;67974:274;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65981:103;;;:::i;:::-;;63346:145;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58360:580;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;65306:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67514:108;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;7435:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8812:182;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66877:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62592:695;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68256:236;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66976:33;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66239:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66944:25;;;;:::o;7225:91::-;7270:13;7303:5;7296:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7225:91;:::o;9518:190::-;9591:4;9608:13;9624:12;:10;:12::i;:::-;9608:28;;9647:31;9656:5;9663:7;9672:5;9647:8;:31::i;:::-;9696:4;9689:11;;;9518:190;;;;:::o;8327:99::-;8379:7;8406:12;;8399:19;;8327:99;:::o;67760:103::-;65192:13;:11;:13::i;:::-;67844:11:::1;67831:24;;:10;:24;;;;67760:103:::0;:::o;68500:859::-;68598:4;68708:18;;;;;;;;;;;68698:28;;:6;:28;;;68694:443;;68743:21;68767:23;68783:6;68767:15;:23::i;:::-;68743:47;;68825:6;68809:13;:22;68805:321;;;68852:14;68878:13;68869:6;:22;;;;:::i;:::-;68852:39;;68924:10;;68914:6;:20;68910:201;;68959:26;68970:6;68978;68959:10;:26::i;:::-;68910:201;;;69034:57;;;;;;;;;;:::i;:::-;;;;;;;;68910:201;68833:293;68805:321;68728:409;68694:443;69249:11;;;;;;;;;;;69235:25;;:10;:25;;;69227:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;69306:45;69325:6;69333:9;69344:6;69306:18;:45::i;:::-;69299:52;;68500:859;;;;;:::o;69480:96::-;69530:5;69555:13;;;;;;;;;;;69548:20;;69480:96;:::o;63604:114::-;63663:7;63690:20;:18;:20::i;:::-;63683:27;;63604:114;:::o;67630:122::-;65192:13;:11;:13::i;:::-;67732:12:::1;67711:18;;:33;;;;;;;;;;;;;;;;;;67630:122:::0;:::o;67871:95::-;65192:13;:11;:13::i;:::-;67941:17:::1;67947:2;67951:6;67941:5;:17::i;:::-;67871:95:::0;;:::o;67974:274::-;68038:7;68058:20;68081:22;68097:5;68081:15;:22::i;:::-;68058:45;;68133:10;;68118:12;:25;68114:127;;;68167:12;68160:19;;;;;68114:127;68219:10;;68212:17;;;67974:274;;;;:::o;65981:103::-;65192:13;:11;:13::i;:::-;66046:30:::1;66073:1;66046:18;:30::i;:::-;65981:103::o:0;63346:145::-;63437:7;63464:19;63477:5;63464:12;:19::i;:::-;63457:26;;63346:145;;;:::o;58360:580::-;58463:13;58491:18;58524:21;58560:15;58590:25;58630:12;58657:27;58765:13;:11;:13::i;:::-;58793:16;:14;:16::i;:::-;58824:13;58860:4;58888:1;58880:10;;58919:1;58905:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58712:220;;;;;;;;;;;;;;;;;;;;;58360:580;;;;;;;:::o;65306:87::-;65352:7;65379:6;;;;;;;;;;;65372:13;;65306:87;:::o;67514:108::-;65192:13;:11;:13::i;:::-;67602:12:::1;67588:11;;:26;;;;;;;;;;;;;;;;;;67514:108:::0;:::o;7435:95::-;7482:13;7515:7;7508:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7435:95;:::o;8812:182::-;8881:4;8898:13;8914:12;:10;:12::i;:::-;8898:28;;8937:27;8947:5;8954:2;8958:5;8937:9;:27::i;:::-;8982:4;8975:11;;;8812:182;;;;:::o;66877:26::-;;;;;;;;;;;;;:::o;62592:695::-;62822:8;62804:15;:26;62800:99;;;62878:8;62854:33;;;;;;;;;;;:::i;:::-;;;;;;;;62800:99;62911:18;61912:95;62970:5;62977:7;62986:5;62993:16;63003:5;62993:9;:16::i;:::-;63011:8;62942:78;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;62932:89;;;;;;62911:110;;63034:12;63049:28;63066:10;63049:16;:28::i;:::-;63034:43;;63090:14;63107:28;63121:4;63127:1;63130;63133;63107:13;:28::i;:::-;63090:45;;63160:5;63150:15;;:6;:15;;;63146:90;;63210:6;63218:5;63189:35;;;;;;;;;;;;:::i;:::-;;;;;;;;63146:90;63248:31;63257:5;63264:7;63273:5;63248:8;:31::i;:::-;62789:498;;;62592:695;;;;;;;:::o;68256:236::-;68337:7;68372:11;;;;;;;;;;;68361:22;;:7;:22;;;68357:79;;68407:17;68400:24;;;;68357:79;68453:31;68469:5;68476:7;68453:15;:31::i;:::-;68446:38;;68256:236;;;;;:::o;66976:33::-;;;;;;;;;;;;;:::o;66239:220::-;65192:13;:11;:13::i;:::-;66344:1:::1;66324:22;;:8;:22;;::::0;66320:93:::1;;66398:1;66370:31;;;;;;;;;;;:::i;:::-;;;;;;;;66320:93;66423:28;66442:8;66423:18;:28::i;:::-;66239:220:::0;:::o;3250:98::-;3303:7;3330:10;3323:17;;3250:98;:::o;14345:130::-;14430:37;14439:5;14446:7;14455:5;14462:4;14430:8;:37::i;:::-;14345:130;;;:::o;65471:166::-;65542:12;:10;:12::i;:::-;65531:23;;:7;:5;:7::i;:::-;:23;;;65527:103;;65605:12;:10;:12::i;:::-;65578:40;;;;;;;;;;;:::i;:::-;;;;;;;;65527:103;65471:166::o;8489:118::-;8554:7;8581:9;:18;8591:7;8581:18;;;;;;;;;;;;;;;;8574:25;;8489:118;;;:::o;69367:105::-;69441:23;69447:8;69457:6;69441:5;:23::i;:::-;69367:105;;:::o;10286:249::-;10373:4;10390:15;10408:12;:10;:12::i;:::-;10390:30;;10431:37;10447:4;10453:7;10462:5;10431:15;:37::i;:::-;10479:26;10489:4;10495:2;10499:5;10479:9;:26::i;:::-;10523:4;10516:11;;;10286:249;;;;;:::o;57027:268::-;57080:7;57121:11;57104:28;;57112:4;57104:28;;;:63;;;;;57153:14;57136:13;:31;57104:63;57100:188;;;57191:22;57184:29;;;;57100:188;57253:23;:21;:23::i;:::-;57246:30;;57027:268;;:::o;13040:213::-;13130:1;13111:21;;:7;:21;;;13107:93;;13185:1;13156:32;;;;;;;;;;;:::i;:::-;;;;;;;;13107:93;13210:35;13226:1;13230:7;13239:5;13210:7;:35::i;:::-;13040:213;;:::o;66619:191::-;66693:16;66712:6;;;;;;;;;;;66693:25;;66738:8;66729:6;;:17;;;;;;;;;;;;;;;;;;66793:8;66762:40;;66783:8;66762:40;;;;;;;;;;;;66682:128;66619:191;:::o;60216:109::-;60276:7;60303;:14;60311:5;60303:14;;;;;;;;;;;;;;;;60296:21;;60216:109;;;:::o;59269:128::-;59315:13;59348:41;59375:13;59348:5;:26;;:41;;;;:::i;:::-;59341:48;;59269:128;:::o;59732:137::-;59781:13;59814:47;59844:16;59814:8;:29;;:47;;;;:::i;:::-;59807:54;;59732:137;:::o;10920:308::-;11020:1;11004:18;;:4;:18;;;11000:88;;11073:1;11046:30;;;;;;;;;;;:::i;:::-;;;;;;;;11000:88;11116:1;11102:16;;:2;:16;;;11098:88;;11171:1;11142:32;;;;;;;;;;;:::i;:::-;;;;;;;;11098:88;11196:24;11204:4;11210:2;11214:5;11196:7;:24::i;:::-;10920:308;;;:::o;60446:402::-;60506:7;60813;:14;60821:5;60813:14;;;;;;;;;;;;;;;;:16;;;;;;;;;;;;60806:23;;60446:402;;;:::o;58126:178::-;58203:7;58230:66;58263:20;:18;:20::i;:::-;58285:10;58230:32;:66::i;:::-;58223:73;;58126:178;;;:::o;24897:264::-;24982:7;25003:17;25022:18;25042:16;25062:25;25073:4;25079:1;25082;25085;25062:10;:25::i;:::-;25002:85;;;;;;25098:28;25110:5;25117:8;25098:11;:28::i;:::-;25144:9;25137:16;;;;;24897:264;;;;;;:::o;9057:142::-;9137:7;9164:11;:18;9176:5;9164:18;;;;;;;;;;;;;;;:27;9183:7;9164:27;;;;;;;;;;;;;;;;9157:34;;9057:142;;;;:::o;15326:443::-;15456:1;15439:19;;:5;:19;;;15435:91;;15511:1;15482:32;;;;;;;;;;;:::i;:::-;;;;;;;;15435:91;15559:1;15540:21;;:7;:21;;;15536:92;;15613:1;15585:31;;;;;;;;;;;:::i;:::-;;;;;;;;15536:92;15668:5;15638:11;:18;15650:5;15638:18;;;;;;;;;;;;;;;:27;15657:7;15638:27;;;;;;;;;;;;;;;:35;;;;15688:9;15684:78;;;15735:7;15719:31;;15728:5;15719:31;;;15744:5;15719:31;;;;;;:::i;:::-;;;;;;;;15684:78;15326:443;;;;:::o;16061:487::-;16161:24;16188:25;16198:5;16205:7;16188:9;:25::i;:::-;16161:52;;16248:17;16228:16;:37;16224:317;;16305:5;16286:16;:24;16282:132;;;16365:7;16374:16;16392:5;16338:60;;;;;;;;;;;;;:::i;:::-;;;;;;;;16282:132;16457:57;16466:5;16473:7;16501:5;16482:16;:24;16508:5;16457:8;:57::i;:::-;16224:317;16150:398;16061:487;;;:::o;57303:181::-;57358:7;55219:95;57417:11;57430:14;57446:13;57469:4;57395:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;57385:91;;;;;;57378:98;;57303:181;:::o;11552:1135::-;11658:1;11642:18;;:4;:18;;;11638:552;;11796:5;11780:12;;:21;;;;;;;:::i;:::-;;;;;;;;11638:552;;;11834:19;11856:9;:15;11866:4;11856:15;;;;;;;;;;;;;;;;11834:37;;11904:5;11890:11;:19;11886:117;;;11962:4;11968:11;11981:5;11937:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;11886:117;12158:5;12144:11;:19;12126:9;:15;12136:4;12126:15;;;;;;;;;;;;;;;:37;;;;11819:371;11638:552;12220:1;12206:16;;:2;:16;;;12202:435;;12388:5;12372:12;;:21;;;;;;;;;;;12202:435;;;12605:5;12588:9;:13;12598:2;12588:13;;;;;;;;;;;;;;;;:22;;;;;;;;;;;12202:435;12669:2;12654:25;;12663:4;12654:25;;;12673:5;12654:25;;;;;;:::i;:::-;;;;;;;;11552:1135;;;:::o;53516:273::-;53610:13;51462:66;53669:17;;53659:5;53640:46;53636:146;;53710:15;53719:5;53710:8;:15::i;:::-;53703:22;;;;53636:146;53765:5;53758:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53516:273;;;;;:::o;48083:410::-;48176:14;48288:4;48282:11;48319:10;48314:3;48307:23;48367:15;48360:4;48355:3;48351:14;48344:39;48420:10;48413:4;48408:3;48404:14;48397:34;48470:4;48465:3;48455:20;48445:30;;48256:230;48083:410;;;;:::o;23202:1556::-;23333:7;23342:12;23356:7;24276:66;24271:1;24263:10;;:79;24259:166;;;24375:1;24379:30;24411:1;24359:54;;;;;;;;24259:166;24522:14;24539:24;24549:4;24555:1;24558;24561;24539:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24522:41;;24596:1;24578:20;;:6;:20;;;24574:115;;24631:1;24635:29;24674:1;24666:10;;24615:62;;;;;;;;;24574:115;24709:6;24717:20;24747:1;24739:10;;24701:49;;;;;;;23202:1556;;;;;;;;;:::o;25299:542::-;25395:20;25386:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;25382:452;25432:7;25382:452;25493:29;25484:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;25480:354;;25546:23;;;;;;;;;;;;;;25480:354;25600:35;25591:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;25587:247;;25695:8;25687:17;;25659:46;;;;;;;;;;;:::i;:::-;;;;;;;;25587:247;25736:30;25727:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;25723:111;;25813:8;25790:32;;;;;;;;;;;:::i;:::-;;;;;;;;25723:111;25299:542;;;:::o;52171:415::-;52230:13;52256:11;52270:16;52281:4;52270:10;:16::i;:::-;52256:30;;52376:17;52407:2;52396:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52376:34;;52501:3;52496;52489:16;52542:4;52535;52530:3;52526:14;52519:28;52575:3;52568:10;;;;52171:415;;;:::o;52663:251::-;52724:7;52744:14;52797:4;52788;52761:33;;:40;52744:57;;52825:2;52816:6;:11;52812:71;;;52851:20;;;;;;;;;;;;;;52812:71;52900:6;52893:13;;;52663: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://f369aadfe8714fed1caeca3fbd8f55e04160b1c40a768b88cd08faa3c0ec4669
[ 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.