Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at fraxscan.com on 2024-04-11
*/

// Sources flattened with hardhat v2.19.1 https://hardhat.org

// SPDX-License-Identifier: MIT

// File @axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/[email protected]

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

// General interface for upgradable contracts
interface IContractIdentifier {
    /**
     * @notice Returns the contract ID. It can be used as a check during upgrades.
     * @dev Meant to be overridden in derived contracts.
     * @return bytes32 The contract ID
     */
    function contractId() external pure returns (bytes32);
}


// File @axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/[email protected]

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

interface IImplementation is IContractIdentifier {
    error NotProxy();

    function setup(bytes calldata data) external;
}


// File @axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/[email protected]

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    error InvalidAccount();

    /**
     * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

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


// File @axelar-network/axelar-gmp-sdk-solidity/contracts/libs/[email protected]

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

error TokenTransferFailed();

/*
 * @title SafeTokenCall
 * @dev This library is used for performing safe token transfers.
 */
library SafeTokenCall {
    /*
     * @notice Make a safe call to a token contract.
     * @param token The token contract to interact with.
     * @param callData The function call data.
     * @throws TokenTransferFailed error if transfer of token is not successful.
     */
    function safeCall(IERC20 token, bytes memory callData) internal {
        (bool success, bytes memory returnData) = address(token).call(callData);
        bool transferred = success && (returnData.length == uint256(0) || abi.decode(returnData, (bool)));

        if (!transferred || address(token).code.length == 0) revert TokenTransferFailed();
    }
}

/*
 * @title SafeTokenTransfer
 * @dev This library safely transfers tokens from the contract to a recipient.
 */
library SafeTokenTransfer {
    /*
     * @notice Transfer tokens to a recipient.
     * @param token The token contract.
     * @param receiver The recipient of the tokens.
     * @param amount The amount of tokens to transfer.
     */
    function safeTransfer(
        IERC20 token,
        address receiver,
        uint256 amount
    ) internal {
        SafeTokenCall.safeCall(token, abi.encodeWithSelector(IERC20.transfer.selector, receiver, amount));
    }
}

/*
 * @title SafeTokenTransferFrom
 * @dev This library helps to safely transfer tokens on behalf of a token holder.
 */
library SafeTokenTransferFrom {
    /*
     * @notice Transfer tokens on behalf of a token holder.
     * @param token The token contract.
     * @param from The address of the token holder.
     * @param to The address the tokens are to be sent to.
     * @param amount The amount of tokens to be transferred.
     */
    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 amount
    ) internal {
        SafeTokenCall.safeCall(token, abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, amount));
    }
}


// File @axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/[email protected]

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title ReentrancyGuard
 * @notice This contract provides a mechanism to halt the execution of specific functions
 * if a pause condition is activated.
 */
interface IReentrancyGuard {
    error ReentrantCall();
}


// File @axelar-network/axelar-gmp-sdk-solidity/contracts/utils/[email protected]

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title ReentrancyGuard
 * @notice This contract provides a mechanism to halt the execution of specific functions
 * if a pause condition is activated.
 */
contract ReentrancyGuard is IReentrancyGuard {
    // uint256(keccak256('ReentrancyGuard:entered')) - 1
    uint256 internal constant ENTERED_SLOT = 0x1a771c70cada93a906f955a7dec24a83d7954ba2f75256be4febcf62b395d532;
    uint256 internal constant NOT_ENTERED = 1;
    uint256 internal constant ENTERED = 2;

    /**
     * @notice A modifier that throws a ReEntrancy custom error if the contract is entered
     * @dev This modifier should be used with functions that can be entered twice
     */
    modifier noReEntrancy() {
        if (_hasEntered()) revert ReentrantCall();
        _setEntered(ENTERED);
        _;
        _setEntered(NOT_ENTERED);
    }

    /**
     * @notice Check if the contract is already executing.
     * @return entered A boolean representing the entered status. True if already executing, false otherwise.
     */
    function _hasEntered() internal view returns (bool entered) {
        assembly {
            entered := eq(sload(ENTERED_SLOT), ENTERED)
        }
    }

    /**
     * @notice Sets the entered status of the contract
     * @param entered A boolean representing the entered status. True if already executing, false otherwise.
     */
    function _setEntered(uint256 entered) internal {
        assembly {
            sstore(ENTERED_SLOT, entered)
        }
    }
}


