Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;

import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { AccessControlInternal } from "@solidstate/contracts/access/access_control/AccessControlInternal.sol";

contract FeeContract is Ownable, AccessControlInternal {
    bytes32 internal constant SWAP_ROLE = keccak256("SWAP_ROLE");
    event SwapResult(bool success, bytes data);

    function addSwapRole(address account) external onlyOwner {
        _grantRole(SWAP_ROLE, account);
    }

    function removeRole(address account) external onlyOwner {
        _revokeRole(SWAP_ROLE, account);
    }

    function getSwapRoleMember(uint256 index) public view returns (address) {
        return _getRoleMember(SWAP_ROLE, index);
    }

    function getSwapRoleMemberCount() public view returns (uint256) {
        return _getRoleMemberCount(SWAP_ROLE);
    }

    function swap(address router, address _targetTokenAddress, bytes calldata _data) external onlyRole(SWAP_ROLE) {
        IERC20 targetToken = IERC20(_targetTokenAddress);
        uint256 balance = targetToken.balanceOf(address(this));
        targetToken.approve(router, 0);
        targetToken.approve(router, balance);

        (bool swapSuccess, bytes memory data) = router.call(_data);
        targetToken.approve(router, 0);
        emit SwapResult(swapSuccess, data);

        if (!swapSuccess) {
            revert("Swap failed.");
        }
    }

    function transferNative(address _to, uint256 _amount) public onlyOwner {
        if (_amount == type(uint256).max) {
            _amount = address(this).balance;
        }

        (bool success, bytes memory result) = _to.call{ value: _amount }("");
        if (!success) {
            string memory errorMessage = string(result);
            revert(errorMessage);
        }
    }

    function emergencyWithdraw(address _token, address _to, uint256 _amount) public onlyOwner {
        IERC20 token = IERC20(_token);
        uint256 balance = token.balanceOf(address(this));
        if (_amount == type(uint256).max) {
            _amount = balance;
        }

        token.transfer(_to, balance);
    }

    receive() external payable {
        // This function is executed when a contract receives plain Ether (without data)
    }
}

// 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 (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (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;
    }

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { EnumerableSet } from '../../data/EnumerableSet.sol';
import { AddressUtils } from '../../utils/AddressUtils.sol';
import { UintUtils } from '../../utils/UintUtils.sol';
import { IAccessControlInternal } from './IAccessControlInternal.sol';
import { AccessControlStorage } from './AccessControlStorage.sol';

/**
 * @title Role-based access control system
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts (MIT license)
 */
