MATIC Price: $0.72537 (-1.44%)
Gas: 30 GWei
 

Overview

MATIC Balance

Polygon PoS Chain LogoPolygon PoS Chain LogoPolygon PoS Chain Logo0 MATIC

MATIC Value

$0.00

Token Holdings

Sponsored

Transaction Hash
Method
Block
From
To
Value
Swap Exact Input...532718572024-02-08 12:30:02104 days ago1707395402IN
0x2961B790...5Efe275A8
0 MATIC0.0075059651.62251778
Swap Exact Input...532718062024-02-08 12:28:12104 days ago1707395292IN
0x2961B790...5Efe275A8
0.9 MATIC0.0079859953.69925756
Swap Exact Input...532051872024-02-06 20:11:47105 days ago1707250307IN
0x2961B790...5Efe275A8
0 MATIC0.0143052861.47630047
Swap Exact Input...532049462024-02-06 20:02:03105 days ago1707249723IN
0x2961B790...5Efe275A8
0 MATIC0.0064387244.28190087
Swap Exact Input...532000592024-02-06 17:06:42106 days ago1707239202IN
0x2961B790...5Efe275A8
5 MATIC0.0112607776.23309677
Swap Exact Input...531703892024-02-05 23:20:25106 days ago1707175225IN
0x2961B790...5Efe275A8
0 MATIC0.0079405135.60451751
Swap Exact Input...531702892024-02-05 23:16:53106 days ago1707175013IN
0x2961B790...5Efe275A8
0 MATIC0.0077364635.21282731
Swap Exact Input...531701482024-02-05 23:11:38106 days ago1707174698IN
0x2961B790...5Efe275A8
0 MATIC0.0079285535.42789855
Swap Exact Input...531697992024-02-05 22:59:15106 days ago1707173955IN
0x2961B790...5Efe275A8
0 MATIC0.0052958433.29042049
Swap Exact Input...531692402024-02-05 22:38:41106 days ago1707172721IN
0x2961B790...5Efe275A8
1 MATIC0.0060075440.40775084
Transfer Ownersh...527041272024-01-24 17:48:01118 days ago1706118481IN
0x2961B790...5Efe275A8
0 MATIC0.000898530.90921909
0x60e06040527039762024-01-24 17:42:32119 days ago1706118152IN
 Create: DIMPSwap
0 MATIC0.1416231775

Latest 3 internal transactions

Parent Transaction Hash Block From To Value
532718062024-02-08 12:28:12104 days ago1707395292
0x2961B790...5Efe275A8
0.9 MATIC
532000592024-02-06 17:06:42106 days ago1707239202
0x2961B790...5Efe275A8
5 MATIC
531692402024-02-05 22:38:41106 days ago1707172721
0x2961B790...5Efe275A8
1 MATIC
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
DIMPSwap

Compiler Version
v0.8.20+commit.a1b79de6

Optimization Enabled:
No with 200 runs

Other Settings:
byzantium EvmVersion
File 1 of 10 : DIMPSwap.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@uniswap/v3-periphery/contracts/interfaces/IQuoter.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";

