Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import {ILynexRouter} from "./Interfaces.sol";
import {RouterIntentEoaAdapterWithoutDataProvider, EoaExecutorWithoutDataProvider} from "@routerprotocol/intents-core/contracts/RouterIntentEoaAdapter.sol";
import {Errors} from "@routerprotocol/intents-core/contracts/utils/Errors.sol";
import {IERC20, SafeERC20} from "../../../utils/SafeERC20.sol";
import {LynexHelpers} from "./LynexHelpers.sol";

/**
 * @title LynexMint
 * @author Shivam Agrawal
 * @notice Adding liquidity on Lynex.
 */

contract LynexMint is RouterIntentEoaAdapterWithoutDataProvider, LynexHelpers {
    using SafeERC20 for IERC20;

    constructor(
        address __native,
        address __wnative,
        address __lynexRouter
    )
        RouterIntentEoaAdapterWithoutDataProvider(__native, __wnative)
        LynexHelpers(__lynexRouter)
    // solhint-disable-next-line no-empty-blocks
    {

    }

    function name() public pure override returns (string memory) {
        return "LynexMint";
    }

    /**
     * @inheritdoc EoaExecutorWithoutDataProvider
     */
    function execute(
        bytes calldata data
    ) external payable override returns (address[] memory tokens) {
        ILynexRouter.LynexSupplyData memory mintParams = parseInputs(data);

        // If the adapter is called using `call` and not `delegatecall`
        if (address(this) == self()) {
            if (mintParams.tokenA != native())
                IERC20(mintParams.tokenA).safeTransferFrom(
                    msg.sender,
                    self(),
                    mintParams.amountADesired
                );
            else
                require(
                    msg.value == mintParams.amountADesired,
                    Errors.INSUFFICIENT_NATIVE_FUNDS_PASSED
                );

            if (mintParams.tokenB != native())
                IERC20(mintParams.tokenB).safeTransferFrom(
                    msg.sender,
                    self(),
                    mintParams.amountBDesired
                );
            else
                require(
                    msg.value == mintParams.amountBDesired,
                    Errors.INSUFFICIENT_NATIVE_FUNDS_PASSED
                );
        } else {
            if (mintParams.amountADesired == type(uint256).max)
                mintParams.amountADesired = getBalance(
                    mintParams.tokenA,
                    address(this)
                );

            if (mintParams.amountBDesired == type(uint256).max)
                mintParams.amountBDesired = getBalance(
                    mintParams.tokenB,
                    address(this)
                );
        }

        if (mintParams.tokenA == native()) {
            convertNativeToWnative(mintParams.amountADesired);
            mintParams.tokenA = wnative();
        }

        if (mintParams.tokenB == native()) {
            convertNativeToWnative(mintParams.amountBDesired);
            mintParams.tokenB = wnative();
        }

        IERC20(mintParams.tokenA).safeIncreaseAllowance(
            address(lynexRouter),
            mintParams.amountADesired
        );

        IERC20(mintParams.tokenB).safeIncreaseAllowance(
            address(lynexRouter),
            mintParams.amountBDesired
        );

        (uint256 amountA, uint256 amountB, uint256 liqAmount) = _mint(
            mintParams
        );

        bytes memory logData = abi.encode(
            mintParams,
            amountA,
            amountB,
            liqAmount
        );

        tokens = new address[](2);
        tokens[0] = mintParams.tokenA;
        tokens[1] = mintParams.tokenB;

        emit ExecutionEvent(name(), logData);
        return tokens;
    }

    //////////////////////////// ACTION LOGIC ////////////////////////////

    function _mint(
        ILynexRouter.LynexSupplyData memory _mintParams
    ) internal returns (uint256 amountA, uint256 amountB, uint256 liqAmount) {
        (amountA, amountB, liqAmount) = lynexRouter.addLiquidity(
            _mintParams.tokenA,
            _mintParams.tokenB,
            _mintParams.stable,
            _mintParams.amountADesired,
            _mintParams.amountBDesired,
            _mintParams.amountAMin,
            _mintParams.amountBMin,
            _mintParams.to,
            _mintParams.deadline
        );
    }

    /**
     * @dev function to parse input data.
     * @param data input data.
     */
    function parseInputs(
        bytes memory data
    ) public pure returns (ILynexRouter.LynexSupplyData memory) {
        return abi.decode(data, (ILynexRouter.LynexSupplyData));
    }

    // solhint-disable-next-line no-empty-blocks
    receive() external payable {}
}

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

