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 {RouterIntentEoaAdapterWithoutDataProvider, EoaExecutorWithoutDataProvider} from "@routerprotocol/intents-core/contracts/RouterIntentEoaAdapter.sol";
import {Errors} from "../../Errors.sol";
import {IERC20, SafeERC20} from "../../utils/SafeERC20.sol";
import {IAssetBridge} from "../../interfaces/IAssetBridge.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

contract AssetBridgeDataStore is Ownable {
    address public assetBridge;

    constructor(address _owner, address _assetBridge) {
        _transferOwnership(_owner);
        assetBridge = _assetBridge;
    }

    function setAssetBridge(address _assetBridge) external onlyOwner {
        assetBridge = _assetBridge;
    }
}

/**
 * @title AssetBridgeAdapter
 * @author Yashika Goyal
 * @notice Adapter for bridging funds and instructions to another chain.
 */
contract AssetBridgeAdapter is RouterIntentEoaAdapterWithoutDataProvider {
    using SafeERC20 for IERC20;

    AssetBridgeDataStore public immutable assetBridgeDataStore;
    uint256 public constant PARTNER_ID = 1;

    constructor(
        address __native,
        address __wnative,
        address __assetBridge
    )
        RouterIntentEoaAdapterWithoutDataProvider(__native, __wnative)
    // solhint-disable-next-line no-empty-blocks
    {
        assetBridgeDataStore = new AssetBridgeDataStore(
            msg.sender,
            __assetBridge
        );
    }

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

    /**
     * @inheritdoc EoaExecutorWithoutDataProvider
     */
    function execute(
        bytes calldata data
    ) external payable override returns (address[] memory tokens) {
        // txType = 0 -> assetBridge transferToken
        // txType = 1 -> assetBridge swapAndTransferToken
        uint8 txType = abi.decode(data, (uint8));

        if (txType > 1) revert(Errors.INVALID_ASSET_BRDIGE_TX_TYPE);

        address[] memory _tokens = new address[](1);

        if (txType == 0) {
            (
                ,
                IAssetBridge.TransferPayload memory transferPayload,
                uint64 destGasLimit,
                bytes memory instruction
            ) = abi.decode(
                    data,
                    (uint8, IAssetBridge.TransferPayload, uint64 , bytes)
                );

            address assetBridge = assetBridgeDataStore.assetBridge();

            if (address(transferPayload.srcTokenAddress) == native()) {
                if (address(this) == self())
                    require(
                        msg.value == transferPayload.srcTokenAmount,
                        Errors.INSUFFICIENT_NATIVE_FUNDS_PASSED
                    );
                else if (transferPayload.srcTokenAmount == type(uint256).max)
                    transferPayload.srcTokenAmount = address(this).balance;

                _tokens[0] = native();

                if (instruction.length == 0) {
                    IAssetBridge(assetBridge).transferToken{
                        value: transferPayload.srcTokenAmount
                    }(transferPayload);
                } else
                    IAssetBridge(assetBridge).transferTokenWithInstruction{
                        value: transferPayload.srcTokenAmount
                    }(transferPayload, destGasLimit, instruction);
            } else {
                if (address(this) == self())
                    IERC20(transferPayload.srcTokenAddress).safeTransferFrom(
                        msg.sender,
                        address(this),
                        transferPayload.srcTokenAmount
                    );
                else if (transferPayload.srcTokenAmount == type(uint256).max)
                    transferPayload.srcTokenAmount = IERC20(transferPayload.srcTokenAddress).balanceOf(
                        address(this)
                    );

                IERC20(transferPayload.srcTokenAddress).safeIncreaseAllowance(
                    assetBridge,
                    transferPayload.srcTokenAmount
                );

                _tokens[0] = transferPayload.srcTokenAddress;

                if (instruction.length == 0)
                    IAssetBridge(assetBridge).transferToken(
                        transferPayload
                    );
                else
                    IAssetBridge(assetBridge).transferTokenWithInstruction(
                        transferPayload,
                        destGasLimit,
                        instruction
                    );
            }
        } else {
            (
                ,
                IAssetBridge.SwapTransferPayload memory swapTransferPayload,
                uint64 destGasLimit,
                bytes memory instruction
            ) = abi.decode(data, (uint8, IAssetBridge.SwapTransferPayload, uint64, bytes));

            address assetBridge = assetBridgeDataStore.assetBridge();

            if (address(swapTransferPayload.tokens[0]) == native()) {
                if (address(this) == self())
                    require(
                        msg.value == swapTransferPayload.srcTokenAmount,
                        Errors.INSUFFICIENT_NATIVE_FUNDS_PASSED
                    );
                else if (swapTransferPayload.srcTokenAmount == type(uint256).max)
                    swapTransferPayload.srcTokenAmount = address(this).balance;

                _tokens[0] = native();

                if (instruction.length == 0) {
                    IAssetBridge(assetBridge).swapAndTransferToken{
                        value: swapTransferPayload.srcTokenAmount
                    }(swapTransferPayload);
                } else
                    IAssetBridge(assetBridge).swapAndTransferTokenWithInstruction{
                        value: swapTransferPayload.srcTokenAmount
                    }(swapTransferPayload, destGasLimit, instruction);
            } else {
                if (address(this) == self())
                    IERC20(swapTransferPayload.tokens[0]).safeTransferFrom(
                        msg.sender,
                        address(this),
                        swapTransferPayload.srcTokenAmount
                    );
                else if (swapTransferPayload.srcTokenAmount == type(uint256).max)
                    swapTransferPayload.srcTokenAmount = IERC20(swapTransferPayload.tokens[0]).balanceOf(
                        address(this)
                    );

                IERC20(swapTransferPayload.tokens[0]).safeIncreaseAllowance(
                    assetBridge,
                    swapTransferPayload.srcTokenAmount
                );

                _tokens[0] = swapTransferPayload.tokens[0];

                if (instruction.length == 0)
                    IAssetBridge(assetBridge).swapAndTransferToken(
                        swapTransferPayload
                    );
                else
                    IAssetBridge(assetBridge).swapAndTransferTokenWithInstruction(
                        swapTransferPayload,
                        destGasLimit,
                        instruction
                    );
            }
        }
        emit ExecutionEvent(name(), data);
        return _tokens;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../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.
 *
 * By default, the owner account will be the one that deploys the contract. 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;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @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 {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _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);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

// 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: 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'
    string public constant INVALID_BRIDGE_ADDRESS = "8"; // 'Bridge address neither asset forwarder nor dexspan'
    string public constant BRIDGE_CALL_FAILED = "9"; // 'Bridge call failed'
    string public constant INVALID_BRDIGE_TX_TYPE = "10"; // 'Bridge tx type cannot be greater than 3'
    string public constant INVALID_AMOUNT = "11"; // 'Amount is invalid'
    string public constant INVALID_BRIDGE_CHAIN_ID = "12"; // 'Bridging chainId is invalid'
    string public constant ZERO_AMOUNT_RECEIVED = "13"; // 'Zero amount received'
    string public constant INVALID_TX_TYPE = "14"; // 'Invalid txType value'
    string public constant INVALID_REQUEST = "15"; // 'Invalid Request'
    string public constant INVALID_ASSET_BRDIGE_TX_TYPE = "16"; // 'Asset Bridge tx type cannot be greater than 1'
}

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

/// @title Interface for Voyager contracts that support deposits and deposit executions.
/// @author Router Protocol.

interface IAssetBridge {
    event TokenTransfer(
        bytes32 indexed destChainIdBytes,
        address indexed srcTokenAddress,
        uint256 srcTokenAmount,
        bytes recipient,
        uint256 partnerId,
        uint256 depositId
    );

    event TokenTransferWithInstruction(
        bytes32 indexed destChainIdBytes,
        address indexed srcTokenAddress,
        uint256 srcTokenAmount,
        bytes recipient,
        uint256 partnerId,
        uint64 destGasLimit,
        bytes instruction,
        uint256 depositId
    );

    event DepositReverted(
        bytes32 indexed destChainIdBytes,
        uint256 indexed depositNonce,
        address indexed sender,
        address srcSettlementToken,
        uint256 srcSettlementAmount
    );

    event Execute(
        uint8 executeType,
        bytes32 indexed sourceChainIdBytes,
        uint256 indexed depositNonce,
        address settlementToken,
        uint256 settlementAmount,
        address recipient
    );

    event ExecuteWithMessage(
        uint8 executeType,
        bytes32 indexed sourceChainIdBytes,
        uint256 indexed depositNonce,
        address settlementToken,
        uint256 settlementAmount,
        address recipient,
        bool flag,
        bytes data
    );
    struct ExecuteInfo {
        address recipient;
        address destTokenAddress;
        uint256 destTokenAmount;
        uint256 depositNonce;
    }

    struct DepositData {
        address sender;
        address srcTokenAddress;
        uint256 srcTokenAmount;
        uint256 depositNonce;
    }

    struct TransferPayload {
        bytes32 destChainIdBytes;
        address srcTokenAddress;
        uint256 srcTokenAmount;
        bytes recipient;
        uint256 partnerId;
    }
    
    struct SwapTransferPayload {
        bytes32 destChainIdBytes;
        address[] tokens; // index 0 will be src token and index n-1 will be to address
        uint256[] flags;
        bytes[] dataTx;
        uint256 srcTokenAmount;
        uint256 minToAmount;
        bytes recipient;
        uint256 partnerId;
    }

    function transferTokenWithInstruction(
        TransferPayload memory transferPayload,
        uint64 destGasLimit,
        bytes calldata instruction
    ) external payable;

    function transferToken(TransferPayload memory transferPayload) external payable;

    function swapAndTransferToken(SwapTransferPayload memory transferPayload) external payable;

    function swapAndTransferTokenWithInstruction(
        SwapTransferPayload memory transferPayload,
        uint64 destGasLimit,
        bytes calldata instruction
    ) external payable;
}

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

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":"__assetBridge","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":"PARTNER_ID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"adapterDataProvider","outputs":[{"internalType":"contract AdapterDataProvider","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"assetBridgeDataStore","outputs":[{"internalType":"contract AssetBridgeDataStore","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":"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":[],"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"}]

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

000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee0000000000000000000000000d500b1d8e8ef31e21c99d1db9a6444d3adf1270000000000000000000000000a62ec33abd6d7ebdf8ec98ce874820517ae71e4d

-----Decoded View---------------
Arg [0] : __native (address): 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE
Arg [1] : __wnative (address): 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270
Arg [2] : __assetBridge (address): 0xa62ec33AbD6d7eBdF8ec98ce874820517Ae71E4D

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
Arg [1] : 0000000000000000000000000d500b1d8e8ef31e21c99d1db9a6444d3adf1270
Arg [2] : 000000000000000000000000a62ec33abd6d7ebdf8ec98ce874820517ae71e4d