Dinoshi | Address 0x45418Cf495a4d3D9F9D5842207072d292E6a056f | Etherscan (2024)

0 ETH

Add

dinoshideployer1.eth at txn 0xb40d46e253074f5e9ae3057c91986c6876fe20ac6688ec25f7747f9c929a63c1

Dinoshi (DINOSHI)

Contract Source Code Verified (Exact Match)

File 1 of 14 : Contract.sol

/**██████╗░██╗███╗░░██╗░█████╗░░██████╗██╗░░██╗██╗██╔══██╗██║████╗░██║██╔══██╗██╔════╝██║░░██║██║██║░░██║██║██╔██╗██║██║░░██║╚█████╗░███████║██║██║░░██║██║██║╚████║██║░░██║░╚═══██╗██╔══██║██║██████╔╝██║██║░╚███║╚█████╔╝██████╔╝██║░░██║██║╚═════╝░╚═╝╚═╝░░╚══╝░╚════╝░╚═════╝░╚═╝░░╚═╝╚═╝Website: https://dinolfg.comTelegram: https://t.me/OfficialDinoLFGTwiiter: https://x.com/therealdinoshi*/// SPDX-License-Identifier: MIT// File: @openzeppelin/contracts/interfaces/draft-IERC6093.solpragma solidity ^0.8.20;/** * @dev Standard ERC20 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens. */interface IERC20Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientBalance( address sender, uint256 balance, uint256 needed ); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC20InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC20InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers. * @param spender Address that may be allowed to operate on tokens without being their owner. * @param allowance Amount of tokens a `spender` is allowed to operate with. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientAllowance( address spender, uint256 allowance, uint256 needed ); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC20InvalidApprover(address approver); /** * @dev Indicates a failure with the `spender` to be approved. Used in approvals. * @param spender Address that may be allowed to operate on tokens without being their owner. */ error ERC20InvalidSpender(address spender);}// File: @openzeppelin/contracts/utils/Context.sol// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)pragma solidity ^0.8.20;/** * @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; } function _contextSuffixLength() internal view virtual returns (uint256) { return 0; }}// File: @openzeppelin/contracts/access/Ownable.sol// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)pragma solidity ^0.8.20;/** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * The initial owner is set to the address provided by the deployer. This can * later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */abstract contract Ownable is Context { address private _owner; /** * @dev The caller account is not authorized to perform an operation. */ error OwnableUnauthorizedAccount(address account); /** * @dev The owner is not a valid owner account. (eg. `address(0)`) */ error OwnableInvalidOwner(address owner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); /** * @dev Initializes the contract setting the address provided by the deployer as the initial owner. */ constructor(address initialOwner) { if (initialOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(initialOwner); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { if (owner() != _msgSender()) { revert OwnableUnauthorizedAccount(_msgSender()); } } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { if (newOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); }}// File: @openzeppelin/contracts/token/ERC20/IERC20.sol// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)pragma solidity ^0.8.20;/** * @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 value of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the value of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves a `value` amount of tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 value) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance( address owner, address spender ) external view returns (uint256); /** * @dev Sets a `value` amount of tokens as the allowance of `spender` over the * caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 value) external returns (bool); /** * @dev Moves a `value` amount of tokens from `from` to `to` using the * allowance mechanism. `value` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 value ) external returns (bool);}// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)pragma solidity ^0.8.20;/** * @dev Interface for the optional metadata functions from the ERC20 standard. */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);}// File: @openzeppelin/contracts/token/ERC20/ERC20.sol// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)pragma solidity ^0.8.20;/** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * * TIP: For a detailed writeup see our guide * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * The default value of {decimals} is 18. To change this, you should override * this function so it returns a different value. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. */abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors { mapping(address account => uint256) private _balances; mapping(address account => mapping(address spender => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the default value returned by this function, unless * it's overridden. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `value`. */ function transfer(address to, uint256 value) public virtual returns (bool) { address owner = _msgSender(); _transfer(owner, to, value); return true; } /** * @dev See {IERC20-allowance}. */ function allowance( address owner, address spender ) public view virtual returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve( address spender, uint256 value ) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, value); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `value`. * - the caller must have allowance for ``from``'s tokens of at least * `value`. */ function transferFrom( address from, address to, uint256 value ) public virtual returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, value); _transfer(from, to, value); return true; } /** * @dev Moves a `value` amount of tokens from `from` to `to`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * NOTE: This function is not virtual, {_update} should be overridden instead. */ function _transfer(address from, address to, uint256 value) internal { if (from == address(0)) { revert ERC20InvalidSender(address(0)); } if (to == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(from, to, value); } /** * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from` * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding * this function. * * Emits a {Transfer} event. */ function _update(address from, address to, uint256 value) internal virtual { if (from == address(0)) { // Overflow check required: The rest of the code assumes that totalSupply never overflows _totalSupply += value; } else { uint256 fromBalance = _balances[from]; if (fromBalance < value) { revert ERC20InsufficientBalance(from, fromBalance, value); } unchecked { // Overflow not possible: value <= fromBalance <= totalSupply. _balances[from] = fromBalance - value; } } if (to == address(0)) { unchecked { // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply. _totalSupply -= value; } } else { unchecked { // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256. _balances[to] += value; } } emit Transfer(from, to, value); } /** * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0). * Relies on the `_update` mechanism * * Emits a {Transfer} event with `from` set to the zero address. * * NOTE: This function is not virtual, {_update} should be overridden instead. */ function _mint(address account, uint256 value) internal { if (account == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(address(0), account, value); } /** * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply. * Relies on the `_update` mechanism. * * Emits a {Transfer} event with `to` set to the zero address. * * NOTE: This function is not virtual, {_update} should be overridden instead */ function _burn(address account, uint256 value) internal { if (account == address(0)) { revert ERC20InvalidSender(address(0)); } _update(account, address(0), value); } /** * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. * * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument. */ function _approve(address owner, address spender, uint256 value) internal { _approve(owner, spender, value, true); } /** * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event. * * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any * `Approval` event during `transferFrom` operations. * * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to * true using the following override: * ``` * function _approve(address owner, address spender, uint256 value, bool) internal virtual override { * super._approve(owner, spender, value, true); * } * ``` * * Requirements are the same as {_approve}. */ function _approve( address owner, address spender, uint256 value, bool emitEvent ) internal virtual { if (owner == address(0)) { revert ERC20InvalidApprover(address(0)); } if (spender == address(0)) { revert ERC20InvalidSpender(address(0)); } _allowances[owner][spender] = value; if (emitEvent) { emit Approval(owner, spender, value); } } /** * @dev Updates `owner` s allowance for `spender` based on spent `value`. * * Does not update the allowance value in case of infinite allowance. * Revert if not enough allowance is available. * * Does not emit an {Approval} event. */ function _spendAllowance( address owner, address spender, uint256 value ) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { if (currentAllowance < value) { revert ERC20InsufficientAllowance( spender, currentAllowance, value ); } unchecked { _approve(owner, spender, currentAllowance - value, false); } } }}// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Burnable.sol)pragma solidity ^0.8.20;/** * @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 a `value` amount of tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 value) public virtual { _burn(_msgSender(), value); } /** * @dev Destroys a `value` amount of 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 * `value`. */ function burnFrom(address account, uint256 value) public virtual { _spendAllowance(account, _msgSender(), value); _burn(account, value); }}// Compatible with OpenZeppelin Contracts ^5.0.0pragma solidity ^0.8.20;interface IUniswapV2Factory { event PairCreated( address indexed token0, address indexed token1, address pair, uint ); function getPair( address tokenA, address tokenB ) external view returns (address pair); function createPair( address tokenA, address tokenB ) external returns (address pair);}interface IUniswapV2Router02 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external;}interface IBeautifulToken { event SwapTokensAtAmountUpdated(uint256 value); event SwapAndLiquifyEnabledUpdated(bool enabled); event SwapAndLiquify( uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity ); event DistributeFeeTokens(uint256 tokens); event V2RouterUpdated( address indexed newAddress, address indexed oldAddress ); event SetAutomatedMarketMakerPair(address indexed pair, bool value); event ExcludeFromTax(address indexed _user, bool _isExcludeFromTax); event TaxUpdated(uint256 buyTax, uint256 sellTax); event MaxBuyCapUpdated(uint256 oldCap, uint256 newCap); event MaxSellCapUpdated(uint256 oldCap, uint256 newCap); event OpenTrading(bool); event RemoveLimits(); error TradeOpened(); error TradeNotOpened();}contract Dinoshi is IBeautifulToken, ERC20, ERC20Burnable, Ownable { IUniswapV2Router02 public uniswapV2Router; mapping(address => bool) public automatedMarketMakerPairs; mapping(address => bool) public isExcludeFromTax; address public pair; address[] public feeReceivers; uint256[] public feeDividers; uint256 public absorbFeeRate; address public marketingWallet; address public liquidityWallet; uint256 public MAX_SUPPLY = 3_333_333 * (10 ** decimals()); uint256 public buyTax; uint256 public sellTax; uint256 public maxBuyCap; uint256 public maxSellCap; bool private swapping; bool public swapAndLiquifyEnabled = true; bool public tradeOpened = false; uint256 public swapTokensAtAmount; constructor() ERC20("Dinoshi", "DINOSHI") Ownable(msg.sender) { IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02( 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D ); // routerv2 for mainnet ethereum chain uniswapV2Router = _uniswapV2Router; buyTax = 0; sellTax = 0; _setUpAbsorbFee(); maxBuyCap = MAX_SUPPLY / 2; // 2% supply maxSellCap = MAX_SUPPLY / 2; // 2% supply swapTokensAtAmount = MAX_SUPPLY / 200; // 0.5% supply isExcludeFromTax[address(msg.sender)] = true; // excluding deployer isExcludeFromTax[address(this)] = true; _mint(msg.sender, MAX_SUPPLY); } /** * @dev this function is used to set up fee before deployment */ function _setUpAbsorbFee() private { absorbFeeRate = 0; } /** * @dev this function is for open trading */ function openTrading() external onlyOwner { if (tradeOpened == true) { revert TradeOpened(); } address _uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()) .getPair(address(this), uniswapV2Router.WETH()); pair = _uniswapV2Pair; automatedMarketMakerPairs[_uniswapV2Pair] = true; tradeOpened = true; emit OpenTrading(true); } /** * @dev this function is for open trading */ function removeLimits() external onlyOwner { maxBuyCap = MAX_SUPPLY; maxSellCap = MAX_SUPPLY; emit RemoveLimits(); } /** * @dev function for setting Automated MarketMaker Pair * @param _pair address for pair. * @param _value boolean true or false. */ function setAutomatedMarketMakerPair( address _pair, bool _value ) external onlyOwner { require( automatedMarketMakerPairs[_pair] != _value, "PairIsAlreadyGivenValue" ); automatedMarketMakerPairs[_pair] = _value; emit SetAutomatedMarketMakerPair(_pair, _value); } /** * @dev Function to update isExcludeFromTax mapping to exclude or include From Tax * @param _user The address to be exclude or include From Tax * @param _isExcludeFromTax true or false */ function excludeFromTax( address _user, bool _isExcludeFromTax ) external onlyOwner { isExcludeFromTax[_user] = _isExcludeFromTax; emit ExcludeFromTax(_user, _isExcludeFromTax); } function setDinoshiDao(uint256 buyFee, uint256 sellFee) external onlyOwner { buyTax = buyFee; sellTax = sellFee; emit TaxUpdated(buyFee, sellFee); } /** * @dev Function to update MaxBuyCap * @param cap cap in amounts of tokens in wei */ function setMaxWallet(uint256 cap) external onlyOwner { require( cap >= totalSupply() / 100, "maxBuy Cannot be less than 1% of totalSupply" ); emit MaxBuyCapUpdated(maxBuyCap, cap); maxBuyCap = cap; } /** * @dev Function to update MaxSellCap * @param cap cap in amounts of tokens in wei */ function setMaxSwapTnx(uint256 cap) external onlyOwner { require( cap >= totalSupply() / 100, "maxSell Cannot be less than 1% of totalSupply" ); emit MaxSellCapUpdated(maxSellCap, cap); maxSellCap = cap; } /** * @dev Function to toggle swap and liquify feature * @param _enabled true or false */ function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner { swapAndLiquifyEnabled = _enabled; emit SwapAndLiquifyEnabledUpdated(_enabled); } //to receive ETH from uniswapV2Router when swaping receive() external payable {} // The following function is overriden to support fees on transfers function _update( address from, address to, uint256 value ) internal override(ERC20) { if (tradeOpened == false && (from != owner() && to != owner())) { revert TradeNotOpened(); } if ( !swapping && from != address(uniswapV2Router) && //router -> pair is removing liquidity which shouldn't have max !isExcludeFromTax[to] //no max for those excluded from fees ) { _validateTransfer(from, to, value, true); } uint256 contractTokenBalance = balanceOf(address(this)); bool canSwap = contractTokenBalance >= swapTokensAtAmount; if ( swapAndLiquifyEnabled && canSwap && !swapping && !automatedMarketMakerPairs[from] && from != owner() && to != owner() ) { swapping = true; uint256 swapTokens = (contractTokenBalance * (100 - absorbFeeRate)) / 100; _swapAndLiquidifyUnderlying(swapTokens); uint256 sellTokens = balanceOf(address(this)); _distributeFeeTokens(sellTokens); swapping = false; } bool takeFee = !swapping; // if any account belongs to isExcludeFromTax account then remove the fee if (isExcludeFromTax[from] || isExcludeFromTax[to]) { takeFee = false; } if (takeFee) { uint256 fees; if (_isBuy(from)) { fees = (value * buyTax) / 100; } else if (_isSell(from, to)) { fees = (value * sellTax) / 100; } value = value - fees; super._update(from, address(this), fees); } super._update(from, to, value); } // helper functions for buy, sell, lp, swap on uniswap function _isSell( address sender, address recipient ) internal view returns (bool) { return sender != address(uniswapV2Router) && automatedMarketMakerPairs[recipient]; } function _isBuy(address sender) internal view returns (bool) { return automatedMarketMakerPairs[sender]; } function _swapAndLiquidifyUnderlying(uint256 contractTokenBalance) private { uint256 half = contractTokenBalance / 2; uint256 otherHalf = contractTokenBalance - half; uint256 initialBalance = address(this).balance; // swap tokens for ETH swapTokensForEth(half); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered // how much ETH did we just swap into? uint256 newBalance = address(this).balance - initialBalance; // add liquidity to uniswap _addLiquidityUnderlying(otherHalf, newBalance); emit SwapAndLiquify(half, newBalance, otherHalf); } function swapTokensForEth(uint256 tokenAmount) private { // generate the uniswap pair path of token -> weth address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); // make the swap try uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( tokenAmount, 0, // accept any amount of ETH path, address(this), block.timestamp ) {} catch {} } function _addLiquidityUnderlying( uint256 tokenAmount, uint256 ethAmount ) private { _approve(address(this), address(uniswapV2Router), tokenAmount); try uniswapV2Router.addLiquidityETH{ value: ethAmount }( address(this), tokenAmount, 0, 0, liquidityWallet, block.timestamp ) {} catch {} } function _distributeFeeTokens(uint256 tokens) private { for (uint i = 0; i < feeDividers.length; i++) { _transfer( address(this), feeReceivers[i], (tokens * feeDividers[i]) / 100 ); } emit DistributeFeeTokens(tokens); } function _validateTransfer( address sender, address recipient, uint256 amount, bool takeFee ) private view { // Do not check if we are not open trading if (tradeOpened == false) { return; } // Excluded addresses don't have limits if (takeFee) { if (_isBuy(sender) && maxBuyCap != 0) { require(amount <= maxBuyCap, "Buy amount exceeds limit"); } else if (_isSell(sender, recipient) && maxSellCap != 0) { require(amount <= maxSellCap, "Sell amount exceeds limit"); } } }}

