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.27;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IDXITokenMigration} from "./interfaces/IDXITokenMigration.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/// @title DXI Token Migration
/// @author DacxiChain Labs (Bruno Gasparin, Jean Prado, Ricardo Hildebrand)
/// @notice This is the migration contract for DACXI <-> DXIToken ERC20 token on Ethereum L1
/// @dev The contract allows for a 1-to-1 conversion from $DACXI into $DXI
/// @custom:security-contact [email protected]
contract DXITokenMigration is Ownable, IDXITokenMigration {
    using SafeERC20 for IERC20;

    /// @inheritdoc IDXITokenMigration
    IERC20 public immutable dacxi;

    /// @inheritdoc IDXITokenMigration
    IERC20 public dxi;

    // --- Whitelist ---
    bool public isWhitelistEnabled = true;
    mapping(address => bool) private whitelist;
    uint32 private constant WHITELIST_DISABLE_DELAY = 5 days;
    uint256 public whitelistDisableTimestamp = 0;

    /// @param dacxi_ $DACXI contract address
    constructor(address dacxi_) Ownable(msg.sender) {
        if (dacxi_ == address(0)) revert InvalidAddress();

        dacxi = IERC20(dacxi_);
    }

    /// @inheritdoc IDXITokenMigration
    function setDXIToken(address dxi_) external onlyOwner {
        if (dxi_ == address(0)) revert InvalidAddress();
        if (address(dxi) != address(0)) revert DXITokenAddressAlreadySet();

        emit DXITokenAdded(dxi_);

        dxi = IERC20(dxi_);
    }

    /// @inheritdoc IDXITokenMigration
    function migrate(uint256 amount) external {
        if (address(dxi) == address(0)) revert DXITokenAddressNotSet();
        if (!_whitelistHasAddress(msg.sender)) revert AddressNotInWhitelist();

        emit Migrated(msg.sender, amount);

        dacxi.safeTransferFrom(msg.sender, address(this), amount);
        dxi.safeTransfer(msg.sender, amount);
    }

    /// @inheritdoc IDXITokenMigration
    function addToWhitelist(address account) external onlyOwner {
        emit AddressWhitelistStatusChanged(account, true);

        whitelist[account] = true;
    }

    /// @inheritdoc IDXITokenMigration
    function removeFromWhitelist(address account) external onlyOwner {
        emit AddressWhitelistStatusChanged(account, false);

        whitelist[account] = false;
    }

    /// @inheritdoc IDXITokenMigration
    function isInWhitelist(address account) external view returns (bool) {
        return _whitelistHasAddress(account);
    }

    /// @inheritdoc IDXITokenMigration
    function checkMyWhitelistStatus() external view returns (bool) {
        return _whitelistHasAddress(_msgSender());
    }

    /// @inheritdoc IDXITokenMigration
    function initiateWhitelistDisable() external onlyOwner {
        whitelistDisableTimestamp = block.timestamp + WHITELIST_DISABLE_DELAY;

        emit WhitelistDisableInitiated(whitelistDisableTimestamp);
    }

    /// @inheritdoc IDXITokenMigration
    function finalizeWhitelistDisable() external onlyOwner {
        //slither-disable-next-line timestamp
        if (whitelistDisableTimestamp == 0) revert WhitelistDisabledNotInitiated();

        //slither-disable-next-line timestamp
        if (block.timestamp < whitelistDisableTimestamp) {
            revert WhitelistDisableEnforcedDelay(whitelistDisableTimestamp);
        }

        emit WhitelistDisabled();

        isWhitelistEnabled = false;
    }

    /// @inheritdoc IDXITokenMigration
    function cancelWhitelistDisable() external onlyOwner {
        //slither-disable-next-line timestamp
        if (whitelistDisableTimestamp == 0) revert WhitelistDisabledNotInitiated();

        emit WhitelistDisableCancelled();

        whitelistDisableTimestamp = 0;
    }

    /// @dev See {Ownable-renounceOwnership}.
    function renounceOwnership() public override(Ownable) onlyOwner {
        if (isWhitelistEnabled) revert WhitelistNotDisabled();

        super.renounceOwnership();
    }

    /// @dev Check if an address is in the whitelist
    /// @param account account
    function _whitelistHasAddress(address account) private view returns (bool) {
        if (!isWhitelistEnabled) return true;

        return whitelist[account];
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

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

import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";

/// @title Dacxi Token Migration
/// @author DacxiChain Labs (Bruno Gasparin, Jean Prado, Ricardo Hildebrand)
/// @notice This contract migrated $DACXI to $DXI in 1:1 ration
/// @custom:security-contact [email protected]
interface IDXITokenMigration {
    /// @notice emitted when the $DXI is set
    /// @param dxi_ token to be added
    event DXITokenAdded(address indexed dxi_);

    /// @notice emitted when an accounts migrate $DACXI to $DXI
    /// @param account account to be added
    /// @param amount amount to be migrated
    event Migrated(address indexed account, uint256 amount);

    /// @notice emitted when an account is added/removed to/from whitelist
    /// @param account account to be added/removed
    /// @param isWhitelisted is account whitelisted
    event AddressWhitelistStatusChanged(address indexed account, bool isWhitelisted);

    /// @notice emitted when whitelist is disabled
    event WhitelistDisabled();

    /// @notice emitted when disable whitelist process started
    event WhitelistDisableInitiated(uint256 timestamp);

    /// @notice emitted when disable whitelist process canceled
    event WhitelistDisableCancelled();

    /// @notice thrown when an invalid address is supplied
    error InvalidAddress();

    /// @notice thrown when DXI token address already set
    error DXITokenAddressAlreadySet();

    /// @notice thrown when DXI token address is not set
    error DXITokenAddressNotSet();

    /// @notice thrown when the address calling `migrate` is not in the whitelist
    /// @dev only thrown when the whitelist is enabled
    error AddressNotInWhitelist();

    /// @notice thrown when whitelist disable was not initiated
    error WhitelistDisabledNotInitiated();

    /// @notice thrown when admin tries to finalize the whitelist disable before the delay
    error WhitelistDisableEnforcedDelay(uint256 delay);

    /// @notice thrown when whitelist is not disabled
    error WhitelistNotDisabled();

    /// @notice Address of the DACXI token
    /// @return dacxi Address of the DACXI token
    function dacxi() external view returns (IERC20);

    /// @notice Address of the DXI token
    /// @return dxi Address of the DXI token
    function dxi() external view returns (IERC20);

    /// @notice Set the $DXI contract address
    /// @dev the contract address can be set only once
    /// @param dxi_ $DXI contract address
    function setDXIToken(address dxi_) external;

    /// @notice This function allows for migrating DACXI tokens to DXI tokens
    /// @param amount amount of DACXI to migrate
    /// @dev The migration is a one-way process
    /// @dev Initially allow only set of addresses can migrate the tokens. Later the migration will be bepermissionless (see {IDXITokenMigration-disableWhitelist})
    function migrate(uint256 amount) external;

    /// @notice Add an account to the whitelist
    /// @param account account to include in the whitelist
    /// @dev only the contract owner can add an address
    function addToWhitelist(address account) external;

    /// @notice Remove an account from the whitelist
    /// @param account Account to remove from the whitelist
    /// @dev Only the contract owner can remove an address
    function removeFromWhitelist(address account) external;

    /// @notice Check if an address is in the whitelist
    /// @param account Account to check against whitelist
    function isInWhitelist(address account) external view returns (bool);

    /// @notice Check if the sender address is in the whitelist
    function checkMyWhitelistStatus() external view returns (bool);

    /// @notice Return if the whitelist is enabled or not
    function isWhitelistEnabled() external view returns (bool);

    /// @notice Starts the process to disable the whitelist
    function initiateWhitelistDisable() external;

    /// @notice Finalize the whitelist disable process. This action is permanent and cannot be reverted.
    /// @dev only the contract owner can disalbe the whitelist
    /// @dev Disabling the whitelist, make the migration to be permissionless
    function finalizeWhitelistDisable() external;

    /// @notice Cancel an ongoing process to disable the whitelist
    function cancelWhitelistDisable() external;

    /// @notice Return when the admin can finalize the whitelist disable process
    function whitelistDisableTimestamp() external view returns (uint256);
}

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../token/ERC20/IERC20.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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

pragma solidity ^0.8.20;

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

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

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

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "remappings": [
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ]
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"dacxi_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"AddressNotInWhitelist","type":"error"},{"inputs":[],"name":"DXITokenAddressAlreadySet","type":"error"},{"inputs":[],"name":"DXITokenAddressNotSet","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"InvalidAddress","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[{"internalType":"uint256","name":"delay","type":"uint256"}],"name":"WhitelistDisableEnforcedDelay","type":"error"},{"inputs":[],"name":"WhitelistDisabledNotInitiated","type":"error"},{"inputs":[],"name":"WhitelistNotDisabled","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isWhitelisted","type":"bool"}],"name":"AddressWhitelistStatusChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"dxi_","type":"address"}],"name":"DXITokenAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Migrated","type":"event"},{"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":[],"name":"WhitelistDisableCancelled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"WhitelistDisableInitiated","type":"event"},{"anonymous":false,"inputs":[],"name":"WhitelistDisabled","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addToWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cancelWhitelistDisable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"checkMyWhitelistStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dacxi","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dxi","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"finalizeWhitelistDisable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initiateWhitelistDisable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isInWhitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isWhitelistEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"removeFromWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"dxi_","type":"address"}],"name":"setDXIToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"whitelistDisableTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000efab7248d36585e2340e5d25f8a8d243e6e3193f

-----Decoded View---------------
Arg [0] : dacxi_ (address): 0xEfaB7248D36585e2340E5d25F8a8D243E6e3193F

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000efab7248d36585e2340e5d25f8a8d243e6e3193f