// 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.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: MIT
// ENVELOP(NIFTSY) protocol for NFT. 
pragma solidity 0.8.26;

import "@envelop-protocol-v2/src/utils/LibET.sol";

interface IOrderStorage {

    event EnvelopP2PNewOrder(
        bytes32 indexed OrderId,
        address indexed OrderMaker,
        address indexed AssetAddress,
        uint256 TokenId,
        uint256 AssetAmount,
        address PayToken,
        uint256 PayAmount,
        uint8 OrderType
    );

    event EnvelopOrderRemoved(
        bytes32 indexed OrderId,
        address indexed AssetAddress,
        uint256 indexed TokenId,
        uint256 AssetAmount,
        uint8 OrderType
    );

	function makeOrder(
        ET.AssetItem memory _assetItem,
        ET.Price calldata _price,
        ET.OrderType _ordeType,
        address orderMaker
    )   
        external 
        returns (bytes32 orderId);

    function removeOrder(
        bytes32  _orderId,
        ET.AssetItem memory _assetItem,
        address _orderMaker
    ) external returns(bool deleted);
    
    function getOrdersForItem(ET.AssetItem memory _assetItem) 
        external 
        view 
        returns(ET.Order[] memory orderList);

    function getPriceForOrder(
        bytes32  _orderId,
        ET.OrderType _orderType,
        ET.AssetItem memory _assetItem
    ) 
        external view returns(ET.Price memory pr, address payer, address maker);


}

// SPDX-License-Identifier: MIT
// ENVELOP(NIFTSY) protocol NFT. 
pragma solidity ^0.8.20;

/// @title Library for asset eoperation encoding from Envelop/
/// @author Envelop Team
/// @notice This lib implement asset's data types
library ET {

    enum AssetType {EMPTY, NATIVE, ERC20, ERC721, ERC1155, FUTURE1, FUTURE2, FUTURE3}
    enum OrderType {SELL, BUY, FUTURE1, FUTURE2, FUTURE3, FUTURE4, FUTURE5, FUTURE6}

    struct Asset {
        AssetType assetType;
        address contractAddress;
    }

    struct AssetItem {
        Asset asset;
        uint256 tokenId;
        uint256 amount;
    }

    struct Price {
        address payToken;
        uint256 payAmount;
    }

    struct Order {
        bytes32 orderId;
        OrderType orderType;
        address orderBook;
        address orderMaker;
        uint256 amount;
        Price price;
        bool assetApproveExist;
    }
}

// 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
// ENVELOP(NIFTSY) protocol for NFT. 
pragma solidity 0.8.26;

import "@envelop-protocol-v2/src/utils/TokenService.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interface/IOrderStorage.sol";