File 2 of 14 : IERC20.sol

// 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);}

File 3 of 14 : IUniswapV2Pair.sol

interface IUniswapV2Pair { event Approval( address indexed owner, address indexed spender, uint256 value ); event Transfer(address indexed from, address indexed to, uint256 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 (uint256); function balanceOf(address owner) external view returns (uint256); function allowance( address owner, address spender ) external view returns (uint256); function approve(address spender, uint256 value) external returns (bool); function transfer(address to, uint256 value) external returns (bool); function transferFrom( address from, address to, uint256 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 (uint256); function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; event Mint(address indexed sender, uint256 amount0, uint256 amount1); event Burn( address indexed sender, uint256 amount0, uint256 amount1, address indexed to ); event Swap( address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint256); 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 (uint256); function price1CumulativeLast() external view returns (uint256); function kLast() external view returns (uint256); function mint(address to) external returns (uint256 liquidity); function burn( address to ) external returns (uint256 amount0, uint256 amount1); function swap( uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data ) external; function skim(address to) external; function sync() external; function initialize(address, address) external;}

File 4 of 14 : IUniswapV2Router01.sol

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);}

File 5 of 14 : IUniswapV2Router02.sol

interface IUniswapV2Router02 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity); function addLiquidityETH( address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline ) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external;}

