previousOwner

newOwner

OwnershipTransferred

owner

renounceOwnership

transferOwnership

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

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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


Ownable

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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


Context

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}


SafeMath

appealIndex

appealList

user

appealNo

orderNo

witness

buyer

seller

mortgage

status

appealTime

witTakeTime

obTakeTime

detail

appeals

applyAppeal

applyFinal

_type

changeHandler

observerOpt

searchAppeal

appeal

searchAppealList

takeOb

takeWit

witnessOpt

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./RecordInterface.sol";
import "./UserStorage.sol";

contract AppealStorage {
    OrderInterface private _oSt;
    RecordInterface private _rSt;
    UserInterface private _uSt;
    address recAddr;

    struct Appeal {
        address user;
        uint256 appealNo;
        uint256 orderNo;
        address witness;
        address buyer;
        address seller;
        uint256 mortgage;
        uint256 status;
        uint256 appealTime;
        uint256 witTakeTime;
        uint256 obTakeTime;
        AppealDetail detail;
    }

    struct AppealDetail {
        address finalAppealAddr;
        uint256 updateTime;
        string witnessReason;
        uint256 witnessAppealStatus;
        string observerReason;
        uint256 witnessHandleTime;
        uint256 observerHandleTime;
        address observerAddr;
        uint256 witnessHandleReward;
        uint256 observerHandleReward;
        uint256 witnessHandleCredit;
        uint256 observerHandleCredit;
        uint256 witReward;
        uint256 witSub;
        uint256 witCreditR;
        uint256 witCreditS;
    }

    mapping(uint256 => Appeal) public appeals;
    mapping(uint256 => uint256) public appealIndex;

    Appeal[] public appealList;

    constructor(
        address _r,
        address _o,
        address _u
    ) {
        _rSt = RecordInterface(_r);
        _oSt = OrderInterface(_o);
        _uSt = UserInterface(_u);
        recAddr = _r;
    }

    modifier onlyWit(uint256 _o) {
        Appeal memory _al = appeals[_o];
        require(_al.witness == msg.sender, "1");
        require(_al.buyer != msg.sender && _al.seller != msg.sender, "2");
        _;
    }

    modifier onlyOb(uint256 _o) {
        Appeal memory _al = appeals[_o];
        require(_al.detail.observerAddr == msg.sender, "1");
        require(_al.buyer != msg.sender && _al.seller != msg.sender, "2");
        _;
    }

    modifier onlyBOS(uint256 _o) {
        OrderStorage.Order memory _or = _oSt.searchOrder(_o);
        require(
            _or.orderDetail.sellerAddr == msg.sender ||
                _or.orderDetail.buyerAddr == msg.sender,
            "1"
        );
        _;
    }

    function _insert(uint256 _o, uint256 _count) internal {
        OrderStorage.Order memory _or = _oSt.searchOrder(_o);

        require(appeals[_o].appealNo == uint256(0), "4");

        AppealDetail memory _detail = AppealDetail({
            finalAppealAddr: address(0),
            updateTime: uint256(0),
            witnessReason: "",
            observerReason: "",
            witnessAppealStatus: 0,
            witnessHandleTime: uint256(0),
            observerHandleTime: uint256(0),
            observerAddr: address(0),
            witnessHandleReward: 0,
            observerHandleReward: 0,
            witnessHandleCredit: 0,
            observerHandleCredit: 0,
            witReward: 0,
            witSub: 0,
            witCreditR: 0,
            witCreditS: 0
        });

        uint256 _appealNo = block.timestamp;

        Appeal memory _appeal = Appeal({
            user: msg.sender,
            appealNo: _appealNo,
            orderNo: _o,
            witness: address(0),
            buyer: _or.orderDetail.buyerAddr,
            seller: _or.orderDetail.sellerAddr,
            mortgage: _count,
            status: 1,
            appealTime: block.timestamp,
            witTakeTime: 0,
            obTakeTime: 0,
            detail: _detail
        });

        appeals[_o] = _appeal;

        appealList.push(_appeal);
        appealIndex[_o] = appealList.length - 1;

        chanT(_or.orderDetail.sellerAddr, _or.orderDetail.buyerAddr, 1, 0);
    }

    function chanT(
        address _seller,
        address _buyer,
        uint256 _t,
        uint256 _r
    ) internal {
        uint256 _tc = _rSt.getTradeCredit();
        uint256 _rs = _rSt.getSubTCredit();

        UserStorage.User memory _user = _uSt.searchUser(_seller);
        UserStorage.TradeStats memory _tr = _user.tradeStats;

        uint256 _c = _user.credit;
        if (_t == 1) {
            _tr.tradeTotal = _tr.tradeTotal > 0 ? (_tr.tradeTotal - 1) : 0;

            _c = (_c >= _tc) ? (_c - _tc) : 0;
        } else if (_t == 2) {
            _tr.tradeTotal += 1;

            if (_r == 1) {
                _c += _tc;
            } else if (_r == 2) {
                _c = (_c >= _rs) ? (_c - _rs) : 0;
            }
        }

        _uSt.updateTradeStats(_seller, _tr, _c);

        UserStorage.User memory _user2 = _uSt.searchUser(_buyer);
        UserStorage.TradeStats memory _tr2 = _user2.tradeStats;
        uint256 _c2 = _user2.credit;
        if (_t == 1) {
            _tr2.tradeTotal = _tr2.tradeTotal > 0 ? (_tr2.tradeTotal - 1) : 0;

            _c2 = (_c2 >= _tc) ? (_c2 - _tc) : 0;
        } else if (_t == 2) {
            _tr2.tradeTotal += 1;

            if (_r == 1) {
                _c2 = (_c2 >= _rs) ? (_c2 - _rs) : 0;
            } else if (_r == 2) {
                _c2 += _tc;
            }
        }

        _uSt.updateTradeStats(_buyer, _tr2, _c2);
    }

    function applyAppeal(uint256 _o) external onlyBOS(_o) {
        uint256 _fee = _rSt.getAppealFee();
        _insert(_o, _fee);

        TokenTransfer _tokenTransfer = _rSt.setERC20Address("AIR");
        _tokenTransfer.transferFrom(msg.sender, recAddr, _fee);
    }

    function takeWit(uint256 _o) external {
        Appeal memory _al = appeals[_o];

        require(_al.buyer != msg.sender && _al.seller != msg.sender, "1");

        require(_al.witness == address(0), "2");
        require(_al.status == 1, "3");

        bool _f = witOrOb(1);
        require(_f, "4");

        _al.witness = msg.sender;
        _al.witTakeTime = block.timestamp;

        appeals[_o] = _al;
        appealList[appealIndex[_o]] = _al;
    }

    function takeOb(uint256 _o) external {
        Appeal memory _al = appeals[_o];

        require(_al.buyer != msg.sender && _al.seller != msg.sender, "1");

        require(_al.status == 4 || _al.status == 5, "2");
        require(_al.detail.observerAddr == address(0), "3");

        bool _f = witOrOb(2);
        require(_f, "4");

        _al.detail.observerAddr = msg.sender;
        _al.obTakeTime = block.timestamp;

        appeals[_o] = _al;
        appealList[appealIndex[_o]] = _al;
    }

    function changeHandler(uint256 _o, uint256 _type) external {
        Appeal memory _al = appeals[_o];

        if (_type == 1) {
            require(_al.status == 1, "2");
            require(_al.witness != address(0), "3");
            require(block.timestamp - _al.witTakeTime > 24 hours, "4");

            _al.witness = address(0);
            _al.witTakeTime = 0;
        } else if (_type == 2) {
            require(_al.status == 4 || _al.status == 5, "5");
            require(_al.detail.observerAddr != address(0), "6");
            require(block.timestamp - _al.obTakeTime > 24 hours, "7");

            _al.detail.observerAddr = address(0);
            _al.obTakeTime = 0;
        }

        appeals[_o] = _al;
        appealList[appealIndex[_o]] = _al;
    }

    function witOrOb(uint256 _f) internal view returns (bool) {
        UserStorage.User memory _user = _uSt.searchUser(msg.sender);
        if (_user.userFlag == _f) {
            return true;
        }
        return false;
    }

    function applyFinal(uint256 _o) external onlyBOS(_o) {
        Appeal memory _al = appeals[_o];

        require(_al.status == 2 || _al.status == 3, "1");

        require(
            block.timestamp - _al.detail.witnessHandleTime <= 24 hours,
            "2"
        );

        chanT(_al.seller, _al.buyer, 1, 0);

        uint256 _fee = _rSt.getAppealFeeFinal();

        TokenTransfer _tokenTransfer = _rSt.setERC20Address("AIR");
        _tokenTransfer.transferFrom(msg.sender, recAddr, _fee);

        if (_al.status == 2) {
            _al.status = 4;
        } else if (_al.status == 3) {
            _al.status = 5;
        }
        _al.detail.finalAppealAddr = msg.sender;
        _al.detail.updateTime = block.timestamp;
        appeals[_o] = _al;
        appealList[appealIndex[_o]] = _al;
    }

    function witnessOpt(
        uint256 _o,
        string memory _r,
        uint256 _s
    ) external onlyWit(_o) {
        require(_s == 2 || _s == 3, "1");
        Appeal memory _al = appeals[_o];

        require(_al.status == 1, "2");
        uint256 _fee = _rSt.getAppealFee();
        uint256 _rcedit = _rSt.getWitnessHandleCredit();

        _al.status = _s;
        _al.detail.witnessAppealStatus = _s;
        _al.detail.witnessReason = _r;
        _al.detail.witnessHandleTime = block.timestamp;
        _al.detail.witnessHandleReward = _fee;
        _al.detail.witnessHandleCredit = _rcedit;
        _al.detail.witReward = _fee;
        _al.detail.witCreditR = _rcedit;

        _al.detail.updateTime = block.timestamp;
        appeals[_o] = _al;
        appealList[appealIndex[_o]] = _al;

        if (_s == 2) {
            if (_al.user == _al.buyer) {
                _rSt.subAvaAppeal(_al.seller, _al.buyer, _al, _fee, 1, 0);
                chanT(_al.seller, _al.buyer, 2, 2);
            } else if (_al.user == _al.seller) {
                _rSt.subAvaAppeal(_al.buyer, _al.seller, _al, _fee, 1, 0);

                chanT(_al.seller, _al.buyer, 2, 1);
            }
        }

        if (_s == 3) {
            if (_al.user == _al.buyer) {
                _rSt.subAvaAppeal(_al.buyer, _al.seller, _al, _fee, 1, 1);
                chanT(_al.seller, _al.buyer, 2, 1);
            } else if (_al.user == _al.seller) {
                _rSt.subAvaAppeal(_al.seller, _al.buyer, _al, _fee, 1, 1);
                chanT(_al.seller, _al.buyer, 2, 2);
            }
        }
    }

    function observerOpt(
        uint256 _o,
        string memory _r,
        uint256 _s
    ) external onlyOb(_o) {
        require(_s == 6 || _s == 7, "1");
        Appeal memory _appeal = appeals[_o];

        require(_appeal.status == 4 || _appeal.status == 5, "2");
        uint256 _fee = _rSt.getAppealFeeFinal();
        uint256 _rcedit = _rSt.getObserverHandleCredit();

        _appeal.status = _s;
        _appeal.detail.observerReason = _r;
        _appeal.detail.observerHandleTime = block.timestamp;
        _appeal.detail.observerHandleReward = _fee;
        _appeal.detail.observerHandleCredit = _rcedit;

        uint256 _subWC = _rSt.getSubWitCredit();
        uint256 _subWF = _rSt.getSubWitFee();

        if (_s == 6) {
            if (_appeal.user == _appeal.buyer) {
                _rSt.subAvaAppeal(
                    _appeal.seller,
                    _appeal.buyer,
                    _appeal,
                    _fee,
                    2,
                    0
                );

                chanT(_appeal.seller, _appeal.buyer, 2, 1);
                _rSt.subFrozenTotal(_o, _appeal.buyer);
            } else if (_appeal.user == _appeal.seller) {
                _rSt.subAvaAppeal(
                    _appeal.buyer,
                    _appeal.seller,
                    _appeal,
                    _fee,
                    2,
                    0
                );

                chanT(_appeal.seller, _appeal.buyer, 2, 2);
                _rSt.subFrozenTotal(_o, _appeal.seller);
            }
            if (_appeal.detail.witnessAppealStatus == 3) {
                _appeal.detail.witSub = _subWF;
                _appeal.detail.witCreditS = _subWC;

                if (_appeal.detail.witnessHandleCredit >= _subWC) {
                    _appeal.detail.witnessHandleCredit = SafeMath.sub(
                        _appeal.detail.witnessHandleCredit,
                        _subWC
                    );
                } else {
                    _appeal.detail.witnessHandleCredit = 0;
                }
                _rSt.subWitnessAvailable(_appeal.witness);
            }
        }

        if (_s == 7) {
            if (_appeal.user == _appeal.buyer) {
                _rSt.subAvaAppeal(
                    _appeal.buyer,
                    _appeal.seller,
                    _appeal,
                    _fee,
                    2,
                    1
                );
                chanT(_appeal.seller, _appeal.buyer, 2, 1);
                _rSt.subFrozenTotal(_o, _appeal.seller);
            } else if (_appeal.user == _appeal.seller) {
                _rSt.subAvaAppeal(
                    _appeal.seller,
                    _appeal.buyer,
                    _appeal,
                    _fee,
                    2,
                    1
                );
                chanT(_appeal.seller, _appeal.buyer, 2, 2);
                _rSt.subFrozenTotal(_o, _appeal.buyer);
            }
            if (_appeal.detail.witnessAppealStatus == 2) {
                _appeal.detail.witSub = _subWF;
                _appeal.detail.witCreditS = _subWC;

                if (_appeal.detail.witnessHandleCredit >= _subWC) {
                    _appeal.detail.witnessHandleCredit = SafeMath.sub(
                        _appeal.detail.witnessHandleCredit,
                        _subWC
                    );
                } else {
                    _appeal.detail.witnessHandleCredit = 0;
                }
                _rSt.subWitnessAvailable(_appeal.witness);
            }
        }

        _appeal.detail.updateTime = block.timestamp;
        appeals[_o] = _appeal;
        appealList[appealIndex[_o]] = _appeal;
    }

    function searchAppeal(uint256 _o)
        external
        view
        returns (Appeal memory appeal)
    {
        return appeals[_o];
    }

    function searchAppealList() external view returns (Appeal[] memory) {
        return appealList;
    }
}