// D swaps DIMP/WMATIC for single path swaps and tokenIn/WMATIC/tokenOut for multi path swaps.
contract DIMPSwap is Ownable {
    using Math for uint256;

    ISwapRouter private _swapRouter;
    IUniswapV3Factory private immutable _uniswapFactory;
    IQuoter private immutable _quoter;
    address private immutable _WMATIC;
    uint24 private _fee;

    constructor(
        IUniswapV3Factory uniswapFactory_,
        ISwapRouter swapRouter_,
        IQuoter quoter_,
        address WMATIC_
    ) Ownable(_msgSender()) {
        _uniswapFactory = uniswapFactory_;
        _swapRouter = swapRouter_;
        _quoter = quoter_;
        _WMATIC = WMATIC_;
        _fee = 3000;
    }

    function swapRouter() external view returns (ISwapRouter) {
        return _swapRouter;
    }

    function uniswapFactory() external view returns (IUniswapV3Factory) {
        return _uniswapFactory;
    }

    function WMATIC() external view returns (address) {
        return _WMATIC;
    }

    function fee() external view returns (uint24) {
        return _fee;
    }

    function setFee(uint24 fee_) external onlyOwner {
        _fee = fee_;
    }

    function updateSwapRouter(ISwapRouter swapRouter_) external onlyOwner {
        _swapRouter = swapRouter_;
    }

    function _quoteExactInputSingle(
        address tokenIn,
        address tokenOut,
        uint256 amountIn
    ) internal returns (uint256 amountOut) {
        amountOut = _quoter.quoteExactInputSingle(tokenIn, tokenOut, _fee, amountIn, 0);
    }

    function _quoteExactInput(
        address tokenIn,
        address tokenOut,
        uint256 amountIn
    ) internal returns (uint256 amountOut) {
        amountOut = _quoter.quoteExactInput(
            abi.encodePacked(tokenIn, _fee, _WMATIC, _fee, tokenOut),
            amountIn
        );
    }

    function quoteExactInputSmartRouter(
        address tokenIn,
        address tokenOut,
        uint256 amountIn
    ) external payable returns (uint256 amountOut) {
        address pool = _uniswapFactory.getPool(tokenIn, tokenOut, _fee);
        if (pool == address(0)) {
            return _quoteExactInput(tokenIn, tokenOut, amountIn);
        } else {
            return _quoteExactInputSingle(tokenIn, tokenOut, amountIn);
        }
    }

    function swapExactInputSingle(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOutMinimum
    ) public payable returns (uint256 amountOut) {
        if (tokenIn != _WMATIC) {
            TransferHelper.safeTransferFrom(tokenIn, _msgSender(), address(this), amountIn);
            TransferHelper.safeApprove(tokenIn, address(_swapRouter), amountIn);
        }

        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
            tokenIn: tokenIn,
            tokenOut: tokenOut,
            fee: _fee,
            recipient: _msgSender(),
            deadline: block.timestamp + 2,
            amountIn: amountIn,
            amountOutMinimum: amountOutMinimum,
            sqrtPriceLimitX96: 0
        });

        amountOut = _swapRouter.exactInputSingle{value: msg.value}(params);
    }

    function swapExactInput(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOutMinimum
    ) public payable returns (uint256 amountOut) {
        if (tokenIn != _WMATIC) {
            TransferHelper.safeTransferFrom(tokenIn, _msgSender(), address(this), amountIn);
            TransferHelper.safeApprove(tokenIn, address(_swapRouter), amountIn);
        }

        ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
            path: abi.encodePacked(tokenIn, _fee, _WMATIC, _fee, tokenOut),
            recipient: _msgSender(),
            deadline: block.timestamp + 2,
            amountIn: amountIn,
            amountOutMinimum: amountOutMinimum
        });
        amountOut = _swapRouter.exactInput{value: msg.value}(params);
    }

    function swapExactInputSmartRouter(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOutMinimum
    ) external payable returns (uint256 amountOut) {
        if (tokenIn != _WMATIC) {
            TransferHelper.safeTransferFrom(tokenIn, _msgSender(), address(this), amountIn);
            TransferHelper.safeApprove(tokenIn, address(_swapRouter), amountIn);
        }

        address pool = _uniswapFactory.getPool(tokenIn, tokenOut, _fee);
        if (pool != address(0)) {
            ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
                tokenIn: tokenIn,
                tokenOut: tokenOut,
                fee: _fee,
                recipient: _msgSender(),
                deadline: block.timestamp + 2,
                amountIn: amountIn,
                amountOutMinimum: amountOutMinimum,
                sqrtPriceLimitX96: 0
            });

            amountOut = _swapRouter.exactInputSingle{value: msg.value}(params);
        } else {
            ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
                path: abi.encodePacked(tokenIn, _fee, _WMATIC, _fee, tokenOut),
                recipient: _msgSender(),
                deadline: block.timestamp + 2,
                amountIn: amountIn,
                amountOutMinimum: amountOutMinimum
            });
            amountOut = _swapRouter.exactInput{value: msg.value}(params);
        }
    }
}

File 2 of 10 : TransferHelper.sol
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.6.0;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

library TransferHelper {
    /// @notice Transfers tokens from the targeted address to the given destination
    /// @notice Errors with 'STF' if transfer fails
    /// @param token The contract address of the token to be transferred
    /// @param from The originating address from which the tokens will be transferred
    /// @param to The destination address of the transfer
    /// @param value The amount to be transferred
    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) =
            token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
    }

    /// @notice Transfers tokens from msg.sender to a recipient
    /// @dev Errors with ST if transfer fails
    /// @param token The contract address of the token which will be transferred
    /// @param to The recipient of the transfer
    /// @param value The value of the transfer
    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
    }

    /// @notice Approves the stipulated contract to spend the given allowance in the given token
    /// @dev Errors with 'SA' if transfer fails
    /// @param token The contract address of the token to be approved
    /// @param to The target of the approval
    /// @param value The amount of the given token the target will be allowed to spend
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
    }

    /// @notice Transfers ETH to the recipient address
    /// @dev Fails with `STE`
    /// @param to The destination of the transfer
    /// @param value The value to be transferred
    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'STE');
    }
}