import {IAdapterDataProvider} from "./interfaces/IAdapterDataProvider.sol";

/**
 * @title AdapterDataProvider
 * @author Router Protocol
 * @notice This contract serves as the data provider for an intent adapter based on Router
 * Cross-Chain Intent Framework.
 */
contract AdapterDataProvider is IAdapterDataProvider {
    address private _owner;
    mapping(address => bool) private _headRegistry;
    mapping(address => bool) private _tailRegistry;
    mapping(address => bool) private _inboundAssetRegistry;
    mapping(address => bool) private _outboundAssetRegistry;

    constructor(address __owner) {
        _owner = __owner;
    }

    /**
     * @inheritdoc IAdapterDataProvider
     */
    function owner() external view returns (address) {
        return _owner;
    }

    /**
     * @inheritdoc IAdapterDataProvider
     */
    function setOwner(address __owner) external onlyOwner {
        _owner = __owner;
    }

    /**
     * @inheritdoc IAdapterDataProvider
     */
    function isAuthorizedPrecedingContract(
        address precedingContract
    ) external view returns (bool) {
        if (precedingContract == address(0)) return true;
        return _headRegistry[precedingContract];
    }

    /**
     * @inheritdoc IAdapterDataProvider
     */
    function isAuthorizedSucceedingContract(
        address succeedingContract
    ) external view returns (bool) {
        if (succeedingContract == address(0)) return true;
        return _tailRegistry[succeedingContract];
    }

    /**
     * @inheritdoc IAdapterDataProvider
     */
    function isValidInboundAsset(address asset) external view returns (bool) {
        return _inboundAssetRegistry[asset];
    }

    /**
     * @inheritdoc IAdapterDataProvider
     */
    function isValidOutboundAsset(address asset) external view returns (bool) {
        return _outboundAssetRegistry[asset];
    }

    /**
     * @inheritdoc IAdapterDataProvider
     */
    function setPrecedingContract(
        address precedingContract,
        bool isValid
    ) external onlyOwner {
        _headRegistry[precedingContract] = isValid;
    }

    /**
     * @inheritdoc IAdapterDataProvider
     */
    function setSucceedingContract(
        address succeedingContract,
        bool isValid
    ) external onlyOwner {
        _tailRegistry[succeedingContract] = isValid;
    }

    /**
     * @inheritdoc IAdapterDataProvider
     */
    function setInboundAsset(address asset, bool isValid) external onlyOwner {
        _inboundAssetRegistry[asset] = isValid;
    }

    /**
     * @inheritdoc IAdapterDataProvider
     */
    function setOutboundAsset(address asset, bool isValid) external onlyOwner {
        _outboundAssetRegistry[asset] = isValid;
    }

    /**
     * @notice modifier to ensure that only owner can call this function
     */
    modifier onlyOwner() {
        _onlyOwner();
        _;
    }

    function _onlyOwner() private view {
        require(msg.sender == _owner, "Only owner");
    }
}

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

import {Basic} from "./common/Basic.sol";
import {Errors} from "./utils/Errors.sol";
import {ReentrancyGuard} from "./utils/ReentrancyGuard.sol";
import {AdapterDataProvider} from "./AdapterDataProvider.sol";

/**
 * @title BaseAdapter
 * @author Router Protocol
 * @notice This contract is the base implementation of an intent adapter based on Router
 * Cross-Chain Intent Framework.
 */