contract P2POrderManager is TokenService, ReentrancyGuard, Ownable {
    
    // struct OBRegistryItem {
    //     address orderBookAddress;
    //     bool isEnabled;
    // }
    uint256 public FEE_PERCENT_DENOMINATOR = 10000;
    address public immutable FEE_BENEFICIARY;
    uint256 public immutable FEE_PERCENT;

    // map asset  type and orderbook address
    mapping(ET.AssetType => address) public orderBooks;

    // map orderbook address and  status for support old  orderbooks
    mapping(address => bool) public orderBooksStatus;

    event EnvelopP2POrderTaked(
        address indexed AssetAddress,
        uint256 indexed TokenId,
        bytes32 indexed OrderId,
        address OrderMaker,
        address OrderTaker,
        address PayToken,
        uint256 PayAmount,
        uint8 OrderType
    );

    error ErrorDeleteOrder(bytes32 OrderId);

    constructor (uint256 _feePercent, address _feeBeneficiary) 
        Ownable(msg.sender) 
    {
        FEE_BENEFICIARY = _feeBeneficiary;
        FEE_PERCENT = _feePercent;
    }
    
    function makeOrder(
        ET.AssetItem memory _assetItem,
        ET.Price calldata _price,
        ET.OrderType _ordeType
    ) external returns (bytes32 orderId) {
       orderId = IOrderStorage(
           orderBooks[_assetItem.asset.assetType]
       ).makeOrder(_assetItem, _price, _ordeType, msg.sender);
    }

    function removeOrder(
        bytes32  _orderId,
        ET.AssetItem memory _assetItem
    ) external returns(bool deleted){
        deleted =  IOrderStorage(
           orderBooks[_assetItem.asset.assetType]
       ).removeOrder(_orderId, _assetItem, msg.sender);
    }

    function takeOrder(
        bytes32  _orderId, 
        address _orderBook,
        ET.OrderType _orderType,
        ET.AssetItem memory _assetItem
    ) 
        external 
        payable 
        nonReentrant 
    {
        address _currentAssetOwner = _ownerOf(_assetItem);
       

        // Check that _orderBook addres is valid
        require(orderBooksStatus[_orderBook], "OrderBook is not enabled");

        (ET.Price memory p, address payer, address maker) =  IOrderStorage(
           orderBooks[_assetItem.asset.assetType]
        ).getPriceForOrder(_orderId, _orderType, _assetItem);
        if (payer == address(0)) {
            payer = msg.sender;
        }
         // TODO Check that orderMaker cant take order
        if (_orderType ==  ET.OrderType.BUY) {
            require(msg.sender == _currentAssetOwner, "Only asset owner can take BUY order");
        }
       
        // Remove  order from orderbook
        if (!
            IOrderStorage(_orderBook).removeOrder(
                _orderId,
                _assetItem,
                maker
            )
        ) {
            revert ErrorDeleteOrder(_orderId);
        }

        // Check  change in case NATIVE payment
        uint256 change;
        if (p.payToken == address(0)) {
            change = msg.value - p.payAmount;
        }
        // Process payment: charge FEE
        uint256 feeAmount = p.payAmount * FEE_PERCENT/ (100 * FEE_PERCENT_DENOMINATOR);

        if (FEE_BENEFICIARY != address(0)){
            p.payAmount -= _transferSafe(
                ET.AssetItem(
                    ET.Asset(
                        p.payToken == address(0) ? ET.AssetType.NATIVE : ET.AssetType.ERC20,
                        p.payToken
                    ), 0, feeAmount
                ),
                 payer, 
                 FEE_BENEFICIARY
            );
        }

        // Process payment: body
        _transfer(
             ET.AssetItem(
                 ET.Asset(
                     p.payToken == address(0) ? ET.AssetType.NATIVE : ET.AssetType.ERC20,
                     p.payToken
                 ), 0, p.payAmount
             ), payer, _currentAssetOwner
        );

        // Delivery asset from Order 
        _transfer(_assetItem, _currentAssetOwner, payer);
        if (change > 0) {
            address payable s = payable(payer);
            s.transfer(change);
        }

        emit EnvelopP2POrderTaked(
            _assetItem.asset.contractAddress,  //AssetAddress,
            _assetItem.tokenId,                //TokenId,
            _orderId,                          // OrderId,
            maker,                             // OrderMaker,
            msg.sender,                        //OrderTaker,
            p.payToken,                        //PayToken,
            p.payAmount,                       //PayAmount,
           uint8(_orderType)                   // OrderType
        );
       
    }

    ////////////////////////////////////////////////////////////
    /// Admin functions              ///////////////////////////
    ////////////////////////////////////////////////////////////
    function setOrderBookAddressForAssetType(
        ET.AssetType _contractType, 
        address _orderBookAddress
    ) 
        external onlyOwner 
    {
        require(_orderBookAddress != address(0), "No Zero address");
        orderBooks[_contractType] = _orderBookAddress;
        orderBooksStatus[_orderBookAddress] = true;
    }

    function setOrderBookStatus(
        address _orderBookAddress,
        bool _status
    ) 
        external onlyOwner 
    {
        require(_orderBookAddress != address(0), "No Zero address");
        orderBooksStatus[_orderBookAddress] = _status;
    }
    ////////////////////////////////////////////////////////////

    function getOrdersForItem(ET.AssetItem memory _assetItem) 
        external view returns(ET.Order[] memory orderList) 
    {   
        return IOrderStorage(
           orderBooks[_assetItem.asset.assetType]
       ).getOrdersForItem(_assetItem);
    }

}

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

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// ENVELOP(NIFTSY) protocol for NFT. 
pragma solidity ^0.8.20;

import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import "./LibET.sol";