File 6 of 14 : Address.sol

// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)pragma solidity ^0.8.1;/** * @dev Collection of functions related to the address type */library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require( address(this).balance >= amount, "Address: insufficient balance" ); (bool success, ) = recipient.call{ value: amount }(""); require( success, "Address: unable to send value, recipient may have reverted" ); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data ) internal returns (bytes memory) { return functionCallWithValue( target, data, 0, "Address: low-level call failed" ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue( target, data, value, "Address: low-level call with value failed" ); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require( address(this).balance >= value, "Address: insufficient balance for call" ); (bool success, bytes memory returndata) = target.call{ value: value }( data ); return verifyCallResultFromTarget( target, success, returndata, errorMessage ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data ) internal view returns (bytes memory) { return functionStaticCall( target, data, "Address: low-level static call failed" ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget( target, success, returndata, errorMessage ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data ) internal returns (bytes memory) { return functionDelegateCall( target, data, "Address: low-level delegate call failed" ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget( target, success, returndata, errorMessage ); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert( bytes memory returndata, string memory errorMessage ) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } }}

File 7 of 14 : Context.sol

// 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; }}

File 8 of 14 : Ecosystem.sol

// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)pragma solidity ^0.8.1;/** * @dev Collection of functions related to the address type */library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require( address(this).balance >= amount, "Address: insufficient balance" ); (bool success, ) = recipient.call{ value: amount }(""); require( success, "Address: unable to send value, recipient may have reverted" ); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data ) internal returns (bytes memory) { return functionCallWithValue( target, data, 0, "Address: low-level call failed" ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue( target, data, value, "Address: low-level call with value failed" ); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require( address(this).balance >= value, "Address: insufficient balance for call" ); (bool success, bytes memory returndata) = target.call{ value: value }( data ); return verifyCallResultFromTarget( target, success, returndata, errorMessage ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data ) internal view returns (bytes memory) { return functionStaticCall( target, data, "Address: low-level static call failed" ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget( target, success, returndata, errorMessage ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data ) internal returns (bytes memory) { return functionDelegateCall( target, data, "Address: low-level delegate call failed" ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget( target, success, returndata, errorMessage ); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert( bytes memory returndata, string memory errorMessage ) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } }}