This smart contract is an appeal storage contract that allows users to submit appeals for orders. It stores appeal details, including the user, order number, witnesses, reasons, and status. Users can apply for appeals, take on the role of a witness or observer, and handle appeals. The contract also includes functions to search for appeals and appeal lists.

AppealStorage

_recordAddr

_restAddr

_userAddr

_orderNo

_restNo

_coinCount

_tradeFee

_orderAmount

_payType

_orderType

_buyerAddr

_sellerAddr

OrderAdd

OrderCancel

OrderConfirmCollect

OrderPaidMoney

_tradeHash

OrderUpdateHash

_orderStatus

OrderUpdateStatus

addBuyOrder

addSellOrder

_fromAppeal

authFromContract

cancelOrder

confirmCollect

getCancelOrderTime

searchListByRest

searchMyOrderList

searchOrder

order

searchOrderList

_count

setCancelOrderTime

setPaidMoney

takeCoin

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./RecordInterface.sol";
import "./RestStorage.sol";
import "./UserStorage.sol";
import "./RecordStorage.sol";
import "./AppealStorage.sol";

contract OrderStorage is Ownable {
    RestStorage private _restStorage;
    RecordInterface private _recordStorage;
    UserInterface private _userStorage;
    AppealInterface private _appealS;
    address recordAddress;

    struct Order {
        address userAddr;
        uint256 orderNo;
        uint256 restNo;
        uint256 coinCount;
        uint256 orderAmount;
        uint256 payType;
        string currencyType;
        uint256 orderType;
        uint256 orderStatus;
        OrderDetail orderDetail;
    }
    struct OrderDetail {
        address buyerAddr;
        address sellerAddr;
        string coinType;
        uint256 price;
        uint256 tradeTime;
        uint256 updateTime;
        string tradeHash;
        uint256 tradeFee;
    }

    mapping(uint256 => Order) private orders;
    mapping(uint256 => uint256) private orderIndex;

    Order[] private orderList;

    mapping(address => mapping(uint256 => uint256)) orderFrozenTotal;

    uint256 cancelOrderTime = 30;

    function setCancelOrderTime(uint256 _count) public onlyOwner {
        cancelOrderTime = _count;
    }

    function getCancelOrderTime() public view returns (uint256) {
        return cancelOrderTime;
    }

    event OrderAdd(
        uint256 _orderNo,
        uint256 _restNo,
        uint256 _coinCount,
        uint256 _tradeFee,
        uint256 _orderAmount,
        uint256 _payType,
        uint256 _orderType,
        address _buyerAddr,
        address _sellerAddr
    );
    event OrderUpdateHash(uint256 _orderNo, string _tradeHash);
    event OrderPaidMoney(uint256 _orderNo);
    event OrderConfirmCollect(uint256 _orderNo);
    event OrderCancel(uint256 _orderNo);
    event OrderUpdateStatus(uint256 _orderNo, uint256 _orderStatus);

    constructor(
        address _recordAddr,
        address _restAddr,
        address _userAddr
    ) {
        _recordStorage = RecordInterface(_recordAddr);
        _restStorage = RestStorage(_restAddr);
        _userStorage = UserInterface(_userAddr);
        recordAddress = _recordAddr;
    }

    address _appealCAddr;

    modifier onlyAuthFromAddr() {
        require(_appealCAddr != address(0), "Invalid address call order");
        _;
    }

    function authFromContract(address _fromAppeal) external {
        require(_appealCAddr == address(0), "appeal address has Auth");
        _appealCAddr = _fromAppeal;
        _appealS = AppealInterface(_appealCAddr);
    }

    modifier onlyBuyer(uint256 _orderNo) {
        require(_orderNo != uint256(0), "orderNo null is not allowed");
        require(
            orders[_orderNo].orderDetail.buyerAddr == msg.sender,
            "Only buyer can call"
        );
        _;
    }

    modifier onlySeller(uint256 _orderNo) {
        require(_orderNo != uint256(0), "orderNo null is not allowed");
        require(
            orders[_orderNo].orderDetail.sellerAddr == msg.sender,
            "Only seller can call"
        );
        _;
    }

    modifier onlyBuyerOrSeller(uint256 _orderNo) {
        require(_orderNo != uint256(0), "orderNo null is not allowed");
        require(
            orders[_orderNo].orderDetail.sellerAddr == msg.sender ||
                orders[_orderNo].orderDetail.buyerAddr == msg.sender,
            "Only buyer or seller can call"
        );
        _;
    }

    function _checkParam(
        uint256 _restNo,
        uint256 _coinCount,
        uint256 _orderAmount,
        uint256 _payType
    ) internal pure {
        require(
            _restNo != uint256(0),
            "OrderStorage: restNo null is not allowed"
        );
        require(_coinCount > 0, "OrderStorage: coinCount null is not allowed");
        require(
            _orderAmount > 0,
            "OrderStorage: orderAmount null is not allowed"
        );
        require(
            _payType != uint256(0),
            "OrderStorage: payType null is not allowed"
        );
    }

    function _insert(
        uint256 _restNo,
        uint256 _coinCount,
        uint256 _tradeFee,
        uint256 _orderAmount,
        uint256 _payType,
        uint256 _orderType,
        address _buyerAddr,
        address _sellerAddr
    ) internal returns (uint256 restNo) {
        _checkParam(_restNo, _coinCount, _orderAmount, _payType);

        RestStorage.Rest memory _rest = _restStorage.searchRest(_restNo);
        require(_rest.userAddr != address(0), "rest not exist");
        OrderDetail memory _orderDetail = OrderDetail({
            buyerAddr: _buyerAddr,
            sellerAddr: _sellerAddr,
            coinType: _rest.coinType,
            price: _rest.price,
            tradeTime: block.timestamp,
            updateTime: 0,
            tradeHash: "",
            tradeFee: _tradeFee
        });

        uint256 _orderNo = block.timestamp;
        Order memory order = Order({
            userAddr: msg.sender,
            orderNo: _orderNo,
            restNo: _restNo,
            coinCount: _coinCount,
            orderAmount: _orderAmount,
            payType: _payType,
            currencyType: _rest.currencyType,
            orderType: _orderType,
            orderStatus: 1,
            orderDetail: _orderDetail
        });

        orders[_orderNo] = order;

        orderList.push(order);
        orderIndex[_orderNo] = orderList.length - 1;

        if (_orderType == 2) {
            orderFrozenTotal[msg.sender][_orderNo] = _coinCount;
        } else if (_orderType == 1) {
            orderFrozenTotal[_rest.userAddr][_orderNo] = _coinCount;
        }

        emit OrderAdd(
            _orderNo,
            _restNo,
            _coinCount,
            _tradeFee,
            _orderAmount,
            _payType,
            _orderType,
            _buyerAddr,
            _sellerAddr
        );

        return _orderNo;
    }

    function addBuyOrder(
        uint256 _restNo,
        uint256 _coinCount,
        uint256 _orderAmount,
        uint256 _payType
    ) external {
        RestStorage.Rest memory _rest = _restStorage.searchRest(_restNo);
        require(_rest.userAddr != msg.sender, "rest not exist");
        require(_rest.restType == 2, "sell rest not exist");
        require(_coinCount > 0 && _orderAmount > 0, "coin count error");
        require(_rest.restStatus == 1, "rest status error");
        UserStorage.User memory _currentUser = _userStorage.searchUser(
            msg.sender
        );

        require(
            _currentUser.userFlag != 1 && _currentUser.userFlag != 2,
            "invalid user"
        );

        uint256 _restFrozen = _restStorage.getRestFrozenTotal(
            _rest.userAddr,
            _restNo
        );
        require(_restFrozen >= _coinCount, "coin not enough");

        uint256 _amo = SafeMath.mul(_rest.price, _coinCount);
        require(
            _amo >= _rest.restDetail.limitAmountFrom &&
                _amo <= _rest.restDetail.limitAmountTo,
            "amount error"
        );
        require(
            _currentUser.credit >= _rest.restDetail.limitMinCredit,
            "credit error"
        );
        require(
            _currentUser.morgageStats.mortgage >=
                _rest.restDetail.limitMinMortgage,
            "mortgage error"
        );

        _restStorage.updateRestFinishCount(_restNo, _coinCount);
        _insert(
            _restNo,
            _coinCount,
            0,
            _orderAmount,
            _payType,
            1,
            msg.sender,
            _rest.userAddr
        );
    }

    function addSellOrder(
        uint256 _restNo,
        uint256 _coinCount,
        uint256 _tradeFee,
        uint256 _orderAmount,
        uint256 _payType
    ) external {
        RestStorage.Rest memory _rest = _restStorage.searchRest(_restNo);
        require(_rest.userAddr != msg.sender, "rest not exist");
        require(_rest.restType == 1, "buy rest not exist");
        require(_coinCount > 0 && _tradeFee >= 0, "coin count error");
        require(_orderAmount > 0, "orderAmount error");
        require(_rest.restStatus == 1, "rest status error");

        uint256 _amo = SafeMath.mul(_rest.price, _coinCount);
        require(
            _amo >= _rest.restDetail.limitAmountFrom &&
                _amo <= _rest.restDetail.limitAmountTo,
            "amount error"
        );

        UserStorage.User memory _currentUser = _userStorage.searchUser(
            msg.sender
        );

        require(
            _currentUser.userFlag != 1 && _currentUser.userFlag != 2,
            "invalid user"
        );
        require(
            _currentUser.credit >= _rest.restDetail.limitMinCredit,
            "credit error"
        );
        require(
            _currentUser.morgageStats.mortgage >=
                _rest.restDetail.limitMinMortgage,
            "mortgage error"
        );

        uint256 _needSub = SafeMath.add(_coinCount, _tradeFee);

        _restStorage.updateRestFinishCount(_restNo, _coinCount);
        _insert(
            _restNo,
            _coinCount,
            _tradeFee,
            _orderAmount,
            _payType,
            2,
            _rest.userAddr,
            msg.sender
        );

        TokenTransfer _tokenTransfer = _recordStorage.setERC20Address(
            _rest.coinType
        );
        _tokenTransfer.transferFrom(msg.sender, recordAddress, _needSub);
        _recordStorage.addRecord(
            msg.sender,
            "",
            _rest.coinType,
            _coinCount,
            2,
            1,
            2
        );
    }

    function setPaidMoney(uint256 _orderNo)
        external
        onlyBuyer(_orderNo)
        returns (bool)
    {
        _updateOrderStatus(_orderNo, 2);
        emit OrderPaidMoney(_orderNo);
        return true;
    }

    function confirmCollect(uint256 _orderNo) external onlySeller(_orderNo) {
        require(
            _orderNo != uint256(0),
            "OrderStorage:orderNo null is not allowed"
        );
        Order memory _order = orders[_orderNo];
        require(_order.orderStatus == 2, "OrderStorage:Invalid order status");
        require(
            _order.orderDetail.buyerAddr != address(0),
            "OrderStorage:Invalid buyer address"
        );
        require(
            orderFrozenTotal[msg.sender][_orderNo] >= _order.coinCount,
            "OrderStorage:coin not enough"
        );

        _updateOrderStatus(_orderNo, 3);

        orderFrozenTotal[msg.sender][_orderNo] = 0;

        uint256 _rc = _recordStorage.getTradeCredit();
        UserStorage.User memory _user = _userStorage.searchUser(msg.sender);
        uint256 _credit = _user.credit + _rc;
        UserStorage.TradeStats memory _tradeStats = _user.tradeStats;
        _tradeStats.tradeTotal += 1;
        _userStorage.updateTradeStats(msg.sender, _tradeStats, _credit);

        UserStorage.User memory _user2 = _userStorage.searchUser(
            _order.orderDetail.buyerAddr
        );
        uint256 _credit2 = _user2.credit + _rc;
        UserStorage.TradeStats memory _tradeStats2 = _user2.tradeStats;
        _tradeStats2.tradeTotal += 1;
        _userStorage.updateTradeStats(
            _order.orderDetail.buyerAddr,
            _tradeStats2,
            _credit2
        );

        _recordStorage.subFrozenTotal(_orderNo, _order.orderDetail.buyerAddr);

        emit OrderConfirmCollect(_orderNo);
    }

    function cancelOrder(uint256 _orderNo)
        external
        onlyBuyerOrSeller(_orderNo)
        returns (bool)
    {
        Order memory _order = orders[_orderNo];
        require(
            _order.orderNo != uint256(0),
            "OrderStorage: current Order not exist"
        );

        require(_order.orderStatus == 1, "Can't cancel order");

        require(
            _order.orderDetail.tradeTime + cancelOrderTime * 1 minutes <
                block.timestamp,
            "30 minutes limit"
        );
        RestStorage.Rest memory _rest = _restStorage.searchRest(_order.restNo);

        if (_rest.restStatus == 4 || _rest.restStatus == 5) {
            orderFrozenTotal[_order.orderDetail.sellerAddr][_orderNo] = 0;

            _recordStorage.addAvailableTotal(
                _order.orderDetail.sellerAddr,
                _order.orderDetail.coinType,
                _order.coinCount
            );
        } else {
            if (_order.orderType == 2) {
                orderFrozenTotal[_order.orderDetail.sellerAddr][_orderNo] = 0;

                _recordStorage.addAvailableTotal(
                    _order.orderDetail.sellerAddr,
                    _order.orderDetail.coinType,
                    _order.coinCount
                );
            }

            _restStorage.addRestRemainCount(_order.restNo, _order.coinCount);
        }
        _updateOrderStatus(_orderNo, 4);
        emit OrderCancel(_orderNo);
        return true;
    }

    function takeCoin(uint256 _o) external onlyBuyerOrSeller(_o) {
        AppealStorage.Appeal memory _appeal = _appealS.searchAppeal(_o);
        require(
            block.timestamp - _appeal.detail.witnessHandleTime > 24 hours,
            "time error"
        );

        address _win;

        if (_appeal.user == _appeal.buyer) {
            if (_appeal.status == 2) {
                _win = _appeal.buyer;
            } else if (_appeal.status == 3) {
                _win = _appeal.seller;
            }
        } else {
            if (_appeal.status == 2) {
                _win = _appeal.seller;
            } else if (_appeal.status == 3) {
                _win = _appeal.buyer;
            }
        }
        require(_win == msg.sender, "opt error");

        _updateOrderStatus(_o, 5);
        orderFrozenTotal[_appeal.seller][_o] = 0;
        _recordStorage.subFrozenTotal(_o, msg.sender);
    }

    function _updateOrderStatus(uint256 _orderNo, uint256 _orderStatus)
        internal
        onlyBuyerOrSeller(_orderNo)
    {
        Order memory order = orders[_orderNo];
        require(
            order.orderNo != uint256(0),
            "OrderStorage: current Order not exist"
        );
        require(_orderStatus >= 1 && _orderStatus <= 5, "Invalid order status");

        if (_orderStatus == 2 && order.orderStatus != 1) {
            revert("Invalid order status 2");
        }
        if (_orderStatus == 3 && order.orderStatus != 2) {
            revert("Invalid order status 3");
        }
        if (_orderStatus == 4 && order.orderStatus != 1) {
            revert("Invalid order status 4");
        }
        if (
            _orderStatus == 5 &&
            order.orderStatus != 1 &&
            order.orderStatus != 2
        ) {
            revert("Invalid order status 5");
        }

        if (_orderStatus == 2) {
            require(
                order.orderDetail.buyerAddr == msg.sender,
                "only buyer call"
            );
        }
        if (_orderStatus == 3) {
            require(
                order.orderDetail.sellerAddr == msg.sender,
                "only seller call"
            );
        }
        order.orderStatus = _orderStatus;

        order.orderDetail.updateTime = block.timestamp;
        orders[_orderNo] = order;
        orderList[orderIndex[_orderNo]] = order;
        emit OrderUpdateStatus(_orderNo, _orderStatus);
    }

    function _search(uint256 _orderNo)
        internal
        view
        returns (Order memory order)
    {
        require(
            _orderNo != uint256(0),
            "OrderStorage: orderNo null is not allowed"
        );
        require(
            orders[_orderNo].orderNo != uint256(0),
            "OrderStorage: current Order not exist"
        );

        Order memory o = orders[_orderNo];
        return o;
    }

    function searchOrder(uint256 _orderNo)
        external
        view
        returns (Order memory order)
    {
        return _search(_orderNo);
    }

    function searchOrderList() external view returns (Order[] memory) {
        return orderList;
    }

    function searchMyOrderList() external view returns (Order[] memory) {
        Order[] memory resultList = new Order[](orderList.length);
        for (uint256 i = 0; i < orderList.length; i++) {
            Order memory _order = orderList[i];
            if (
                _order.orderDetail.buyerAddr == msg.sender ||
                _order.orderDetail.sellerAddr == msg.sender
            ) {
                resultList[i] = _order;
            }
        }
        return resultList;
    }

    function searchListByRest(uint256 _restNo)
        external
        view
        returns (Order[] memory)
    {
        Order[] memory resultList = new Order[](orderList.length);
        for (uint256 i = 0; i < orderList.length; i++) {
            Order memory _order = orderList[i];
            if (_order.restNo == _restNo) {
                resultList[i] = _order;
            }
        }
        return resultList;
    }
}


