Contract Overview
My Name Tag:
Not Available, login to update
[ Download CSV Export ]
Latest 25 internal transaction
[ Download CSV Export ]
Contract Name:
Zapper
Compiler Version
v0.8.9+commit.e5eed63a
Contract Source Code (Solidity)
/** *Submitted for verification at snowtrace.io on 2022-08-04 */ // File: gladiator-finance-contracts/contracts/helpers/traderjoe/interfaces/IJoeRouter01.sol pragma solidity >=0.6.2; interface IJoeRouter01 { function factory() external pure returns (address); function WAVAX() 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 addLiquidityAVAX( address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountAVAXMin, address to, uint256 deadline ) external payable returns ( uint256 amountToken, uint256 amountAVAX, uint256 liquidity ); function removeLiquidity( address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline ) external returns (uint256 amountA, uint256 amountB); function removeLiquidityAVAX( address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountAVAXMin, address to, uint256 deadline ) external returns (uint256 amountToken, uint256 amountAVAX); function removeLiquidityWithPermit( address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint256 amountA, uint256 amountB); function removeLiquidityAVAXWithPermit( address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountAVAXMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint256 amountToken, uint256 amountAVAX); function swapExactTokensForTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function swapTokensForExactTokens( uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function swapExactAVAXForTokens( uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external payable returns (uint256[] memory amounts); function swapTokensForExactAVAX( uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function swapExactTokensForAVAX( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function swapAVAXForExactTokens( uint256 amountOut, address[] calldata path, address to, uint256 deadline ) external payable returns (uint256[] memory amounts); function quote( uint256 amountA, uint256 reserveA, uint256 reserveB ) external pure returns (uint256 amountB); function getAmountOut( uint256 amountIn, uint256 reserveIn, uint256 reserveOut ) external pure returns (uint256 amountOut); function getAmountIn( uint256 amountOut, uint256 reserveIn, uint256 reserveOut ) external pure returns (uint256 amountIn); function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts); function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts); } // File: gladiator-finance-contracts/contracts/helpers/traderjoe/interfaces/IJoeRouter02.sol pragma solidity >=0.6.2; interface IJoeRouter02 is IJoeRouter01 { function removeLiquidityAVAXSupportingFeeOnTransferTokens( address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountAVAXMin, address to, uint256 deadline ) external returns (uint256 amountAVAX); function removeLiquidityAVAXWithPermitSupportingFeeOnTransferTokens( address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountAVAXMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint256 amountAVAX); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external; function swapExactAVAXForTokensSupportingFeeOnTransferTokens( uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external payable; function swapExactTokensForAVAXSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external; } // File: gladiator-finance-contracts/contracts/helpers/traderjoe/interfaces/IJoePair.sol pragma solidity >=0.5.0; interface IJoePair { 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: gladiator-finance-contracts/contracts/interfaces/WAVAX.sol pragma solidity ^0.8.0; interface WAVAX { function withdraw(uint256 wad) external; function deposit() external payable; } // File: @openzeppelin/contracts/utils/Context.sol // 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: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @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 anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing 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: @openzeppelin/contracts/utils/Address.sol // OpenZeppelin Contracts (last updated v4.7.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 * ==== * * [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://diligence.consensys.net/posts/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.5.11/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 functionCall(target, data, "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"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(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) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(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) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason 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 { // 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: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } // File: @openzeppelin/contracts/token/ERC20/IERC20.sol // OpenZeppelin Contracts (last updated v4.6.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: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function safePermit( IERC20Permit token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } // File: gladiator-finance-contracts/contracts/Zapper.sol pragma solidity 0.8.9; contract Zapper is Ownable { using SafeERC20 for IERC20; IJoeRouter02 public router; constructor(address _router) { if (_router != address(0)) router = IJoeRouter02(_router); } // Zap AVAX to lpToken function zap(address lpToken) public payable returns (uint256 liquidity) { require(msg.value > 0, "msg.value = 0"); address wavax = router.WAVAX(); WAVAX(wavax).deposit{value: msg.value}(); IJoePair pair = IJoePair(address(lpToken)); address token0 = pair.token0(); address token1 = pair.token1(); uint256 sellAmount = msg.value / 2; uint256 amount0 = _swapTokenForToken(wavax, token0, sellAmount); uint256 amount1 = _swapTokenForToken(wavax, token1, sellAmount); IERC20(token0).safeApprove(address(router), 0); IERC20(token0).safeApprove(address(router), amount0); IERC20(token1).safeApprove(address(router), 0); IERC20(token1).safeApprove(address(router), amount1); (, , liquidity) = router.addLiquidity( token0, token1, amount0, amount1, 0, 0, msg.sender, block.timestamp ); } function _swapTokenForToken( address tokenIn, address tokenOut, uint256 amountIn ) private returns (uint256) { if (tokenIn == tokenOut) { return amountIn; } address[] memory path = new address[](2); path[0] = tokenIn; path[1] = tokenOut; IERC20(tokenIn).safeApprove(address(router), 0); IERC20(tokenIn).safeApprove(address(router), amountIn); uint256[] memory amountsOut = router.swapExactTokensForTokens( amountIn, 0, path, address(this), block.timestamp ); return amountsOut[1]; } function ownerRecoverTokens( IERC20 _token, uint256 amount, address to ) external onlyOwner { _token.safeTransfer(to, amount); } function ownerRecoverAVAX(uint256 amount, address to) external onlyOwner { payable(to).transfer(amount); } }
[{"inputs":[{"internalType":"address","name":"_router","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"ownerRecoverAVAX","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"ownerRecoverTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IJoeRouter02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"lpToken","type":"address"}],"name":"zap","outputs":[{"internalType":"uint256","name":"liquidity","type":"uint256"}],"stateMutability":"payable","type":"function"}]
Contract Creation Code
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000060ae616a2155ee3d9a68541ba4544862310933d4
-----Decoded View---------------
Arg [0] : _router (address): 0x60ae616a2155ee3d9a68541ba4544862310933d4
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000060ae616a2155ee3d9a68541ba4544862310933d4
Deployed ByteCode Sourcemap
31001:2288:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31246:1031;;;;;;:::i;:::-;;:::i;:::-;;;548:25:1;;;536:2;521:18;31246:1031:0;;;;;;;;32984:174;;;;;;;;;;-1:-1:-1;32984:174:0;;;;;:::i;:::-;;:::i;:::-;;11782:103;;;;;;;;;;;;;:::i;11134:87::-;;;;;;;;;;-1:-1:-1;11180:7:0;11207:6;-1:-1:-1;;;;;11207:6:0;11134:87;;;-1:-1:-1;;;;;1224:32:1;;;1206:51;;1194:2;1179:18;11134:87:0;1060:203:1;33166:120:0;;;;;;;;;;-1:-1:-1;33166:120:0;;;;;:::i;:::-;;:::i;12040:201::-;;;;;;;;;;-1:-1:-1;12040:201:0;;;;;:::i;:::-;;:::i;31070:26::-;;;;;;;;;;-1:-1:-1;31070:26:0;;;;-1:-1:-1;;;;;31070:26:0;;;31246:1031;31300:17;31350:1;31338:9;:13;31330:39;;;;-1:-1:-1;;;31330:39:0;;2018:2:1;31330:39:0;;;2000:21:1;2057:2;2037:18;;;2030:30;-1:-1:-1;;;2076:18:1;;;2069:43;2129:18;;31330:39:0;;;;;;;;;31398:6;;:14;;;-1:-1:-1;;;31398:14:0;;;;31382:13;;-1:-1:-1;;;;;31398:6:0;;:12;;:14;;;;;;;;;;;;;;:6;:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;31382:30;;31429:5;-1:-1:-1;;;;;31423:20:0;;31451:9;31423:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31476:13;31509:7;31476:42;;31529:14;31546:4;-1:-1:-1;;;;;31546:11:0;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;31529:30;;31570:14;31587:4;-1:-1:-1;;;;;31587:11:0;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;31570:30;-1:-1:-1;31611:18:0;31632:13;31644:1;31632:9;:13;:::i;:::-;31611:34;;31656:15;31674:45;31693:5;31700:6;31708:10;31674:18;:45::i;:::-;31656:63;;31730:15;31748:45;31767:5;31774:6;31782:10;31748:18;:45::i;:::-;31841:6;;31730:63;;-1:-1:-1;31806:46:0;;-1:-1:-1;;;;;31806:26:0;;;;31841:6;;31806:26;:46::i;:::-;31898:6;;31863:52;;-1:-1:-1;;;;;31863:26:0;;;;31898:6;31907:7;31863:26;:52::i;:::-;31961:6;;31926:46;;-1:-1:-1;;;;;31926:26:0;;;;31961:6;;31926:26;:46::i;:::-;32018:6;;31983:52;;-1:-1:-1;;;;;31983:26:0;;;;32018:6;32027:7;31983:26;:52::i;:::-;32066:6;;:203;;-1:-1:-1;;;32066:203:0;;-1:-1:-1;;;;;3051:15:1;;;32066:203:0;;;3033:34:1;3103:15;;;3083:18;;;3076:43;3135:18;;;3128:34;;;3178:18;;;3171:34;;;32066:6:0;3221:19:1;;;3214:35;;;3265:19;;;3258:35;32218:10:0;3309:19:1;;;3302:44;32243:15:0;3362:19:1;;;3355:35;32066:6:0;;;;:19;;2967::1;;32066:203:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;32048:221;31246:1031;-1:-1:-1;;;;;;;;;;;31246:1031:0:o;32984:174::-;11020:13;:11;:13::i;:::-;33119:31:::1;-1:-1:-1::0;;;;;33119:19:0;::::1;33139:2:::0;33143:6;33119:19:::1;:31::i;:::-;32984:174:::0;;;:::o;11782:103::-;11020:13;:11;:13::i;:::-;11847:30:::1;11874:1;11847:18;:30::i;:::-;11782:103::o:0;33166:120::-;11020:13;:11;:13::i;:::-;33250:28:::1;::::0;-1:-1:-1;;;;;33250:20:0;::::1;::::0;:28;::::1;;;::::0;33271:6;;33250:28:::1;::::0;;;33271:6;33250:20;:28;::::1;;;;;;;;;;;;;::::0;::::1;;;;12040:201:::0;11020:13;:11;:13::i;:::-;-1:-1:-1;;;;;12129:22:0;::::1;12121:73;;;::::0;-1:-1:-1;;;12121:73:0;;3914:2:1;12121:73:0::1;::::0;::::1;3896:21:1::0;3953:2;3933:18;;;3926:30;3992:34;3972:18;;;3965:62;-1:-1:-1;;;4043:18:1;;;4036:36;4089:19;;12121:73:0::1;3712:402:1::0;12121:73:0::1;12205:28;12224:8;12205:18;:28::i;:::-;12040:201:::0;:::o;32285:691::-;32417:7;32452:8;-1:-1:-1;;;;;32441:19:0;:7;-1:-1:-1;;;;;32441:19:0;;32437:67;;;-1:-1:-1;32484:8:0;32477:15;;32437:67;32538:16;;;32552:1;32538:16;;;;;;;;32514:21;;32538:16;;;;;;;;;;-1:-1:-1;32538:16:0;32514:40;;32575:7;32565:4;32570:1;32565:7;;;;;;;;:::i;:::-;;;;;;:17;-1:-1:-1;;;;;32565:17:0;;;-1:-1:-1;;;;;32565:17:0;;;;;32603:8;32593:4;32598:1;32593:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;32593:18:0;;;:7;;;;;;;;;:18;32660:6;;32624:47;;:27;;;;32660:6;;32624:27;:47::i;:::-;32718:6;;32682:54;;-1:-1:-1;;;;;32682:27:0;;;;32718:6;32727:8;32682:27;:54::i;:::-;32779:6;;:158;;-1:-1:-1;;;32779:158:0;;32749:27;;-1:-1:-1;;;;;32779:6:0;;:31;;:158;;32825:8;;32749:27;;32864:4;;32891;;32911:15;;32779:158;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;32779:158:0;;;;;;;;;;;;:::i;:::-;32749:188;;32955:10;32966:1;32955:13;;;;;;;;:::i;:::-;;;;;;;32948:20;;;;32285:691;;;;;;:::o;27846:616::-;28210:10;;;28209:62;;-1:-1:-1;28226:39:0;;-1:-1:-1;;;28226:39:0;;28250:4;28226:39;;;6690:34:1;-1:-1:-1;;;;;6760:15:1;;;6740:18;;;6733:43;28226:15:0;;;;;6625:18:1;;28226:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;28209:62;28187:166;;;;-1:-1:-1;;;28187:166:0;;7178:2:1;28187:166:0;;;7160:21:1;7217:2;7197:18;;;7190:30;7256:34;7236:18;;;7229:62;-1:-1:-1;;;7307:18:1;;;7300:52;7369:19;;28187:166:0;6976:418:1;28187:166:0;28391:62;;-1:-1:-1;;;;;7591:32:1;;28391:62:0;;;7573:51:1;7640:18;;;7633:34;;;28364:90:0;;28384:5;;-1:-1:-1;;;28414:22:0;7546:18:1;;28391:62:0;;;;-1:-1:-1;;28391:62:0;;;;;;;;;;;;;;-1:-1:-1;;;;;28391:62:0;-1:-1:-1;;;;;;28391:62:0;;;;;;;;;;28364:19;:90::i;11299:132::-;11180:7;11207:6;-1:-1:-1;;;;;11207:6:0;9765:10;11363:23;11355:68;;;;-1:-1:-1;;;11355:68:0;;7880:2:1;11355:68:0;;;7862:21:1;;;7899:18;;;7892:30;7958:34;7938:18;;;7931:62;8010:18;;11355:68:0;7678:356:1;27110:211:0;27254:58;;-1:-1:-1;;;;;7591:32:1;;27254:58:0;;;7573:51:1;7640:18;;;7633:34;;;27227:86:0;;27247:5;;-1:-1:-1;;;27277:23:0;7546:18:1;;27254:58:0;7399:274:1;12401:191:0;12475:16;12494:6;;-1:-1:-1;;;;;12511:17:0;;;-1:-1:-1;;;;;;12511:17:0;;;;;;12544:40;;12494:6;;;;;;;12544:40;;12475:16;12544:40;12464:128;12401:191;:::o;30177:716::-;30601:23;30627:69;30655:4;30627:69;;;;;;;;;;;;;;;;;30635:5;-1:-1:-1;;;;;30627:27:0;;;:69;;;;;:::i;:::-;30711:17;;30601:95;;-1:-1:-1;30711:21:0;30707:179;;30808:10;30797:30;;;;;;;;;;;;:::i;:::-;30789:85;;;;-1:-1:-1;;;30789:85:0;;8523:2:1;30789:85:0;;;8505:21:1;8562:2;8542:18;;;8535:30;8601:34;8581:18;;;8574:62;-1:-1:-1;;;8652:18:1;;;8645:40;8702:19;;30789:85:0;8321:406:1;16577:229:0;16714:12;16746:52;16768:6;16776:4;16782:1;16785:12;16746:21;:52::i;:::-;16739:59;16577:229;-1:-1:-1;;;;16577:229:0:o;17697:510::-;17867:12;17925:5;17900:21;:30;;17892:81;;;;-1:-1:-1;;;17892:81:0;;8934:2:1;17892:81:0;;;8916:21:1;8973:2;8953:18;;;8946:30;9012:34;8992:18;;;8985:62;-1:-1:-1;;;9063:18:1;;;9056:36;9109:19;;17892:81:0;8732:402:1;17892:81:0;-1:-1:-1;;;;;14127:19:0;;;17984:60;;;;-1:-1:-1;;;17984:60:0;;9341:2:1;17984:60:0;;;9323:21:1;9380:2;9360:18;;;9353:30;9419:31;9399:18;;;9392:59;9468:18;;17984:60:0;9139:353:1;17984:60:0;18058:12;18072:23;18099:6;-1:-1:-1;;;;;18099:11:0;18118:5;18125:4;18099:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18057:73;;;;18148:51;18165:7;18174:10;18186:12;18148:16;:51::i;:::-;18141:58;17697:510;-1:-1:-1;;;;;;;17697:510:0:o;20383:762::-;20533:12;20562:7;20558:580;;;-1:-1:-1;20593:10:0;20586:17;;20558:580;20707:17;;:21;20703:424;;20955:10;20949:17;21016:15;21003:10;20999:2;20995:19;20988:44;20703:424;21098:12;21091:20;;-1:-1:-1;;;21091:20:0;;;;;;;;:::i;14:131:1:-;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;150:247;209:6;262:2;250:9;241:7;237:23;233:32;230:52;;;278:1;275;268:12;230:52;317:9;304:23;336:31;361:5;336:31;:::i;584:471::-;676:6;684;692;745:2;733:9;724:7;720:23;716:32;713:52;;;761:1;758;751:12;713:52;800:9;787:23;819:31;844:5;819:31;:::i;:::-;869:5;-1:-1:-1;921:2:1;906:18;;893:32;;-1:-1:-1;977:2:1;962:18;;949:32;990:33;949:32;990:33;:::i;:::-;1042:7;1032:17;;;584:471;;;;;:::o;1268:315::-;1336:6;1344;1397:2;1385:9;1376:7;1372:23;1368:32;1365:52;;;1413:1;1410;1403:12;1365:52;1449:9;1436:23;1426:33;;1509:2;1498:9;1494:18;1481:32;1522:31;1547:5;1522:31;:::i;:::-;1572:5;1562:15;;;1268:315;;;;;:::o;2158:251::-;2228:6;2281:2;2269:9;2260:7;2256:23;2252:32;2249:52;;;2297:1;2294;2287:12;2249:52;2329:9;2323:16;2348:31;2373:5;2348:31;:::i;2414:217::-;2454:1;2480;2470:132;;2524:10;2519:3;2515:20;2512:1;2505:31;2559:4;2556:1;2549:15;2587:4;2584:1;2577:15;2470:132;-1:-1:-1;2616:9:1;;2414:217::o;3401:306::-;3489:6;3497;3505;3558:2;3546:9;3537:7;3533:23;3529:32;3526:52;;;3574:1;3571;3564:12;3526:52;3603:9;3597:16;3587:26;;3653:2;3642:9;3638:18;3632:25;3622:35;;3697:2;3686:9;3682:18;3676:25;3666:35;;3401:306;;;;;:::o;4119:127::-;4180:10;4175:3;4171:20;4168:1;4161:31;4211:4;4208:1;4201:15;4235:4;4232:1;4225:15;4251:127;4312:10;4307:3;4303:20;4300:1;4293:31;4343:4;4340:1;4333:15;4367:4;4364:1;4357:15;4383:980;4645:4;4693:3;4682:9;4678:19;4724:6;4713:9;4706:25;4750:2;4788:6;4783:2;4772:9;4768:18;4761:34;4831:3;4826:2;4815:9;4811:18;4804:31;4855:6;4890;4884:13;4921:6;4913;4906:22;4959:3;4948:9;4944:19;4937:26;;4998:2;4990:6;4986:15;4972:29;;5019:1;5029:195;5043:6;5040:1;5037:13;5029:195;;;5108:13;;-1:-1:-1;;;;;5104:39:1;5092:52;;5199:15;;;;5164:12;;;;5140:1;5058:9;5029:195;;;-1:-1:-1;;;;;;;5280:32:1;;;;5275:2;5260:18;;5253:60;-1:-1:-1;;;5344:3:1;5329:19;5322:35;5241:3;4383:980;-1:-1:-1;;;4383:980:1:o;5368:1105::-;5463:6;5494:2;5537;5525:9;5516:7;5512:23;5508:32;5505:52;;;5553:1;5550;5543:12;5505:52;5586:9;5580:16;5615:18;5656:2;5648:6;5645:14;5642:34;;;5672:1;5669;5662:12;5642:34;5710:6;5699:9;5695:22;5685:32;;5755:7;5748:4;5744:2;5740:13;5736:27;5726:55;;5777:1;5774;5767:12;5726:55;5806:2;5800:9;5828:2;5824;5821:10;5818:36;;;5834:18;;:::i;:::-;5880:2;5877:1;5873:10;5912:2;5906:9;5975:2;5971:7;5966:2;5962;5958:11;5954:25;5946:6;5942:38;6030:6;6018:10;6015:22;6010:2;5998:10;5995:18;5992:46;5989:72;;;6041:18;;:::i;:::-;6077:2;6070:22;6127:18;;;6161:15;;;;-1:-1:-1;6203:11:1;;;6199:20;;;6231:19;;;6228:39;;;6263:1;6260;6253:12;6228:39;6287:11;;;;6307:135;6323:6;6318:3;6315:15;6307:135;;;6389:10;;6377:23;;6340:12;;;;6420;;;;6307:135;;;6461:6;5368:1105;-1:-1:-1;;;;;;;;5368:1105:1:o;6787:184::-;6857:6;6910:2;6898:9;6889:7;6885:23;6881:32;6878:52;;;6926:1;6923;6916:12;6878:52;-1:-1:-1;6949:16:1;;6787:184;-1:-1:-1;6787:184:1:o;8039:277::-;8106:6;8159:2;8147:9;8138:7;8134:23;8130:32;8127:52;;;8175:1;8172;8165:12;8127:52;8207:9;8201:16;8260:5;8253:13;8246:21;8239:5;8236:32;8226:60;;8282:1;8279;8272:12;9497:258;9569:1;9579:113;9593:6;9590:1;9587:13;9579:113;;;9669:11;;;9663:18;9650:11;;;9643:39;9615:2;9608:10;9579:113;;;9710:6;9707:1;9704:13;9701:48;;;9745:1;9736:6;9731:3;9727:16;9720:27;9701:48;;9497:258;;;:::o;9760:274::-;9889:3;9927:6;9921:13;9943:53;9989:6;9984:3;9977:4;9969:6;9965:17;9943:53;:::i;:::-;10012:16;;;;;9760:274;-1:-1:-1;;9760:274:1:o;10039:383::-;10188:2;10177:9;10170:21;10151:4;10220:6;10214:13;10263:6;10258:2;10247:9;10243:18;10236:34;10279:66;10338:6;10333:2;10322:9;10318:18;10313:2;10305:6;10301:15;10279:66;:::i;:::-;10406:2;10385:15;-1:-1:-1;;10381:29:1;10366:45;;;;10413:2;10362:54;;10039:383;-1:-1:-1;;10039:383:1:o
Swarm Source
ipfs://765ea9426cf41794cdef91d0240b9bb6db8e47d6ae9b3304c1266fc668cd917b
Age | Block | Fee Address | BC Fee Address | Voting Power | Jailed | Incoming |
---|
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.