File 9 of 14 : Ownable.sol

// 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); }}

File 10 of 14 : SafeCast.sol

// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)// This file was procedurally generated from scripts/generate/templates/SafeCast.js.pragma solidity ^0.8.0;/** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */library SafeCast { /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toUint248(uint256 value) internal pure returns (uint248) { require( value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits" ); return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toUint240(uint256 value) internal pure returns (uint240) { require( value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits" ); return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toUint232(uint256 value) internal pure returns (uint232) { require( value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits" ); return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.2._ */ function toUint224(uint256 value) internal pure returns (uint224) { require( value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits" ); return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toUint216(uint256 value) internal pure returns (uint216) { require( value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits" ); return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toUint208(uint256 value) internal pure returns (uint208) { require( value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits" ); return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toUint200(uint256 value) internal pure returns (uint200) { require( value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits" ); return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toUint192(uint256 value) internal pure returns (uint192) { require( value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits" ); return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toUint184(uint256 value) internal pure returns (uint184) { require( value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits" ); return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toUint176(uint256 value) internal pure returns (uint176) { require( value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits" ); return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toUint168(uint256 value) internal pure returns (uint168) { require( value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits" ); return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toUint160(uint256 value) internal pure returns (uint160) { require( value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits" ); return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toUint152(uint256 value) internal pure returns (uint152) { require( value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits" ); return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toUint144(uint256 value) internal pure returns (uint144) { require( value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits" ); return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toUint136(uint256 value) internal pure returns (uint136) { require( value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits" ); return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v2.5._ */ function toUint128(uint256 value) internal pure returns (uint128) { require( value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits" ); return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toUint120(uint256 value) internal pure returns (uint120) { require( value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits" ); return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toUint112(uint256 value) internal pure returns (uint112) { require( value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits" ); return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toUint104(uint256 value) internal pure returns (uint104) { require( value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits" ); return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.2._ */ function toUint96(uint256 value) internal pure returns (uint96) { require( value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits" ); return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toUint88(uint256 value) internal pure returns (uint88) { require( value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits" ); return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toUint80(uint256 value) internal pure returns (uint80) { require( value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits" ); return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toUint72(uint256 value) internal pure returns (uint72) { require( value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits" ); return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v2.5._ */ function toUint64(uint256 value) internal pure returns (uint64) { require( value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits" ); return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toUint56(uint256 value) internal pure returns (uint56) { require( value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits" ); return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toUint48(uint256 value) internal pure returns (uint48) { require( value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits" ); return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toUint40(uint256 value) internal pure returns (uint40) { require( value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits" ); return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v2.5._ */ function toUint32(uint256 value) internal pure returns (uint32) { require( value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits" ); return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toUint24(uint256 value) internal pure returns (uint24) { require( value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits" ); return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v2.5._ */ function toUint16(uint256 value) internal pure returns (uint16) { require( value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits" ); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v2.5._ */ function toUint8(uint256 value) internal pure returns (uint8) { require( value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits" ); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. * * _Available since v3.0._ */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); require(downcasted == value, "SafeCast: value doesn't fit in 248 bits"); } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); require(downcasted == value, "SafeCast: value doesn't fit in 240 bits"); } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); require(downcasted == value, "SafeCast: value doesn't fit in 232 bits"); } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.7._ */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); require(downcasted == value, "SafeCast: value doesn't fit in 224 bits"); } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); require(downcasted == value, "SafeCast: value doesn't fit in 216 bits"); } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); require(downcasted == value, "SafeCast: value doesn't fit in 208 bits"); } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); require(downcasted == value, "SafeCast: value doesn't fit in 200 bits"); } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); require(downcasted == value, "SafeCast: value doesn't fit in 192 bits"); } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); require(downcasted == value, "SafeCast: value doesn't fit in 184 bits"); } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); require(downcasted == value, "SafeCast: value doesn't fit in 176 bits"); } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); require(downcasted == value, "SafeCast: value doesn't fit in 168 bits"); } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); require(downcasted == value, "SafeCast: value doesn't fit in 160 bits"); } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); require(downcasted == value, "SafeCast: value doesn't fit in 152 bits"); } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); require(downcasted == value, "SafeCast: value doesn't fit in 144 bits"); } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); require(downcasted == value, "SafeCast: value doesn't fit in 136 bits"); } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); require(downcasted == value, "SafeCast: value doesn't fit in 128 bits"); } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); require(downcasted == value, "SafeCast: value doesn't fit in 120 bits"); } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); require(downcasted == value, "SafeCast: value doesn't fit in 112 bits"); } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); require(downcasted == value, "SafeCast: value doesn't fit in 104 bits"); } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.7._ */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); require(downcasted == value, "SafeCast: value doesn't fit in 96 bits"); } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); require(downcasted == value, "SafeCast: value doesn't fit in 88 bits"); } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); require(downcasted == value, "SafeCast: value doesn't fit in 80 bits"); } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); require(downcasted == value, "SafeCast: value doesn't fit in 72 bits"); } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); require(downcasted == value, "SafeCast: value doesn't fit in 64 bits"); } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); require(downcasted == value, "SafeCast: value doesn't fit in 56 bits"); } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); require(downcasted == value, "SafeCast: value doesn't fit in 48 bits"); } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); require(downcasted == value, "SafeCast: value doesn't fit in 40 bits"); } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); require(downcasted == value, "SafeCast: value doesn't fit in 32 bits"); } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); require(downcasted == value, "SafeCast: value doesn't fit in 24 bits"); } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); require(downcasted == value, "SafeCast: value doesn't fit in 16 bits"); } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); require(downcasted == value, "SafeCast: value doesn't fit in 8 bits"); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. * * _Available since v3.0._ */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require( value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256" ); return int256(value); }}

