Contract 0x34c1de737e201f9581f37564b492b492288eb7af 5

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x02f20a95ae782084ea5afa5aadf15dca417146110ce6684c8253d476df66694a0x60806040125984802022-05-21 1:42:14678 days 4 hrs ago0xc36142c497053c42bdaa14737bf80e71daa984c5 IN  Create: ConnectV2UniswapV3SwapArbitrum0 ETH0.00463464075 ETH0.333918324
[ Download CSV Export 
Latest 1 internal transaction
Parent Txn Hash Block From To Value
0x32ba9729a622f3b0b8a2b023c1cce8440e986365c1a218ada0992706850c5a51126523442022-05-21 16:52:38677 days 13 hrs ago InstaDApp: Connectors 0x34c1de737e201f9581f37564b492b492288eb7af0 ETH
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
ConnectV2UniswapV3SwapArbitrum

Compiler Version
v0.7.6+commit.7338295f

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion
File 1 of 13 : main.sol
//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";
}

File 2 of 13 : interfaces.sol
//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);
}

File 3 of 13 : helpers.sol
//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
		);
	}
}

File 4 of 13 : events.sol
//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
	);
}

File 5 of 13 : interface.sol
//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
{}

File 6 of 13 : math.sol
//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);
  }

}

File 7 of 13 : basic.sol
//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);
        }
    }
}

File 8 of 13 : SafeMath.sol
// 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;
    }
}

File 9 of 13 : stores.sol
//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);
  }

}

File 10 of 13 : IERC721.sol
// 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;
}

File 11 of 13 : IERC721Metadata.sol
// 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);
}

File 12 of 13 : IERC721Enumerable.sol
// 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);
}

File 13 of 13 : IERC165.sol
// 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);
}

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

Contract ABI

[{"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"}]

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

Deployed Bytecode

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

Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.