Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.25;

import { FixedPointMathLib } from "@solmate/utils/FixedPointMathLib.sol";
import { SafeTransferLib } from "@solmate/utils/SafeTransferLib.sol";
import { ERC20 } from "@solmate/tokens/ERC20.sol";
import { ReentrancyGuard } from "@solmate/utils/ReentrancyGuard.sol";
import { IAtomicSolver } from "./IAtomicSolver.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title AtomicQueueUCP
 * @notice Allows users to create `AtomicRequests` that specify an ERC20 asset to `offer`
 *         and an ERC20 asset to `want` in return.
 * @notice Making atomic requests where the exchange rate between offer and want is not
 *         relatively stable is effectively the same as placing a limit order between
 *         those assets, so requests can be filled at a rate worse than the current market rate.
 * @notice It is possible for a user to make multiple requests that use the same offer asset.
 *         If this is done it is important that the user has approved the queue to spend the
 *         total amount of assets aggregated from all their requests, and to also have enough
 *         `offer` asset to cover the aggregate total request of `offerAmount`.
 * @custom:security-contact [email protected]
 */
contract AtomicQueueUCP is ReentrancyGuard, Ownable {
    using SafeTransferLib for ERC20;
    using FixedPointMathLib for uint256;

    // ========================================= STRUCTS =========================================

    /**
     * @notice Stores request information needed to fulfill a users atomic request.
     * @param deadline unix timestamp for when request is no longer valid
     * @param atomicPrice the price in terms of `want` asset the user wants their `offer` assets "sold" at
     * @dev atomicPrice MUST be in terms of `want` asset decimals.
     * @param offerAmount the amount of `offer` asset the user wants converted to `want` asset
     * @param inSolve bool used during solves to prevent duplicate users, and to prevent redoing multiple checks
     */
    struct AtomicRequest {
        uint64 deadline; // Timestamp when request expires
        uint88 atomicPrice; // User's limit price in want asset decimals
        uint96 offerAmount; // Amount of offer asset to sell
        bool inSolve; // Prevents double-processing in solve
    }

    /**
     * @notice Used in `viewSolveMetaData` helper function to return data in a clean struct.
     * @param user the address of the user
     * @param flags 8 bits indicating the state of the user. Multiple flags can be set simultaneously.
     *             Each bit represents a different error condition:
     *             From right to left:
     *             - 0: indicates user deadline has passed
     *             - 1: indicates user request has zero offer amount
     *             - 2: indicates user does not have enough offer asset in wallet
     *             - 3: indicates user has not given AtomicQueue approval
     *             - 4: indicates user's atomic price is above clearing price
     *             A value of 0 means no errors (user is solvable).
     * @param assetsToOffer the amount of offer asset to solve
     * @param assetsForWant the amount of assets users want for their offer assets
     */
    struct SolveMetaData {
        address user; // User's address
        uint8 flags; // Bitfield for various error conditions
        uint256 assetsToOffer; // Amount of offer asset from this user
        uint256 assetsForWant; // Amount of want asset for this user
    }

    // ========================================= ERRORS =========================================

    error AtomicQueue__UserRepeated(address user);
    error AtomicQueue__RequestDeadlineExceeded(address user);
    error AtomicQueue__UserNotInSolve(address user);
    error AtomicQueue__ZeroOfferAmount(address user);
    error AtomicQueue__PriceAboveClearing(address user);
    error AtomicQueue__UnapprovedSolveCaller(address user);

    // ========================================= EVENTS =========================================

    event AtomicRequestUpdated(
        address user,
        address offerToken,
        address wantToken,
        uint256 amount,
        uint256 deadline,
        uint256 minPrice,
        uint256 timestamp
    );

    event AtomicRequestFulfilled(
        address user,
        address offerToken,
        address wantToken,
        uint256 offerAmountSpent,
        uint256 wantAmountReceived,
        uint256 timestamp
    );

    event SolverCallerToggled(address caller, bool isApproved);

    // ========================================= STORAGE =========================================

    /**
     * @notice Maps user address to offer asset to want asset to a AtomicRequest struct.
     */
    mapping(address => mapping(ERC20 => mapping(ERC20 => AtomicRequest))) public userAtomicRequest;

    mapping(address => bool) public isApprovedSolveCaller;

    constructor(address _owner, address[] memory approvedSolveCallers) Ownable(_owner) {
        for (uint256 i; i < approvedSolveCallers.length; ++i) {
            isApprovedSolveCaller[approvedSolveCallers[i]] = true;
            emit SolverCallerToggled(approvedSolveCallers[i], true);
        }
    }

    // ========================================= OWNER FUNCTIONS =========================================

    /**
     * @notice Allows owner to toggle approved solve callers.
     * @param solveCallers an array of addresses to toggle approval for
     */
    function toggleApprovedSolveCallers(address[] memory solveCallers) external onlyOwner {
        bool isApproved;
        for (uint256 i; i < solveCallers.length; ++i) {
            isApproved = !isApprovedSolveCaller[solveCallers[i]];
            isApprovedSolveCaller[solveCallers[i]] = isApproved;
            emit SolverCallerToggled(solveCallers[i], isApproved);
        }
    }

    // ========================================= USER FUNCTIONS =========================================

    /**
     * @notice Get a users Atomic Request.
     * @param user the address of the user to get the request for
     * @param offer the ERC0 token they want to exchange for the want
     * @param want the ERC20 token they want in exchange for the offer
     */
    function getUserAtomicRequest(address user, ERC20 offer, ERC20 want) external view returns (AtomicRequest memory) {
        return userAtomicRequest[user][offer][want];
    }

    /**
     * @notice Helper function that returns either
     *         true: Withdraw request is valid.
     *         false: Withdraw request is not valid.
     * @dev It is possible for a withdraw request to return false from this function, but using the
     *      request in `updateAtomicRequest` will succeed, but solvers will not be able to include
     *      the user in `solve` unless some other state is changed.
     * @param offer the ERC0 token they want to exchange for the want
     * @param user the address of the user making the request
     * @param userRequest the request struct to validate
     */
    function isAtomicRequestValid(
        ERC20 offer,
        address user,
        AtomicRequest calldata userRequest
    )
        external
        view
        returns (bool)
    {
        // Check user has enough balance
        if (userRequest.offerAmount > offer.balanceOf(user)) return false;
        // Check request hasn't expired
        if (block.timestamp > userRequest.deadline) return false;
        // Check sufficient allowance
        if (offer.allowance(user, address(this)) < userRequest.offerAmount) return false;
        // Check non-zero amounts
        if (userRequest.offerAmount == 0) return false;
        if (userRequest.atomicPrice == 0) return false;

        return true;
    }

    /**
     * @notice Allows user to add/update their withdraw request.
     * @notice It is possible for a withdraw request with a zero atomicPrice to be made, and solved.
     *         If this happens, users will be selling their shares for no assets in return.
     *         To determine a safe atomicPrice, share.previewRedeem should be used to get
     *         a good share price, then the user can lower it from there to make their request fill faster.
     * @param offer the ERC20 token the user is offering in exchange for the want
     * @param want the ERC20 token the user wants in exchange for offer
     * @param userRequest the users request
     */
    function updateAtomicRequest(ERC20 offer, ERC20 want, AtomicRequest calldata userRequest) external nonReentrant {
        // Update user's request in storage
        AtomicRequest storage request = userAtomicRequest[msg.sender][offer][want];

        request.deadline = userRequest.deadline;
        request.atomicPrice = userRequest.atomicPrice;
        request.offerAmount = userRequest.offerAmount;

        // Emit update event with full request details
        emit AtomicRequestUpdated(
            msg.sender,
            address(offer),
            address(want),
            userRequest.offerAmount,
            userRequest.deadline,
            userRequest.atomicPrice,
            block.timestamp
        );
    }

    /**
     * @notice Called by solvers in order to exchange offer asset for want asset.
     * @notice Solvers are optimistically transferred the offer asset, then are required to
     *         approve this contract to spend enough of want assets to cover all requests.
     * @dev It is very likely `solve` TXs will be front run if broadcasted to public mem pools,
     *      so solvers should use private mem pools.
     * @param offer the ERC20 offer token to solve for
     * @param want the ERC20 want token to solve for
     * @param users an array of user addresses to solve for
     * @param runData extra data that is passed back to solver when `finishSolve` is called
     * @param solver the address to make `finishSolve` callback to
     * @param clearingPrice the uniform clearing price that all requests will be settled at
     */
    function solve(
        ERC20 offer,
        ERC20 want,
        address[] calldata users,
        bytes calldata runData,
        address solver,
        uint256 clearingPrice
    )
        external
        nonReentrant
    {
        if (!isApprovedSolveCaller[msg.sender]) revert AtomicQueue__UnapprovedSolveCaller(msg.sender);
        uint8 offerDecimals = offer.decimals();
        (uint256 assetsToOffer, uint256 assetsForWant) =
            _handleFirstLoop(offer, want, users, clearingPrice, solver, offerDecimals);

        IAtomicSolver(solver).finishSolve(runData, msg.sender, offer, want, assetsToOffer, assetsForWant);

        _handleSecondLoop(offer, want, users, clearingPrice, solver, offerDecimals);
    }

    function _handleFirstLoop(
        ERC20 offer,
        ERC20 want,
        address[] calldata users,
        uint256 clearingPrice,
        address solver,
        uint8 offerDecimals
    )
        internal
        returns (uint256 assetsToOffer, uint256 assetsForWant)
    {
        for (uint256 i = users.length; i > 0;) {
            unchecked {
                --i;
            }

            AtomicRequest memory request = _firstLoopHelper(users[i], offer, want, clearingPrice, solver);

            assetsToOffer += request.offerAmount;
            assetsForWant += _calculateAssetAmount(request.offerAmount, clearingPrice, offerDecimals);
        }
    }

    function _handleSecondLoop(
        ERC20 offer,
        ERC20 want,
        address[] calldata users,
        uint256 clearingPrice,
        address solver,
        uint8 offerDecimals
    )
        internal
    {
        for (uint256 i = users.length; i > 0;) {
            unchecked {
                --i;
            }
            address user = users[i];
            AtomicRequest storage request = userAtomicRequest[users[i]][offer][want];
            bytes32 key = keccak256(abi.encode(user, offer, want));

            uint256 isInSolve;
            assembly {
                isInSolve := tload(key)
            }

            if (isInSolve == 0) revert AtomicQueue__UserNotInSolve(user);

            uint256 assetsToUser = _calculateAssetAmount(request.offerAmount, clearingPrice, offerDecimals);
            want.safeTransferFrom(solver, user, assetsToUser);

            emit AtomicRequestFulfilled(
                user, address(offer), address(want), request.offerAmount, assetsToUser, block.timestamp
            );

            request.offerAmount = 0;
            assembly {
                tstore(key, 0)
            }
        }
    }

    /**
     * @notice Helper function solvers can use to determine if users are solvable, and the required amounts to do so.
     * @notice Repeated users are not accounted for in this setup, so if solvers have repeat users in their `users`
     *         array the results can be wrong.
     * @dev Since a user can have multiple requests with the same offer asset but different want asset, it is
     *      possible for `viewSolveMetaData` to report no errors, but for a solve to fail, if any solves were done
     *      between the time `viewSolveMetaData` and before `solve` is called.
     * @param offer the ERC20 offer token to check for solvability
     * @param want the ERC20 want token to check for solvability
     * @param users an array of user addresses to check for solvability
     * @param clearingPrice the uniform clearing price to check requests against
     */
    function viewSolveMetaData(
        ERC20 offer,
        ERC20 want,
        address[] calldata users,
        uint256 clearingPrice
    )
        external
        view
        returns (SolveMetaData[] memory metaData, uint256 totalAssetsForWant, uint256 totalAssetsToOffer)
    {
        // Cache decimals
        uint8 offerDecimals = offer.decimals();

        // Initialize return array
        metaData = new SolveMetaData[](users.length);

        // Check each user's request
        for (uint256 i; i < users.length; ++i) {
            AtomicRequest memory request = userAtomicRequest[users[i]][offer][want];

            metaData[i].user = users[i];

            // Set appropriate error flags
            if (block.timestamp > request.deadline) {
                metaData[i].flags |= uint8(1);
            }
            if (request.offerAmount == 0) {
                metaData[i].flags |= uint8(1) << 1;
            }
            if (offer.balanceOf(users[i]) < request.offerAmount) {
                metaData[i].flags |= uint8(1) << 2;
            }
            if (offer.allowance(users[i], address(this)) < request.offerAmount) {
                metaData[i].flags |= uint8(1) << 3;
            }
            if (request.atomicPrice > clearingPrice) {
                metaData[i].flags |= uint8(1) << 4;
            }

            // Calculate amounts for this user
            metaData[i].assetsToOffer = request.offerAmount;
            metaData[i].assetsForWant = _calculateAssetAmount(request.offerAmount, clearingPrice, offerDecimals);

            // If no errors, add to totals
            if (metaData[i].flags == 0) {
                totalAssetsForWant += metaData[i].assetsForWant;
                totalAssetsToOffer += request.offerAmount;
            }
        }
    }

    /**
     * @notice Helper function to calculate the amount of want assets a users wants in exchange for
     *         `offerAmount` of offer asset.
     */
    function _calculateAssetAmount(
        uint256 offerAmount,
        uint256 clearingPrice,
        uint8 offerDecimals
    )
        internal
        pure
        returns (uint256)
    {
        return clearingPrice.mulDivDown(offerAmount, 10 ** offerDecimals);
    }

    function _firstLoopHelper(
        address user,
        ERC20 offer,
        ERC20 want,
        uint256 clearingPrice,
        address solver
    )
        internal
        returns (AtomicRequest memory request)
    {
        request = userAtomicRequest[user][offer][want];
        bytes32 key = keccak256(abi.encode(user, offer, want));

        uint256 isInSolve;
        assembly {
            isInSolve := tload(key)
        }

        if (isInSolve == 1) revert AtomicQueue__UserRepeated(user);
        if (block.timestamp > request.deadline) revert AtomicQueue__RequestDeadlineExceeded(user);
        if (request.offerAmount == 0) revert AtomicQueue__ZeroOfferAmount(user);
        if (request.atomicPrice > clearingPrice) revert AtomicQueue__PriceAboveClearing(user);

        assembly {
            tstore(key, 1)
        }

        offer.safeTransferFrom(user, solver, request.offerAmount);
    }
}

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

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Transfer(address indexed from, address indexed to, uint256 amount);

    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /*//////////////////////////////////////////////////////////////
                            METADATA STORAGE
    //////////////////////////////////////////////////////////////*/

    string public name;

    string public symbol;

    uint8 public immutable decimals;

    /*//////////////////////////////////////////////////////////////
                              ERC20 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;

    mapping(address => mapping(address => uint256)) public allowance;

    /*//////////////////////////////////////////////////////////////
                            EIP-2612 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 internal immutable INITIAL_CHAIN_ID;

    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

    mapping(address => uint256) public nonces;

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;

        INITIAL_CHAIN_ID = block.chainid;
        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
    }

    /*//////////////////////////////////////////////////////////////
                               ERC20 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(address spender, uint256 amount) public virtual returns (bool) {
        allowance[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);

        return true;
    }

    function transfer(address to, uint256 amount) public virtual returns (bool) {
        balanceOf[msg.sender] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(msg.sender, to, amount);

        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.

        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;

        balanceOf[from] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(from, to, amount);

        return true;
    }

    /*//////////////////////////////////////////////////////////////
                             EIP-2612 LOGIC
    //////////////////////////////////////////////////////////////*/

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");

        // Unchecked because the only math done is incrementing
        // the owner's nonce which cannot realistically overflow.
        unchecked {
            address recoveredAddress = ecrecover(
                keccak256(
                    abi.encodePacked(
                        "\x19\x01",
                        DOMAIN_SEPARATOR(),
                        keccak256(
                            abi.encode(
                                keccak256(
                                    "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
                                ),
                                owner,
                                spender,
                                value,
                                nonces[owner]++,
                                deadline
                            )
                        )
                    )
                ),
                v,
                r,
                s
            );

            require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");

            allowance[recoveredAddress][spender] = value;
        }

        emit Approval(owner, spender, value);
    }

    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
        return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
    }

    function computeDomainSeparator() internal view virtual returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                    keccak256(bytes(name)),
                    keccak256("1"),
                    block.chainid,
                    address(this)
                )
            );
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

    function _mint(address to, uint256 amount) internal virtual {
        totalSupply += amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(address(0), to, amount);
    }

    function _burn(address from, uint256 amount) internal virtual {
        balanceOf[from] -= amount;

        // Cannot underflow because a user's balance
        // will never be larger than the total supply.
        unchecked {
            totalSupply -= amount;
        }

        emit Transfer(from, address(0), amount);
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Arithmetic library with operations for fixed-point numbers.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol)
/// @author Inspired by USM (https://github.com/usmfum/USM/blob/master/contracts/WadMath.sol)
library FixedPointMathLib {
    /*//////////////////////////////////////////////////////////////
                    SIMPLIFIED FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    uint256 internal constant MAX_UINT256 = 2**256 - 1;

    uint256 internal constant WAD = 1e18; // The scalar of ETH and most ERC20s.

    function mulWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivDown(x, y, WAD); // Equivalent to (x * y) / WAD rounded down.
    }

    function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivUp(x, y, WAD); // Equivalent to (x * y) / WAD rounded up.
    }

    function divWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivDown(x, WAD, y); // Equivalent to (x * WAD) / y rounded down.
    }

    function divWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivUp(x, WAD, y); // Equivalent to (x * WAD) / y rounded up.
    }

    /*//////////////////////////////////////////////////////////////
                    LOW LEVEL FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function mulDivDown(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y))
            if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
                revert(0, 0)
            }

            // Divide x * y by the denominator.
            z := div(mul(x, y), denominator)
        }
    }

    function mulDivUp(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y))
            if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
                revert(0, 0)
            }

            // If x * y modulo the denominator is strictly greater than 0,
            // 1 is added to round up the division of x * y by the denominator.
            z := add(gt(mod(mul(x, y), denominator), 0), div(mul(x, y), denominator))
        }
    }

    function rpow(
        uint256 x,
        uint256 n,
        uint256 scalar
    ) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            switch x
            case 0 {
                switch n
                case 0 {
                    // 0 ** 0 = 1
                    z := scalar
                }
                default {
                    // 0 ** n = 0
                    z := 0
                }
            }
            default {
                switch mod(n, 2)
                case 0 {
                    // If n is even, store scalar in z for now.
                    z := scalar
                }
                default {
                    // If n is odd, store x in z for now.
                    z := x
                }

                // Shifting right by 1 is like dividing by 2.
                let half := shr(1, scalar)

                for {
                    // Shift n right by 1 before looping to halve it.
                    n := shr(1, n)
                } n {
                    // Shift n right by 1 each iteration to halve it.
                    n := shr(1, n)
                } {
                    // Revert immediately if x ** 2 would overflow.
                    // Equivalent to iszero(eq(div(xx, x), x)) here.
                    if shr(128, x) {
                        revert(0, 0)
                    }

                    // Store x squared.
                    let xx := mul(x, x)

                    // Round to the nearest number.
                    let xxRound := add(xx, half)

                    // Revert if xx + half overflowed.
                    if lt(xxRound, xx) {
                        revert(0, 0)
                    }

                    // Set x to scaled xxRound.
                    x := div(xxRound, scalar)

                    // If n is even:
                    if mod(n, 2) {
                        // Compute z * x.
                        let zx := mul(z, x)

                        // If z * x overflowed:
                        if iszero(eq(div(zx, x), z)) {
                            // Revert if x is non-zero.
                            if iszero(iszero(x)) {
                                revert(0, 0)
                            }
                        }

                        // Round to the nearest number.
                        let zxRound := add(zx, half)

                        // Revert if zx + half overflowed.
                        if lt(zxRound, zx) {
                            revert(0, 0)
                        }

                        // Return properly scaled zxRound.
                        z := div(zxRound, scalar)
                    }
                }
            }
        }
    }

    /*//////////////////////////////////////////////////////////////
                        GENERAL NUMBER UTILITIES
    //////////////////////////////////////////////////////////////*/

    function sqrt(uint256 x) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            let y := x // We start y at x, which will help us make our initial estimate.

            z := 181 // The "correct" value is 1, but this saves a multiplication later.

            // This segment is to get a reasonable initial estimate for the Babylonian method. With a bad
            // start, the correct # of bits increases ~linearly each iteration instead of ~quadratically.

            // We check y >= 2^(k + 8) but shift right by k bits
            // each branch to ensure that if x >= 256, then y >= 256.
            if iszero(lt(y, 0x10000000000000000000000000000000000)) {
                y := shr(128, y)
                z := shl(64, z)
            }
            if iszero(lt(y, 0x1000000000000000000)) {
                y := shr(64, y)
                z := shl(32, z)
            }
            if iszero(lt(y, 0x10000000000)) {
                y := shr(32, y)
                z := shl(16, z)
            }
            if iszero(lt(y, 0x1000000)) {
                y := shr(16, y)
                z := shl(8, z)
            }

            // Goal was to get z*z*y within a small factor of x. More iterations could
            // get y in a tighter range. Currently, we will have y in [256, 256*2^16).
            // We ensured y >= 256 so that the relative difference between y and y+1 is small.
            // That's not possible if x < 256 but we can just verify those cases exhaustively.

            // Now, z*z*y <= x < z*z*(y+1), and y <= 2^(16+8), and either y >= 256, or x < 256.
            // Correctness can be checked exhaustively for x < 256, so we assume y >= 256.
            // Then z*sqrt(y) is within sqrt(257)/sqrt(256) of sqrt(x), or about 20bps.

            // For s in the range [1/256, 256], the estimate f(s) = (181/1024) * (s+1) is in the range
            // (1/2.84 * sqrt(s), 2.84 * sqrt(s)), with largest error when s = 1 and when s = 256 or 1/256.

            // Since y is in [256, 256*2^16), let a = y/65536, so that a is in [1/256, 256). Then we can estimate
            // sqrt(y) using sqrt(65536) * 181/1024 * (a + 1) = 181/4 * (y + 65536)/65536 = 181 * (y + 65536)/2^18.

            // There is no overflow risk here since y < 2^136 after the first branch above.
            z := shr(18, mul(z, add(y, 65536))) // A mul() is saved from starting z at 181.

            // Given the worst case multiplicative error of 2.84 above, 7 iterations should be enough.
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))

            // If x+1 is a perfect square, the Babylonian method cycles between
            // floor(sqrt(x)) and ceil(sqrt(x)). This statement ensures we return floor.
            // See: https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division
            // Since the ceil is rare, we save gas on the assignment and repeat division in the rare case.
            // If you don't care whether the floor or ceil square root is returned, you can remove this statement.
            z := sub(z, lt(div(x, z), z))
        }
    }

    function unsafeMod(uint256 x, uint256 y) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Mod x by y. Note this will return
            // 0 instead of reverting if y is zero.
            z := mod(x, y)
        }
    }

    function unsafeDiv(uint256 x, uint256 y) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            // Divide x by y. Note this will return
            // 0 instead of reverting if y is zero.
            r := div(x, y)
        }
    }

    function unsafeDivUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Add 1 to x * y if x % y > 0. Note this will
            // return 0 instead of reverting if y is zero.
            z := add(gt(mod(x, y), 0), div(x, y))
        }
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Gas optimized reentrancy protection for smart contracts.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
    uint256 private locked = 1;

    modifier nonReentrant() virtual {
        require(locked == 1, "REENTRANCY");

        locked = 2;

        _;

        locked = 1;
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

import {ERC20} from "../tokens/ERC20.sol";

/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
library SafeTransferLib {
    /*//////////////////////////////////////////////////////////////
                             ETH OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function safeTransferETH(address to, uint256 amount) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the ETH and store if it succeeded or not.
            success := call(gas(), to, amount, 0, 0, 0, 0)
        }

        require(success, "ETH_TRANSFER_FAILED");
    }

    /*//////////////////////////////////////////////////////////////
                            ERC20 OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function safeTransferFrom(
        ERC20 token,
        address from,
        address to,
        uint256 amount
    ) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata into memory, beginning with the function selector.
            mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
            mstore(add(freeMemoryPointer, 4), and(from, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "from" argument.
            mstore(add(freeMemoryPointer, 36), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument.
            mstore(add(freeMemoryPointer, 68), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type.

            success := and(
                // Set success to whether the call reverted, if not we check it either
                // returned exactly 1 (can't just be non-zero data), or had no return data.
                or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                // We use 100 because the length of our calldata totals up like so: 4 + 32 * 3.
                // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                // Counterintuitively, this call must be positioned second to the or() call in the
                // surrounding and() call or else returndatasize() will be zero during the computation.
                call(gas(), token, 0, freeMemoryPointer, 100, 0, 32)
            )
        }

        require(success, "TRANSFER_FROM_FAILED");
    }

    function safeTransfer(
        ERC20 token,
        address to,
        uint256 amount
    ) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata into memory, beginning with the function selector.
            mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
            mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument.
            mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type.

            success := and(
                // Set success to whether the call reverted, if not we check it either
                // returned exactly 1 (can't just be non-zero data), or had no return data.
                or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
                // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                // Counterintuitively, this call must be positioned second to the or() call in the
                // surrounding and() call or else returndatasize() will be zero during the computation.
                call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
            )
        }

        require(success, "TRANSFER_FAILED");
    }

    function safeApprove(
        ERC20 token,
        address to,
        uint256 amount
    ) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata into memory, beginning with the function selector.
            mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000)
            mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument.
            mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type.

            success := and(
                // Set success to whether the call reverted, if not we check it either
                // returned exactly 1 (can't just be non-zero data), or had no return data.
                or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
                // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                // Counterintuitively, this call must be positioned second to the or() call in the
                // surrounding and() call or else returndatasize() will be zero during the computation.
                call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
            )
        }

        require(success, "APPROVE_FAILED");
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0;