File 11 of 14 : SafeMath.sol

library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd( uint256 a, uint256 b ) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub( uint256 a, uint256 b ) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul( uint256 a, uint256 b ) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv( uint256 a, uint256 b ) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod( uint256 a, uint256 b ) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } }}

File 12 of 14 : SignedMath.sol

// 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); } }}

File 13 of 14 : Staking.sol

// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)// This file was procedurally generated from scripts/generate/templates/SafeCast.js.pragma solidity ^0.8.0;/** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */library SafeCast { /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toUint248(uint256 value) internal pure returns (uint248) { require( value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits" ); return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toUint240(uint256 value) internal pure returns (uint240) { require( value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits" ); return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toUint232(uint256 value) internal pure returns (uint232) { require( value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits" ); return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.2._ */ function toUint224(uint256 value) internal pure returns (uint224) { require( value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits" ); return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toUint216(uint256 value) internal pure returns (uint216) { require( value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits" ); return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toUint208(uint256 value) internal pure returns (uint208) { require( value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits" ); return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toUint200(uint256 value) internal pure returns (uint200) { require( value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits" ); return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toUint192(uint256 value) internal pure returns (uint192) { require( value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits" ); return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toUint184(uint256 value) internal pure returns (uint184) { require( value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits" ); return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toUint176(uint256 value) internal pure returns (uint176) { require( value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits" ); return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toUint168(uint256 value) internal pure returns (uint168) { require( value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits" ); return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toUint160(uint256 value) internal pure returns (uint160) { require( value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits" ); return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toUint152(uint256 value) internal pure returns (uint152) { require( value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits" ); return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toUint144(uint256 value) internal pure returns (uint144) { require( value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits" ); return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toUint136(uint256 value) internal pure returns (uint136) { require( value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits" ); return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v2.5._ */ function toUint128(uint256 value) internal pure returns (uint128) { require( value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits" ); return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toUint120(uint256 value) internal pure returns (uint120) { require( value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits" ); return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toUint112(uint256 value) internal pure returns (uint112) { require( value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits" ); return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toUint104(uint256 value) internal pure returns (uint104) { require( value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits" ); return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.2._ */ function toUint96(uint256 value) internal pure returns (uint96) { require( value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits" ); return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toUint88(uint256 value) internal pure returns (uint88) { require( value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits" ); return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toUint80(uint256 value) internal pure returns (uint80) { require( value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits" ); return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toUint72(uint256 value) internal pure returns (uint72) { require( value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits" ); return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v2.5._ */ function toUint64(uint256 value) internal pure returns (uint64) { require( value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits" ); return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toUint56(uint256 value) internal pure returns (uint56) { require( value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits" ); return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toUint48(uint256 value) internal pure returns (uint48) { require( value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits" ); return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toUint40(uint256 value) internal pure returns (uint40) { require( value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits" ); return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v2.5._ */ function toUint32(uint256 value) internal pure returns (uint32) { require( value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits" ); return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toUint24(uint256 value) internal pure returns (uint24) { require( value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits" ); return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v2.5._ */ function toUint16(uint256 value) internal pure returns (uint16) { require( value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits" ); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v2.5._ */ function toUint8(uint256 value) internal pure returns (uint8) { require( value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits" ); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. * * _Available since v3.0._ */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); require(downcasted == value, "SafeCast: value doesn't fit in 248 bits"); } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); require(downcasted == value, "SafeCast: value doesn't fit in 240 bits"); } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); require(downcasted == value, "SafeCast: value doesn't fit in 232 bits"); } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.7._ */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); require(downcasted == value, "SafeCast: value doesn't fit in 224 bits"); } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); require(downcasted == value, "SafeCast: value doesn't fit in 216 bits"); } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); require(downcasted == value, "SafeCast: value doesn't fit in 208 bits"); } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); require(downcasted == value, "SafeCast: value doesn't fit in 200 bits"); } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); require(downcasted == value, "SafeCast: value doesn't fit in 192 bits"); } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); require(downcasted == value, "SafeCast: value doesn't fit in 184 bits"); } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); require(downcasted == value, "SafeCast: value doesn't fit in 176 bits"); } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); require(downcasted == value, "SafeCast: value doesn't fit in 168 bits"); } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); require(downcasted == value, "SafeCast: value doesn't fit in 160 bits"); } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); require(downcasted == value, "SafeCast: value doesn't fit in 152 bits"); } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); require(downcasted == value, "SafeCast: value doesn't fit in 144 bits"); } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); require(downcasted == value, "SafeCast: value doesn't fit in 136 bits"); } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); require(downcasted == value, "SafeCast: value doesn't fit in 128 bits"); } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); require(downcasted == value, "SafeCast: value doesn't fit in 120 bits"); } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); require(downcasted == value, "SafeCast: value doesn't fit in 112 bits"); } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); require(downcasted == value, "SafeCast: value doesn't fit in 104 bits"); } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.7._ */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); require(downcasted == value, "SafeCast: value doesn't fit in 96 bits"); } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); require(downcasted == value, "SafeCast: value doesn't fit in 88 bits"); } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); require(downcasted == value, "SafeCast: value doesn't fit in 80 bits"); } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); require(downcasted == value, "SafeCast: value doesn't fit in 72 bits"); } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); require(downcasted == value, "SafeCast: value doesn't fit in 64 bits"); } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); require(downcasted == value, "SafeCast: value doesn't fit in 56 bits"); } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); require(downcasted == value, "SafeCast: value doesn't fit in 48 bits"); } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); require(downcasted == value, "SafeCast: value doesn't fit in 40 bits"); } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); require(downcasted == value, "SafeCast: value doesn't fit in 32 bits"); } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); require(downcasted == value, "SafeCast: value doesn't fit in 24 bits"); } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); require(downcasted == value, "SafeCast: value doesn't fit in 16 bits"); } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); require(downcasted == value, "SafeCast: value doesn't fit in 8 bits"); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. * * _Available since v3.0._ */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require( value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256" ); return int256(value); }}