// File @axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/[email protected]

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title IRolesBase Interface
 * @notice IRolesBase is an interface that abstracts the implementation of a
 * contract with role control internal functions.
 */
interface IRolesBase {
    error MissingRole(address account, uint8 role);
    error MissingAllRoles(address account, uint256 accountRoles);
    error MissingAnyOfRoles(address account, uint256 accountRoles);

    error InvalidProposedRoles(address fromAccount, address toAccount, uint256 accountRoles);

    event RolesProposed(address indexed fromAccount, address indexed toAccount, uint256 accountRoles);
    event RolesAdded(address indexed account, uint256 accountRoles);
    event RolesRemoved(address indexed account, uint256 accountRoles);

    /**
     * @notice Checks if an account has a role.
     * @param account The address to check
     * @param role The role to check
     * @return True if the account has the role, false otherwise
     */
    function hasRole(address account, uint8 role) external view returns (bool);
}


// File contracts/interfaces/IOperator.sol

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title IOperator Interface
 * @notice An interface for a contract module which provides a basic access control mechanism, where
 * there is an account (a operator) that can be granted exclusive access to specific functions.
 */
interface IOperator is IRolesBase {
    /**
     * @notice Change the operator of the contract.
     * @dev Can only be called by the current operator.
     * @param operator_ The address of the new operator.
     */
    function transferOperatorship(address operator_) external;

    /**
     * @notice Proposed a change of the operator of the contract.
     * @dev Can only be called by the current operator.
     * @param operator_ The address of the new operator.
     */
    function proposeOperatorship(address operator_) external;

    /**
     * @notice Accept a proposed change of operatorship.
     * @dev Can only be called by the proposed operator.
     * @param fromOperator The previous operator of the contract.
     */
    function acceptOperatorship(address fromOperator) external;

    /**
     * @notice Query if an address is a operator.
     * @param addr The address to query for.
     * @return bool Boolean value representing whether or not the address is an operator.
     */
    function isOperator(address addr) external view returns (bool);
}


// File contracts/interfaces/IBaseTokenManager.sol

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title IBaseTokenManager
 * @notice This contract is defines the base token manager interface implemented by all token managers.
 */
interface IBaseTokenManager {
    /**
     * @notice A function that returns the token id.
     */
    function interchainTokenId() external view returns (bytes32);

    /**
     * @notice A function that should return the address of the token.
     * Must be overridden in the inheriting contract.
     * @return address address of the token.
     */
    function tokenAddress() external view returns (address);

    /**
     * @notice A function that should return the token address from the init params.
     */
    function getTokenAddressFromParams(bytes calldata params) external pure returns (address);
}


// File contracts/interfaces/IFlowLimit.sol

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title FlowLimit Interface
 * @notice Interface for flow limit logic for interchain token transfers.
 */
interface IFlowLimit {
    error FlowLimitExceeded(uint256 limit, uint256 flowAmount, address tokenManager);

    event FlowLimitSet(bytes32 indexed tokenId, address operator, uint256 flowLimit_);

    /**
     * @notice Returns the current flow limit.
     * @return flowLimit_ The current flow limit value.
     */
    function flowLimit() external view returns (uint256 flowLimit_);

    /**
     * @notice Returns the current flow out amount.
     * @return flowOutAmount_ The current flow out amount.
     */
    function flowOutAmount() external view returns (uint256 flowOutAmount_);

    /**
     * @notice Returns the current flow in amount.
     * @return flowInAmount_ The current flow in amount.
     */
    function flowInAmount() external view returns (uint256 flowInAmount_);
}


// File contracts/interfaces/ITokenManager.sol

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;



/**
 * @title ITokenManager Interface
 * @notice This contract is responsible for managing tokens, such as setting locking token balances, or setting flow limits, for interchain transfers.
 */
interface ITokenManager is IBaseTokenManager, IOperator, IFlowLimit, IImplementation {
    error TokenLinkerZeroAddress();
    error NotService(address caller);
    error TakeTokenFailed();
    error GiveTokenFailed();
    error NotToken(address caller);
    error ZeroAddress();
    error AlreadyFlowLimiter(address flowLimiter);
    error NotFlowLimiter(address flowLimiter);
    error NotSupported();

    /**
     * @notice Returns implementation type of this token manager.
     * @return uint256 The implementation type of this token manager.
     */
    function implementationType() external view returns (uint256);