import { ERC20 } from "@solmate/tokens/ERC20.sol";

interface IAtomicSolver {
    /**
     * @notice This function must be implemented in order for an address to be a `solver`
     *         for the AtomicQueue
     * @param runData arbitrary bytes data that is dependent on how each solver is setup
     *        it could contain swap data, or flash loan data, etc..
     * @param initiator the address that initiated a solve
     * @param offer the ERC20 asset sent to the solver
     * @param want the ERC20 asset the solver must approve the queue for
     * @param assetsToOffer the amount of `offer` sent to the solver
     * @param assetsForWant the amount of `want` the solver must approve the queue for
     */
    function finishSolve(
        bytes calldata runData,
        address initiator,
        ERC20 offer,
        ERC20 want,
        uint256 assetsToOffer,
        uint256 assetsForWant
    )
        external;
}

{
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "appendCBOR": true,
    "bytecodeHash": "ipfs",
    "useLiteralContent": false
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "remappings": [
    "@solmate/=lib/solmate/src/",
    "@forge-std/=lib/forge-std/src/",
    "forge-std/=lib/forge-std/src/",
    "@ds-test/=lib/forge-std/lib/ds-test/src/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "@openzeppelin/=lib/openzeppelin-contracts/",
    "@ion-protocol/=lib/nucleus-boring-vault/lib/ion-protocol/src/",
    "@layerzerolabs/=node_modules/@layerzerolabs/",
    "@executooor/=lib/executooor/contracts/",
    "@uniswap-core/=lib/v3-core/contracts/",
    "@uniswap-periphery/=lib/v3-periphery/contracts/",
    "1inch-v2-contracts/=lib/1inch-v2-contracts/contracts/",
    "@axelar-network/=node_modules/@axelar-network/",
    "@balancer-labs/v2-interfaces/=lib/nucleus-boring-vault/lib/ion-protocol/lib/balancer-v2-monorepo/pkg/interfaces/",
    "@balancer-labs/v2-pool-stable/=lib/nucleus-boring-vault/lib/ion-protocol/lib/balancer-v2-monorepo/pkg/pool-stable/",
    "@chainlink/=node_modules/@chainlink/",
    "@chainlink/contracts/=lib/nucleus-boring-vault/lib/ion-protocol/lib/chainlink/contracts/",
    "@eth-optimism/=node_modules/@eth-optimism/",
    "@openzeppelin/contracts-upgradeable/=lib/nucleus-boring-vault/lib/ion-protocol/lib/openzeppelin-contracts-upgradeable/contracts/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "@uniswap/v3-core/=lib/nucleus-boring-vault/lib/ion-protocol/lib/v3-core/",
    "@uniswap/v3-periphery/=lib/nucleus-boring-vault/lib/ion-protocol/lib/v3-periphery/",
    "balancer-v2-monorepo/=lib/nucleus-boring-vault/lib/ion-protocol/lib/",
    "chainlink/=lib/nucleus-boring-vault/lib/ion-protocol/lib/chainlink/",
    "createx/=lib/nucleus-boring-vault/lib/createx/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "executooor/=lib/executooor/contracts/",
    "forge-safe/=lib/nucleus-boring-vault/lib/ion-protocol/lib/forge-safe/",
    "halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",
    "hardhat-deploy/=node_modules/hardhat-deploy/",
    "ion-protocol/=lib/nucleus-boring-vault/lib/ion-protocol/",
    "nucleus-boring-vault/=lib/nucleus-boring-vault/",
    "openzeppelin-contracts-upgradeable/=lib/nucleus-boring-vault/lib/ion-protocol/lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/nucleus-boring-vault/lib/createx/lib/openzeppelin-contracts/contracts/",
    "pendle-core-v2-public/=lib/nucleus-boring-vault/lib/ion-protocol/lib/pendle-core-v2-public/contracts/",
    "solady/=lib/nucleus-boring-vault/lib/ion-protocol/lib/solady/",
    "solarray/=lib/nucleus-boring-vault/lib/ion-protocol/lib/solarray/src/",
    "solidity-bytes-utils/=node_modules/solidity-bytes-utils/",
    "solidity-stringutils/=lib/nucleus-boring-vault/lib/ion-protocol/lib/forge-safe/lib/surl/lib/solidity-stringutils/",
    "solmate/=lib/solmate/src/",
    "surl/=lib/nucleus-boring-vault/lib/ion-protocol/lib/forge-safe/lib/surl/",
    "v3-core/=lib/v3-core/",
    "v3-periphery/=lib/v3-periphery/contracts/"
  ],
  "viaIR": true
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address[]","name":"approvedSolveCallers","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"AtomicQueue__PriceAboveClearing","type":"error"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"AtomicQueue__RequestDeadlineExceeded","type":"error"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"AtomicQueue__UnapprovedSolveCaller","type":"error"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"AtomicQueue__UserNotInSolve","type":"error"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"AtomicQueue__UserRepeated","type":"error"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"AtomicQueue__ZeroOfferAmount","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"offerToken","type":"address"},{"indexed":false,"internalType":"address","name":"wantToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"offerAmountSpent","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"wantAmountReceived","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"AtomicRequestFulfilled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"offerToken","type":"address"},{"indexed":false,"internalType":"address","name":"wantToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"deadline","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"minPrice","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"AtomicRequestUpdated","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":[{"indexed":false,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"bool","name":"isApproved","type":"bool"}],"name":"SolverCallerToggled","type":"event"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"contract ERC20","name":"offer","type":"address"},{"internalType":"contract ERC20","name":"want","type":"address"}],"name":"getUserAtomicRequest","outputs":[{"components":[{"internalType":"uint64","name":"deadline","type":"uint64"},{"internalType":"uint88","name":"atomicPrice","type":"uint88"},{"internalType":"uint96","name":"offerAmount","type":"uint96"},{"internalType":"bool","name":"inSolve","type":"bool"}],"internalType":"struct AtomicQueueUCP.AtomicRequest","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isApprovedSolveCaller","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"offer","type":"address"},{"internalType":"address","name":"user","type":"address"},{"components":[{"internalType":"uint64","name":"deadline","type":"uint64"},{"internalType":"uint88","name":"atomicPrice","type":"uint88"},{"internalType":"uint96","name":"offerAmount","type":"uint96"},{"internalType":"bool","name":"inSolve","type":"bool"}],"internalType":"struct AtomicQueueUCP.AtomicRequest","name":"userRequest","type":"tuple"}],"name":"isAtomicRequestValid","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"offer","type":"address"},{"internalType":"contract ERC20","name":"want","type":"address"},{"internalType":"address[]","name":"users","type":"address[]"},{"internalType":"bytes","name":"runData","type":"bytes"},{"internalType":"address","name":"solver","type":"address"},{"internalType":"uint256","name":"clearingPrice","type":"uint256"}],"name":"solve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"solveCallers","type":"address[]"}],"name":"toggleApprovedSolveCallers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"offer","type":"address"},{"internalType":"contract ERC20","name":"want","type":"address"},{"components":[{"internalType":"uint64","name":"deadline","type":"uint64"},{"internalType":"uint88","name":"atomicPrice","type":"uint88"},{"internalType":"uint96","name":"offerAmount","type":"uint96"},{"internalType":"bool","name":"inSolve","type":"bool"}],"internalType":"struct AtomicQueueUCP.AtomicRequest","name":"userRequest","type":"tuple"}],"name":"updateAtomicRequest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"contract ERC20","name":"","type":"address"},{"internalType":"contract ERC20","name":"","type":"address"}],"name":"userAtomicRequest","outputs":[{"internalType":"uint64","name":"deadline","type":"uint64"},{"internalType":"uint88","name":"atomicPrice","type":"uint88"},{"internalType":"uint96","name":"offerAmount","type":"uint96"},{"internalType":"bool","name":"inSolve","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"offer","type":"address"},{"internalType":"contract ERC20","name":"want","type":"address"},{"internalType":"address[]","name":"users","type":"address[]"},{"internalType":"uint256","name":"clearingPrice","type":"uint256"}],"name":"viewSolveMetaData","outputs":[{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint8","name":"flags","type":"uint8"},{"internalType":"uint256","name":"assetsToOffer","type":"uint256"},{"internalType":"uint256","name":"assetsForWant","type":"uint256"}],"internalType":"struct AtomicQueueUCP.SolveMetaData[]","name":"metaData","type":"tuple[]"},{"internalType":"uint256","name":"totalAssetsForWant","type":"uint256"},{"internalType":"uint256","name":"totalAssetsToOffer","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000006e6a79c033ebee27c80444daca7f9aed8bb060450000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000100000000000000000000000054563d1ddb55b029d6d7acd89c633af746823092

-----Decoded View---------------
Arg [0] : _owner (address): 0x6E6a79C033ebEE27C80444DaCA7F9aed8BB06045
Arg [1] : approvedSolveCallers (address[]): 0x54563d1DdB55b029D6D7AcD89C633af746823092

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000006e6a79c033ebee27c80444daca7f9aed8bb06045
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [3] : 00000000000000000000000054563d1ddb55b029d6d7acd89c633af746823092