The OrderStorage contract is responsible for managing orders in a marketplace. It allows users to create buy and sell orders, update order status, cancel orders, and confirm order completion. It also handles the transfer of tokens between buyers and sellers.

OrderStorage

_addr

_coinType

remainHoldCoin

addAvailableTotal

_hostCount

_hostStatus

_hostType

_hostDirection

addRecord

getAppealFee

getAppealFeeFinal

getAvailableTotal

getErcBalance

getFrozenTotal

getObserverHandleCredit

getObserverHandleReward

getOpenTrade

getSubTCredit

getSubWitCredit

getSubWitFee

getTradeCredit

getWitnessHandleCredit

getWitnessHandleReward

setERC20Address

_from

_amt

_self

subAvaAppeal

subFrozenTotal

subWitnessAvailable

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;
import "./RestStorage.sol";
import './OrderStorage.sol';
import './UserStorage.sol';
import './RecordStorage.sol';
import './AppealStorage.sol';

interface RecordInterface {
    function getErcBalance(string memory _coinType, address _addr) external returns(uint);
    function getAvailableTotal(address _addr, string memory _coinType) external returns(uint);
    function getFrozenTotal(address _addr, string memory _coinType) external returns(uint);
    function addAvailableTotal(address _addr, string memory _coinType, uint remainHoldCoin) external;
    function subAvaAppeal(address _from, address _to, AppealStorage.Appeal memory _al, uint _amt, uint _type, uint _self) external;
    function subWitnessAvailable(address _addr) external;
    function setERC20Address(string memory _coinType) external returns(TokenTransfer);
    function subFrozenTotal(uint _orderNo, address _addr) external;
    function addRecord(address _addr, string memory _tradeHash, string memory _coinType, uint _hostCount, uint _hostStatus, uint _hostType, uint _hostDirection) external;
    function getAppealFee() external view returns(uint);
    function getAppealFeeFinal() external view returns(uint);
    function getWitnessHandleReward() external view returns(uint);
    function getObserverHandleReward() external view returns(uint);
    function getWitnessHandleCredit() external view returns(uint);
    function getObserverHandleCredit() external view returns(uint); 
    function getSubWitCredit() external view returns(uint);
    function getOpenTrade() external view returns(bool);
    function getTradeCredit() external view returns(uint);
    function getSubTCredit() external view returns(uint);
    function getSubWitFee() external view returns(uint);
}
interface RestInterface {
    function searchRest(uint _restNo) external returns(RestStorage.Rest memory rest);
    function getRestFrozenTotal(address _addr, uint _restNo) external returns(uint);
    function updateRestFinishCount(uint _restNo, uint _coinCount) external returns(uint);
    function addRestRemainCount(uint _restNo, uint _remainCount) external returns(uint);
}
interface OrderInterface {
    function searchOrder(uint _orderNo) external returns(OrderStorage.Order memory order);
}
interface UserInterface {
    function searchUser(address _addr) external view returns(UserStorage.User memory user);
    function searchWitnessList(uint _userFlag) external returns(UserStorage.User[] memory userList);
    function updateTradeStats(address _addr, UserStorage.TradeStats memory _tradeStats, uint _credit) external;
    function updateMorgageStats(address _addr, UserStorage.MorgageStats memory _morgageStats) external;
    function updateUserRole(address _addr, uint _userFlag) external;
}
interface AppealInterface {
    function searchAppeal(uint _o) external view returns(AppealStorage.Appeal memory appeal);
}