abstract contract BaseAdapter is Basic, ReentrancyGuard {
    address private immutable _self;
    address private immutable _native;
    address private immutable _wnative;
    AdapterDataProvider private immutable _adapterDataProvider;

    event ExecutionEvent(string indexed adapterName, bytes data);
    event OperationFailedRefundEvent(
        address token,
        address recipient,
        uint256 amount
    );
    event UnsupportedOperation(
        address token,
        address refundAddress,
        uint256 amount
    );

    constructor(
        address __native,
        address __wnative,
        bool __deployDataProvider,
        address __owner
    ) {
        _self = address(this);
        _native = __native;
        _wnative = __wnative;

        AdapterDataProvider dataProvider;

        if (__deployDataProvider)
            dataProvider = new AdapterDataProvider(__owner);
        else dataProvider = AdapterDataProvider(address(0));

        _adapterDataProvider = dataProvider;
    }

    /**
     * @dev function to get the address of weth
     */
    function wnative() public view override returns (address) {
        return _wnative;
    }

    /**
     * @dev function to get the address of native token
     */
    function native() public view override returns (address) {
        return _native;
    }

    /**
     * @dev function to get the AdapterDataProvider instance for this contract
     */
    function adapterDataProvider() public view returns (AdapterDataProvider) {
        return _adapterDataProvider;
    }

    /**
     * @dev Function to check whether the contract is a valid preceding contract registered in
     * the head registry.
     * @dev This registry governs the initiation of the adapter, exclusively listing authorized
     * preceding adapters.
     * @notice Only the adapters documented in this registry can invoke the current adapter,
     * thereby guaranteeing regulated and secure execution sequences.
     * @param precedingContract Address of preceding contract.
     * @return true if valid, false if invalid.
     */
    function isAuthorizedPrecedingContract(
        address precedingContract
    ) public view returns (bool) {
        return
            _adapterDataProvider.isAuthorizedPrecedingContract(
                precedingContract
            );
    }

    /**
     * @dev Function to check whether the contract is a valid succeeding contract registered in
     * the tail registry.
     * @dev This registry dictates the potential succeeding actions by listing adapters that
     * may be invoked following the current one.
     * @notice Only the adapters documented in this registry can be invoked by the current adapter,
     * thereby guaranteeing regulated and secure execution sequences.
     * @param succeedingContract Address of succeeding contract.
     * @return true if valid, false if invalid.
     */
    function isAuthorizedSucceedingContract(
        address succeedingContract
    ) public view returns (bool) {
        return
            _adapterDataProvider.isAuthorizedSucceedingContract(
                succeedingContract
            );
    }

    /**
     * @dev Function to check whether the asset is a valid inbound asset registered in the inbound
     * asset registry.
     * @dev This registry keeps track of all the acceptable incoming assets, ensuring that the
     * adapter only processes predefined asset types.
     * @param asset Address of the asset.
     * @return true if valid, false if invalid.
     */
    function isValidInboundAsset(address asset) public view returns (bool) {
        return _adapterDataProvider.isValidInboundAsset(asset);
    }

    /**
     * @dev Function to check whether the asset is a valid outbound asset registered in the outbound
     * asset registry.
     * @dev It manages the types of assets that the adapter is allowed to output, thus controlling
     * the flow’s output and maintaining consistency.
     * @param asset Address of the asset.
     * @return true if valid, false if invalid.
     */
    function isValidOutboundAsset(address asset) public view returns (bool) {
        return _adapterDataProvider.isValidOutboundAsset(asset);
    }

    /**
     * @dev function to get the name of the adapter
     */
    function name() public view virtual returns (string memory);

    /**
     * @dev function to get the address of the contract
     */
    function self() public view returns (address) {
        return _self;
    }
}

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

import {TokenInterface} from "./Interfaces.sol";
import {TokenUtilsBase} from "./TokenUtilsBase.sol";

abstract contract Basic is TokenUtilsBase {
    function getTokenBal(address token) internal view returns (uint _amt) {
        _amt = address(token) == native()
            ? address(this).balance
            : TokenInterface(token).balanceOf(address(this));
    }

    function approve(address token, address spender, uint256 amount) internal {
        // solhint-disable-next-line no-empty-blocks
        try TokenInterface(token).approve(spender, amount) {} catch {
            TokenInterface(token).approve(spender, 0);
            TokenInterface(token).approve(spender, amount);
        }
    }

    function convertNativeToWnative(uint amount) internal {
        TokenInterface(wnative()).deposit{value: amount}();
    }

    function convertWnativeToNative(uint amount) internal {
        TokenInterface(wnative()).withdraw(amount);
    }
}

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

interface TokenInterface {
    function approve(address, uint256) external;

    function transfer(address, uint) external;

    function transferFrom(address, address, uint) external;

    function deposit() external payable;

    function withdraw(uint) external;

    function balanceOf(address) external view returns (uint);

    function decimals() external view returns (uint);
}

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

import {IWETH} from "../interfaces/IWETH.sol";
import {SafeERC20, IERC20} from "../utils/SafeERC20.sol";