    function addFlowIn(uint256 amount) external;

    function addFlowOut(uint256 amount) external;

    /**
     * @notice This function adds a flow limiter for this TokenManager.
     * @dev Can only be called by the operator.
     * @param flowLimiter the address of the new flow limiter.
     */
    function addFlowLimiter(address flowLimiter) external;

    /**
     * @notice This function removes a flow limiter for this TokenManager.
     * @dev Can only be called by the operator.
     * @param flowLimiter the address of an existing flow limiter.
     */
    function removeFlowLimiter(address flowLimiter) external;

    /**
     * @notice Query if an address is a flow limiter.
     * @param addr The address to query for.
     * @return bool Boolean value representing whether or not the address is a flow limiter.
     */
    function isFlowLimiter(address addr) external view returns (bool);

    /**
     * @notice This function sets the flow limit for this TokenManager.
     * @dev Can only be called by the flow limiters.
     * @param flowLimit_ The maximum difference between the tokens flowing in and/or out at any given interval of time (6h).
     */
    function setFlowLimit(uint256 flowLimit_) external;

    /**
     * @notice A function to renew approval to the service if we need to.
     */
    function approveService() external;

    /**
     * @notice Getter function for the parameters of a lock/unlock TokenManager.
     * @dev This function will be mainly used by frontends.
     * @param operator_ The operator of the TokenManager.
     * @param tokenAddress_ The token to be managed.
     * @return params_ The resulting params to be passed to custom TokenManager deployments.
     */
    function params(bytes calldata operator_, address tokenAddress_) external pure returns (bytes memory params_);

    /**
     * @notice External function to allow the service to mint tokens through the tokenManager
     * @dev This function should revert if called by anyone but the service.
     * @param tokenAddress_ The address of the token, since its cheaper to pass it in instead of reading it as the token manager.
     * @param to The recipient.
     * @param amount The amount to mint.
     */
    function mintToken(address tokenAddress_, address to, uint256 amount) external;

    /**
     * @notice External function to allow the service to burn tokens through the tokenManager
     * @dev This function should revert if called by anyone but the service.
     * @param tokenAddress_ The address of the token, since its cheaper to pass it in instead of reading it as the token manager.
     * @param from The address to burn the token from.
     * @param amount The amount to burn.
     */
    function burnToken(address tokenAddress_, address from, uint256 amount) external;
}


// File contracts/interfaces/IERC20BurnableFrom.sol

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title IERC20BurnableFrom Interface
 * @notice Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20BurnableFrom {
    /**
     * @notice Function to burn tokens.
     * @dev Requires the caller to have allowance for `amount` on `from`.
     * Can only be called by the minter address.
     * @param from The address that will have its tokens burnt.
     * @param amount The amount of tokens to burn.
     */
    function burnFrom(address from, uint256 amount) external;
}


// File contracts/interfaces/IERC20MintableBurnable.sol

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title IERC20MintableBurnable Interface
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20MintableBurnable {
    /**
     * @notice Function to mint new tokens.
     * @dev Can only be called by the minter address.
     * @param to The address that will receive the minted tokens.
     * @param amount The amount of tokens to mint.
     */
    function mint(address to, uint256 amount) external;

    /**
     * @notice Function to burn tokens.
     * @dev Can only be called by the minter address.
     * @param from The address that will have its tokens burnt.
     * @param amount The amount of tokens to burn.
     */
    function burn(address from, uint256 amount) external;
}


// File contracts/interfaces/ITokenHandler.sol

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title ITokenHandler Interface
 * @notice This interface is responsible for handling tokens before initiating an interchain token transfer, or after receiving one.
 */
interface ITokenHandler {
    error UnsupportedTokenManagerType(uint256 tokenManagerType);

    /**
     * @notice This function gives token to a specified address from the token manager.
     * @param tokenManagerType The token manager type.
     * @param tokenAddress The address of the token to give.
     * @param tokenManager The address of the token manager.
     * @param to The address to give tokens to.
     * @param amount The amount of tokens to give.
     * @return uint256 The amount of token actually given, which could be different for certain token type.
     */
    function giveToken(
        uint256 tokenManagerType,
        address tokenAddress,
        address tokenManager,
        address to,
        uint256 amount
    ) external payable returns (uint256);