This smart contract provides functions for managing records, balances, appeals, and user roles in a decentralized application. It interfaces with other contracts for storage and retrieval of data related to orders, users, and restaurants.

RecordInterface

_usdtAddress

_usdcAddress

_busdAddress

_airAddress

_recordNo

RecordAdd

RecordApplyUnfrozen

_hash

RecordUpdate

_lastAmount

UnfrozenTotalTransfer

applyUnfrozen

applyWithdraw

_fromUser

_fromRest

_fromOrder

availableTotal

frozenTotal

getAppealFeeCoinTypeList

getCanWithdrawToTime

getCoinType

getCoinTypeMapping

getCongressFlag

getCongressNeedCount

getMerchantNeedCount

getUnfrozenTotal

getWithdrawingTotal

getWitnessFlag

getWitnessNeedCount

punishPerson

recordIndex

recordList

recordNo

userAddr

tradeHash

coinType

hostCount

hostStatus

hostType

hostDirection

hostTime

updateTime

records

searchRecord

record

searchRecordList

setAppealFee

_list

setAppealFeeCoinTypeList

setAppealFeeFinal

_days

setCanWithdrawToTime

_coinTypeList

setCoinType

_coinTypeAddr

setCoinTypeMapping

_flag

setCongressFlag

setCongressNeedCount

