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 IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transfer(address to, uint va ...
•    - function transferFrom(address from, a ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function _functionCallWithValue(addre ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function callOptionalReturn(IERC20 to ...
• interface IUniswapFactory
•    - 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 IUniswapRouter01
•    - 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 IUniswapRouter02 is IUniswa ...
•    - function removeLiquidityETHSupporting ...
•    - function removeLiquidityETHWithPermit ...
•    - function swapExactTokensForTokensSupp ...
•    - function swapExactETHForTokensSupport ...
•    - function swapExactTokensForETHSupport ...
• interface IUniswapPair
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transfer(address to, uint va ...
•    - function transferFrom(address from, a ...
•    - function DOMAIN_SEPARATOR()
•    - function PERMIT_TYPEHASH()
•    - function nonces(address owner)
•    - function permit(address owner, addres ...
•    - function MINIMUM_LIQUIDITY()
•    - function factory()
•    - function token0()
•    - function token1()
•    - function getReserves()
•    - function price0CumulativeLast()
•    - function price1CumulativeLast()
•    - function kLast()
•    - function mint(address to)
•    - function burn(address to)
•    - function swap(uint amount0Out, uint a ...
•    - function skim(address to)
•    - function sync()
•    - function initialize(address, address)
•  contract Ownable
•    - function isOwner()
•  contract POMMigration is Ownable *
•    - function swap()
•    - function _swapToken(uint256 tokensToS ...
•    - function swapToken(uint256 tokensToSw ...
•    - function setSwap(bool _swapEnable)
•    - function clearStuckBalance(uint256 am ...
•    - function clearStuckToken(address Toke ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-11-24
*/

// 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;
    }
}

interface IERC20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
	
	event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);
}

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */

library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

interface IUniswapFactory {
    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;
}

interface IUniswapRouter01 {
    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);
}

interface IUniswapRouter02 is IUniswapRouter01 {
    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;
}

interface IUniswapPair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

contract Ownable {
   address payable public _owner;
	   
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () public {
        _owner = msg.sender;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

}

contract POMMigration is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
	
	uint256 public _deadline;
	bool swapEnable = true;
    
	address public _weth;
	address public _pom;
	address public _liquidReceiverAddress;
	IUniswapRouter02 public _uniswapRouter;
	
	mapping (address => uint256) public claimableAmount;
	
	receive() external payable {}
	
    constructor (
		address pom
		,address liquidReceiverAddress
		,address uniswapRouter
		,uint256 deadline
	) public Ownable() {
		_uniswapRouter = IUniswapRouter02(uniswapRouter);
		_weth = _uniswapRouter.WETH();
		_deadline = deadline;
		_pom = pom;
		_liquidReceiverAddress = liquidReceiverAddress;
	}	
	
	event Swapped(address indexed sender, uint256 amount);
	
	function swap() external {		
		require(block.timestamp <= _deadline, "Swap times up");
		require(tx.origin == msg.sender , 'call from unauthorized contract');
		
		uint256 balance = IERC20(address(_pom)).balanceOf(msg.sender);
		
		if(balance > 0){
			uint256 beforeSendBalance = IERC20(address(_pom)).balanceOf(address(this));
			IERC20(address(_pom)).safeTransferFrom(msg.sender, address(this), balance);
			uint256 afterSendBalance = IERC20(address(_pom)).balanceOf(address(this));
			
			balance = afterSendBalance - beforeSendBalance;
			
            if(swapEnable){
                _swapToken(balance);
            }
            
			
			claimableAmount[msg.sender] += balance;
			emit Swapped(msg.sender,  balance);
		}
	}

	function _swapToken(uint256 tokensToSwap) internal {
		uint256 deadline = block.timestamp + 5 minutes;
		
		IERC20(address(_pom)).safeApprove(address(_uniswapRouter), 0);
		IERC20(address(_pom)).safeApprove(address(_uniswapRouter), tokensToSwap);
		
		address[] memory path = new address[](2);
		path[0] = address(address(_pom));
		path[1] = address(_weth);
		_uniswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(tokensToSwap, 0, path, address(this), deadline);
		
		uint256 amountETH = address(this).balance;
        payable(_liquidReceiverAddress).transfer(amountETH);
	}
	
    function swapToken(uint256 tokensToSwap) external onlyOwner{
        _swapToken(tokensToSwap);
    }
    
    function setSwap(bool _swapEnable) external onlyOwner{
        swapEnable = _swapEnable;
    }

	function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
        uint256 amountETH = address(this).balance;
        payable(msg.sender).transfer((amountETH * amountPercentage) / 100);
    }
	
	function clearStuckToken(address TokenAddress, uint256 amountPercentage) external onlyOwner {
        uint256 amountToken = IERC20(TokenAddress).balanceOf(address(this));
		IERC20(TokenAddress).safeTransfer(msg.sender, (amountToken * amountPercentage) / 100);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"pom","type":"address"},{"internalType":"address","name":"liquidReceiverAddress","type":"address"},{"internalType":"address","name":"uniswapRouter","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Swapped","type":"event"},{"inputs":[],"name":"_deadline","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_liquidReceiverAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_owner","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_pom","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_uniswapRouter","outputs":[{"internalType":"contract IUniswapRouter02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_weth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claimableAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountPercentage","type":"uint256"}],"name":"clearStuckBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"TokenAddress","type":"address"},{"internalType":"uint256","name":"amountPercentage","type":"uint256"}],"name":"clearStuckToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_swapEnable","type":"bool"}],"name":"setSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokensToSwap","type":"uint256"}],"name":"swapToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

24710:2839:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;26962:96:0;;5:9:-1;2:2;;;27:1;24;17:12;2:2;26962:96:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;26962:96:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;24816:24;;5:9:-1;2:2;;;27:1;24;17:12;2:2;24816:24:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;27063:209;;5:9:-1;2:2;;;27:1;24;17:12;2:2;27063:209:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;27063:209:0;;;;;;;;;;;;;;;;;:::i;:::-;;24923:37;;5:9:-1;2:2;;;27:1;24;17:12;2:2;24923:37:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;26848:102;;5:9:-1;2:2;;;27:1;24;17:12;2:2;26848:102:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;26848:102:0;;;;;;;;;;;;;;;;;:::i;:::-;;24964:38;;5:9:-1;2:2;;;27:1;24;17:12;2:2;24964:38:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;27278:268;;5:9:-1;2:2;;;27:1;24;17:12;2:2;27278:268:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;27278:268:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;25486:749;;5:9:-1;2:2;;;27:1;24;17:12;2:2;25486:749:0;;;:::i;:::-;;25009:51;;5:9:-1;2:2;;;27:1;24;17:12;2:2;25009:51:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;25009:51:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;24609:92;;5:9:-1;2:2;;;27:1;24;17:12;2:2;24609:92:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;24876:20;;5:9:-1;2:2;;;27:1;24;17:12;2:2;24876:20:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;24029:29;;5:9:-1;2:2;;;27:1;24;17:12;2:2;24029:29:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;24900:19;;5:9:-1;2:2;;;27:1;24;17:12;2:2;24900:19:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;26962:96;24455:9;:7;:9::i;:::-;24447:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27039:11:::1;27026:10;;:24;;;;;;;;;;;;;;;;;;26962:96:::0;:::o;24816:24::-;;;;:::o;27063:209::-;24455:9;:7;:9::i;:::-;24447:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27146:17:::1;27166:21;27146:41;;27206:10;27198:28;;:66;27260:3;27240:16;27228:9;:28;27227:36;;;;;;27198:66;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;27198:66:0;24512:1;27063:209:::0;:::o;24923:37::-;;;;;;;;;;;;;:::o;26848:102::-;24455:9;:7;:9::i;:::-;24447:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26918:24:::1;26929:12;26918:10;:24::i;:::-;26848:102:::0;:::o;24964:38::-;;;;;;;;;;;;;:::o;27278:268::-;24455:9;:7;:9::i;:::-;24447:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27381:19:::1;27410:12;27403:30;;;27442:4;27403:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;27403:45:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;27403:45:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;27403:45:0;;;;;;;;;;;;;;;;27381:67;;27453:85;27487:10;27534:3;27514:16;27500:11;:30;27499:38;;;;;;27460:12;27453:33;;;;:85;;;;;:::i;:::-;24512:1;27278:268:::0;;:::o;25486:749::-;25545:9;;25526:15;:28;;25518:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25598:10;25585:23;;:9;:23;;;25577:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25654:15;25687:4;;;;;;;;;;;25672:31;;;25704:10;25672:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;25672:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;25672:43:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;25672:43:0;;;;;;;;;;;;;;;;25654:61;;25737:1;25727:7;:11;25724:507;;;25745:25;25788:4;;;;;;;;;;;25773:31;;;25813:4;25773:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;25773:46:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;25773:46:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;25773:46:0;;;;;;;;;;;;;;;;25745:74;;25825;25864:10;25884:4;25891:7;25840:4;;;;;;;;;;;25825:38;;;;:74;;;;;;:::i;:::-;25905:24;25947:4;;;;;;;;;;;25932:31;;;25972:4;25932:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;25932:46:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;25932:46:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;25932:46:0;;;;;;;;;;;;;;;;25905:73;;26018:17;25999:16;:36;25989:46;;26058:10;;;;;;;;;;;26055:68;;;26088:19;26099:7;26088:10;:19::i;:::-;26055:68;26178:7;26147:15;:27;26163:10;26147:27;;;;;;;;;;;;;;;;:38;;;;;;;;;;;26204:10;26196:29;;;26217:7;26196:29;;;;;;;;;;;;;;;;;;25724:507;;;25486:749;:::o;25009:51::-;;;;;;;;;;;;;;;;;:::o;24609:92::-;24649:4;24687:6;;;;;;;;;;;24673:20;;:10;:20;;;24666:27;;24609:92;:::o;24876:20::-;;;;;;;;;;;;;:::o;24029:29::-;;;;;;;;;;;;;:::o;24900:19::-;;;;;;;;;;;;;:::o;26240:599::-;26296:16;26333:9;26315:15;:27;26296:46;;26351:61;26393:14;;;;;;;;;;;26410:1;26366:4;;;;;;;;;;;26351:33;;;;:61;;;;;:::i;:::-;26417:72;26459:14;;;;;;;;;;;26476:12;26432:4;;;;;;;;;;;26417:33;;;;:72;;;;;:::i;:::-;26498:21;26536:1;26522:16;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;26522:16:0;;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;125:4;109:14;101:6;88:42;156:4;148:6;144:17;134:27;;0:165;26522:16:0;;;;26498:40;;26569:4;;;;;;;;;;;26543;26548:1;26543:7;;;;;;;;;;;;;:32;;;;;;;;;;;26598:5;;;;;;;;;;;26580:4;26585:1;26580:7;;;;;;;;;;;;;:24;;;;;;;;;;;26609:14;;;;;;;;;;;:65;;;26675:12;26689:1;26692:4;26706;26713:8;26609:113;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;26609:113:0;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;26609:113:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;26609:113:0;;;;26731:17;26751:21;26731:41;;26791:22;;;;;;;;;;;26783:40;;:51;26824:9;26783:51;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;26783:51:0;26240:599;;;;:::o;12893:176::-;12976:85;12995:5;13025:23;;;13050:2;13054:5;13002:58;;;;;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;13002:58:0;;;;;;;38:4:-1;29:7;25:18;67:10;61:17;96:58;199:8;192:4;186;182:15;179:29;167:10;160:49;0:215;;;13002:58:0;12976:18;:85::i;:::-;12893:176;;;:::o;13077:204::-;13178:95;13197:5;13227:27;;;13256:4;13262:2;13266:5;13204:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;13204:68:0;;;;;;;38:4:-1;29:7;25:18;67:10;61:17;96:58;199:8;192:4;186;182:15;179:29;167:10;160:49;0:215;;;13204:68:0;13178:18;:95::i;:::-;13077:204;;;;:::o;13289:621::-;13668:1;13659:5;:10;13658:62;;;;13718:1;13675:5;:15;;;13699:4;13706:7;13675:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;13675:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;13675:39:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;13675:39:0;;;;;;;;;;;;;;;;:44;13658:62;13650:152;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13813:89;13832:5;13862:22;;;13886:7;13895:5;13839:62;;;;;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;13839:62:0;;;;;;;38:4:-1;29:7;25:18;67:10;61:17;96:58;199:8;192:4;186;182:15;179:29;167:10;160:49;0:215;;;13839:62:0;13813:18;:89::i;:::-;13289:621;;;:::o;14932:1114::-;15536:27;15544:5;15536:25;;;:27::i;:::-;15528:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15673:12;15687:23;15722:5;15714:19;;15734:4;15714:25;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;15714:25:0;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;15672:67:0;;;;15758:7;15750:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15839:1;15819:10;:17;:21;15815:224;;;15961:10;15950:30;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;15950:30:0;;;;;;;;;;;;;;;;15942:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15815:224;14932:1114;;;;:::o;6853:619::-;6913:4;7175:16;7202:19;7224:66;7202:88;;;;7393:7;7381:20;7369:32;;7433:11;7421:8;:23;;:42;;;;;7460:3;7448:15;;:8;:15;;7421:42;7413:51;;;;6853:619;;;:::o

ipfs://1aa0a7c79a6cfe85f68c95ec82af1a3c0b8649d102f06e99f428a0d8c8e7b388