File 14 of 14 : Treasury.sol

// 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); } }}

Settings

{ "optimizer": { "enabled": true, "runs": 200 }, "evmVersion": "shanghai", "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "metadata": { "useLiteralContent": true }, "libraries": {}}

Contract Security Audit

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"TradeNotOpened","type":"error"},{"inputs":[],"name":"TradeOpened","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"DistributeFeeTokens","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_user","type":"address"},{"indexed":false,"internalType":"bool","name":"_isExcludeFromTax","type":"bool"}],"name":"ExcludeFromTax","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldCap","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newCap","type":"uint256"}],"name":"MaxBuyCapUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldCap","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newCap","type":"uint256"}],"name":"MaxSellCapUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"","type":"bool"}],"name":"OpenTrading","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":[],"name":"RemoveLimits","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"bool","name":"value","type":"bool"}],"name":"SetAutomatedMarketMakerPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokensSwapped","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethReceived","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokensIntoLiquidity","type":"uint256"}],"name":"SwapAndLiquify","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"SwapAndLiquifyEnabledUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"SwapTokensAtAmountUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"buyTax","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sellTax","type":"uint256"}],"name":"TaxUpdated","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":true,"internalType":"address","name":"newAddress","type":"address"},{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"}],"name":"V2RouterUpdated","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"absorbFeeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"automatedMarketMakerPairs","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"buyTax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"bool","name":"_isExcludeFromTax","type":"bool"}],"name":"excludeFromTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"feeDividers","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"feeReceivers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExcludeFromTax","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketingWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxBuyCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSellCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"removeLimits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellTax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"},{"internalType":"bool","name":"_value","type":"bool"}],"name":"setAutomatedMarketMakerPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"buyFee","type":"uint256"},{"internalType":"uint256","name":"sellFee","type":"uint256"}],"name":"setDinoshiDao","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"cap","type":"uint256"}],"name":"setMaxSwapTnx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"cap","type":"uint256"}],"name":"setMaxWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setSwapAndLiquifyEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapAndLiquifyEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapTokensAtAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradeOpened","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","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":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Deployed Bytecode

