yousuf-hossain-shanto · May 6, 2022 02:21
diff --git a/EscrowHub.sol b/EscrowHub.sol
 // SPDX-License-Identifier: UNLICENSED

 pragma solidity 0.8.7;

 library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
    unchecked {
        counter._value += 1;
    }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
    unchecked {
        counter._value = value - 1;
    }
    }
 }

 library Strings {
    bytes16 private constant alphabet = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = alphabet[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

 }

 library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @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://diligence.consensys.net/posts/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.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @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, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * 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.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @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`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // 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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
 }

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

    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() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

 contract EscrowHub is ReentrancyGuard {
    using Counters for Counters.Counter;
    using Strings for uint256;

    enum EscrowState {
        AWAITING_DELIVERY,
        COMPLETED,
        CLAIMED_ON_EXPIRE,
        REFUNDED
    }

    struct Escrow {
        uint256 id;
        string uri;
        address payable buyer;
        address payable seller;
        uint256 amount;
        uint256 fee;
        uint256 createdAt;
        uint256 expireAt;
        uint256 clearAt;
        EscrowState state;
    }

    Counters.Counter private _escrowIds;
    mapping(uint256 => Escrow) private idToEscrow;
    address payable private _owner;
    uint256 private constant _minimumEscrow = 5 ether;
    uint256 private constant _fee = 2; // Fee In Percent

    event EscrowCreated(
        uint256 indexed escrowId,
        string uri,
        address buyer,
        address seller,
        uint256 indexed amount,
        uint256 indexed fee,
        EscrowState state
    );

    event EscrowUpdated(
        uint256 indexed escrowId,
        string uri,
        address buyer,
        address seller,
        uint256 amount,
        uint256 fee,
        EscrowState indexed state
    );

    constructor() {
        _owner = payable(msg.sender);
    }

    modifier onlyOwner() {
        require(_owner == msg.sender, "Only Owner Can Access");
        _;
    }

    modifier onlyBuyer(uint256 escrowId) {
        require(
            idToEscrow[escrowId].buyer == msg.sender,
            "Only Buyer Can Access"
        );
        _;
    }

    modifier onlySeller(uint256 escrowId) {
        require(
            idToEscrow[escrowId].seller == msg.sender,
            "Only Seller Can Access"
        );
        _;
    }

    modifier notBuyer(uint256 escrowId) {
        require(
            idToEscrow[escrowId].seller == msg.sender || _owner == msg.sender,
            "Only seller or Owner can perform this action"
        );
        _;
    }

    function newEscrow(
        address _seller,
        string memory _uri,
        uint256 expireIn
    ) public payable nonReentrant {
        _escrowIds.increment();
        uint256 curId = _escrowIds.current();
        require(
            msg.value >= _minimumEscrow,
            "Escrow must be larger then minimum amount"
        );
        uint256 fee = (msg.value * _fee) / 100;
        uint256 _amount = msg.value - fee;
        idToEscrow[curId] = Escrow(
            curId,
            _uri,
            payable(msg.sender),
            payable(_seller),
            _amount,
            fee,
            block.timestamp,
            (block.timestamp + expireIn),
            0,
            EscrowState.AWAITING_DELIVERY
        );

        emit EscrowCreated(
            curId,
            _uri,
            msg.sender,
            _seller,
            _amount,
            fee,
            EscrowState.AWAITING_DELIVERY
        );
    }

    function deliver(uint256 _escrowId)
        public
        onlyBuyer(_escrowId)
        nonReentrant
    {
        require(
            idToEscrow[_escrowId].state == EscrowState.AWAITING_DELIVERY,
            "You can't deliver this escrow. Already updated before"
        );

        idToEscrow[_escrowId].seller.transfer(idToEscrow[_escrowId].amount);
        _owner.transfer(idToEscrow[_escrowId].fee);
        idToEscrow[_escrowId].clearAt = block.timestamp;
        idToEscrow[_escrowId].state = EscrowState.COMPLETED;

        emit EscrowUpdated(
            _escrowId,
            idToEscrow[_escrowId].uri,
            idToEscrow[_escrowId].buyer,
            idToEscrow[_escrowId].seller,
            idToEscrow[_escrowId].amount,
            idToEscrow[_escrowId].fee,
            EscrowState.COMPLETED
        );
    }

    function claimAfterExpire(uint256 _escrowId)
        public
        onlySeller(_escrowId)
        nonReentrant
    {
        require(
            idToEscrow[_escrowId].expireAt <= block.timestamp,
            "Escrow isn't expired yet"
        );
        require(
            idToEscrow[_escrowId].state == EscrowState.AWAITING_DELIVERY,
            "You can't claim this escrow. Already updated before"
        );

        idToEscrow[_escrowId].seller.transfer(idToEscrow[_escrowId].amount);
        _owner.transfer(idToEscrow[_escrowId].fee);
        idToEscrow[_escrowId].clearAt = block.timestamp;
        idToEscrow[_escrowId].state = EscrowState.CLAIMED_ON_EXPIRE;

        emit EscrowUpdated(
            _escrowId,
            idToEscrow[_escrowId].uri,
            idToEscrow[_escrowId].buyer,
            idToEscrow[_escrowId].seller,
            idToEscrow[_escrowId].amount,
            idToEscrow[_escrowId].fee,
            EscrowState.CLAIMED_ON_EXPIRE
        );
    }

    function refund(uint256 _escrowId) public notBuyer(_escrowId) nonReentrant {
        require(
            idToEscrow[_escrowId].state == EscrowState.AWAITING_DELIVERY,
            "Can't refund this escrow. Already updated before"
        );

        idToEscrow[_escrowId].buyer.transfer(
            idToEscrow[_escrowId].amount + idToEscrow[_escrowId].fee
        );
        idToEscrow[_escrowId].clearAt = block.timestamp;
        idToEscrow[_escrowId].state = EscrowState.REFUNDED;

        emit EscrowUpdated(
            _escrowId,
            idToEscrow[_escrowId].uri,
            idToEscrow[_escrowId].buyer,
            idToEscrow[_escrowId].seller,
            idToEscrow[_escrowId].amount,
            idToEscrow[_escrowId].fee,
            EscrowState.REFUNDED
        );
    }

    /* Returns only escrows that pointed me as seller */
    function fetchMyEscrows() public view returns (Escrow[] memory) {
        uint256 totalItemCount = _escrowIds.current();
        uint256 itemCount = 0;
        uint256 currentIndex = 0;

        for (uint256 i = 0; i < totalItemCount; i++) {
            if (idToEscrow[i + 1].seller == msg.sender) {
                itemCount += 1;
            }
        }

        Escrow[] memory items = new Escrow[](itemCount);
        for (uint256 i = 0; i < totalItemCount; i++) {
            if (idToEscrow[i + 1].seller == msg.sender) {
                items[currentIndex] = idToEscrow[i + 1];
                currentIndex += 1;
            }
        }
        return items;
    }

    /* Returns only escrows that pointed me as buyer */
    function fetchCreatedEscrows() public view returns (Escrow[] memory) {
        uint256 totalItemCount = _escrowIds.current();
        uint256 itemCount = 0;
        uint256 currentIndex = 0;

        for (uint256 i = 0; i < totalItemCount; i++) {
            if (idToEscrow[i + 1].buyer == msg.sender) {
                itemCount += 1;
            }
        }

        Escrow[] memory items = new Escrow[](itemCount);
        for (uint256 i = 0; i < totalItemCount; i++) {
            if (idToEscrow[i + 1].buyer == msg.sender) {
                items[currentIndex] = idToEscrow[i + 1];
                currentIndex += 1;
            }
        }
        return items;
    }

    // Return All The Escrows Here Me As A Buyer Or Seller
    function fecthMyAllEscrows() public view returns (Escrow[] memory) {
        uint256 totalItemCount = _escrowIds.current();
        uint256 itemCount = 0;
        uint256 currentIndex = 0;

        for (uint256 i = 0; i < totalItemCount; i++) {
            if (
                idToEscrow[i + 1].buyer == msg.sender ||
                idToEscrow[i + 1].seller == msg.sender
            ) {
                itemCount += 1;
            }
        }

        Escrow[] memory items = new Escrow[](itemCount);
        for (uint256 i = 0; i < totalItemCount; i++) {
            if (
                idToEscrow[i + 1].buyer == msg.sender ||
                idToEscrow[i + 1].seller == msg.sender
            ) {
                items[currentIndex] = idToEscrow[i + 1];
                currentIndex += 1;
            }
        }
        return items;
    }

    function fetchAllEscrows() public view returns (Escrow[] memory) {
        uint256 totalItemCount = _escrowIds.current();
        uint256 currentIndex = 0;

        Escrow[] memory items = new Escrow[](totalItemCount);
        for (uint256 i = 0; i < totalItemCount; i++) {
            items[currentIndex] = idToEscrow[i + 1];
            currentIndex += 1;
        }
        return items;
    }

    function fetchEscrow(uint256 escrowId) public view returns (Escrow memory) {
        return idToEscrow[escrowId];
    }
 }
	// SPDX-License-Identifier: UNLICENSED

	pragma solidity 0.8.7;

	library Counters {
	struct Counter {
	// This variable should never be directly accessed by users of the library: interactions must be restricted to
	// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
	// this feature: see https://github.com/ethereum/solidity/issues/4637
	uint256 _value; // default: 0
	}

	function current(Counter storage counter) internal view returns (uint256) {
	return counter._value;
	}

	function increment(Counter storage counter) internal {
	unchecked {
	counter._value += 1;
	}
	}

	function decrement(Counter storage counter) internal {
	uint256 value = counter._value;
	require(value > 0, "Counter: decrement overflow");
	unchecked {
	counter._value = value - 1;
	}
	}
	}

	library Strings {
	bytes16 private constant alphabet = "0123456789abcdef";

	/**
	* @dev Converts a `uint256` to its ASCII `string` decimal representation.
	*/
	function toString(uint256 value) internal pure returns (string memory) {
	// Inspired by OraclizeAPI's implementation - MIT licence
	// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

	if (value == 0) {
	return "0";
	}
	uint256 temp = value;
	uint256 digits;
	while (temp != 0) {
	digits++;
	temp /= 10;
	}
	bytes memory buffer = new bytes(digits);
	while (value != 0) {
	digits -= 1;
	buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
	value /= 10;
	}
	return string(buffer);
	}

	/**
	* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
	*/
	function toHexString(uint256 value) internal pure returns (string memory) {
	if (value == 0) {
	return "0x00";
	}
	uint256 temp = value;
	uint256 length = 0;
	while (temp != 0) {
	length++;
	temp >>= 8;
	}
	return toHexString(value, length);
	}

	/**
	* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
	*/
	function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
	bytes memory buffer = new bytes(2 * length + 2);
	buffer[0] = "0";
	buffer[1] = "x";
	for (uint256 i = 2 * length + 1; i > 1; --i) {
	buffer[i] = alphabet[value & 0xf];
	value >>= 4;
	}
	require(value == 0, "Strings: hex length insufficient");
	return string(buffer);
	}

	}

	library Address {
	/**
	* @dev Returns true if `account` is a contract.
	*
	* [IMPORTANT]
	* ====
	* It is unsafe to assume that an address for which this function returns
	* false is an externally-owned account (EOA) and not a contract.
	*
	* Among others, `isContract` will return false for the following
	* types of addresses:
	*
	* - an externally-owned account
	* - a contract in construction
	* - an address where a contract will be created
	* - an address where a contract lived, but was destroyed
	* ====
	*/
	function isContract(address account) internal view returns (bool) {
	// This method relies on extcodesize, which returns 0 for contracts in
	// construction, since the code is only stored at the end of the
	// constructor execution.

	uint256 size;
	// solhint-disable-next-line no-inline-assembly
	assembly { size := extcodesize(account) }
	return size > 0;
	}

	/**
	* @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://diligence.consensys.net/posts/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.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
	*/
	function sendValue(address payable recipient, uint256 amount) internal {
	require(address(this).balance >= amount, "Address: insufficient balance");

	// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
	(bool success, ) = recipient.call{ value: amount }("");
	require(success, "Address: unable to send value, recipient may have reverted");
	}

	/**
	* @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, it is bubbled up by this
	* function (like regular Solidity function calls).
	*
	* 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.
	*
	* _Available since v3.1._
	*/
	function functionCall(address target, bytes memory data) internal returns (bytes memory) {
	return functionCall(target, data, "Address: low-level call failed");
	}

	/**
	* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
	* `errorMessage` as a fallback revert reason when `target` reverts.
	*
	* _Available since v3.1._
	*/
	function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
	return functionCallWithValue(target, data, 0, errorMessage);
	}

	/**
	* @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`.
	*
	* _Available since v3.1._
	*/
	function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
	return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
	}

	/**
	* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
	* with `errorMessage` as a fallback revert reason when `target` reverts.
	*
	* _Available since v3.1._
	*/
	function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
	require(address(this).balance >= value, "Address: insufficient balance for call");
	require(isContract(target), "Address: call to non-contract");

	// solhint-disable-next-line avoid-low-level-calls
	(bool success, bytes memory returndata) = target.call{ value: value }(data);
	return _verifyCallResult(success, returndata, errorMessage);
	}

	/**
	* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
	* but performing a static call.
	*
	* _Available since v3.3._
	*/
	function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
	return functionStaticCall(target, data, "Address: low-level static call failed");
	}

	/**
	* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
	* but performing a static call.
	*
	* _Available since v3.3._
	*/
	function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
	require(isContract(target), "Address: static call to non-contract");

	// solhint-disable-next-line avoid-low-level-calls
	(bool success, bytes memory returndata) = target.staticcall(data);
	return _verifyCallResult(success, returndata, errorMessage);
	}

	/**
	* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
	* but performing a delegate call.
	*
	* _Available since v3.4._
	*/
	function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
	return functionDelegateCall(target, data, "Address: low-level delegate call failed");
	}

	/**
	* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
	* but performing a delegate call.
	*
	* _Available since v3.4._
	*/
	function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
	require(isContract(target), "Address: delegate call to non-contract");

	// solhint-disable-next-line avoid-low-level-calls
	(bool success, bytes memory returndata) = target.delegatecall(data);
	return _verifyCallResult(success, returndata, errorMessage);
	}

	function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
	if (success) {
	return returndata;
	} else {
	// 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

	// solhint-disable-next-line no-inline-assembly
	assembly {
	let returndata_size := mload(returndata)
	revert(add(32, returndata), returndata_size)
	}
	} else {
	revert(errorMessage);
	}
	}
	}
	}

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

	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() {
	// On the first call to nonReentrant, _notEntered will be true
	require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

	_;

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

	contract EscrowHub is ReentrancyGuard {
	using Counters for Counters.Counter;
	using Strings for uint256;

	enum EscrowState {
	AWAITING_DELIVERY,
	COMPLETED,
	CLAIMED_ON_EXPIRE,
	REFUNDED
	}

	struct Escrow {
	uint256 id;
	string uri;
	address payable buyer;
	address payable seller;
	uint256 amount;
	uint256 fee;
	uint256 createdAt;
	uint256 expireAt;
	uint256 clearAt;
	EscrowState state;
	}

	Counters.Counter private _escrowIds;
	mapping(uint256 => Escrow) private idToEscrow;
	address payable private _owner;
	uint256 private constant _minimumEscrow = 5 ether;
	uint256 private constant _fee = 2; // Fee In Percent

	event EscrowCreated(
	uint256 indexed escrowId,
	string uri,
	address buyer,
	address seller,
	uint256 indexed amount,
	uint256 indexed fee,
	EscrowState state
	);

	event EscrowUpdated(
	uint256 indexed escrowId,
	string uri,
	address buyer,
	address seller,
	uint256 amount,
	uint256 fee,
	EscrowState indexed state
	);

	constructor() {
	_owner = payable(msg.sender);
	}

	modifier onlyOwner() {
	require(_owner == msg.sender, "Only Owner Can Access");
	_;
	}

	modifier onlyBuyer(uint256 escrowId) {
	require(
	idToEscrow[escrowId].buyer == msg.sender,
	"Only Buyer Can Access"
	);
	_;
	}

	modifier onlySeller(uint256 escrowId) {
	require(
	idToEscrow[escrowId].seller == msg.sender,
	"Only Seller Can Access"
	);
	_;
	}

	modifier notBuyer(uint256 escrowId) {
	require(
	idToEscrow[escrowId].seller == msg.sender \|\| _owner == msg.sender,
	"Only seller or Owner can perform this action"
	);
	_;
	}

	function newEscrow(
	address _seller,
	string memory _uri,
	uint256 expireIn
	) public payable nonReentrant {
	_escrowIds.increment();
	uint256 curId = _escrowIds.current();
	require(
	msg.value >= _minimumEscrow,
	"Escrow must be larger then minimum amount"
	);
	uint256 fee = (msg.value * _fee) / 100;
	uint256 _amount = msg.value - fee;
	idToEscrow[curId] = Escrow(
	curId,
	_uri,
	payable(msg.sender),
	payable(_seller),
	_amount,
	fee,
	block.timestamp,
	(block.timestamp + expireIn),
	0,
	EscrowState.AWAITING_DELIVERY
	);

	emit EscrowCreated(
	curId,
	_uri,
	msg.sender,
	_seller,
	_amount,
	fee,
	EscrowState.AWAITING_DELIVERY
	);
	}

	function deliver(uint256 _escrowId)
	public
	onlyBuyer(_escrowId)
	nonReentrant
	{
	require(
	idToEscrow[_escrowId].state == EscrowState.AWAITING_DELIVERY,
	"You can't deliver this escrow. Already updated before"
	);

	idToEscrow[_escrowId].seller.transfer(idToEscrow[_escrowId].amount);
	_owner.transfer(idToEscrow[_escrowId].fee);
	idToEscrow[_escrowId].clearAt = block.timestamp;
	idToEscrow[_escrowId].state = EscrowState.COMPLETED;

	emit EscrowUpdated(
	_escrowId,
	idToEscrow[_escrowId].uri,
	idToEscrow[_escrowId].buyer,
	idToEscrow[_escrowId].seller,
	idToEscrow[_escrowId].amount,
	idToEscrow[_escrowId].fee,
	EscrowState.COMPLETED
	);
	}

	function claimAfterExpire(uint256 _escrowId)
	public
	onlySeller(_escrowId)
	nonReentrant
	{
	require(
	idToEscrow[_escrowId].expireAt <= block.timestamp,
	"Escrow isn't expired yet"
	);
	require(
	idToEscrow[_escrowId].state == EscrowState.AWAITING_DELIVERY,
	"You can't claim this escrow. Already updated before"
	);

	idToEscrow[_escrowId].seller.transfer(idToEscrow[_escrowId].amount);
	_owner.transfer(idToEscrow[_escrowId].fee);
	idToEscrow[_escrowId].clearAt = block.timestamp;
	idToEscrow[_escrowId].state = EscrowState.CLAIMED_ON_EXPIRE;

	emit EscrowUpdated(
	_escrowId,
	idToEscrow[_escrowId].uri,
	idToEscrow[_escrowId].buyer,
	idToEscrow[_escrowId].seller,
	idToEscrow[_escrowId].amount,
	idToEscrow[_escrowId].fee,
	EscrowState.CLAIMED_ON_EXPIRE
	);
	}

	function refund(uint256 _escrowId) public notBuyer(_escrowId) nonReentrant {
	require(
	idToEscrow[_escrowId].state == EscrowState.AWAITING_DELIVERY,
	"Can't refund this escrow. Already updated before"
	);

	idToEscrow[_escrowId].buyer.transfer(
	idToEscrow[_escrowId].amount + idToEscrow[_escrowId].fee
	);
	idToEscrow[_escrowId].clearAt = block.timestamp;
	idToEscrow[_escrowId].state = EscrowState.REFUNDED;

	emit EscrowUpdated(
	_escrowId,
	idToEscrow[_escrowId].uri,
	idToEscrow[_escrowId].buyer,
	idToEscrow[_escrowId].seller,
	idToEscrow[_escrowId].amount,
	idToEscrow[_escrowId].fee,
	EscrowState.REFUNDED
	);
	}

	/* Returns only escrows that pointed me as seller */
	function fetchMyEscrows() public view returns (Escrow[] memory) {
	uint256 totalItemCount = _escrowIds.current();
	uint256 itemCount = 0;
	uint256 currentIndex = 0;

	for (uint256 i = 0; i < totalItemCount; i++) {
	if (idToEscrow[i + 1].seller == msg.sender) {
	itemCount += 1;
	}
	}

	Escrow[] memory items = new Escrow[](itemCount);
	for (uint256 i = 0; i < totalItemCount; i++) {
	if (idToEscrow[i + 1].seller == msg.sender) {
	items[currentIndex] = idToEscrow[i + 1];
	currentIndex += 1;
	}
	}
	return items;
	}

	/* Returns only escrows that pointed me as buyer */
	function fetchCreatedEscrows() public view returns (Escrow[] memory) {
	uint256 totalItemCount = _escrowIds.current();
	uint256 itemCount = 0;
	uint256 currentIndex = 0;

	for (uint256 i = 0; i < totalItemCount; i++) {
	if (idToEscrow[i + 1].buyer == msg.sender) {
	itemCount += 1;
	}
	}

	Escrow[] memory items = new Escrow[](itemCount);
	for (uint256 i = 0; i < totalItemCount; i++) {
	if (idToEscrow[i + 1].buyer == msg.sender) {
	items[currentIndex] = idToEscrow[i + 1];
	currentIndex += 1;
	}
	}
	return items;
	}

	// Return All The Escrows Here Me As A Buyer Or Seller
	function fecthMyAllEscrows() public view returns (Escrow[] memory) {
	uint256 totalItemCount = _escrowIds.current();
	uint256 itemCount = 0;
	uint256 currentIndex = 0;

	for (uint256 i = 0; i < totalItemCount; i++) {
	if (
	idToEscrow[i + 1].buyer == msg.sender \|\|
	idToEscrow[i + 1].seller == msg.sender
	) {
	itemCount += 1;
	}
	}

	Escrow[] memory items = new Escrow[](itemCount);
	for (uint256 i = 0; i < totalItemCount; i++) {
	if (
	idToEscrow[i + 1].buyer == msg.sender \|\|
	idToEscrow[i + 1].seller == msg.sender
	) {
	items[currentIndex] = idToEscrow[i + 1];
	currentIndex += 1;
	}
	}
	return items;
	}

	function fetchAllEscrows() public view returns (Escrow[] memory) {
	uint256 totalItemCount = _escrowIds.current();
	uint256 currentIndex = 0;

	Escrow[] memory items = new Escrow[](totalItemCount);
	for (uint256 i = 0; i < totalItemCount; i++) {
	items[currentIndex] = idToEscrow[i + 1];
	currentIndex += 1;
	}
	return items;
	}

	function fetchEscrow(uint256 escrowId) public view returns (Escrow memory) {
	return idToEscrow[escrowId];
	}
	}
No results found