abstract contract TokenUtilsBase {
    using SafeERC20 for IERC20;

    function wnative() public view virtual returns (address);

    function native() public view virtual returns (address);

    function approveToken(
        address _tokenAddr,
        address _to,
        uint256 _amount
    ) internal {
        if (_tokenAddr == native()) return;

        if (IERC20(_tokenAddr).allowance(address(this), _to) < _amount) {
            IERC20(_tokenAddr).safeApprove(_to, _amount);
        }
    }

    function pullTokensIfNeeded(
        address _token,
        address _from,
        uint256 _amount
    ) internal returns (uint256) {
        // handle max uint amount
        if (_amount == type(uint256).max) {
            _amount = getBalance(_token, _from);
        }

        if (
            _from != address(0) &&
            _from != address(this) &&
            _token != native() &&
            _amount != 0
        ) {
            IERC20(_token).safeTransferFrom(_from, address(this), _amount);
        }

        return _amount;
    }

    function withdrawTokens(
        address _token,
        address _to,
        uint256 _amount
    ) internal returns (uint256) {
        if (_amount == type(uint256).max) {
            _amount = getBalance(_token, address(this));
        }

        if (_to != address(0) && _to != address(this) && _amount != 0) {
            if (_token != native()) {
                IERC20(_token).safeTransfer(_to, _amount);
            } else {
                (bool success, ) = _to.call{value: _amount}("");
                require(success, "native send fail");
            }
        }

        return _amount;
    }

    function depositWnative(uint256 _amount) internal {
        IWETH(wnative()).deposit{value: _amount}();
    }

    function withdrawWnative(uint256 _amount) internal {
        IWETH(wnative()).withdraw(_amount);
    }

    function getBalance(
        address _tokenAddr,
        address _acc
    ) internal view returns (uint256) {
        if (_tokenAddr == native()) {
            return _acc.balance;
        } else {
            return IERC20(_tokenAddr).balanceOf(_acc);
        }
    }

    function getTokenDecimals(address _token) internal view returns (uint256) {
        if (_token == native()) return 18;

        return IERC20(_token).decimals();
    }
}

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

/**
 * @title Interface for Adapter Data Provider contract for intent adapter.
 * @author Router Protocol.
 */

interface IAdapterDataProvider {
    /**
     * @dev Function to get the address of owner.
     */
    function owner() external view returns (address);

    /**
     * @dev Function to set the address of owner.
     * @dev This function can only be called by the owner of this contract.
     * @param __owner Address of the new owner
     */
    function setOwner(address __owner) external;

    /**
     * @dev Function to check whether the contract is a valid preceding contract registered in
     * the head registry.
     * @dev This registry governs the initiation of the adapter, exclusively listing authorized
     * preceding adapters.
     * @notice Only the adapters documented in this registry can invoke the current adapter,
     * thereby guaranteeing regulated and secure execution sequences.
     * @param precedingContract Address of preceding contract.
     * @return true if valid, false if invalid.
     */
    function isAuthorizedPrecedingContract(
        address precedingContract
    ) external view returns (bool);

    /**
     * @dev Function to check whether the contract is a valid succeeding contract registered in
     * the tail registry.
     * @dev This registry dictates the potential succeeding actions by listing adapters that
     * may be invoked following the current one.
     * @notice Only the adapters documented in this registry can be invoked by the current adapter,
     * thereby guaranteeing regulated and secure execution sequences.
     * @param succeedingContract Address of succeeding contract.
     * @return true if valid, false if invalid.
     */
    function isAuthorizedSucceedingContract(
        address succeedingContract
    ) external view returns (bool);

    /**
     * @dev Function to check whether the asset is a valid inbound asset registered in the inbound
     * asset registry.
     * @dev This registry keeps track of all the acceptable incoming assets, ensuring that the
     * adapter only processes predefined asset types.
     * @param asset Address of the asset.
     * @return true if valid, false if invalid.
     */
    function isValidInboundAsset(address asset) external view returns (bool);

    /**
     * @dev Function to check whether the asset is a valid outbound asset registered in the outbound
     * asset registry.
     * @dev It manages the types of assets that the adapter is allowed to output, thus controlling
     * the flow’s output and maintaining consistency.
     * @param asset Address of the asset.
     * @return true if valid, false if invalid.
     */
    function isValidOutboundAsset(address asset) external view returns (bool);

