Feature Tip: Add private address tag to any address under My Name Tag !
More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x60806040 | 11240965 | 1400 days ago | IN | 0 ETH | 0.03249552 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
FlashArbitrageCOREBuyer
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2020-11-12 */ // _________ ________ _____________________ // \_ ___ \ \_____ \\______ \_ _____/ // / \ \/ / | \| _/| __)_ // \ \____/ | \ | \| \ // \______ /\_______ /____|_ /_______ / // \/ \/ \/ \/ // ___________.____ _____ _________ ___ ___ // \_ _____/| | / _ \ / _____// | \ // | __) | | / /_\ \ \_____ \/ ~ \ // | \ | |___/ | \/ \ Y / // \___ / |_______ \____|__ /_______ /\___|_ / // \/ \/ \/ \/ \/ // _____ ____________________.________________________ _____ ___________________ // / _ \\______ \______ \ \__ ___/\______ \ / _ \ / _____/\_ _____/ // / /_\ \| _/| | _/ | | | | _/ / /_\ \/ \ ___ | __)_ // / | \ | \| | \ | | | | | \/ | \ \_\ \| \ // \____|__ /____|_ /|______ /___| |____| |____|_ /\____|__ /\______ /_______ / // \/ \/ \/ \/ \/ \/ \/ // CORE BUYER // // This contract buys CORE for tokens inside it (which it gets from the controller upon successfull arbitrage) // And then sends it to the farming vault boosting everyones APY // // Sources flattened with hardhat v2.0.1 https://hardhat.org // File @uniswap/v2-core/contracts/interfaces/[email protected] pragma solidity >=0.5.0; interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } // File @uniswap/lib/contracts/libraries/[email protected] // SPDX-License-Identifier: GPL-3.0-or-later pragma solidity >=0.5.0; library AddressStringUtil { // converts an address to the uppercase hex string, extracting only len bytes (up to 20, multiple of 2) function toAsciiString(address addr, uint len) pure internal returns (string memory) { require(len % 2 == 0 && len > 0 && len <= 40, "AddressStringUtil: INVALID_LEN"); bytes memory s = new bytes(len); uint addrNum = uint(addr); for (uint i = 0; i < len / 2; i++) { // shift right and truncate all but the least significant byte to extract the byte at position 19-i uint8 b = uint8(addrNum >> (8 * (19 - i))); // first hex character is the most significant 4 bits uint8 hi = b >> 4; // second hex character is the least significant 4 bits uint8 lo = b - (hi << 4); s[2 * i] = char(hi); s[2 * i + 1] = char(lo); } return string(s); } // hi and lo are only 4 bits and between 0 and 16 // this method converts those values to the unicode/ascii code point for the hex representation // uses upper case for the characters function char(uint8 b) pure private returns (byte c) { if (b < 10) { return byte(b + 0x30); } else { return byte(b + 0x37); } } } // File @uniswap/lib/contracts/libraries/[email protected] pragma solidity >=0.5.0; // produces token descriptors from inconsistent or absent ERC20 symbol implementations that can return string or bytes32 // this library will always produce a string symbol to represent the token library SafeERC20Namer { function bytes32ToString(bytes32 x) pure private returns (string memory) { bytes memory bytesString = new bytes(32); uint charCount = 0; for (uint j = 0; j < 32; j++) { byte char = x[j]; if (char != 0) { bytesString[charCount] = char; charCount++; } } bytes memory bytesStringTrimmed = new bytes(charCount); for (uint j = 0; j < charCount; j++) { bytesStringTrimmed[j] = bytesString[j]; } return string(bytesStringTrimmed); } // assumes the data is in position 2 function parseStringData(bytes memory b) pure private returns (string memory) { uint charCount = 0; // first parse the charCount out of the data for (uint i = 32; i < 64; i++) { charCount <<= 8; charCount += uint8(b[i]); } bytes memory bytesStringTrimmed = new bytes(charCount); for (uint i = 0; i < charCount; i++) { bytesStringTrimmed[i] = b[i + 64]; } return string(bytesStringTrimmed); } // uses a heuristic to produce a token name from the address // the heuristic returns the full hex of the address string in upper case function addressToName(address token) pure private returns (string memory) { return AddressStringUtil.toAsciiString(token, 40); } // uses a heuristic to produce a token symbol from the address // the heuristic returns the first 6 hex of the address string in upper case function addressToSymbol(address token) pure private returns (string memory) { return AddressStringUtil.toAsciiString(token, 6); } // calls an external view token contract method that returns a symbol or name, and parses the output into a string function callAndParseStringReturn(address token, bytes4 selector) view private returns (string memory) { (bool success, bytes memory data) = token.staticcall(abi.encodeWithSelector(selector)); // if not implemented, or returns empty data, return empty string if (!success || data.length == 0) { return ""; } // bytes32 data always has length 32 if (data.length == 32) { bytes32 decoded = abi.decode(data, (bytes32)); return bytes32ToString(decoded); } else if (data.length > 64) { return abi.decode(data, (string)); } return ""; } // attempts to extract the token symbol. if it does not implement symbol, returns a symbol derived from the address function tokenSymbol(address token) internal view returns (string memory) { // 0x95d89b41 = bytes4(keccak256("symbol()")) string memory symbol = callAndParseStringReturn(token, 0x95d89b41); if (bytes(symbol).length == 0) { // fallback to 6 uppercase hex of address return addressToSymbol(token); } return symbol; } // attempts to extract the token name. if it does not implement name, returns a name derived from the address function tokenName(address token) internal view returns (string memory) { // 0x06fdde03 = bytes4(keccak256("name()")) string memory name = callAndParseStringReturn(token, 0x06fdde03); if (bytes(name).length == 0) { // fallback to full hex of address return addressToName(token); } return name; } } // File @uniswap/v2-core/contracts/interfaces/[email protected] pragma solidity >=0.5.0; interface IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } // File contracts/v612/ICOREGlobals.sol // COPYRIGHT cVault.finance TEAM // NO COPY // COPY = BAD // This code is provided with no assurances or guarantees of any kind. Use at your own responsibility. interface ICOREGlobals { function CORETokenAddress() external view returns (address); function COREGlobalsAddress() external view returns (address); function COREDelegatorAddress() external view returns (address); function COREVaultAddress() external returns (address); function COREWETHUniPair() external view returns (address); function UniswapFactory() external view returns (address); function TransferHandler() external view returns (address); function addDelegatorStateChangePermission(address that, bool status) external; function isStateChangeApprovedContract(address that) external view returns (bool); } // File @openzeppelin/contracts-ethereum-package/contracts/token/ERC20/[email protected] pragma solidity ^0.6.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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 `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, 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 `sender` to `recipient` 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 sender, address recipient, uint256 amount) external returns (bool); /** * @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); } // File @openzeppelin/contracts-ethereum-package/contracts/math/[email protected] pragma solidity ^0.6.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when 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. */ library SafeMath { /** * @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) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @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 sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @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) { // 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 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts 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) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts 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) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts 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 mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // File @openzeppelin/contracts/GSN/[email protected] pragma solidity ^0.6.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 GSN 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 payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } // File @openzeppelin/contracts/access/[email protected] pragma solidity ^0.6.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. */ 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 () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { 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 { emit OwnershipTransferred(_owner, address(0)); _owner = 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"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File contracts/v612/FlashArbitrageCOREBuyer.sol pragma solidity 0.6.12; pragma experimental ABIEncoderV2; // import "hardhat/console.sol"; // import "@openzeppelin/contracts-ethereum-package/contracts/Initializable.sol"; // import "@openzeppelin/contracts-ethereum-package/contracts/access/Ownable.sol"; interface ICOREVault { function addPendingRewards(uint256 _) external; } contract FlashArbitrageCOREBuyer is Ownable { using SafeMath for uint256; event StrategyAdded(string indexed name, uint256 indexed id, address[] pairs, bool feeOff, address indexed originator); IERC20 public CORE; address public wETH; ICOREVault public coreVault; IUniswapV2Factory public uniswapFactory; address public CORExWETHPair; constructor (address _coreGlobals) public { ICOREGlobals globals = ICOREGlobals(_coreGlobals); IERC20 CORE = IERC20(globals.CORETokenAddress()); wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; IUniswapV2Factory uniswapFactory = IUniswapV2Factory(globals.UniswapFactory()); ICOREVault coreVault = ICOREVault(globals.COREVaultAddress()); CORExWETHPair = globals.COREWETHUniPair(); } function buyAndGiveOutCOREForToken(address _token) public { // We check if this token is CORE token if it is we just send it out if(_token == address(CORE)) { // return breaks out no need to else..else.. return sendCOREToVault(); } uint256 balInputToken = IERC20(_token).balanceOf(address(this)); address pairWithCORE = uniswapFactory.getPair(_token, address(CORE)); // We check if there is a pair for CORE token with that token if(pairWithCORE != address(0)){ // It mens we have a pair with CORE // So we should just swap with it //Suport FoT tokens swapSupportingFeeOnTransfertokens(_token, pairWithCORE, balInputToken); return sendCOREToVault(); } // This is the case we are not finding a pair with CORE so we try to find one with wETH address pairWithWETH = uniswapFactory.getPair(_token, wETH); if(pairWithWETH != address(0)) { uint256 amountOut = swapSupportingFeeOnTransfertokens(_token, pairWithWETH, balInputToken); swapSupportingFeeOnTransfertokens(wETH, CORExWETHPair, amountOut); sendCOREToVault(); } else { revert("FA COREBuyer : Unsupported token"); } } function swapSupportingFeeOnTransfertokens(address _inputToken, address _pair, uint256 amountIn) internal returns (uint256 amountOut) { IUniswapV2Pair pair = IUniswapV2Pair(_pair); // We check the balance before uint256 balanceOfTargetTokenUniBefore = IERC20(_inputToken).balanceOf(_pair); // Then transfers safeTransfer(_inputToken, _pair, amountIn); // And check it again to get the delta // This is to support fee on tranfer tokens uint256 balanceOfTargetTokenUniAfter = IERC20(_inputToken).balanceOf(_pair); bool token0Out = pair.token1() == _pair; (uint256 reserve0, uint256 reserve1,) = pair.getReserves(); if(token0Out) { amountOut = getAmountOut( balanceOfTargetTokenUniAfter - balanceOfTargetTokenUniBefore, reserve1, reserve0 ); pair.swap(amountOut,0, address(this), ""); } else { amountOut = getAmountOut( balanceOfTargetTokenUniAfter - balanceOfTargetTokenUniBefore, reserve0, reserve1 ); pair.swap(0,amountOut, address(this), ""); } } function sendCOREToVault() internal { uint256 balanceCORE = CORE.balanceOf(address(this)); CORE.transfer(address(coreVault), balanceCORE); coreVault.addPendingRewards(0); } function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) internal pure returns (uint256 amountOut) { require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT'); require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY'); uint amountInWithFee = amountIn.mul(997); uint numerator = amountInWithFee.mul(reserveOut); uint denominator = reserveIn.mul(1000).add(amountInWithFee); amountOut = numerator / denominator; } /////////////////// //// Helper functions ////////////////// function sendETH(address payable to, uint256 amt) internal { // console.log("I'm transfering ETH", amt/1e18, to); // throw exception on failure to.transfer(amt); } function safeTransfer(address token, address to, uint256 value) internal { // bytes4(keccak256(bytes('transfer(address,uint256)'))); (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), 'FA Controller: TRANSFER_FAILED'); } // A function that lets owner remove any tokens from this addrss // note this address shoudn't hold any tokens // And if it does that means someting already went wrong or someone send them to this address function rescueUnsupportedTokens(address token, uint256 amt) public onlyOwner { IERC20(token).transfer(owner(), amt); } function rescueETH(uint256 amt) public { sendETH(0xd5b47B80668840e7164C1D1d81aF8a9d9727B421, amt); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_coreGlobals","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"string","name":"name","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"pairs","type":"address[]"},{"indexed":false,"internalType":"bool","name":"feeOff","type":"bool"},{"indexed":true,"internalType":"address","name":"originator","type":"address"}],"name":"StrategyAdded","type":"event"},{"inputs":[],"name":"CORE","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CORExWETHPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"buyAndGiveOutCOREForToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"coreVault","outputs":[{"internalType":"contract ICOREVault","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amt","type":"uint256"}],"name":"rescueETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amt","type":"uint256"}],"name":"rescueUnsupportedTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapFactory","outputs":[{"internalType":"contract IUniswapV2Factory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000255ca4596a963883afe0ef9c85ea071cc050128b
-----Decoded View---------------
Arg [0] : _coreGlobals (address): 0x255CA4596A963883Afe0eF9c85EA071Cc050128B
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000255ca4596a963883afe0ef9c85ea071cc050128b
Deployed Bytecode Sourcemap
23429:5418:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23699:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23648:18;;;:::i;22459:148::-;;;:::i;:::-;;23733:39;;;:::i;21817:79::-;;;:::i;28724:114::-;;;;;;:::i;:::-;;:::i;28583:133::-;;;;;;:::i;:::-;;:::i;24282:1388::-;;;;;;:::i;:::-;;:::i;23779:28::-;;;:::i;23673:19::-;;;:::i;22762:244::-;;;;;;:::i;:::-;;:::i;23699:27::-;;;-1:-1:-1;;;;;23699:27:0;;:::o;23648:18::-;;;-1:-1:-1;;;;;23648:18:0;;:::o;22459:148::-;22039:12;:10;:12::i;:::-;22029:6;;-1:-1:-1;;;;;22029:6:0;;;:22;;;22021:67;;;;-1:-1:-1;;;22021:67:0;;;;;;;:::i;:::-;;;;;;;;;22566:1:::1;22550:6:::0;;22529:40:::1;::::0;-1:-1:-1;;;;;22550:6:0;;::::1;::::0;22529:40:::1;::::0;22566:1;;22529:40:::1;22597:1;22580:19:::0;;-1:-1:-1;;;;;;22580:19:0::1;::::0;;22459:148::o;23733:39::-;;;-1:-1:-1;;;;;23733:39:0;;:::o;21817:79::-;21855:7;21882:6;-1:-1:-1;;;;;21882:6:0;21817:79;:::o;28724:114::-;28774:56;28782:42;28826:3;28774:7;:56::i;:::-;28724:114;:::o;28583:133::-;22039:12;:10;:12::i;:::-;22029:6;;-1:-1:-1;;;;;22029:6:0;;;:22;;;22021:67;;;;-1:-1:-1;;;22021:67:0;;;;;;;:::i;:::-;28679:5:::1;-1:-1:-1::0;;;;;28672:22:0::1;;28695:7;:5;:7::i;:::-;28704:3;28672:36;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;28583:133:::0;;:::o;24282:1388::-;24460:4;;-1:-1:-1;;;;;24442:23:0;;;24460:4;;24442:23;24439:137;;;24547:17;:15;:17::i;:::-;24540:24;;24439:137;24611:39;;-1:-1:-1;;;24611:39:0;;24586:21;;-1:-1:-1;;;;;24611:24:0;;;;;:39;;24644:4;;24611:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24686:14;;;;24725:4;24686:45;;-1:-1:-1;;;24686:45:0;;24586:64;;-1:-1:-1;24663:20:0;;-1:-1:-1;;;;;24686:14:0;;;;:22;;:45;;24709:6;;24725:4;;;24686:45;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24663:68;-1:-1:-1;;;;;;24816:26:0;;;24813:297;;24989:70;25023:6;25031:12;25045:13;24989:33;:70::i;:::-;;25081:17;:15;:17::i;:::-;25074:24;;;;24813:297;25250:14;;;25281:4;;25250:36;;-1:-1:-1;;;25250:36:0;;25227:20;;-1:-1:-1;;;;;25250:14:0;;;;:22;;:36;;25273:6;;25281:4;;;;;25250:36;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25227:59;-1:-1:-1;;;;;;25300:26:0;;;25297:358;;25343:17;25363:70;25397:6;25405:12;25419:13;25363:33;:70::i;:::-;25496:4;;25502:13;;25343:90;;-1:-1:-1;25462:65:0;;-1:-1:-1;;;;;25496:4:0;;;;25502:13;25343:90;25462:33;:65::i;:::-;;25542:17;:15;:17::i;:::-;25297:358;;;;25601:42;;-1:-1:-1;;;25601:42:0;;;;;;;:::i;25297:358::-;24282:1388;;;;:::o;23779:28::-;;;-1:-1:-1;;;;;23779:28:0;;:::o;23673:19::-;;;-1:-1:-1;;;;;23673:19:0;;:::o;22762:244::-;22039:12;:10;:12::i;:::-;22029:6;;-1:-1:-1;;;;;22029:6:0;;;:22;;;22021:67;;;;-1:-1:-1;;;22021:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;22851:22:0;::::1;22843:73;;;;-1:-1:-1::0;;;22843:73:0::1;;;;;;;:::i;:::-;22953:6;::::0;;22932:38:::1;::::0;-1:-1:-1;;;;;22932:38:0;;::::1;::::0;22953:6;::::1;::::0;22932:38:::1;::::0;::::1;22981:6;:17:::0;;-1:-1:-1;;;;;;22981:17:0::1;-1:-1:-1::0;;;;;22981:17:0;;;::::1;::::0;;;::::1;::::0;;22762:244::o;20363:106::-;20451:10;20363:106;:::o;27787:195::-;27958:16;;-1:-1:-1;;;;;27958:11:0;;;:16;;;;;27970:3;;27958:16;;;;27970:3;27958:11;:16;;;;;;;;;;;;;;;;;;;26952:204;27021:4;;:29;;-1:-1:-1;;;27021:29:0;;26999:19;;-1:-1:-1;;;;;27021:4:0;;:14;;:29;;27044:4;;27021:29;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;27061:4;;27083:9;;27061:46;;-1:-1:-1;;;27061:46:0;;26999:51;;-1:-1:-1;;;;;;27061:4:0;;;;:13;;:46;;27083:9;;26999:51;;27061:46;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;27118:9:0;;:30;;-1:-1:-1;;;27118:30:0;;-1:-1:-1;;;;;27118:9:0;;;;:27;;:30;;:9;;:30;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26952:204;:::o;25678:1266::-;25960:36;;-1:-1:-1;;;25960:36:0;;25793:17;;25862:5;;25793:17;;-1:-1:-1;;;;;25960:29:0;;;;;:36;;25862:5;;25960:36;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25920:76;;26034:42;26047:11;26060:5;26067:8;26034:12;:42::i;:::-;26229:36;;-1:-1:-1;;;26229:36:0;;26190;;-1:-1:-1;;;;;26229:29:0;;;;;:36;;26259:5;;26229:36;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;26190:75;;26276:14;26310:5;-1:-1:-1;;;;;26293:22:0;:4;-1:-1:-1;;;;;26293:11:0;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;26293:22:0;;26276:39;;26327:16;26345;26366:4;-1:-1:-1;;;;;26366:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;26326:58;-1:-1:-1;;;;;26326:58:0;;;-1:-1:-1;;;;;26326:58:0;;;26400:9;26397:540;;;26438:161;26500:29;26469:28;:60;26548:8;26575;26438:12;:161::i;:::-;26614:41;;-1:-1:-1;;;26614:41:0;;26426:173;;-1:-1:-1;;;;;;26614:9:0;;;;;:41;;26426:173;;26634:1;;26645:4;;26614:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26397:540;;;26709:160;26771:29;26740:28;:60;26819:8;26846;26709:12;:160::i;:::-;26884:41;;-1:-1:-1;;;26884:41:0;;26697:172;;-1:-1:-1;;;;;;26884:9:0;;;;;:41;;26894:1;;26697:172;;26915:4;;26884:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26397:540;25678:1266;;;;;;;;;;;:::o;27990:363::-;28142:12;28156:17;28177:5;-1:-1:-1;;;;;28177:10:0;28211;28223:2;28227:5;28188:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;28188:45:0;;;;;;;;;;;28177:57;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28141:93;;;;28253:7;:57;;;;-1:-1:-1;28265:11:0;;:16;;:44;;;28296:4;28285:24;;;;;;;;;;;;:::i;:::-;28245:100;;;;-1:-1:-1;;;28245:100:0;;;;;;;:::i;27164:530::-;27267:17;27316:1;27305:8;:12;27297:68;;;;-1:-1:-1;;;27297:68:0;;;;;;;:::i;:::-;27396:1;27384:9;:13;:31;;;;;27414:1;27401:10;:14;27384:31;27376:84;;;;-1:-1:-1;;;27376:84:0;;;;;;;:::i;:::-;27471:20;27494:17;:8;27507:3;27494:12;:17::i;:::-;27471:40;-1:-1:-1;27522:14:0;27539:31;27471:40;27559:10;27539:19;:31::i;:::-;27522:48;-1:-1:-1;27581:16:0;27600:40;27624:15;27600:19;:9;27614:4;27600:13;:19::i;:::-;:23;;:40::i;:::-;27581:59;;27675:11;27663:9;:23;;;;;;;27164:530;-1:-1:-1;;;;;;;27164:530:0:o;16590:471::-;16648:7;16893:6;16889:47;;-1:-1:-1;16923:1:0;16916:8;;16889:47;16960:5;;;16964:1;16960;:5;:1;16984:5;;;;;:10;16976:56;;;;-1:-1:-1;;;16976:56:0;;;;;;;:::i;:::-;17052:1;-1:-1:-1;16590:471:0;;;;;:::o;15260:181::-;15318:7;15350:5;;;15374:6;;;;15366:46;;;;-1:-1:-1;;;15366:46:0;;;;;;;:::i;976:241:-1:-;;1080:2;1068:9;1059:7;1055:23;1051:32;1048:2;;;-1:-1;;1086:12;1048:2;85:6;72:20;97:33;124:5;97:33;:::i;1224:263::-;;1339:2;1327:9;1318:7;1314:23;1310:32;1307:2;;;-1:-1;;1345:12;1307:2;226:6;220:13;238:33;265:5;238:33;:::i;1494:366::-;;;1615:2;1603:9;1594:7;1590:23;1586:32;1583:2;;;-1:-1;;1621:12;1583:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;1673:63;1773:2;1812:22;;;;626:20;;-1:-1;;;1577:283::o;1867:257::-;;1979:2;1967:9;1958:7;1954:23;1950:32;1947:2;;;-1:-1;;1985:12;1947:2;364:6;358:13;17521:5;15569:13;15562:21;17499:5;17496:32;17486:2;;-1:-1;;17532:12;2131:533;;;;2279:2;2267:9;2258:7;2254:23;2250:32;2247:2;;;-1:-1;;2285:12;2247:2;502:6;496:13;514:33;541:5;514:33;:::i;:::-;2448:2;2498:22;;496:13;2337:74;;-1:-1;514:33;496:13;514:33;:::i;:::-;2567:2;2616:22;;914:13;2456:74;;-1:-1;15990:10;15979:22;;17864:34;;17854:2;;-1:-1;;17902:12;17854:2;2575:73;;;;2241:423;;;;;:::o;2671:241::-;;2775:2;2763:9;2754:7;2750:23;2746:32;2743:2;;;-1:-1;;2781:12;2743:2;-1:-1;626:20;;2737:175;-1:-1;2737:175::o;2919:263::-;;3034:2;3022:9;3013:7;3009:23;3005:32;3002:2;;;-1:-1;;3040:12;3002:2;-1:-1;774:13;;2996:186;-1:-1;2996:186::o;7620:271::-;;3469:5;14868:12;-1:-1;17112:101;17126:6;17123:1;17120:13;17112:101;;;3613:4;17193:11;;;;;17187:18;17174:11;;;17167:39;17141:10;17112:101;;;17228:6;17225:1;17222:13;17219:2;;;-1:-1;17284:6;17279:3;17275:16;17268:27;17219:2;-1:-1;3644:16;;;;;7754:137;-1:-1;;7754:137::o;7898:222::-;-1:-1;;;;;15773:54;;;;3260:37;;8025:2;8010:18;;7996:124::o;8127:333::-;-1:-1;;;;;15773:54;;;3260:37;;15773:54;;8446:2;8431:18;;3260:37;8282:2;8267:18;;8253:207::o;8467:333::-;-1:-1;;;;;15773:54;;;;3260:37;;8786:2;8771:18;;7571:37;8622:2;8607:18;;8593:207::o;9610:238::-;4266:58;;;9745:2;9730:18;;9716:132::o;9855:764::-;4266:58;;;10319:2;10304:18;;7571:37;;;;-1:-1;;;;;15773:54;10402:2;10387:18;;3260:37;10146:3;10439:2;10424:18;;10417:48;;;9855:764;10131:19;;;15012;15784:42;15052:14;;10117:502::o;10626:416::-;10826:2;10840:47;;;4561:2;10811:18;;;15012:19;4597:34;15052:14;;;4577:55;-1:-1;;;4652:12;;;4645:30;4694:12;;;10797:245::o;11049:416::-;11249:2;11263:47;;;11234:18;;;15012:19;4981:34;15052:14;;;4961:55;5035:12;;;11220:245::o;11472:416::-;11672:2;11686:47;;;5286:2;11657:18;;;15012:19;5322:29;15052:14;;;5302:50;5371:12;;;11643:245::o;11895:416::-;12095:2;12109:47;;;5622:2;12080:18;;;15012:19;5658:32;15052:14;;;5638:53;5710:12;;;12066:245::o;12318:416::-;12518:2;12532:47;;;5961:2;12503:18;;;15012:19;5997:34;15052:14;;;5977:55;-1:-1;;;6052:12;;;6045:32;6096:12;;;12489:245::o;12741:416::-;12941:2;12955:47;;;6347:2;12926:18;;;15012:19;6383:34;15052:14;;;6363:55;-1:-1;;;6438:12;;;6431:25;6475:12;;;12912:245::o;13164:416::-;13364:2;13378:47;;;13349:18;;;15012:19;6762:34;15052:14;;;6742:55;6816:12;;;13335:245::o;13587:416::-;13787:2;13801:47;;;7336:2;13772:18;;;15012:19;7372:34;15052:14;;;7352:55;-1:-1;;;7427:12;;;7420:35;7474:12;;;13758:245::o;17316:117::-;-1:-1;;;;;15773:54;;17375:35;;17365:2;;17424:1;;17414:12;17558:117;-1:-1;;;;;17645:5;15657:42;17620:5;17617:35;17607:2;;17666:1;;17656:12
Swarm Source
ipfs://cc89750d7a70f7e481d417117244298f0d911ce67dde2355dfbe1f00b360631e
Loading...
Loading
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.