0x60806040526004361061022b575f3560e01c806375f0a87411610129578063b62496f5116100a8578063d46980161161006d578063d469801614610656578063dd62ed3e14610675578063e2f45605146106b9578063e6dd8856146106ce578063f2fde38b146106e3575f80fd5b8063b62496f5146105c1578063c49b9a80146105ef578063c6a306471461060e578063c9567bf91461062d578063cc1776d314610641575f80fd5b80639708e250116100ee5780639708e250146105305780639a7a23d614610545578063a8aa1b3114610564578063a9059cbb14610583578063af10b3d7146105a2575f80fd5b806375f0a8741461049357806379cc6790146104b25780638da5cb5b146104d157806395d89b41146104ee578063961cc9f814610502575f80fd5b806347b9b949116101b5578063667967f11161017a578063667967f1146103f95780636bd118191461041857806370a0823114610437578063715018a61461046b578063751039fc1461047f575f80fd5b806347b9b949146103695780634a74bb02146103885780634f7041a5146103a65780635b381760146103bb5780635d0044ca146103da575f80fd5b806323b872dd116101fb57806323b872dd146102e457806324c3491814610303578063313ce5671461031857806332cb6b0c1461033357806342966c6814610348575f80fd5b806306fdde0314610236578063095ea7b3146102605780631694505e1461028f57806318160ddd146102c6575f80fd5b3661023257005b5f80fd5b348015610241575f80fd5b5061024a610702565b6040516102579190611904565b60405180910390f35b34801561026b575f80fd5b5061027f61027a366004611964565b610792565b6040519015158152602001610257565b34801561029a575f80fd5b506006546102ae906001600160a01b031681565b6040516001600160a01b039091168152602001610257565b3480156102d1575f80fd5b506002545b604051908152602001610257565b3480156102ef575f80fd5b5061027f6102fe36600461198e565b6107ab565b34801561030e575f80fd5b506102d6600c5481565b348015610323575f80fd5b5060405160128152602001610257565b34801561033e575f80fd5b506102d6600f5481565b348015610353575f80fd5b506103676103623660046119cc565b6107ce565b005b348015610374575f80fd5b506103676103833660046119e3565b6107db565b348015610393575f80fd5b5060145461027f90610100900460ff1681565b3480156103b1575f80fd5b506102d660105481565b3480156103c6575f80fd5b506102ae6103d53660046119cc565b61082a565b3480156103e5575f80fd5b506103676103f43660046119cc565b610852565b348015610404575f80fd5b506102d66104133660046119cc565b610919565b348015610423575f80fd5b5060145461027f9062010000900460ff1681565b348015610442575f80fd5b506102d6610451366004611a03565b6001600160a01b03165f9081526020819052604090205490565b348015610476575f80fd5b50610367610938565b34801561048a575f80fd5b5061036761094b565b34801561049e575f80fd5b50600d546102ae906001600160a01b031681565b3480156104bd575f80fd5b506103676104cc366004611964565b610988565b3480156104dc575f80fd5b506005546001600160a01b03166102ae565b3480156104f9575f80fd5b5061024a6109a1565b34801561050d575f80fd5b5061027f61051c366004611a03565b60086020525f908152604090205460ff1681565b34801561053b575f80fd5b506102d660135481565b348015610550575f80fd5b5061036761055f366004611a32565b6109b0565b34801561056f575f80fd5b506009546102ae906001600160a01b031681565b34801561058e575f80fd5b5061027f61059d366004611964565b610a86565b3480156105ad575f80fd5b506103676105bc3660046119cc565b610a93565b3480156105cc575f80fd5b5061027f6105db366004611a03565b60076020525f908152604090205460ff1681565b3480156105fa575f80fd5b50610367610609366004611a65565b610b56565b348015610619575f80fd5b50610367610628366004611a32565b610bb2565b348015610638575f80fd5b50610367610c11565b34801561064c575f80fd5b506102d660115481565b348015610661575f80fd5b50600e546102ae906001600160a01b031681565b348015610680575f80fd5b506102d661068f366004611a7e565b6001600160a01b039182165f90815260016020908152604080832093909416825291909152205490565b3480156106c4575f80fd5b506102d660155481565b3480156106d9575f80fd5b506102d660125481565b3480156106ee575f80fd5b506103676106fd366004611a03565b610e21565b60606003805461071190611ab5565b80601f016020809104026020016040519081016040528092919081815260200182805461073d90611ab5565b80156107885780601f1061075f57610100808354040283529160200191610788565b820191905f5260205f20905b81548152906001019060200180831161076b57829003601f168201915b5050505050905090565b5f3361079f818585610e5b565b60019150505b92915050565b5f336107b8858285610e6d565b6107c3858585610ee8565b506001949350505050565b6107d83382610f45565b50565b6107e3610f79565b6010829055601181905560408051838152602081018390527fb841faf0d1b32571f4ef966a2f35e3ae51f3cdda45318c3da5570a5b2ad85605910160405180910390a15050565b600a8181548110610839575f80fd5b5f918252602090912001546001600160a01b0316905081565b61085a610f79565b606461086560025490565b61086f9190611b01565b8110156108d85760405162461bcd60e51b815260206004820152602c60248201527f6d61784275792043616e6e6f74206265206c657373207468616e203125206f6660448201526b20746f74616c537570706c7960a01b60648201526084015b60405180910390fd5b60125460408051918252602082018390527f1146bdc56e690d4231f59e950050325db142ae360e77ae43a09710897b557eeb910160405180910390a1601255565b600b8181548110610928575f80fd5b5f91825260209091200154905081565b610940610f79565b6109495f610fa6565b565b610953610f79565b600f5460128190556013556040517f56cd40e702ad44e23718371585a7a88bfb79ab8ea81a03c7f8945fabc3c279cf905f90a1565b610993823383610e6d565b61099d8282610f45565b5050565b60606004805461071190611ab5565b6109b8610f79565b6001600160a01b0382165f9081526007602052604090205481151560ff909116151503610a275760405162461bcd60e51b815260206004820152601760248201527f506169724973416c7265616479476976656e56616c756500000000000000000060448201526064016108cf565b6001600160a01b0382165f81815260076020908152604091829020805460ff191685151590811790915591519182527fffa9187bf1f18bf477bd0ea1bcbb64e93b6a98132473929edfce215cd9b16fab91015b60405180910390a25050565b5f3361079f818585610ee8565b610a9b610f79565b6064610aa660025490565b610ab09190611b01565b811015610b155760405162461bcd60e51b815260206004820152602d60248201527f6d617853656c6c2043616e6e6f74206265206c657373207468616e203125206f60448201526c6620746f74616c537570706c7960981b60648201526084016108cf565b60135460408051918252602082018390527f12bf45c61b66f0927229652515d6cfd15abd8d60f90ddd1f2a0abc1aed87e229910160405180910390a1601355565b610b5e610f79565b601480548215156101000261ff00199091161790556040517f53726dfcaf90650aa7eb35524f4d3220f07413c8d6cb404cc8c18bf5591bc15990610ba790831515815260200190565b60405180910390a150565b610bba610f79565b6001600160a01b0382165f81815260086020908152604091829020805460ff191685151590811790915591519182527f7e9c88b87a525bea9b5a9169ddf4660ad19e19b88ea5057a584ee4d31cceec9c9101610a7a565b610c19610f79565b60145462010000900460ff161515600103610c475760405163176dfd6d60e21b815260040160405180910390fd5b6006546040805163c45a015560e01b815290515f926001600160a01b03169163c45a01559160048083019260209291908290030181865afa158015610c8e573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610cb29190611b20565b6001600160a01b031663e6a439053060065f9054906101000a90046001600160a01b03166001600160a01b031663ad5c46486040518163ffffffff1660e01b8152600401602060405180830381865afa158015610d11573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610d359190611b20565b6040516001600160e01b031960e085901b1681526001600160a01b03928316600482015291166024820152604401602060405180830381865afa158015610d7e573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610da29190611b20565b600980546001600160a01b0383166001600160a01b031990911681179091555f90815260076020908152604091829020805460ff191660019081179091556014805462ff000019166201000017905591519182529192507f1f600db0df6d805ecdba9e86fb22102b65e03ebd7311928418efa609804ddcf79101610ba7565b610e29610f79565b6001600160a01b038116610e5257604051631e4fbdf760e01b81525f60048201526024016108cf565b6107d881610fa6565b610e688383836001610ff7565b505050565b6001600160a01b038381165f908152600160209081526040808320938616835292905220545f198114610ee25781811015610ed457604051637dc7a0d960e11b81526001600160a01b038416600482015260248101829052604481018390526064016108cf565b610ee284848484035f610ff7565b50505050565b6001600160a01b038316610f1157604051634b637e8f60e11b81525f60048201526024016108cf565b6001600160a01b038216610f3a5760405163ec442f0560e01b81525f60048201526024016108cf565b610e688383836110c9565b6001600160a01b038216610f6e57604051634b637e8f60e11b81525f60048201526024016108cf565b61099d825f836110c9565b6005546001600160a01b031633146109495760405163118cdaa760e01b81523360048201526024016108cf565b600580546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b6001600160a01b0384166110205760405163e602df0560e01b81525f60048201526024016108cf565b6001600160a01b03831661104957604051634a1406b160e11b81525f60048201526024016108cf565b6001600160a01b038085165f9081526001602090815260408083209387168352929052208290558015610ee257826001600160a01b0316846001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925846040516110bb91815260200190565b60405180910390a350505050565b60145462010000900460ff1615801561110957506005546001600160a01b0384811691161480159061110957506005546001600160a01b03838116911614155b156111275760405163025052a560e61b815260040160405180910390fd5b60145460ff1615801561114857506006546001600160a01b03848116911614155b801561116c57506001600160a01b0382165f9081526008602052604090205460ff16155b1561117e5761117e8383836001611364565b305f908152602081905260409020546015546014549082101590610100900460ff1680156111a95750805b80156111b8575060145460ff16155b80156111dc57506001600160a01b0385165f9081526007602052604090205460ff16155b80156111f657506005546001600160a01b03868116911614155b801561121057506005546001600160a01b03858116911614155b15611278576014805460ff19166001179055600c545f906064906112349082611b3b565b61123e9085611b4e565b6112489190611b01565b90506112538161146d565b305f9081526020819052604090205461126b816114f1565b50506014805460ff191690555b6014546001600160a01b0386165f9081526008602052604090205460ff918216159116806112bd57506001600160a01b0385165f9081526008602052604090205460ff165b156112c557505f5b8015611351576001600160a01b0386165f9081526007602052604081205460ff161561130c576064601054866112fb9190611b4e565b6113059190611b01565b9050611338565b61131687876115a0565b156113385760646011548661132b9190611b4e565b6113359190611b01565b90505b6113428186611b3b565b945061134f8730836115de565b505b61135c8686866115de565b505050505050565b60145462010000900460ff1615610ee2578015610ee2576001600160a01b0384165f9081526007602052604090205460ff1680156113a3575060125415155b156113ff576012548211156113fa5760405162461bcd60e51b815260206004820152601860248201527f42757920616d6f756e742065786365656473206c696d6974000000000000000060448201526064016108cf565b610ee2565b61140984846115a0565b8015611416575060135415155b15610ee257601354821115610ee25760405162461bcd60e51b815260206004820152601960248201527f53656c6c20616d6f756e742065786365656473206c696d69740000000000000060448201526064016108cf565b5f611479600283611b01565b90505f6114868284611b3b565b90504761149283611704565b5f61149d8247611b3b565b90506114a98382611854565b60408051858152602081018390529081018490527f17bbfb9a6069321b6ded73bd96327c9e6b7212a5cd51ff219cd61370acafb5619060600160405180910390a15050505050565b5f5b600b5481101561156f5761156730600a838154811061151457611514611b65565b905f5260205f20015f9054906101000a90046001600160a01b03166064600b858154811061154457611544611b65565b905f5260205f200154866115589190611b4e565b6115629190611b01565b610ee8565b6001016114f3565b506040518181527f88437947f9cbc04f50ea6ffceb9de5d9d59570e76d480ae51710bd9fb9f32ae190602001610ba7565b6006545f906001600160a01b038481169116148015906115d757506001600160a01b0382165f9081526007602052604090205460ff165b9392505050565b6001600160a01b038316611608578060025f8282546115fd9190611b79565b909155506116789050565b6001600160a01b0383165f908152602081905260409020548181101561165a5760405163391434e360e21b81526001600160a01b038516600482015260248101829052604481018390526064016108cf565b6001600160a01b0384165f9081526020819052604090209082900390555b6001600160a01b038216611694576002805482900390556116b2565b6001600160a01b0382165f9081526020819052604090208054820190555b816001600160a01b0316836001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040516116f791815260200190565b60405180910390a3505050565b6040805160028082526060820183525f9260208301908036833701905050905030815f8151811061173757611737611b65565b6001600160a01b03928316602091820292909201810191909152600654604080516315ab88c960e31b81529051919093169263ad5c46489260048083019391928290030181865afa15801561178e573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906117b29190611b20565b816001815181106117c5576117c5611b65565b6001600160a01b0392831660209182029290920101526006546117eb9130911684610e5b565b60065460405163791ac94760e01b81526001600160a01b039091169063791ac947906118239085905f90869030904290600401611b8c565b5f604051808303815f87803b15801561183a575f80fd5b505af192505050801561184b575060015b1561099d575050565b60065461186c9030906001600160a01b031684610e5b565b600654600e5460405163f305d71960e01b8152306004820152602481018590525f6044820181905260648201526001600160a01b0391821660848201524260a482015291169063f305d71990839060c40160606040518083038185885af1935050505080156118f8575060408051601f3d908101601f191682019092526118f591810190611bfd565b60015b1561099d575050505050565b5f602080835283518060208501525f5b8181101561193057858101830151858201604001528201611914565b505f604082860101526040601f19601f8301168501019250505092915050565b6001600160a01b03811681146107d8575f80fd5b5f8060408385031215611975575f80fd5b823561198081611950565b946020939093013593505050565b5f805f606084860312156119a0575f80fd5b83356119ab81611950565b925060208401356119bb81611950565b929592945050506040919091013590565b5f602082840312156119dc575f80fd5b5035919050565b5f80604083850312156119f4575f80fd5b50508035926020909101359150565b5f60208284031215611a13575f80fd5b81356115d781611950565b80358015158114611a2d575f80fd5b919050565b5f8060408385031215611a43575f80fd5b8235611a4e81611950565b9150611a5c60208401611a1e565b90509250929050565b5f60208284031215611a75575f80fd5b6115d782611a1e565b5f8060408385031215611a8f575f80fd5b8235611a9a81611950565b91506020830135611aaa81611950565b809150509250929050565b600181811c90821680611ac957607f821691505b602082108103611ae757634e487b7160e01b5f52602260045260245ffd5b50919050565b634e487b7160e01b5f52601160045260245ffd5b5f82611b1b57634e487b7160e01b5f52601260045260245ffd5b500490565b5f60208284031215611b30575f80fd5b81516115d781611950565b818103818111156107a5576107a5611aed565b80820281158282048414176107a5576107a5611aed565b634e487b7160e01b5f52603260045260245ffd5b808201808211156107a5576107a5611aed565b5f60a08201878352602087602085015260a0604085015281875180845260c0860191506020890193505f5b81811015611bdc5784516001600160a01b031683529383019391830191600101611bb7565b50506001600160a01b03969096166060850152505050608001529392505050565b5f805f60608486031215611c0f575f80fd5b835192506020840151915060408401519050925092509256fea26469706673582212200349f806316b9b3a0922b2f4ac788e43f2cbd7cd2c0d3a294cdb305c77e0f29464736f6c63430008180033

View All Withdrawals

View All Deposits

Display all chains•

Last updated: less than 1 sec ago