    /**
     * @notice This function takes token from a specified address to the token manager.
     * @param tokenManagerType The token manager type.
     * @param tokenAddress The address of the token to give.
     * @param tokenManager The address of the token manager.
     * @param from The address to take tokens from.
     * @param amount The amount of token to take.
     * @return uint256 The amount of token actually taken, which could be different for certain token type.
     */
    function takeToken(
        uint256 tokenManagerType,
        address tokenAddress,
        address tokenManager,
        address from,
        uint256 amount
    ) external payable returns (uint256);

    /**
     * @notice This function transfers token from and to a specified address.
     * @param tokenManagerType The token manager type.
     * @param tokenAddress the address of the token to give.
     * @param from The address to transfer tokens from.
     * @param to The address to transfer tokens to.
     * @param amount The amount of token to transfer.
     * @return uint256 The amount of token actually transferred, which could be different for certain token type.
     */
    function transferTokenFrom(
        uint256 tokenManagerType,
        address tokenAddress,
        address from,
        address to,
        uint256 amount
    ) external payable returns (uint256);
}


// File contracts/interfaces/ITokenManagerType.sol

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title ITokenManagerType Interface
 * @notice A simple interface that defines all the token manager types.
 */
interface ITokenManagerType {
    enum TokenManagerType {
        NATIVE_INTERCHAIN_TOKEN, // This type is reserved for interchain tokens deployed by ITS, and can't be used by custom token managers.
        MINT_BURN_FROM, // The token will be minted/burned on transfers. The token needs to give mint permission to the token manager, but burning happens via an approval.
        LOCK_UNLOCK, // The token will be locked/unlocked at the token manager.
        LOCK_UNLOCK_FEE, // The token will be locked/unlocked at the token manager, which will account for any fee-on-transfer behaviour.
        MINT_BURN // The token will be minted/burned on transfers. The token needs to give mint and burn permission to the token manager.
    }
}


// File contracts/TokenHandler.sol

// Original license: SPDX_License_Identifier: MIT

pragma solidity ^0.8.0;







/**
 * @title TokenHandler
 * @notice This interface is responsible for handling tokens before initiating an interchain token transfer, or after receiving one.
 */
