Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• interface IUniswapV2Factory
•    - function feeTo()
•    - function feeToSetter()
•    - function getPair(address tokenA, addr ...
•    - function allPairs(uint)
•    - function allPairsLength()
•    - function createPair(address tokenA, a ...
•    - function setFeeTo(address)
•    - function setFeeToSetter(address)
• interface IUniswapV2Router01
•    - function factory()
•    - function WETH()
•    - function addLiquidity(
•    - function addLiquidityETH(
•    - function removeLiquidity(
•    - function removeLiquidityETH(
•    - function removeLiquidityWithPermit(
•    - function removeLiquidityETHWithPermit ...
•    - function swapExactTokensForTokens(
•    - function swapTokensForExactTokens(
•    - function swapExactETHForTokens(uint a ...
•    - function swapTokensForExactETH(uint a ...
•    - function swapExactTokensForETH(uint a ...
•    - function swapETHForExactTokens(uint a ...
•    - function quote(uint amountA, uint res ...
•    - function getAmountOut(uint amountIn, ...
•    - function getAmountIn(uint amountOut, ...
•    - function getAmountsOut(uint amountIn, ...
•    - function getAmountsIn(uint amountOut, ...
• interface IUniswapV2Router02 is IUnis ...
•    - function removeLiquidityETHSupporting ...
•    - function removeLiquidityETHWithPermit ...
•    - function swapExactTokensForTokensSupp ...
•    - function swapExactETHForTokensSupport ...
•    - function swapExactTokensForETHSupport ...
•  contract UniTradeIncinerator *
•    - function burn()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-10-06
*/

// Dependency file: @openzeppelin/contracts/math/SafeMath.sol

// SPDX-License-Identifier: MIT

// pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}


// Dependency file: @uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol

// pragma solidity >=0.5.0;

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}


// Dependency file: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol

// pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}


// Dependency file: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol

// pragma solidity >=0.6.2;

// import '/Users/train/Documents/Work/Decent/unitrade/unitrade/node_modules/@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol';

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}


// Root file: contracts/UniTradeIncinerator.sol

pragma solidity ^0.6.6;

// import "@openzeppelin/contracts/math/SafeMath.sol";
// import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
// import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";

contract UniTradeIncinerator {
    using SafeMath for uint256;

    uint256 constant UINT256_MAX = ~uint256(0);
    IUniswapV2Router02 public immutable uniswapV2Router;
    address public immutable unitrade;
    uint256 lastIncinerated;

    event UniTradeToBurn(uint256 etherIn);
    event UniTradeBurned(uint256 etherIn, uint256 tokensBurned);

    constructor(IUniswapV2Router02 _uniswapV2Router, address _unitrade) public {
        uniswapV2Router = _uniswapV2Router;
        unitrade = _unitrade;
        lastIncinerated = block.timestamp;
    }

    function burn() external payable returns (bool) {
        require(msg.value > 0, "Nothing to burn");

        emit UniTradeToBurn(msg.value);

        if (block.timestamp < lastIncinerated + 1 days) {
            return true;
        }

        lastIncinerated = block.timestamp;

        address[] memory _tokenPair = new address[](2);
        _tokenPair[0] = uniswapV2Router.WETH();
        _tokenPair[1] = unitrade;

        uint256[] memory _swapResult = uniswapV2Router.swapExactETHForTokens{
            value: address(this).balance
        }(
            0, // take any
            _tokenPair,
            address(this),
            UINT256_MAX
        );

        emit UniTradeBurned(_swapResult[0], _swapResult[1]);

        return true;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IUniswapV2Router02","name":"_uniswapV2Router","type":"address"},{"internalType":"address","name":"_unitrade","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"etherIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokensBurned","type":"uint256"}],"name":"UniTradeBurned","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"etherIn","type":"uint256"}],"name":"UniTradeToBurn","type":"event"},{"inputs":[],"name":"burn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unitrade","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d0000000000000000000000006f87d756daf0503d08eb8993686c7fc01dc44fb1

-----Decoded View---------------
Arg [0] : _uniswapV2Router (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
Arg [1] : _unitrade (address): 0x6F87D756DAf0503d08Eb8993686c7Fc01Dc44fB1

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [1] : 0000000000000000000000006f87d756daf0503d08eb8993686c7fc01dc44fb1

11743:1355:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11863:51;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;11863:51:0;;;;;;;;;;;;;;12316:779;;;:::i;:::-;;;;;;;;;;;;;;;;;;11921:33;;;;;;;;;;;;;:::i;11863:51::-;;;:::o;12316:779::-;12358:4;12395:1;12383:9;:13;12375:41;;;;;-1:-1:-1;;;12375:41:0;;;;;;;;;;;;-1:-1:-1;;;12375:41:0;;;;;;;;;;;;;;;12434:25;;;12449:9;12434:25;;;;;;;;;;;;;12494:15;;12512:6;12494:24;12476:15;:42;12472:86;;;-1:-1:-1;12542:4:0;12535:11;;12472:86;12588:15;12570;:33;12646:16;;;12660:1;12646:16;;;12616:27;12646:16;;;;;12616:27;12646:16;;;;;;;;;;-1:-1:-1;12646:16:0;12616:46;;12689:15;-1:-1:-1;;;;;12689:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12689:22:0;12673:13;;:10;;12684:1;;12673:13;;;;;;;;;:38;-1:-1:-1;;;;;12673:38:0;;;-1:-1:-1;;;;;12673:38:0;;;;;12738:8;12722:10;12733:1;12722:13;;;;;;;;;;;;;:24;-1:-1:-1;;;;;12722:24:0;;;-1:-1:-1;;;;;12722:24:0;;;;;12759:28;12790:15;-1:-1:-1;;;;;12790:37:0;;12849:21;12896:1;12924:10;12957:4;11854:1;11845:11;12790:209;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;12790:209:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;12790:209:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12790:209:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12759:240;;13017:46;13032:11;13044:1;13032:14;;;;;;;;;;;;;;13048:11;13060:1;13048:14;;;;;;;;;;;;;;13017:46;;;;;;;;;;;;;;;;;;;;;;;;13083:4;13076:11;;;;12316:779;;:::o;11921:33::-;;;:::o

ipfs://038539ab33ef56e3223998b7330b6def39c45b71a77d9c284e7e14c4f2487a0d