abstract contract AccessControlInternal is IAccessControlInternal {
    using AddressUtils for address;
    using EnumerableSet for EnumerableSet.AddressSet;
    using UintUtils for uint256;

    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /*
     * @notice query whether role is assigned to account
     * @param role role to query
     * @param account account to query
     * @return whether role is assigned to account
     */
    function _hasRole(
        bytes32 role,
        address account
    ) internal view virtual returns (bool) {
        return
            AccessControlStorage.layout().roles[role].members.contains(account);
    }

    /**
     * @notice revert if sender does not have given role
     * @param role role to query
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, msg.sender);
    }

    /**
     * @notice revert if given account does not have given role
     * @param role role to query
     * @param account to query
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!_hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        'AccessControl: account ',
                        account.toString(),
                        ' is missing role ',
                        uint256(role).toHexString(32)
                    )
                )
            );
        }
    }

    /*
     * @notice query admin role for given role
     * @param role role to query
     * @return admin role
     */
    function _getRoleAdmin(
        bytes32 role
    ) internal view virtual returns (bytes32) {
        return AccessControlStorage.layout().roles[role].adminRole;
    }

    /**
     * @notice set role as admin role
     * @param role role to set
     * @param adminRole admin role to set
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = _getRoleAdmin(role);
        AccessControlStorage.layout().roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /*
     * @notice assign role to given account
     * @param role role to assign
     * @param account recipient of role assignment
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        AccessControlStorage.layout().roles[role].members.add(account);
        emit RoleGranted(role, account, msg.sender);
    }

    /*
     * @notice unassign role from given account
     * @param role role to unassign
     * @parm account
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        AccessControlStorage.layout().roles[role].members.remove(account);
        emit RoleRevoked(role, account, msg.sender);
    }

    /**
     * @notice relinquish role
     * @param role role to relinquish
     */
    function _renounceRole(bytes32 role) internal virtual {
        _revokeRole(role, msg.sender);
    }

    /**
     * @notice query role for member at given index
     * @param role role to query
     * @param index index to query
     */
    function _getRoleMember(
        bytes32 role,
        uint256 index
    ) internal view virtual returns (address) {
        return AccessControlStorage.layout().roles[role].members.at(index);
    }

    /**
     * @notice query role for member count
     * @param role role to query
     */
    function _getRoleMemberCount(
        bytes32 role
    ) internal view virtual returns (uint256) {
        return AccessControlStorage.layout().roles[role].members.length();
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { EnumerableSet } from '../../data/EnumerableSet.sol';

library AccessControlStorage {
    struct RoleData {
        EnumerableSet.AddressSet members;
        bytes32 adminRole;
    }

    struct Layout {
        mapping(bytes32 => RoleData) roles;
    }

    bytes32 internal constant DEFAULT_ADMIN_ROLE = 0x00;

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.AccessControl');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title Partial AccessControl interface needed by internal functions
 */
interface IAccessControlInternal {
    event RoleAdminChanged(
        bytes32 indexed role,
        bytes32 indexed previousAdminRole,
        bytes32 indexed newAdminRole
    );

    event RoleGranted(
        bytes32 indexed role,
        address indexed account,
        address indexed sender
    );

    event RoleRevoked(
        bytes32 indexed role,
        address indexed account,
        address indexed sender
    );
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

/**
 * @title Set implementation with enumeration functions
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts (MIT license)
 */
library EnumerableSet {
    error EnumerableSet__IndexOutOfBounds();

    struct Set {
        bytes32[] _values;
        // 1-indexed to allow 0 to signify nonexistence
        mapping(bytes32 => uint256) _indexes;
    }

    struct Bytes32Set {
        Set _inner;
    }

    struct AddressSet {
        Set _inner;
    }

    struct UintSet {
        Set _inner;
    }

    function at(
        Bytes32Set storage set,
        uint256 index
    ) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    function at(
        AddressSet storage set,
        uint256 index
    ) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    function at(
        UintSet storage set,
        uint256 index
    ) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    function contains(
        Bytes32Set storage set,
        bytes32 value
    ) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    function contains(
        AddressSet storage set,
        address value
    ) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    function contains(
        UintSet storage set,
        uint256 value
    ) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    function indexOf(
        Bytes32Set storage set,
        bytes32 value
    ) internal view returns (uint256) {
        return _indexOf(set._inner, value);
    }

    function indexOf(
        AddressSet storage set,
        address value
    ) internal view returns (uint256) {
        return _indexOf(set._inner, bytes32(uint256(uint160(value))));
    }

    function indexOf(
        UintSet storage set,
        uint256 value
    ) internal view returns (uint256) {
        return _indexOf(set._inner, bytes32(value));
    }

    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function add(
        Bytes32Set storage set,
        bytes32 value
    ) internal returns (bool) {
        return _add(set._inner, value);
    }

    function add(
        AddressSet storage set,
        address value
    ) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    function remove(
        Bytes32Set storage set,
        bytes32 value
    ) internal returns (bool) {
        return _remove(set._inner, value);
    }

    function remove(
        AddressSet storage set,
        address value
    ) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    function remove(
        UintSet storage set,
        uint256 value
    ) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    function toArray(
        Bytes32Set storage set
    ) internal view returns (bytes32[] memory) {
        return set._inner._values;
    }

    function toArray(
        AddressSet storage set
    ) internal view returns (address[] memory) {
        bytes32[] storage values = set._inner._values;
        address[] storage array;

        assembly {
            array.slot := values.slot
        }

        return array;
    }

    function toArray(
        UintSet storage set
    ) internal view returns (uint256[] memory) {
        bytes32[] storage values = set._inner._values;
        uint256[] storage array;

        assembly {
            array.slot := values.slot
        }

        return array;
    }

    function _at(
        Set storage set,
        uint256 index
    ) private view returns (bytes32) {
        if (index >= set._values.length)
            revert EnumerableSet__IndexOutOfBounds();
        return set._values[index];
    }

    function _contains(
        Set storage set,
        bytes32 value
    ) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    function _indexOf(
        Set storage set,
        bytes32 value
    ) private view returns (uint256) {
        unchecked {
            return set._indexes[value] - 1;
        }
    }

    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    function _add(
        Set storage set,
        bytes32 value
    ) private returns (bool status) {
        if (!_contains(set, value)) {
            set._values.push(value);
            set._indexes[value] = set._values.length;
            status = true;
        }
    }

    function _remove(
        Set storage set,
        bytes32 value
    ) private returns (bool status) {
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            unchecked {
                bytes32 last = set._values[set._values.length - 1];

                // move last value to now-vacant index

                set._values[valueIndex - 1] = last;
                set._indexes[last] = valueIndex;
            }
            // clear last index

            set._values.pop();
            delete set._indexes[value];

            status = true;
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { UintUtils } from './UintUtils.sol';

library AddressUtils {
    using UintUtils for uint256;

    error AddressUtils__InsufficientBalance();
    error AddressUtils__NotContract();
    error AddressUtils__SendValueFailed();

    function toString(address account) internal pure returns (string memory) {
        return uint256(uint160(account)).toHexString(20);
    }

    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function sendValue(address payable account, uint256 amount) internal {
        (bool success, ) = account.call{ value: amount }('');
        if (!success) revert AddressUtils__SendValueFailed();
    }

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

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

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                'AddressUtils: failed low-level call with value'
            );
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory error
    ) internal returns (bytes memory) {
        if (value > address(this).balance)
            revert AddressUtils__InsufficientBalance();
        return _functionCallWithValue(target, data, value, error);
    }

    /**
     * @notice execute arbitrary external call with limited gas usage and amount of copied return data
     * @dev derived from https://github.com/nomad-xyz/ExcessivelySafeCall (MIT License)
     * @param target recipient of call
     * @param gasAmount gas allowance for call
     * @param value native token value to include in call
     * @param maxCopy maximum number of bytes to copy from return data
     * @param data encoded call data
     * @return success whether call is successful
     * @return returnData copied return data
     */
    function excessivelySafeCall(
        address target,
        uint256 gasAmount,
        uint256 value,
        uint16 maxCopy,
        bytes memory data
    ) internal returns (bool success, bytes memory returnData) {
        returnData = new bytes(maxCopy);

        assembly {
            // execute external call via assembly to avoid automatic copying of return data
            success := call(
                gasAmount,
                target,
                value,
                add(data, 0x20),
                mload(data),
                0,
                0
            )

            // determine whether to limit amount of data to copy
            let toCopy := returndatasize()

            if gt(toCopy, maxCopy) {
                toCopy := maxCopy
            }

            // store the length of the copied bytes
            mstore(returnData, toCopy)

            // copy the bytes from returndata[0:toCopy]
            returndatacopy(add(returnData, 0x20), 0, toCopy)
        }
    }

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory error
    ) private returns (bytes memory) {
        if (!isContract(target)) revert AddressUtils__NotContract();

        (bool success, bytes memory returnData) = target.call{ value: value }(
            data
        );

        if (success) {
            return returnData;
        } else if (returnData.length > 0) {
            assembly {
                let returnData_size := mload(returnData)
                revert(add(32, returnData), returnData_size)
            }
        } else {
            revert(error);
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

/**
 * @title utility functions for uint256 operations
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts/ (MIT license)
 */
library UintUtils {
    error UintUtils__InsufficientHexLength();

    bytes16 private constant HEX_SYMBOLS = '0123456789abcdef';

    function add(uint256 a, int256 b) internal pure returns (uint256) {
        return b < 0 ? sub(a, -b) : a + uint256(b);
    }

    function sub(uint256 a, int256 b) internal pure returns (uint256) {
        return b < 0 ? add(a, -b) : a - uint256(b);
    }

    function toString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return '0';
        }

        uint256 temp = value;
        uint256 digits;

        while (temp != 0) {
            digits++;
            temp /= 10;
        }

        bytes memory buffer = new bytes(digits);

        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }

        return string(buffer);
    }

    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return '0x00';
        }

        uint256 length = 0;

        for (uint256 temp = value; temp != 0; temp >>= 8) {
            unchecked {
                length++;
            }
        }

        return toHexString(value, length);
    }

    function toHexString(
        uint256 value,
        uint256 length
    ) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = '0';
        buffer[1] = 'x';

        unchecked {
            for (uint256 i = 2 * length + 1; i > 1; --i) {
                buffer[i] = HEX_SYMBOLS[value & 0xf];
                value >>= 4;
            }
        }

        if (value != 0) revert UintUtils__InsufficientHexLength();

        return string(buffer);
    }
}

{
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "none",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 10
  },
  "remappings": [],
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"EnumerableSet__IndexOutOfBounds","type":"error"},{"inputs":[],"name":"UintUtils__InsufficientHexLength","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"success","type":"bool"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"SwapResult","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addSwapRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getSwapRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSwapRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"removeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"router","type":"address"},{"internalType":"address","name":"_targetTokenAddress","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"swap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transferNative","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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