/// @title Envelop helper service for ERC(20, 721, 1155) transfers
/// @author Envelop Team
/// @notice Full refactored from Enveop V1
abstract contract TokenService {
	using Address for address;
    
    error UnSupportedAsset(ET.AssetItem asset);
    error TokenTransferFailed(address assetAddress);
	

    function _getTransferTxData(
        ET.AssetItem memory _assetItem,
        address _from,
        address _to
    ) internal view returns(bytes memory _calldata) {
        if (_assetItem.asset.assetType == ET.AssetType.NATIVE) {
        } else if (_assetItem.asset.assetType == ET.AssetType.ERC20) {
            if (_from == address(this)){
               _calldata = abi.encodeWithSignature("transfer(address,uint256)", _to, _assetItem.amount);
            } else {
               _calldata = abi.encodeWithSignature("transferFrom(address,address,uint256)", _from, _to, _assetItem.amount); 
            }
        } else if (_assetItem.asset.assetType == ET.AssetType.ERC721) {
            _calldata = abi.encodeWithSignature("transferFrom(address,address,uint256)", _from, _to, _assetItem.tokenId);
        } else if (_assetItem.asset.assetType == ET.AssetType.ERC1155) {
            _calldata = abi.encodeWithSignature("safeTransferFrom(address,address,uint256,uint256,bytes)", 
                _from, _to, _assetItem.tokenId, _assetItem.amount, bytes(''));
        } else {
            revert UnSupportedAsset(_assetItem);
        }

    }

    /**
     * @dev This function must never revert. Use it for Last Chance
     * to transfer suspecial token
     */ 
    function _transferEmergency(
        ET.AssetItem memory _assetItem,
        address _from,
        address _to
    ) internal virtual returns (bytes memory _returndata){
        bytes memory transferCallData;
        if (_assetItem.asset.assetType == ET.AssetType.NATIVE) {
            Address.sendValue(payable(_to), _assetItem.amount);
        } else {
            transferCallData = _getTransferTxData(_assetItem, _from, _to);
            // Low level Call with OZ Address
            _returndata = _assetItem.asset.contractAddress.functionCall(
                transferCallData);
        }
    }

     /**
     * @dev Implement Transfer logic for supporting tokens. If `_assetItem` returns no value,
     * non-reverting calls are assumed to be successful. 
     */
    function _transfer(
        ET.AssetItem memory _assetItem,
        address _from,
        address _to
    ) internal virtual returns (bytes memory returndata) {
        returndata = _transferEmergency(_assetItem, _from, _to);
        // Like OZ  SafeERC20 check
        // 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.
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert TokenTransferFailed(_assetItem.asset.contractAddress);
        }
    }

    function _transferSafe(
        ET.AssetItem memory _assetItem,
        address _from,
        address _to
    ) internal virtual returns (uint256 _transferedValue){
        uint256 balanceBefore;
        if (_assetItem.asset.assetType == ET.AssetType.NATIVE) {
            balanceBefore = _to.balance;
            _transfer(_assetItem, _from, _to);
            _transferedValue = _to.balance - balanceBefore;
        
        } else if (_assetItem.asset.assetType == ET.AssetType.ERC20) {
            balanceBefore = _balanceOf(_assetItem, _to);
            _transfer(_assetItem, _from, _to);  
            _transferedValue = _balanceOf(_assetItem, _to) - balanceBefore;
        
        } else if (_assetItem.asset.assetType == ET.AssetType.ERC721 && _ownerOf(_assetItem) == _from){
            balanceBefore = _balanceOf(_assetItem, _to);
             _transfer(_assetItem, _from, _to);
            if (_ownerOf(_assetItem) == _to && _balanceOf(_assetItem, _to) - balanceBefore == 1) {
                _transferedValue = 1;
            }
        
        } else if (_assetItem.asset.assetType == ET.AssetType.ERC1155) {
            balanceBefore = _balanceOf(_assetItem, _to);
            _transfer(_assetItem, _from, _to);  
            _transferedValue = _balanceOf(_assetItem, _to) - balanceBefore;
        
        } else {
            revert UnSupportedAsset(_assetItem);
        }
        return _transferedValue;
    }


    function _balanceOf(
        ET.AssetItem memory _assetItem,
        address _holder
    ) internal view virtual returns (uint256 _balance){
        bytes memory _calldata;
        bytes memory _returnedData;
        if (_assetItem.asset.assetType == ET.AssetType.NATIVE) {
            _balance = _holder.balance;

        } else if (_assetItem.asset.assetType == ET.AssetType.ERC20) {
             _calldata = abi.encodeWithSignature("balanceOf(address)", _holder);

        } else if (_assetItem.asset.assetType == ET.AssetType.ERC721) {
            _calldata = abi.encodeWithSignature("balanceOf(address)", _holder);

        } else if (_assetItem.asset.assetType == ET.AssetType.ERC1155) {
            _calldata = abi.encodeWithSignature("balanceOf(address,uint256)", _holder, _assetItem.tokenId);

        } else {
            revert UnSupportedAsset(_assetItem);
        }

        if (_assetItem.asset.assetType != ET.AssetType.NATIVE) {
            _returnedData = _assetItem.asset.contractAddress.functionStaticCall(_calldata);
            _balance = abi.decode(_returnedData, (uint256));
        }
    }

    function _ownerOf(
        ET.AssetItem memory _assetItem
    ) internal view virtual returns (address _owner){
        if (_assetItem.asset.assetType == ET.AssetType.NATIVE) {
            _owner = address(0);
        
        } else if (_assetItem.asset.assetType == ET.AssetType.ERC20) {
            _owner = address(0);
        } else if (_assetItem.asset.assetType == ET.AssetType.ERC721) {
            bytes memory _calldata = abi.encodeWithSignature("ownerOf(uint256)", _assetItem.tokenId);
            bytes memory _returnedData = _assetItem.asset.contractAddress.functionStaticCall(_calldata);
            _owner = abi.decode(_returnedData, (address));
        } else if (_assetItem.asset.assetType == ET.AssetType.ERC1155) {
            _owner = address(0);
        } else {
            revert UnSupportedAsset(_assetItem);
        }
    }

    function _isApprovedFor(
        ET.AssetItem memory _assetItem,
        address _owner,
        address _spender
    ) internal view virtual returns (uint256 _approvedBalance){
        bytes memory _calldata;
        bytes memory _returnedData;
        if (_assetItem.asset.assetType == ET.AssetType.NATIVE) {
            _approvedBalance = 0;
        } else if (_assetItem.asset.assetType == ET.AssetType.ERC20) {
             _calldata = abi.encodeWithSignature("allowance(address,address)", _owner, _spender);
             _returnedData = _assetItem.asset.contractAddress.functionStaticCall(_calldata);
             _approvedBalance = abi.decode(_returnedData, (uint256));

        } else if (_assetItem.asset.assetType == ET.AssetType.ERC721) {
            // Because there are two ways to approve ERC721
            _calldata = abi.encodeWithSignature("isApprovedForAll(address,address)", _owner, _spender);
            _returnedData = _assetItem.asset.contractAddress.functionStaticCall(_calldata);
            if (abi.decode(_returnedData, (bool))) {
                _approvedBalance = 1;
            } else {
                _calldata = abi.encodeWithSignature("getApproved(uint256)", _assetItem.tokenId);
                 _returnedData = _assetItem.asset.contractAddress.functionStaticCall(_calldata);
                address _spndr = abi.decode(_returnedData, (address));
                if (_spndr == _spender){
                    _approvedBalance = 1;
                }
            }

        } else if (_assetItem.asset.assetType == ET.AssetType.ERC1155) {
            _calldata = abi.encodeWithSignature("isApprovedForAll(address,address)", _owner, _spender);
            _returnedData = _assetItem.asset.contractAddress.functionStaticCall(_calldata);
            if (abi.decode(_returnedData, (bool))) {
                _approvedBalance = 1;
            }
        } else {
            revert UnSupportedAsset(_assetItem);
        }
        
    }
}

{
  "compilationTarget": {
    "src/P2POrderManager.sol": "P2POrderManager"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@envelop-protocol-v2/=lib/envelop-protocol-v2/",
    ":@openzeppelin/=lib/openzeppelin-contracts/",
    ":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    ":@uniswap/=lib/",
    ":ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    ":envelop-protocol-v2/=lib/envelop-protocol-v2/",
    ":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    ":forge-std/=lib/forge-std/src/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ]
}