File 2 of 10 : ISwapRouter.sol
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

import '@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3SwapCallback.sol';

/// @title Router token swapping functionality
/// @notice Functions for swapping tokens via Uniswap V3
interface ISwapRouter is IUniswapV3SwapCallback {
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Swaps `amountIn` of one token for as much as possible of another token
    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
    /// @return amountOut The amount of the received token
    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);

    struct ExactInputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
    }

    /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
    /// @return amountOut The amount of the received token
    function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);

    struct ExactOutputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Swaps as little as possible of one token for `amountOut` of another token
    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
    /// @return amountIn The amount of the input token
    function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);

    struct ExactOutputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
    }

    /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
    /// @return amountIn The amount of the input token
    function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
}

File 2 of 10 : IQuoter.sol
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;

/// @title Quoter Interface
/// @notice Supports quoting the calculated amounts from exact input or exact output swaps
/// @dev These functions are not marked view because they rely on calling non-view functions and reverting
/// to compute the result. They are also not gas efficient and should not be called on-chain.
interface IQuoter {
    /// @notice Returns the amount out received for a given exact input swap without executing the swap
    /// @param path The path of the swap, i.e. each token pair and the pool fee
    /// @param amountIn The amount of the first token to swap
    /// @return amountOut The amount of the last token that would be received
    function quoteExactInput(bytes memory path, uint256 amountIn) external returns (uint256 amountOut);

    /// @notice Returns the amount out received for a given exact input but for a swap of a single pool
    /// @param tokenIn The token being swapped in
    /// @param tokenOut The token being swapped out
    /// @param fee The fee of the token pool to consider for the pair
    /// @param amountIn The desired input amount
    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountOut The amount of `tokenOut` that would be received
    function quoteExactInputSingle(
        address tokenIn,
        address tokenOut,
        uint24 fee,
        uint256 amountIn,
        uint160 sqrtPriceLimitX96
    ) external returns (uint256 amountOut);

    /// @notice Returns the amount in required for a given exact output swap without executing the swap
    /// @param path The path of the swap, i.e. each token pair and the pool fee. Path must be provided in reverse order
    /// @param amountOut The amount of the last token to receive
    /// @return amountIn The amount of first token required to be paid
    function quoteExactOutput(bytes memory path, uint256 amountOut) external returns (uint256 amountIn);

    /// @notice Returns the amount in required to receive the given exact output amount but for a swap of a single pool
    /// @param tokenIn The token being swapped in
    /// @param tokenOut The token being swapped out
    /// @param fee The fee of the token pool to consider for the pair
    /// @param amountOut The desired output amount
    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountIn The amount required as the input for the swap in order to receive `amountOut`
    function quoteExactOutputSingle(
        address tokenIn,
        address tokenOut,
        uint24 fee,
        uint256 amountOut,
        uint160 sqrtPriceLimitX96
    ) external returns (uint256 amountIn);
}

File 2 of 10 : IUniswapV3SwapCallback.sol
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Callback for IUniswapV3PoolActions#swap
/// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface
interface IUniswapV3SwapCallback {
    /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.
    /// @dev In the implementation you must pay the pool tokens owed for the swap.
    /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
    /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
    /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by
    /// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
    /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by
    /// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
    /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external;
}

File 2 of 10 : IUniswapV3Factory.sol
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title The interface for the Uniswap V3 Factory
/// @notice The Uniswap V3 Factory facilitates creation of Uniswap V3 pools and control over the protocol fees
interface IUniswapV3Factory {
    /// @notice Emitted when the owner of the factory is changed
    /// @param oldOwner The owner before the owner was changed
    /// @param newOwner The owner after the owner was changed
    event OwnerChanged(address indexed oldOwner, address indexed newOwner);

    /// @notice Emitted when a pool is created
    /// @param token0 The first token of the pool by address sort order
    /// @param token1 The second token of the pool by address sort order
    /// @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip
    /// @param tickSpacing The minimum number of ticks between initialized ticks
    /// @param pool The address of the created pool
    event PoolCreated(
        address indexed token0,
        address indexed token1,
        uint24 indexed fee,
        int24 tickSpacing,
        address pool
    );