    /**
     * @dev Function to set preceding contract (head registry) for the adapter.
     * @dev This registry governs the initiation of the adapter, exclusively listing authorized
     * preceding adapters.
     * @notice Only the adapters documented in this registry can invoke the current adapter,
     * thereby guaranteeing regulated and secure execution sequences.
     * @param precedingContract Address of preceding contract.
     * @param isValid Boolean value suggesting if this is a valid preceding contract.
     */
    function setPrecedingContract(
        address precedingContract,
        bool isValid
    ) external;

    /**
     * @dev Function to set succeeding contract (tail registry) for the adapter.
     * @dev This registry dictates the potential succeeding actions by listing adapters that
     * may be invoked following the current one.
     * @notice Only the adapters documented in this registry can be invoked by the current adapter,
     * thereby guaranteeing regulated and secure execution sequences.
     * @param succeedingContract Address of succeeding contract.
     * @param isValid Boolean value suggesting if this is a valid succeeding contract.
     */
    function setSucceedingContract(
        address succeedingContract,
        bool isValid
    ) external;

    /**
     * @dev Function to set inbound asset registry for the adapter.
     * @dev This registry keeps track of all the acceptable incoming assets, ensuring that the
     * adapter only processes predefined asset types.
     * @param asset Address of the asset.
     * @param isValid Boolean value suggesting if this is a valid inbound asset.
     */
    function setInboundAsset(address asset, bool isValid) external;

    /**
     * @dev Function to set outbound asset registry for the adapter.
     * @dev It manages the types of assets that the adapter is allowed to output, thus controlling
     * the flow’s output and maintaining consistency.
     * @param asset Address of the asset.
     * @param isValid Boolean value suggesting if this is a valid inbound asset.
     */
    function setOutboundAsset(address asset, bool isValid) external;
}

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

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 (uint256 supply);

    function balanceOf(address _owner) external view returns (uint256 balance);

    function transfer(
        address _to,
        uint256 _value
    ) external returns (bool success);

    function transferFrom(
        address _from,
        address _to,
        uint256 _value
    ) external returns (bool success);

    function approve(
        address _spender,
        uint256 _value
    ) external returns (bool success);

    function allowance(
        address _owner,
        address _spender
    ) external view returns (uint256 remaining);

    event Approval(
        address indexed _owner,
        address indexed _spender,
        uint256 _value
    );
}

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

import {IERC20} from "../utils/SafeERC20.sol";

abstract contract IWETH {
    function allowance(address, address) public view virtual returns (uint256);

    function balanceOf(address) public view virtual returns (uint256);

    function approve(address, uint256) public virtual;

    function transfer(address, uint256) public virtual returns (bool);

    function transferFrom(
        address,
        address,
        uint256
    ) public virtual returns (bool);

    function deposit() public payable virtual;

    function withdraw(uint256) public virtual;
}

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

import {BaseAdapter} from "./BaseAdapter.sol";
import {EoaExecutorWithDataProvider, EoaExecutorWithoutDataProvider} from "./utils/EoaExecutor.sol";

abstract contract RouterIntentEoaAdapterWithDataProvider is
    BaseAdapter,
    EoaExecutorWithDataProvider
{
    constructor(
        address __native,
        address __wnative,
        address __owner
    )
        BaseAdapter(__native, __wnative, true, __owner)
    // solhint-disable-next-line no-empty-blocks
    {

    }
}

abstract contract RouterIntentEoaAdapterWithoutDataProvider is
    BaseAdapter,
    EoaExecutorWithoutDataProvider
{
    constructor(
        address __native,
        address __wnative
    )
        BaseAdapter(__native, __wnative, false, address(0))
    // solhint-disable-next-line no-empty-blocks
    {

    }
}

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

