organized_contracts/29/290682325e7fe923e1746d9745ac6f52f25ab4c18ca44b03233fc871dc887148/contract.json

{
  "language": "Solidity",
  "sources": {
    "contracts/Escrow.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/utils/math/SafeMath.sol\";\nimport \"./IEscrow.sol\";\nimport \"./IModerator.sol\";\nimport \"./IProduct.sol\";\n\ncontract Escrow is IEscrow, Ownable {\n    using SafeMath for uint256;\n    //moderator contract\n    address private moderatorAddress;\n\n    IModerator moderatorContract;\n\n    // product contract\n    address private productAddress;\n    IProduct productContract;\n\n\n    // total app num\n    uint256 private maxAppNum;\n\n    // app owner\n    // appId => address\n    mapping(uint256 => address) private appOwner;\n\n    //how many seconds after order paid, can buyer make dispute\n    // appId => interval\n    mapping(uint256 => uint256) private appIntervalDispute;\n\n    //how many seconds after order paid, can seller claim order\n    // appId => interval\n    mapping(uint256 => uint256) private appIntervalClaim;\n\n    //how many seconds after dispute made, if seller does not response, buyer can claim the refund\n    // appId => interval\n    mapping(uint256 => uint256) private appIntervalRefuse;\n\n    // app uri\n    // appId => string\n    mapping(uint256 => string) private appURI;\n\n    // app name\n    // appId => string\n    mapping(uint256 => string) private appName;\n\n    // app mod commission (For each mod and app owner if possible)\n    mapping(uint256 => uint8) private appModCommission;\n\n    // app owner commission\n    mapping(uint256 => uint8) private appOwnerCommission;\n\n    // modA resolution for order.\n    // orderId => modA resolution : 0 not resolved, 1 agree refund, 2 disagree refund.\n    mapping(uint256 => uint8) private orderModAResolution;\n\n    // modB resolution for order.\n    // orderId => modB resolution : 0 not resolved, 1 agree refund, 2 disagree refund.\n    mapping(uint256 => uint8) private orderModBResolution;\n\n    // total order num\n    uint256 public maxOrderId;\n\n    //Struct Order\n    struct Order {\n        uint256 appId; //app id\n        uint256 amount; //order amount\n        address coinAddress; //coin contract address\n        address buyer; //buyer address\n        uint256 productId; // product id\n        address seller; //seller address\n        uint256 createdTime; //order created timestamp\n        uint256 claimTime; //timestamp after when seller can claim if there is no dispute\n        uint8 status; //order status, 1 paid, 2 buyer ask refund, 3 completed, 4 seller refuse dispute, 5 buyer or seller escalate, so voters can vote\n        \n    }\n\n    // orderId => Order\n    mapping(uint256 => Order) public orderBook;\n    //Struct Dispute\n    struct Dispute {\n        uint256 refund; // refund amount\n        uint256 modAId; //the mod that chosen by buyer\n        uint256 modBId; // the mod that chosen by seller\n        uint256 refuseExpired; // after it, if seller does not refuse refund, buyer can claim the refund\n    }\n\n    // orderId => Dispute\n    mapping(uint256 => Dispute) public disputeBook;\n\n    // user balance (userAddress => mapping(coinAddress => balance))\n    mapping(address => mapping(address => uint256)) private userBalance;\n\n    //Withdraw event\n    event Withdraw(\n        address indexed user, //user wallet address\n        uint256 indexed amount, //withdraw amount\n        address indexed coinContract //withdraw coin contract\n    );\n\n    //Create new APP event\n    event NewApp(uint256 indexed appId); //appId\n\n    //Create order event\n    event PayOrder(\n        uint256 indexed orderId,\n        uint256 indexed appOrderId,\n        address indexed coinAddress,\n        uint256 amount,\n        uint256 productId,\n        address buyer,\n        address seller,\n        uint256 appId\n    );\n\n    //Confirm Done event\n    event ConfirmDone(uint256 indexed appId, uint256 indexed orderId);\n\n    //Ask refund event\n    event AskRefund(\n        uint256 indexed appId,\n        uint256 indexed orderId,\n        uint256 indexed refund,\n        uint256 modAId\n    );\n\n    //Cancel refund event\n    event CancelRefund(uint256 indexed appId, uint256 indexed orderId);\n\n    //Refuse refund event\n    event RefuseRefund(\n        uint256 indexed appId, \n        uint256 indexed orderId,\n        uint256 indexed modBId\n        );\n\n    //Escalate dispute event\n    event Escalate(uint256 indexed appId, uint256 indexed orderId);\n\n    //Resolve to Agree or Disagree refund\n    event Resolve(\n        address indexed user,\n        bool indexed isAgree,\n        uint256 indexed orderId,\n        uint256 appId,\n        uint8 modType // 0 both modA&modB, 1 modA, 2 modB, 3 app Owner \n    );\n\n    //Resolved now event\n    event ResolvedFinally(\n        uint256 indexed appId,\n        uint256 indexed orderId,\n        uint8 indexed refundType //0 disagree win, 1 agree win, 2 seller refund\n    );\n\n    //Cash out event\n    event Claim(\n        address indexed user,\n        uint256 indexed appId,\n        uint256 indexed orderId\n    );\n\n    //User Balance Changed event\n    event UserBalanceChanged(\n        address indexed user,\n        bool indexed isIn,\n        uint256 indexed amount,\n        address coinAddress,\n        uint256 appId,\n        uint256 orderId\n    );\n\n    constructor(address _modAddress, address _prodAddress) payable {\n            moderatorAddress    =   _modAddress;\n            moderatorContract   =  IModerator(_modAddress);\n\n            productAddress      =   _prodAddress;\n            productContract     =   IProduct(_prodAddress);\n\n    }\n\n    // Function to deposit Ether into this contract.\n    // Call this function along with some Ether.\n    // The balance of this contract will be automatically updated.\n    receive() external payable {}\n\n    // get Moderator contract address\n    function getModAddress() external view override returns (address)\n    {\n        return moderatorAddress;\n    }\n\n    // get Product contract address\n    function getProductAddress() external view override returns (address)\n    {\n        return productAddress;\n    }\n\n    // get app owner address\n    function getAppOwner(uint256 appId) public view returns (address) {\n        return appOwner[appId];\n    }\n\n    // get app Interval Dispute timestamp\n    function getAppIntervalDispute(uint256 appId) public view returns(uint256) {\n        return appIntervalDispute[appId];\n    }\n\n    // get app Interval Claim timestamp\n    function getAppIntervalClaim(uint256 appId) public view returns(uint256) {\n        return appIntervalClaim[appId];\n    }\n\n    // get app Interval Refuse timestamp\n    function getAppIntervalRefuse(uint256 appId) public view returns(uint256) {\n        return appIntervalRefuse[appId];\n    }\n\n    // get app URI\n    function getAppURI(uint256 appId) public view returns(string memory) {\n        return appURI[appId];\n    }\n\n    // get app Name\n    function getAppName(uint256 appId) public view returns(string memory) {\n        return appName[appId];\n    }\n\n    // get app Mod Commission\n    function getAppModCommission(uint256 appId) public view returns(uint8) {\n        return appModCommission[appId];\n    }\n\n    // get app Owner Commission\n    function getAppOwnerCommission(uint256 appId) public view returns(uint8) {\n        return appOwnerCommission[appId];\n    }\n\n    // get order ModA Resolution\n    function getModAResolution(uint256 orderId) public view returns(uint8) {\n        return orderModAResolution[orderId];\n    }\n\n    // get order ModB Resolution\n    function getModBResolution(uint256 orderId) public view returns(uint8) {\n        return orderModBResolution[orderId];\n    }\n\n    // get user balance\n    function getUserBalance(address userAddress, address coinAddress) public view returns(uint256) {\n        return userBalance[userAddress][coinAddress];\n    }\n\n    // get order detail\n    function getOrderDetail(uint256 orderId) public view returns(Order memory) {\n        return orderBook[orderId];\n    }\n\n    // get dispute detail\n    function getDisputeDetail(uint256 orderId) public view returns(Dispute memory) {\n        return disputeBook[orderId];\n    }\n\n    //Create new APP\n    function newApp(\n        address _appOwner,\n        string memory _appName,\n        string memory websiteURI\n    ) public onlyOwner returns (uint256) {\n        uint256 appId = maxAppNum.add(1);\n        appOwner[appId] = _appOwner;\n        appURI[appId] = websiteURI;\n        appName[appId] = _appName;\n        appIntervalDispute[appId] = uint256(3000000);// buyer can only dispute in 1 month after order paid.\n        appIntervalClaim[appId] = uint256(3000000);  // seller can claim if buyer does not dispute over 1 month after order paid.\n        appIntervalRefuse[appId] = uint256(259200); // buyer can claim if seller does not refuse dispute over 3 days after dispute .\n        appModCommission[appId] = uint8(1);\n        appOwnerCommission[appId] = uint8(0);\n        maxAppNum = appId;\n        emit NewApp(appId);\n\n        return appId;\n    }\n\n    //Transfer app owner to a new address\n    function setAppOwner(uint256 appId, address _newOwner)\n        public\n        returns (bool)\n    {\n        // Only app owner\n        require(\n            _msgSender() == appOwner[appId],\n            \"Escrow: only app owner can set app owner\"\n        );\n        require(_newOwner != address(0), \"Escrow: new owner is the zero address\");\n        appOwner[appId] = _newOwner;\n\n        return true;\n    }\n\n    //Set mod commission\n    //Only app owner\n    function setModCommission(uint256 appId, uint8 _commission)\n        public\n        returns (bool)\n    {\n        // Only app owner\n        require(\n            _msgSender() == appOwner[appId],\n            \"Escrow: only app owner can set mod commission\"\n        );\n        require(_commission < 15, \"Escrow: commission must be less than 15\");\n        appModCommission[appId] = _commission;\n        return true;\n    }\n\n    //Set app owner commission\n    function setAppOwnerCommission(uint256 appId, uint8 _commission)\n        public\n        returns (bool)\n    {\n        // Only app owner\n        require(\n            _msgSender() == appOwner[appId],\n            \"Escrow: only app owner can set app owner commission\"\n        );\n        require(_commission < 45, \"Escrow: commission must be less than 45\");\n        appOwnerCommission[appId] = _commission;\n        return true;\n    }\n\n    //Set dispute interval\n    function setIntervalDispute(uint256 appId, uint256 _seconds)\n        public\n        returns (bool)\n    {\n        // Only app owner\n        require(\n            _msgSender() == appOwner[appId],\n            \"Escrow: only app owner can set dispute interval\"\n        );\n        require(_seconds > 10, \"Escrow: interval time too small!\");\n        require(_seconds < 10000000, \"Escrow: interval time too big!\");\n        appIntervalDispute[appId] = _seconds;\n        return true;\n    }\n\n    //Set refuse interval\n    function setIntervalRefuse(uint256 appId, uint256 _seconds)\n        public\n        returns (bool)\n    {\n        // Only app owner\n        require(\n            _msgSender() == appOwner[appId],\n            \"Escrow: only app owner can set refuse interval\"\n        );\n        require(_seconds > 10, \"Escrow: interval time too small!\");\n        require(_seconds < 10000000, \"Escrow: interval time too big!\");\n        appIntervalRefuse[appId] = _seconds;\n        return true;\n    }\n\n    //Set claim interval\n    function setIntervalClaim(uint256 appId, uint256 _seconds)\n        public\n        returns (bool)\n    {\n        // Only app owner\n        require(\n            _msgSender() == appOwner[appId],\n            \"Escrow: only app owner can set claim interval\"\n        );\n        require(_seconds > 20, \"Escrow: interval time too small!\");\n        require(_seconds < 10000000, \"Escrow: interval time too big!\");\n        appIntervalClaim[appId] = _seconds;\n        return true;\n    }\n\n    function getMaxModId() public view returns (uint256) {\n       return moderatorContract.getMaxModId();\n    }\n\n    function getModOwner(uint256 modId) public view returns (address) {\n        return moderatorContract.getModOwner(modId);\n    }\n\n    //Pay Order\n    function payOrder(\n        uint256 appId,\n        uint256 amount,\n        address coinAddress,\n        uint256 productId,\n        uint256 appOrderId\n    ) public payable returns (uint256) {\n        require(\n            appId > 0 &&\n                appId <= maxAppNum &&\n                appOrderId > 0 &&\n                amount > 0,\n                \"Escrow: all the ids should be bigger than 0\"\n        );\n        // Product should not be blocked\n        require(!productContract.isProductBlocked(productId),\"product should not be blocked\");\n        \n        //Native Currency\n        if (coinAddress == address(0)) {\n            require(msg.value == amount, \"Escrow: Wrong amount or wrong value sent\");\n            //send native currency to this contract\n            payable(this).transfer(amount);\n        } else {\n            IERC20 buyCoinContract = IERC20(coinAddress);\n            //send ERC20 to this contract\n            buyCoinContract.transferFrom(_msgSender(), address(this), amount);\n        }\n        maxOrderId = maxOrderId.add(1);\n        // store order information\n        Order memory _order;\n        _order.appId = appId;\n        _order.coinAddress = coinAddress;\n        _order.amount = amount;\n        _order.buyer = _msgSender();\n        _order.seller = productContract.getProdOwner(productId);\n        _order.productId = productId;\n        _order.createdTime = block.timestamp;\n        _order.claimTime = block.timestamp.add(appIntervalClaim[appId]);\n        _order.status = uint8(1);\n        \n        orderBook[maxOrderId] = _order;\n\n        // emit event\n        emit PayOrder(\n            maxOrderId,\n            appOrderId,\n            coinAddress,\n            amount,\n            productId,\n            _msgSender(),\n            productContract.getProdOwner(productId),\n            appId\n        );\n\n        return maxOrderId;\n    }\n\n    //confirm order received, and money will be sent to seller's balance\n    //triggled by buyer\n    function confirmDone(uint256 orderId) public {\n        require(\n            _msgSender() == orderBook[orderId].buyer,\n            \"Escrow: only buyer can confirm done\"\n        );\n\n        require(\n            orderBook[orderId].status == uint8(1) ||\n                orderBook[orderId].status == uint8(2) ||\n                orderBook[orderId].status == uint8(4),\n            \"Escrow: order status must be equal to just paid or refund asked or dispute refused\"\n        );\n\n        // send money to seller's balance\n        userBalance[orderBook[orderId].seller][\n            orderBook[orderId].coinAddress\n        ] = userBalance[orderBook[orderId].seller][\n            orderBook[orderId].coinAddress\n        ].add(orderBook[orderId].amount);\n        emit UserBalanceChanged(\n            orderBook[orderId].seller,\n            true,\n            orderBook[orderId].amount,\n            orderBook[orderId].coinAddress,\n            orderBook[orderId].appId,\n            orderId\n        );\n\n        // set order status to completed\n        orderBook[orderId].status = uint8(3);\n\n        // update product sold\n        productContract.updateProdScore(orderBook[orderId].productId, true);\n\n        //emit event\n        emit ConfirmDone(orderBook[orderId].appId, orderId);\n    }\n\n    //ask refund\n    //triggled by buyer\n    function askRefund(uint256 orderId, uint256 refund, uint256 modAId) public {\n        require(\n            _msgSender() == orderBook[orderId].buyer,\n            \"Escrow: only buyer can make dispute\"\n        );\n\n        require(\n            orderBook[orderId].status == uint8(1) ||\n                orderBook[orderId].status == uint8(2),\n            \"Escrow: order status must be equal to just paid or refund asked\"\n        );\n\n        require(\n            block.timestamp < orderBook[orderId].createdTime.add(appIntervalDispute[orderBook[orderId].appId]),\n            \"Escrow: it is too late to make dispute\"\n        );\n\n        require(refund > 0 && refund <= orderBook[orderId].amount, \n                \"Escrow: refund amount must be bigger than 0 and not bigger than paid amount\");\n\n        //Mod Id should be validated\n        require(modAId <= moderatorContract.getMaxModId(), \"Escrow: mod id is too big\");\n\n        // update order status \n        if (orderBook[orderId].status == uint8(1)) {\n            orderBook[orderId].status = uint8(2);\n        }\n        // update dispute modAId\n        disputeBook[orderId].modAId = modAId;\n        // update refund of dispute\n        disputeBook[orderId].refund = refund;\n        \n        // update refuse expired\n        disputeBook[orderId].refuseExpired = block.timestamp.add(appIntervalRefuse[orderBook[orderId].appId]);\n        //emit event\n        emit AskRefund(orderBook[orderId].appId, orderId, refund, modAId);\n    }\n\n    //cancel refund\n    //triggled by buyer\n    function cancelRefund(uint256 orderId) public {\n        require(\n            _msgSender() == orderBook[orderId].buyer,\n            \"Escrow: only buyer can cancel refund\"\n        );\n\n        require(\n            orderBook[orderId].status == uint8(2) ||\n                orderBook[orderId].status == uint8(4),\n            \"Escrow: order status must be equal to refund asked or refund refused\"\n        );\n\n        //update order status to paid\n        orderBook[orderId].status = uint8(1);\n\n        emit CancelRefund(orderBook[orderId].appId, orderId);\n    }\n\n    //refuse refund\n    //triggled by seller\n    function refuseRefund(uint256 orderId, uint256 modBId) public {\n        require(\n            _msgSender() == orderBook[orderId].seller,\n            \"Escrow: only seller can refuse dispute\"\n        );\n\n        require(\n            orderBook[orderId].status == uint8(2),\n            \"Escrow: order status must be equal to refund asked\"\n        );\n\n        require(\n            modBId > 0 && modBId <= moderatorContract.getMaxModId(),\n            \"Escrow: modB id does not exists\"\n        );\n\n        // update modBId of dispute\n        disputeBook[orderId].modBId = modBId;\n\n        //update order status to refund refused\n        orderBook[orderId].status = uint8(4);\n\n        emit RefuseRefund(orderBook[orderId].appId, orderId, modBId);\n    }\n\n    //escalate, so mods can vote\n    //triggled by seller or buyer\n    function escalate(uint256 orderId) public {\n        require(\n            _msgSender() == orderBook[orderId].seller ||\n                _msgSender() == orderBook[orderId].buyer,\n            \"Escrow: only seller or buyer can escalate\"\n        );\n\n        require(\n            orderBook[orderId].status == uint8(4),\n            \"Escrow: order status must be equal to refund refused by seller\"\n        );\n\n        //update order status to escalated dispute, ready for mods to vote\n        orderBook[orderId].status = uint8(5);\n\n        emit Escalate(orderBook[orderId].appId, orderId);\n    }\n\n    // if seller agreed refund, then refund immediately\n    // otherwise let mods or appOwner(if need) to judge\n    \n    function agreeRefund(uint256 orderId) public {\n        //if seller agreed refund, then refund immediately\n        if (_msgSender() == orderBook[orderId].seller) {\n            require(\n                orderBook[orderId].status == uint8(2) ||\n                    orderBook[orderId].status == uint8(4) ||\n                    orderBook[orderId].status == uint8(5),\n                \"Escrow: order status must be at refund asked or refund refused or dispute esclated\"\n            );\n            sellerAgree(orderId);\n        } else {\n            require(\n                orderBook[orderId].status == uint8(5),\n                \"Escrow: mod can only vote on dispute escalated status\"\n            );\n            // get the mod's owner wallet address\n            address modAWallet = moderatorContract.getModOwner(disputeBook[orderId].modAId);\n            address modBWallet = moderatorContract.getModOwner(disputeBook[orderId].modBId);\n            // if modA's owner equal to modB's owner and they are msg sender\n            if (\n                modAWallet == modBWallet &&\n                modAWallet == _msgSender()\n            ) {\n                // set modAResolution/modBResolution to voted\n                orderModAResolution[orderId] = uint8(1);\n                orderModBResolution[orderId] = uint8(1);\n                resolvedFinally(orderId, true);\n                emit Resolve(\n                    _msgSender(),\n                    true,\n                    orderId,\n                    orderBook[orderId].appId,\n                    uint8(0)\n                );\n            }\n            // if voter is app owner , and modA/modB not agree with each other.\n            else if (\n                appOwner[orderBook[orderId].appId] == _msgSender() &&\n                ((orderModAResolution[orderId] == uint8(1) &&\n                    orderModBResolution[orderId] == uint8(2)) ||\n                    (orderModAResolution[orderId] == uint8(2) &&\n                        orderModBResolution[orderId] == uint8(1)))\n            ) {\n                resolvedFinally(orderId, true);\n                emit Resolve(\n                    _msgSender(),\n                    true,\n                    orderId,\n                    orderBook[orderId].appId,\n                    uint8(3)\n                );\n            }\n            // if voter is modA, and modA not vote yet, and modB not vote or vote disagree\n            else if (\n                modAWallet ==  _msgSender() &&\n                orderModAResolution[orderId] == uint8(0) &&\n                (orderModBResolution[orderId] == uint8(0) ||\n                    orderModBResolution[orderId] == uint8(2))\n            ) {\n                // set modAResolution to voted\n                orderModAResolution[orderId] = uint8(1);\n                emit Resolve(\n                    _msgSender(),\n                    true,\n                    orderId,\n                    orderBook[orderId].appId,\n                    uint8(1)\n                );\n            }\n            // if voter is modA, and modA not vote yet, and modB vote agree\n            else if (\n                modAWallet == _msgSender() &&\n                orderModAResolution[orderId] == uint8(0) &&\n                orderModBResolution[orderId] == uint8(1)\n            ) {\n                // set modAResolution to voted\n                orderModAResolution[orderId] = uint8(1);\n                resolvedFinally(orderId, true);\n                emit Resolve(\n                    _msgSender(),\n                    true,\n                    orderId,\n                    orderBook[orderId].appId,\n                    uint8(1)\n                );\n            }\n            // if voter is modB, and modB not vote yet, and modA not vote or vote disagree\n            else if (\n                modBWallet == _msgSender() &&\n                orderModBResolution[orderId] == uint8(0) &&\n                (orderModAResolution[orderId] == uint8(0) ||\n                    orderModAResolution[orderId] == uint8(2))\n            ) {\n                // set modBResolution to voted\n                orderModBResolution[orderId] = uint8(1);\n                emit Resolve(\n                    _msgSender(),\n                    true,\n                    orderId,\n                    orderBook[orderId].appId,\n                    uint8(2)\n                );\n            }\n            // if voter is modB, and modB not vote yet, and modA vote agree\n            else if (\n                modBWallet == _msgSender() &&\n                orderModBResolution[orderId] == uint8(0) &&\n                orderModAResolution[orderId] == uint8(1)\n            ) {\n                // set modBResolution to voted\n                orderModBResolution[orderId] = uint8(1);\n                resolvedFinally(orderId, true);\n                emit Resolve(\n                    _msgSender(),\n                    true,\n                    orderId,\n                    orderBook[orderId].appId,\n                    uint8(2)\n                );\n            }\n            // in other case , revert\n            else {\n                revert(\"Escrow: sender can not vote!\");\n            }\n        }\n    } \n\n    // the _msgSender() does not agree the refund\n    \n    function disagreeRefund(uint256 orderId) public {\n        require(\n            orderBook[orderId].status == uint8(5),\n            \"Escrow: mod can only vote on dispute escalated status\"\n        );\n        // get the mod's owner wallet address\n        address modAWallet = moderatorContract.getModOwner(disputeBook[orderId].modAId);\n        address modBWallet = moderatorContract.getModOwner(disputeBook[orderId].modBId);\n        // if modA's owner equal to modB's owner and they are msg sender\n        if (\n            modAWallet == modBWallet && \n            modAWallet == _msgSender()\n        ) {\n            // set modAResolution/modBResolution to voted\n            orderModAResolution[orderId] = uint8(2);\n            orderModBResolution[orderId] = uint8(2);\n            resolvedFinally(orderId, false);\n            emit Resolve(\n                _msgSender(), \n                false, \n                orderId, \n                orderBook[orderId].appId,\n                uint8(0)\n                );\n        }\n        // if voter is app owner , and modA/modB not agree with each other.\n        else if (\n            appOwner[orderBook[orderId].appId] == _msgSender() &&\n            ((orderModAResolution[orderId] == uint8(2) &&\n                orderModBResolution[orderId] == uint8(1)) ||\n                (orderModAResolution[orderId] == uint8(1) &&\n                    orderModBResolution[orderId] == uint8(2)))\n        ) {\n            resolvedFinally(orderId, false);\n            emit Resolve(\n                _msgSender(), \n                false, \n                orderId, \n                orderBook[orderId].appId,\n                uint8(3)\n                );\n        }\n        // if voter is modA, and modA not vote yet, and modB not vote or vote agree\n        else if (\n            modAWallet == _msgSender() &&\n            orderModAResolution[orderId] == uint8(0) &&\n            (orderModBResolution[orderId] == uint8(0) ||\n                orderModBResolution[orderId] == uint8(1))\n        ) {\n            // set modAResolution to voted\n            orderModAResolution[orderId] = uint8(2);\n            emit Resolve(\n                _msgSender(), \n                false, \n                orderId, \n                orderBook[orderId].appId,\n                uint8(1)\n                );\n        }\n        // if voter is modA, and modA not vote yet, and modB vote disagree\n        else if (\n            modAWallet == _msgSender() &&\n            orderModAResolution[orderId] == uint8(0) &&\n            orderModBResolution[orderId] == uint8(2)\n        ) {\n            // set modAResolution to voted\n            orderModAResolution[orderId] = uint8(2);\n            resolvedFinally(orderId, false);\n            emit Resolve(\n                _msgSender(), \n                false, \n                orderId, \n                orderBook[orderId].appId,\n                uint8(1)\n                );\n        }\n        // if voter is modB, and modB not vote yet, and modA not vote or vote agree\n        else if (\n            modBWallet == _msgSender() &&\n            orderModBResolution[orderId] == uint8(0) &&\n            (orderModAResolution[orderId] == uint8(0) ||\n                orderModAResolution[orderId] == uint8(1))\n        ) {\n            // set modBResolution to voted\n            orderModBResolution[orderId] = uint8(2);\n            emit Resolve(\n                _msgSender(), \n                false, \n                orderId, \n                orderBook[orderId].appId,\n                uint8(2)\n                );\n        }\n        // if voter is modB, and modB not vote yet, and modA vote disagree\n        else if (\n            modBWallet == _msgSender() &&\n            orderModBResolution[orderId] == uint8(0) &&\n            orderModAResolution[orderId] == uint8(2)\n        ) {\n            // set modBResolution to voted\n            orderModBResolution[orderId] = uint8(2);\n            resolvedFinally(orderId, false);\n            emit Resolve(\n                _msgSender(), \n                false, \n                orderId, \n                orderBook[orderId].appId,\n                uint8(2)\n                );\n        }\n        // in other case , revert\n        else {\n            revert(\"Escrow: sender can not vote!\");\n        }\n    } \n\n    // if seller agreed refund, then refund immediately\n    \n    function sellerAgree(uint256 orderId) internal {\n        require(_msgSender() == orderBook[orderId].seller);\n        // update order status to finish\n        orderBook[orderId].status = uint8(3);\n        // final commission is the app owner commission\n        uint8 finalCommission = appOwnerCommission[orderBook[orderId].appId];\n        // add app ownner commission fee\n        userBalance[appOwner[orderBook[orderId].appId]][orderBook[orderId].coinAddress] =\n        userBalance[appOwner[orderBook[orderId].appId]][orderBook[orderId].coinAddress].add(\n            orderBook[orderId].amount.mul(finalCommission).div(100));\n        emit UserBalanceChanged(\n                appOwner[orderBook[orderId].appId],\n                true,\n                orderBook[orderId].amount.mul(finalCommission).div(100),\n                orderBook[orderId].coinAddress,\n                orderBook[orderId].appId,\n                orderId\n            );\n        // as the refund is approved, refund to buyer\n        userBalance[orderBook[orderId].buyer][\n            orderBook[orderId].coinAddress\n        ] = userBalance[orderBook[orderId].buyer][\n            orderBook[orderId].coinAddress\n        ].add(disputeBook[orderId].refund.mul(100 - finalCommission).div(100));\n        emit UserBalanceChanged(\n            orderBook[orderId].buyer,\n            true,\n            disputeBook[orderId].refund.mul(100 - finalCommission).div(100),\n            orderBook[orderId].coinAddress,\n            orderBook[orderId].appId,\n            orderId\n        );\n        // if there is amount left, then send left amount to seller\n        if (orderBook[orderId].amount > disputeBook[orderId].refund) {\n            userBalance[orderBook[orderId].seller][\n                orderBook[orderId].coinAddress\n            ] = userBalance[orderBook[orderId].seller][\n                orderBook[orderId].coinAddress\n            ].add(\n                    (orderBook[orderId].amount.sub(disputeBook[orderId].refund))\n                        .mul(100 - finalCommission)\n                        .div(100)\n                );\n            emit UserBalanceChanged(\n                orderBook[orderId].seller,\n                true,\n                (orderBook[orderId].amount.sub(disputeBook[orderId].refund))\n                    .mul(100 - finalCommission)\n                    .div(100),\n                orderBook[orderId].coinAddress,\n                orderBook[orderId].appId,\n                orderId\n            );\n        }\n        emit ResolvedFinally(orderBook[orderId].appId, orderId, uint8(1));\n    } \n    \n    function resolvedFinally(uint256 orderId, bool result) internal {\n        // update order status to finish\n        orderBook[orderId].status = uint8(3);\n\n        // the mod who judge right decision will increase 1 score, as well as adding the mod commission\n        uint8 modNum = 1;\n        uint8 winResolve = result ? 1 : 2;\n        // get the mod's owner wallet address\n        address modAWallet = moderatorContract.getModOwner(disputeBook[orderId].modAId);\n        address modBWallet = moderatorContract.getModOwner(disputeBook[orderId].modBId);\n        // if modA's owner equal to modB's owner, then just increase 1 success score for the owner\n        // and add the mod commission\n        if (\n            modAWallet == modBWallet\n        ) {\n            rewardMod(\n                orderId,\n                disputeBook[orderId].modAId,\n                modAWallet\n            );\n        }\n        // else if modA does not agree with modB\n        else if (orderModAResolution[orderId] != orderModBResolution[orderId]) {\n            modNum = 2;\n            // anyway app owner will get the mod commission\n            userBalance[appOwner[orderBook[orderId].appId]][\n                orderBook[orderId].coinAddress\n            ] = userBalance[appOwner[orderBook[orderId].appId]][\n                orderBook[orderId].coinAddress\n            ].add(\n                    orderBook[orderId]\n                        .amount\n                        .mul(appModCommission[orderBook[orderId].appId])\n                        .div(100)\n                );\n            // the mod who vote the same as final result will give award\n            if (orderModAResolution[orderId] == winResolve) {\n                rewardMod(\n                    orderId,\n                    disputeBook[orderId].modAId,\n                    modAWallet\n                );\n                moderatorContract.updateModScore(disputeBook[orderId].modBId,false);\n            } else {\n                rewardMod(\n                    orderId,\n                    disputeBook[orderId].modBId,\n                    modBWallet\n                );\n                moderatorContract.updateModScore(disputeBook[orderId].modAId,false);\n            }\n        }\n        // else if modA agree with modB\n        else {\n            // give both mods reward\n            modNum = 2;\n            rewardMod(\n                orderId,\n                disputeBook[orderId].modAId,\n                modAWallet\n            );\n            rewardMod(\n                orderId,\n                disputeBook[orderId].modBId,\n                modBWallet\n            );\n        }\n        // caculate the commission fee\n        uint8 finalCommission = appOwnerCommission[orderBook[orderId].appId] +\n            (modNum * appModCommission[orderBook[orderId].appId]);\n        // send app owner commission fee\n        userBalance[appOwner[orderBook[orderId].appId]][orderBook[orderId].coinAddress] =\n        userBalance[appOwner[orderBook[orderId].appId]][orderBook[orderId].coinAddress].add(\n            orderBook[orderId].amount.mul(appOwnerCommission[orderBook[orderId].appId]).div(100));\n        emit UserBalanceChanged(\n                appOwner[orderBook[orderId].appId],\n                true,\n                orderBook[orderId].amount.mul(appOwnerCommission[orderBook[orderId].appId]).div(100),\n                orderBook[orderId].coinAddress,\n                orderBook[orderId].appId,\n                orderId\n            );\n        //if result is to refund, then refund to buyer, the left will be sent to seller\n        //else all paid to the seller\n\n        if (result == true) {\n            // as the refund is approved, refund to buyer\n            userBalance[orderBook[orderId].buyer][orderBook[orderId].coinAddress] = \n            userBalance[orderBook[orderId].buyer][orderBook[orderId].coinAddress].add(\n                    disputeBook[orderId].refund.mul(100 - finalCommission).div(100));\n            emit UserBalanceChanged(\n                orderBook[orderId].buyer,\n                true,\n                disputeBook[orderId].refund.mul(100 - finalCommission).div(100),\n                orderBook[orderId].coinAddress,\n                orderBook[orderId].appId,\n                orderId\n            );\n            // if there is amount left, then send left amount to seller\n            if (orderBook[orderId].amount > disputeBook[orderId].refund) {\n                userBalance[orderBook[orderId].seller][\n                    orderBook[orderId].coinAddress\n                ] = userBalance[orderBook[orderId].seller][\n                    orderBook[orderId].coinAddress\n                ].add(\n                        (\n                            orderBook[orderId].amount.sub(\n                                disputeBook[orderId].refund\n                            )\n                        ).mul(100 - finalCommission).div(100)\n                    );\n                emit UserBalanceChanged(\n                    orderBook[orderId].seller,\n                    true,\n                    (orderBook[orderId].amount.sub(disputeBook[orderId].refund))\n                        .mul(100 - finalCommission)\n                        .div(100),\n                    orderBook[orderId].coinAddress,\n                    orderBook[orderId].appId,\n                    orderId\n                );\n            }\n            // update product sold\n            productContract.updateProdScore(orderBook[orderId].productId, false);\n            emit ResolvedFinally(orderBook[orderId].appId, orderId, uint8(1));\n        } else {\n            // send all the amount to the seller\n            userBalance[orderBook[orderId].seller][\n                orderBook[orderId].coinAddress\n            ] = userBalance[orderBook[orderId].seller][\n                orderBook[orderId].coinAddress\n            ].add(\n                    orderBook[orderId].amount.mul(100 - finalCommission).div(\n                        100\n                    )\n                );\n            emit UserBalanceChanged(\n                orderBook[orderId].seller,\n                true,\n                orderBook[orderId].amount.mul(100 - finalCommission).div(100),\n                orderBook[orderId].coinAddress,\n                orderBook[orderId].appId,\n                orderId\n            );\n            // update product sold\n            productContract.updateProdScore(orderBook[orderId].productId, true);\n            emit ResolvedFinally(orderBook[orderId].appId, orderId, uint8(0));\n        }\n    }\n\n    // reward mod\n    // adding mod commission as well as increasing mod score\n    \n    function rewardMod(uint256 orderId, uint256 modId, address mod) private {\n        moderatorContract.updateModScore(modId, true);\n        userBalance[mod][orderBook[orderId].coinAddress] = \n        userBalance[mod][orderBook[orderId].coinAddress].add(\n            orderBook[orderId].amount.mul(appModCommission[orderBook[orderId].appId]).div(100));\n        emit UserBalanceChanged(\n                mod,\n                true,\n                orderBook[orderId].amount.mul(appModCommission[orderBook[orderId].appId]).div(100),\n                orderBook[orderId].coinAddress,\n                orderBook[orderId].appId,\n                orderId\n            );\n    } \n\n    //seller want to claim money from order to balance\n    //or\n    //buyer want to claim money after seller either not to refuse dispute or agree dispute\n    \n    function claim(uint256 orderId) public {\n        // final commission is the app owner commission\n        uint8 finalCommission = appOwnerCommission[orderBook[orderId].appId];\n        // add app ownner commission fee\n        userBalance[appOwner[orderBook[orderId].appId]][orderBook[orderId].coinAddress] =\n        userBalance[appOwner[orderBook[orderId].appId]][orderBook[orderId].coinAddress].add(\n            orderBook[orderId].amount.mul(finalCommission).div(100));\n        emit UserBalanceChanged(\n                appOwner[orderBook[orderId].appId],\n                true,\n                orderBook[orderId].amount.mul(finalCommission).div(100),\n                orderBook[orderId].coinAddress,\n                orderBook[orderId].appId,\n                orderId\n            );\n        //seller claim\n        if (_msgSender() == orderBook[orderId].seller) {\n            require(\n                orderBook[orderId].status == uint8(1),\n                \"Escrow: order status must be equal to 1 \"\n            );\n\n            require(\n                block.timestamp > orderBook[orderId].claimTime,\n                \"Escrow: currently seller can not claim, need to wait\"\n            );\n            // send all the amount to the seller\n            userBalance[orderBook[orderId].seller][\n                orderBook[orderId].coinAddress\n            ] = userBalance[orderBook[orderId].seller][\n                orderBook[orderId].coinAddress\n            ].add(\n                    orderBook[orderId].amount.mul(100 - finalCommission).div(\n                        100\n                    )\n                );\n            // update product sold record\n            productContract.updateProdScore(orderBook[orderId].productId, true);\n            emit UserBalanceChanged(\n                orderBook[orderId].seller,\n                true,\n                orderBook[orderId].amount.mul(100 - finalCommission).div(100),\n                orderBook[orderId].coinAddress,\n                orderBook[orderId].appId,\n                orderId\n            );\n            \n        } else if (_msgSender() == orderBook[orderId].buyer) {\n            // buyer claim\n\n            require(\n                orderBook[orderId].status == uint8(2),\n                \"Escrow: order status must be equal to 2 \"\n            );\n\n            require(\n                block.timestamp > disputeBook[orderId].refuseExpired,\n                \"Escrow: currently buyer can not claim, need to wait\"\n            );\n            // refund to buyer\n            userBalance[orderBook[orderId].buyer][orderBook[orderId].coinAddress] = \n            userBalance[orderBook[orderId].buyer][orderBook[orderId].coinAddress].add(\n                    disputeBook[orderId].refund.mul(100 - finalCommission).div(100));\n            // update product sold record\n            productContract.updateProdScore(orderBook[orderId].productId, false);\n            emit UserBalanceChanged(\n                orderBook[orderId].buyer,\n                true,\n                disputeBook[orderId].refund.mul(100 - finalCommission).div(100),\n                orderBook[orderId].coinAddress,\n                orderBook[orderId].appId,\n                orderId\n            );\n            // if there is amount left, then send left amount to seller\n            if (orderBook[orderId].amount > disputeBook[orderId].refund) {\n                userBalance[orderBook[orderId].seller][\n                    orderBook[orderId].coinAddress\n                ] = userBalance[orderBook[orderId].seller][\n                    orderBook[orderId].coinAddress\n                ].add(\n                        (\n                            orderBook[orderId].amount.sub(\n                                disputeBook[orderId].refund\n                            )\n                        ).mul(100 - finalCommission).div(100)\n                    );\n                    \n                emit UserBalanceChanged(\n                    orderBook[orderId].seller,\n                    true,\n                    (orderBook[orderId].amount.sub(disputeBook[orderId].refund))\n                        .mul(100 - finalCommission)\n                        .div(100),\n                    orderBook[orderId].coinAddress,\n                    orderBook[orderId].appId,\n                    orderId\n                );\n            }\n            \n        } else {\n            revert(\"Escrow: only seller or buyer can claim\");\n        }\n\n        orderBook[orderId].status = 3;\n        emit Claim(_msgSender(), orderBook[orderId].appId, orderId);\n    } \n\n    //withdraw from user balance\n    function withdraw(uint256 _amount, address _coinAddress) public {\n        //get user balance\n        uint256 _balance = userBalance[_msgSender()][_coinAddress];\n\n        require(_balance >= _amount, \"Escrow: insufficient balance!\");\n\n        //descrease user balance\n        userBalance[_msgSender()][_coinAddress] = _balance.sub(_amount);\n\n        //if the coin type is ETH\n        if (_coinAddress == address(0)) {\n            //check balance is enough\n            require(address(this).balance > _amount, \"Escrow: insufficient balance\");\n\n            payable(_msgSender()).transfer(_amount);\n        } else {\n            //if the coin type is ERC20\n\n            IERC20 _token = IERC20(_coinAddress);\n\n            _token.transfer(_msgSender(), _amount);\n        }\n\n        //emit withdraw event\n        emit Withdraw(_msgSender(), _amount, _coinAddress);\n    }\n}\n"
    },
    "contracts/IProduct.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IProduct {\n    \n    // get product's owner\n    function getProdOwner(uint256 prodId) external view returns(address);\n\n    // get product's total supply\n    function getMaxProdId() external view returns(uint256);\n\n    // update product's score\n    function updateProdScore(uint256 prodId, bool ifSuccess) external returns(bool);\n\n    // get product's block status\n    function isProductBlocked(uint256 prodId) external view returns(bool);\n}"
    },
    "contracts/IModerator.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IModerator {\n    \n    // get mod's owner\n    function getModOwner(uint256 modId) external view returns(address);\n\n    // get mod's total supply\n    function getMaxModId() external view returns(uint256);\n\n    // update mod's score\n    function updateModScore(uint256 modId, bool ifSuccess) external returns(bool);\n}"
    },
    "contracts/IEscrow.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IEscrow {\n    function getModAddress() external view returns (address);\n\n    function getProductAddress() external view returns (address);\n}"
    },
    "@openzeppelin/contracts/utils/math/SafeMath.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)\n\npragma solidity ^0.8.0;\n\n// CAUTION\n// This version of SafeMath should only be used with Solidity 0.8 or later,\n// because it relies on the compiler's built in overflow checks.\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations.\n *\n * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler\n * now has built in overflow checking.\n */\nlibrary SafeMath {\n    /**\n     * @dev Returns the addition of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            uint256 c = a + b;\n            if (c < a) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b > a) return (false, 0);\n            return (true, a - b);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n            // benefit is lost if 'b' is also tested.\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n            if (a == 0) return (true, 0);\n            uint256 c = a * b;\n            if (c / a != b) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a / b);\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a % b);\n        }\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `+` operator.\n     *\n     * Requirements:\n     *\n     * - Addition cannot overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a + b;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a - b;\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `*` operator.\n     *\n     * Requirements:\n     *\n     * - Multiplication cannot overflow.\n     */\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a * b;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator.\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a / b;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a % b;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {trySub}.\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(\n        uint256 a,\n        uint256 b,\n        string memory errorMessage\n    ) internal pure returns (uint256) {\n        unchecked {\n            require(b <= a, errorMessage);\n            return a - b;\n        }\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(\n        uint256 a,\n        uint256 b,\n        string memory errorMessage\n    ) internal pure returns (uint256) {\n        unchecked {\n            require(b > 0, errorMessage);\n            return a / b;\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting with custom message when dividing by zero.\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {tryMod}.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(\n        uint256 a,\n        uint256 b,\n        string memory errorMessage\n    ) internal pure returns (uint256) {\n        unchecked {\n            require(b > 0, errorMessage);\n            return a % b;\n        }\n    }\n}\n"
    },
    "@openzeppelin/contracts/access/Ownable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"
    },
    "@openzeppelin/contracts/token/ERC20/IERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 amount\n    ) external returns (bool);\n}\n"
    },
    "@openzeppelin/contracts/utils/Context.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}\n"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    }
  }
}