{{ "language": "Solidity", "sources": { "contracts/Detf.sol": { "content": "// SPDX-License-Identifier: Unlicensed\npragma solidity >=0.8.4;\n\nimport '@openzeppelin/contracts/utils/math/SafeMath.sol';\nimport \"./DetfReflect.sol\";\n\n\n/// @title Detf smart contract\n/// @author D-ETF.com\n/// @notice DETF ERC20 token contract\n/// @dev Deployable smart contract, which includes the governance logic (voting, delegating and etc).\ncontract Detf is DetfReflect {\n using SafeMath for uint256;\n\n /// @notice A record of each accounts delegate\n mapping(address => address) public delegates;\n\n /// @notice A checkpoint for marking number of votes from a given block\n struct Checkpoint {\n uint256 fromBlock;\n uint256 votes;\n }\n\n /// @notice A record of votes checkpoints for each account, by index\n mapping(address => mapping(uint256 => Checkpoint)) public checkpoints;\n\n /// @notice The number of checkpoints for each account\n mapping(address => uint256) public numCheckpoints;\n\n mapping(address => uint256) public delegatorVotes;\n\n /// @notice The EIP-712 typehash for the contract's domain\n bytes32 public constant DOMAIN_TYPEHASH = keccak256(\"EIP712Domain(string name,uint256 chainId,address verifyingContract)\");\n\n /// @notice The EIP-712 typehash for the delegation struct used by the contract\n bytes32 public constant DELEGATION_TYPEHASH = keccak256(\"Delegation(address delegatee,uint256 nonce,uint256 expiry)\");\n\n /// @notice A record of states for signing / validating signatures\n mapping(address => uint256) public nonces;\n\n /// @notice An event thats emitted when an account changes its delegate\n event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);\n\n /// @notice An event thats emitted when a delegate account's vote balance changes\n event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);\n\n\n // --------------------\n // CONSTRUCTOR\n // --------------------\n\n\n constructor (address uniswapV2Router_, address usdc_) DetfReflect(uniswapV2Router_, usdc_) {\n // Silence\n }\n\n fallback () external payable {\n // Empty fallback\n }\n\n receive () external payable {\n // Empty receive\n }\n\n\n // --------------------\n // SETTERS\n // --------------------\n\n\n /**\n * @notice Delegate votes from `msg.sender` to `delegatee`\n * @param delegatee The address to delegate votes to\n */\n function delegate(address delegatee) public {\n return _delegate(msg.sender, delegatee);\n }\n\n function _transfer(address sender, address recipient, uint256 amount) internal virtual override {\n _moveDelegates(delegates[sender], delegates[recipient], amount, sender, true);\n super._transfer(sender, recipient, amount);\n }\n\n /**\n * @notice Delegates votes from signatory to `delegatee`\n * @param delegatee The address to delegate votes to\n * @param nonce The contract state required to match the signature\n * @param expiry The time at which to expire the signature\n * @param v The recovery byte of the signature\n * @param r Half of the ECDSA signature pair\n * @param s Half of the ECDSA signature pair\n */\n function delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) public {\n bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name())), block.chainid, address(this)));\n bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));\n bytes32 digest = keccak256(abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash));\n address signatory = ecrecover(digest, v, r, s);\n require(signatory != address(0), \"delegateBySig: Invalid signature!\");\n require(nonce == nonces[signatory]++, \"delegateBySig: Invalid nonce!\");\n require(block.timestamp <= expiry, \"delegateBySig: Signature expired!\");\n return _delegate(signatory, delegatee);\n }\n\n\n // --------------------\n // GETTERS\n // --------------------\n\n\n /**\n * @notice Gets the current votes balance for `account`\n * @param account The address to get votes balance\n * @return The number of current votes for `account`\n */\n function getCurrentVotes(address account) external view returns (uint256) {\n uint256 nCheckpoints = numCheckpoints[account];\n return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;\n }\n\n /**\n * @notice Determine the prior number of votes for an account as of a block number\n * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.\n * @param account The address of the account to check\n * @param blockNumber The block number to get the vote balance at\n * @return The number of votes the account had as of the given block\n */\n function getPriorVotes(address account, uint256 blockNumber) public view returns (uint256) {\n require(blockNumber < block.number, \"getPriorVotes: Not yet determined!\");\n\n uint256 nCheckpoints = numCheckpoints[account];\n if (nCheckpoints == 0) {\n return 0;\n }\n\n // First check most recent balance\n if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {\n return checkpoints[account][nCheckpoints - 1].votes;\n }\n\n // Next check implicit zero balance\n if (checkpoints[account][0].fromBlock > blockNumber) {\n return 0;\n }\n\n uint256 lower = 0;\n uint256 upper = nCheckpoints - 1;\n while (upper > lower) {\n uint256 center = upper - (upper - lower) / 2; // ceil, avoiding overflow\n Checkpoint memory cp = checkpoints[account][center];\n if (cp.fromBlock == blockNumber) {\n return cp.votes;\n } else if (cp.fromBlock < blockNumber) {\n lower = center;\n } else {\n upper = center - 1;\n }\n }\n return checkpoints[account][lower].votes;\n }\n\n\n // --------------------\n // INTERNAL\n // --------------------\n\n\n /// @dev Delegate votes from the sender to the delegatee.\n /// Users can delegate to 1 address at a time, and the number of votes added to the delegatee’s vote count is equivalent to the balance of DETF in the user’s account.\n /// Votes are delegated from the current block and onward, until the sender delegates again, or transfers their DETF.\n function _delegate(address delegator, address delegatee) internal {\n address currentDelegate = delegates[delegator];\n uint256 delegatorBalance = balanceOf(delegator);\n delegates[delegator] = delegatee;\n \n emit DelegateChanged(delegator, currentDelegate, delegatee);\n\n _moveDelegates(currentDelegate, delegatee, delegatorBalance, delegator, false);\n }\n\n function _moveDelegates(address srcRep, address dstRep, uint256 amount, address senderVotes, bool isTransfer) internal {\n uint256 delegateVotes = delegatorVotes[senderVotes];\n uint256 delegatorBalance = balanceOf(senderVotes);\n\n if (srcRep != dstRep && amount > 0) {\n if (srcRep != address(0)) {\n uint256 srcRepNum = numCheckpoints[srcRep];\n uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;\n uint256 srcRepNew;\n if (isTransfer) {\n if (amount > delegateVotes) {\n delegatorVotes[senderVotes] = delegatorBalance.sub(amount);\n srcRepNew = srcRepOld.add(delegatorVotes[senderVotes]).sub(delegateVotes);\n } else {\n delegatorVotes[senderVotes] = delegateVotes - amount;\n srcRepNew = srcRepOld.sub(amount);\n }\n } else {\n if (delegateVotes != amount) {\n delegatorVotes[senderVotes] = amount;\n srcRepNew = srcRepOld.sub(delegateVotes);\n } else {\n srcRepNew = srcRepOld.sub(amount);\n }\n }\n _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);\n } else {\n delegatorVotes[senderVotes] = amount;\n }\n\n if (dstRep != address(0)) {\n uint256 dstRepNum = numCheckpoints[dstRep];\n uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;\n uint256 dstRepNew = dstRepOld.add(amount);\n if (isTransfer) delegatorVotes[dstRep] += amount;\n _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);\n }\n } else if (!isTransfer && srcRep == dstRep && amount != delegateVotes) {\n uint256 dstRepNum = numCheckpoints[dstRep];\n uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;\n uint256 dstRepNew = dstRepOld.sub(delegateVotes).add(amount);\n delegatorVotes[senderVotes] = amount;\n _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);\n }\n }\n\n function _writeCheckpoint(address delegatee, uint256 nCheckpoints, uint256 oldVotes, uint256 newVotes) internal {\n uint256 blockNumber = block.number;\n\n if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {\n checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;\n } else {\n checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);\n numCheckpoints[delegatee] = nCheckpoints + 1;\n }\n\n emit DelegateVotesChanged(delegatee, oldVotes, newVotes);\n }\n}" }, "@openzeppelin/contracts/utils/math/SafeMath.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)\n\npragma solidity ^0.8.0;\n\n// CAUTION\n// This version of SafeMath should only be used with Solidity 0.8 or later,\n// because it relies on the compiler's built in overflow checks.\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations.\n *\n * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler\n * now has built in overflow checking.\n */\nlibrary SafeMath {\n /**\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n uint256 c = a + b;\n if (c < a) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b > a) return (false, 0);\n return (true, a - b);\n }\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n *\n * _Available since v3.4._\n */\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n // benefit is lost if 'b' is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) return (true, 0);\n uint256 c = a * b;\n if (c / a != b) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a / b);\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n *\n * _Available since v3.4._\n */\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a % b);\n }\n }\n\n /**\n * @dev Returns the addition of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `+` operator.\n *\n * Requirements:\n *\n * - Addition cannot overflow.\n */\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\n return a + b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return a - b;\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `*` operator.\n *\n * Requirements:\n *\n * - Multiplication cannot overflow.\n */\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n return a * b;\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator.\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\n return a / b;\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting when dividing by zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return a % b;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n * overflow (when the result is negative).\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {trySub}.\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(\n uint256 a,\n uint256 b,\n string memory errorMessage\n ) internal pure returns (uint256) {\n unchecked {\n require(b <= a, errorMessage);\n return a - b;\n }\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(\n uint256 a,\n uint256 b,\n string memory errorMessage\n ) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a / b;\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * reverting with custom message when dividing by zero.\n *\n * CAUTION: This function is deprecated because it requires allocating memory for the error\n * message unnecessarily. For custom revert reasons use {tryMod}.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(\n uint256 a,\n uint256 b,\n string memory errorMessage\n ) internal pure returns (uint256) {\n unchecked {\n require(b > 0, errorMessage);\n return a % b;\n }\n }\n}\n" }, "contracts/DetfReflect.sol": { "content": "// SPDX-License-Identifier: Unlicensed\npragma solidity >=0.8.4;\n\nimport '@openzeppelin/contracts/utils/Address.sol';\nimport '@openzeppelin/contracts/access/Ownable.sol';\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\nimport '@openzeppelin/contracts/utils/math/SafeMath.sol';\nimport '@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol';\nimport { IUniswapV2Router02, IUniswapV2Factory, IUniswapV2Pair } from './interfaces/IUniswap.sol';\n\n/// @title DetfReflect smart contract\n/// @author D-ETF.com\n/// @notice This contract included in the main Detf smart contract\n/// @dev Contains the main logic of re-balancing and fees.\n/// The contract was forked from reflect.finance project, and includes changes related to AMM swap fees.\ncontract DetfReflect is Ownable, IERC20, IERC20Metadata {\n using SafeMath for uint256;\n using Address for address;\n\n string private constant _NAME = 'DETF token';\n string private constant _SYMBOL = 'DETF';\n uint8 private constant _DECIMALS = 18;\n\n uint256 private constant _MAX = ~uint256(0);\n uint256 private constant _HOLD_FEE = 150; // 1.5% of tokens goes to existing holders\n uint256 private _holdFee = _HOLD_FEE;\n uint256 private constant _TREASURE_FEE = 150; // 1.5% of tokens goes to treasury contract\n uint256 private _treasureFee = _TREASURE_FEE;\n uint256 private constant _HUNDRED_PERCENT = 10000; // 100%\n uint256 private _withdrawableAmount = 100000 * (10 ** _DECIMALS); // When 100k DEFT collected, it should be swapped to USDC automatically\n\n uint256 private _tTotal = 100000000 * (10 ** _DECIMALS); // 100 mln tokens\n uint256 private _rTotal = (_MAX - (_MAX % _tTotal));\n uint256 private _tHoldFeeTotal;\n uint256 private _slippage;\n\n bool private _swapping;\n bool public inSwapAndLiquify;\n address public pool;\n address public uniswapV2UsdcPair;\n IUniswapV2Router02 public uniswapV2Router;\n IERC20 public usdc;\n\n address[] private _excluded;\n mapping (address => bool) private _isExcluded;\n mapping (address => bool) private _isAmm;\n\n mapping (address => uint256) private _rOwned;\n mapping (address => uint256) private _tOwned;\n mapping (address => mapping (address => uint256)) private _allowances;\n\n event Log(string message);\n event AmmAdded(address target);\n event AmmRemoved(address target);\n event ExcludedAdded(address target);\n event ExcludedRemoved(address target);\n event PoolAddressChanged(address newPool);\n event TreasureWithdraw(address receiver, uint256 amount);\n event TreasureFeeAdded(uint256 totalBalance, uint256 tfee, uint256 rFee);\n event UsdcReceived(address receiver, uint256 detfSwapped, uint256 usdcReceived);\n\n constructor (address uniswapV2Router_, address usdc_) {\n _rOwned[_msgSender()] = _rTotal;\n usdc = IERC20(usdc_);\n uniswapV2Router = IUniswapV2Router02(uniswapV2Router_);\n uniswapV2UsdcPair = address(IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), address(usdc)));\n excludeAccountFromRewards(msg.sender);\n excludeAccountFromRewards(address(this));\n excludeAccountFromRewards(uniswapV2UsdcPair);\n addToAmmList(uniswapV2UsdcPair);\n emit Transfer(address(0), _msgSender(), _tTotal);\n }\n\n // --------------------\n // SETTERS (Ownable)\n // --------------------\n\n modifier lockTheSwap {\n inSwapAndLiquify = true;\n _;\n inSwapAndLiquify = false;\n }\n\n function excludeAccountFromRewards(address account) public onlyOwner {\n require(!_isExcluded[account], 'excludeAccountFromRewards: Account is already excluded');\n\n if(_rOwned[account] > 0) {\n _tOwned[account] = tokenFromReflection(_rOwned[account]);\n }\n\n _isExcluded[account] = true;\n _excluded.push(account);\n\n emit ExcludedAdded(account);\n }\n\n function includeAccountForRewards(address account) public onlyOwner {\n require(_isExcluded[account], 'includeAccountForRewards: Account is already excluded');\n require(account != address(this), 'includeAccountForRewards: Can not include token address');\n\n for (uint256 i = 0; i < _excluded.length; i++) {\n if (_excluded[i] == account) {\n _excluded[i] = _excluded[_excluded.length - 1];\n _tOwned[account] = 0;\n _isExcluded[account] = false;\n _excluded.pop();\n break;\n }\n }\n\n emit ExcludedRemoved(account);\n }\n\n function addToAmmList(address account) public onlyOwner {\n require(account != address(0), 'addToAmmList: Incorrect address!');\n\n _isAmm[account] = true;\n\n emit AmmAdded(account);\n }\n\n function removeFromAmmList(address account) public onlyOwner {\n require(account != address(0), 'removeFromAmmList: Incorrect address!');\n\n _isAmm[account] = false;\n\n emit AmmRemoved(account);\n }\n\n function changeWithdrawLimit(uint256 newLimit) public onlyOwner {\n _withdrawableAmount = newLimit;\n }\n\n function withdraw(address recipient, uint256 amount) public onlyOwner {\n uint256 balance = balanceOf(address(this));\n require(balance >= _withdrawableAmount, 'withdraw: Balance is less from required limit');\n require(amount <= balance, 'withdraw: Amount is more then balance');\n\n _transfer(address(this), recipient, amount);\n\n emit TreasureWithdraw(recipient, amount);\n }\n\n function setPoolAddress(address pool_) public onlyOwner {\n require(pool_ != address(this), 'setPoolAddress: Zero address not allowed');\n pool = pool_;\n\n emit PoolAddressChanged(pool);\n }\n\n function setSlippage(uint256 slippage) public onlyOwner returns (bool) {\n _slippage = slippage;\n return true;\n }\n\n // --------------------\n // SETTERS\n // --------------------\n\n\n function transfer(address recipient, uint256 amount) public override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n\n return true;\n }\n\n function approve(address spender, uint256 amount) public override returns (bool) {\n _approve(_msgSender(), spender, amount);\n\n return true;\n }\n\n function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {\n _transfer(sender, recipient, amount);\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, 'transferFrom: Transfer amount exceeds allowance'));\n\n return true;\n }\n\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));\n\n return true;\n }\n\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, 'decreaseAllowance: decreased allowance below zero'));\n\n return true;\n }\n\n function reflect(uint256 tAmount) public {\n address sender = _msgSender();\n require(!_isExcluded[sender], 'reflect: Excluded addresses cannot call this function');\n\n (uint256 rAmount,,,,,) = _getValues(tAmount);\n _rOwned[sender] = _rOwned[sender].sub(rAmount);\n _rTotal = _rTotal.sub(rAmount);\n _tHoldFeeTotal = _tHoldFeeTotal.add(tAmount);\n }\n\n\n // --------------------\n // GETTERS\n // --------------------\n\n\n function name() public pure override returns (string memory) {\n return _NAME;\n }\n\n function symbol() public pure override returns (string memory) {\n return _SYMBOL;\n }\n\n function decimals() public pure override returns (uint8) {\n return _DECIMALS;\n }\n\n function totalSupply() public view override returns (uint256) {\n return _tTotal;\n }\n\n function balanceOf(address account) public view override returns (uint256) {\n if (account == address(this) || _isExcluded[account]) return _tOwned[account];\n else return tokenFromReflection(_rOwned[account]);\n }\n\n function allowance(address owner, address spender) public view override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n function isExcluded(address account) public view returns (bool) {\n return _isExcluded[account];\n }\n\n function isAmmContract(address account) public view returns (bool) {\n return _isAmm[account];\n }\n\n function totalFees() public view returns (uint256) {\n return _tHoldFeeTotal;\n }\n\n function getSlippage() public view returns (uint256) {\n return _slippage;\n }\n\n function getHoldingFee() public pure returns (uint256) {\n return _HOLD_FEE;\n }\n\n function getTreasureFee() public pure returns (uint256) {\n return _TREASURE_FEE;\n }\n\n function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns (uint256) {\n require(tAmount <= _tTotal, 'reflectionFromToken: Amount must be less than supply');\n\n if (!deductTransferFee) {\n (uint256 rAmount,,,,,) = _getValues(tAmount);\n return rAmount;\n } else {\n (,uint256 rTransferAmount,,,,) = _getValues(tAmount);\n return rTransferAmount;\n }\n }\n\n function tokenFromReflection(uint256 rAmount) public view returns (uint256) {\n require(rAmount <= _rTotal, 'tokenFromReflection: Amount must be less than total reflections');\n\n uint256 currentRate = _getRate();\n return rAmount.div(currentRate);\n }\n\n\n // --------------------\n // INTERNAL\n // --------------------\n\n\n function _approve(address owner, address spender, uint256 amount) private {\n require(owner != address(0), '_approve: Approve from the zero address');\n require(spender != address(0), '_approve: Approve to the zero address');\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n require(sender != address(0), '_transfer: Transfer from the zero address');\n require(recipient != address(0), '_transfer: Transfer to the zero address');\n require(amount > 0, '_transfer: Transfer amount must be greater than zero');\n require(balanceOf(sender) >= amount, \"_transfer: The balance is insufficient\");\n bool cutFee = (_isAmm[recipient] || _isAmm[sender]) && !_swapping;\n if (\n _tOwned[address(this)] >= _withdrawableAmount && \n msg.sender != uniswapV2UsdcPair && \n !inSwapAndLiquify\n ) {\n _swapAndSend();\n }\n // Remove all fees, if it is not swap transaction\n if (!cutFee) {\n _disableFee();\n }\n\n if (_isExcluded[sender] && !_isExcluded[recipient]) {\n _transferFromExcluded(sender, recipient, amount);\n } else if (!_isExcluded[sender] && _isExcluded[recipient]) {\n _transferToExcluded(sender, recipient, amount);\n } else if (!_isExcluded[sender] && !_isExcluded[recipient]) {\n _transferStandard(sender, recipient, amount);\n } else if (_isExcluded[sender] && _isExcluded[recipient]) {\n _transferBothExcluded(sender, recipient, amount);\n } else {\n _transferStandard(sender, recipient, amount);\n }\n\n // Reset the fees back again\n if (!cutFee) {\n _enableFee();\n }\n }\n\n function _transferStandard(address sender, address recipient, uint256 tAmount) private {\n (\n uint256 rAmount,\n uint256 rTransferAmount,\n uint256 rFee,\n uint256 tTransferAmount,\n uint256 tHoldFee,\n uint256 tTreasureFee\n ) = _getValues(tAmount);\n\n _rOwned[sender] = _rOwned[sender].sub(rAmount);\n _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);\n\n _claimTreasureFee(tTreasureFee);\n _reflectFee(rFee, tHoldFee);\n\n emit Transfer(sender, recipient, tTransferAmount);\n }\n\n function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {\n (\n uint256 rAmount,\n uint256 rTransferAmount,\n uint256 rFee,\n uint256 tTransferAmount,\n uint256 tHoldFee,\n uint256 tTreasureFee\n ) = _getValues(tAmount);\n\n _rOwned[sender] = _rOwned[sender].sub(rAmount);\n _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);\n _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);\n\n _claimTreasureFee(tTreasureFee);\n _reflectFee(rFee, tHoldFee);\n\n emit Transfer(sender, recipient, tTransferAmount);\n }\n\n function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {\n (\n uint256 rAmount,\n uint256 rTransferAmount,\n uint256 rFee,\n uint256 tTransferAmount,\n uint256 tHoldFee,\n uint256 tTreasureFee\n ) = _getValues(tAmount);\n\n _tOwned[sender] = _tOwned[sender].sub(tAmount);\n _rOwned[sender] = _rOwned[sender].sub(rAmount);\n _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);\n\n _claimTreasureFee(tTreasureFee);\n _reflectFee(rFee, tHoldFee);\n\n emit Transfer(sender, recipient, tTransferAmount);\n }\n\n function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {\n (\n uint256 rAmount,\n uint256 rTransferAmount,\n uint256 rFee,\n uint256 tTransferAmount,\n uint256 tHoldFee,\n uint256 tTreasureFee\n ) = _getValues(tAmount);\n\n _tOwned[sender] = _tOwned[sender].sub(tAmount);\n _rOwned[sender] = _rOwned[sender].sub(rAmount);\n _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);\n _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);\n\n _claimTreasureFee(tTreasureFee);\n _reflectFee(rFee, tHoldFee);\n\n emit Transfer(sender, recipient, tTransferAmount);\n }\n\n function _reflectFee(uint256 rFee, uint256 tHoldFee) private {\n _rTotal = _rTotal.sub(rFee);\n _tHoldFeeTotal = _tHoldFeeTotal.add(tHoldFee);\n }\n\n function _disableFee() private {\n if (_holdFee == 0 && _treasureFee == 0) return;\n\n _swapping = true;\n _holdFee = 0;\n _treasureFee = 0;\n }\n\n function _enableFee() private {\n _swapping = false;\n _holdFee = _HOLD_FEE;\n _treasureFee = _TREASURE_FEE;\n }\n\n function _claimTreasureFee(uint256 tTreasureFee) private {\n uint256 currentRate = _getRate();\n uint256 rTreasureFee = tTreasureFee.mul(currentRate);\n\n _rOwned[address(this)] = _rOwned[address(this)].add(rTreasureFee);\n _tOwned[address(this)] = _tOwned[address(this)].add(tTreasureFee);\n\n emit TreasureFeeAdded(balanceOf(address(this)), tTreasureFee, rTreasureFee);\n }\n\n function _swapAndSend() private lockTheSwap {\n _swapTokensForUSDC(_withdrawableAmount);\n uint256 usdcBalance = usdc.balanceOf(address(this));\n usdc.transfer(pool, usdcBalance);\n emit UsdcReceived(pool, _withdrawableAmount, usdcBalance);\n }\n\n function _swapTokensForUSDC(uint256 tokenAmount) private {\n require(pool != address(0), \"Pool not found\");\n (uint256 reserveIn, uint256 reserveOut,) = IUniswapV2Pair(uniswapV2UsdcPair).getReserves();\n uint256 amountOut; \n try uniswapV2Router.getAmountOut(tokenAmount, reserveIn, reserveOut) {\n amountOut = uniswapV2Router.getAmountOut(tokenAmount, reserveIn, reserveOut);\n } catch {\n _approve(address(this), address(uniswapV2Router), 0);\n emit Log(\"DETF->USDC swap failed\");\n }\n uint256 minAmountOut = amountOut.sub(amountOut.mul(_slippage).div(_HUNDRED_PERCENT));\n address[] memory path = new address[](2);\n path[0] = address(this);\n path[1] = address(usdc);\n _approve(address(this), address(uniswapV2Router), tokenAmount);\n try uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(\n tokenAmount,\n minAmountOut,\n path,\n pool,\n block.timestamp\n ) {\n emit Log(\"DETF->USDC swap success\");\n } catch {\n _approve(address(this), address(uniswapV2Router), 0);\n emit Log(\"DETF->USDC swap failed\");\n }\n }\n\n function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {\n (uint256 tTransferAmount, uint256 tHoldFee, uint256 tTreasureFee) = _getTValues(tAmount);\n (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tHoldFee, tTreasureFee);\n\n return (\n rAmount,\n rTransferAmount,\n rFee,\n tTransferAmount,\n tHoldFee,\n tTreasureFee\n );\n }\n\n function _getReflectAmount(uint256 tAmount) private view returns (uint256) {\n uint256 currentRate = _getRate();\n uint256 rAmount = tAmount.mul(currentRate);\n\n return rAmount;\n }\n\n function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {\n // Cut the holding and treasure fees from the main amount (only if swapping)\n uint256 tHoldFee = tAmount.mul(_holdFee).div(_HUNDRED_PERCENT);\n uint256 tTreasureFee = tAmount.mul(_treasureFee).div(_HUNDRED_PERCENT);\n uint256 tTransferAmount = tAmount.sub(tHoldFee).sub(tTreasureFee);\n\n return (\n tTransferAmount,\n tHoldFee,\n tTreasureFee\n );\n }\n\n function _getRValues(uint256 tAmount, uint256 tHoldFee, uint256 tTreasureFee) private view returns (uint256, uint256, uint256) {\n uint256 currentRate = _getRate();\n uint256 rAmount = tAmount.mul(currentRate);\n uint256 rFee = tHoldFee.mul(currentRate);\n uint256 rTreasureFee = tTreasureFee.mul(currentRate);\n uint256 rTransferAmount = rAmount.sub(rFee).sub(rTreasureFee);\n\n return (\n rAmount,\n rTransferAmount,\n rFee\n );\n }\n\n function _getRate() private view returns (uint256) {\n (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();\n\n return rSupply.div(tSupply);\n }\n\n function _getCurrentSupply() private view returns (uint256, uint256) {\n uint256 rSupply = _rTotal;\n uint256 tSupply = _tTotal;\n for (uint256 i = 0; i < _excluded.length; i++) {\n if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);\n rSupply = rSupply.sub(_rOwned[_excluded[i]]);\n tSupply = tSupply.sub(_tOwned[_excluded[i]]);\n }\n\n if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);\n\n return (\n rSupply,\n tSupply\n );\n }\n}" }, "@openzeppelin/contracts/utils/Address.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(isContract(target), \"Address: delegate call to non-contract\");\n\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" }, "@openzeppelin/contracts/access/Ownable.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor() {\n _transferOwnership(_msgSender());\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n _;\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n _transferOwnership(address(0));\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n _transferOwnership(newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n}\n" }, "@openzeppelin/contracts/token/ERC20/IERC20.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(\n address from,\n address to,\n uint256 amount\n ) external returns (bool);\n}\n" }, "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n" }, "contracts/interfaces/IUniswap.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.4;\n\n\ninterface IUniswapV2Factory {\n event PairCreated(address indexed token0, address indexed token1, address pair, uint);\n\n function feeTo() external view returns (address);\n function feeToSetter() external view returns (address);\n\n function getPair(address tokenA, address tokenB) external view returns (address pair);\n function allPairs(uint) external view returns (address pair);\n function allPairsLength() external view returns (uint);\n\n function createPair(address tokenA, address tokenB) external returns (address pair);\n\n function setFeeTo(address) external;\n function setFeeToSetter(address) external;\n}\n\ninterface IUniswapV2Pair {\n event Approval(address indexed owner, address indexed spender, uint value);\n event Transfer(address indexed from, address indexed to, uint value);\n\n function name() external pure returns (string memory);\n function symbol() external pure returns (string memory);\n function decimals() external pure returns (uint8);\n function totalSupply() external view returns (uint);\n function balanceOf(address owner) external view returns (uint);\n function allowance(address owner, address spender) external view returns (uint);\n\n function approve(address spender, uint value) external returns (bool);\n function transfer(address to, uint value) external returns (bool);\n function transferFrom(address from, address to, uint value) external returns (bool);\n\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n function PERMIT_TYPEHASH() external pure returns (bytes32);\n function nonces(address owner) external view returns (uint);\n\n function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;\n\n event Mint(address indexed sender, uint amount0, uint amount1);\n event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);\n event Swap(\n address indexed sender,\n uint amount0In,\n uint amount1In,\n uint amount0Out,\n uint amount1Out,\n address indexed to\n );\n event Sync(uint112 reserve0, uint112 reserve1);\n\n function MINIMUM_LIQUIDITY() external pure returns (uint);\n function factory() external view returns (address);\n function token0() external view returns (address);\n function token1() external view returns (address);\n function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\n function price0CumulativeLast() external view returns (uint);\n function price1CumulativeLast() external view returns (uint);\n function kLast() external view returns (uint);\n\n function mint(address to) external returns (uint liquidity);\n function burn(address to) external returns (uint amount0, uint amount1);\n function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;\n function skim(address to) external;\n function sync() external;\n\n function initialize(address, address) external;\n}\n\ninterface IUniswapV2Router01 {\n function factory() external pure returns (address);\n function WETH() external pure returns (address);\n\n function addLiquidity(\n address tokenA,\n address tokenB,\n uint amountADesired,\n uint amountBDesired,\n uint amountAMin,\n uint amountBMin,\n address to,\n uint deadline\n ) external returns (uint amountA, uint amountB, uint liquidity);\n function addLiquidityETH(\n address token,\n uint amountTokenDesired,\n uint amountTokenMin,\n uint amountETHMin,\n address to,\n uint deadline\n ) external payable returns (uint amountToken, uint amountETH, uint liquidity);\n function removeLiquidity(\n address tokenA,\n address tokenB,\n uint liquidity,\n uint amountAMin,\n uint amountBMin,\n address to,\n uint deadline\n ) external returns (uint amountA, uint amountB);\n function removeLiquidityETH(\n address token,\n uint liquidity,\n uint amountTokenMin,\n uint amountETHMin,\n address to,\n uint deadline\n ) external returns (uint amountToken, uint amountETH);\n function removeLiquidityWithPermit(\n address tokenA,\n address tokenB,\n uint liquidity,\n uint amountAMin,\n uint amountBMin,\n address to,\n uint deadline,\n bool approveMax, uint8 v, bytes32 r, bytes32 s\n ) external returns (uint amountA, uint amountB);\n function removeLiquidityETHWithPermit(\n address token,\n uint liquidity,\n uint amountTokenMin,\n uint amountETHMin,\n address to,\n uint deadline,\n bool approveMax, uint8 v, bytes32 r, bytes32 s\n ) external returns (uint amountToken, uint amountETH);\n function swapExactTokensForTokens(\n uint amountIn,\n uint amountOutMin,\n address[] calldata path,\n address to,\n uint deadline\n ) external returns (uint[] memory amounts);\n function swapTokensForExactTokens(\n uint amountOut,\n uint amountInMax,\n address[] calldata path,\n address to,\n uint deadline\n ) external returns (uint[] memory amounts);\n function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)\n external\n payable\n returns (uint[] memory amounts);\n function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)\n external\n returns (uint[] memory amounts);\n function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)\n external\n returns (uint[] memory amounts);\n function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)\n external\n payable\n returns (uint[] memory amounts);\n\n function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);\n function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);\n function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);\n function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);\n function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);\n}\n\ninterface IUniswapV2Router02 is IUniswapV2Router01 {\n function removeLiquidityETHSupportingFeeOnTransferTokens(\n address token,\n uint liquidity,\n uint amountTokenMin,\n uint amountETHMin,\n address to,\n uint deadline\n ) external returns (uint amountETH);\n function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\n address token,\n uint liquidity,\n uint amountTokenMin,\n uint amountETHMin,\n address to,\n uint deadline,\n bool approveMax, uint8 v, bytes32 r, bytes32 s\n ) external returns (uint amountETH);\n\n function swapExactTokensForTokensSupportingFeeOnTransferTokens(\n uint amountIn,\n uint amountOutMin,\n address[] calldata path,\n address to,\n uint deadline\n ) external;\n function swapExactETHForTokensSupportingFeeOnTransferTokens(\n uint amountOutMin,\n address[] calldata path,\n address to,\n uint deadline\n ) external payable;\n function swapExactTokensForETHSupportingFeeOnTransferTokens(\n uint amountIn,\n uint amountOutMin,\n address[] calldata path,\n address to,\n uint deadline\n ) external;\n}" }, "@openzeppelin/contracts/utils/Context.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n}\n" } }, "settings": { "optimizer": { "enabled": true, "runs": 999999 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} } }}

Decentralized ETF

Start building on QuickNode

Source code: