ERC-20
Overview
Max Total Supply
1,000,000,000 BRB
Holders
129
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Balance
1,008,153.436333929962199875 BRBValue
$0.00Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
BullRunBack
Compiler Version
v0.8.19+commit.7dd6d404
Contract Source Code (Solidity Standard Json-Input format)
/* BRB token on Ethereum network, believe the Bullrun is coming? So do we! As BTC grows we rocket! https://bullrunback.vip https://twitter.com/BullRunBackETH https://t.me/BRBERC20 */ // SPDX-License-Identifier: No License pragma solidity 0.8.19; import "./ERC20.sol"; import "./ERC20Burnable.sol"; import "./Ownable2Step.sol"; import "./ERC20Permit.sol"; import "./Initializable.sol"; import "./IUniswapV2Factory.sol"; import "./IUniswapV2Pair.sol"; import "./IUniswapV2Router01.sol"; import "./IUniswapV2Router02.sol"; contract BullRunBack is ERC20, ERC20Burnable, Ownable2Step, ERC20Permit, Initializable { mapping (address => bool) public blacklisted; uint16 public swapThresholdRatio; uint256 private _marketingPending; address public marketingAddress; uint16[3] public marketingFees; mapping (address => bool) public isExcludedFromFees; uint16[3] public totalFees; bool private _swapping; IUniswapV2Router02 public routerV2; address public pairV2; mapping (address => bool) public AMMPairs; mapping (address => bool) public isExcludedFromLimits; uint256 public maxWalletAmount; bool public tradingEnabled; mapping (address => bool) public isExcludedFromTradingRestriction; event BlacklistUpdated(address indexed account, bool isBlacklisted); event SwapThresholdUpdated(uint16 swapThresholdRatio); event marketingAddressUpdated(address marketingAddress); event marketingFeesUpdated(uint16 buyFee, uint16 sellFee, uint16 transferFee); event marketingFeeSent(address recipient, uint256 amount); event ExcludeFromFees(address indexed account, bool isExcluded); event RouterV2Updated(address indexed routerV2); event AMMPairsUpdated(address indexed AMMPair, bool isPair); event ExcludeFromLimits(address indexed account, bool isExcluded); event MaxWalletAmountUpdated(uint256 maxWalletAmount); event TradingEnabled(); event ExcludeFromTradingRestriction(address indexed account, bool isExcluded); constructor() ERC20(unicode"BullRunBack", unicode"BRB") ERC20Permit(unicode"BullRunBack") { address supplyRecipient = 0x2Db2a98Ce75E0533AD2602D315Dcbc694B774e74; updateSwapThreshold(50); marketingAddressSetup(0x2Db2a98Ce75E0533AD2602D315Dcbc694B774e74); marketingFeesSetup(997, 2300, 0); excludeFromFees(supplyRecipient, true); excludeFromFees(address(this), true); _excludeFromLimits(supplyRecipient, true); _excludeFromLimits(address(this), true); _excludeFromLimits(address(0), true); updateMaxWalletAmount(200000000 * (10 ** decimals()) / 10); excludeFromTradingRestriction(supplyRecipient, true); excludeFromTradingRestriction(address(this), true); _mint(supplyRecipient, 10000000000 * (10 ** decimals()) / 10); _transferOwnership(0x2Db2a98Ce75E0533AD2602D315Dcbc694B774e74); } /* This token is not upgradeable, but uses both the constructor and initializer for post-deployment setup. */ function initialize(address _router) initializer external { _updateRouterV2(_router); } receive() external payable {} function decimals() public pure override returns (uint8) { return 18; } function blacklist(address account, bool isBlacklisted) external onlyOwner { blacklisted[account] = isBlacklisted; emit BlacklistUpdated(account, isBlacklisted); } function _swapTokensForCoin(uint256 tokenAmount) private { address[] memory path = new address[](2); path[0] = address(this); path[1] = routerV2.WETH(); _approve(address(this), address(routerV2), tokenAmount); routerV2.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, address(this), block.timestamp); } function updateSwapThreshold(uint16 _swapThresholdRatio) public onlyOwner { require(_swapThresholdRatio > 0 && _swapThresholdRatio <= 500, "SwapThreshold: Cannot exceed limits from 0.01% to 5% for new swap threshold"); swapThresholdRatio = _swapThresholdRatio; emit SwapThresholdUpdated(_swapThresholdRatio); } function getSwapThresholdAmount() public view returns (uint256) { return balanceOf(pairV2) * swapThresholdRatio / 10000; } function getAllPending() public view returns (uint256) { return 0 + _marketingPending; } function marketingAddressSetup(address _newAddress) public onlyOwner { require(_newAddress != address(0), "TaxesDefaultRouterWallet: Wallet tax recipient cannot be a 0x0 address"); marketingAddress = _newAddress; excludeFromFees(_newAddress, true); _excludeFromLimits(_newAddress, true); emit marketingAddressUpdated(_newAddress); } function marketingFeesSetup(uint16 _buyFee, uint16 _sellFee, uint16 _transferFee) public onlyOwner { totalFees[0] = totalFees[0] - marketingFees[0] + _buyFee; totalFees[1] = totalFees[1] - marketingFees[1] + _sellFee; totalFees[2] = totalFees[2] - marketingFees[2] + _transferFee; require(totalFees[0] <= 2500 && totalFees[1] <= 2500 && totalFees[2] <= 2500, "TaxesDefaultRouter: Cannot exceed max total fee of 25%"); marketingFees = [_buyFee, _sellFee, _transferFee]; emit marketingFeesUpdated(_buyFee, _sellFee, _transferFee); } function excludeFromFees(address account, bool isExcluded) public onlyOwner { isExcludedFromFees[account] = isExcluded; emit ExcludeFromFees(account, isExcluded); } function _transfer( address from, address to, uint256 amount ) internal override { if (!_swapping && amount > 0 && to != address(routerV2) && !isExcludedFromFees[from] && !isExcludedFromFees[to]) { uint256 fees = 0; uint8 txType = 3; if (AMMPairs[from]) { if (totalFees[0] > 0) txType = 0; } else if (AMMPairs[to]) { if (totalFees[1] > 0) txType = 1; } else if (totalFees[2] > 0) txType = 2; if (txType < 3) { fees = amount * totalFees[txType] / 10000; amount -= fees; _marketingPending += fees * marketingFees[txType] / totalFees[txType]; } if (fees > 0) { super._transfer(from, address(this), fees); } } bool canSwap = getAllPending() >= getSwapThresholdAmount() && balanceOf(pairV2) > 0; if (!_swapping && !AMMPairs[from] && from != address(routerV2) && canSwap) { _swapping = true; if (false || _marketingPending > 0) { uint256 token2Swap = 0 + _marketingPending; bool success = false; _swapTokensForCoin(token2Swap); uint256 coinsReceived = address(this).balance; uint256 marketingPortion = coinsReceived * _marketingPending / token2Swap; if (marketingPortion > 0) { success = payable(marketingAddress).send(marketingPortion); if (success) { emit marketingFeeSent(marketingAddress, marketingPortion); } } _marketingPending = 0; } _swapping = false; } super._transfer(from, to, amount); } function _updateRouterV2(address router) private { routerV2 = IUniswapV2Router02(router); pairV2 = IUniswapV2Factory(routerV2.factory()).createPair(address(this), routerV2.WETH()); _excludeFromLimits(router, true); _setAMMPair(pairV2, true); emit RouterV2Updated(router); } function setAMMPair(address pair, bool isPair) external onlyOwner { require(pair != pairV2, "DefaultRouter: Cannot remove initial pair from list"); _setAMMPair(pair, isPair); } function _setAMMPair(address pair, bool isPair) private { AMMPairs[pair] = isPair; if (isPair) { _excludeFromLimits(pair, true); } emit AMMPairsUpdated(pair, isPair); } function excludeFromLimits(address account, bool isExcluded) external onlyOwner { _excludeFromLimits(account, isExcluded); } function _excludeFromLimits(address account, bool isExcluded) internal { isExcludedFromLimits[account] = isExcluded; emit ExcludeFromLimits(account, isExcluded); } function updateMaxWalletAmount(uint256 _maxWalletAmount) public onlyOwner { require(_maxWalletAmount >= _maxWalletSafeLimit(), "MaxWallet: Limit too low"); maxWalletAmount = _maxWalletAmount; emit MaxWalletAmountUpdated(_maxWalletAmount); } function _maxWalletSafeLimit() private view returns (uint256) { return totalSupply() / 1000; } function enableTrading() external onlyOwner { require(!tradingEnabled, "EnableTrading: Trading was enabled already"); tradingEnabled = true; emit TradingEnabled(); } function excludeFromTradingRestriction(address account, bool isExcluded) public onlyOwner { isExcludedFromTradingRestriction[account] = isExcluded; emit ExcludeFromTradingRestriction(account, isExcluded); } function _beforeTokenTransfer(address from, address to, uint256 amount) internal override { require(!blacklisted[from] && !blacklisted[to], "Blacklist: Sender or recipient is blacklisted"); // Interactions with DEX are disallowed prior to enabling trading by owner if ((AMMPairs[from] && !isExcludedFromTradingRestriction[to]) || (AMMPairs[to] && !isExcludedFromTradingRestriction[from])) { require(tradingEnabled, "EnableTrading: Trading was not enabled yet"); } super._beforeTokenTransfer(from, to, amount); } function _afterTokenTransfer(address from, address to, uint256 amount) internal override { if (!isExcludedFromLimits[to]) { require(balanceOf(to) <= maxWalletAmount, "MaxWallet: Cannot exceed max wallet limit"); } super._afterTokenTransfer(from, to, amount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.0; import "./IERC20.sol"; import "./IERC20Metadata.sol"; import "./Context.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}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * 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. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => 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 override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override 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 override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override 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 `amount`. */ function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _transfer(owner, to, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `amount` 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 amount) public virtual override returns (bool) { address owner = _msgSender(); _approve(owner, spender, amount); 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 `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, allowance(owner, spender) + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { address owner = _msgSender(); uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `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. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer(address from, address to, uint256 amount) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by // decrementing then incrementing. _balances[to] += amount; } emit Transfer(from, to, amount); _afterTokenTransfer(from, to, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; unchecked { // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above. _balances[account] += amount; } emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; // Overflow not possible: amount <= accountBalance <= totalSupply. _totalSupply -= amount; } emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` 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. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Updates `owner` s allowance for `spender` based on spent `amount`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance(address owner, address spender, uint256 amount) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {} }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol) pragma solidity ^0.8.0; import "./ERC20.sol"; import "./Context.sol"; /** * @dev Extension of {ERC20} that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). */ abstract contract ERC20Burnable is Context, ERC20 { /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for ``accounts``'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { _spendAllowance(account, _msgSender(), amount); _burn(account, amount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol) pragma solidity ^0.8.0; import "./Ownable.sol"; /** * @dev Contract module which provides access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership} and {acceptOwnership}. * * This module is used through inheritance. It will make available all functions * from parent (Ownable). */ abstract contract Ownable2Step is Ownable { address private _pendingOwner; event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner); /** * @dev Returns the address of the pending owner. */ function pendingOwner() public view virtual returns (address) { return _pendingOwner; } /** * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual override onlyOwner { _pendingOwner = newOwner; emit OwnershipTransferStarted(owner(), newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner. * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual override { delete _pendingOwner; super._transferOwnership(newOwner); } /** * @dev The new owner accepts the ownership transfer. */ function acceptOwnership() public virtual { address sender = _msgSender(); require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner"); _transferOwnership(sender); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/ERC20Permit.sol) pragma solidity ^0.8.0; import "./IERC20Permit.sol"; import "./ERC20.sol"; import "./ECDSA.sol"; import "./EIP712.sol"; import "./Counters.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. * * _Available since v3.4._ */ abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 { using Counters for Counters.Counter; mapping(address => Counters.Counter) private _nonces; // solhint-disable-next-line var-name-mixedcase bytes32 private constant _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); /** * @dev In previous versions `_PERMIT_TYPEHASH` was declared as `immutable`. * However, to ensure consistency with the upgradeable transpiler, we will continue * to reserve a slot. * @custom:oz-renamed-from _PERMIT_TYPEHASH */ // solhint-disable-next-line var-name-mixedcase bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT; /** * @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") {} /** * @dev See {IERC20Permit-permit}. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual override { require(block.timestamp <= deadline, "ERC20Permit: expired 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); require(signer == owner, "ERC20Permit: invalid signature"); _approve(owner, spender, value); } /** * @dev See {IERC20Permit-nonces}. */ function nonces(address owner) public view virtual override returns (uint256) { return _nonces[owner].current(); } /** * @dev See {IERC20Permit-DOMAIN_SEPARATOR}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view override returns (bytes32) { return _domainSeparatorV4(); } /** * @dev "Consume a nonce": return the current value and increment. * * _Available since v4.1._ */ function _useNonce(address owner) internal virtual returns (uint256 current) { Counters.Counter storage nonce = _nonces[owner]; current = nonce.current(); nonce.increment(); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. */ bool private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Modifier to protect an initializer function from being invoked twice. */ modifier initializer() { require(_initializing || !_initialized, "Initializable: contract is already initialized"); bool isTopLevelCall = !_initializing; if (isTopLevelCall) { _initializing = true; _initialized = true; } _; if (isTopLevelCall) { _initializing = false; } } }
pragma solidity >=0.5.0; interface IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; }
pragma solidity >=0.5.0; interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; }
pragma solidity >=0.6.2; interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); }
pragma solidity >=0.6.2; import './IUniswapV2Router01.sol'; interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "./Context.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. * * By default, the owner account will be the one that deploys the contract. 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; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @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 { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @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 { require(newOwner != address(0), "Ownable: new owner is the zero address"); _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); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ 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 amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` 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 amount) external returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "./IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ 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); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface 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. */ 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]. */ 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); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol) pragma solidity ^0.8.0; import "./Strings.sol"; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV // Deprecated in v4.8 } function _throwError(RecoverError error) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert("ECDSA: invalid signature"); } else if (error == RecoverError.InvalidSignatureLength) { revert("ECDSA: invalid signature length"); } else if (error == RecoverError.InvalidSignatureS) { revert("ECDSA: invalid signature 's' value"); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature` or error string. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode 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 {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] * * _Available since v4.3._ */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) { 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); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode 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 {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, signature); _throwError(error); 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] * * _Available since v4.3._ */ function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) { bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); 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. * * _Available since v4.2._ */ function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, r, vs); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. * * _Available since v4.3._ */ function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) { // 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); } // 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); } return (signer, RecoverError.NoError); } /** * @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) = tryRecover(hash, v, r, s); _throwError(error); return recovered; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) { // 32 is the length in bytes of hash, // enforced by the type signature above /// @solidity memory-safe-assembly assembly { mstore(0x00, "\x19Ethereum Signed Message:\n32") mstore(0x1c, hash) message := keccak256(0x00, 0x3c) } } /** * @dev Returns an Ethereum Signed Message, created from `s`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s)); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) { /// @solidity memory-safe-assembly assembly { let ptr := mload(0x40) mstore(ptr, "\x19\x01") mstore(add(ptr, 0x02), domainSeparator) mstore(add(ptr, 0x22), structHash) data := keccak256(ptr, 0x42) } } /** * @dev Returns an Ethereum Signed Data with intended validator, created from a * `validator` and `data` according to the version 0 of EIP-191. * * See {recover}. */ function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x00", validator, data)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/EIP712.sol) pragma solidity ^0.8.8; import "./ECDSA.sol"; import "./ShortStrings.sol"; import "./IERC5267.sol"; /** * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data. * * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible, * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding * they need in their contracts using a combination of `abi.encode` and `keccak256`. * * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA * ({_hashTypedDataV4}). * * The implementation of the domain separator was designed to be as efficient as possible while still properly updating * the chain id to protect against replay attacks on an eventual fork of the chain. * * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask]. * * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain * separator of the implementation contract. This will cause the `_domainSeparatorV4` function to always rebuild the * separator from the immutable values, which is cheaper than accessing a cached version in cold storage. * * _Available since v3.4._ * * @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment */ 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 ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash); } /** * @dev See {EIP-5267}. * * _Available since v4.9._ */ function eip712Domain() public view virtual override returns ( bytes1 fields, string memory name, string memory version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] memory extensions ) { return ( hex"0f", // 01111 _name.toStringWithFallback(_nameFallback), _version.toStringWithFallback(_versionFallback), block.chainid, address(this), bytes32(0), new uint256[](0) ); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Counters.sol) pragma solidity ^0.8.0; /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./Math.sol"; import "./SignedMath.sol"; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @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), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(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) { 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] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); 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 keccak256(bytes(a)) == keccak256(bytes(b)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/ShortStrings.sol) pragma solidity ^0.8.8; import "./StorageSlot.sol"; // | string | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | // | length | 0x BB | type ShortString is bytes32; /** * @dev This library provides functions to convert short memory strings * into a `ShortString` type that can be used as an immutable variable. * * Strings of arbitrary length can be optimized using this library if * they are short enough (up to 31 bytes) by packing them with their * length (1 byte) in a single EVM word (32 bytes). Additionally, a * fallback mechanism can be used for every other case. * * Usage example: * * ```solidity * contract Named { * using ShortStrings for *; * * ShortString private immutable _name; * string private _nameFallback; * * constructor(string memory contractName) { * _name = contractName.toShortStringWithFallback(_nameFallback); * } * * function name() external view returns (string memory) { * return _name.toStringWithFallback(_nameFallback); * } * } * ``` */ 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; } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC5267.sol) pragma solidity ^0.8.0; 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 ); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @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 up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (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; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) 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. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 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. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); 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 (rounding == Rounding.Up && 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 down. * * 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * 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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * 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 + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * 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 + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.0; /** * @dev Standard signed math utilities missing in the Solidity language. */ 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); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol) // This file was procedurally generated from scripts/generate/templates/StorageSlot.js. pragma solidity ^0.8.0; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC1967 implementation slot: * ```solidity * contract ERC1967 { * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` * * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._ * _Available since v4.9 for `string`, `bytes`._ */ 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 } } }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"AMMPair","type":"address"},{"indexed":false,"internalType":"bool","name":"isPair","type":"bool"}],"name":"AMMPairsUpdated","type":"event"},{"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":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isBlacklisted","type":"bool"}],"name":"BlacklistUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeFromFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeFromLimits","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeFromTradingRestriction","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"maxWalletAmount","type":"uint256"}],"name":"MaxWalletAmountUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","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":"routerV2","type":"address"}],"name":"RouterV2Updated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"swapThresholdRatio","type":"uint16"}],"name":"SwapThresholdUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"TradingEnabled","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"marketingAddress","type":"address"}],"name":"marketingAddressUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"marketingFeeSent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"buyFee","type":"uint16"},{"indexed":false,"internalType":"uint16","name":"sellFee","type":"uint16"},{"indexed":false,"internalType":"uint16","name":"transferFee","type":"uint16"}],"name":"marketingFeesUpdated","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"AMMPairs","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","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":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"isBlacklisted","type":"bool"}],"name":"blacklist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"blacklisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","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":"enableTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"excludeFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"excludeFromLimits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"excludeFromTradingRestriction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAllPending","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSwapThresholdAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_router","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExcludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExcludedFromLimits","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExcludedFromTradingRestriction","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketingAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newAddress","type":"address"}],"name":"marketingAddressSetup","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"marketingFees","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"_buyFee","type":"uint16"},{"internalType":"uint16","name":"_sellFee","type":"uint16"},{"internalType":"uint16","name":"_transferFee","type":"uint16"}],"name":"marketingFeesSetup","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxWalletAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[],"name":"pairV2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","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":[],"name":"routerV2","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"isPair","type":"bool"}],"name":"setAMMPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapThresholdRatio","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"totalFees","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","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"},{"inputs":[{"internalType":"uint256","name":"_maxWalletAmount","type":"uint256"}],"name":"updateMaxWalletAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_swapThresholdRatio","type":"uint16"}],"name":"updateSwapThreshold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
0x6080604052600436106102975760003560e01c8063801b51d91161015a578063c0a904a2116100c1578063dbac26e91161007a578063dbac26e914610820578063dd62ed3e14610850578063e30c397814610870578063e85ceee81461088e578063f112ba72146108be578063f2fde38b146108d357600080fd5b8063c0a904a21461076b578063c18bc1951461078b578063c400f5e7146107ab578063c4d66de8146107cb578063d505accf146107eb578063d94775261461080b57600080fd5b806395d89b411161011357806395d89b41146106c0578063a457c2d7146106d5578063a5ece941146106f5578063a9059cbb14610715578063aa4bde2814610735578063c02466681461074b57600080fd5b8063801b51d91461060557806384b0196e146106255780638a8c523c1461064d5780638da5cb5b146106625780638e749a8f146106805780638fffabed146106a057600080fd5b80634a4dd9cd116101fe57806370a08231116101b757806370a0823114610535578063715018a61461056b578063768565571461058057806379ba5097146105b057806379cc6790146105c55780637ecebe00146105e557600080fd5b80634a4dd9cd146104435780634ada218b146104635780634f011b831461047d5780634fbee19314610498578063502f7446146104c85780635cce86cd1461050557600080fd5b8063313ce56711610250578063313ce5671461037f5780633644e5151461039b57806339509351146103b0578063404e5129146103d0578063408ccbdf146103f057806342966c681461042357600080fd5b806306fdde03146102a3578063095ea7b3146102ce57806318160ddd146102fe5780631a0e718c1461031d57806323b872dd1461033f5780632d99d32e1461035f57600080fd5b3661029e57005b600080fd5b3480156102af57600080fd5b506102b86108f3565b6040516102c59190612b6b565b60405180910390f35b3480156102da57600080fd5b506102ee6102e9366004612b9a565b610985565b60405190151581526020016102c5565b34801561030a57600080fd5b506002545b6040519081526020016102c5565b34801561032957600080fd5b5061033d610338366004612bdd565b61099f565b005b34801561034b57600080fd5b506102ee61035a366004612bf8565b610a97565b34801561036b57600080fd5b5061033d61037a366004612c39565b610abb565b34801561038b57600080fd5b50604051601281526020016102c5565b3480156103a757600080fd5b5061030f610b4b565b3480156103bc57600080fd5b506102ee6103cb366004612b9a565b610b5a565b3480156103dc57600080fd5b5061033d6103eb366004612c39565b610b7c565b3480156103fc57600080fd5b5061041061040b366004612c77565b610be4565b60405161ffff90911681526020016102c5565b34801561042f57600080fd5b5061033d61043e366004612c77565b610c12565b34801561044f57600080fd5b5061033d61045e366004612c90565b610c1f565b34801561046f57600080fd5b506018546102ee9060ff1681565b34801561048957600080fd5b50600d546104109061ffff1681565b3480156104a457600080fd5b506102ee6104b3366004612cd3565b60116020526000908152604090205460ff1681565b3480156104d457600080fd5b506013546104ed9061010090046001600160a01b031681565b6040516001600160a01b0390911681526020016102c5565b34801561051157600080fd5b506102ee610520366004612cd3565b60166020526000908152604090205460ff1681565b34801561054157600080fd5b5061030f610550366004612cd3565b6001600160a01b031660009081526020819052604090205490565b34801561057757600080fd5b5061033d610e14565b34801561058c57600080fd5b506102ee61059b366004612cd3565b60156020526000908152604090205460ff1681565b3480156105bc57600080fd5b5061033d610e28565b3480156105d157600080fd5b5061033d6105e0366004612b9a565b610e9f565b3480156105f157600080fd5b5061030f610600366004612cd3565b610eb4565b34801561061157600080fd5b5061033d610620366004612c39565b610ed2565b34801561063157600080fd5b5061063a610f32565b6040516102c59796959493929190612cf0565b34801561065957600080fd5b5061033d610fbb565b34801561066e57600080fd5b506005546001600160a01b03166104ed565b34801561068c57600080fd5b5061041061069b366004612c77565b611061565b3480156106ac57600080fd5b506014546104ed906001600160a01b031681565b3480156106cc57600080fd5b506102b8611071565b3480156106e157600080fd5b506102ee6106f0366004612b9a565b611080565b34801561070157600080fd5b50600f546104ed906001600160a01b031681565b34801561072157600080fd5b506102ee610730366004612b9a565b6110fb565b34801561074157600080fd5b5061030f60175481565b34801561075757600080fd5b5061033d610766366004612c39565b611109565b34801561077757600080fd5b5061033d610786366004612c39565b611169565b34801561079757600080fd5b5061033d6107a6366004612c77565b61117b565b3480156107b757600080fd5b5061033d6107c6366004612cd3565b61120f565b3480156107d757600080fd5b5061033d6107e6366004612cd3565b61130c565b3480156107f757600080fd5b5061033d610806366004612d86565b6113c8565b34801561081757600080fd5b5061030f61152c565b34801561082c57600080fd5b506102ee61083b366004612cd3565b600c6020526000908152604090205460ff1681565b34801561085c57600080fd5b5061030f61086b366004612dfd565b611568565b34801561087c57600080fd5b506006546001600160a01b03166104ed565b34801561089a57600080fd5b506102ee6108a9366004612cd3565b60196020526000908152604090205460ff1681565b3480156108ca57600080fd5b5061030f611593565b3480156108df57600080fd5b5061033d6108ee366004612cd3565b6115a4565b60606003805461090290612e2b565b80601f016020809104026020016040519081016040528092919081815260200182805461092e90612e2b565b801561097b5780601f106109505761010080835404028352916020019161097b565b820191906000526020600020905b81548152906001019060200180831161095e57829003601f168201915b5050505050905090565b600033610993818585611615565b60019150505b92915050565b6109a7611739565b60008161ffff161180156109c157506101f48161ffff1611155b610a4c5760405162461bcd60e51b815260206004820152604b60248201527f537761705468726573686f6c643a2043616e6e6f7420657863656564206c696d60448201527f6974732066726f6d20302e30312520746f20352520666f72206e65772073776160648201526a1c081d1a1c995cda1bdb1960aa1b608482015260a4015b60405180910390fd5b600d805461ffff191661ffff83169081179091556040519081527fcf1366790fe21e66c9df9dcf67218b1e10acd64d3c99ae8a7429a68de91f1720906020015b60405180910390a150565b600033610aa5858285611793565b610ab085858561180d565b506001949350505050565b610ac3611739565b6014546001600160a01b0390811690831603610b3d5760405162461bcd60e51b815260206004820152603360248201527f44656661756c74526f757465723a2043616e6e6f742072656d6f766520696e696044820152721d1a585b081c185a5c88199c9bdb481b1a5cdd606a1b6064820152608401610a43565b610b478282611bb0565b5050565b6000610b55611c25565b905090565b600033610993818585610b6d8383611568565b610b779190612e75565b611615565b610b84611739565b6001600160a01b0382166000818152600c6020908152604091829020805460ff191685151590811790915591519182527f6a12b3df6cba4203bd7fd06b816789f87de8c594299aed5717ae070fac781bac91015b60405180910390a25050565b60128160038110610bf457600080fd5b60109182820401919006600202915054906101000a900461ffff1681565b610c1c3382611d50565b50565b610c27611739565b6010546012548491610c409161ffff9182169116612e9e565b610c4a9190612ec0565b6012805461ffff191661ffff92831617908190556010548492610c7a926201000092839004821692900416612e9e565b610c849190612ec0565b6012805463ffff000019166201000061ffff9384160217908190556010548392610cbd9264010000000092839004821692900416612e9e565b610cc79190612ec0565b6012805461ffff9283166401000000000265ffff0000000019821681179092556109c4908316919092161711801590610d0f57506012546109c46201000090910461ffff1611155b8015610d2c57506012546109c464010000000090910461ffff1611155b610d975760405162461bcd60e51b815260206004820152603660248201527f546178657344656661756c74526f757465723a2043616e6e6f7420657863656560448201527564206d617820746f74616c20666565206f662032352560501b6064820152608401610a43565b6040805160608101825261ffff80861682528481166020830152831691810191909152610dc8906010906003612a7a565b506040805161ffff8581168252848116602083015283168183015290517f1e5d76e30cd4303515f118e75cbf9d9440bb68ab78b2c2fa46984200dc11ad649181900360600190a1505050565b610e1c611739565b610e266000611e9a565b565b60065433906001600160a01b03168114610e965760405162461bcd60e51b815260206004820152602960248201527f4f776e61626c6532537465703a2063616c6c6572206973206e6f7420746865206044820152683732bb9037bbb732b960b91b6064820152608401610a43565b610c1c81611e9a565b610eaa823383611793565b610b478282611d50565b6001600160a01b038116600090815260096020526040812054610999565b610eda611739565b6001600160a01b038216600081815260196020908152604091829020805460ff191685151590811790915591519182527f38d2732664f4152f6b6754aa1afeaec7fa6618671b172e5430139b51dba2d1d69101610bd8565b600060608082808083610f667f42756c6c52756e4261636b00000000000000000000000000000000000000000b6007611eb3565b610f917f31000000000000000000000000000000000000000000000000000000000000016008611eb3565b60408051600080825260208201909252600f60f81b9b939a50919850469750309650945092509050565b610fc3611739565b60185460ff16156110295760405162461bcd60e51b815260206004820152602a60248201527f456e61626c6554726164696e673a2054726164696e672077617320656e61626c604482015269656420616c726561647960b01b6064820152608401610a43565b6018805460ff191660011790556040517f799663458a5ef2936f7fa0c99b3336c69c25890f82974f04e811e5bb359186c790600090a1565b60108160038110610bf457600080fd5b60606004805461090290612e2b565b6000338161108e8286611568565b9050838110156110ee5760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77604482015264207a65726f60d81b6064820152608401610a43565b610ab08286868403611615565b60003361099381858561180d565b611111611739565b6001600160a01b038216600081815260116020908152604091829020805460ff191685151590811790915591519182527f9d8f7706ea1113d1a167b526eca956215946dd36cc7df39eb16180222d8b5df79101610bd8565b611171611739565b610b478282611f5e565b611183611739565b61118b611fb6565b8110156111da5760405162461bcd60e51b815260206004820152601860248201527f4d617857616c6c65743a204c696d697420746f6f206c6f7700000000000000006044820152606401610a43565b60178190556040518181527f4b39c36d20c57d220f61fd25c4349d4435cc03ef6c2a680942f15333c3c3e00190602001610a8c565b611217611739565b6001600160a01b0381166112a25760405162461bcd60e51b815260206004820152604660248201527f546178657344656661756c74526f7574657257616c6c65743a2057616c6c657460448201527f2074617820726563697069656e742063616e6e6f74206265206120307830206160648201526564647265737360d01b608482015260a401610a43565b600f80546001600160a01b0319166001600160a01b0383161790556112c8816001611109565b6112d3816001611f5e565b6040516001600160a01b03821681527feaf1986d341c3096d2d5d32f86ed29a21fee4e0d8365cd2b6fa85c0ec6889cf690602001610a8c565b600b54610100900460ff16806113255750600b5460ff16155b6113885760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b6064820152608401610a43565b600b54610100900460ff161580156113aa57600b805461ffff19166101011790555b6113b382611fc4565b8015610b4757600b805461ff00191690555050565b834211156114185760405162461bcd60e51b815260206004820152601d60248201527f45524332305065726d69743a206578706972656420646561646c696e650000006044820152606401610a43565b60007f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c98888886114478c6121d2565b6040805160208101969096526001600160a01b0394851690860152929091166060840152608083015260a082015260c0810186905260e00160405160208183030381529060405280519060200120905060006114a2826121fa565b905060006114b282878787612227565b9050896001600160a01b0316816001600160a01b0316146115155760405162461bcd60e51b815260206004820152601e60248201527f45524332305065726d69743a20696e76616c6964207369676e617475726500006044820152606401610a43565b6115208a8a8a611615565b50505050505050505050565b600d546014546001600160a01b031660009081526020819052604081205490916127109161155e9161ffff1690612edb565b610b559190612ef2565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b6000600e546000610b559190612e75565b6115ac611739565b600680546001600160a01b0383166001600160a01b031990911681179091556115dd6005546001600160a01b031690565b6001600160a01b03167f38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e2270060405160405180910390a350565b6001600160a01b0383166116775760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b6064820152608401610a43565b6001600160a01b0382166116d85760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b6064820152608401610a43565b6001600160a01b0383811660008181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b6005546001600160a01b03163314610e265760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610a43565b600061179f8484611568565b9050600019811461180757818110156117fa5760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e63650000006044820152606401610a43565b6118078484848403611615565b50505050565b60135460ff161580156118205750600081115b801561183f57506013546001600160a01b038381166101009092041614155b801561186457506001600160a01b03831660009081526011602052604090205460ff16155b801561188957506001600160a01b03821660009081526011602052604090205460ff16155b15611a28576001600160a01b03831660009081526015602052604081205460039060ff16156118c75760125461ffff16156118c2575060005b61191a565b6001600160a01b03841660009081526015602052604090205460ff16156119025760125462010000900461ffff16156118c25750600161191a565b601254640100000000900461ffff161561191a575060025b60038160ff161015611a145761271060128260ff166003811061193f5761193f612e88565b601091828204019190066002029054906101000a900461ffff1661ffff16846119689190612edb565b6119729190612ef2565b915061197e8284612f14565b925060128160ff166003811061199657611996612e88565b601091828204019190066002029054906101000a900461ffff1661ffff1660108260ff16600381106119ca576119ca612e88565b601091828204019190066002029054906101000a900461ffff1661ffff16836119f39190612edb565b6119fd9190612ef2565b600e6000828254611a0e9190612e75565b90915550505b8115611a2557611a2585308461224f565b50505b6000611a3261152c565b611a3a611593565b10158015611a6057506014546001600160a01b0316600090815260208190526040812054115b60135490915060ff16158015611a8f57506001600160a01b03841660009081526015602052604090205460ff16155b8015611aae57506013546001600160a01b038581166101009092041614155b8015611ab75750805b15611ba5576013805460ff191660011790556000600e541115611b9a576000600e546000611ae59190612e75565b90506000611af282612404565b600e5447906000908490611b069084612edb565b611b109190612ef2565b90508015611b9057600f546040516001600160a01b039091169082156108fc029083906000818181858888f1935050505092508215611b9057600f54604080516001600160a01b039092168252602082018390527f3e6afd69feef8f4cc1adbe6d3905e477db85aa5aa28d02674dc4bc6d39237fe4910160405180910390a15b50506000600e5550505b6013805460ff191690555b61180784848461224f565b6001600160a01b0382166000908152601560205260409020805460ff19168215801591909117909155611be857611be8826001611f5e565b816001600160a01b03167f911aa18ddbbbc33c9b4c704a71bdaa0984b0aa2e82726a7f51e64bad0b0a845582604051610bd8911515815260200190565b6000306001600160a01b037f00000000000000000000000026a20e3a9f944ffd76b507d3075808225569381d16148015611c7e57507f000000000000000000000000000000000000000000000000000000000000000146145b15611ca857507f036ab0bbf44b3b789343f3130a8474762b3a6882282d15aeb77acda7ec9f48a690565b610b55604080517f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f60208201527f41cc59a1e0739c2a0749e5ddfd308cc338e7c63b35913dc40ed986a06128d170918101919091527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc660608201524660808201523060a082015260009060c00160405160208183030381529060405280519060200120905090565b6001600160a01b038216611db05760405162461bcd60e51b815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f206164647265736044820152607360f81b6064820152608401610a43565b611dbc82600083612581565b6001600160a01b03821660009081526020819052604090205481811015611e305760405162461bcd60e51b815260206004820152602260248201527f45524332303a206275726e20616d6f756e7420657863656564732062616c616e604482015261636560f01b6064820152608401610a43565b6001600160a01b0383166000818152602081815260408083208686039055600280548790039055518581529192917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3611e9583600084612717565b505050565b600680546001600160a01b0319169055610c1c816127b3565b606060ff8314611ecd57611ec683612805565b9050610999565b818054611ed990612e2b565b80601f0160208091040260200160405190810160405280929190818152602001828054611f0590612e2b565b8015611f525780601f10611f2757610100808354040283529160200191611f52565b820191906000526020600020905b815481529060010190602001808311611f3557829003601f168201915b50505050509050610999565b6001600160a01b038216600081815260166020908152604091829020805460ff191685151590811790915591519182527f4b89c347592b1d537e066cb4ed98d87696ae35164745d7e370e4add16941dc929101610bd8565b60006103e861155e60025490565b80601360016101000a8154816001600160a01b0302191690836001600160a01b03160217905550601360019054906101000a90046001600160a01b03166001600160a01b031663c45a01556040518163ffffffff1660e01b8152600401602060405180830381865afa15801561203e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906120629190612f27565b6001600160a01b031663c9c6539630601360019054906101000a90046001600160a01b03166001600160a01b031663ad5c46486040518163ffffffff1660e01b8152600401602060405180830381865afa1580156120c4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906120e89190612f27565b6040516001600160e01b031960e085901b1681526001600160a01b039283166004820152911660248201526044016020604051808303816000875af1158015612135573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906121599190612f27565b601480546001600160a01b0319166001600160a01b0392909216919091179055612184816001611f5e565b60145461219b906001600160a01b03166001611bb0565b6040516001600160a01b038216907fbc052db65df144ad4f71f02da93cae3d4401104c30ac374d7cc10d87ee07b60290600090a250565b6001600160a01b03811660009081526009602052604090208054600181018255905b50919050565b6000610999612207611c25565b8360405161190160f01b8152600281019290925260228201526042902090565b600080600061223887878787612844565b9150915061224581612908565b5095945050505050565b6001600160a01b0383166122b35760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604482015264647265737360d81b6064820152608401610a43565b6001600160a01b0382166123155760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201526265737360e81b6064820152608401610a43565b612320838383612581565b6001600160a01b038316600090815260208190526040902054818110156123985760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e7420657863656564732062604482015265616c616e636560d01b6064820152608401610a43565b6001600160a01b03848116600081815260208181526040808320878703905593871680835291849020805487019055925185815290927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3611807848484612717565b604080516002808252606082018352600092602083019080368337019050509050308160008151811061243957612439612e88565b60200260200101906001600160a01b031690816001600160a01b031681525050601360019054906101000a90046001600160a01b03166001600160a01b031663ad5c46486040518163ffffffff1660e01b8152600401602060405180830381865afa1580156124ac573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906124d09190612f27565b816001815181106124e3576124e3612e88565b6001600160a01b03928316602091820292909201015260135461250e91309161010090041684611615565b60135460405163791ac94760e01b81526101009091046001600160a01b03169063791ac9479061254b908590600090869030904290600401612f44565b600060405180830381600087803b15801561256557600080fd5b505af1158015612579573d6000803e3d6000fd5b505050505050565b6001600160a01b0383166000908152600c602052604090205460ff161580156125c357506001600160a01b0382166000908152600c602052604090205460ff16155b6126255760405162461bcd60e51b815260206004820152602d60248201527f426c61636b6c6973743a2053656e646572206f7220726563697069656e74206960448201526c1cc8189b1858dadb1a5cdd1959609a1b6064820152608401610a43565b6001600160a01b03831660009081526015602052604090205460ff16801561266657506001600160a01b03821660009081526019602052604090205460ff16155b806126ad57506001600160a01b03821660009081526015602052604090205460ff1680156126ad57506001600160a01b03831660009081526019602052604090205460ff16155b15611e955760185460ff16611e955760405162461bcd60e51b815260206004820152602a60248201527f456e61626c6554726164696e673a2054726164696e6720776173206e6f7420656044820152691b98589b1959081e595d60b21b6064820152608401610a43565b6001600160a01b03821660009081526016602052604090205460ff16611e95576017546001600160a01b0383166000908152602081905260409020541115611e955760405162461bcd60e51b815260206004820152602960248201527f4d617857616c6c65743a2043616e6e6f7420657863656564206d61782077616c6044820152681b195d081b1a5b5a5d60ba1b6064820152608401610a43565b600580546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6060600061281283612a52565b604080516020808252818301909252919250600091906020820181803683375050509182525060208101929092525090565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a083111561287b57506000905060036128ff565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa1580156128cf573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b0381166128f8576000600192509250506128ff565b9150600090505b94509492505050565b600081600481111561291c5761291c612fb5565b036129245750565b600181600481111561293857612938612fb5565b036129855760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e617475726500000000000000006044820152606401610a43565b600281600481111561299957612999612fb5565b036129e65760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e677468006044820152606401610a43565b60038160048111156129fa576129fa612fb5565b03610c1c5760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b6064820152608401610a43565b600060ff8216601f81111561099957604051632cd44ac360e21b815260040160405180910390fd5b600183019183908215612b005791602002820160005b83821115612ad057835183826101000a81548161ffff021916908361ffff1602179055509260200192600201602081600101049283019260010302612a90565b8015612afe5782816101000a81549061ffff0219169055600201602081600101049283019260010302612ad0565b505b50612b0c929150612b10565b5090565b5b80821115612b0c5760008155600101612b11565b6000815180845260005b81811015612b4b57602081850181015186830182015201612b2f565b506000602082860101526020601f19601f83011685010191505092915050565b602081526000612b7e6020830184612b25565b9392505050565b6001600160a01b0381168114610c1c57600080fd5b60008060408385031215612bad57600080fd5b8235612bb881612b85565b946020939093013593505050565b803561ffff81168114612bd857600080fd5b919050565b600060208284031215612bef57600080fd5b612b7e82612bc6565b600080600060608486031215612c0d57600080fd5b8335612c1881612b85565b92506020840135612c2881612b85565b929592945050506040919091013590565b60008060408385031215612c4c57600080fd5b8235612c5781612b85565b915060208301358015158114612c6c57600080fd5b809150509250929050565b600060208284031215612c8957600080fd5b5035919050565b600080600060608486031215612ca557600080fd5b612cae84612bc6565b9250612cbc60208501612bc6565b9150612cca60408501612bc6565b90509250925092565b600060208284031215612ce557600080fd5b8135612b7e81612b85565b60ff60f81b881681526000602060e081840152612d1060e084018a612b25565b8381036040850152612d22818a612b25565b606085018990526001600160a01b038816608086015260a0850187905284810360c0860152855180825283870192509083019060005b81811015612d7457835183529284019291840191600101612d58565b50909c9b505050505050505050505050565b600080600080600080600060e0888a031215612da157600080fd5b8735612dac81612b85565b96506020880135612dbc81612b85565b95506040880135945060608801359350608088013560ff81168114612de057600080fd5b9699959850939692959460a0840135945060c09093013592915050565b60008060408385031215612e1057600080fd5b8235612e1b81612b85565b91506020830135612c6c81612b85565b600181811c90821680612e3f57607f821691505b6020821081036121f457634e487b7160e01b600052602260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b8082018082111561099957610999612e5f565b634e487b7160e01b600052603260045260246000fd5b61ffff828116828216039080821115612eb957612eb9612e5f565b5092915050565b61ffff818116838216019080821115612eb957612eb9612e5f565b808202811582820484141761099957610999612e5f565b600082612f0f57634e487b7160e01b600052601260045260246000fd5b500490565b8181038181111561099957610999612e5f565b600060208284031215612f3957600080fd5b8151612b7e81612b85565b600060a082018783526020878185015260a0604085015281875180845260c086019150828901935060005b81811015612f945784516001600160a01b031683529383019391830191600101612f6f565b50506001600160a01b03969096166060850152505050608001529392505050565b634e487b7160e01b600052602160045260246000fdfea2646970667358221220ee33bdbc55759dc213c8f6bc9894793467b804c60bfe4fd7d08c80fc1c481d9264736f6c63430008130033
Loading...
Loading
Loading...
Loading
[ 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.