    /// @notice Emitted when a new fee amount is enabled for pool creation via the factory
    /// @param fee The enabled fee, denominated in hundredths of a bip
    /// @param tickSpacing The minimum number of ticks between initialized ticks for pools created with the given fee
    event FeeAmountEnabled(uint24 indexed fee, int24 indexed tickSpacing);

    /// @notice Returns the current owner of the factory
    /// @dev Can be changed by the current owner via setOwner
    /// @return The address of the factory owner
    function owner() external view returns (address);

    /// @notice Returns the tick spacing for a given fee amount, if enabled, or 0 if not enabled
    /// @dev A fee amount can never be removed, so this value should be hard coded or cached in the calling context
    /// @param fee The enabled fee, denominated in hundredths of a bip. Returns 0 in case of unenabled fee
    /// @return The tick spacing
    function feeAmountTickSpacing(uint24 fee) external view returns (int24);

    /// @notice Returns the pool address for a given pair of tokens and a fee, or address 0 if it does not exist
    /// @dev tokenA and tokenB may be passed in either token0/token1 or token1/token0 order
    /// @param tokenA The contract address of either token0 or token1
    /// @param tokenB The contract address of the other token
    /// @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip
    /// @return pool The pool address
    function getPool(
        address tokenA,
        address tokenB,
        uint24 fee
    ) external view returns (address pool);

    /// @notice Creates a pool for the given two tokens and fee
    /// @param tokenA One of the two tokens in the desired pool
    /// @param tokenB The other of the two tokens in the desired pool
    /// @param fee The desired fee for the pool
    /// @dev tokenA and tokenB may be passed in either order: token0/token1 or token1/token0. tickSpacing is retrieved
    /// from the fee. The call will revert if the pool already exists, the fee is invalid, or the token arguments
    /// are invalid.
    /// @return pool The address of the newly created pool
    function createPool(
        address tokenA,
        address tokenB,
        uint24 fee
    ) external returns (address pool);

    /// @notice Updates the owner of the factory
    /// @dev Must be called by the current owner
    /// @param _owner The new owner of the factory
    function setOwner(address _owner) external;

    /// @notice Enables a fee amount with the given tickSpacing
    /// @dev Fee amounts may never be removed once enabled
    /// @param fee The fee amount to enable, denominated in hundredths of a bip (i.e. 1e-6)
    /// @param tickSpacing The spacing between ticks to be enforced for all pools created with the given fee amount
    function enableFeeAmount(uint24 fee, int24 tickSpacing) external;
}

File 2 of 10 : Math.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

File 2 of 10 : Context.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

File 2 of 10 : IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

File 2 of 10 : Ownable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

Settings
{
  "remappings": [],
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "evmVersion": "byzantium",
  "libraries": {},
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"contract IUniswapV3Factory","name":"uniswapFactory_","type":"address"},{"internalType":"contract ISwapRouter","name":"swapRouter_","type":"address"},{"internalType":"contract IQuoter","name":"quoter_","type":"address"},{"internalType":"address","name":"WMATIC_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"WMATIC","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fee","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"}],"name":"quoteExactInputSmartRouter","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint24","name":"fee_","type":"uint24"}],"name":"setFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"}],"name":"swapExactInput","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"}],"name":"swapExactInputSingle","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"}],"name":"swapExactInputSmartRouter","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"swapRouter","outputs":[{"internalType":"contract ISwapRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapFactory","outputs":[{"internalType":"contract IUniswapV3Factory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ISwapRouter","name":"swapRouter_","type":"address"}],"name":"updateSwapRouter","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000001f98431c8ad98523631ae4a59f267346ea31f984000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564000000000000000000000000b27308f9f90d607463bb33ea1bebb41c27ce5ab60000000000000000000000000d500b1d8e8ef31e21c99d1db9a6444d3adf1270

-----Decoded View---------------
Arg [0] : uniswapFactory_ (address): 0x1F98431c8aD98523631AE4a59f267346ea31F984
Arg [1] : swapRouter_ (address): 0xE592427A0AEce92De3Edee1F18E0157C05861564
Arg [2] : quoter_ (address): 0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6
Arg [3] : WMATIC_ (address): 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000001f98431c8ad98523631ae4a59f267346ea31f984
Arg [1] : 000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564
Arg [2] : 000000000000000000000000b27308f9f90d607463bb33ea1bebb41c27ce5ab6
Arg [3] : 0000000000000000000000000d500b1d8e8ef31e21c99d1db9a6444d3adf1270


Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
[ Download: CSV Export  ]
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.