library Address {
    //insufficient balance
    error InsufficientBalance(uint256 available, uint256 required);
    //unable to send value, recipient may have reverted
    error SendingValueFail();
    //insufficient balance for call
    error InsufficientBalanceForCall(uint256 available, uint256 required);
    //call to non-contract
    error NonContractCall();

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

    function sendValue(address payable recipient, uint256 amount) internal {
        uint256 balance = address(this).balance;
        if (balance < amount) {
            revert InsufficientBalance(balance, amount);
        }

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{value: amount}("");
        if (!(success)) {
            revert SendingValueFail();
        }
    }

    function functionCall(
        address target,
        bytes memory data
    ) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    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"
            );
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        uint256 balance = address(this).balance;
        if (balance < value) {
            revert InsufficientBalanceForCall(balance, value);
        }
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 weiValue,
        string memory errorMessage
    ) private returns (bytes memory) {
        if (!(isContract(target))) {
            revert NonContractCall();
        }

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

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

abstract contract EoaExecutorWithDataProvider {
    /**
     * @dev function to execute an action on an adapter used in an EOA.
     * @param precedingAdapter Address of the preceding adapter.
     * @param succeedingAdapter Address of the succeeding adapter.
     * @param data inputs data.
     * @return tokens to be refunded to user at the end of tx.
     */
    function execute(
        address precedingAdapter,
        address succeedingAdapter,
        bytes calldata data
    ) external payable virtual returns (address[] memory tokens);
}

abstract contract EoaExecutorWithoutDataProvider {
    /**
     * @dev function to execute an action on an adapter used in an EOA.
     * @param data inputs data.
     * @return tokens to be refunded to user at the end of tx.
     */
    function execute(
        bytes calldata data
    ) external payable virtual returns (address[] memory tokens);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.18;

/**
 * @title Errors library
 * @author Router Intents Error
 * @notice Defines the error messages emitted by the contracts on Router Intents
 */
library Errors {
    string public constant ARRAY_LENGTH_MISMATCH = "1"; // 'Array lengths mismatch'
    string public constant INSUFFICIENT_NATIVE_FUNDS_PASSED = "2"; // 'Insufficient native tokens passed'
    string public constant WRONG_BATCH_PROVIDED = "3"; // 'The targetLength, valueLength, callTypeLength, funcLength do not match in executeBatch transaction functions in batch transaction contract'
    string public constant INVALID_CALL_TYPE = "4"; // 'The callType value can only be 1 (call)' and 2(delegatecall)'
    string public constant ONLY_NITRO = "5"; // 'Only nitro can call this function'
    string public constant ONLY_SELF = "6"; // 'Only the current contract can call this function'
    string public constant ADAPTER_NOT_WHITELISTED = "7"; // 'Adapter not whitelisted'
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    error ReentrantCall();

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        if (_status == _ENTERED) {
            revert ReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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

import {IERC20} from "../interfaces/IERC20.sol";
import {Address} from "./Address.sol";
import {SafeMath} from "./SafeMath.sol";

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

    /// @dev Edited so it always first approves 0 and then the value, because of non standard tokens
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, 0)
        );
        _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
            )
        );
    }

    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        bytes memory returndata = address(token).functionCall(
            data,
            "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: operation failed"
            );
        }
    }
}

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

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    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: mul overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by 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;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

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

import {IWETH} from "../../../interfaces/IWETH.sol";

interface ILynexRouter {
    struct LynexSupplyData {
        address tokenA;
        address tokenB;
        bool stable;
        uint256 amountADesired;
        uint256 amountBDesired;
        uint256 amountAMin;
        uint256 amountBMin;
        address to;
        uint256 deadline;
    }

    /// @notice Add liquidity of two tokens to a Pool
    /// @param tokenA           .
    /// @param tokenB           .
    /// @param stable           True if pool is stable, false if volatile
    /// @param amountADesired   Amount of tokenA desired to deposit
    /// @param amountBDesired   Amount of tokenB desired to deposit
    /// @param amountAMin       Minimum amount of tokenA to deposit
    /// @param amountBMin       Minimum amount of tokenB to deposit
    /// @param to               Recipient of liquidity token
    /// @param deadline         Deadline to receive liquidity
    /// @return amountA         Amount of tokenA to actually deposit
    /// @return amountB         Amount of tokenB to actually deposit
    /// @return liquidity       Amount of liquidity token returned from deposit
    function addLiquidity(
        address tokenA,
        address tokenB,
        bool stable,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
}

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

import {ILynexRouter} from "./Interfaces.sol";

contract LynexHelpers {
    ILynexRouter public immutable lynexRouter;

    constructor(address __lynexRouter) {
        lynexRouter = ILynexRouter(__lynexRouter);
    }
}

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

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 (uint256 supply);

    function balanceOf(address _owner) external view returns (uint256 balance);

    function transfer(
        address _to,
        uint256 _value
    ) external returns (bool success);

    function transferFrom(
        address _from,
        address _to,
        uint256 _value
    ) external returns (bool success);