contract TokenHandler is ITokenHandler, ITokenManagerType, ReentrancyGuard {
    using SafeTokenTransferFrom for IERC20;
    using SafeTokenCall for IERC20;

    /**
     * @notice This function gives token to a specified address from the token manager.
     * @param tokenManagerType The token manager type.
     * @param tokenAddress The address of the token to give.
     * @param tokenManager The address of the token manager.
     * @param to The address to give tokens to.
     * @param amount The amount of tokens to give.
     * @return uint256 The amount of token actually given, which could be different for certain token type.
     */
    // slither-disable-next-line locked-ether
    function giveToken(
        uint256 tokenManagerType,
        address tokenAddress,
        address tokenManager,
        address to,
        uint256 amount
    ) external payable returns (uint256) {
        if (tokenManagerType == uint256(TokenManagerType.NATIVE_INTERCHAIN_TOKEN)) {
            _giveInterchainToken(tokenAddress, to, amount);
            return amount;
        }

        if (tokenManagerType == uint256(TokenManagerType.MINT_BURN) || tokenManagerType == uint256(TokenManagerType.MINT_BURN_FROM)) {
            _mintToken(tokenManager, tokenAddress, to, amount);
            return amount;
        }

        if (tokenManagerType == uint256(TokenManagerType.LOCK_UNLOCK)) {
            _transferTokenFrom(tokenAddress, tokenManager, to, amount);
            return amount;
        }

        if (tokenManagerType == uint256(TokenManagerType.LOCK_UNLOCK_FEE)) {
            amount = _transferTokenFromWithFee(tokenAddress, tokenManager, to, amount);
            return amount;
        }

        revert UnsupportedTokenManagerType(tokenManagerType);
    }

    /**
     * @notice This function takes token from a specified address to the token manager.
     * @param tokenManagerType The token manager type.
     * @param tokenAddress The address of the token to give.
     * @param tokenManager The address of the token manager.
     * @param from The address to take tokens from.
     * @param amount The amount of token to take.
     * @return uint256 The amount of token actually taken, which could be different for certain token type.
     */
    // slither-disable-next-line locked-ether
    function takeToken(
        uint256 tokenManagerType,
        address tokenAddress,
        address tokenManager,
        address from,
        uint256 amount
    ) external payable returns (uint256) {
        if (tokenManagerType == uint256(TokenManagerType.NATIVE_INTERCHAIN_TOKEN)) {
            _takeInterchainToken(tokenAddress, from, amount);
            return amount;
        }

        if (tokenManagerType == uint256(TokenManagerType.MINT_BURN)) {
            _burnToken(tokenManager, tokenAddress, from, amount);
            return amount;
        }

        if (tokenManagerType == uint256(TokenManagerType.MINT_BURN_FROM)) {
            _burnTokenFrom(tokenAddress, from, amount);
            return amount;
        }

        if (tokenManagerType == uint256(TokenManagerType.LOCK_UNLOCK)) {
            _transferTokenFrom(tokenAddress, from, tokenManager, amount);
            return amount;
        }

        if (tokenManagerType == uint256(TokenManagerType.LOCK_UNLOCK_FEE)) {
            amount = _transferTokenFromWithFee(tokenAddress, from, tokenManager, amount);
            return amount;
        }

        revert UnsupportedTokenManagerType(tokenManagerType);
    }

    /**
     * @notice This function transfers token from and to a specified address.
     * @param tokenManagerType The token manager type.
     * @param tokenAddress the address of the token to give.
     * @param from The address to transfer tokens from.
     * @param to The address to transfer tokens to.
     * @param amount The amount of token to transfer.
     * @return uint256 The amount of token actually transferred, which could be different for certain token type.
     */
    // slither-disable-next-line locked-ether
    function transferTokenFrom(
        uint256 tokenManagerType,
        address tokenAddress,
        address from,
        address to,
        uint256 amount
    ) external payable returns (uint256) {
        if (
            tokenManagerType == uint256(TokenManagerType.NATIVE_INTERCHAIN_TOKEN) ||
            tokenManagerType == uint256(TokenManagerType.LOCK_UNLOCK) ||
            tokenManagerType == uint256(TokenManagerType.MINT_BURN) ||
            tokenManagerType == uint256(TokenManagerType.MINT_BURN_FROM)
        ) {
            _transferTokenFrom(tokenAddress, from, to, amount);
            return amount;
        }

        if (tokenManagerType == uint256(TokenManagerType.LOCK_UNLOCK_FEE)) {
            amount = _transferTokenFromWithFee(tokenAddress, from, to, amount);
            return amount;
        }

        revert UnsupportedTokenManagerType(tokenManagerType);
    }

    function _transferTokenFrom(address tokenAddress, address from, address to, uint256 amount) internal {
        // slither-disable-next-line arbitrary-send-erc20
        IERC20(tokenAddress).safeTransferFrom(from, to, amount);
    }

    function _transferTokenFromWithFee(
        address tokenAddress,
        address from,
        address to,
        uint256 amount
    ) internal noReEntrancy returns (uint256) {
        uint256 balanceBefore = IERC20(tokenAddress).balanceOf(to);

        _transferTokenFrom(tokenAddress, from, to, amount);

        uint256 diff = IERC20(tokenAddress).balanceOf(to) - balanceBefore;
        if (diff < amount) {
            amount = diff;
        }

        return amount;
    }

    function _giveInterchainToken(address tokenAddress, address to, uint256 amount) internal {
        IERC20(tokenAddress).safeCall(abi.encodeWithSelector(IERC20MintableBurnable.mint.selector, to, amount));
    }

    function _takeInterchainToken(address tokenAddress, address from, uint256 amount) internal {
        IERC20(tokenAddress).safeCall(abi.encodeWithSelector(IERC20MintableBurnable.burn.selector, from, amount));
    }

    function _mintToken(address tokenManager, address tokenAddress, address to, uint256 amount) internal {
        ITokenManager(tokenManager).mintToken(tokenAddress, to, amount);
    }

    function _burnToken(address tokenManager, address tokenAddress, address from, uint256 amount) internal {
        ITokenManager(tokenManager).burnToken(tokenAddress, from, amount);
    }

    function _burnTokenFrom(address tokenAddress, address from, uint256 amount) internal {
        IERC20(tokenAddress).safeCall(abi.encodeWithSelector(IERC20BurnableFrom.burnFrom.selector, from, amount));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"ReentrantCall","type":"error"},{"inputs":[],"name":"TokenTransferFailed","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenManagerType","type":"uint256"}],"name":"UnsupportedTokenManagerType","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenManagerType","type":"uint256"},{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"address","name":"tokenManager","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"giveToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenManagerType","type":"uint256"},{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"address","name":"tokenManager","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"takeToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenManagerType","type":"uint256"},{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferTokenFrom","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"}]

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

22170:6845:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26308:914;;;;;;:::i;:::-;;:::i;:::-;;;838:25:1;;;826:2;811:18;26308:914:0;;;;;;;22880:1101;;;;;;:::i;:::-;;:::i;24536:1222::-;;;;;;:::i;:::-;;:::i;26308:914::-;26503:7;26541:69;;;:143;;-1:-1:-1;26655:28:0;26627:16;:57;26541:143;:215;;;-1:-1:-1;26729:26:0;26701:16;:55;26541:215;:292;;;-1:-1:-1;26801:31:0;26773:16;:60;26541:292;26523:427;;;26860:50;26879:12;26893:4;26899:2;26903:6;26860:18;:50::i;:::-;-1:-1:-1;26932:6:0;26925:13;;26523:427;26994:32;26966:16;:61;26962:188;;27053:57;27079:12;27093:4;27099:2;27103:6;27053:25;:57::i;:::-;27044:66;;27132:6;27125:13;;;;26962:188;27169:45;;;;;;;;838:25:1;;;811:18;;27169:45:0;;;;;;;26308:914;;;;;;;;:::o;22880:1101::-;23075:7;23099:16;23095:176;;23185:46;23206:12;23220:2;23224:6;23185:20;:46::i;23095:176::-;23315:26;23287:16;:55;:119;;;-1:-1:-1;23374:31:0;23346:16;:60;23287:119;23283:230;;;23423:50;23434:12;23448;23462:2;23466:6;23423:10;:50::i;23283:230::-;23557:28;23529:16;:57;23525:176;;23603:58;23622:12;23636;23650:2;23654:6;23603:18;:58::i;24536:1222::-;24733:7;24757:16;24753:178;;24843:48;24864:12;24878:4;24884:6;24843:20;:48::i;24753:178::-;24975:26;24947:16;:55;24943:168;;25019:52;25030:12;25044;25058:4;25064:6;25019:10;:52::i;24943:168::-;25155:31;25127:16;:60;25123:163;;25204:42;25219:12;25233:4;25239:6;25204:14;:42::i;25123:163::-;25330:28;25302:16;:57;25298:178;;25376:60;25395:12;25409:4;25415:12;25429:6;25376:18;:60::i;25298:178::-;25520:32;25492:16;:61;25488:198;;25579:67;25605:12;25619:4;25625:12;25639:6;25579:25;:67::i;27230:234::-;27401:55;-1:-1:-1;;;;;27401:37:0;;27439:4;27445:2;27449:6;27401:37;:55::i;:::-;27230:234;;;;:::o;27472:495::-;27645:7;7472:13;7907:12;7901:19;7922:7;7898:32;;7792:156;7472:13;7468:41;;;7494:15;;;;;;;;;;;;;;7468:41;7520:20;7230:1;8229:12;8222:29;8140:129;7520:20;27689:34:::1;::::0;-1:-1:-1;;;27689:34:0;;-1:-1:-1;;;;;1227:55:1;;;27689:34:0::1;::::0;::::1;1209:74:1::0;27665:21:0::1;::::0;27689:30;;::::1;::::0;::::1;::::0;1182:18:1;;27689:34:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;27665:58;;27736:50;27755:12;27769:4;27775:2;27779:6;27736:18;:50::i;:::-;27814:34;::::0;-1:-1:-1;;;27814:34:0;;-1:-1:-1;;;;;1227:55:1;;;27814:34:0::1;::::0;::::1;1209:74:1::0;27799:12:0::1;::::0;27851:13;;27814:30;::::1;::::0;::::1;::::0;1182:18:1;;27814:34:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:50;;;;:::i;:::-;27799:65;;27886:6;27879:4;:13;27875:59;;;27918:4;27909:13;;27875:59;-1:-1:-1::0;;7186:1:0;8229:12;8222:29;-1:-1:-1;27953:6:0;27472:495;-1:-1:-1;;;27472:495:0:o;27975:211::-;28105:72;;-1:-1:-1;;;;;1962:55:1;;28105:72:0;;;1944:74:1;2034:18;;;2027:34;;;28075:103:0;;28128:36;;1917:18:1;;28105:72:0;;;;-1:-1:-1;;28105:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;28075:29:0;;;;:103::i;:::-;27975:211;;;:::o;28417:183::-;28529:63;;;;;-1:-1:-1;;;;;2353:15:1;;;28529:63:0;;;2335:34:1;2405:15;;;2385:18;;;2378:43;2437:18;;;2430:34;;;28529:37:0;;;;;2247:18:1;;28529:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28417:183;;;;:::o;28194:215::-;28326:74;;-1:-1:-1;;;;;1962:55:1;;28326:74:0;;;1944::1;2034:18;;;2027:34;;;28296:105:0;;28349:36;;1917:18:1;;28326:74:0;1770:297:1;28608:187:0;28722:65;;;;;-1:-1:-1;;;;;2353:15:1;;;28722:65:0;;;2335:34:1;2405:15;;;2385:18;;;2378:43;2437:18;;;2430:34;;;28722:37:0;;;;;2247:18:1;;28722:65:0;2072:398:1;28803:209:0;28929:74;;-1:-1:-1;;;;;1962:55:1;;28929:74:0;;;1944::1;2034:18;;;2027:34;;;28899:105:0;;28952:36;;1917:18:1;;28929:74:0;1770:297:1;5906:254:0;6081:70;;;-1:-1:-1;;;;;2353:15:1;;;6081:70:0;;;2335:34:1;2405:15;;2385:18;;;2378:43;2437:18;;;;2430:34;;;6081:70:0;;;;;;;;;;2247:18:1;;;;6081:70:0;;;;;;;;;;6104:28;6081:70;;;6051:101;;6074:5;;4485:356;4561:12;4575:23;4610:5;-1:-1:-1;;;;;4602:19:0;4622:8;4602:29;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4560:71;;;;4642:16;4661:7;:78;;;;-1:-1:-1;4673:17:0;;:31;;:65;;;4719:10;4708:30;;;;;;;;;;;;:::i;:::-;4642:97;;4757:11;4756:12;:47;;;-1:-1:-1;;;;;;4772:26:0;;;:31;4756:47;4752:81;;;4812:21;;;;;;;;;;;;;;4752:81;4549:292;;;4485:356;;:::o;14:196:1:-;82:20;;-1:-1:-1;;;;;131:54:1;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:472::-;310:6;318;326;334;342;395:3;383:9;374:7;370:23;366:33;363:53;;;412:1;409;402:12;363:53;448:9;435:23;425:33;;477:38;511:2;500:9;496:18;477:38;:::i;:::-;467:48;;534:38;568:2;557:9;553:18;534:38;:::i;:::-;524:48;;591:38;625:2;614:9;610:18;591:38;:::i;:::-;215:472;;;;-1:-1:-1;215:472:1;;676:3;661:19;648:33;;215:472;-1:-1:-1;;215:472:1:o;1294:184::-;1364:6;1417:2;1405:9;1396:7;1392:23;1388:32;1385:52;;;1433:1;1430;1423:12;1385:52;-1:-1:-1;1456:16:1;;1294:184;-1:-1:-1;1294:184:1:o;1483:282::-;1550:9;;;1571:11;;;1568:191;;;1615:77;1612:1;1605:88;1716:4;1713:1;1706:15;1744:4;1741:1;1734:15;1568:191;1483:282;;;;:::o;2475:412::-;2604:3;2642:6;2636:13;2667:1;2677:129;2691:6;2688:1;2685:13;2677:129;;;2789:4;2773:14;;;2769:25;;2763:32;2750:11;;;2743:53;2706:12;2677:129;;;-1:-1:-1;2861:1:1;2825:16;;2850:13;;;-1:-1:-1;2825:16:1;2475:412;-1:-1:-1;2475:412:1:o;2892:277::-;2959:6;3012:2;3000:9;2991:7;2987:23;2983:32;2980:52;;;3028:1;3025;3018:12;2980:52;3060:9;3054:16;3113:5;3106:13;3099:21;3092:5;3089:32;3079:60;;3135:1;3132;3125:12;3079:60;3158:5;2892:277;-1:-1:-1;;;2892:277:1:o

ipfs://6fcf6c1f7270e2d23ad329ed23b2c84d1a3abc01ba1e18ca2b7b3a219194a0e4