setMerchantNeedCount

setObserverHandleCredit

setObserverHandleReward

setOpenTrade

setSubTCredit

setSubWitCredit

setSubWitFee

setTradeCredit

setWitnessFlag

setWitnessHandleCredit

setWitnessHandleReward

setWitnessNeedCount

tokenEscrow

unfrozenTotal

unfrozenTotalSearch

updateInfo

withdrawingTotal

The RecordStorage contract is a storage contract that allows users to store and manage records. It provides functions for setting and getting various parameters related to the records, such as coin types, counts, fees, and flags. It also allows for the creation and retrieval of records, as well as the transfer of tokens.

RecordStorage

_userContractAddr

_restType

_currencyType

_restCount

_price

_restDetail

RestAdd

RestUpdate

_restHash

RestUpdateHash

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;

import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./RecordInterface.sol";
import "./UserStorage.sol";
import "./RecordStorage.sol";

contract RestStorage {
    RecordInterface private _recordStorage;
    UserInterface private _userStorage;
    address recordAddress;

    struct Rest {
        address userAddr;
        uint256 restNo;
        uint256 restType;
        string coinType;
        string currencyType;
        uint256 restCount;
        uint256 price;
        uint256[] payType;
        uint256 restStatus;
        RestDetail restDetail;
    }
    struct RestDetail {
        uint256 finishCount;
        uint256 remainderCount;
        uint256 limitAmountFrom;
        uint256 limitAmountTo;
        uint256 limitMinCredit;
        uint256 limitMinMortgage;
        string restRemark;
        uint256 restTime;
        uint256 updateTime;
        uint256 restFee;
        string restHash;
    }

    mapping(uint256 => Rest) private rests;
    mapping(uint256 => uint256) private restIndex;

    Rest[] private restList;

    mapping(address => mapping(uint256 => uint256)) restFrozenTotal;

    event RestAdd(
        uint256 _restNo,
        uint256 _restType,
        string _coinType,
        string _currencyType,
        uint256 _restCount,
        uint256 _price,
        uint256[] _payType,
        RestDetail _restDetail
    );
    event RestUpdate(
        uint256 _restNo,
        string _coinType,
        string _currencyType,
        uint256 _restCount,
        uint256 _price,
        uint256[] _payType,
        RestDetail _restDetail
    );
    event RestUpdateHash(uint256 _restNo, string _restHash);

    constructor(address _recordAddr, address _userContractAddr) {
        _recordStorage = RecordInterface(_recordAddr);
        _userStorage = UserInterface(_userContractAddr);
        recordAddress = _recordAddr;
    }

    address _orderCAddr;

    modifier onlyAuthFromAddr() {
        require(_orderCAddr != address(0), "Invalid address call rest");
        _;
    }

    function authFromContract(address _fromOrder) external {
        require(_orderCAddr == address(0), "order address has Auth");
        _orderCAddr = _fromOrder;
    }

    modifier onlyRestOwner(uint256 _restNo) {
        require(
            rests[_restNo].userAddr == msg.sender,
            "rest address not exist"
        );
        _;
    }

    function _checkParam(
        uint256 _restType,
        string memory _coinType,
        string memory _currencyType,
        uint256 _restCount,
        uint256 _price,
        uint256[] memory _payType
    ) internal pure {
        require(
            _restType != uint256(0),
            "RestStorage: restType null is not allowed"
        );
        require(
            bytes(_coinType).length != 0,
            "RestStorage: coinType null is not allowed"
        );
        require(
            bytes(_currencyType).length != 0,
            "RestStorage: currencyType null is not allowed"
        );
        require(
            _restCount != uint256(0),
            "RestStorage: restCount null is not allowed"
        );
        require(_price != uint256(0), "RestStorage: price null is not allowed");
        require(
            _payType.length != 0,
            "RestStorage: payType null is not allowed"
        );
    }

    function _insert(
        uint256 _restType,
        string memory _coinType,
        string memory _currencyType,
        uint256 _restCount,
        uint256 _price,
        uint256[] memory _payType,
        RestDetail memory _restDetail
    ) internal returns (uint256) {
        _checkParam(
            _restType,
            _coinType,
            _currencyType,
            _restCount,
            _price,
            _payType
        );

        uint256 _restNo = block.timestamp;
        _restDetail.finishCount = 0;
        _restDetail.remainderCount = _restCount;
        _restDetail.restTime = block.timestamp;
        _restDetail.updateTime = 0;

        if (
            _restDetail.limitAmountTo > SafeMath.mul(_restCount, _price) ||
            _restDetail.limitAmountTo == 0
        ) {
            _restDetail.limitAmountTo = SafeMath.mul(_restCount, _price);
        }
        Rest memory r = Rest({
            userAddr: msg.sender,
            restNo: _restNo,
            restType: _restType,
            coinType: _coinType,
            currencyType: _currencyType,
            restCount: _restCount,
            price: _price,
            payType: _payType,
            restStatus: 1,
            restDetail: _restDetail
        });
        rests[_restNo] = r;

        restList.push(r);
        restIndex[_restNo] = restList.length - 1;

        emit RestAdd(
            _restNo,
            _restType,
            _coinType,
            _currencyType,
            _restCount,
            _price,
            _payType,
            _restDetail
        );
        return _restNo;
    }

    function _updateInfo(
        uint256 _restNo,
        string memory _coinType,
        string memory _currencyType,
        uint256 _restCount,
        uint256 _price,
        uint256[] memory _payType,
        RestDetail memory _restDetail
    ) internal {
        require(_restNo != uint256(0), "Invalid restNo");
        Rest memory r = rests[_restNo];
        r.restStatus = 1;
        if (bytes(_coinType).length != 0) {
            r.coinType = _coinType;
        }
        if (bytes(_currencyType).length != 0) {
            r.currencyType = _currencyType;
        }

        if (_restCount != uint256(0)) {
            r.restCount = _restCount;
        }
        if (_price != uint256(0)) {
            r.price = _price;
        }
        if (_payType.length != 0) {
            r.payType = _payType;
        }

        if (_restDetail.limitAmountFrom != uint256(0)) {
            r.restDetail.limitAmountFrom = _restDetail.limitAmountFrom;
        }
        if (_restDetail.limitAmountTo != uint256(0)) {
            if (_restDetail.limitAmountTo > SafeMath.mul(_restCount, _price)) {
                _restDetail.limitAmountTo = SafeMath.mul(_restCount, _price);
            }
            r.restDetail.limitAmountTo = _restDetail.limitAmountTo;
        }
        if (_restDetail.limitMinCredit != uint256(0)) {
            r.restDetail.limitMinCredit = _restDetail.limitMinCredit;
        }
        if (_restDetail.limitMinMortgage != uint256(0)) {
            r.restDetail.limitMinMortgage = _restDetail.limitMinMortgage;
        }
        if (bytes(_restDetail.restRemark).length != 0) {
            r.restDetail.restRemark = _restDetail.restRemark;
        }

        if (_restDetail.restFee != uint256(0)) {
            r.restDetail.restFee = _restDetail.restFee;
        }
        if (bytes(_restDetail.restHash).length != 0) {
            r.restDetail.restHash = _restDetail.restHash;
        }

        r.restDetail.updateTime = block.timestamp;
        rests[_restNo] = r;
        restList[restIndex[_restNo]] = r;
        emit RestUpdate(
            _restNo,
            _coinType,
            _currencyType,
            _restCount,
            _price,
            _payType,
            _restDetail
        );
    }

    function addBuyRest(
        uint256 _restType,
        string memory _coinType,
        string memory _currencyType,
        uint256 _restCount,
        uint256 _price,
        uint256[] memory _payType,
        RestDetail memory _restDetail
    ) external {
        require(_restType == 1, "must buy rest");

        UserStorage.User memory _user = _userStorage.searchUser(msg.sender);

        bool _openTrade = _recordStorage.getOpenTrade();
        require(_openTrade || _user.userFlag == 3, "invalid user");

        _insert(
            _restType,
            _coinType,
            _currencyType,
            _restCount,
            _price,
            _payType,
            _restDetail
        );
    }

    function _addSell(
        uint256 _restType,
        string memory _coinType,
        string memory _currencyType,
        uint256 _restCount,
        uint256 _restFee,
        uint256 _price,
        uint256[] memory _payType,
        RestDetail memory _restDetail
    ) internal {
        require(_restType == 2, "must sell rest");
        require(_restCount > 0, "restCount error");
        require(_restFee >= 0, "restFee error");

        UserStorage.User memory _user = _userStorage.searchUser(msg.sender);
        bool _openTrade = _recordStorage.getOpenTrade();
        require(_openTrade || _user.userFlag == 3, "invalid user");

        uint256 _newRestNo = _insert(
            _restType,
            _coinType,
            _currencyType,
            _restCount,
            _price,
            _payType,
            _restDetail
        );

        restFrozenTotal[msg.sender][_newRestNo] = _restCount;

        _recordStorage.addRecord(
            msg.sender,
            "",
            _coinType,
            _restCount,
            2,
            1,
            2
        );
        uint256 _needSub = SafeMath.add(_restCount, _restFee);
        TokenTransfer _tokenTransfer = _recordStorage.setERC20Address(
            _coinType
        );
        _tokenTransfer.transferFrom(msg.sender, recordAddress, _needSub);
    }

    function addSellRest(
        uint256 _restType,
        string memory _coinType,
        string memory _currencyType,
        uint256 _restCount,
        uint256 _restFee,
        uint256 _price,
        uint256[] memory _payType,
        RestDetail memory _restDetail
    ) external {
        _addSell(
            _restType,
            _coinType,
            _currencyType,
            _restCount,
            _restFee,
            _price,
            _payType,
            _restDetail
        );
    }

    function getRestFrozenTotal(address _addr, uint256 _restNo)
        public
        view
        returns (uint256)
    {
        return restFrozenTotal[_addr][_restNo];
    }

    function cancelBuyRest(uint256 _restNo) external onlyRestOwner(_restNo) {
        require(rests[_restNo].restStatus == 1, "can't change this rest");
        require(rests[_restNo].restType == 1, "Invalid rest type");
        require(
            rests[_restNo].restDetail.finishCount < rests[_restNo].restCount,
            "this rest has finished"
        );

        Rest memory r = rests[_restNo];
        r.restStatus = 4;
        r.restDetail.updateTime = block.timestamp;
        rests[_restNo] = r;
        restList[restIndex[_restNo]] = r;
    }

    function _cancelSell(uint256 _restNo) internal onlyRestOwner(_restNo) {
        require(rests[_restNo].restStatus == 1, "can't cancel this rest");
        require(rests[_restNo].restType == 2, "Invalid rest type");
        require(
            rests[_restNo].restDetail.finishCount < rests[_restNo].restCount,
            "this rest has finished"
        );
        require(restFrozenTotal[msg.sender][_restNo] > 0, "rest has finished");
        uint256 _frozenTotal = _recordStorage.getFrozenTotal(
            msg.sender,
            rests[_restNo].coinType
        );
        require(
            _frozenTotal >= restFrozenTotal[msg.sender][_restNo],
            "can't cancel this rest"
        );

        uint256 remainHoldCoin = restFrozenTotal[msg.sender][_restNo];

        Rest memory r = rests[_restNo];
        r.restStatus = 4;

        if (remainHoldCoin < rests[_restNo].restCount) {
            r.restStatus = 5;
        }
        r.restDetail.remainderCount = 0;
        r.restDetail.updateTime = block.timestamp;
        rests[_restNo] = r;
        restList[restIndex[_restNo]] = r;

        restFrozenTotal[msg.sender][_restNo] = 0;

        _recordStorage.addAvailableTotal(
            msg.sender,
            rests[_restNo].coinType,
            remainHoldCoin
        );
    }

    function cancelSellRest(uint256 _restNo) external {
        _cancelSell(_restNo);
    }

    function startOrStop(uint256 _restNo, uint256 _restStatus)
        external
        onlyRestOwner(_restNo)
    {
        require(_restStatus == 1 || _restStatus == 3, "Invalid rest status");

        Rest memory r = rests[_restNo];
        require(
            r.restStatus == 1 || r.restStatus == 3,
            "Invalid rest status,opt error"
        );
        r.restStatus = _restStatus;
        r.restDetail.updateTime = block.timestamp;
        rests[_restNo] = r;
        restList[restIndex[_restNo]] = r;
    }

    function updateInfo(
        uint256 _restNo,
        string memory _coinType,
        string memory _currencyType,
        uint256 _restCount,
        uint256 _restFee,
        uint256 _price,
        uint256[] memory _payType,
        RestDetail memory _restDetail
    ) external onlyRestOwner(_restNo) {
        require(_restNo != uint256(0), "Invalid restNo");
        Rest memory _rest = rests[_restNo];
        require(_rest.restNo != uint256(0), "rest not exist");

        if (_rest.restType == 2) {
            _cancelSell(_restNo);
            _addSell(
                2,
                _coinType,
                _currencyType,
                _restCount,
                _restFee,
                _price,
                _payType,
                _restDetail
            );
        } else {
            _updateInfo(
                _restNo,
                _coinType,
                _currencyType,
                _restCount,
                _price,
                _payType,
                _restDetail
            );
        }
    }

    function updateRestFinishCount(uint256 _restNo, uint256 _finishCount)
        external
        onlyAuthFromAddr
    {
        require(
            msg.sender == _orderCAddr,
            "RestStorage:Invalid from contract address"
        );
        Rest memory _rest = rests[_restNo];

        require(
            _rest.restDetail.remainderCount >= _finishCount,
            "RestStorage:finish count error"
        );

        if (_rest.restType == 2) {
            restFrozenTotal[_rest.userAddr][_restNo] = SafeMath.sub(
                restFrozenTotal[_rest.userAddr][_restNo],
                _finishCount
            );
        }

        _rest.restDetail.finishCount = SafeMath.add(
            _rest.restDetail.finishCount,
            _finishCount
        );
        _rest.restDetail.remainderCount = SafeMath.sub(
            _rest.restDetail.remainderCount,
            _finishCount
        );
        _rest.restDetail.limitAmountTo = SafeMath.mul(
            _rest.price,
            _rest.restDetail.remainderCount
        );
        if (_rest.restDetail.remainderCount == 0) {
            _rest.restStatus = 2;
        }

        _rest.restDetail.updateTime = block.timestamp;
        rests[_restNo] = _rest;
        restList[restIndex[_restNo]] = _rest;
    }

    function addRestRemainCount(uint256 _restNo, uint256 _remainCount)
        public
        onlyAuthFromAddr
    {
        require(
            msg.sender == _orderCAddr,
            "RestStorage:Invalid from contract address"
        );
        Rest memory _rest = rests[_restNo];
        require(
            _remainCount > 0 && _rest.restDetail.finishCount >= _remainCount,
            "RestStorage:finish count error"
        );

        if (_rest.restType == 2) {
            restFrozenTotal[_rest.userAddr][_restNo] = SafeMath.add(
                restFrozenTotal[_rest.userAddr][_restNo],
                _remainCount
            );
        }

        _rest.restDetail.finishCount = SafeMath.sub(
            _rest.restDetail.finishCount,
            _remainCount
        );
        _rest.restDetail.remainderCount = SafeMath.add(
            _rest.restDetail.remainderCount,
            _remainCount
        );
        _rest.restStatus = 1;

        _rest.restDetail.updateTime = block.timestamp;
        rests[_restNo] = _rest;
        restList[restIndex[_restNo]] = _rest;
    }

    function searchRest(uint256 _restNo)
        external
        view
        returns (Rest memory rest)
    {
        require(_restNo != uint256(0), "restNo null is not allowed");
        Rest memory r = rests[_restNo];
        return r;
    }

    function searchRestList()
        external
        view
        returns (Rest[] memory, UserStorage.User[] memory)
    {
        UserStorage.User[] memory userList = new UserStorage.User[](
            restList.length
        );
        for (uint256 i = 0; i < restList.length; i++) {
            Rest memory _rest = restList[i];
            UserStorage.User memory _user = _userStorage.searchUser(
                _rest.userAddr
            );
            userList[i] = _user;
        }
        return (restList, userList);
    }
}


The RestStorage contract is a smart contract that manages the storage and manipulation of rest-related data. It allows users to add and update rest information, including rest type, coin type, currency type, rest count, price, payment types, and rest details. Users can also cancel or start/stop rests, and the contract keeps track of frozen rest totals.

AirCoinDAOLabs is a decentralized autonomous organization (DAO).  It has built AirCoin, AIRNFT, AirCash(http://aircash.finance), and ACGVentures.