    function approve(
        address _spender,
        uint256 _value
    ) external returns (bool success);

    function allowance(
        address _owner,
        address _spender
    ) external view returns (uint256 remaining);

    event Approval(
        address indexed _owner,
        address indexed _spender,
        uint256 _value
    );
}

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

import {IERC20} from "../utils/SafeERC20.sol";

abstract contract IWETH {
    function allowance(address, address) public view virtual returns (uint256);

    function balanceOf(address) public view virtual returns (uint256);

    function approve(address, uint256) public virtual;

    function transfer(address, uint256) public virtual returns (bool);

    function transferFrom(
        address,
        address,
        uint256
    ) public virtual returns (bool);

    function deposit() public payable virtual;

    function withdraw(uint256) public virtual;
}

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

library Address {
    //insufficient balance
    error InsufficientBalance(uint256 available, uint256 required);
    //unable to send value, recipient may have reverted
    error SendingValueFail();
    //insufficient balance for call
    error InsufficientBalanceForCall(uint256 available, uint256 required);
    //call to non-contract
    error NonContractCall();

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

    function sendValue(address payable recipient, uint256 amount) internal {
        uint256 balance = address(this).balance;
        if (balance < amount) {
            revert InsufficientBalance(balance, amount);
        }

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{value: amount}("");
        if (!(success)) {
            revert SendingValueFail();
        }
    }

    function functionCall(
        address target,
        bytes memory data
    ) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    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"
            );
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        uint256 balance = address(this).balance;
        if (balance < value) {
            revert InsufficientBalanceForCall(balance, value);
        }
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 weiValue,
        string memory errorMessage
    ) private returns (bytes memory) {
        if (!(isContract(target))) {
            revert NonContractCall();
        }

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

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

import {IERC20} from "../interfaces/IERC20.sol";
import {Address} from "./Address.sol";
import {SafeMath} from "./SafeMath.sol";

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

    /// @dev Edited so it always first approves 0 and then the value, because of non standard tokens
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, 0)
        );
        _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
            )
        );
    }

    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        bytes memory returndata = address(token).functionCall(
            data,
            "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: operation failed"
            );
        }
    }
}

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

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    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: mul overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by 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;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 1000000
  },
  "viaIR": true,
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"__native","type":"address"},{"internalType":"address","name":"__wnative","type":"address"},{"internalType":"address","name":"__lynexRouter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"NonContractCall","type":"error"},{"inputs":[],"name":"ReentrantCall","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"string","name":"adapterName","type":"string"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"ExecutionEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"OperationFailedRefundEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"refundAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"UnsupportedOperation","type":"event"},{"inputs":[],"name":"adapterDataProvider","outputs":[{"internalType":"contract AdapterDataProvider","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"name":"execute","outputs":[{"internalType":"address[]","name":"tokens","type":"address[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"precedingContract","type":"address"}],"name":"isAuthorizedPrecedingContract","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"succeedingContract","type":"address"}],"name":"isAuthorizedSucceedingContract","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"}],"name":"isValidInboundAsset","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"}],"name":"isValidOutboundAsset","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lynexRouter","outputs":[{"internalType":"contract ILynexRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"native","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"name":"parseInputs","outputs":[{"components":[{"internalType":"address","name":"tokenA","type":"address"},{"internalType":"address","name":"tokenB","type":"address"},{"internalType":"bool","name":"stable","type":"bool"},{"internalType":"uint256","name":"amountADesired","type":"uint256"},{"internalType":"uint256","name":"amountBDesired","type":"uint256"},{"internalType":"uint256","name":"amountAMin","type":"uint256"},{"internalType":"uint256","name":"amountBMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct ILynexRouter.LynexSupplyData","name":"","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"self","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wnative","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee000000000000000000000000e5d7c2a44ffddf6b295a15c148167daaaf5cf34f000000000000000000000000610d2f07b7edc67565160f587f37636194c34e74

-----Decoded View---------------
Arg [0] : __native (address): 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE
Arg [1] : __wnative (address): 0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f
Arg [2] : __lynexRouter (address): 0x610D2f07b7EdC67565160F587F37636194C34E74

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
Arg [1] : 000000000000000000000000e5d7c2a44ffddf6b295a15c148167daaaf5cf34f
Arg [2] : 000000000000000000000000610d2f07b7edc67565160f587f37636194c34e74