Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

interface Callable    - function tokenCallback(address _from, ... interface Router    - function factory()    - function positionManager()    - function WETH9() interface Factory    - function createPool(address _tokenA, ... interface Pool    - function initialize(uint160 _sqrtPric ... interface PositionManager    - function mint(MintParams calldata)    - function collect(CollectParams callda ... interface ERC20    - function balanceOf(address)    - function transfer(address, uint256) interface WETH is ERC20    - function withdraw(uint256)  contract Team    - function withdrawETH()    - function withdrawToken(ERC20 _token)    - function withdrawFees()    - function _addShare(address _user, uin ...  contract TokenBase    - function transfer(address _to, uint25 ...    - function approve(address _spender, ui ...    - function transferFrom(address _from, ...    - function transferAndCall(address _to, ...    - function totalSupply()    - function balanceOf(address _user)    - function allowance(address _user, add ...    - function _approve(address _owner, add ...    - function _transfer(address _from, add ...  contract SEETHE is TokenBase *  contract COPE is TokenBase    - function initialize()    - function collectTradingFees()    - function seethe()    - function copePool()    - function seethePool()    - function oneToOnePool()    - function positions()    - function _getSqrtRatioAtTick(int24 ti ...    - function _getTickAtSqrtRatio(uint160 ...    - function _sqrt(uint256 _n)    - function _getPriceAndTickFromValues(b ...  contract Deploy

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-07-27
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

// $COPE & $SEETHE
// - no contract owner
// - LP permanently locked
// - initial marketcap of 100 ETH each
// - 10% of each supply goes into a 1:1 pool
// https://copeandseethe.lol/

interface Callable {
	function tokenCallback(address _from, uint256 _tokens, bytes calldata _data) external returns (bool);
}

interface Router {
	function factory() external view returns (address);
	function positionManager() external view returns (address);
	function WETH9() external view returns (address);
}

interface Factory {
	function createPool(address _tokenA, address _tokenB, uint24 _fee) external returns (address);
}

interface Pool {
	function initialize(uint160 _sqrtPriceX96) external;
}

interface PositionManager {
	struct MintParams {
		address token0;
		address token1;
		uint24 fee;
		int24 tickLower;
		int24 tickUpper;
		uint256 amount0Desired;
		uint256 amount1Desired;
		uint256 amount0Min;
		uint256 amount1Min;
		address recipient;
		uint256 deadline;
	}
	struct CollectParams {
		uint256 tokenId;
		address recipient;
		uint128 amount0Max;
		uint128 amount1Max;
	}
	function mint(MintParams calldata) external payable returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
	function collect(CollectParams calldata) external payable returns (uint256 amount0, uint256 amount1);
}

interface ERC20 {
	function balanceOf(address) external view returns (uint256);
	function transfer(address, uint256) external returns (bool);
}

interface WETH is ERC20 {
	function withdraw(uint256) external;
}


contract Team {

	Router constant private ROUTER = Router(0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45);

	struct Share {
		address payable user;
		uint256 shares;
	}
	Share[] public shares;
	uint256 public totalShares;
	ERC20 public cope;
	ERC20 public seethe;


	constructor(address _seethe) {
		cope = ERC20(msg.sender);
		seethe = ERC20(_seethe);
		_addShare(0xfb4E9D0ac9DA6b9cC6F0B0b7d2F59F92416b9E47, 5);
		_addShare(0x604CD20589D5c7297Da1A5eEC355dF8bbd6E3Aca, 4);
		_addShare(0xc881c6866cDffc46573619aE52F22a84A0706115, 1);
	}

	receive() external payable {}

	function withdrawETH() public {
		uint256 _balance = address(this).balance;
		if (_balance > 0) {
			for (uint256 i = 0; i < shares.length; i++) {
				Share memory _share = shares[i];
				!_share.user.send(_balance * _share.shares / totalShares);
			}
		}
	}

	function withdrawToken(ERC20 _token) public {
		uint256 _balance = _token.balanceOf(address(this));
		if (_balance > 0) {
			for (uint256 i = 0; i < shares.length; i++) {
				Share memory _share = shares[i];
				_token.transfer(_share.user, _balance * _share.shares / totalShares);
			}
		}
	}

	function withdrawFees() external {
		WETH _weth = WETH(ROUTER.WETH9());
		_weth.withdraw(_weth.balanceOf(address(this)));
		withdrawETH();
		withdrawToken(cope);
		withdrawToken(seethe);
	}


	function _addShare(address _user, uint256 _shares) internal {
		shares.push(Share(payable(_user), _shares));
		totalShares += _shares;
	}
}


contract TokenBase {

	uint256 constant internal UINT_MAX = type(uint256).max;
	uint256 constant internal INITIAL_SUPPLY = 42069e25; // 420,690,000,000

	string public name;
	string public symbol;
	uint8 constant public decimals = 18;

	struct User {
		uint256 balance;
		mapping(address => uint256) allowance;
	}

	struct Info {
		uint256 totalSupply;
		mapping(address => User) users;
	}
	Info internal info;


	event Transfer(address indexed from, address indexed to, uint256 tokens);
	event Approval(address indexed owner, address indexed spender, uint256 tokens);


	function transfer(address _to, uint256 _tokens) external returns (bool) {
		return _transfer(msg.sender, _to, _tokens);
	}

	function approve(address _spender, uint256 _tokens) external returns (bool) {
		return _approve(msg.sender, _spender, _tokens);
	}

	function transferFrom(address _from, address _to, uint256 _tokens) external returns (bool) {
		uint256 _allowance = allowance(_from, msg.sender);
		require(_allowance >= _tokens);
		if (_allowance != UINT_MAX) {
			info.users[_from].allowance[msg.sender] -= _tokens;
		}
		return _transfer(_from, _to, _tokens);
	}

	function transferAndCall(address _to, uint256 _tokens, bytes calldata _data) external returns (bool) {
		_transfer(msg.sender, _to, _tokens);
		uint32 _size;
		assembly {
			_size := extcodesize(_to)
		}
		if (_size > 0) {
			require(Callable(_to).tokenCallback(msg.sender, _tokens, _data));
		}
		return true;
	}
	

	function totalSupply() public view returns (uint256) {
		return info.totalSupply;
	}

	function balanceOf(address _user) public view returns (uint256) {
		return info.users[_user].balance;
	}

	function allowance(address _user, address _spender) public view returns (uint256) {
		return info.users[_user].allowance[_spender];
	}


	function _approve(address _owner, address _spender, uint256 _tokens) internal returns (bool) {
		info.users[_owner].allowance[_spender] = _tokens;
		emit Approval(_owner, _spender, _tokens);
		return true;
	}
	
	function _transfer(address _from, address _to, uint256 _tokens) internal returns (bool) {
		unchecked {
			require(balanceOf(_from) >= _tokens);
			info.users[_from].balance -= _tokens;
			info.users[_to].balance += _tokens;
			emit Transfer(_from, _to, _tokens);
			return true;
		}
	}
}


contract SEETHE is TokenBase {
	constructor() {
		name = "Seethe";
		symbol = "SEETHE";
		info.totalSupply = INITIAL_SUPPLY;
		info.users[msg.sender].balance = INITIAL_SUPPLY;
		emit Transfer(address(0x0), msg.sender, INITIAL_SUPPLY);
	}
}


contract COPE is TokenBase {

	uint256 constant private FLOAT_SCALAR = 2**64;
	uint128 constant private UINT128_MAX = type(uint128).max;
	Router constant private ROUTER = Router(0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45);
	uint256 constant private INITIAL_ETH_MC = 100 ether; // 100 ETH initial market cap price
	uint256 constant private UPPER_ETH_MC = 1e6 ether; // 1,000,000 ETH max market cap price
	uint256 constant private ONE_TO_ONE_PERCENT = 10; // 10% (42,069,000,000)

	int24 constant private MIN_TICK = -887272;
	int24 constant private MAX_TICK = -MIN_TICK;
	uint160 constant private MIN_SQRT_RATIO = 4295128739;
	uint160 constant private MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;

	struct ExtraInfo {
		Team team;
		SEETHE seethe;
		address copePool;
		address seethePool;
		address oneToOnePool;
		uint256 copePositionId;
		uint256 seethePositionId;
		uint256 oneToOnePositionId;
	}
	ExtraInfo private extraInfo;


	constructor() {
		name = "Cope";
		symbol = "COPE";
		extraInfo.seethe = new SEETHE();
		address _seethe = seethe();
		extraInfo.team = new Team(_seethe);
		address _this = address(this);
		address _weth = ROUTER.WETH9();
		(uint160 _initialSqrtPrice, ) = _getPriceAndTickFromValues(_weth < _this, INITIAL_SUPPLY, INITIAL_ETH_MC);
		extraInfo.copePool = Factory(ROUTER.factory()).createPool(_this, _weth, 10000);
		Pool(copePool()).initialize(_initialSqrtPrice);
		(_initialSqrtPrice, ) = _getPriceAndTickFromValues(_weth < _seethe, INITIAL_SUPPLY, INITIAL_ETH_MC);
		extraInfo.seethePool = Factory(ROUTER.factory()).createPool(_seethe, _weth, 10000);
		Pool(seethePool()).initialize(_initialSqrtPrice);
		uint256 _oneToOneTokens = ONE_TO_ONE_PERCENT * INITIAL_SUPPLY / 100;
		(_initialSqrtPrice, ) = _getPriceAndTickFromValues(true, _oneToOneTokens, _oneToOneTokens);
		extraInfo.oneToOnePool = Factory(ROUTER.factory()).createPool(_this, _seethe, 10000);
		Pool(oneToOnePool()).initialize(_initialSqrtPrice);
	}
	
	function initialize() external {
		require(totalSupply() == 0);
		address _this = address(this);
		address _weth = ROUTER.WETH9();
		bool _weth0 = _weth < _this;
		PositionManager _pm = PositionManager(ROUTER.positionManager());
		info.totalSupply = INITIAL_SUPPLY;
		info.users[_this].balance = INITIAL_SUPPLY;
		emit Transfer(address(0x0), _this, INITIAL_SUPPLY);
		_approve(_this, address(_pm), INITIAL_SUPPLY);
		( , int24 _minTick) = _getPriceAndTickFromValues(_weth0, INITIAL_SUPPLY, INITIAL_ETH_MC);
		( , int24 _maxTick) = _getPriceAndTickFromValues(_weth0, INITIAL_SUPPLY, UPPER_ETH_MC);
		uint256 _oneToOneTokens = ONE_TO_ONE_PERCENT * INITIAL_SUPPLY / 100;
		(extraInfo.copePositionId, , , ) = _pm.mint(PositionManager.MintParams({
			token0: _weth0 ? _weth : _this,
			token1: !_weth0 ? _weth : _this,
			fee: 10000,
			tickLower: _weth0 ? _maxTick : _minTick,
			tickUpper: !_weth0 ? _maxTick : _minTick,
			amount0Desired: _weth0 ? 0 : INITIAL_SUPPLY - _oneToOneTokens,
			amount1Desired: !_weth0 ? 0 : INITIAL_SUPPLY - _oneToOneTokens,
			amount0Min: 0,
			amount1Min: 0,
			recipient: _this,
			deadline: block.timestamp
		}));
		address _seethe = seethe();
		extraInfo.seethe.approve(address(_pm), INITIAL_SUPPLY);
		_weth0 = _weth < _seethe;
		( , _minTick) = _getPriceAndTickFromValues(_weth0, INITIAL_SUPPLY, INITIAL_ETH_MC);
		( , _maxTick) = _getPriceAndTickFromValues(_weth0, INITIAL_SUPPLY, UPPER_ETH_MC);
		(extraInfo.seethePositionId, , , ) = _pm.mint(PositionManager.MintParams({
			token0: _weth0 ? _weth : _seethe,
			token1: !_weth0 ? _weth : _seethe,
			fee: 10000,
			tickLower: _weth0 ? _maxTick : _minTick,
			tickUpper: !_weth0 ? _maxTick : _minTick,
			amount0Desired: _weth0 ? 0 : INITIAL_SUPPLY - _oneToOneTokens,
			amount1Desired: !_weth0 ? 0 : INITIAL_SUPPLY - _oneToOneTokens,
			amount0Min: 0,
			amount1Min: 0,
			recipient: _this,
			deadline: block.timestamp
		}));
		bool _this0 = _this < _seethe;
		( , int24 _oneToOneTick) = _getPriceAndTickFromValues(true, _oneToOneTokens, _oneToOneTokens);
		(extraInfo.oneToOnePositionId, , , ) = _pm.mint(PositionManager.MintParams({
			token0: _this0 ? _this : _seethe,
			token1: !_this0 ? _this : _seethe,
			fee: 10000,
			tickLower: _oneToOneTick - 200,
			tickUpper: _oneToOneTick + 200,
			amount0Desired: _oneToOneTokens,
			amount1Desired: _oneToOneTokens,
			amount0Min: 0,
			amount1Min: 0,
			recipient: _this,
			deadline: block.timestamp
		}));
	}

	function collectTradingFees() external {
		PositionManager _pm = PositionManager(ROUTER.positionManager());
		_pm.collect(PositionManager.CollectParams({
			tokenId: extraInfo.copePositionId,
			recipient: address(extraInfo.team),
			amount0Max: UINT128_MAX,
			amount1Max: UINT128_MAX
		}));
		_pm.collect(PositionManager.CollectParams({
			tokenId: extraInfo.seethePositionId,
			recipient: address(extraInfo.team),
			amount0Max: UINT128_MAX,
			amount1Max: UINT128_MAX
		}));
		_pm.collect(PositionManager.CollectParams({
			tokenId: extraInfo.oneToOnePositionId,
			recipient: address(extraInfo.team),
			amount0Max: UINT128_MAX,
			amount1Max: UINT128_MAX
		}));
		extraInfo.team.withdrawFees();
	}
	

	function seethe() public view returns (address) {
		return address(extraInfo.seethe);
	}

	function copePool() public view returns (address) {
		return extraInfo.copePool;
	}

	function seethePool() public view returns (address) {
		return extraInfo.seethePool;
	}

	function oneToOnePool() public view returns (address) {
		return extraInfo.oneToOnePool;
	}

	function positions() external view returns (uint256 copePositionId, uint256 seethePositionId, uint256 oneToOnePositionId) {
		return (extraInfo.copePositionId, extraInfo.seethePositionId, extraInfo.oneToOnePositionId);
	}


	function _getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) {
		unchecked {
			uint256 absTick = tick < 0 ? uint256(-int256(tick)) : uint256(int256(tick));
			require(absTick <= uint256(int256(MAX_TICK)), 'T');

			uint256 ratio = absTick & 0x1 != 0 ? 0xfffcb933bd6fad37aa2d162d1a594001 : 0x100000000000000000000000000000000;
			if (absTick & 0x2 != 0) ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
			if (absTick & 0x4 != 0) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
			if (absTick & 0x8 != 0) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
			if (absTick & 0x10 != 0) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
			if (absTick & 0x20 != 0) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
			if (absTick & 0x40 != 0) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
			if (absTick & 0x80 != 0) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
			if (absTick & 0x100 != 0) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
			if (absTick & 0x200 != 0) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
			if (absTick & 0x400 != 0) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
			if (absTick & 0x800 != 0) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
			if (absTick & 0x1000 != 0) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
			if (absTick & 0x2000 != 0) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
			if (absTick & 0x4000 != 0) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
			if (absTick & 0x8000 != 0) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
			if (absTick & 0x10000 != 0) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
			if (absTick & 0x20000 != 0) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
			if (absTick & 0x40000 != 0) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
			if (absTick & 0x80000 != 0) ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;

			if (tick > 0) ratio = type(uint256).max / ratio;

			sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
		}
	}

	function _getTickAtSqrtRatio(uint160 sqrtPriceX96) internal pure returns (int24 tick) {
		unchecked {
			require(sqrtPriceX96 >= MIN_SQRT_RATIO && sqrtPriceX96 < MAX_SQRT_RATIO, 'R');
			uint256 ratio = uint256(sqrtPriceX96) << 32;

			uint256 r = ratio;
			uint256 msb = 0;

			assembly {
				let f := shl(7, gt(r, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
				msb := or(msb, f)
				r := shr(f, r)
			}
			assembly {
				let f := shl(6, gt(r, 0xFFFFFFFFFFFFFFFF))
				msb := or(msb, f)
				r := shr(f, r)
			}
			assembly {
				let f := shl(5, gt(r, 0xFFFFFFFF))
				msb := or(msb, f)
				r := shr(f, r)
			}
			assembly {
				let f := shl(4, gt(r, 0xFFFF))
				msb := or(msb, f)
				r := shr(f, r)
			}
			assembly {
				let f := shl(3, gt(r, 0xFF))
				msb := or(msb, f)
				r := shr(f, r)
			}
			assembly {
				let f := shl(2, gt(r, 0xF))
				msb := or(msb, f)
				r := shr(f, r)
			}
			assembly {
				let f := shl(1, gt(r, 0x3))
				msb := or(msb, f)
				r := shr(f, r)
			}
			assembly {
				let f := gt(r, 0x1)
				msb := or(msb, f)
			}

			if (msb >= 128) r = ratio >> (msb - 127);
			else r = ratio << (127 - msb);

			int256 log_2 = (int256(msb) - 128) << 64;

			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(63, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(62, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(61, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(60, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(59, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(58, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(57, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(56, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(55, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(54, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(53, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(52, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(51, f))
				r := shr(f, r)
			}
			assembly {
				r := shr(127, mul(r, r))
				let f := shr(128, r)
				log_2 := or(log_2, shl(50, f))
			}

			int256 log_sqrt10001 = log_2 * 255738958999603826347141;

			int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
			int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);

			tick = tickLow == tickHi ? tickLow : _getSqrtRatioAtTick(tickHi) <= sqrtPriceX96 ? tickHi : tickLow;
		}
	}

	function _sqrt(uint256 _n) internal pure returns (uint256 result) {
		unchecked {
			uint256 _tmp = (_n + 1) / 2;
			result = _n;
			while (_tmp < result) {
				result = _tmp;
				_tmp = (_n / _tmp + _tmp) / 2;
			}
		}
	}

	function _getPriceAndTickFromValues(bool _weth0, uint256 _tokens, uint256 _weth) internal pure returns (uint160 price, int24 tick) {
		uint160 _tmpPrice = uint160(_sqrt(2**192 / (!_weth0 ? _tokens : _weth) * (_weth0 ? _tokens : _weth)));
		tick = _getTickAtSqrtRatio(_tmpPrice);
		tick = tick - (tick % 200);
		price = _getSqrtRatioAtTick(tick);
	}
}


contract Deploy {
	COPE immutable public cope;
	constructor() {
		cope = new COPE();
		cope.initialize();
	}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"address","name":"_spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_tokens","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokens","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokens","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"transferAndCall","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokens","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

5555:247:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3328:18;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3895:132;;;;;;:::i;:::-;;:::i;:::-;;;1169:14:1;;1162:22;1144:41;;1132:2;1117:18;3895:132:0;1004:187:1;4689:86:0;4754:4;:16;4689:86;;;1342:25:1;;;1330:2;1315:18;4689:86:0;1196:177:1;4032:321:0;;;;;;:::i;:::-;;:::i;3374:35::-;;3407:2;3374:35;;;;;1883:4:1;1871:17;;;1853:36;;1841:2;1826:18;3374:35:0;1711:184:1;4358:323:0;;;;;;:::i;:::-;;:::i;4780:106::-;;;;;;:::i;:::-;-1:-1:-1;;;;;4856:17:0;4835:7;4856:17;;;:10;:17;;;;;:25;;4780:106;3350:20;;;:::i;3766:124::-;;;;;;:::i;:::-;;:::i;4891:136::-;;;;;;:::i;:::-;-1:-1:-1;;;;;4985:17:0;;;4964:7;4985:17;;;:10;:17;;;;;;;;:37;;;;;;:10;:27;;;:37;;;;;;4891:136;3328:18;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;3895:132::-;3965:4;3983:39;3992:10;4004:8;4014:7;3983:8;:39::i;:::-;3976:46;;3895:132;;;;;:::o;4032:321::-;-1:-1:-1;;;;;4985:17:0;;4117:4;4985:17;;;:10;:17;;;;;;;;4166:10;4985:37;;:10;:27;:37;;;;;;4204:7;4190:10;:21;;4182:30;;;;;;-1:-1:-1;;4221:10:0;:22;4217:90;;-1:-1:-1;;;;;4251:17:0;;;;;;:10;:17;;;;;;;;4279:10;4251:39;;:10;:27;:39;;;;;:50;;4294:7;;4251:17;:50;;4294:7;;4251:50;:::i;:::-;;;;-1:-1:-1;;4217:90:0;4318:30;4328:5;4335:3;4340:7;4318:9;:30::i;:::-;4311:37;4032:321;-1:-1:-1;;;;;4032:321:0:o;4358:323::-;4453:4;4464:35;4474:10;4486:3;4491:7;4464:9;:35::i;:::-;-1:-1:-1;4545:16:0;;4574:9;;;;4570:91;;4599:55;;-1:-1:-1;;;4599:55:0;;-1:-1:-1;;;;;4599:27:0;;;;;:55;;4627:10;;4639:7;;4648:5;;;;4599:55;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4591:64;;;;;;-1:-1:-1;4672:4:0;;4358:323;-1:-1:-1;;;;;4358:323:0:o;3350:20::-;;;;;;;:::i;3766:124::-;3832:4;3850:35;3860:10;3872:3;3877:7;3850:9;:35::i;5034:212::-;-1:-1:-1;;;;;5132:18:0;;;5121:4;5132:18;;;:10;:18;;;;;;;;:38;;;;;;:10;:28;;;:38;;;;;:48;;;5190:35;1342:25:1;;;5121:4:0;;5132:38;:18;5190:35;;1315:18:1;5190:35:0;;;;;;;;-1:-1:-1;5237:4:0;5034:212;;;;;:::o;5252:294::-;-1:-1:-1;;;;;4856:17:0;;5334:4;4856:17;;;:10;:17;;;;;:25;5389:7;-1:-1:-1;5369:27:0;5361:36;;;;;;-1:-1:-1;;;;;5403:17:0;;;;;;;:10;:17;;;;;;:36;;;;;;;5445:15;;;;;;;;;;:34;;;;;;5490:29;;;;;;5432:7;1342:25:1;;1330:2;1315:18;;1196:177;14:548;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;298:3;483:1;478:2;469:6;458:9;454:22;450:31;443:42;553:2;546;542:7;537:2;529:6;525:15;521:29;510:9;506:45;502:54;494:62;;;;14:548;;;;:::o;567:173::-;635:20;;-1:-1:-1;;;;;684:31:1;;674:42;;664:70;;730:1;727;720:12;664:70;567:173;;;:::o;745:254::-;813:6;821;874:2;862:9;853:7;849:23;845:32;842:52;;;890:1;887;880:12;842:52;913:29;932:9;913:29;:::i;:::-;903:39;989:2;974:18;;;;961:32;;-1:-1:-1;;;745:254:1:o;1378:328::-;1455:6;1463;1471;1524:2;1512:9;1503:7;1499:23;1495:32;1492:52;;;1540:1;1537;1530:12;1492:52;1563:29;1582:9;1563:29;:::i;:::-;1553:39;;1611:38;1645:2;1634:9;1630:18;1611:38;:::i;:::-;1601:48;;1696:2;1685:9;1681:18;1668:32;1658:42;;1378:328;;;;;:::o;1900:733::-;1988:6;1996;2004;2012;2065:2;2053:9;2044:7;2040:23;2036:32;2033:52;;;2081:1;2078;2071:12;2033:52;2104:29;2123:9;2104:29;:::i;:::-;2094:39;;2180:2;2169:9;2165:18;2152:32;2142:42;;2235:2;2224:9;2220:18;2207:32;2258:18;2299:2;2291:6;2288:14;2285:34;;;2315:1;2312;2305:12;2285:34;2353:6;2342:9;2338:22;2328:32;;2398:7;2391:4;2387:2;2383:13;2379:27;2369:55;;2420:1;2417;2410:12;2369:55;2460:2;2447:16;2486:2;2478:6;2475:14;2472:34;;;2502:1;2499;2492:12;2472:34;2547:7;2542:2;2533:6;2529:2;2525:15;2521:24;2518:37;2515:57;;;2568:1;2565;2558:12;2515:57;1900:733;;;;-1:-1:-1;;2599:2:1;2591:11;;-1:-1:-1;;;1900:733:1:o;2638:186::-;2697:6;2750:2;2738:9;2729:7;2725:23;2721:32;2718:52;;;2766:1;2763;2756:12;2718:52;2789:29;2808:9;2789:29;:::i;2829:260::-;2897:6;2905;2958:2;2946:9;2937:7;2933:23;2929:32;2926:52;;;2974:1;2971;2964:12;2926:52;2997:29;3016:9;2997:29;:::i;:::-;2987:39;;3045:38;3079:2;3068:9;3064:18;3045:38;:::i;:::-;3035:48;;2829:260;;;;;:::o;3094:380::-;3173:1;3169:12;;;;3216;;;3237:61;;3291:4;3283:6;3279:17;3269:27;;3237:61;3344:2;3336:6;3333:14;3313:18;3310:38;3307:161;;3390:10;3385:3;3381:20;3378:1;3371:31;3425:4;3422:1;3415:15;3453:4;3450:1;3443:15;3307:161;;3094:380;;;:::o;3479:225::-;3546:9;;;3567:11;;;3564:134;;;3620:10;3615:3;3611:20;3608:1;3601:31;3655:4;3652:1;3645:15;3683:4;3680:1;3673:15;3709:559;-1:-1:-1;;;;;3922:32:1;;3904:51;;3986:2;3971:18;;3964:34;;;4034:2;4029;4014:18;;4007:30;;;4053:18;;4046:34;;;4073:6;4123;4117:3;4102:19;;4089:49;4188:1;4158:22;;;4182:3;4154:32;;;4147:43;;;;4251:2;4230:15;;;-1:-1:-1;;4226:29:1;4211:45;4207:55;;3709:559;-1:-1:-1;;;3709:559:1:o;4273:277::-;4340:6;4393:2;4381:9;4372:7;4368:23;4364:32;4361:52;;;4409:1;4406;4399:12;4361:52;4441:9;4435:16;4494:5;4487:13;4480:21;4473:5;4470:32;4460:60;;4516:1;4513;4506:12;4460:60;4539:5;4273:277;-1:-1:-1;;;4273:277:1:o

ipfs://02236e6fa9852094b36d343913b397d8bc5955f8a9a2b845275b2647e50ee860