Contract 0x34c1de737e201f9581f37564b492b492288eb7af 5
Contract Overview
Balance:
0 ETH
ETH Value:
$0.00
My Name Tag:
Not Available
TokenTracker:
Txn Hash | Method |
Block
|
From
|
To
|
Value | [Txn Fee] | |||
---|---|---|---|---|---|---|---|---|---|
0x02f20a95ae782084ea5afa5aadf15dca417146110ce6684c8253d476df66694a | 0x60806040 | 12598480 | 678 days 4 hrs ago | 0xc36142c497053c42bdaa14737bf80e71daa984c5 | IN | Create: ConnectV2UniswapV3SwapArbitrum | 0 ETH | 0.00463464075 ETH |
[ Download CSV Export ]
Latest 1 internal transaction
Parent Txn Hash | Block | From | To | Value | |||
---|---|---|---|---|---|---|---|
0x32ba9729a622f3b0b8a2b023c1cce8440e986365c1a218ada0992706850c5a51 | 12652344 | 677 days 13 hrs ago | InstaDApp: Connectors | 0x34c1de737e201f9581f37564b492b492288eb7af | 0 ETH |
[ Download CSV Export ]
Contract Name:
ConnectV2UniswapV3SwapArbitrum
Compiler Version
v0.7.6+commit.7338295f
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
//SPDX-License-Identifier: MIT pragma solidity ^0.7.6; pragma abicoder v2; /** * @title Uniswap v3 swap. * @dev Decentralized Exchange. */ import { TokenInterface } from "../../../common/interfaces.sol"; import { Helpers } from "./helpers.sol"; import { Events } from "./events.sol"; import "./interface.sol"; abstract contract UniswapResolver is Helpers, Events { /** * @dev Buy Function * @notice Swap token(sellAddr) with token(buyAddr), buy token with minimum sell token * @param _buyAddr token to be bought * @param _sellAddr token to be sold * @param _fee pool fees for buyAddr-sellAddr token pair * @param _unitAmt The unit amount of sellAmt/buyAmt with slippage * @param _buyAmt amount of token to be bought * @param _getId Id to get buyAmt * @param _setId Id to store sellAmt */ function buy( address _buyAddr, address _sellAddr, uint24 _fee, uint256 _unitAmt, uint256 _buyAmt, uint256 _getId, uint256 _setId ) external payable returns (string memory _eventName, bytes memory _eventParam) { return _buy( BuyInfo({ buyAddr: _buyAddr, sellAddr: _sellAddr, fee: _fee, unitAmt: _unitAmt, buyAmt: _buyAmt }), _getId, _setId ); } /** * @dev Sell Function * @notice Swap token(sellAddr) with token(buyAddr), buy token with minimum sell token * @param _buyAddr token to be bought * @param _sellAddr token to be sold * @param _fee pool fees for buyAddr-sellAddr token pair * @param _unitAmt The unit amount of buyAmt/sellAmt with slippage * @param _sellAmt amount of token to be sold * @param _getId Id to get sellAmt * @param _setId Id to store buyAmt */ function sell( address _buyAddr, address _sellAddr, uint24 _fee, uint256 _unitAmt, uint256 _sellAmt, uint256 _getId, uint256 _setId ) external payable returns (string memory _eventName, bytes memory _eventParam) { return _sell( SellInfo({ buyAddr: _buyAddr, sellAddr: _sellAddr, fee: _fee, unitAmt: _unitAmt, sellAmt: _sellAmt }), _getId, _setId ); } } contract ConnectV2UniswapV3SwapArbitrum is UniswapResolver { string public constant name = "UniswapV3-Swap-v1"; }
//SPDX-License-Identifier: MIT pragma solidity ^0.7.0; interface TokenInterface { function approve(address, uint256) external; function transfer(address, uint) external; function transferFrom(address, address, uint) external; function deposit() external payable; function withdraw(uint) external; function balanceOf(address) external view returns (uint); function decimals() external view returns (uint); } interface MemoryInterface { function getUint(uint id) external returns (uint num); function setUint(uint id, uint val) external; } interface InstaMapping { function cTokenMapping(address) external view returns (address); function gemJoinMapping(bytes32) external view returns (address); } interface AccountInterface { function enable(address) external; function disable(address) external; function isAuth(address) external view returns (bool); }
//SPDX-License-Identifier: MIT pragma solidity ^0.7.6; pragma abicoder v2; import { TokenInterface } from "../../../common/interfaces.sol"; import { DSMath } from "../../../common/math.sol"; import { Basic } from "../../../common/basic.sol"; import "./interface.sol"; abstract contract Helpers is DSMath, Basic { /** * @dev uniswap v3 Swap Router */ ISwapRouter02 constant swapRouter = ISwapRouter02(0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45); struct BuyInfo { address buyAddr; //token to be bought address sellAddr; //token to be sold uint24 fee; //pool fees for buyAddr-sellAddr token pair uint256 unitAmt; //The unit amount of sellAmt/buyAmt with slippage uint256 buyAmt; //amount of token to be bought } struct SellInfo { address buyAddr; //token to be bought address sellAddr; //token to be sold uint24 fee; //pool fees for buyAddr-sellAddr token pair uint256 unitAmt; //The unit amount of buyAmt/sellAmt with slippage. uint256 sellAmt; //amount of token to sell } /** * @dev Buy Function * @notice Swap token(sellAddr) with token(buyAddr), buy token with minimum sell token * @param buyData Data input for the buy action * @param getId Id to get buyAmt * @param setId Id to store sellAmt */ function _buy( BuyInfo memory buyData, uint256 getId, uint256 setId ) internal returns (string memory _eventName, bytes memory _eventParam) { uint256 _buyAmt = getUint(getId, buyData.buyAmt); (TokenInterface _buyAddr, TokenInterface _sellAddr) = changeEthAddress( buyData.buyAddr, buyData.sellAddr ); uint256 _slippageAmt = convert18ToDec( _sellAddr.decimals(), wmul(buyData.unitAmt, convertTo18(_buyAddr.decimals(), _buyAmt)) ); bool isEth = address(_sellAddr) == wethAddr; convertEthToWeth(isEth, _sellAddr, _slippageAmt); approve(_sellAddr, address(swapRouter), _slippageAmt); ExactOutputSingleParams memory params = ExactOutputSingleParams({ tokenIn: address(_sellAddr), tokenOut: address(_buyAddr), fee: buyData.fee, recipient: address(this), amountOut: _buyAmt, amountInMaximum: _slippageAmt, //require(_sellAmt <= amountInMaximum) sqrtPriceLimitX96: 0 }); uint256 _sellAmt = swapRouter.exactOutputSingle(params); require(_slippageAmt >= _sellAmt, "Too much slippage"); isEth = address(_buyAddr) == wethAddr; convertWethToEth(isEth, _buyAddr, _buyAmt); setUint(setId, _sellAmt); _eventName = "LogBuy(address,address,uint256,uint256,uint256,uint256)"; _eventParam = abi.encode( buyData.buyAddr, buyData.sellAddr, _buyAmt, _sellAmt, getId, setId ); } /** * @dev Sell Function * @notice Swap token(sellAddr) with token(buyAddr), to get max buy tokens * @param sellData Data input for the sell action * @param getId Id to get buyAmt * @param setId Id to store sellAmt */ function _sell( SellInfo memory sellData, uint256 getId, uint256 setId ) internal returns (string memory _eventName, bytes memory _eventParam) { uint256 _sellAmt = getUint(getId, sellData.sellAmt); (TokenInterface _buyAddr, TokenInterface _sellAddr) = changeEthAddress( sellData.buyAddr, sellData.sellAddr ); if (_sellAmt == uint256(-1)) { _sellAmt = sellData.sellAddr == ethAddr ? address(this).balance : _sellAddr.balanceOf(address(this)); } uint256 _slippageAmt = convert18ToDec( _buyAddr.decimals(), wmul(sellData.unitAmt, convertTo18(_sellAddr.decimals(), _sellAmt)) ); bool isEth = address(_sellAddr) == wethAddr; convertEthToWeth(isEth, _sellAddr, _sellAmt); approve(_sellAddr, address(swapRouter), _sellAmt); ExactInputSingleParams memory params = ExactInputSingleParams({ tokenIn: address(_sellAddr), tokenOut: address(_buyAddr), fee: sellData.fee, recipient: address(this), amountIn: _sellAmt, amountOutMinimum: _slippageAmt, //require(_buyAmt >= amountOutMinimum) sqrtPriceLimitX96: 0 }); uint256 _buyAmt = swapRouter.exactInputSingle(params); require(_slippageAmt <= _buyAmt, "Too much slippage"); isEth = address(_buyAddr) == wethAddr; convertWethToEth(isEth, _buyAddr, _buyAmt); setUint(setId, _buyAmt); _eventName = "LogSell(address,address,uint256,uint256,uint256,uint256)"; _eventParam = abi.encode( sellData.buyAddr, sellData.sellAddr, _buyAmt, _sellAmt, getId, setId ); } }
//SPDX-License-Identifier: MIT pragma solidity ^0.7.0; contract Events { event LogBuy( address indexed buyToken, address indexed sellToken, uint256 buyAmt, uint256 sellAmt, uint256 getId, uint256 setId ); event LogSell( address indexed buyToken, address indexed sellToken, uint256 buyAmt, uint256 sellAmt, uint256 getId, uint256 setId ); }
//SPDX-License-Identifier: MIT pragma solidity ^0.7.6; pragma abicoder v2; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "@openzeppelin/contracts/token/ERC721/IERC721Metadata.sol"; import "@openzeppelin/contracts/token/ERC721/IERC721Enumerable.sol"; struct ExactInputSingleParams { address tokenIn; address tokenOut; uint24 fee; address recipient; uint256 amountIn; uint256 amountOutMinimum; uint160 sqrtPriceLimitX96; } struct ExactInputParams { bytes path; address recipient; uint256 amountIn; uint256 amountOutMinimum; } struct ExactOutputSingleParams { address tokenIn; address tokenOut; uint24 fee; address recipient; uint256 amountOut; uint256 amountInMaximum; uint160 sqrtPriceLimitX96; } struct ExactOutputParams { bytes path; address recipient; uint256 amountOut; uint256 amountInMaximum; } /// @title Callback for IUniswapV3PoolActions#swap /// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface interface IUniswapV3SwapCallback { /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap. /// @dev In the implementation you must pay the pool tokens owed for the swap. /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory. /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped. /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by /// the end of the swap. If positive, the callback must send that amount of token0 to the pool. /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by /// the end of the swap. If positive, the callback must send that amount of token1 to the pool. /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call function uniswapV3SwapCallback( int256 amount0Delta, int256 amount1Delta, bytes calldata data ) external; } interface IV3SwapRouter is IUniswapV3SwapCallback { /// @notice Swaps `amountIn` of one token for as much as possible of another token /// @dev Setting `amountIn` to 0 will cause the contract to look up its own balance, /// and swap the entire amount, enabling contracts to send tokens before calling this function. /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata /// @return amountOut The amount of the received token function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut); /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path /// @dev Setting `amountIn` to 0 will cause the contract to look up its own balance, /// and swap the entire amount, enabling contracts to send tokens before calling this function. /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata /// @return amountOut The amount of the received token function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut); /// @notice Swaps as little as possible of one token for `amountOut` of another token /// that may remain in the router after the swap. /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata /// @return amountIn The amount of the input token function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn); /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed) /// that may remain in the router after the swap. /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata /// @return amountIn The amount of the input token function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn); } interface IApproveAndCall {} /// @title Multicall interface /// @notice Enables calling multiple methods in a single call to the contract interface IMulticall { } /// @title MulticallExtended interface /// @notice Enables calling multiple methods in a single call to the contract with optional validation interface IMulticallExtended is IMulticall { } /// @title Self Permit /// @notice Functionality to call permit on any EIP-2612-compliant token for use in the route interface ISelfPermit { } /// @title Router token swapping functionality /// @notice Functions for swapping tokens via Uniswap V2 interface IV2SwapRouter { } interface ISwapRouter02 is IV2SwapRouter, IV3SwapRouter, IApproveAndCall, IMulticallExtended, ISelfPermit {}
//SPDX-License-Identifier: MIT pragma solidity ^0.7.0; import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol"; contract DSMath { uint constant WAD = 10 ** 18; uint constant RAY = 10 ** 27; function add(uint x, uint y) internal pure returns (uint z) { z = SafeMath.add(x, y); } function sub(uint x, uint y) internal virtual pure returns (uint z) { z = SafeMath.sub(x, y); } function mul(uint x, uint y) internal pure returns (uint z) { z = SafeMath.mul(x, y); } function div(uint x, uint y) internal pure returns (uint z) { z = SafeMath.div(x, y); } function wmul(uint x, uint y) internal pure returns (uint z) { z = SafeMath.add(SafeMath.mul(x, y), WAD / 2) / WAD; } function wdiv(uint x, uint y) internal pure returns (uint z) { z = SafeMath.add(SafeMath.mul(x, WAD), y / 2) / y; } function rdiv(uint x, uint y) internal pure returns (uint z) { z = SafeMath.add(SafeMath.mul(x, RAY), y / 2) / y; } function rmul(uint x, uint y) internal pure returns (uint z) { z = SafeMath.add(SafeMath.mul(x, y), RAY / 2) / RAY; } function toInt(uint x) internal pure returns (int y) { y = int(x); require(y >= 0, "int-overflow"); } function toRad(uint wad) internal pure returns (uint rad) { rad = mul(wad, 10 ** 27); } }
//SPDX-License-Identifier: MIT pragma solidity ^0.7.0; import { TokenInterface } from "./interfaces.sol"; import { Stores } from "./stores.sol"; import { DSMath } from "./math.sol"; abstract contract Basic is DSMath, Stores { function convert18ToDec(uint _dec, uint256 _amt) internal pure returns (uint256 amt) { amt = (_amt / 10 ** (18 - _dec)); } function convertTo18(uint _dec, uint256 _amt) internal pure returns (uint256 amt) { amt = mul(_amt, 10 ** (18 - _dec)); } function getTokenBal(TokenInterface token) internal view returns(uint _amt) { _amt = address(token) == ethAddr ? address(this).balance : token.balanceOf(address(this)); } function getTokensDec(TokenInterface buyAddr, TokenInterface sellAddr) internal view returns(uint buyDec, uint sellDec) { buyDec = address(buyAddr) == ethAddr ? 18 : buyAddr.decimals(); sellDec = address(sellAddr) == ethAddr ? 18 : sellAddr.decimals(); } function encodeEvent(string memory eventName, bytes memory eventParam) internal pure returns (bytes memory) { return abi.encode(eventName, eventParam); } function approve(TokenInterface token, address spender, uint256 amount) internal { try token.approve(spender, amount) { } catch { token.approve(spender, 0); token.approve(spender, amount); } } function changeEthAddress(address buy, address sell) internal pure returns(TokenInterface _buy, TokenInterface _sell){ _buy = buy == ethAddr ? TokenInterface(wethAddr) : TokenInterface(buy); _sell = sell == ethAddr ? TokenInterface(wethAddr) : TokenInterface(sell); } function convertEthToWeth(bool isEth, TokenInterface token, uint amount) internal { if(isEth) token.deposit{value: amount}(); } function convertWethToEth(bool isEth, TokenInterface token, uint amount) internal { if(isEth) { approve(token, address(token), amount); token.withdraw(amount); } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.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, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { 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) { 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) { // 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) { 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) { 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) { 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) { require(b <= a, "SafeMath: subtraction overflow"); 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) { 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, reverting 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) { require(b > 0, "SafeMath: division by zero"); 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) { require(b > 0, "SafeMath: modulo by zero"); 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) { 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. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * 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) { 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) { require(b > 0, errorMessage); return a % b; } }
//SPDX-License-Identifier: MIT pragma solidity ^0.7.0; import { MemoryInterface, InstaMapping } from "./interfaces.sol"; abstract contract Stores { /** * @dev Return ethereum address */ address constant internal ethAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; /** * @dev Return Wrapped ETH address */ address constant internal wethAddr = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1; /** * @dev Return memory variable address */ MemoryInterface constant internal instaMemory = MemoryInterface(0xc109f7Ef06152c3a63dc7254fD861E612d3Ac571); /** * @dev Get Uint value from InstaMemory Contract. */ function getUint(uint getId, uint val) internal returns (uint returnVal) { returnVal = getId == 0 ? val : instaMemory.getUint(getId); } /** * @dev Set Uint value in InstaMemory Contract. */ function setUint(uint setId, uint val) virtual internal { if (setId != 0) instaMemory.setUint(setId, val); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <0.8.0; import "../../introspection/IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <0.8.0; import "./IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <0.8.0; import "./IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "metadata": { "useLiteralContent": true }, "libraries": {} }
[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"buyToken","type":"address"},{"indexed":true,"internalType":"address","name":"sellToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"buyAmt","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sellAmt","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"getId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"setId","type":"uint256"}],"name":"LogBuy","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"buyToken","type":"address"},{"indexed":true,"internalType":"address","name":"sellToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"buyAmt","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sellAmt","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"getId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"setId","type":"uint256"}],"name":"LogSell","type":"event"},{"inputs":[{"internalType":"address","name":"_buyAddr","type":"address"},{"internalType":"address","name":"_sellAddr","type":"address"},{"internalType":"uint24","name":"_fee","type":"uint24"},{"internalType":"uint256","name":"_unitAmt","type":"uint256"},{"internalType":"uint256","name":"_buyAmt","type":"uint256"},{"internalType":"uint256","name":"_getId","type":"uint256"},{"internalType":"uint256","name":"_setId","type":"uint256"}],"name":"buy","outputs":[{"internalType":"string","name":"_eventName","type":"string"},{"internalType":"bytes","name":"_eventParam","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_buyAddr","type":"address"},{"internalType":"address","name":"_sellAddr","type":"address"},{"internalType":"uint24","name":"_fee","type":"uint24"},{"internalType":"uint256","name":"_unitAmt","type":"uint256"},{"internalType":"uint256","name":"_sellAmt","type":"uint256"},{"internalType":"uint256","name":"_getId","type":"uint256"},{"internalType":"uint256","name":"_setId","type":"uint256"}],"name":"sell","outputs":[{"internalType":"string","name":"_eventName","type":"string"},{"internalType":"bytes","name":"_eventParam","type":"bytes"}],"stateMutability":"payable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
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.