From 42912bc751eca9264e86f793e3705ce8593163c3 Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Tue, 18 Sep 2018 13:48:14 +0300
Subject: [PATCH 01/18] administratum: advanced master-worker relations

orders crud

master-worker crud

deals crud

change requests crud

massive market reworking

update tests

update migrations

 least crud contracts updations

update gas usage in truffle.js

contracts works fine

migrations updated, will refactor later
---
 blockchain/source/contracts/Administratum.sol | 109 +++
 .../source/contracts/ChangeRequests.sol       | 127 ++++
 blockchain/source/contracts/Deals.sol         | 273 +++++++
 blockchain/source/contracts/Market.sol        | 714 +++++++-----------
 blockchain/source/contracts/Orders.sol        | 202 +++++
 ...list.js => 10_set_market_for_blacklist.js} |  14 +-
 .../source/migrations/1_deploy_token.js       |   4 +-
 .../source/migrations/2_deploy_oracle.js      |   2 +-
 .../migrations/3_deploy_profileRegistry.js    |   2 +-
 .../source/migrations/4_deploy_blacklist.js   |   2 +-
 .../source/migrations/5_deploy_market.js      |  24 -
 blockchain/source/migrations/7_deploy_crud.js |  19 +
 .../migrations/8_deploy_administratum.js      |  13 +
 .../source/migrations/9_deploy_market.js      |  37 +
 blockchain/source/test/blacklist.js           |  20 +-
 blockchain/source/test/market.js              |  19 +
 blockchain/source/truffle.js                  |   5 +-
 17 files changed, 1119 insertions(+), 467 deletions(-)
 create mode 100644 blockchain/source/contracts/Administratum.sol
 create mode 100644 blockchain/source/contracts/ChangeRequests.sol
 create mode 100644 blockchain/source/contracts/Deals.sol
 create mode 100644 blockchain/source/contracts/Orders.sol
 rename blockchain/source/migrations/{6_set_market_for_blacklist.js => 10_set_market_for_blacklist.js} (70%)
 delete mode 100644 blockchain/source/migrations/5_deploy_market.js
 create mode 100644 blockchain/source/migrations/7_deploy_crud.js
 create mode 100644 blockchain/source/migrations/8_deploy_administratum.js
 create mode 100644 blockchain/source/migrations/9_deploy_market.js

diff --git a/blockchain/source/contracts/Administratum.sol b/blockchain/source/contracts/Administratum.sol
new file mode 100644
index 000000000..e56d3f576
--- /dev/null
+++ b/blockchain/source/contracts/Administratum.sol
@@ -0,0 +1,109 @@
+pragma solidity ^0.4.23;
+
+import "zeppelin-solidity/contracts/ownership/Ownable.sol";
+
+contract Administratum is Ownable{
+    // events
+
+
+    event WorkerAnnounced(address indexed worker, address indexed master);
+    event WorkerConfirmed(address indexed worker, address indexed master);
+    event WorkerRemoved(address indexed worker, address indexed master);
+    event adminAdded(address indexed admin, address indexed master);
+
+    // storage
+    mapping(address => address) masterOf;
+
+    mapping(address => bool) isMaster;
+
+    mapping(address => mapping(address => bool)) masterRequest;
+
+    //maps admin into its master; alternative method
+    //that's like asym cryptography, but implemented by design
+    mapping(address => address) admins;
+
+    mapping(address => bool) autoPayoutFlag;
+
+    uint public payoutSupremum;
+
+    //constructor
+    constructor(){
+        owner = msg.sender;
+    }
+
+    //funcs
+
+    function RegisterWorker(address _master) public returns (bool) {
+        require(GetMaster(msg.sender) == msg.sender);
+        require(isMaster[msg.sender] == false);
+        require(GetMaster(_master) == _master);
+        masterRequest[_master][msg.sender] = true;
+        emit WorkerAnnounced(msg.sender, _master);
+        return true;
+    }
+
+    function ConfirmWorker(address _worker) public returns (bool) {
+        require(masterRequest[msg.sender][_worker] == true ||  IsValid(_worker));
+        masterOf[_worker] = msg.sender;
+        isMaster[msg.sender] = true;
+        delete masterRequest[msg.sender][_worker];
+        emit WorkerConfirmed(_worker, msg.sender);
+        return true;
+    }
+
+    function RemoveWorker(address _worker, address _master) public returns (bool) {
+        require(GetMaster(_worker) == _master && (msg.sender == _worker || msg.sender == _master));
+        delete masterOf[_worker];
+        emit WorkerRemoved(_worker, _master);
+        return true;
+    }
+
+    function RegisterAdmin(address _admin) public returns (bool){
+        require(GetMaster(msg.sender) == msg.sender);
+        require(msg.sender != _admin);
+        admins[_admin] = msg.sender;
+        return true;
+    }
+
+    function EnableAutoPayout() public returns (bool){
+        require(GetMaster(msg.sender) == msg.sender);
+        autoPayoutFlag[msg.sender] = true;
+        return true;
+    }
+
+    function DisableAutoPayout() public returns (bool){
+        require(autoPayoutFlag[msg.sender] == true);
+        autoPayoutFlag[msg.sender] = false;
+        return true;
+    }
+
+
+    //INTERNAL
+    // check if transaction sended by valid admin
+    function IsValid(address _worker) view internal returns(bool){
+        address master = admins[msg.sender];
+        return admins[msg.sender] != address(0) && masterRequest[master][_worker] == true;
+    }
+
+
+    //GETTERS
+    function GetMaterOfAdmin(address _admin) view public returns (address){
+        return admins[_admin];
+    }
+
+    function GetMaster(address _worker) view public returns (address master) {
+        if (masterOf[_worker] == 0x0 || masterOf[_worker] == _worker) {
+            master = _worker;
+        } else {
+            master = masterOf[_worker];
+        }
+    }
+
+    function GetAutoPayoutFlag(address _master) view public returns (bool) {
+        return autoPayoutFlag[_master];
+    }
+
+    //modifiers
+
+
+}
diff --git a/blockchain/source/contracts/ChangeRequests.sol b/blockchain/source/contracts/ChangeRequests.sol
new file mode 100644
index 000000000..f68d411cf
--- /dev/null
+++ b/blockchain/source/contracts/ChangeRequests.sol
@@ -0,0 +1,127 @@
+pragma solidity ^0.4.23;
+
+import "zeppelin-solidity/contracts/ownership/Ownable.sol";
+import "zeppelin-solidity/contracts/math/SafeMath.sol";
+import "./Orders.sol";
+
+
+contract ChangeRequests is Ownable {
+    using SafeMath for uint256;
+
+    mapping(uint => ChangeRequest) requests;
+
+    mapping(uint => uint[2]) actualRequests;
+
+    uint requestsAmount;
+
+    struct ChangeRequest {
+        uint dealID;
+        Orders.OrderType requestType;
+        uint price;
+        uint duration;
+        RequestStatus status;
+    }
+
+    enum RequestStatus {
+        REQUEST_UNKNOWN,
+        REQUEST_CREATED,
+        REQUEST_CANCELED,
+        REQUEST_REJECTED,
+        REQUEST_ACCEPTED
+    }
+
+
+    constructor() public {
+        owner = msg.sender;
+    }
+
+    function Write(
+        uint _dealID,
+        Orders.OrderType _requestType,
+        uint _price,
+        uint _duration,
+        RequestStatus _status) public onlyOwner returns(uint){
+
+        requestsAmount = requestsAmount.add(1);
+
+        requests[requestsAmount] = ChangeRequest(_dealID, _requestType, _price, _duration, _status);
+
+        return  requestsAmount;
+    }
+
+    //SETTERS
+
+    function SetChangeRequestDealID(uint _changeRequestID, uint _dealID) public onlyOwner {
+        requests[_changeRequestID].dealID = _dealID;
+    }
+
+    function SetChangeRequestType(uint _changeRequestID, Orders.OrderType _type) public onlyOwner {
+        requests[_changeRequestID].requestType = _type;
+    }
+
+    function SetChangeRequestPrice(uint _changeRequestID, uint _price) public onlyOwner {
+        requests[_changeRequestID].price = _price;
+    }
+
+    function SetChangeRequestDuration(uint _changeRequestID, uint _duration) public onlyOwner {
+        requests[_changeRequestID].duration = _duration;
+    }
+
+    function SetChangeRequestStatus(uint _changeRequestID, RequestStatus _status) public onlyOwner {
+        requests[_changeRequestID].status = _status;
+    }
+
+    function SetActualChangeRequest(uint dealID, uint role, uint _changeRequestID) public onlyOwner {
+        actualRequests[dealID][role] = _changeRequestID;
+    }
+
+    // GETTERS
+
+    function GetChangeRequestDealID(uint _changeRequestID) public view returns(uint) {
+        return requests[_changeRequestID].dealID;
+    }
+
+    function GetChangeRequestType(uint _changeRequestID) public view returns(Orders.OrderType) {
+        return requests[_changeRequestID].requestType;
+    }
+
+    function GetChangeRequestPrice(uint _changeRequestID) public view returns(uint) {
+        return requests[_changeRequestID].price;
+    }
+
+    function GetChangeRequestDuration(uint _changeRequestID) public view returns(uint) {
+        return requests[_changeRequestID].duration;
+    }
+
+    function GetChangeRequestStatus(uint _changeRequestID) public view returns(RequestStatus) {
+        return requests[_changeRequestID].status;
+    }
+
+    function GetActualChangeRequest(uint dealID, uint role)public view returns(uint) {
+        return actualRequests[dealID][role];
+
+    }
+
+    function GetChangeRequestsAmount() public view returns(uint)  {
+        return requestsAmount;
+    }
+
+    function GetChangeRequestInfo(uint changeRequestID) view public
+        returns (
+        uint dealID,
+        Orders.OrderType requestType,
+        uint price,
+        uint duration,
+        RequestStatus status
+        ) {
+        return (
+        requests[changeRequestID].dealID,
+        requests[changeRequestID].requestType,
+        requests[changeRequestID].price,
+        requests[changeRequestID].duration,
+        requests[changeRequestID].status
+        );
+    }
+
+
+}
diff --git a/blockchain/source/contracts/Deals.sol b/blockchain/source/contracts/Deals.sol
new file mode 100644
index 000000000..0b7d640c3
--- /dev/null
+++ b/blockchain/source/contracts/Deals.sol
@@ -0,0 +1,273 @@
+pragma solidity ^0.4.23;
+
+import "zeppelin-solidity/contracts/ownership/Ownable.sol";
+
+
+contract Deals is Ownable {
+    //events
+
+    //enums
+    enum DealStatus {
+        STATUS_UNKNOWN,
+        STATUS_ACCEPTED,
+        STATUS_CLOSED
+    }
+    //data
+
+    struct Deal {
+        DealInfo info;
+        DealParams params;
+
+    }
+
+    struct DealInfo {
+        uint64[] benchmarks;
+        address supplierID;
+        address consumerID;
+        address masterID;
+        uint askID;
+        uint bidID;
+        uint startTime;
+    }
+
+    struct DealParams {
+        uint duration;
+        uint price; //usd * 10^-18
+        uint endTime;
+        DealStatus status;
+        uint blockedBalance;
+        uint totalPayout;
+        uint lastBillTS;
+    }
+
+    mapping(uint => Deal) public deals;
+
+    mapping(address => uint[]) dealsID;
+
+    uint dealsAmount = 0;
+
+    //Constructor
+    constructor() public {
+        owner = msg.sender;
+    }
+
+    function Write(
+        uint64[] _benchmarks,
+        address _supplierID,
+        address _consumerID,
+        address _masterID,
+        uint _askID,
+        uint _bidID,
+        uint _duration,
+        uint _price,
+        uint _startTime,
+        uint _endTime,
+        DealStatus _status,
+        uint _blockedBalance,
+        uint _totalPayout,
+        uint _lastBillTS) public onlyOwner returns(uint) {
+
+        dealsAmount += 1;
+
+        deals[dealsAmount].info.benchmarks = _benchmarks;
+        deals[dealsAmount].info.supplierID = _supplierID;
+        deals[dealsAmount].info.consumerID = _consumerID;
+        deals[dealsAmount].info.masterID = _masterID;
+        deals[dealsAmount].info.askID = _askID;
+        deals[dealsAmount].info.bidID = _bidID;
+        deals[dealsAmount].info.startTime = _startTime;
+        deals[dealsAmount].params.duration = _duration;
+        deals[dealsAmount].params.price = _price;
+        deals[dealsAmount].params.endTime = _endTime;
+        deals[dealsAmount].params.status = _status;
+        deals[dealsAmount].params.blockedBalance = _blockedBalance;
+        deals[dealsAmount].params.totalPayout = _totalPayout;
+        deals[dealsAmount].params.lastBillTS = _lastBillTS;
+
+
+        return dealsAmount;
+    }
+
+
+
+
+
+    /* function Close(uint dealID) public onlyOwner {
+        require(dealID >= dealsAmount);
+        deals[dealID].params.status = DealStatus.STATUS_CLOSED;
+        deals[dealID].params.endTime = block.timestamp;
+    }
+
+    function Bill(uint dealID, uint _balance, uint _totalPayout, uint _billTS) public onlyOwner {
+        require(dealID >= dealsAmount);
+        deals[dealID].params.blockedBalance = _balance;
+        deals[dealID].params.lastBillTS = _billTS;
+        deals[dealID].params.totalPayout = _totalPayout;
+    } */
+
+    function SetDealBenchmarks(uint dealID, uint64[] _benchmarks) public onlyOwner {
+        deals[dealID].info.benchmarks = _benchmarks;
+    }
+
+    function SetDealSupplierID(uint dealID, address _supplierID) public onlyOwner {
+        deals[dealID].info.supplierID = _supplierID;
+    }
+    function SetDealConsumerID(uint dealID, address _consumerID) public onlyOwner {
+        deals[dealID].info.consumerID = _consumerID;
+    }
+
+    function SetDealMasterID(uint dealID, address _masterID) public onlyOwner {
+        deals[dealID].info.masterID = _masterID;
+    }
+
+    function SetDealAskID(uint dealID, uint _askID) public onlyOwner {
+        deals[dealID].info.askID = _askID;
+    }
+
+    function SetDealBidID(uint dealID, uint _bidID) public onlyOwner {
+        deals[dealID].info.bidID = _bidID;
+    }
+
+    function SetDealStartTime(uint dealID, uint _startTime) public onlyOwner {
+        deals[dealID].info.startTime = _startTime;
+    }
+
+    function SetDealStatus(uint dealID, DealStatus _status) public onlyOwner {
+        deals[dealID].params.status = _status;
+    }
+
+    function SetDealEndTime(uint dealID, uint _endTime) public onlyOwner {
+        deals[dealID].params.endTime = _endTime;
+    }
+
+    function SetDealBlockedBalance(uint dealID, uint _blockedBalance) public onlyOwner {
+        deals[dealID].params.blockedBalance = _blockedBalance;
+    }
+
+    function SetDealLastBillTS(uint dealID, uint _lastBillTS) public onlyOwner {
+        deals[dealID].params.lastBillTS = _lastBillTS;
+    }
+
+    function SetDealTotalPayout(uint dealID, uint _totalPayout) public onlyOwner {
+        deals[dealID].params.totalPayout = _totalPayout;
+    }
+
+    function SetDealPrice(uint dealID, uint _price) public onlyOwner {
+        deals[dealID].params.price = _price;
+    }
+    function SetDealDuration(uint dealID, uint _duration) public onlyOwner {
+        deals[dealID].params.duration = _duration;
+    }
+
+    function IncreaseDealsAmount() public onlyOwner {
+        dealsAmount += 1;
+    }
+
+
+    //getters
+
+    function GetDealInfo(uint dealID) public view
+    returns (
+        uint64[] benchmarks,
+        address supplierID,
+        address consumerID,
+        address masterID,
+        uint askID,
+        uint bidID,
+        uint startTime
+    ) {
+        DealInfo memory info = deals[dealID].info;
+        return (
+        info.benchmarks,
+        info.supplierID,
+        info.consumerID,
+        info.masterID,
+        info.askID,
+        info.bidID,
+        info.startTime
+        );
+    }
+
+    function GetDealParams(uint dealID) view public
+    returns (
+        uint duration,
+        uint price,
+        uint endTime,
+        DealStatus status,
+        uint blockedBalance,
+        uint totalPayout,
+        uint lastBillTS
+    ) {
+        DealParams memory params = deals[dealID].params;
+        return (
+        params.duration,
+        params.price,
+        params.endTime,
+        params.status,
+        params.blockedBalance,
+        params.totalPayout,
+        params.lastBillTS
+        );
+    }
+
+    function GetDealBenchmarks(uint dealID) public view returns(uint64[]) {
+        return deals[dealID].info.benchmarks;
+    }
+
+    function GetDealConsumerID(uint dealID) public view returns(address) {
+        return deals[dealID].info.consumerID;
+    }
+
+    function GetDealSupplierID(uint dealID) public view returns(address) {
+        return deals[dealID].info.supplierID;
+    }
+
+    function GetDealMasterID(uint dealID) public view returns(address) {
+        return deals[dealID].info.masterID;
+    }
+
+    function GetDealAskID(uint dealID) public view returns(uint) {
+        return deals[dealID].info.askID;
+    }
+
+    function GetDealBidID(uint dealID) public view returns(uint) {
+        return deals[dealID].info.bidID;
+    }
+
+    function GetDealStartTime(uint dealID) public view returns(uint) {
+        return deals[dealID].info.startTime;
+    }
+
+    function GetDealDuration(uint dealID) public view returns(uint) {
+        return deals[dealID].params.duration;
+    }
+
+    function GetDealPrice(uint dealID) public view returns(uint) {
+        return deals[dealID].params.price;
+    }
+
+    function GetDealEndTime(uint dealID) public view returns(uint) {
+        return deals[dealID].params.endTime;
+    }
+
+    function GetDealStatus(uint dealID) public view returns(DealStatus) {
+        return deals[dealID].params.status;
+    }
+
+    function GetDealBlockedBalance(uint dealID) public view returns(uint) {
+        return deals[dealID].params.blockedBalance;
+    }
+
+    function GetDealTotalPayout(uint dealID) public view returns(uint) {
+        return deals[dealID].params.totalPayout;
+    }
+
+    function GetDealLastBillTS(uint dealID) public view returns(uint) {
+        return deals[dealID].params.lastBillTS;
+    }
+
+    function GetDealsAmount() public view returns(uint) {
+        return dealsAmount;
+    }
+
+}
diff --git a/blockchain/source/contracts/Market.sol b/blockchain/source/contracts/Market.sol
index 35decf30a..c017fcf55 100644
--- a/blockchain/source/contracts/Market.sol
+++ b/blockchain/source/contracts/Market.sol
@@ -7,6 +7,10 @@ import "./SNM.sol";
 import "./Blacklist.sol";
 import "./OracleUSD.sol";
 import "./ProfileRegistry.sol";
+import "./Administratum.sol";
+import "./Orders.sol";
+import "./Deals.sol";
+import "./ChangeRequests.sol";
 
 
 contract Market is Ownable, Pausable {
@@ -15,81 +19,14 @@ contract Market is Ownable, Pausable {
 
     // DECLARATIONS
 
-    enum DealStatus{
-        STATUS_UNKNOWN,
-        STATUS_ACCEPTED,
-        STATUS_CLOSED
-    }
-
-    enum OrderType {
-        ORDER_UNKNOWN,
-        ORDER_BID,
-        ORDER_ASK
-    }
-
-    enum OrderStatus {
-        UNKNOWN,
-        ORDER_INACTIVE,
-        ORDER_ACTIVE
-    }
-
-    enum RequestStatus {
-        REQUEST_UNKNOWN,
-        REQUEST_CREATED,
-        REQUEST_CANCELED,
-        REQUEST_REJECTED,
-        REQUEST_ACCEPTED
-    }
-
     enum BlacklistPerson {
         BLACKLIST_NOBODY,
         BLACKLIST_WORKER,
         BLACKLIST_MASTER
     }
 
-    struct Deal {
-        uint64[] benchmarks;
-        address supplierID;
-        address consumerID;
-        address masterID;
-        uint askID;
-        uint bidID;
-        uint duration;
-        uint price; //usd * 10^-18
-        uint startTime;
-        uint endTime;
-        DealStatus status;
-        uint blockedBalance;
-        uint totalPayout;
-        uint lastBillTS;
-    }
-
-    struct Order {
-        OrderType orderType;
-        OrderStatus orderStatus;
-        address author;
-        address counterparty;
-        uint duration;
-        uint256 price;
-        bool[] netflags;
-        ProfileRegistry.IdentityLevel identityLevel;
-        address blacklist;
-        bytes32 tag;
-        uint64[] benchmarks;
-        uint frozenSum;
-        uint dealID;
-    }
-
-    struct ChangeRequest {
-        uint dealID;
-        OrderType requestType;
-        uint price;
-        uint duration;
-        RequestStatus status;
-    }
 
     // EVENTS
-
     event OrderPlaced(uint indexed orderID);
     event OrderUpdated(uint indexed orderID);
 
@@ -120,9 +57,13 @@ contract Market is Ownable, Pausable {
 
     ProfileRegistry pr;
 
-    uint ordersAmount = 0;
+    Orders ord;
+
+    Administratum adm;
+
+    Deals dl;
 
-    uint dealAmount = 0;
+    ChangeRequests cr;
 
     uint requestsAmount = 0;
 
@@ -132,29 +73,26 @@ contract Market is Ownable, Pausable {
     // current length of netflags
     uint netflagsQuantity;
 
-    mapping(uint => Order) public orders;
-
-    mapping(uint => Deal) public deals;
-
-    mapping(address => uint[]) dealsID;
-
-    mapping(uint => ChangeRequest) requests;
-
-    mapping(uint => uint[2]) actualRequests;
-
-    mapping(address => address) masterOf;
-
-    mapping(address => bool) isMaster;
-
-    mapping(address => mapping(address => bool)) masterRequest;
-
     // INIT
 
-    constructor(address _token, address _blacklist, address _oracle, address _profileRegistry, uint _benchmarksQuantity, uint _netflagsQuantity) public {
+    constructor(address _token,
+        address _blacklist,
+        address _oracle,
+        address _profileRegistry,
+        address _administratum,
+        address _orders,
+        address _deals,
+        address _changeRequests,
+        uint _benchmarksQuantity,
+        uint _netflagsQuantity) public {
         token = SNM(_token);
         bl = Blacklist(_blacklist);
         oracle = OracleUSD(_oracle);
         pr = ProfileRegistry(_profileRegistry);
+        adm = Administratum(_administratum);
+        ord = Orders(_orders);
+        dl = Deals(_deals);
+        cr = ChangeRequests(_changeRequests);
         benchmarksQuantity = _benchmarksQuantity;
         netflagsQuantity = _netflagsQuantity;
     }
@@ -164,8 +102,8 @@ contract Market is Ownable, Pausable {
     // Order functions
 
     function PlaceOrder(
-        OrderType _orderType,
-        address _id_counterparty,
+        Orders.OrderType _orderType,
+        address _counterpartyID,
         uint _duration,
         uint _price,
         bool[] _netflags,
@@ -173,7 +111,7 @@ contract Market is Ownable, Pausable {
         address _blacklist,
         bytes32 _tag,
         uint64[] _benchmarks
-    ) whenNotPaused public returns (uint){
+    ) whenNotPaused public returns (uint) {
 
         require(_identityLevel >= ProfileRegistry.IdentityLevel.ANONYMOUS);
         require(_netflags.length <= netflagsQuantity);
@@ -185,7 +123,7 @@ contract Market is Ownable, Pausable {
 
         uint lockedSum = 0;
 
-        if (_orderType == OrderType.ORDER_BID) {
+        if (_orderType == Orders.OrderType.ORDER_BID) {
             if (_duration == 0) {
                 lockedSum = CalculatePayment(_price, 1 hours);
             } else if (_duration < 1 days) {
@@ -193,18 +131,15 @@ contract Market is Ownable, Pausable {
             } else {
                 lockedSum = CalculatePayment(_price, 1 days);
             }
-            // this line contains err.
-            require(token.transferFrom(msg.sender, this, lockedSum));
+            require(token.transferFrom(msg.sender, address(this), lockedSum));
         }
 
-        ordersAmount = ordersAmount.add(1);
-        uint256 orderId = ordersAmount;
 
-        orders[orderId] = Order(
+        ord.Write(
             _orderType,
-            OrderStatus.ORDER_ACTIVE,
+            Orders.OrderStatus.ORDER_ACTIVE,
             msg.sender,
-            _id_counterparty,
+            _counterpartyID,
             _duration,
             _price,
             _netflags,
@@ -216,126 +151,161 @@ contract Market is Ownable, Pausable {
             0
         );
 
-        emit OrderPlaced(orderId);
-        return orderId;
+        emit OrderPlaced(ord.GetOrdersAmount());
+
+        return ord.GetOrdersAmount();
     }
 
-    function CancelOrder(uint orderID) public returns (bool){
-        require(orderID <= ordersAmount);
-        require(orders[orderID].orderStatus == OrderStatus.ORDER_ACTIVE);
-        require(orders[orderID].author == msg.sender);
+    function CancelOrder(uint orderID) public returns (bool) {
+        require(orderID <= ord.GetOrdersAmount());
+
+        address author = ord.GetOrderAuthor(orderID);
+
+        uint frozenSum = ord.GetOrderFrozenSum(orderID);
+
+        Orders.OrderStatus orderStatus = ord.GetOrderStatus(orderID);
+
+
+        require(orderStatus == Orders.OrderStatus.ORDER_ACTIVE);
+        require(author == msg.sender || adm.GetMaster(author) == msg.sender);
+
+        require(token.transfer(msg.sender, frozenSum));
 
-        require(token.transfer(msg.sender, orders[orderID].frozenSum));
-        orders[orderID].orderStatus = OrderStatus.ORDER_INACTIVE;
+        ord.SetOrderStatus(orderID, Orders.OrderStatus.ORDER_INACTIVE);
 
         emit OrderUpdated(orderID);
+
         return true;
     }
 
     function QuickBuy(uint askID, uint buyoutDuration) public whenNotPaused {
-        Order memory ask = orders[askID];
-        require(ask.orderType == OrderType.ORDER_ASK);
-        require(ask.orderStatus == OrderStatus.ORDER_ACTIVE);
 
-        require(ask.duration >= buyoutDuration);
-        require(pr.GetProfileLevel(msg.sender) >= ask.identityLevel);
-        require(bl.Check(msg.sender, GetMaster(ask.author)) == false && bl.Check(ask.author, msg.sender) == false);
-        require(bl.Check(ask.blacklist, msg.sender) == false);
+        require(ord.GetOrderType(askID) == Orders.OrderType.ORDER_ASK);
+        require(ord.GetOrderStatus(askID) == Orders.OrderStatus.ORDER_ACTIVE);
+
+        require(ord.GetOrderDuration(askID) >= buyoutDuration);
+        require(pr.GetProfileLevel(msg.sender) >= ord.GetOrderIdentityLevel(askID));
+        require(bl.Check(ord.GetOrderBlacklist(askID), msg.sender) == false);
+        require(
+            bl.Check(msg.sender, adm.GetMaster(ord.GetOrderAuthor(askID))) == false
+            && bl.Check(ord.GetOrderAuthor(askID), msg.sender) == false);
 
         PlaceOrder(
-            OrderType.ORDER_BID,
-            GetMaster(ask.author),
+            Orders.OrderType.ORDER_BID,
+            adm.GetMaster(ord.GetOrderAuthor(askID)),
             buyoutDuration,
-            ask.price,
-            ask.netflags,
+            ord.GetOrderPrice(askID),
+            ord.GetOrderNetflags(askID),
             ProfileRegistry.IdentityLevel.ANONYMOUS,
             address(0),
             bytes32(0),
-            ask.benchmarks);
+            ord.GetOrderBenchmarks(askID));
 
-        OpenDeal(askID, GetOrdersAmount());
+        OpenDeal(askID, ord.GetOrdersAmount());
     }
 
     // Deal functions
 
     function OpenDeal(uint _askID, uint _bidID) whenNotPaused public {
-        Order memory ask = orders[_askID];
-        Order memory bid = orders[_bidID];
-
-        require(ask.orderStatus == OrderStatus.ORDER_ACTIVE && bid.orderStatus == OrderStatus.ORDER_ACTIVE);
-        require((ask.counterparty == 0x0 || ask.counterparty == GetMaster(bid.author)) && (bid.counterparty == 0x0 || bid.counterparty == GetMaster(ask.author)));
-        require(ask.orderType == OrderType.ORDER_ASK);
-        require(bid.orderType == OrderType.ORDER_BID);
         require(
-            bl.Check(bid.blacklist, GetMaster(ask.author)) == false
-            && bl.Check(bid.blacklist, ask.author) == false
-            && bl.Check(bid.author, GetMaster(ask.author)) == false
-            && bl.Check(bid.author, ask.author) == false
-            && bl.Check(ask.blacklist, bid.author) == false
-            && bl.Check(GetMaster(ask.author), bid.author) == false
-            && bl.Check(ask.author, bid.author) == false);
-        require(ask.price <= bid.price);
-        require(ask.duration >= bid.duration);
+            ord.GetOrderStatus(_askID) == Orders.OrderStatus.ORDER_ACTIVE
+            && ord.GetOrderStatus(_bidID) == Orders.OrderStatus.ORDER_ACTIVE);
+        require(ord.GetOrderCounterparty(_askID) == 0x0 || ord.GetOrderCounterparty(_askID) == adm.GetMaster(ord.GetOrderAuthor(_bidID)));
+        require(ord.GetOrderCounterparty(_bidID) == 0x0 || ord.GetOrderCounterparty(_bidID) == adm.GetMaster(ord.GetOrderAuthor(_askID)));
+        require(ord.GetOrderType(_askID) == Orders.OrderType.ORDER_ASK);
+        require(ord.GetOrderType(_bidID) == Orders.OrderType.ORDER_BID);
+        require(!bl.Check(ord.GetOrderBlacklist(_bidID), adm.GetMaster(ord.GetOrderAuthor(_askID))));
+        require(!bl.Check(ord.GetOrderBlacklist(_bidID), ord.GetOrderAuthor(_askID)));
+        require(!bl.Check(ord.GetOrderAuthor(_bidID), adm.GetMaster(ord.GetOrderAuthor(_askID))));
+        require(!bl.Check(ord.GetOrderAuthor(_bidID), ord.GetOrderAuthor(_askID)));
+        require(!bl.Check(ord.GetOrderBlacklist(_askID), ord.GetOrderAuthor(_bidID)));
+        require(!bl.Check(adm.GetMaster(ord.GetOrderAuthor(_askID)), ord.GetOrderAuthor(_bidID)));
+        require(!bl.Check(ord.GetOrderAuthor(_askID), ord.GetOrderAuthor(_bidID)));
+        require(ord.GetOrderPrice(_askID) <= ord.GetOrderPrice(_bidID));
+        require(ord.GetOrderDuration(_askID) >= ord.GetOrderDuration(_bidID));
         // profile level check
-        require(pr.GetProfileLevel(bid.author) >= ask.identityLevel);
-        require(pr.GetProfileLevel(ask.author) >= bid.identityLevel);
+        require(pr.GetProfileLevel(ord.GetOrderAuthor(_bidID)) >= ord.GetOrderIdentityLevel(_askID));
+        require(pr.GetProfileLevel(adm.GetMaster(ord.GetOrderAuthor(_askID))) >= ord.GetOrderIdentityLevel(_bidID)); //bug
 
-        if (ask.netflags.length < netflagsQuantity) {
-            ask.netflags = ResizeNetflags(ask.netflags);
+        bool[] memory askNetflags = ord.GetOrderNetflags(_askID);
+        if (askNetflags.length < netflagsQuantity) {
+            askNetflags = ResizeNetflags(askNetflags);
         }
 
-        if (bid.netflags.length < netflagsQuantity) {
-            bid.netflags = ResizeNetflags(ask.netflags);
+        bool[] memory bidNetflags = ord.GetOrderNetflags(_bidID);
+        if (bidNetflags.length < netflagsQuantity) {
+            bidNetflags = ResizeNetflags(bidNetflags);
         }
 
-        for (uint i = 0; i < ask.netflags.length; i++) {
+        for (uint i = 0; i < netflagsQuantity; i++) {
             // implementation: when bid contains requirement, ask necessary needs to have this
             // if ask have this one - pass
-            require(!bid.netflags[i] || ask.netflags[i]);
+            require(!bidNetflags[i] || askNetflags[i]);
         }
 
-        if (ask.benchmarks.length < benchmarksQuantity) {
-            ask.benchmarks = ResizeBenchmarks(ask.benchmarks);
+        uint64[] memory askBenchmarks = ord.GetOrderBenchmarks(_askID);
+        if (askBenchmarks.length < benchmarksQuantity) {
+            askBenchmarks = ResizeBenchmarks(askBenchmarks);
         }
 
-        if (bid.benchmarks.length < benchmarksQuantity) {
-            bid.benchmarks = ResizeBenchmarks(bid.benchmarks);
+        uint64[] memory bidBenchmarks = ord.GetOrderBenchmarks(_bidID);
+        if (bidBenchmarks.length < benchmarksQuantity) {
+            bidBenchmarks = ResizeBenchmarks(bidBenchmarks);
         }
 
-        for (i = 0; i < ask.benchmarks.length; i++) {
-            require(ask.benchmarks[i] >= bid.benchmarks[i]);
+        for (i = 0; i < benchmarksQuantity; i++) {
+            require(askBenchmarks[i] >= bidBenchmarks[i]);
         }
 
-        dealAmount = dealAmount.add(1);
-        address master = GetMaster(ask.author);
-        orders[_askID].orderStatus = OrderStatus.ORDER_INACTIVE;
-        orders[_bidID].orderStatus = OrderStatus.ORDER_INACTIVE;
-        orders[_askID].dealID = dealAmount;
-        orders[_bidID].dealID = dealAmount;
+        ord.SetOrderStatus(_askID, Orders.OrderStatus.ORDER_INACTIVE);
+        ord.SetOrderStatus(_bidID, Orders.OrderStatus.ORDER_INACTIVE);
 
         emit OrderUpdated(_askID);
         emit OrderUpdated(_bidID);
 
-        uint startTime = block.timestamp;
-        uint endTime = 0;
-        // `0` - for spot deal
 
         // if deal is normal
-        if (ask.duration != 0) {
-            endTime = startTime.add(bid.duration);
+        if (ord.GetOrderDuration(_askID) != 0) {
+            uint endTime = block.timestamp.add(ord.GetOrderDuration(_bidID));
+        } else {
+            endTime = 0;
+            // `0` - for spot deal
         }
-        uint blockedBalance = bid.frozenSum;
-        deals[dealAmount] = Deal(ask.benchmarks, ask.author, bid.author, master, _askID, _bidID, bid.duration, ask.price, startTime, endTime, DealStatus.STATUS_ACCEPTED, blockedBalance, 0, block.timestamp);
-        emit DealOpened(dealAmount);
+
+        dl.IncreaseDealsAmount();
+
+        uint dealID = dl.GetDealsAmount();
+
+        dl.SetDealBenchmarks(dealID, askBenchmarks);
+        dl.SetDealConsumerID(dealID, ord.GetOrderAuthor(_bidID));
+        dl.SetDealSupplierID(dealID, ord.GetOrderAuthor(_askID));
+        dl.SetDealMasterID(dealID, adm.GetMaster(ord.GetOrderAuthor(_askID)));
+        dl.SetDealAskID(dealID, _askID);
+        dl.SetDealBidID(dealID, _bidID);
+        dl.SetDealDuration(dealID, ord.GetOrderDuration(_bidID));
+        dl.SetDealPrice(dealID, ord.GetOrderPrice(_askID));
+        dl.SetDealStartTime(dealID, block.timestamp);
+        dl.SetDealEndTime(dealID, endTime);
+        dl.SetDealStatus(dealID, Deals.DealStatus.STATUS_ACCEPTED);
+        dl.SetDealBlockedBalance(dealID, ord.GetOrderFrozenSum(_bidID));
+        dl.SetDealTotalPayout(dealID, 0);
+        dl.SetDealLastBillTS(dealID, block.timestamp);
+
+
+
+        emit DealOpened(dl.GetDealsAmount());
+
+        ord.SetOrderDealID(_askID, dealID);
+        ord.SetOrderDealID(_bidID, dealID);
     }
 
     function CloseDeal(uint dealID, BlacklistPerson blacklisted) public returns (bool){
-        require((deals[dealID].status == DealStatus.STATUS_ACCEPTED));
-        require(msg.sender == deals[dealID].supplierID || msg.sender == deals[dealID].consumerID || msg.sender == deals[dealID].masterID);
+        require((dl.GetDealStatus(dealID) == Deals.DealStatus.STATUS_ACCEPTED));
+        require(msg.sender == dl.GetDealSupplierID(dealID) || msg.sender == dl.GetDealConsumerID(dealID) || msg.sender == dl.GetDealMasterID(dealID));
 
-        if (block.timestamp <= deals[dealID].startTime.add(deals[dealID].duration)) {
+        if (block.timestamp <= dl.GetDealStartTime(dealID).add(dl.GetDealDuration(dealID))) {
             // after endTime
-            require(deals[dealID].consumerID == msg.sender);
+            require(dl.GetDealConsumerID(dealID) == msg.sender);
         }
         AddToBlacklist(dealID, blacklisted);
         InternalBill(dealID);
@@ -351,266 +321,127 @@ contract Market is Ownable, Pausable {
     }
 
     function CreateChangeRequest(uint dealID, uint newPrice, uint newDuration) public returns (uint changeRequestID) {
-        require(msg.sender == deals[dealID].consumerID || msg.sender == deals[dealID].masterID || msg.sender == deals[dealID].supplierID);
-        require(deals[dealID].status == DealStatus.STATUS_ACCEPTED);
 
-        if (IsSpot(dealID)) {
+        require(msg.sender == dl.GetDealConsumerID(dealID)
+            || msg.sender ==  dl.GetDealMasterID(dealID)
+            || msg.sender == dl.GetDealSupplierID(dealID));
+        require(dl.GetDealStatus(dealID) == Deals.DealStatus.STATUS_ACCEPTED);
+
+        if (dl.GetDealDuration(dealID) == 0) {
             require(newDuration == 0);
         }
 
-        requestsAmount = requestsAmount.add(1);
 
-        OrderType requestType;
+        Orders.OrderType requestType;
 
-        if (msg.sender == deals[dealID].consumerID) {
-            requestType = OrderType.ORDER_BID;
+        if (msg.sender == dl.GetDealConsumerID(dealID)) {
+            requestType = Orders.OrderType.ORDER_BID;
         } else {
-            requestType = OrderType.ORDER_ASK;
+            requestType = Orders.OrderType.ORDER_ASK;
         }
 
-        requests[requestsAmount] = ChangeRequest(dealID, requestType, newPrice, newDuration, RequestStatus.REQUEST_CREATED);
-        emit DealChangeRequestSet(requestsAmount);
+        uint currentID = cr.Write(dealID, requestType, newPrice, newDuration, ChangeRequests.RequestStatus.REQUEST_CREATED);
+        emit DealChangeRequestSet(currentID);
 
-        if (requestType == OrderType.ORDER_BID) {
-            emit DealChangeRequestUpdated(actualRequests[dealID][1]);
-            requests[actualRequests[dealID][1]].status = RequestStatus.REQUEST_CANCELED;
-            actualRequests[dealID][1] = requestsAmount;
-            ChangeRequest memory matchingRequest = requests[actualRequests[dealID][0]];
+        if (requestType == Orders.OrderType.ORDER_BID) {
+            uint oldID = cr.GetActualChangeRequest(dealID, 1);
+            uint matchingID = cr.GetActualChangeRequest(dealID, 0);
+            emit DealChangeRequestUpdated(oldID);
+            cr.SetChangeRequestStatus(oldID, ChangeRequests.RequestStatus.REQUEST_CANCELED);
+            cr.SetActualChangeRequest(dealID, 1, currentID);
 
-            if (newDuration == deals[dealID].duration && newPrice > deals[dealID].price) {
-                requests[requestsAmount].status = RequestStatus.REQUEST_ACCEPTED;
+            if (newDuration == dl.GetDealDuration(dealID) && newPrice > dl.GetDealPrice(dealID)) {
+                cr.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
                 Bill(dealID);
-                deals[dealID].price = newPrice;
-                actualRequests[dealID][1] = 0;
+                dl.SetDealPrice(dealID, newPrice);
+                cr.SetActualChangeRequest(dealID, 1, 0);
                 emit DealChangeRequestUpdated(requestsAmount);
-            } else if (matchingRequest.status == RequestStatus.REQUEST_CREATED && matchingRequest.duration >= newDuration && matchingRequest.price <= newPrice) {
-                requests[requestsAmount].status = RequestStatus.REQUEST_ACCEPTED;
-                requests[actualRequests[dealID][0]].status = RequestStatus.REQUEST_ACCEPTED;
-                emit DealChangeRequestUpdated(actualRequests[dealID][0]);
-                actualRequests[dealID][0] = 0;
-                actualRequests[dealID][1] = 0;
+            } else if (cr.GetChangeRequestStatus(matchingID) == ChangeRequests.RequestStatus.REQUEST_CREATED
+                    && cr.GetChangeRequestDuration(matchingID) >= newDuration
+                    && cr.GetChangeRequestPrice(matchingID) <= newPrice) {
+
+                cr.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+                cr.SetChangeRequestStatus(matchingID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+                emit DealChangeRequestUpdated(cr.GetActualChangeRequest(dealID, 0));
+                cr.SetActualChangeRequest(dealID, 0, 0);
+                cr.SetActualChangeRequest(dealID, 1, 0);
                 Bill(dealID);
-                deals[dealID].price = matchingRequest.price;
-                deals[dealID].duration = newDuration;
+                dl.SetDealPrice(dealID, cr.GetChangeRequestPrice(matchingID));
+                dl.SetDealDuration(dealID, newDuration);
                 emit DealChangeRequestUpdated(requestsAmount);
             } else {
-                return requestsAmount;
+                return currentID;
             }
-
-            requests[actualRequests[dealID][1]].status = RequestStatus.REQUEST_CANCELED;
-            emit DealChangeRequestUpdated(actualRequests[dealID][1]);
-            actualRequests[dealID][1] = requestsAmount;
+            cr.SetChangeRequestStatus(cr.GetActualChangeRequest(dealID, 1), ChangeRequests.RequestStatus.REQUEST_CANCELED);
+            emit DealChangeRequestUpdated(cr.GetActualChangeRequest(dealID, 1));
+            cr.SetActualChangeRequest(dealID, 1, cr.GetChangeRequestsAmount());
         }
 
-        if (requestType == OrderType.ORDER_ASK) {
-            emit DealChangeRequestUpdated(actualRequests[dealID][0]);
-            requests[actualRequests[dealID][0]].status = RequestStatus.REQUEST_CANCELED;
-            actualRequests[dealID][0] = requestsAmount;
-            matchingRequest = requests[actualRequests[dealID][1]];
+        if (requestType == Orders.OrderType.ORDER_ASK) {
+            matchingID = cr.GetActualChangeRequest(dealID, 1);
+            oldID = cr.GetActualChangeRequest(dealID, 0);
+            emit DealChangeRequestUpdated(oldID);
+            cr.SetChangeRequestStatus(oldID, ChangeRequests.RequestStatus.REQUEST_CANCELED);
+            cr.SetActualChangeRequest(dealID, 0, currentID);
+
 
-            if (newDuration == deals[dealID].duration && newPrice < deals[dealID].price) {
-                requests[requestsAmount].status = RequestStatus.REQUEST_ACCEPTED;
+            if (newDuration == dl.GetDealDuration(dealID) && newPrice < dl.GetDealPrice(dealID)) {
+                cr.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
                 Bill(dealID);
-                deals[dealID].price = newPrice;
-                actualRequests[dealID][0] = 0;
-                emit DealChangeRequestUpdated(requestsAmount);
-            } else if (matchingRequest.status == RequestStatus.REQUEST_CREATED && matchingRequest.duration <= newDuration && matchingRequest.price >= newPrice) {
-                requests[requestsAmount].status = RequestStatus.REQUEST_ACCEPTED;
-                emit DealChangeRequestUpdated(actualRequests[dealID][1]);
-                actualRequests[dealID][0] = 0;
-                actualRequests[dealID][1] = 0;
+                dl.SetDealPrice(dealID, newPrice);
+                cr.SetActualChangeRequest(dealID, 0, 0);
+                emit DealChangeRequestUpdated(currentID);
+            } else if (cr.GetChangeRequestStatus(matchingID) == ChangeRequests.RequestStatus.REQUEST_CREATED
+                && cr.GetChangeRequestDuration(matchingID) <= newDuration
+                && cr.GetChangeRequestPrice(matchingID) >= newPrice) {
+
+                cr.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+                cr.SetChangeRequestStatus(cr.GetActualChangeRequest(dealID, 1), ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+                emit DealChangeRequestUpdated(matchingID); //bug
+                cr.SetActualChangeRequest(dealID, 0, 0);
+                cr.SetActualChangeRequest(dealID, 1, 0);
                 Bill(dealID);
-                deals[dealID].price = newPrice;
-                deals[dealID].duration = matchingRequest.duration;
-                emit DealChangeRequestUpdated(requestsAmount);
+                dl.SetDealPrice(dealID, newPrice);
+                dl.SetDealDuration(dealID, cr.GetChangeRequestDuration(matchingID));
+                emit DealChangeRequestUpdated(currentID);
             } else {
-                return requestsAmount;
+                return currentID;
             }
         }
 
-        deals[dealID].endTime = deals[dealID].startTime.add(deals[dealID].duration);
-        return requestsAmount;
+        dl.SetDealEndTime(dealID, dl.GetDealStartTime(dealID).add(dl.GetDealEndTime(dealID)));
+        return currentID;
     }
 
     function CancelChangeRequest(uint changeRequestID) public returns (bool) {
-        ChangeRequest memory request = requests[changeRequestID];
-        require(msg.sender == deals[request.dealID].supplierID || msg.sender == deals[request.dealID].masterID || msg.sender == deals[request.dealID].consumerID);
-        require(request.status != RequestStatus.REQUEST_ACCEPTED);
+        uint dealID = cr.GetChangeRequestDealID(changeRequestID);
+        require(msg.sender == dl.GetDealSupplierID(dealID) || msg.sender == dl.GetDealMasterID(dealID) || msg.sender == dl.GetDealConsumerID(dealID));
+        require(cr.GetChangeRequestStatus(changeRequestID) != ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
 
-        if (request.requestType == OrderType.ORDER_ASK) {
-            if (msg.sender == deals[request.dealID].consumerID) {
-                requests[changeRequestID].status = RequestStatus.REQUEST_REJECTED;
+        if (cr.GetChangeRequestType(changeRequestID) == Orders.OrderType.ORDER_ASK) {
+            if (msg.sender == dl.GetDealConsumerID(dealID)) {
+                cr.SetChangeRequestStatus(changeRequestID, ChangeRequests.RequestStatus.REQUEST_REJECTED);
             } else {
-                requests[changeRequestID].status = RequestStatus.REQUEST_CANCELED;
+                cr.SetChangeRequestStatus(changeRequestID, ChangeRequests.RequestStatus.REQUEST_CANCELED);
             }
-            actualRequests[request.dealID][0] = 0;
+            cr.SetActualChangeRequest(dealID, 0, 0);
             emit DealChangeRequestUpdated(changeRequestID);
         }
 
-        if (request.requestType == OrderType.ORDER_BID) {
-            if (msg.sender == deals[request.dealID].consumerID) {
-                requests[changeRequestID].status = RequestStatus.REQUEST_CANCELED;
+        if (cr.GetChangeRequestType(changeRequestID) == Orders.OrderType.ORDER_BID) {
+            if (msg.sender == dl.GetDealConsumerID(dealID)) {
+                cr.SetChangeRequestStatus(changeRequestID, ChangeRequests.RequestStatus.REQUEST_CANCELED);
             } else {
-                requests[changeRequestID].status = RequestStatus.REQUEST_REJECTED;
+                cr.SetChangeRequestStatus(changeRequestID, ChangeRequests.RequestStatus.REQUEST_REJECTED);
             }
-            actualRequests[request.dealID][1] = 0;
+            cr.SetActualChangeRequest(dealID, 1, 0);
             emit DealChangeRequestUpdated(changeRequestID);
         }
         return true;
     }
 
-    // Master-worker functions
-
-    function RegisterWorker(address _master) public whenNotPaused returns (bool) {
-        require(GetMaster(msg.sender) == msg.sender);
-        require(isMaster[msg.sender] == false);
-        require(GetMaster(_master) == _master);
-        masterRequest[_master][msg.sender] = true;
-        emit WorkerAnnounced(msg.sender, _master);
-        return true;
-    }
-
-    function ConfirmWorker(address _worker) public whenNotPaused returns (bool) {
-        require(masterRequest[msg.sender][_worker] == true);
-        masterOf[_worker] = msg.sender;
-        isMaster[msg.sender] = true;
-        delete masterRequest[msg.sender][_worker];
-        emit WorkerConfirmed(_worker, msg.sender);
-        return true;
-    }
-
-    function RemoveWorker(address _worker, address _master) public whenNotPaused returns (bool) {
-        require(GetMaster(_worker) == _master && (msg.sender == _worker || msg.sender == _master));
-        delete masterOf[_worker];
-        emit WorkerRemoved(_worker, _master);
-        return true;
-    }
-
     // GETTERS
 
-    function GetOrderInfo(uint orderID) view public
-    returns (
-        OrderType orderType,
-        address author,
-        address counterparty,
-        uint duration,
-        uint price,
-        bool[] netflags,
-        ProfileRegistry.IdentityLevel identityLevel,
-        address blacklist,
-        bytes32 tag,
-        uint64[] benchmarks,
-        uint frozenSum
-    ){
-        Order memory order = orders[orderID];
-        return (
-        order.orderType,
-        order.author,
-        order.counterparty,
-        order.duration,
-        order.price,
-        order.netflags,
-        order.identityLevel,
-        order.blacklist,
-        order.tag,
-        order.benchmarks,
-        order.frozenSum
-        );
-    }
-
-
-    function GetOrderParams(uint orderID) view public
-    returns (
-        OrderStatus orderStatus,
-        uint dealID
-    ){
-        Order memory order = orders[orderID];
-        return (
-        order.orderStatus,
-        order.dealID
-        );
-    }
-
-    function GetDealInfo(uint dealID) view public
-    returns (
-        uint64[] benchmarks,
-        address supplierID,
-        address consumerID,
-        address masterID,
-        uint askID,
-        uint bidID,
-        uint startTime
-    ){
-        return (
-        deals[dealID].benchmarks,
-        deals[dealID].supplierID,
-        deals[dealID].consumerID,
-        deals[dealID].masterID,
-        deals[dealID].askID,
-        deals[dealID].bidID,
-        deals[dealID].startTime
-
-        );
-    }
-
-    function GetDealParams(uint dealID) view public
-    returns (
-        uint duration,
-        uint price,
-        uint endTime,
-        DealStatus status,
-        uint blockedBalance,
-        uint totalPayout,
-        uint lastBillTS
-    ){
-        return (
-        deals[dealID].duration,
-        deals[dealID].price,
-        deals[dealID].endTime,
-        deals[dealID].status,
-        deals[dealID].blockedBalance,
-        deals[dealID].totalPayout,
-        deals[dealID].lastBillTS
-        );
-    }
-
-    function GetMaster(address _worker) view public returns (address master) {
-        if (masterOf[_worker] == 0x0 || masterOf[_worker] == _worker) {
-            master = _worker;
-        } else {
-            master = masterOf[_worker];
-        }
-    }
-
-    function GetChangeRequestInfo(uint changeRequestID) view public
-    returns (
-        uint dealID,
-        OrderType requestType,
-        uint price,
-        uint duration,
-        RequestStatus status
-    ){
-        return (
-        requests[changeRequestID].dealID,
-        requests[changeRequestID].requestType,
-        requests[changeRequestID].price,
-        requests[changeRequestID].duration,
-        requests[changeRequestID].status
-        );
-    }
-
-    function GetDealsAmount() public view returns (uint){
-        return dealAmount;
-    }
-
-    function GetOrdersAmount() public view returns (uint){
-        return ordersAmount;
-    }
-
-    function GetChangeRequestsAmount() public view returns (uint){
-        return requestsAmount;
-    }
-
     function GetBenchmarksQuantity() public view returns (uint) {
         return benchmarksQuantity;
     }
@@ -623,72 +454,79 @@ contract Market is Ownable, Pausable {
     // INTERNAL
 
     function InternalBill(uint dealID) internal returns (bool){
-        require(deals[dealID].status == DealStatus.STATUS_ACCEPTED);
-        require(msg.sender == deals[dealID].supplierID || msg.sender == deals[dealID].consumerID || msg.sender == deals[dealID].masterID);
-        Deal memory deal = deals[dealID];
 
+        require(dl.GetDealStatus(dealID) == Deals.DealStatus.STATUS_ACCEPTED);
+        require(msg.sender == dl.GetDealSupplierID(dealID) ||
+            msg.sender == dl.GetDealConsumerID(dealID) ||
+            msg.sender == dl.GetDealMasterID(dealID));
         uint paidAmount;
 
-        if (!IsSpot(dealID) && deal.lastBillTS >= deal.endTime) {
+        if (dl.GetDealDuration(dealID) != 0 && dl.GetDealLastBillTS(dealID) >= dl.GetDealEndTime(dealID)) {
             // means we already billed deal after endTime
             return true;
-        } else if (!IsSpot(dealID) && block.timestamp > deal.endTime && deal.lastBillTS < deal.endTime) {
-            paidAmount = CalculatePayment(deal.price, deal.endTime.sub(deal.lastBillTS));
+        } else if (dl.GetDealDuration(dealID) != 0
+            && block.timestamp > dl.GetDealEndTime(dealID)
+            && dl.GetDealLastBillTS(dealID) < dl.GetDealEndTime(dealID)) {
+            paidAmount = CalculatePayment(dl.GetDealPrice(dealID), dl.GetDealEndTime(dealID).sub(dl.GetDealLastBillTS(dealID)));
         } else {
-            paidAmount = CalculatePayment(deal.price, block.timestamp.sub(deal.lastBillTS));
+            paidAmount = CalculatePayment(dl.GetDealPrice(dealID), block.timestamp.sub(dl.GetDealLastBillTS(dealID)));
         }
 
-        if (paidAmount > deal.blockedBalance) {
-            if (token.balanceOf(deal.consumerID) >= paidAmount.sub(deal.blockedBalance)) {
-                require(token.transferFrom(deal.consumerID, this, paidAmount.sub(deal.blockedBalance)));
-                deals[dealID].blockedBalance = deals[dealID].blockedBalance.add(paidAmount.sub(deal.blockedBalance));
+        if (paidAmount > dl.GetDealBlockedBalance(dealID)) {
+            if (token.balanceOf(dl.GetDealConsumerID(dealID)) >= paidAmount.sub(dl.GetDealBlockedBalance(dealID))) {
+                require(token.transferFrom(dl.GetDealConsumerID(dealID), this, paidAmount.sub(dl.GetDealBlockedBalance(dealID))));
+                dl.SetDealBlockedBalance(dealID, dl.GetDealBlockedBalance(dealID).add(paidAmount.sub(dl.GetDealBlockedBalance(dealID))));
             } else {
-                emit Billed(dealID, deals[dealID].blockedBalance);
+                emit Billed(dealID, dl.GetDealBlockedBalance(dealID));
                 InternalCloseDeal(dealID);
-                require(token.transfer(deal.masterID, deal.blockedBalance));
-                deals[dealID].lastBillTS = block.timestamp;
-                deals[dealID].totalPayout = deals[dealID].totalPayout.add(deal.blockedBalance);
-                deals[dealID].blockedBalance = 0;
+                require(token.transfer(dl.GetDealMasterID(dealID), dl.GetDealBlockedBalance(dealID)));
+                dl.SetDealTotalPayout(dealID, dl.GetDealTotalPayout(dealID).add(dl.GetDealBlockedBalance(dealID)));
+                dl.SetDealBlockedBalance(dealID, 0);
+                dl.SetDealEndTime(dealID, block.timestamp);
                 return true;
             }
         }
-        require(token.transfer(deal.masterID, paidAmount));
-        deals[dealID].blockedBalance = deals[dealID].blockedBalance.sub(paidAmount);
-        deals[dealID].totalPayout = deals[dealID].totalPayout.add(paidAmount);
-        deals[dealID].lastBillTS = block.timestamp;
+
+        require(token.transfer(dl.GetDealMasterID(dealID), paidAmount));
+        dl.SetDealBlockedBalance(dealID, dl.GetDealBlockedBalance(dealID).sub(paidAmount));
+        dl.SetDealTotalPayout(dealID, dl.GetDealTotalPayout(dealID).add(paidAmount));
+        dl.SetDealLastBillTS(dealID, block.timestamp);
         emit Billed(dealID, paidAmount);
         return true;
     }
 
     function ReserveNextPeriodFunds(uint dealID) internal returns (bool) {
         uint nextPeriod;
-        Deal memory deal = deals[dealID];
+        ( , address supplierID, address consumerID , , , , ) = dl.GetDealInfo(dealID);
+
+        (uint duration, uint price, uint endTime, Deals.DealStatus status, uint blockedBalance, , ) = dl.GetDealParams(dealID);
 
-        if (IsSpot(dealID)) {
-            if (deal.status == DealStatus.STATUS_CLOSED) {
+        if (duration == 0) {
+            if (status == Deals.DealStatus.STATUS_CLOSED) {
                 return true;
             }
             nextPeriod = 1 hours;
         } else {
-            if (block.timestamp > deal.endTime) {
+            if (block.timestamp > endTime) {
                 // we don't reserve funds for next period
                 return true;
             }
-            if (deal.endTime.sub(block.timestamp) < 1 days) {
-                nextPeriod = deal.endTime.sub(block.timestamp);
+            if (endTime.sub(block.timestamp) < 1 days) {
+                nextPeriod = endTime.sub(block.timestamp);
             } else {
                 nextPeriod = 1 days;
             }
         }
 
-        if (CalculatePayment(deal.price, nextPeriod) > deals[dealID].blockedBalance) {
-            uint nextPeriodSum = CalculatePayment(deal.price, nextPeriod).sub(deals[dealID].blockedBalance);
+        if (CalculatePayment(price, nextPeriod) > blockedBalance) {
+            uint nextPeriodSum = CalculatePayment(price, nextPeriod).sub(blockedBalance);
 
-            if (token.balanceOf(deal.consumerID) >= nextPeriodSum) {
-                require(token.transferFrom(deal.consumerID, this, nextPeriodSum));
-                deals[dealID].blockedBalance = deals[dealID].blockedBalance.add(nextPeriodSum);
+            if (token.balanceOf(consumerID) >= nextPeriodSum) {
+                require(token.transferFrom(consumerID, this, nextPeriodSum));
+                dl.SetDealBlockedBalance(dealID, blockedBalance.add(nextPeriodSum));
             } else {
-                emit Billed(dealID, deals[dealID].blockedBalance);
+              // ?????
+                emit Billed(dealID, blockedBalance);
                 InternalCloseDeal(dealID);
                 RefundRemainingFunds(dealID);
                 return true;
@@ -697,17 +535,19 @@ contract Market is Ownable, Pausable {
         return true;
     }
 
-    function RefundRemainingFunds(uint dealID) internal returns (bool){
-        if (deals[dealID].blockedBalance != 0) {
-            token.transfer(deals[dealID].consumerID, deals[dealID].blockedBalance);
-            deals[dealID].blockedBalance = 0;
+    function RefundRemainingFunds(uint dealID) internal returns (bool) {
+        ( , , address consumerID , , , , ) = dl.GetDealInfo(dealID);
+
+        (, , , , uint blockedBalance, , ) = dl.GetDealParams(dealID);
+
+        if (blockedBalance != 0) {
+            token.transfer(consumerID, blockedBalance);
+            dl.SetDealBlockedBalance(dealID, 0);
         }
         return true;
     }
 
-    function IsSpot(uint dealID) internal view returns (bool){
-        return deals[dealID].duration == 0;
-    }
+
 
     function CalculatePayment(uint _price, uint _period) internal view returns (uint) {
         uint rate = oracle.getCurrentPrice();
@@ -715,23 +555,29 @@ contract Market is Ownable, Pausable {
     }
 
     function AddToBlacklist(uint dealID, BlacklistPerson role) internal {
+        (, address supplierID, address consumerID, address masterID, , , ) = dl.GetDealInfo(dealID);
+
         // only consumer can blacklist
-        require(msg.sender == deals[dealID].consumerID || role == BlacklistPerson.BLACKLIST_NOBODY);
+        require(msg.sender == consumerID || role == BlacklistPerson.BLACKLIST_NOBODY);
         if (role == BlacklistPerson.BLACKLIST_WORKER) {
-            bl.Add(deals[dealID].consumerID, deals[dealID].supplierID);
+            bl.Add(consumerID, supplierID);
         } else if (role == BlacklistPerson.BLACKLIST_MASTER) {
-            bl.Add(deals[dealID].consumerID, deals[dealID].masterID);
+            bl.Add(consumerID, masterID);
         }
     }
 
     function InternalCloseDeal(uint dealID) internal {
-        if (deals[dealID].status == DealStatus.STATUS_CLOSED) {
+        ( , address supplierID, address consumerID, address masterID, , , ) = dl.GetDealInfo(dealID);
+
+        ( , , , Deals.DealStatus status, , , ) = dl.GetDealParams(dealID);
+
+        if (status == Deals.DealStatus.STATUS_CLOSED) {
             return;
         }
-        require((deals[dealID].status == DealStatus.STATUS_ACCEPTED));
-        require(msg.sender == deals[dealID].consumerID || msg.sender == deals[dealID].supplierID || msg.sender == deals[dealID].masterID);
-        deals[dealID].status = DealStatus.STATUS_CLOSED;
-        deals[dealID].endTime = block.timestamp;
+        require((status == Deals.DealStatus.STATUS_ACCEPTED));
+        require(msg.sender == consumerID || msg.sender == supplierID || msg.sender == masterID);
+        dl.SetDealStatus(dealID, Deals.DealStatus.STATUS_CLOSED);
+        dl.SetDealEndTime(dealID, block.timestamp);
         emit DealUpdated(dealID);
     }
 
@@ -769,6 +615,16 @@ contract Market is Ownable, Pausable {
         return true;
     }
 
+    function SetDealsAddress(address _newDeals) public onlyOwner returns (bool) {
+        dl = Deals(_newDeals);
+        return true;
+    }
+
+    function SetOrdersAddress(address _newOrders) public onlyOwner returns (bool) {
+        ord = Orders(_newOrders);
+        return  true;
+    }
+
     function SetBenchmarksQuantity(uint _newQuantity) onlyOwner public returns (bool) {
         require(_newQuantity > benchmarksQuantity);
         emit NumBenchmarksUpdated(_newQuantity);
diff --git a/blockchain/source/contracts/Orders.sol b/blockchain/source/contracts/Orders.sol
new file mode 100644
index 000000000..90633e87c
--- /dev/null
+++ b/blockchain/source/contracts/Orders.sol
@@ -0,0 +1,202 @@
+pragma solidity ^0.4.23;
+
+import "zeppelin-solidity/contracts/ownership/Ownable.sol";
+import "./ProfileRegistry.sol";
+
+contract Orders is Ownable {
+    //events
+
+    //enums
+
+    enum OrderStatus {
+        UNKNOWN,
+        ORDER_INACTIVE,
+        ORDER_ACTIVE
+    }
+
+    enum OrderType {
+        ORDER_UNKNOWN,
+        ORDER_BID,
+        ORDER_ASK
+    }
+
+    //DATA
+    struct Order {
+        OrderInfo info;
+        OrderParams params;
+    }
+
+    struct OrderInfo {
+        OrderType orderType;
+        address author;
+        address counterparty;
+        uint duration;
+        uint price;
+        bool[] netflags;
+        ProfileRegistry.IdentityLevel identityLevel;
+        address blacklist;
+        bytes32 tag;
+        uint64[] benchmarks;
+        uint frozenSum;
+    }
+
+    struct OrderParams {
+        OrderStatus orderStatus;
+        uint dealID;
+    }
+
+    mapping(uint => Order) public orders;
+
+    uint ordersAmount = 0;
+
+    //Constructor
+
+    constructor() public {
+        owner = msg.sender;
+    }
+
+    function Write(OrderType _orderType,
+        OrderStatus _orderStatus,
+        address _author,
+        address _counterparty,
+        uint _duration,
+        uint256 _price,
+        bool[] _netflags,
+        ProfileRegistry.IdentityLevel _identityLevel,
+        address _blacklist,
+        bytes32 _tag,
+        uint64[] _benchmarks,
+        uint _frozenSum,
+        uint _dealID) public onlyOwner  returns(uint) {
+
+        ordersAmount += 1;
+
+        orders[ordersAmount].info.orderType = _orderType;
+        orders[ordersAmount].info.author = _author;
+        orders[ordersAmount].info.counterparty = _counterparty;
+        orders[ordersAmount].info.duration = _duration;
+        orders[ordersAmount].info.price = _price;
+        orders[ordersAmount].info.netflags = _netflags;
+        orders[ordersAmount].info.identityLevel = _identityLevel;
+        orders[ordersAmount].info.blacklist = _blacklist;
+        orders[ordersAmount].info.tag = _tag;
+        orders[ordersAmount].info.benchmarks = _benchmarks;
+        orders[ordersAmount].info.frozenSum = _frozenSum;
+        orders[ordersAmount].params.orderStatus = _orderStatus;
+        orders[ordersAmount].params.dealID = _dealID;
+
+        return ordersAmount;
+    }
+
+    function SetOrderStatus(uint orderID, OrderStatus _status) public onlyOwner {
+        orders[orderID].params.orderStatus = _status;
+    }
+
+    function SetOrderDealID(uint orderID, uint _dealID) public onlyOwner {
+        orders[orderID].params.dealID = _dealID;
+    }
+
+    function SetOrderBenchmarks(uint orderID, uint64[] _benchmarks) public onlyOwner {
+        orders[orderID].info.benchmarks = _benchmarks;
+    }
+
+    function SetOrderNetflags(uint orderID, bool[] _netflags) public onlyOwner {
+        orders[orderID].info.netflags = _netflags;
+    }
+    function GetOrdersAmount() public view returns (uint) {
+        return ordersAmount;
+    }
+
+    function GetOrderInfo(uint orderID) view public
+    returns (
+        OrderType orderType,
+        address author,
+        address counterparty,
+        uint duration,
+        uint price,
+        bool[] netflags,
+        ProfileRegistry.IdentityLevel identityLevel,
+        address blacklist,
+        bytes32 tag,
+        uint64[] benchmarks,
+        uint frozenSum
+    ){
+        OrderInfo memory info = orders[orderID].info;
+        return (
+        info.orderType,
+        info.author,
+        info.counterparty,
+        info.duration,
+        info.price,
+        info.netflags,
+        info.identityLevel,
+        info.blacklist,
+        info.tag,
+        info.benchmarks,
+        info.frozenSum
+        );
+    }
+    function GetOrderType(uint orderID) view public returns (OrderType) {
+        return orders[orderID].info.orderType;
+    }
+
+    function GetOrderAuthor(uint orderID) view public returns (address) {
+        return orders[orderID].info.author;
+    }
+
+    function GetOrderCounterparty(uint orderID) view public returns (address) {
+        return orders[orderID].info.counterparty;
+    }
+
+    function GetOrderDuration(uint orderID) view public returns (uint) {
+        return orders[orderID].info.duration;
+    }
+
+    function GetOrderPrice(uint orderID) view public returns (uint) {
+        return orders[orderID].info.price;
+    }
+
+    function GetOrderNetflags(uint orderID) view public returns (bool[]) {
+        return orders[orderID].info.netflags;
+    }
+
+    function GetOrderIdentityLevel(uint orderID) view public returns (ProfileRegistry.IdentityLevel) {
+        return orders[orderID].info.identityLevel;
+    }
+
+    function GetOrderBlacklist(uint orderID) view public returns (address) {
+        return orders[orderID].info.blacklist;
+    }
+
+    function GetOrderTag(uint orderID) view public returns (bytes32) {
+        return orders[orderID].info.tag;
+    }
+
+    function GetOrderBenchmarks(uint orderID) view public returns (uint64[]) {
+        return orders[orderID].info.benchmarks;
+    }
+    function GetOrderFrozenSum(uint orderID) view public returns (uint) {
+        return orders[orderID].info.frozenSum;
+    }
+
+
+    function GetOrderParams(uint orderID) view public
+    returns (
+        OrderStatus orderStatus,
+        uint dealID
+    ){
+        OrderParams memory params = orders[orderID].params;
+        return (
+        params.orderStatus,
+        params.dealID
+        );
+    }
+
+    function GetOrderStatus(uint orderID) view public returns (OrderStatus) {
+        return orders[orderID].params.orderStatus;
+    }
+
+    function GetOrderDealID(uint orderID) view public returns (uint) {
+        return orders[orderID].params.dealID;
+    }
+}
diff --git a/blockchain/source/migrations/6_set_market_for_blacklist.js b/blockchain/source/migrations/10_set_market_for_blacklist.js
similarity index 70%
rename from blockchain/source/migrations/6_set_market_for_blacklist.js
rename to blockchain/source/migrations/10_set_market_for_blacklist.js
index d0fa1e84e..ad1796a4b 100644
--- a/blockchain/source/migrations/6_set_market_for_blacklist.js
+++ b/blockchain/source/migrations/10_set_market_for_blacklist.js
@@ -3,13 +3,13 @@ let Blacklist = artifacts.require('./Blacklist.sol');
 
 module.exports = function (deployer, network) {
     if (network === 'private') {
-        Blacklist.deployed()
-            .then(function (blacklist) {
-                blacklist.SetMarketAddress(Market.address, { gasPrice: 0 });
-            })
-            .catch(function (err) {
-                console.log(err);
-            });
+        // Blacklist.deployed()
+        //     .then(function (blacklist) {
+        //         blacklist.SetMarketAddress(Market.address, { gasPrice: 0 });
+        //     })
+        //     .catch(function (err) {
+        //         console.log(err);
+        //     });
     } else if (network === 'master') {
         // blacklist haven't reason to deploy to mainnet
     } else if (network === 'rinkeby') {
diff --git a/blockchain/source/migrations/1_deploy_token.js b/blockchain/source/migrations/1_deploy_token.js
index 075ee1721..b0915703e 100644
--- a/blockchain/source/migrations/1_deploy_token.js
+++ b/blockchain/source/migrations/1_deploy_token.js
@@ -3,9 +3,9 @@ let TestnetFaucet = artifacts.require('./TestnetFaucet.sol');
 
 module.exports = function (deployer, network) {
     if ((network === 'private') || (network === 'privateLive')) {
-        deployer.deploy(SNM, { gasPrice: 0 });
+        //deployer.deploy(SNM, { gasPrice: 0 });
     } else if (network === 'rinkeby') {
-        deployer.deploy(TestnetFaucet);
+        //deployer.deploy(TestnetFaucet);
     } else if (network === 'master') {
         // token already deployed at master to address 0x983f6d60db79ea8ca4eb9968c6aff8cfa04b3c63
     } else {
diff --git a/blockchain/source/migrations/2_deploy_oracle.js b/blockchain/source/migrations/2_deploy_oracle.js
index 26f474e06..920d407cc 100644
--- a/blockchain/source/migrations/2_deploy_oracle.js
+++ b/blockchain/source/migrations/2_deploy_oracle.js
@@ -2,7 +2,7 @@ let OracleUSD = artifacts.require('./OracleUSD.sol');
 
 module.exports = function (deployer, network) {
     if ((network === 'private') || (network === 'privateLive')) {
-        deployer.deploy(OracleUSD, { gasPrice: 0 });
+        //deployer.deploy(OracleUSD, { gasPrice: 0 });
     } else if (network === 'master') {
         // oracle haven't reason to deploy to mainnet
     } else if (network === 'rinkeby') {
diff --git a/blockchain/source/migrations/3_deploy_profileRegistry.js b/blockchain/source/migrations/3_deploy_profileRegistry.js
index eba35e58c..72ff845d1 100644
--- a/blockchain/source/migrations/3_deploy_profileRegistry.js
+++ b/blockchain/source/migrations/3_deploy_profileRegistry.js
@@ -2,7 +2,7 @@ let ProfileRegistry = artifacts.require('./ProfileRegistry.sol');
 
 module.exports = function (deployer, network) {
     if ((network === 'private') || (network === 'privateLive')) {
-        deployer.deploy(ProfileRegistry, { gasPrice: 0 });
+        //deployer.deploy(ProfileRegistry, { gasPrice: 0 });
     } else if (network === 'master') {
         // we do not deploy ProfileRegistry at master anytime
     } else if (network === 'rinkeby') {
diff --git a/blockchain/source/migrations/4_deploy_blacklist.js b/blockchain/source/migrations/4_deploy_blacklist.js
index 3a06abecc..719a9d9a8 100644
--- a/blockchain/source/migrations/4_deploy_blacklist.js
+++ b/blockchain/source/migrations/4_deploy_blacklist.js
@@ -2,7 +2,7 @@ let Blacklist = artifacts.require('./Blacklist.sol');
 
 module.exports = function (deployer, network) {
     if ((network === 'private') || (network === 'privateLive')) {
-        deployer.deploy(Blacklist, { gasPrice: 0 });
+        //deployer.deploy(Blacklist, { gasPrice: 0 });
     } else if (network === 'master') {
         // blacklist haven't reason to deploy to mainnet
     } else if (network === 'rinkeby') {
diff --git a/blockchain/source/migrations/5_deploy_market.js b/blockchain/source/migrations/5_deploy_market.js
deleted file mode 100644
index f576c58e2..000000000
--- a/blockchain/source/migrations/5_deploy_market.js
+++ /dev/null
@@ -1,24 +0,0 @@
-let SNM = artifacts.require('./SNM.sol');
-let Market = artifacts.require('./Market.sol');
-let Blacklist = artifacts.require('./Blacklist.sol');
-let OracleUSD = artifacts.require('./OracleUSD.sol');
-let ProfileRegistry = artifacts.require('./ProfileRegistry.sol');
-
-module.exports = function (deployer, network) {
-    if ((network === 'private') || (network === 'privateLive')) {
-        deployer.deploy(Market,
-            SNM.address, // token address
-            Blacklist.address, // Blacklist address
-            OracleUSD.address, // Oracle address
-            ProfileRegistry.address, // ProfileRegistry address
-            12, // benchmarks quantity
-            3, // netflags quantity
-            { gasPrice: 0 });
-    } else if (network === 'master') {
-        // market haven't reason to deploy to mainnet
-    } else if (network === 'rinkeby') {
-        // market haven't reason to deploy to rinkeby
-    } else {
-        deployer.deploy(Market, SNM.address, Blacklist.address, OracleUSD.address, ProfileRegistry.address, 12, 3);
-    }
-};
diff --git a/blockchain/source/migrations/7_deploy_crud.js b/blockchain/source/migrations/7_deploy_crud.js
new file mode 100644
index 000000000..2bf871966
--- /dev/null
+++ b/blockchain/source/migrations/7_deploy_crud.js
@@ -0,0 +1,19 @@
+let Orders = artifacts.require('./Orders.sol');
+let Deals = artifacts.require('./Deals.sol');
+let ChangeRequests = artifacts.require('./ChangeRequests.sol');
+
+module.exports = function (deployer, network) {
+  deployer.then(async () => {
+    if ((network === 'private') || (network === 'privateLive')) {
+        //await deployer.deploy(Blacklist, { gasPrice: 0 });
+    } else if (network === 'master') {
+        // will filled later
+    } else if (network === 'rinkeby') {
+        // later
+    } else {
+        await deployer.deploy(Orders, {gasLimit: 20000000});
+        await deployer.deploy(Deals, {gasLimit: 20000000});
+        await deployer.deploy(ChangeRequests, {gasLimit: 20000000})
+    }
+  });
+};
diff --git a/blockchain/source/migrations/8_deploy_administratum.js b/blockchain/source/migrations/8_deploy_administratum.js
new file mode 100644
index 000000000..251363d0b
--- /dev/null
+++ b/blockchain/source/migrations/8_deploy_administratum.js
@@ -0,0 +1,13 @@
+let Administratum = artifacts.require('./Administratum.sol');
+
+module.exports = function (deployer, network) {
+    if ((network === 'private') || (network === 'privateLive')) {
+        deployer.deploy(Administratum, { gasPrice: 0 });
+    } else if (network === 'master') {
+        // will filled later
+    } else if (network === 'rinkeby') {
+        // later
+    } else {
+        deployer.deploy(Administratum);
+    }
+};
diff --git a/blockchain/source/migrations/9_deploy_market.js b/blockchain/source/migrations/9_deploy_market.js
new file mode 100644
index 000000000..7f6fc05cb
--- /dev/null
+++ b/blockchain/source/migrations/9_deploy_market.js
@@ -0,0 +1,37 @@
+let SNM = artifacts.require('./SNM.sol');
+let Market = artifacts.require('./Market.sol');
+let Blacklist = artifacts.require('./Blacklist.sol');
+let OracleUSD = artifacts.require('./OracleUSD.sol');
+let ProfileRegistry = artifacts.require('./ProfileRegistry.sol');
+let Administratum = artifacts.require('./Administratum.sol');
+let Orders = artifacts.require('./Orders.sol');
+let Deals = artifacts.require('./Deals.sol');
+let ChangeRequests = artifacts.require('./ChangeRequests.sol');
+
+module.exports = function (deployer, network) {
+    deployer.then(async () => {
+      if ((network === 'private') || (network === 'privateLive')) {
+          // await deployer.deploy(Market,
+          //       SNM.address, // token address
+          //       Blacklist.address, // Blacklist address
+          //       OracleUSD.address, // Oracle address
+          //       ProfileRegistry.address, // ProfileRegistry address
+          //       Administratum.address,
+          //       Orders.address,
+          //       Deals.address,
+          //       ChangeRequests.address,
+          //       12, // benchmarks quantity
+          //       3, // netflags quantity
+          //       { gasPrice: 0 });
+          await deployer.deploy(Market, '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', 12, 3, {gasLimit: 99000000, gasPrice: 0});
+      } else if (network === 'master') {
+          // market haven't reason to deploy to mainnet
+      } else if (network === 'rinkeby') {
+          // market haven't reason to deploy to rinkeby
+          //await deployer.deploy(Market, '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', 12, 3, {gasLimit: 100000000, gasPrice: 1000000};
+      } else {
+        await deployer.deploy(Market, SNM.address, Blacklist.address, OracleUSD.address, ProfileRegistry.address, Administratum.address, Orders.address, Deals.address, ChangeRequests.address, 12, 3, {gasLimit: 1000000000});
+        //await deployer.deploy(Market, '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', 12, 3, {gasLimit: 15000000, gasPrice: 1})
+      }
+   });
+};
diff --git a/blockchain/source/test/blacklist.js b/blockchain/source/test/blacklist.js
index 6dd85f57f..4958c5c8b 100644
--- a/blockchain/source/test/blacklist.js
+++ b/blockchain/source/test/blacklist.js
@@ -5,6 +5,10 @@ const Blacklist = artifacts.require('./Blacklist.sol');
 const SNM = artifacts.require('./SNM.sol');
 const OracleUSD = artifacts.require('./OracleUSD.sol');
 const ProfileRegistry = artifacts.require('./ProfileRegistry.sol');
+const Orders = artifacts.require('./Orders.sol');
+const Deals = artifacts.require('./Deals.sol');
+const ChangeRequests = artifacts.require('./ChangeRequests.sol');
+const Administratum = artifacts.require('./Administratum.sol');
 
 contract('Blacklist', async function (accounts) {
     let market;
@@ -26,7 +30,21 @@ contract('Blacklist', async function (accounts) {
         oracle = await OracleUSD.new();
         pr = await ProfileRegistry.new();
         await blacklist.AddMaster(master, { from: owner });
-        market = await Market.new(token.address, blacklist.address, oracle.address, pr.address, 12, 3);
+        orders = await Orders.new();
+        deals = await Deals.new();
+        changeRequests = await ChangeRequests.new();
+
+        market = await Market.new(token.address,
+            blacklist.address,
+            oracle.address,
+            pr.address,
+            administratum.address,
+            orders.address,
+            deals.address,
+            changeRequests.address,
+            12,
+            3,
+            {gasLimit: 30000000});
     });
 
     it('test ACL', async function () {
diff --git a/blockchain/source/test/market.js b/blockchain/source/test/market.js
index 66853503e..06d9c786f 100644
--- a/blockchain/source/test/market.js
+++ b/blockchain/source/test/market.js
@@ -31,6 +31,10 @@ const Market = artifacts.require('./Market.sol');
 const OracleUSD = artifacts.require('./OracleUSD.sol');
 const Blacklist = artifacts.require('./Blacklist.sol');
 const ProfileRegistry = artifacts.require('./ProfileRegistry.sol');
+const Orders = artifacts.require('./Orders.sol');
+const Deals = artifacts.require('./Deals.sol');
+const ChangeRequests = artifacts.require('./ChangeRequests.sol');
+const Administratum = artifacts.require('./Administratum.sol');
 
 const ONE_MILLION_TOKEN = 1e6 * 1e18;
 
@@ -57,14 +61,29 @@ contract('Market', async (accounts) => {
         await oracle.setCurrentPrice(oraclePrice);
         blacklist = await Blacklist.new();
         profileRegistry = await ProfileRegistry.new();
+        administratum = await Administratum.new();
+        orders = await Orders.new();
+        deals = await Deals.new();
+        changeRequests = await ChangeRequests.new();
         market = await Market.new(
             token.address,
             blacklist.address,
             oracle.address,
             profileRegistry.address,
+            administratum.address,
+            orders.address,
+            deals.address,
+            changeRequests.address,
             benchmarkQuantity,
             netflagsQuantity,
+            {gasLimit: 30000000}
         );
+
+        await administratum.transferOwnership(market.address);
+        await orders.transferOwnership(market.address);
+        await deals.transferOwnership(market.address);
+        await changeRequests.transferOwnership(market.address);
+
         await blacklist.SetMarketAddress(market.address);
 
         await token.transfer(consumer, oraclePrice / 1e7, { from: accounts[0] });
diff --git a/blockchain/source/truffle.js b/blockchain/source/truffle.js
index 3389f3be9..4068e2dd0 100644
--- a/blockchain/source/truffle.js
+++ b/blockchain/source/truffle.js
@@ -29,6 +29,8 @@ module.exports = {
             host: 'localhost',
             port: 8535,
             network_id: '*', // eslint-disable-line camelcase
+            gas: 8000000000 ,
+            gasPrice: 1
         },
         coverage: {
             host: 'localhost',
@@ -36,6 +38,7 @@ module.exports = {
             port: 8555,
             gas: 0xfffffffffff,
             gasPrice: 0x01,
+            gas:200000000
         },
 
         master: {
@@ -58,7 +61,7 @@ module.exports = {
     },
     solc: {
         optimizer: {
-            enabled: true,
+            enabled: false,
             runs: 200,
         },
     },

From 8efee2dec87481cb22c53c7a0d42085f7e3ac4cc Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Wed, 31 Oct 2018 18:02:37 +0300
Subject: [PATCH 02/18] tests updated

---
 blockchain/source/test/blacklist.js      |   5 +
 blockchain/source/test/helpers/common.js |  14 +-
 blockchain/source/test/market.js         | 335 ++++++++++++-----------
 3 files changed, 182 insertions(+), 172 deletions(-)

diff --git a/blockchain/source/test/blacklist.js b/blockchain/source/test/blacklist.js
index 4958c5c8b..6ba6244ef 100644
--- a/blockchain/source/test/blacklist.js
+++ b/blockchain/source/test/blacklist.js
@@ -16,6 +16,10 @@ contract('Blacklist', async function (accounts) {
     let token;
     let oracle;
     let pr;
+    let administratum;
+    let orders;
+    let deals;
+    let changeRequests;
 
     const owner = accounts[0];
     const creeper = accounts[1];
@@ -30,6 +34,7 @@ contract('Blacklist', async function (accounts) {
         oracle = await OracleUSD.new();
         pr = await ProfileRegistry.new();
         await blacklist.AddMaster(master, { from: owner });
+        administratum = await Administratum.new();
         orders = await Orders.new();
         deals = await Deals.new();
         changeRequests = await ChangeRequests.new();
diff --git a/blockchain/source/test/helpers/common.js b/blockchain/source/test/helpers/common.js
index 29f4059dc..3e89b693d 100644
--- a/blockchain/source/test/helpers/common.js
+++ b/blockchain/source/test/helpers/common.js
@@ -3,17 +3,17 @@ export async function checkBenchmarks (info, benchmarks) {
     assert.equal(JSON.stringify(benchmarks), JSON.stringify(b), 'Incorrect benchmarks');
 }
 
-export async function checkOrderStatus (market, key, orderId, status) {
-    let res = await market.GetOrderParams(orderId, { from: key });
+export async function checkOrderStatus (orders, key, orderId, status) {
+    let res = await orders.GetOrderParams(orderId, { from: key });
     assert.equal(status, res[0], 'Incorrect order status');
 }
 
-export async function getDealIdFromOrder (market, key, orderId) {
-    let orderParams = await market.GetOrderParams(orderId, { from: key });
+export async function getDealIdFromOrder (orders, key, orderId) {
+    let orderParams = await orders.GetOrderParams(orderId, { from: key });
     return orderParams[1].toNumber(10);
 }
 
-export async function getDealInfoFromOrder (market, key, orderId) {
-    let dealId = await getDealIdFromOrder(market, key, orderId);
-    return market.GetDealInfo(dealId, { from: key });
+export async function getDealInfoFromOrder (deals, orders, key, orderId) {
+    let dealId = await getDealIdFromOrder(orders, key, orderId);
+    return deals.GetDealInfo(dealId, { from: key });
 }
diff --git a/blockchain/source/test/market.js b/blockchain/source/test/market.js
index 06d9c786f..8864a4f00 100644
--- a/blockchain/source/test/market.js
+++ b/blockchain/source/test/market.js
@@ -44,6 +44,10 @@ contract('Market', async (accounts) => {
     let oracle;
     let blacklist;
     let profileRegistry;
+    let administratum;
+    let orders;
+    let deals;
+    let changeRequests;
     let supplier = accounts[1];
     let consumer = accounts[2];
     let master = accounts[3];
@@ -107,7 +111,7 @@ contract('Market', async (accounts) => {
             // TODO: test above normal deal
             let oid = await Ask({ market, supplier });
 
-            let info = await market.GetOrderInfo(oid, { from: supplier });
+            let info = await orders.GetOrderInfo(oid, { from: supplier });
             assert.equal(OrderType.ASK, info[orderInfo.type]);
             assert.equal(supplier, info[orderInfo.author]);
             assert.equal('0x0000000000000000000000000000000000000000', info[orderInfo.counterparty]);
@@ -129,7 +133,7 @@ contract('Market', async (accounts) => {
         it('CreateOrder forward bid', async () => {
             let balanceBefore = await token.balanceOf(consumer);
             let oid = await Bid({ market, consumer });
-            let info = await market.GetOrderInfo(oid, { from: consumer });
+            let info = await orders.GetOrderInfo(oid, { from: consumer });
             assert.equal(OrderType.BID, info[orderInfo.type]);
             assert.equal(consumer, info[orderInfo.author]);
             assert.equal('0x0000000000000000000000000000000000000000', info[orderInfo.counterparty]);
@@ -165,7 +169,7 @@ contract('Market', async (accounts) => {
             let marketBalanceAfter = await token.balanceOf(market.address);
             let marketDifference = marketBalanceAfter.toNumber() - marketBalanceBefore.toNumber();
 
-            let info = await market.GetOrderInfo(oid, { from: consumer });
+            let info = await orders.GetOrderInfo(oid, { from: consumer });
             let frozenSum = info[orderInfo.frozenSum];
 
             assert.equal(balanceBefore.toNumber() - frozenSum, balanceAfter.toNumber());
@@ -174,7 +178,7 @@ contract('Market', async (accounts) => {
 
         it('CreateOrder spot ask', async () => {
             let oid = await Ask({ market, supplier, duration: 0 });
-            let info = await market.GetOrderInfo(oid, { from: supplier });
+            let info = await orders.GetOrderInfo(oid, { from: supplier });
             assert.equal(0, info[orderInfo.duration]);
         });
 
@@ -196,7 +200,7 @@ contract('Market', async (accounts) => {
             let balanceAfter = await token.balanceOf(supplier);
             assert.equal(balanceBefore.toNumber(), balanceAfter.toNumber());
 
-            let res = await market.GetOrderParams(oid, { from: supplier });
+            let res = await orders.GetOrderParams(oid, { from: supplier });
             assert.equal(OrderStatus.INACTIVE, res[OrderParams.status]);
             assert.equal(0, res[OrderParams.dealId]);
         });
@@ -210,7 +214,7 @@ contract('Market', async (accounts) => {
             let balanceAfter = await token.balanceOf(consumer);
             assert.equal(balanceBefore.toNumber(), balanceAfter.toNumber());
 
-            let res = await market.GetOrderParams(oid, { from: consumer });
+            let res = await orders.GetOrderParams(oid, { from: consumer });
             assert.equal(OrderStatus.INACTIVE, res[OrderParams.status]);
             assert.equal(0, res[OrderParams.dealId]);
         });
@@ -231,17 +235,18 @@ contract('Market', async (accounts) => {
         it('OpenDeal forward', async () => {
             let askId = await Ask({ market, supplier });
             let bidId = await Bid({ market, consumer });
-            let dealsAmountBefore = await market.GetDealsAmount({ from: consumer });
+            let dealsAmountBefore = await deals.GetDealsAmount({ from: consumer });
             await market.OpenDeal(askId, bidId, { from: consumer });
 
-            let askParams = await market.GetOrderParams(askId, { from: supplier });
-            let bidParams = await market.GetOrderParams(bidId, { from: consumer });
+            let askParams = await orders.GetOrderParams(askId, { from: supplier });
+            let bidParams = await orders.GetOrderParams(bidId, { from: consumer });
             assert.equal(OrderStatus.INACTIVE, askParams[OrderParams.status]);
             assert.equal(OrderStatus.INACTIVE, bidParams[OrderParams.status]);
             let dealId = bidParams[1];
-            let dealsAmountAfter = await market.GetDealsAmount({ from: consumer });
-            let dealInfo = await market.GetDealInfo(dealId, { from: consumer });
-            let dealParams = await market.GetDealParams(dealId, { from: consumer });
+            let dealsAmountAfter = await deals.GetDealsAmount({ from: consumer });
+            let dealInfo = await deals.GetDealInfo(dealId, { from: consumer });
+            let dealParams = await deals.GetDealParams(dealId, { from: consumer });
+
             assert.equal(dealsAmountBefore.toNumber() + 1, dealsAmountAfter.toNumber());
             assert.equal(DealStatus.ACCEPTED, dealParams[DealParams.status]);
             assert.ok(dealInfo[DealInfo.startTime].toNumber() === dealParams[DealParams.lastBillTs].toNumber(),
@@ -266,14 +271,14 @@ contract('Market', async (accounts) => {
             let bidId = await Bid({ market, consumer, duration: 0 });
             await market.OpenDeal(askId, bidId, { from: consumer });
 
-            let askParams = await market.GetOrderParams(askId, { from: supplier });
-            let bidParams = await market.GetOrderParams(bidId, { from: consumer });
+            let askParams = await orders.GetOrderParams(askId, { from: supplier });
+            let bidParams = await orders.GetOrderParams(bidId, { from: consumer });
             assert.equal(OrderStatus.INACTIVE, askParams[OrderParams.status]);
             assert.equal(OrderStatus.INACTIVE, bidParams[OrderParams.status]);
 
             let dealId = bidParams[OrderParams.dealId];
-            let dealInfo = await market.GetDealInfo(dealId, { from: consumer });
-            let dealParams = await market.GetDealParams(dealId, { from: consumer });
+            let dealInfo = await deals.GetDealInfo(dealId, { from: consumer });
+            let dealParams = await deals.GetDealParams(dealId, { from: consumer });
             assert.equal(DealStatus.ACCEPTED, dealParams[DealParams.status]);
             assert.ok(dealInfo[DealInfo.startTime].toNumber() === dealParams[DealParams.lastBillTs].toNumber(),
                 'lastBillTs not equal to startTime');
@@ -297,43 +302,43 @@ contract('Market', async (accounts) => {
             await market.OpenDeal(askId, bidId, { from: consumer });
             await increaseTime(duration + 1);
 
-            let bidParams = await market.GetOrderParams(bidId, { from: consumer });
+            let bidParams = await orders.GetOrderParams(bidId, { from: consumer });
             let dealId = bidParams[OrderParams.dealId];
 
             await market.CloseDeal(dealId, BlackListPerson.NOBODY, { from: consumer });
-            let dealParams = await market.GetDealParams(dealId, { from: consumer });
+            let dealParams = await deals.GetDealParams(dealId, { from: consumer });
             assert.equal(DealStatus.CLOSED, dealParams[DealParams.status]);
         });
     });
 
     describe('Workers:', () => {
         it('Register worker', async () => {
-            let tx = await market.RegisterWorker(master, { from: supplier });
+            let tx = await administratum.RegisterWorker(master, { from: supplier });
             await eventInTransaction(tx, 'WorkerAnnounced');
         });
 
         it('Confirm worker', async () => {
-            let masterBefore = await market.GetMaster(supplier);
-            let tx = await market.ConfirmWorker(supplier, { from: master });
-            let masterAfter = await market.GetMaster(supplier);
+            let masterBefore = await administratum.GetMaster(supplier);
+            let tx = await administratum.ConfirmWorker(supplier, { from: master });
+            let masterAfter = await administratum.GetMaster(supplier);
             assert.ok(masterBefore !== masterAfter && masterAfter === master);
             await eventInTransaction(tx, 'WorkerConfirmed');
         });
 
         it('Remove worker from master', async () => {
-            let tx = await market.RemoveWorker(supplier, master, { from: master });
-            let masterAfter = await market.GetMaster(supplier);
+            let tx = await administratum.RemoveWorker(supplier, master, { from: master });
+            let masterAfter = await administratum.GetMaster(supplier);
             assert.equal(masterAfter, supplier);
             await eventInTransaction(tx, 'WorkerRemoved');
         });
 
         it('Register/confirm worker, remove master from worker', async () => {
-            await market.RegisterWorker(master, { from: supplier });
-            await market.ConfirmWorker(supplier, { from: master });
+            await administratum.RegisterWorker(master, { from: supplier });
+            await administratum.ConfirmWorker(supplier, { from: master });
 
-            let txRemove = await market.RemoveWorker(supplier, master, { from: supplier });
+            let txRemove = await administratum.RemoveWorker(supplier, master, { from: supplier });
             await eventInTransaction(txRemove, 'WorkerRemoved');
-            let masterAfter = await market.GetMaster(supplier);
+            let masterAfter = await administratum.GetMaster(supplier);
             assert.equal(masterAfter, supplier);
         });
     });
@@ -351,24 +356,24 @@ contract('Market', async (accounts) => {
             let askId = await Ask({ market, supplier });
             let bidId = await Bid({ market, consumer });
             await market.OpenDeal(askId, bidId, { from: consumer });
-            let bidParams = await market.GetOrderParams(bidId, { from: consumer });
+            let bidParams = await orders.GetOrderParams(bidId, { from: consumer });
             presetFwdDealId = bidParams[OrderParams.dealId];
-            presetFwdDealParams = await market.GetDealParams(presetFwdDealId, { from: consumer });
+            presetFwdDealParams = await deals.GetDealParams(presetFwdDealId, { from: consumer });
 
-            await market.RegisterWorker(master, { from: supplierWithMaster });
-            await market.ConfirmWorker(supplierWithMaster, { from: master });
+            await administratum.RegisterWorker(master, { from: supplierWithMaster });
+            await administratum.ConfirmWorker(supplierWithMaster, { from: master });
             let maskId = await Ask({ market, supplier: supplierWithMaster });
             let mbidId = await Bid({ market, consumer });
             await market.OpenDeal(maskId, mbidId, { from: consumer });
-            let mbidParams = await market.GetOrderParams(mbidId, { from: consumer });
+            let mbidParams = await orders.GetOrderParams(mbidId, { from: consumer });
             presetMasterFwdDealId = mbidParams[OrderParams.dealId];
 
             let saskId = await Ask({ market, supplier, duration: 0 });
             let sbidId = await Bid({ market, consumer, duration: 0 });
             await market.OpenDeal(saskId, sbidId, { from: consumer });
-            let sbidParams = await market.GetOrderParams(sbidId, { from: consumer });
+            let sbidParams = await orders.GetOrderParams(sbidId, { from: consumer });
             presetSpotDealId = sbidParams[OrderParams.dealId];
-            presetSpotDealParams = await market.GetDealParams(presetSpotDealId, { from: consumer });
+            presetSpotDealParams = await deals.GetDealParams(presetSpotDealId, { from: consumer });
 
             await increaseTime(secInHour / 2);
         });
@@ -394,7 +399,7 @@ contract('Market', async (accounts) => {
             let supplierBalanceAfter = await token.balanceOf(supplier);
             let marketBalanceAfter = await token.balanceOf(market.address);
 
-            let dealParamsAfter = await market.GetDealParams(presetSpotDealId);
+            let dealParamsAfter = await deals.GetDealParams(presetSpotDealId);
 
             let lastBillTSAfter = dealParamsAfter[DealParams.lastBillTs];
 
@@ -413,7 +418,7 @@ contract('Market', async (accounts) => {
         });
 
         it('Billing forward deal', async () => {
-            let deal = await market.GetDealParams(presetFwdDealId);
+            let deal = await deals.GetDealParams(presetFwdDealId);
             let consumerBalanceBefore = await token.balanceOf(consumer);
             let supplierBalanceBefore = await token.balanceOf(supplier);
             let marketBalanceBefore = await token.balanceOf(market.address);
@@ -426,7 +431,7 @@ contract('Market', async (accounts) => {
             let supplierBalanceAfter = await token.balanceOf(supplier);
             let marketBalanceAfter = await token.balanceOf(market.address);
 
-            let dealParamsAfter = await market.GetDealParams(presetFwdDealId);
+            let dealParamsAfter = await deals.GetDealParams(presetFwdDealId);
 
             let lastBillTSAfter = dealParamsAfter[DealParams.lastBillTs];
 
@@ -445,7 +450,7 @@ contract('Market', async (accounts) => {
         });
 
         it('Billing forward deal, with master', async () => {
-            let deal = await market.GetDealParams(presetMasterFwdDealId);
+            let deal = await deals.GetDealParams(presetMasterFwdDealId);
             let consumerBalanceBefore = await token.balanceOf(consumer);
             let masterBalanceBefore = await token.balanceOf(master);
             let marketBalanceBefore = await token.balanceOf(market.address);
@@ -457,7 +462,7 @@ contract('Market', async (accounts) => {
             let consumerBalanceAfter = await token.balanceOf(consumer);
             let masterBalanceAfter = await token.balanceOf(master);
             let marketBalanceAfter = await token.balanceOf(market.address);
-            let dealParamsAfter = await market.GetDealParams(presetMasterFwdDealId);
+            let dealParamsAfter = await deals.GetDealParams(presetMasterFwdDealId);
 
             let lastBillTSAfter = dealParamsAfter[DealParams.lastBillTs];
 
@@ -474,7 +479,7 @@ contract('Market', async (accounts) => {
                 masterBalanceBefore.toNumber() + event.paidAmount.toNumber());
             assert.equal(marketBalanceAfter.toNumber() - marketBalanceBefore.toNumber(), 0);
 
-            await market.RemoveWorker(supplierWithMaster, master, { from: master });
+            await administratum.RemoveWorker(supplierWithMaster, master, { from: master });
         });
 
         it('Billing forward deal: not billed if deal.lastBillTS >= deal.endTime', async () => {
@@ -496,18 +501,18 @@ contract('Market', async (accounts) => {
             let askId = await Ask({ market, supplier, price: testPrice });
             let bidId = await Bid({ market, consumer, price: testPrice });
             await market.OpenDeal(askId, bidId, { from: consumer });
-            let bidParams = await market.GetOrderParams(bidId, { from: consumer });
+            let bidParams = await orders.GetOrderParams(bidId, { from: consumer });
             presetFwdDealId = bidParams[OrderParams.dealId];
 
             let saskId = await Ask({ market, supplier, price: testPrice, duration: 0 });
             let sbidId = await Bid({ market, consumer, price: testPrice, duration: 0 });
             await market.OpenDeal(saskId, sbidId, { from: consumer });
-            let sbidParams = await market.GetOrderParams(sbidId, { from: consumer });
+            let sbidParams = await orders.GetOrderParams(sbidId, { from: consumer });
             presetSpotDealId = sbidParams[OrderParams.dealId];
         });
 
         it('Create change request as supplier and close', async () => {
-            let chReqsBefore = await market.GetChangeRequestsAmount();
+            let chReqsBefore = await changeRequests.GetChangeRequestsAmount();
 
             // raising price
             let newPrice = 1e6;
@@ -518,26 +523,26 @@ contract('Market', async (accounts) => {
                 { from: supplier });
 
             // price not changed
-            let dealParamsAfter = await market.GetDealParams(presetFwdDealId);
+            let dealParamsAfter = await deals.GetDealParams(presetFwdDealId);
             let priceAfter = dealParamsAfter[DealParams.price].toNumber();
             assert.equal(testPrice, priceAfter);
 
-            let chReqsAfter = await market.GetChangeRequestsAmount();
+            let chReqsAfter = await changeRequests.GetChangeRequestsAmount();
             let currentChReq = chReqsBefore.toNumber() + 1;
             assert.equal(currentChReq, chReqsAfter.toNumber());
 
-            let chReqInfoBefore = await market.GetChangeRequestInfo(currentChReq);
+            let chReqInfoBefore = await changeRequests.GetChangeRequestInfo(currentChReq);
             assert.equal(RequestStatus.REQUEST_CREATED, chReqInfoBefore[ChangeRequestInfo.status]);
 
             await market.CancelChangeRequest(currentChReq, { from: supplier });
 
-            let chReqInfoAfter = await market.GetChangeRequestInfo(currentChReq);
+            let chReqInfoAfter = await changeRequests.GetChangeRequestInfo(currentChReq);
             assert.equal(RequestStatus.REQUEST_CANCELED,
                 chReqInfoAfter[ChangeRequestInfo.status]);
         });
 
         it('Create change request as consumer and close', async () => {
-            let chReqsBefore = await market.GetChangeRequestsAmount();
+            let chReqsBefore = await changeRequests.GetChangeRequestsAmount();
 
             // lowering price
             let newPrice = 1e2;
@@ -548,26 +553,26 @@ contract('Market', async (accounts) => {
                 { from: consumer });
 
             // price not changed
-            let dealParamsAfter = await market.GetDealParams(presetFwdDealId);
+            let dealParamsAfter = await deals.GetDealParams(presetFwdDealId);
             let priceAfter = dealParamsAfter[DealParams.price].toNumber();
             assert.equal(testPrice, priceAfter);
 
-            let chReqsAfter = await market.GetChangeRequestsAmount();
+            let chReqsAfter = await changeRequests.GetChangeRequestsAmount();
             let currentChReq = chReqsBefore.toNumber() + 1;
             assert.equal(currentChReq, chReqsAfter.toNumber());
 
-            let chReqInfoBefore = await market.GetChangeRequestInfo(currentChReq);
+            let chReqInfoBefore = await changeRequests.GetChangeRequestInfo(currentChReq);
             assert.equal(RequestStatus.REQUEST_CREATED, chReqInfoBefore[ChangeRequestInfo.status]);
 
             await market.CancelChangeRequest(currentChReq, { from: consumer });
 
-            let chReqInfoAfter = await market.GetChangeRequestInfo(currentChReq);
+            let chReqInfoAfter = await changeRequests.GetChangeRequestInfo(currentChReq);
             assert.equal(RequestStatus.REQUEST_CANCELED,
                 chReqInfoAfter[ChangeRequestInfo.status]);
         });
 
         it('Create change request as consumer and reject as supplier', async () => {
-            let chReqsBefore = await market.GetChangeRequestsAmount();
+            let chReqsBefore = await changeRequests.GetChangeRequestsAmount();
 
             // lowering price
             let newPrice = 1e2;
@@ -578,27 +583,27 @@ contract('Market', async (accounts) => {
                 { from: consumer });
 
             // price not changed
-            let dealParamsAfter = await market.GetDealParams(presetFwdDealId);
+            let dealParamsAfter = await deals.GetDealParams(presetFwdDealId);
             let priceAfter = dealParamsAfter[DealParams.price].toNumber();
             assert.equal(testPrice, priceAfter);
 
-            let chReqsAfter = await market.GetChangeRequestsAmount();
+            let chReqsAfter = await changeRequests.GetChangeRequestsAmount();
             let currentChReq = chReqsBefore.toNumber() + 1;
             assert.equal(currentChReq, chReqsAfter.toNumber());
 
-            let chReqInfoBefore = await market.GetChangeRequestInfo(currentChReq);
+            let chReqInfoBefore = await changeRequests.GetChangeRequestInfo(currentChReq);
             assert.equal(RequestStatus.REQUEST_CREATED, chReqInfoBefore[ChangeRequestInfo.status]);
 
             // rejecting
             await market.CancelChangeRequest(currentChReq, { from: supplier });
 
-            let chReqInfoAfter = await market.GetChangeRequestInfo(currentChReq);
+            let chReqInfoAfter = await changeRequests.GetChangeRequestInfo(currentChReq);
             assert.equal(RequestStatus.REQUEST_REJECTED,
                 chReqInfoAfter[ChangeRequestInfo.status]);
         });
 
         it('Create change request as supplier and reject as consumer', async () => {
-            let chReqsBefore = await market.GetChangeRequestsAmount();
+            let chReqsBefore = await changeRequests.GetChangeRequestsAmount();
 
             // raising price
             let newPrice = 1e6;
@@ -609,21 +614,21 @@ contract('Market', async (accounts) => {
                 { from: supplier });
 
             // price not changed
-            let dealParamsAfter = await market.GetDealParams(presetFwdDealId);
+            let dealParamsAfter = await deals.GetDealParams(presetFwdDealId);
             let priceAfter = dealParamsAfter[DealParams.price].toNumber();
             assert.equal(testPrice, priceAfter);
 
-            let chReqsAfter = await market.GetChangeRequestsAmount();
+            let chReqsAfter = await changeRequests.GetChangeRequestsAmount();
             let currentChReq = chReqsBefore.toNumber() + 1;
             assert.equal(currentChReq, chReqsAfter.toNumber());
 
-            let chReqInfoBefore = await market.GetChangeRequestInfo(currentChReq);
+            let chReqInfoBefore = await changeRequests.GetChangeRequestInfo(currentChReq);
             assert.equal(RequestStatus.REQUEST_CREATED, chReqInfoBefore[ChangeRequestInfo.status]);
 
             // rejecting
             await market.CancelChangeRequest(currentChReq, { from: consumer });
 
-            let chReqInfoAfter = await market.GetChangeRequestInfo(currentChReq);
+            let chReqInfoAfter = await changeRequests.GetChangeRequestInfo(currentChReq);
             assert.equal(RequestStatus.REQUEST_REJECTED,
                 chReqInfoAfter[ChangeRequestInfo.status]);
         });
@@ -644,7 +649,7 @@ contract('Market', async (accounts) => {
                 testDuration,
                 { from: supplier });
 
-            let dealParamsAfter = await market.GetDealParams(presetFwdDealId, { from: consumer });
+            let dealParamsAfter = await deals.GetDealParams(presetFwdDealId, { from: consumer });
 
             let priceAfter = dealParamsAfter[DealParams.price].toNumber();
             assert.equal(newPrice, priceAfter);
@@ -665,7 +670,7 @@ contract('Market', async (accounts) => {
                 newDuration,
                 { from: supplier });
 
-            let dealParamsAfter = await market.GetDealParams(presetFwdDealId);
+            let dealParamsAfter = await deals.GetDealParams(presetFwdDealId);
             let durationAfter = dealParamsAfter[DealParams.duration].toNumber();
             assert.equal(newDuration, durationAfter);
         });
@@ -686,7 +691,7 @@ contract('Market', async (accounts) => {
                 0,
                 { from: supplier });
 
-            let dealParamsAfter = await market.GetDealParams(presetSpotDealId, { from: consumer });
+            let dealParamsAfter = await deals.GetDealParams(presetSpotDealId, { from: consumer });
 
             let priceAfter = dealParamsAfter[DealParams.price].toNumber();
             assert.equal(newPrice, priceAfter);
@@ -711,7 +716,7 @@ contract('Market', async (accounts) => {
                 { from: consumer });
 
             // price changed
-            let dealParamsAfter = await market.GetDealParams(presetFwdDealId);
+            let dealParamsAfter = await deals.GetDealParams(presetFwdDealId);
             let priceAfter = dealParamsAfter[DealParams.price].toNumber();
             assert.equal(newPrice, priceAfter);
         });
@@ -725,7 +730,7 @@ contract('Market', async (accounts) => {
                 { from: supplier });
 
             // price changed
-            let dealParamsAfter = await market.GetDealParams(presetFwdDealId);
+            let dealParamsAfter = await deals.GetDealParams(presetFwdDealId);
             let priceAfter = dealParamsAfter[DealParams.price].toNumber();
             assert.equal(newPrice, priceAfter);
         });
@@ -746,7 +751,7 @@ contract('Market', async (accounts) => {
                 newDuration,
                 { from: consumer });
 
-            let dealParamsAfter = await market.GetDealParams(presetFwdDealId);
+            let dealParamsAfter = await deals.GetDealParams(presetFwdDealId);
             let durationAfter = dealParamsAfter[DealParams.duration].toNumber();
             let priceAfter = dealParamsAfter[DealParams.price].toNumber();
             assert.equal(newDuration, durationAfter);
@@ -767,8 +772,8 @@ contract('Market', async (accounts) => {
             assert.equal(balConsBefore.toNumber() - balConsInterm.toNumber(), 3600, 'incorrect consumer balance');
 
             await market.OpenDeal(askId, bidId, { from: specialConsumer2 });
-            let dealId = await getDealIdFromOrder(market, specialConsumer2, askId);
-            let paramsBeforeBill = await market.GetDealParams(dealId);
+            let dealId = await getDealIdFromOrder(orders, specialConsumer2, askId);
+            let paramsBeforeBill = await deals.GetDealParams(dealId);
             await increaseTime(secInHour - 3);
 
             assert.equal(paramsBeforeBill[DealParams.status].toNumber(),
@@ -780,8 +785,8 @@ contract('Market', async (accounts) => {
             let balMarketAfter = await token.balanceOf(market.address);
             let balSuppAfter = await token.balanceOf(specialSupplier);
             let balConsAfter = await token.balanceOf(specialConsumer2);
-            let pAfterBill = await market.GetDealParams(dealId);
-            let iAfterBill = await market.GetDealInfo(dealId);
+            let pAfterBill = await deals.GetDealParams(dealId);
+            let iAfterBill = await deals.GetDealInfo(dealId);
             let dealTime = pAfterBill[DealParams.endTime].toNumber() - iAfterBill[DealInfo.startTime].toNumber();
             assert.equal(pAfterBill[DealParams.totalPayout].toNumber(), dealTime, 'incorrect total payout');
             assert.equal(balSuppAfter.toNumber() - balSuppBefore.toNumber(),
@@ -801,7 +806,7 @@ contract('Market', async (accounts) => {
             let bidId = await Bid({ market, consumer: specialConsumer, price: 1e6, duration: 0 });
 
             await market.OpenDeal(askId, bidId, { from: specialConsumer });
-            let dealId = await getDealIdFromOrder(market, supplier, askId);
+            let dealId = await getDealIdFromOrder(orders, supplier, askId);
 
             await increaseTime(secInHour - 3);
 
@@ -811,7 +816,7 @@ contract('Market', async (accounts) => {
             let balMarketAfter = await token.balanceOf(market.address);
             let balSuppAfter = await token.balanceOf(supplier);
             let balConsAfter = await token.balanceOf(specialConsumer);
-            let pAfterBill = await market.GetDealParams(dealId);
+            let pAfterBill = await deals.GetDealParams(dealId);
             assert.equal(pAfterBill[DealParams.totalPayout].toNumber(), 3600, 'incorrect total payout');
             assert.equal(balSuppAfter.toNumber() - balSuppBefore.toNumber(),
                 pAfterBill[DealParams.totalPayout].toNumber(),
@@ -834,7 +839,7 @@ contract('Market', async (accounts) => {
             let bidId = await Bid({ market, consumer, price: 1e6, duration: 0 });
 
             await market.OpenDeal(askId, bidId, { from: consumer });
-            let dealId = await getDealIdFromOrder(market, consumer, askId);
+            let dealId = await getDealIdFromOrder(orders, consumer, askId);
             await increaseTime(secInHour - 3);
 
             await oracle.setCurrentPrice(priceAfter);
@@ -843,8 +848,8 @@ contract('Market', async (accounts) => {
             let balSuppAfter = await token.balanceOf(supplier);
             let balConsAfter = await token.balanceOf(consumer);
             let balMarketAfter = await token.balanceOf(market.address);
-            let pAfterBill = await market.GetDealParams(dealId);
-            let iAfterBill = await market.GetDealInfo(dealId);
+            let pAfterBill = await deals.GetDealParams(dealId);
+            let iAfterBill = await deals.GetDealInfo(dealId);
             let dealTime = pAfterBill[DealParams.lastBillTs].toNumber() - iAfterBill[DealInfo.startTime].toNumber();
 
             assert.equal(pAfterBill[DealParams.totalPayout].toNumber(),
@@ -873,7 +878,7 @@ contract('Market', async (accounts) => {
             let bidId = await Bid({ market, consumer, price: 1e6, duration: 0 });
 
             await market.OpenDeal(askId, bidId, { from: consumer });
-            let dealId = await getDealIdFromOrder(market, consumer, askId);
+            let dealId = await getDealIdFromOrder(orders, consumer, askId);
             await increaseTime(secInHour - 3);
 
             await oracle.setCurrentPrice(priceAfter);
@@ -882,8 +887,8 @@ contract('Market', async (accounts) => {
             let balSuppAfter = await token.balanceOf(supplier);
             let balConsAfter = await token.balanceOf(consumer);
             let balMarketAfter = await token.balanceOf(market.address);
-            let pAfterBill = await market.GetDealParams(dealId);
-            let iAfterBill = await market.GetDealInfo(dealId);
+            let pAfterBill = await deals.GetDealParams(dealId);
+            let iAfterBill = await deals.GetDealInfo(dealId);
             let dealTime = pAfterBill[DealParams.endTime].toNumber() - iAfterBill[DealInfo.startTime].toNumber();
             assert.equal(pAfterBill[DealParams.totalPayout].toNumber(),
                 priceAfter / priceBefore * dealTime,
@@ -910,8 +915,8 @@ contract('Market', async (accounts) => {
             assert.equal(balConsBefore.toNumber() - balConsInterm.toNumber(), 3600, 'incorrect consumer balance');
 
             await market.OpenDeal(askId, bidId, { from: consumer });
-            let dealId = await getDealIdFromOrder(market, consumer, askId);
-            let paramsBeforeBill = await market.GetDealParams(dealId);
+            let dealId = await getDealIdFromOrder(orders, consumer, askId);
+            let paramsBeforeBill = await deals.GetDealParams(dealId);
             await increaseTime(secInHour + 3);
 
             assert.equal(paramsBeforeBill[DealParams.status].toNumber(), DealStatus.ACCEPTED, 'deal must be ACCEPTED');
@@ -921,7 +926,7 @@ contract('Market', async (accounts) => {
             let balMarketAfter = await token.balanceOf(market.address);
             let balSuppAfter = await token.balanceOf(supplier);
             let balConsAfter = await token.balanceOf(consumer);
-            let pAfterBill = await market.GetDealParams(dealId);
+            let pAfterBill = await deals.GetDealParams(dealId);
             assert.equal(pAfterBill[DealParams.totalPayout].toNumber(), 3600, 'incorrect total payout');
             assert.equal(balSuppAfter.toNumber() - balSuppBefore.toNumber(),
                 pAfterBill[DealParams.totalPayout].toNumber(),
@@ -945,8 +950,8 @@ contract('Market', async (accounts) => {
             assert.equal(balConsBefore.toNumber() - balConsInterm.toNumber(), 3600, 'incorrect consumer balance');
 
             await market.OpenDeal(askId, bidId, { from: consumer });
-            let dealId = await getDealIdFromOrder(market, consumer, askId);
-            let paramsBeforeBill = await market.GetDealParams(dealId);
+            let dealId = await getDealIdFromOrder(orders, consumer, askId);
+            let paramsBeforeBill = await deals.GetDealParams(dealId);
             await increaseTime(secInHour / 2);
 
             assert.equal(paramsBeforeBill[DealParams.status].toNumber(), DealStatus.ACCEPTED,
@@ -957,8 +962,8 @@ contract('Market', async (accounts) => {
             let balMarketAfter = await token.balanceOf(market.address);
             let balSuppAfter = await token.balanceOf(supplier);
             let balConsAfter = await token.balanceOf(consumer);
-            let pAfterBill = await market.GetDealParams(dealId);
-            let iAfterBill = await market.GetDealInfo(dealId);
+            let pAfterBill = await deals.GetDealParams(dealId);
+            let iAfterBill = await deals.GetDealInfo(dealId);
             let dealTime = pAfterBill[DealParams.endTime].toNumber() - iAfterBill[DealInfo.startTime].toNumber();
             assert.equal(pAfterBill[DealParams.totalPayout].toNumber(), dealTime, 'incorrect total payout');
             assert.equal(balSuppAfter.toNumber() - balSuppBefore.toNumber(),
@@ -976,7 +981,7 @@ contract('Market', async (accounts) => {
             let bidId = await Bid({ market, consumer: consumer, price: 1e6, duration: 3600 });
             let askId = await Ask({ market, supplier: supplier, price: 1e6, duration: 3600 });
             await market.OpenDeal(askId, bidId, { from: consumer });
-            let dealId = await getDealIdFromOrder(market, consumer, askId);
+            let dealId = await getDealIdFromOrder(orders, consumer, askId);
             await increaseTime(secInHour / 2);
             await assertRevert(market.CloseDeal(dealId, 0, { from: supplier }));
         });
@@ -984,12 +989,12 @@ contract('Market', async (accounts) => {
 
     describe('Blacklist', async () => {
         it('Prepare workers', async () => {
-            await market.RegisterWorker(blacklistMaster, { from: blacklistWorker1 });
-            await market.RegisterWorker(blacklistMaster, { from: blacklistWorker2 });
-            await market.ConfirmWorker(blacklistWorker1, { from: blacklistMaster });
-            await market.ConfirmWorker(blacklistWorker2, { from: blacklistMaster });
-            let master1 = await market.GetMaster(blacklistWorker1);
-            let master2 = await market.GetMaster(blacklistWorker2);
+            await administratum.RegisterWorker(blacklistMaster, { from: blacklistWorker1 });
+            await administratum.RegisterWorker(blacklistMaster, { from: blacklistWorker2 });
+            await administratum.ConfirmWorker(blacklistWorker1, { from: blacklistMaster });
+            await administratum.ConfirmWorker(blacklistWorker2, { from: blacklistMaster });
+            let master1 = await administratum.GetMaster(blacklistWorker1);
+            let master2 = await administratum.GetMaster(blacklistWorker2);
 
             assert.equal(master1, blacklistMaster, 'Worker not confirmed');
             assert.equal(master2, blacklistMaster, 'Worker not confirmed');
@@ -1005,15 +1010,15 @@ contract('Market', async (accounts) => {
             let bidId = await Bid({ market, consumer, price: 1e6, duration: 0 });
 
             await market.OpenDeal(askId, bidId, { from: consumer });
-            let dealId = await getDealIdFromOrder(market, consumer, askId);
+            let dealId = await getDealIdFromOrder(orders, consumer, askId);
             await increaseTime(secInHour - 3);
             // close deal with blacklist worker blacklistWorker1
             await market.CloseDeal(dealId, 1, { from: consumer });
             let balSuppAfter = await token.balanceOf(blacklistMaster);
             let balConsAfter = await token.balanceOf(consumer);
             let balMarketAfter = await token.balanceOf(market.address);
-            let pAfterClose = await market.GetDealParams(dealId);
-            let iAfterClose = await market.GetDealInfo(dealId);
+            let pAfterClose = await deals.GetDealParams(dealId);
+            let iAfterClose = await deals.GetDealInfo(dealId);
             let dealTime = pAfterClose[DealParams.lastBillTs].toNumber() - iAfterClose[DealInfo.startTime].toNumber();
             assert.equal(pAfterClose[DealParams.totalPayout].toNumber(), dealTime, 'incorrect total payout');
             assert.equal(balSuppAfter.toNumber() - balSuppBefore.toNumber(),
@@ -1048,15 +1053,15 @@ contract('Market', async (accounts) => {
             let bidId = await Bid({ market, consumer, price: 1e6, duration: 0 });
 
             await market.OpenDeal(askId, bidId, { from: consumer });
-            let dealId = await getDealIdFromOrder(market, consumer, askId);
+            let dealId = await getDealIdFromOrder(orders, consumer, askId);
             await increaseTime(secInHour - 3);
             // close deal with blacklist master
             await market.CloseDeal(dealId, 2, { from: consumer });
             let balSuppAfter = await token.balanceOf(blacklistMaster);
             let balConsAfter = await token.balanceOf(consumer);
             let balMarketAfter = await token.balanceOf(market.address);
-            let pAfterClose = await market.GetDealParams(dealId);
-            let iAfterClose = await market.GetDealInfo(dealId);
+            let pAfterClose = await deals.GetDealParams(dealId);
+            let iAfterClose = await deals.GetDealInfo(dealId);
             let dealTime = pAfterClose[DealParams.lastBillTs].toNumber() - iAfterClose[DealInfo.startTime].toNumber();
             assert.equal(pAfterClose[DealParams.totalPayout].toNumber(), dealTime, 'incorrect total payout');
             assert.equal(balSuppAfter.toNumber() - balSuppBefore.toNumber(),
@@ -1091,9 +1096,9 @@ contract('Market', async (accounts) => {
             await oracle.setCurrentPrice(1e12);
             let askId = await Ask({ market, supplier, price: 1e6, duration: 3600 });
             await market.QuickBuy(askId, 1800, { from: consumer });
-            let dealId = await getDealIdFromOrder(market, consumer, askId);
-            let dealInfo = await market.GetDealInfo(dealId, { from: consumer });
-            let dealParams = await market.GetDealParams(dealId, { from: consumer });
+            let dealId = await getDealIdFromOrder(orders, consumer, askId);
+            let dealInfo = await deals.GetDealInfo(dealId, { from: consumer });
+            let dealParams = await deals.GetDealParams(dealId, { from: consumer });
             assert.equal(DealStatus.ACCEPTED, dealParams[DealParams.status]);
             assert.ok(dealInfo[DealInfo.startTime].toNumber() === dealParams[DealParams.lastBillTs].toNumber(),
                 'lastBillTs not equal to startTime');
@@ -1112,13 +1117,13 @@ contract('Market', async (accounts) => {
         });
 
         it('QuickBuy forward with master', async () => {
-            await market.RegisterWorker(master, { from: supplier });
-            await market.ConfirmWorker(supplier, { from: master });
+            await administratum.RegisterWorker(master, { from: supplier });
+            await administratum.ConfirmWorker(supplier, { from: master });
             let askId = await Ask({ market, supplier, price: 1e6, duration: 3600 });
             await market.QuickBuy(askId, 10, { from: consumer });
-            let dealId = await getDealIdFromOrder(market, consumer, askId);
-            let dealInfo = await market.GetDealInfo(dealId, { from: consumer });
-            let dealParams = await market.GetDealParams(dealId, { from: consumer });
+            let dealId = await getDealIdFromOrder(orders, consumer, askId);
+            let dealInfo = await deals.GetDealInfo(dealId, { from: consumer });
+            let dealParams = await deals.GetDealParams(dealId, { from: consumer });
             assert.equal(DealStatus.ACCEPTED, dealParams[DealParams.status]);
             assert.ok(dealInfo[DealInfo.startTime].toNumber() === dealParams[DealParams.lastBillTs].toNumber(),
                 'lastBillTs not equal to startTime');
@@ -1150,22 +1155,22 @@ contract('Market', async (accounts) => {
             let bidNew = await Bid({ market, consumer, netFlags: [0, 0], benchmarks: newBenchmarksWZero });
             let askNew = await Ask({ market, supplier, netFlags: [0, 0], benchmarks: newBenchmarks });
 
-            let bidInfo = await market.GetOrderInfo(bidNew, { from: consumer });
+            let bidInfo = await orders.GetOrderInfo(bidNew, { from: consumer });
             checkBenchmarks(bidInfo[orderInfo.benchmarks], newBenchmarksWZero);
-            let askInfo = await market.GetOrderInfo(askNew, { from: consumer });
+            let askInfo = await orders.GetOrderInfo(askNew, { from: consumer });
             checkBenchmarks(askInfo[orderInfo.benchmarks], newBenchmarks);
 
             await market.OpenDeal(askOld, bidNew, { from: consumer });
             await market.OpenDeal(askNew, bidOld, { from: consumer });
 
-            await checkOrderStatus(market, supplier, askOld, OrderStatus.INACTIVE);
-            await checkOrderStatus(market, supplier, bidOld, OrderStatus.INACTIVE);
-            await checkOrderStatus(market, supplier, bidNew, OrderStatus.INACTIVE);
-            await checkOrderStatus(market, supplier, askNew, OrderStatus.INACTIVE);
+            await checkOrderStatus(orders, supplier, askOld, OrderStatus.INACTIVE);
+            await checkOrderStatus(orders, supplier, bidOld, OrderStatus.INACTIVE);
+            await checkOrderStatus(orders, supplier, bidNew, OrderStatus.INACTIVE);
+            await checkOrderStatus(orders, supplier, askNew, OrderStatus.INACTIVE);
 
-            let dealInfo1 = await getDealInfoFromOrder(market, consumer, bidNew);
+            let dealInfo1 = await getDealInfoFromOrder(deals, orders, consumer, bidNew);
             checkBenchmarks(dealInfo1[DealInfo.benchmarks], newBenchmarksWZero);
-            let dealInfo2 = await getDealInfoFromOrder(market, consumer, askNew);
+            let dealInfo2 = await getDealInfoFromOrder(deals, orders, consumer, askNew);
             checkBenchmarks(dealInfo2[DealInfo.benchmarks], newBenchmarks);
         });
 
@@ -1173,7 +1178,7 @@ contract('Market', async (accounts) => {
             let bid = await Bid({ market, consumer, benchmarks: newBenchmarksWZero });
             let ask = await Ask({ market, supplier, benchmarks: newBenchmarks });
             await market.OpenDeal(ask, bid, { from: consumer });
-            let dealInfo = await getDealInfoFromOrder(market, consumer, bid);
+            let dealInfo = await getDealInfoFromOrder(deals, orders, consumer, bid);
             checkBenchmarks(dealInfo[DealInfo.benchmarks], newBenchmarks);
         });
 
@@ -1281,53 +1286,53 @@ contract('Market', async (accounts) => {
             });
         });
 
-        describe('RegisterWorker', () => {
-            before(async () => {
-                await market.pause();
-            });
-
-            it('should revert', async () => {
-                await assertRevert(market.RegisterWorker(master, { from: supplier }));
-            });
-
-            after(async () => {
-                await market.unpause();
-            });
-        });
-
-        describe('ConfirmWorker', () => {
-            before(async () => {
-                await market.RegisterWorker(master, { from: accounts[0] });
-                await market.pause();
-            });
-
-            it('should revert', async () => {
-                await assertRevert(market.ConfirmWorker(supplier, { from: master }));
-            });
-
-            after(async () => {
-                await market.unpause();
-                await market.ConfirmWorker(accounts[0], { from: master });
-                await market.RemoveWorker(accounts[0], master, { from: master });
-            });
-        });
-
-        describe('RemoveWorker', () => {
-            before(async () => {
-                await market.RegisterWorker(master, { from: accounts[0] });
-                await market.ConfirmWorker(accounts[0], { from: master });
-                await market.pause();
-            });
-
-            it('should revert', async () => {
-                await assertRevert(market.RemoveWorker(accounts[0], master, { from: master }));
-            });
-
-            after(async () => {
-                await market.unpause();
-                await market.RemoveWorker(accounts[0], master, { from: master });
-            });
-        });
+        // describe('RegisterWorker', () => {
+        //     before(async () => {
+        //         await market.pause();
+        //     });
+        //
+        //     it('should revert', async () => {
+        //         await assertRevert(administratum.RegisterWorker(master, { from: supplier }));
+        //     });
+        //
+        //     after(async () => {
+        //         await market.unpause();
+        //     });
+        // });
+        //
+        // describe('ConfirmWorker', () => {
+        //     before(async () => {
+        //         await administratum.RegisterWorker(master, { from: accounts[0] });
+        //         await market.pause();
+        //     });
+        //
+        //     it('should revert', async () => {
+        //         await assertRevert(administratum.ConfirmWorker(supplier, { from: master }));
+        //     });
+        //
+        //     after(async () => {
+        //         await market.unpause();
+        //         await administratum.ConfirmWorker(accounts[0], { from: master });
+        //         await administratum.RemoveWorker(accounts[0], master, { from: master });
+        //     });
+        // });
+        //
+        // describe('RemoveWorker', () => {
+        //     before(async () => {
+        //         await administratum.RegisterWorker(master, { from: accounts[0] });
+        //         await administratum.ConfirmWorker(accounts[0], { from: master });
+        //         await market.pause();
+        //     });
+        //
+        //     it('should revert', async () => {
+        //         await assertRevert(administratum.RemoveWorker(accounts[0], master, { from: master }));
+        //     });
+        //
+        //     after(async () => {
+        //         await market.unpause();
+        //         await administratum.RemoveWorker(accounts[0], master, { from: master });
+        //     });
+        // });
     });
 
     describe('kill market', () => {

From be1654f5318d87f5d63f55453faca31cd2a67a4a Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Wed, 31 Oct 2018 18:36:07 +0300
Subject: [PATCH 03/18] linted

---
 blockchain/source/contracts/Market.sol        |  6 +-
 blockchain/source/contracts/Orders.sol        |  3 +-
 .../source/migrations/1_deploy_token.js       |  4 +-
 .../source/migrations/2_deploy_oracle.js      |  2 +-
 .../migrations/3_deploy_profileRegistry.js    |  2 +-
 .../source/migrations/4_deploy_blacklist.js   |  2 +-
 blockchain/source/migrations/7_deploy_crud.js | 10 ++--
 .../source/migrations/9_deploy_market.js      | 56 ++++++++++---------
 blockchain/source/test/blacklist.js           |  2 +-
 blockchain/source/test/market.js              |  2 +-
 blockchain/source/truffle.js                  |  5 +-
 11 files changed, 50 insertions(+), 44 deletions(-)

diff --git a/blockchain/source/contracts/Market.sol b/blockchain/source/contracts/Market.sol
index c017fcf55..8bae8977c 100644
--- a/blockchain/source/contracts/Market.sol
+++ b/blockchain/source/contracts/Market.sol
@@ -322,7 +322,8 @@ contract Market is Ownable, Pausable {
 
     function CreateChangeRequest(uint dealID, uint newPrice, uint newDuration) public returns (uint changeRequestID) {
 
-        require(msg.sender == dl.GetDealConsumerID(dealID)
+        require(
+            msg.sender == dl.GetDealConsumerID(dealID)
             || msg.sender ==  dl.GetDealMasterID(dealID)
             || msg.sender == dl.GetDealSupplierID(dealID));
         require(dl.GetDealStatus(dealID) == Deals.DealStatus.STATUS_ACCEPTED);
@@ -456,7 +457,8 @@ contract Market is Ownable, Pausable {
     function InternalBill(uint dealID) internal returns (bool){
 
         require(dl.GetDealStatus(dealID) == Deals.DealStatus.STATUS_ACCEPTED);
-        require(msg.sender == dl.GetDealSupplierID(dealID) ||
+        require(
+            msg.sender == dl.GetDealSupplierID(dealID) ||
             msg.sender == dl.GetDealConsumerID(dealID) ||
             msg.sender == dl.GetDealMasterID(dealID));
         uint paidAmount;
diff --git a/blockchain/source/contracts/Orders.sol b/blockchain/source/contracts/Orders.sol
index 90633e87c..a906d9e89 100644
--- a/blockchain/source/contracts/Orders.sol
+++ b/blockchain/source/contracts/Orders.sol
@@ -55,7 +55,8 @@ contract Orders is Ownable {
         owner = msg.sender;
     }
 
-    function Write(OrderType _orderType,
+    function Write(
+        OrderType _orderType,
         OrderStatus _orderStatus,
         address _author,
         address _counterparty,
diff --git a/blockchain/source/migrations/1_deploy_token.js b/blockchain/source/migrations/1_deploy_token.js
index b0915703e..075ee1721 100644
--- a/blockchain/source/migrations/1_deploy_token.js
+++ b/blockchain/source/migrations/1_deploy_token.js
@@ -3,9 +3,9 @@ let TestnetFaucet = artifacts.require('./TestnetFaucet.sol');
 
 module.exports = function (deployer, network) {
     if ((network === 'private') || (network === 'privateLive')) {
-        //deployer.deploy(SNM, { gasPrice: 0 });
+        deployer.deploy(SNM, { gasPrice: 0 });
     } else if (network === 'rinkeby') {
-        //deployer.deploy(TestnetFaucet);
+        deployer.deploy(TestnetFaucet);
     } else if (network === 'master') {
         // token already deployed at master to address 0x983f6d60db79ea8ca4eb9968c6aff8cfa04b3c63
     } else {
diff --git a/blockchain/source/migrations/2_deploy_oracle.js b/blockchain/source/migrations/2_deploy_oracle.js
index 920d407cc..65b7f5716 100644
--- a/blockchain/source/migrations/2_deploy_oracle.js
+++ b/blockchain/source/migrations/2_deploy_oracle.js
@@ -2,7 +2,7 @@ let OracleUSD = artifacts.require('./OracleUSD.sol');
 
 module.exports = function (deployer, network) {
     if ((network === 'private') || (network === 'privateLive')) {
-        //deployer.deploy(OracleUSD, { gasPrice: 0 });
+        // deployer.deploy(OracleUSD, { gasPrice: 0 });
     } else if (network === 'master') {
         // oracle haven't reason to deploy to mainnet
     } else if (network === 'rinkeby') {
diff --git a/blockchain/source/migrations/3_deploy_profileRegistry.js b/blockchain/source/migrations/3_deploy_profileRegistry.js
index 72ff845d1..655c602a2 100644
--- a/blockchain/source/migrations/3_deploy_profileRegistry.js
+++ b/blockchain/source/migrations/3_deploy_profileRegistry.js
@@ -2,7 +2,7 @@ let ProfileRegistry = artifacts.require('./ProfileRegistry.sol');
 
 module.exports = function (deployer, network) {
     if ((network === 'private') || (network === 'privateLive')) {
-        //deployer.deploy(ProfileRegistry, { gasPrice: 0 });
+        // deployer.deploy(ProfileRegistry, { gasPrice: 0 });
     } else if (network === 'master') {
         // we do not deploy ProfileRegistry at master anytime
     } else if (network === 'rinkeby') {
diff --git a/blockchain/source/migrations/4_deploy_blacklist.js b/blockchain/source/migrations/4_deploy_blacklist.js
index 719a9d9a8..d62da7936 100644
--- a/blockchain/source/migrations/4_deploy_blacklist.js
+++ b/blockchain/source/migrations/4_deploy_blacklist.js
@@ -2,7 +2,7 @@ let Blacklist = artifacts.require('./Blacklist.sol');
 
 module.exports = function (deployer, network) {
     if ((network === 'private') || (network === 'privateLive')) {
-        //deployer.deploy(Blacklist, { gasPrice: 0 });
+        // deployer.deploy(Blacklist, { gasPrice: 0 });
     } else if (network === 'master') {
         // blacklist haven't reason to deploy to mainnet
     } else if (network === 'rinkeby') {
diff --git a/blockchain/source/migrations/7_deploy_crud.js b/blockchain/source/migrations/7_deploy_crud.js
index 2bf871966..07f6ff2ff 100644
--- a/blockchain/source/migrations/7_deploy_crud.js
+++ b/blockchain/source/migrations/7_deploy_crud.js
@@ -3,17 +3,15 @@ let Deals = artifacts.require('./Deals.sol');
 let ChangeRequests = artifacts.require('./ChangeRequests.sol');
 
 module.exports = function (deployer, network) {
-  deployer.then(async () => {
     if ((network === 'private') || (network === 'privateLive')) {
-        //await deployer.deploy(Blacklist, { gasPrice: 0 });
+        // await deployer.deploy(Blacklist, { gasPrice: 0 });
     } else if (network === 'master') {
         // will filled later
     } else if (network === 'rinkeby') {
         // later
     } else {
-        await deployer.deploy(Orders, {gasLimit: 20000000});
-        await deployer.deploy(Deals, {gasLimit: 20000000});
-        await deployer.deploy(ChangeRequests, {gasLimit: 20000000})
+        deployer.deploy(Orders, { gasLimit: 20000000 });
+        deployer.deploy(Deals, { gasLimit: 20000000 });
+        deployer.deploy(ChangeRequests, { gasLimit: 20000000 });
     }
-  });
 };
diff --git a/blockchain/source/migrations/9_deploy_market.js b/blockchain/source/migrations/9_deploy_market.js
index 7f6fc05cb..95e709bc4 100644
--- a/blockchain/source/migrations/9_deploy_market.js
+++ b/blockchain/source/migrations/9_deploy_market.js
@@ -9,29 +9,35 @@ let Deals = artifacts.require('./Deals.sol');
 let ChangeRequests = artifacts.require('./ChangeRequests.sol');
 
 module.exports = function (deployer, network) {
-    deployer.then(async () => {
-      if ((network === 'private') || (network === 'privateLive')) {
-          // await deployer.deploy(Market,
-          //       SNM.address, // token address
-          //       Blacklist.address, // Blacklist address
-          //       OracleUSD.address, // Oracle address
-          //       ProfileRegistry.address, // ProfileRegistry address
-          //       Administratum.address,
-          //       Orders.address,
-          //       Deals.address,
-          //       ChangeRequests.address,
-          //       12, // benchmarks quantity
-          //       3, // netflags quantity
-          //       { gasPrice: 0 });
-          await deployer.deploy(Market, '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', 12, 3, {gasLimit: 99000000, gasPrice: 0});
-      } else if (network === 'master') {
-          // market haven't reason to deploy to mainnet
-      } else if (network === 'rinkeby') {
-          // market haven't reason to deploy to rinkeby
-          //await deployer.deploy(Market, '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', 12, 3, {gasLimit: 100000000, gasPrice: 1000000};
-      } else {
-        await deployer.deploy(Market, SNM.address, Blacklist.address, OracleUSD.address, ProfileRegistry.address, Administratum.address, Orders.address, Deals.address, ChangeRequests.address, 12, 3, {gasLimit: 1000000000});
-        //await deployer.deploy(Market, '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', '0x0', 12, 3, {gasLimit: 15000000, gasPrice: 1})
-      }
-   });
+    if ((network === 'private') || (network === 'privateLive')) {
+        deployer.deploy(Market,
+            SNM.address, // token address
+            Blacklist.address, // Blacklist address
+            OracleUSD.address, // Oracle address
+            ProfileRegistry.address, // ProfileRegistry address
+            Administratum.address,
+            Orders.address,
+            Deals.address,
+            ChangeRequests.address,
+            12, // benchmarks quantity
+            3, // netflags quantity
+            { gasPrice: 0 });
+    } else if (network === 'master') {
+        // market haven't reason to deploy to mainnet
+    } else if (network === 'rinkeby') {
+        // market haven't reason to deploy to rinkeby
+    } else {
+        deployer.deploy(Market,
+            SNM.address,
+            Blacklist.address,
+            OracleUSD.address,
+            ProfileRegistry.address,
+            Administratum.address,
+            Orders.address,
+            Deals.address,
+            ChangeRequests.address,
+            12,
+            3,
+            { gasLimit: 1000000000 });
+    }
 };
diff --git a/blockchain/source/test/blacklist.js b/blockchain/source/test/blacklist.js
index 6ba6244ef..e797df284 100644
--- a/blockchain/source/test/blacklist.js
+++ b/blockchain/source/test/blacklist.js
@@ -49,7 +49,7 @@ contract('Blacklist', async function (accounts) {
             changeRequests.address,
             12,
             3,
-            {gasLimit: 30000000});
+            { gasLimit: 30000000 });
     });
 
     it('test ACL', async function () {
diff --git a/blockchain/source/test/market.js b/blockchain/source/test/market.js
index 8864a4f00..75aab0ef4 100644
--- a/blockchain/source/test/market.js
+++ b/blockchain/source/test/market.js
@@ -80,7 +80,7 @@ contract('Market', async (accounts) => {
             changeRequests.address,
             benchmarkQuantity,
             netflagsQuantity,
-            {gasLimit: 30000000}
+            { gasLimit: 30000000 }
         );
 
         await administratum.transferOwnership(market.address);
diff --git a/blockchain/source/truffle.js b/blockchain/source/truffle.js
index 4068e2dd0..8ec701a3b 100644
--- a/blockchain/source/truffle.js
+++ b/blockchain/source/truffle.js
@@ -29,8 +29,8 @@ module.exports = {
             host: 'localhost',
             port: 8535,
             network_id: '*', // eslint-disable-line camelcase
-            gas: 8000000000 ,
-            gasPrice: 1
+            gas: 100000000,
+            gasPrice: 1,
         },
         coverage: {
             host: 'localhost',
@@ -38,7 +38,6 @@ module.exports = {
             port: 8555,
             gas: 0xfffffffffff,
             gasPrice: 0x01,
-            gas:200000000
         },
 
         master: {

From da992f45efc67b4d555c64e37a8fbb1e38e942b0 Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Thu, 1 Nov 2018 12:42:38 +0300
Subject: [PATCH 04/18] remove limit for da contract bytecode length

---
 blockchain/source/scripts/test.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/blockchain/source/scripts/test.sh b/blockchain/source/scripts/test.sh
index 2da036a27..769a28685 100755
--- a/blockchain/source/scripts/test.sh
+++ b/blockchain/source/scripts/test.sh
@@ -40,9 +40,9 @@ start_testrpc() {
   )
 
   if [ "$SOLIDITY_COVERAGE" = true ]; then
-    node_modules/.bin/testrpc-sc --gasLimit 0xfffffffffff --port "$testrpc_port" "${accounts[@]}" > /dev/null &
+    node_modules/.bin/testrpc-sc --gasLimit 0xfffffffffff --allowUnlimitedContractSize --port "$testrpc_port" "${accounts[@]}" > /dev/null &
   else
-    node_modules/.bin/ganache-cli --gasLimit 0xfffffffffff --port "$testrpc_port" "${accounts[@]}" > /dev/null &
+    node_modules/.bin/ganache-cli --gasLimit 0xfffffffffff --allowUnlimitedContractSize --port "$testrpc_port" "${accounts[@]}" > /dev/null &
   fi
 
   testrpc_pid=$!

From 1587b79b7259cfa4aa6fe51d4e8395f606920a72 Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Fri, 2 Nov 2018 16:21:12 +0300
Subject: [PATCH 05/18] some refactoring

---
 blockchain/source/contracts/Deals.sol  | 17 -----------------
 blockchain/source/contracts/Market.sol | 19 +++++++++----------
 2 files changed, 9 insertions(+), 27 deletions(-)

diff --git a/blockchain/source/contracts/Deals.sol b/blockchain/source/contracts/Deals.sol
index 0b7d640c3..f1e708b51 100644
--- a/blockchain/source/contracts/Deals.sol
+++ b/blockchain/source/contracts/Deals.sol
@@ -88,23 +88,6 @@ contract Deals is Ownable {
         return dealsAmount;
     }
 
-
-
-
-
-    /* function Close(uint dealID) public onlyOwner {
-        require(dealID >= dealsAmount);
-        deals[dealID].params.status = DealStatus.STATUS_CLOSED;
-        deals[dealID].params.endTime = block.timestamp;
-    }
-
-    function Bill(uint dealID, uint _balance, uint _totalPayout, uint _billTS) public onlyOwner {
-        require(dealID >= dealsAmount);
-        deals[dealID].params.blockedBalance = _balance;
-        deals[dealID].params.lastBillTS = _billTS;
-        deals[dealID].params.totalPayout = _totalPayout;
-    } */
-
     function SetDealBenchmarks(uint dealID, uint64[] _benchmarks) public onlyOwner {
         deals[dealID].info.benchmarks = _benchmarks;
     }
diff --git a/blockchain/source/contracts/Market.sol b/blockchain/source/contracts/Market.sol
index 8bae8977c..f8f28b832 100644
--- a/blockchain/source/contracts/Market.sol
+++ b/blockchain/source/contracts/Market.sol
@@ -499,7 +499,7 @@ contract Market is Ownable, Pausable {
 
     function ReserveNextPeriodFunds(uint dealID) internal returns (bool) {
         uint nextPeriod;
-        ( , address supplierID, address consumerID , , , , ) = dl.GetDealInfo(dealID);
+        address consumerID = dl.GetDealConsumerID(dealID);
 
         (uint duration, uint price, uint endTime, Deals.DealStatus status, uint blockedBalance, , ) = dl.GetDealParams(dealID);
 
@@ -527,7 +527,6 @@ contract Market is Ownable, Pausable {
                 require(token.transferFrom(consumerID, this, nextPeriodSum));
                 dl.SetDealBlockedBalance(dealID, blockedBalance.add(nextPeriodSum));
             } else {
-              // ?????
                 emit Billed(dealID, blockedBalance);
                 InternalCloseDeal(dealID);
                 RefundRemainingFunds(dealID);
@@ -538,9 +537,9 @@ contract Market is Ownable, Pausable {
     }
 
     function RefundRemainingFunds(uint dealID) internal returns (bool) {
-        ( , , address consumerID , , , , ) = dl.GetDealInfo(dealID);
+        address consumerID = dl.GetDealConsumerID(dealID);
 
-        (, , , , uint blockedBalance, , ) = dl.GetDealParams(dealID);
+        uint blockedBalance = dl.GetDealBlockedBalance(dealID);
 
         if (blockedBalance != 0) {
             token.transfer(consumerID, blockedBalance);
@@ -571,7 +570,7 @@ contract Market is Ownable, Pausable {
     function InternalCloseDeal(uint dealID) internal {
         ( , address supplierID, address consumerID, address masterID, , , ) = dl.GetDealInfo(dealID);
 
-        ( , , , Deals.DealStatus status, , , ) = dl.GetDealParams(dealID);
+        Deals.DealStatus status = dl.GetDealStatus(dealID);
 
         if (status == Deals.DealStatus.STATUS_CLOSED) {
             return;
@@ -601,17 +600,17 @@ contract Market is Ownable, Pausable {
 
     // SETTERS
 
-    function SetProfileRegistryAddress(address _newPR) onlyOwner public returns (bool) {
+    function SetProfileRegistryAddress(address _newPR) public onlyOwner returns (bool) {
         pr = ProfileRegistry(_newPR);
         return true;
     }
 
-    function SetBlacklistAddress(address _newBL) onlyOwner public returns (bool) {
+    function SetBlacklistAddress(address _newBL) public onlyOwner returns (bool) {
         bl = Blacklist(_newBL);
         return true;
     }
 
-    function SetOracleAddress(address _newOracle) onlyOwner public returns (bool) {
+    function SetOracleAddress(address _newOracle) public onlyOwner returns (bool) {
         require(OracleUSD(_newOracle).getCurrentPrice() != 0);
         oracle = OracleUSD(_newOracle);
         return true;
@@ -627,14 +626,14 @@ contract Market is Ownable, Pausable {
         return  true;
     }
 
-    function SetBenchmarksQuantity(uint _newQuantity) onlyOwner public returns (bool) {
+    function SetBenchmarksQuantity(uint _newQuantity) public onlyOwner returns (bool) {
         require(_newQuantity > benchmarksQuantity);
         emit NumBenchmarksUpdated(_newQuantity);
         benchmarksQuantity = _newQuantity;
         return true;
     }
 
-    function SetNetflagsQuantity(uint _newQuantity) onlyOwner public returns (bool) {
+    function SetNetflagsQuantity(uint _newQuantity) public onlyOwner returns (bool) {
         require(_newQuantity > netflagsQuantity);
         emit NumNetflagsUpdated(_newQuantity);
         netflagsQuantity = _newQuantity;

From 3c85c405575615b500d5b9623404b25b4836da2e Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Wed, 7 Nov 2018 15:18:52 +0300
Subject: [PATCH 06/18] feat: migrate func added

---
 blockchain/source/contracts/Market.sol | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/blockchain/source/contracts/Market.sol b/blockchain/source/contracts/Market.sol
index f8f28b832..5fb2fc63b 100644
--- a/blockchain/source/contracts/Market.sol
+++ b/blockchain/source/contracts/Market.sol
@@ -644,4 +644,13 @@ contract Market is Ownable, Pausable {
         token.transfer(owner, token.balanceOf(address(this)));
         selfdestruct(owner);
     }
+
+    function Migrate(address _newMarket) public onlyOwner returns (bool) {
+        token.transfer(_newMarket, token.balanceOf(address(this)));
+        ord.transferOwnership(_newMarket);
+        dl.transferOwnership(_newMarket);
+        cr.transferOwnership(_newMarket);
+        super.pause();
+
+    }
 }

From a1771a0515360e097eb5041200347557179ed354 Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Fri, 9 Nov 2018 18:59:04 +0300
Subject: [PATCH 07/18] some style mistakes fixed

---
 .../source/contracts/ChangeRequests.sol       |  6 ++--
 blockchain/source/contracts/Deals.sol         |  4 ++-
 blockchain/source/contracts/Market.sol        |  3 +-
 blockchain/source/contracts/OracleUSD.sol     |  4 +++
 blockchain/source/contracts/Orders.sol        | 30 +++++++++----------
 .../source/contracts/ProfileRegistry.sol      | 28 +++++++++++++++++
 .../contracts/SimpleGatekeeperWithLimit.sol   |  4 +++
 blockchain/source/contracts/TestnetFaucet.sol |  8 +++++
 8 files changed, 67 insertions(+), 20 deletions(-)

diff --git a/blockchain/source/contracts/ChangeRequests.sol b/blockchain/source/contracts/ChangeRequests.sol
index f68d411cf..844cbc643 100644
--- a/blockchain/source/contracts/ChangeRequests.sol
+++ b/blockchain/source/contracts/ChangeRequests.sol
@@ -106,14 +106,14 @@ contract ChangeRequests is Ownable {
         return requestsAmount;
     }
 
-    function GetChangeRequestInfo(uint changeRequestID) view public
-        returns (
+    function GetChangeRequestInfo(uint changeRequestID) public view
+    returns (
         uint dealID,
         Orders.OrderType requestType,
         uint price,
         uint duration,
         RequestStatus status
-        ) {
+    ) {
         return (
         requests[changeRequestID].dealID,
         requests[changeRequestID].requestType,
diff --git a/blockchain/source/contracts/Deals.sol b/blockchain/source/contracts/Deals.sol
index f1e708b51..e396c46b2 100644
--- a/blockchain/source/contracts/Deals.sol
+++ b/blockchain/source/contracts/Deals.sol
@@ -95,6 +95,7 @@ contract Deals is Ownable {
     function SetDealSupplierID(uint dealID, address _supplierID) public onlyOwner {
         deals[dealID].info.supplierID = _supplierID;
     }
+    
     function SetDealConsumerID(uint dealID, address _consumerID) public onlyOwner {
         deals[dealID].info.consumerID = _consumerID;
     }
@@ -138,6 +139,7 @@ contract Deals is Ownable {
     function SetDealPrice(uint dealID, uint _price) public onlyOwner {
         deals[dealID].params.price = _price;
     }
+
     function SetDealDuration(uint dealID, uint _duration) public onlyOwner {
         deals[dealID].params.duration = _duration;
     }
@@ -171,7 +173,7 @@ contract Deals is Ownable {
         );
     }
 
-    function GetDealParams(uint dealID) view public
+    function GetDealParams(uint dealID) public view
     returns (
         uint duration,
         uint price,
diff --git a/blockchain/source/contracts/Market.sol b/blockchain/source/contracts/Market.sol
index 5fb2fc63b..3d301cbe9 100644
--- a/blockchain/source/contracts/Market.sol
+++ b/blockchain/source/contracts/Market.sol
@@ -84,7 +84,8 @@ contract Market is Ownable, Pausable {
         address _deals,
         address _changeRequests,
         uint _benchmarksQuantity,
-        uint _netflagsQuantity) public {
+        uint _netflagsQuantity
+        ) public {
         token = SNM(_token);
         bl = Blacklist(_blacklist);
         oracle = OracleUSD(_oracle);
diff --git a/blockchain/source/contracts/OracleUSD.sol b/blockchain/source/contracts/OracleUSD.sol
index b1c3f7001..a1f34bce6 100644
--- a/blockchain/source/contracts/OracleUSD.sol
+++ b/blockchain/source/contracts/OracleUSD.sol
@@ -20,7 +20,11 @@ contract OracleUSD is Ownable {
         emit PriceChanged(_price);
     }
 
+<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function getCurrentPrice() public view returns (uint){
+=======
+    function getCurrentPrice()  public view returns (uint){
+>>>>>>> some style mistakes fixed
         return currentPrice;
     }
 }
diff --git a/blockchain/source/contracts/Orders.sol b/blockchain/source/contracts/Orders.sol
index a906d9e89..741f1a036 100644
--- a/blockchain/source/contracts/Orders.sol
+++ b/blockchain/source/contracts/Orders.sol
@@ -108,7 +108,7 @@ contract Orders is Ownable {
         return ordersAmount;
     }
 
-    function GetOrderInfo(uint orderID) view public
+    function GetOrderInfo(uint orderID) public view
     returns (
         OrderType orderType,
         address author,
@@ -137,51 +137,51 @@ contract Orders is Ownable {
         info.frozenSum
         );
     }
-    function GetOrderType(uint orderID) view public returns (OrderType) {
+    function GetOrderType(uint orderID) public view returns (OrderType) {
         return orders[orderID].info.orderType;
     }
 
-    function GetOrderAuthor(uint orderID) view public returns (address) {
+    function GetOrderAuthor(uint orderID) public view returns (address) {
         return orders[orderID].info.author;
     }
 
-    function GetOrderCounterparty(uint orderID) view public returns (address) {
+    function GetOrderCounterparty(uint orderID) public view returns (address) {
         return orders[orderID].info.counterparty;
     }
 
-    function GetOrderDuration(uint orderID) view public returns (uint) {
+    function GetOrderDuration(uint orderID) public view returns (uint) {
         return orders[orderID].info.duration;
     }
 
-    function GetOrderPrice(uint orderID) view public returns (uint) {
+    function GetOrderPrice(uint orderID) public view returns (uint) {
         return orders[orderID].info.price;
     }
 
-    function GetOrderNetflags(uint orderID) view public returns (bool[]) {
+    function GetOrderNetflags(uint orderID) public view returns (bool[]) {
         return orders[orderID].info.netflags;
     }
 
-    function GetOrderIdentityLevel(uint orderID) view public returns (ProfileRegistry.IdentityLevel) {
+    function GetOrderIdentityLevel(uint orderID) public view returns (ProfileRegistry.IdentityLevel) {
         return orders[orderID].info.identityLevel;
     }
 
-    function GetOrderBlacklist(uint orderID) view public returns (address) {
+    function GetOrderBlacklist(uint orderID) public view returns (address) {
         return orders[orderID].info.blacklist;
     }
 
-    function GetOrderTag(uint orderID) view public returns (bytes32) {
+    function GetOrderTag(uint orderID) public view returns (bytes32) {
         return orders[orderID].info.tag;
     }
 
-    function GetOrderBenchmarks(uint orderID) view public returns (uint64[]) {
+    function GetOrderBenchmarks(uint orderID) public view returns (uint64[]) {
         return orders[orderID].info.benchmarks;
     }
-    function GetOrderFrozenSum(uint orderID) view public returns (uint) {
+    function GetOrderFrozenSum(uint orderID) public view returns (uint) {
         return orders[orderID].info.frozenSum;
     }
 
 
-    function GetOrderParams(uint orderID) view public
+    function GetOrderParams(uint orderID) public view
     returns (
         OrderStatus orderStatus,
         uint dealID
@@ -193,11 +193,11 @@ contract Orders is Ownable {
         );
     }
 
-    function GetOrderStatus(uint orderID) view public returns (OrderStatus) {
+    function GetOrderStatus(uint orderID) public view returns (OrderStatus) {
         return orders[orderID].params.orderStatus;
     }
 
-    function GetOrderDealID(uint orderID) view public returns (uint) {
+    function GetOrderDealID(uint orderID) public view returns (uint) {
         return orders[orderID].params.dealID;
     }
 }
diff --git a/blockchain/source/contracts/ProfileRegistry.sol b/blockchain/source/contracts/ProfileRegistry.sol
index b6a7441d3..236e8e9e2 100644
--- a/blockchain/source/contracts/ProfileRegistry.sol
+++ b/blockchain/source/contracts/ProfileRegistry.sol
@@ -53,7 +53,11 @@ contract ProfileRegistry is Ownable, Pausable {
         validators[msg.sender] = - 1;
     }
 
+<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function AddValidator(address _validator, int8 _level) public onlySonm whenNotPaused returns (address) {
+=======
+    function AddValidator(address _validator, int8 _level) public onlySonm whenNotPaused returns (address){
+>>>>>>> some style mistakes fixed
         require(_level > 0);
         require(GetValidatorLevel(_validator) == 0);
         validators[_validator] = _level;
@@ -61,14 +65,22 @@ contract ProfileRegistry is Ownable, Pausable {
         return _validator;
     }
 
+<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function RemoveValidator(address _validator) public onlySonm whenNotPaused returns (address) {
+=======
+    function RemoveValidator(address _validator) public onlySonm whenNotPaused returns (address){
+>>>>>>> some style mistakes fixed
         require(GetValidatorLevel(_validator) > 0);
         validators[_validator] = 0;
         emit ValidatorDeleted(_validator);
         return _validator;
     }
 
+<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function GetValidatorLevel(address _validator) public view returns (int8) {
+=======
+    function GetValidatorLevel(address _validator) public view returns (int8){
+>>>>>>> some style mistakes fixed
         return validators[_validator];
     }
 
@@ -115,6 +127,7 @@ contract ProfileRegistry is Ownable, Pausable {
         emit CertificateUpdated(_id);
     }
 
+<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function GetCertificate(uint256 _id) public view returns (address, address, uint256, bytes) {
         return (certificates[_id].from, certificates[_id].to, certificates[_id].attributeType, certificates[_id].value);
     }
@@ -128,6 +141,21 @@ contract ProfileRegistry is Ownable, Pausable {
     }
 
     function GetProfileLevel(address _owner) public view returns (IdentityLevel) {
+=======
+    function GetCertificate(uint256 _id) public view returns (address, address, uint256, bytes){
+        return (certificates[_id].from, certificates[_id].to, certificates[_id].attributeType, certificates[_id].value);
+    }
+
+    function GetAttributeValue(address _owner, uint256 _type) public view returns (bytes){
+        return certificateValue[_owner][_type];
+    }
+
+    function GetAttributeCount(address _owner, uint256 _type) public view returns (uint256){
+        return certificateCount[_owner][_type];
+    }
+
+    function GetProfileLevel(address _owner) public view returns (IdentityLevel){
+>>>>>>> some style mistakes fixed
         if (GetAttributeValue(_owner, 1401).length > 0) {
             return IdentityLevel.PROFESSIONAL;
         } else if (GetAttributeValue(_owner, 1301).length > 0) {
diff --git a/blockchain/source/contracts/SimpleGatekeeperWithLimit.sol b/blockchain/source/contracts/SimpleGatekeeperWithLimit.sol
index 95ad1a469..d795a1710 100644
--- a/blockchain/source/contracts/SimpleGatekeeperWithLimit.sol
+++ b/blockchain/source/contracts/SimpleGatekeeperWithLimit.sol
@@ -123,7 +123,11 @@ contract SimpleGatekeeperWithLimit is Ownable {
         CommissionChanged(commission);
     }
 
+<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function GetCommission() public view returns (uint256){
+=======
+    function GetCommission() public view returns (uint256) {
+>>>>>>> some style mistakes fixed
         return commission;
     }
 
diff --git a/blockchain/source/contracts/TestnetFaucet.sol b/blockchain/source/contracts/TestnetFaucet.sol
index f954b58a3..864183394 100644
--- a/blockchain/source/contracts/TestnetFaucet.sol
+++ b/blockchain/source/contracts/TestnetFaucet.sol
@@ -19,12 +19,20 @@ contract TestnetFaucet is Ownable {
         return true;
     }
 
+<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function mintToken(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
+=======
+    function mintToken(address target, uint256 mintedAmount) public onlyOwner returns (bool){
+>>>>>>> some style mistakes fixed
         token.mint(target, mintedAmount);
         return true;
     }
 
+<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function() public payable{
+=======
+    function() public payable {
+>>>>>>> some style mistakes fixed
         getTokens();
     }
 

From 5e730d618bd6aaa05f42b3e24dd4dbd621d6781e Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Fri, 9 Nov 2018 18:59:25 +0300
Subject: [PATCH 08/18] crud for administratum

---
 blockchain/source/contracts/Administratum.sol | 73 ++++++-------------
 .../source/contracts/AdministratumCrud.sol    | 60 +++++++++++++++
 2 files changed, 82 insertions(+), 51 deletions(-)
 create mode 100644 blockchain/source/contracts/AdministratumCrud.sol

diff --git a/blockchain/source/contracts/Administratum.sol b/blockchain/source/contracts/Administratum.sol
index e56d3f576..7870c84de 100644
--- a/blockchain/source/contracts/Administratum.sol
+++ b/blockchain/source/contracts/Administratum.sol
@@ -1,59 +1,53 @@
 pragma solidity ^0.4.23;
 
 import "zeppelin-solidity/contracts/ownership/Ownable.sol";
+import "./AdministratumCrud.sol";
 
-contract Administratum is Ownable{
+contract Administratum is Ownable {
     // events
 
 
     event WorkerAnnounced(address indexed worker, address indexed master);
-    event WorkerConfirmed(address indexed worker, address indexed master);
+    event WorkerConfirmed(address indexed worker, address indexed master, address indexed confirmator);
     event WorkerRemoved(address indexed worker, address indexed master);
-    event adminAdded(address indexed admin, address indexed master);
+    event AdminAdded(address indexed admin, address indexed master);
 
     // storage
-    mapping(address => address) masterOf;
-
-    mapping(address => bool) isMaster;
 
     mapping(address => mapping(address => bool)) masterRequest;
 
-    //maps admin into its master; alternative method
-    //that's like asym cryptography, but implemented by design
-    mapping(address => address) admins;
-
-    mapping(address => bool) autoPayoutFlag;
+    AdministratumCrud crud;
 
-    uint public payoutSupremum;
 
     //constructor
-    constructor(){
+    constructor(address _administratumCrud){
         owner = msg.sender;
+        crud = AdministratumCrud(_administratumCrud);
     }
 
     //funcs
 
     function RegisterWorker(address _master) public returns (bool) {
-        require(GetMaster(msg.sender) == msg.sender);
-        require(isMaster[msg.sender] == false);
-        require(GetMaster(_master) == _master);
+        require(crud.GetMaster(msg.sender) == msg.sender);
+        require(!crud.isMaster(msg.sender));
+        require(crud.GetMaster(_master) == _master);
         masterRequest[_master][msg.sender] = true;
         emit WorkerAnnounced(msg.sender, _master);
         return true;
     }
 
     function ConfirmWorker(address _worker) public returns (bool) {
-        require(masterRequest[msg.sender][_worker] == true ||  IsValid(_worker));
-        masterOf[_worker] = msg.sender;
-        isMaster[msg.sender] = true;
+        require(masterRequest[msg.sender][_worker] == true || IsValid(_worker));
+        crud.SetMaster(_worker, msg.sender);
+        crud.SwitchToMaster(msg.sender);
         delete masterRequest[msg.sender][_worker];
-        emit WorkerConfirmed(_worker, msg.sender);
+        emit WorkerConfirmed(_worker, crud.GetMaster(_worker), msg.sender);
         return true;
     }
 
     function RemoveWorker(address _worker, address _master) public returns (bool) {
-        require(GetMaster(_worker) == _master && (msg.sender == _worker || msg.sender == _master));
-        delete masterOf[_worker];
+        require(crud.GetMaster(_worker) == _master && (msg.sender == _worker || msg.sender == _master));
+        crud.DeleteMaster(_worker);
         emit WorkerRemoved(_worker, _master);
         return true;
     }
@@ -61,46 +55,23 @@ contract Administratum is Ownable{
     function RegisterAdmin(address _admin) public returns (bool){
         require(GetMaster(msg.sender) == msg.sender);
         require(msg.sender != _admin);
-        admins[_admin] = msg.sender;
-        return true;
-    }
-
-    function EnableAutoPayout() public returns (bool){
-        require(GetMaster(msg.sender) == msg.sender);
-        autoPayoutFlag[msg.sender] = true;
-        return true;
-    }
-
-    function DisableAutoPayout() public returns (bool){
-        require(autoPayoutFlag[msg.sender] == true);
-        autoPayoutFlag[msg.sender] = false;
+        crud.SetAdmin(_admin, msg.sender);
         return true;
     }
 
 
     //INTERNAL
     // check if transaction sended by valid admin
-    function IsValid(address _worker) view internal returns(bool){
-        address master = admins[msg.sender];
-        return admins[msg.sender] != address(0) && masterRequest[master][_worker] == true;
+    function IsValid(address _worker) internal view returns(bool){
+        address master = crud.GetAdminMaster(msg.sender);
+        return master != address(0) && masterRequest[master][_worker] == true;
     }
 
 
     //GETTERS
-    function GetMaterOfAdmin(address _admin) view public returns (address){
-        return admins[_admin];
-    }
-
-    function GetMaster(address _worker) view public returns (address master) {
-        if (masterOf[_worker] == 0x0 || masterOf[_worker] == _worker) {
-            master = _worker;
-        } else {
-            master = masterOf[_worker];
-        }
-    }
 
-    function GetAutoPayoutFlag(address _master) view public returns (bool) {
-        return autoPayoutFlag[_master];
+    function GetMaster(address _worker) public view returns (address master) {
+        return  crud.GetMaster(_worker);
     }
 
     //modifiers
diff --git a/blockchain/source/contracts/AdministratumCrud.sol b/blockchain/source/contracts/AdministratumCrud.sol
new file mode 100644
index 000000000..abe225630
--- /dev/null
+++ b/blockchain/source/contracts/AdministratumCrud.sol
@@ -0,0 +1,60 @@
+pragma solidity ^0.4.23;
+
+import "zeppelin-solidity/contracts/ownership/Ownable.sol";
+
+contract AdministratumCrud is Ownable {
+    // events
+
+
+    event WorkerAnnounced(address indexed worker, address indexed master);
+    event WorkerConfirmed(address indexed worker, address indexed master);
+    event WorkerRemoved(address indexed worker, address indexed master);
+    event AdminAdded(address indexed admin, address indexed master);
+
+    // storage
+    mapping(address => address) masterOf;
+
+    mapping(address => bool) flagIsMaster;
+
+    mapping(address => mapping(address => bool)) masterRequest;
+
+    //maps admin into its master; alternative method
+    //that's like asym cryptography, but implemented by design
+    mapping(address => address) admins;
+
+    //constructor
+    constructor(){
+        owner = msg.sender;
+    }
+
+    function SetMaster(address _worker, address _master) public onlyOwner {
+        masterOf[_worker] = _master;
+    }
+
+    function SetAdmin(address _admin, address _master) public onlyOwner {
+        admins[_admin] = _master;
+    }
+
+    function DeleteMaster(address _worker) public onlyOwner {
+        delete masterOf[_worker];
+    }
+
+    function SwitchToMaster(address _target) public onlyOwner {
+        flagIsMaster[_target] = true;
+    }
+
+    function GetMaster(address _worker) public view returns (address) {
+        if (masterOf[_worker] == address(0) || flagIsMaster[_worker] == true){
+            return _worker;
+        }
+        return masterOf[_worker];
+    }
+
+    function GetAdminMaster(address _admin) public view returns (address) {
+        return admins[_admin];
+    }
+
+    function isMaster(address _address) public view returns (bool) {
+        return flagIsMaster[_address];
+    }
+}

From cd5b55934591c0955bb4adcc22977cb92f14b13d Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Fri, 9 Nov 2018 18:59:47 +0300
Subject: [PATCH 09/18] and update its migrations

---
 blockchain/source/migrations/7_deploy_crud.js          | 2 ++
 blockchain/source/migrations/8_deploy_administratum.js | 3 ++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/blockchain/source/migrations/7_deploy_crud.js b/blockchain/source/migrations/7_deploy_crud.js
index 07f6ff2ff..00563aec2 100644
--- a/blockchain/source/migrations/7_deploy_crud.js
+++ b/blockchain/source/migrations/7_deploy_crud.js
@@ -1,6 +1,7 @@
 let Orders = artifacts.require('./Orders.sol');
 let Deals = artifacts.require('./Deals.sol');
 let ChangeRequests = artifacts.require('./ChangeRequests.sol');
+let AdministratumCrud = artifacts.require('./AdministratumCrud.sol');
 
 module.exports = function (deployer, network) {
     if ((network === 'private') || (network === 'privateLive')) {
@@ -13,5 +14,6 @@ module.exports = function (deployer, network) {
         deployer.deploy(Orders, { gasLimit: 20000000 });
         deployer.deploy(Deals, { gasLimit: 20000000 });
         deployer.deploy(ChangeRequests, { gasLimit: 20000000 });
+        deployer.deploy(AdministratumCrud, { gasLimit: 10000000 });
     }
 };
diff --git a/blockchain/source/migrations/8_deploy_administratum.js b/blockchain/source/migrations/8_deploy_administratum.js
index 251363d0b..013030975 100644
--- a/blockchain/source/migrations/8_deploy_administratum.js
+++ b/blockchain/source/migrations/8_deploy_administratum.js
@@ -1,3 +1,4 @@
+let AdministratumCrud = artifacts.require('./AdministratumCrud.sol');
 let Administratum = artifacts.require('./Administratum.sol');
 
 module.exports = function (deployer, network) {
@@ -8,6 +9,6 @@ module.exports = function (deployer, network) {
     } else if (network === 'rinkeby') {
         // later
     } else {
-        deployer.deploy(Administratum);
+        deployer.deploy(Administratum, AdministratumCrud.address);
     }
 };

From d459acc7afd326e0500ce51af9eb3adca737344c Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Fri, 9 Nov 2018 19:00:06 +0300
Subject: [PATCH 10/18] and update its tests

---
 blockchain/source/test/blacklist.js | 5 ++++-
 blockchain/source/test/market.js    | 6 +++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/blockchain/source/test/blacklist.js b/blockchain/source/test/blacklist.js
index e797df284..704583429 100644
--- a/blockchain/source/test/blacklist.js
+++ b/blockchain/source/test/blacklist.js
@@ -8,6 +8,7 @@ const ProfileRegistry = artifacts.require('./ProfileRegistry.sol');
 const Orders = artifacts.require('./Orders.sol');
 const Deals = artifacts.require('./Deals.sol');
 const ChangeRequests = artifacts.require('./ChangeRequests.sol');
+const AdministratumCrud = artifacts.require('./AdministratumCrud.sol');
 const Administratum = artifacts.require('./Administratum.sol');
 
 contract('Blacklist', async function (accounts) {
@@ -16,6 +17,7 @@ contract('Blacklist', async function (accounts) {
     let token;
     let oracle;
     let pr;
+    let administratumCrud;
     let administratum;
     let orders;
     let deals;
@@ -34,7 +36,8 @@ contract('Blacklist', async function (accounts) {
         oracle = await OracleUSD.new();
         pr = await ProfileRegistry.new();
         await blacklist.AddMaster(master, { from: owner });
-        administratum = await Administratum.new();
+        administratumCrud = await AdministratumCrud.new();
+        administratum = await Administratum.new(administratumCrud.address);
         orders = await Orders.new();
         deals = await Deals.new();
         changeRequests = await ChangeRequests.new();
diff --git a/blockchain/source/test/market.js b/blockchain/source/test/market.js
index 75aab0ef4..207d36f3b 100644
--- a/blockchain/source/test/market.js
+++ b/blockchain/source/test/market.js
@@ -34,6 +34,7 @@ const ProfileRegistry = artifacts.require('./ProfileRegistry.sol');
 const Orders = artifacts.require('./Orders.sol');
 const Deals = artifacts.require('./Deals.sol');
 const ChangeRequests = artifacts.require('./ChangeRequests.sol');
+const AdministratumCrud = artifacts.require('./AdministratumCrud.sol');
 const Administratum = artifacts.require('./Administratum.sol');
 
 const ONE_MILLION_TOKEN = 1e6 * 1e18;
@@ -44,6 +45,7 @@ contract('Market', async (accounts) => {
     let oracle;
     let blacklist;
     let profileRegistry;
+    let administratumCrud;
     let administratum;
     let orders;
     let deals;
@@ -65,7 +67,8 @@ contract('Market', async (accounts) => {
         await oracle.setCurrentPrice(oraclePrice);
         blacklist = await Blacklist.new();
         profileRegistry = await ProfileRegistry.new();
-        administratum = await Administratum.new();
+        administratumCrud = await AdministratumCrud.new();
+        administratum = await Administratum.new(administratumCrud.address);
         orders = await Orders.new();
         deals = await Deals.new();
         changeRequests = await ChangeRequests.new();
@@ -83,6 +86,7 @@ contract('Market', async (accounts) => {
             { gasLimit: 30000000 }
         );
 
+        await administratumCrud.transferOwnership(administratum.address);
         await administratum.transferOwnership(market.address);
         await orders.transferOwnership(market.address);
         await deals.transferOwnership(market.address);

From e4070701497eebc3605b24aa5bd743a920d8a2f3 Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Mon, 12 Nov 2018 16:27:47 +0300
Subject: [PATCH 11/18] clean

---
 blockchain/source/contracts/Administratum.sol |  11 +-
 .../source/contracts/AdministratumCrud.sol    |   3 +-
 blockchain/source/contracts/Deals.sol         |   3 +-
 blockchain/source/contracts/Market.sol        | 360 +++++++++---------
 blockchain/source/contracts/OracleUSD.sol     |   6 +-
 .../source/contracts/ProfileRegistry.sol      |  28 --
 .../contracts/SimpleGatekeeperWithLimit.sol   |   4 -
 blockchain/source/contracts/TestnetFaucet.sol |   8 -
 .../migrations/10_set_market_for_blacklist.js |  14 +-
 blockchain/source/truffle.js                  |   1 -
 10 files changed, 199 insertions(+), 239 deletions(-)

diff --git a/blockchain/source/contracts/Administratum.sol b/blockchain/source/contracts/Administratum.sol
index 7870c84de..bf6adb089 100644
--- a/blockchain/source/contracts/Administratum.sol
+++ b/blockchain/source/contracts/Administratum.sol
@@ -4,9 +4,8 @@ import "zeppelin-solidity/contracts/ownership/Ownable.sol";
 import "./AdministratumCrud.sol";
 
 contract Administratum is Ownable {
-    // events
-
 
+    // events
     event WorkerAnnounced(address indexed worker, address indexed master);
     event WorkerConfirmed(address indexed worker, address indexed master, address indexed confirmator);
     event WorkerRemoved(address indexed worker, address indexed master);
@@ -59,6 +58,11 @@ contract Administratum is Ownable {
         return true;
     }
 
+    function Migrate (address _newAdministratum) public onlyOwner {
+        crud.transferOwnership(_newAdministratum);
+        suicide(msg.sender);
+    }
+
 
     //INTERNAL
     // check if transaction sended by valid admin
@@ -74,6 +78,9 @@ contract Administratum is Ownable {
         return  crud.GetMaster(_worker);
     }
 
+
+
+
     //modifiers
 
 
diff --git a/blockchain/source/contracts/AdministratumCrud.sol b/blockchain/source/contracts/AdministratumCrud.sol
index abe225630..53f820b78 100644
--- a/blockchain/source/contracts/AdministratumCrud.sol
+++ b/blockchain/source/contracts/AdministratumCrud.sol
@@ -3,9 +3,8 @@ pragma solidity ^0.4.23;
 import "zeppelin-solidity/contracts/ownership/Ownable.sol";
 
 contract AdministratumCrud is Ownable {
-    // events
-
 
+    // events
     event WorkerAnnounced(address indexed worker, address indexed master);
     event WorkerConfirmed(address indexed worker, address indexed master);
     event WorkerRemoved(address indexed worker, address indexed master);
diff --git a/blockchain/source/contracts/Deals.sol b/blockchain/source/contracts/Deals.sol
index e396c46b2..e298c1634 100644
--- a/blockchain/source/contracts/Deals.sol
+++ b/blockchain/source/contracts/Deals.sol
@@ -17,7 +17,6 @@ contract Deals is Ownable {
     struct Deal {
         DealInfo info;
         DealParams params;
-
     }
 
     struct DealInfo {
@@ -95,7 +94,7 @@ contract Deals is Ownable {
     function SetDealSupplierID(uint dealID, address _supplierID) public onlyOwner {
         deals[dealID].info.supplierID = _supplierID;
     }
-    
+
     function SetDealConsumerID(uint dealID, address _consumerID) public onlyOwner {
         deals[dealID].info.consumerID = _consumerID;
     }
diff --git a/blockchain/source/contracts/Market.sol b/blockchain/source/contracts/Market.sol
index 3d301cbe9..4bb5ec6e3 100644
--- a/blockchain/source/contracts/Market.sol
+++ b/blockchain/source/contracts/Market.sol
@@ -55,15 +55,15 @@ contract Market is Ownable, Pausable {
 
     OracleUSD oracle;
 
-    ProfileRegistry pr;
+    ProfileRegistry profiles;
 
-    Orders ord;
+    Orders ordersCrud;
 
-    Administratum adm;
+    Administratum administratum;
 
-    Deals dl;
+    Deals dealsCrud;
 
-    ChangeRequests cr;
+    ChangeRequests changeRequestsCrud;
 
     uint requestsAmount = 0;
 
@@ -89,11 +89,11 @@ contract Market is Ownable, Pausable {
         token = SNM(_token);
         bl = Blacklist(_blacklist);
         oracle = OracleUSD(_oracle);
-        pr = ProfileRegistry(_profileRegistry);
-        adm = Administratum(_administratum);
-        ord = Orders(_orders);
-        dl = Deals(_deals);
-        cr = ChangeRequests(_changeRequests);
+        profiles = ProfileRegistry(_profileRegistry);
+        administratum = Administratum(_administratum);
+        ordersCrud = Orders(_orders);
+        dealsCrud = Deals(_deals);
+        changeRequestsCrud = ChangeRequests(_changeRequests);
         benchmarksQuantity = _benchmarksQuantity;
         netflagsQuantity = _netflagsQuantity;
     }
@@ -136,7 +136,7 @@ contract Market is Ownable, Pausable {
         }
 
 
-        ord.Write(
+        ordersCrud.Write(
             _orderType,
             Orders.OrderStatus.ORDER_ACTIVE,
             msg.sender,
@@ -152,27 +152,27 @@ contract Market is Ownable, Pausable {
             0
         );
 
-        emit OrderPlaced(ord.GetOrdersAmount());
+        emit OrderPlaced(ordersCrud.GetOrdersAmount());
 
-        return ord.GetOrdersAmount();
+        return ordersCrud.GetOrdersAmount();
     }
 
     function CancelOrder(uint orderID) public returns (bool) {
-        require(orderID <= ord.GetOrdersAmount());
+        require(orderID <= ordersCrud.GetOrdersAmount());
 
-        address author = ord.GetOrderAuthor(orderID);
+        address author = ordersCrud.GetOrderAuthor(orderID);
 
-        uint frozenSum = ord.GetOrderFrozenSum(orderID);
+        uint frozenSum = ordersCrud.GetOrderFrozenSum(orderID);
 
-        Orders.OrderStatus orderStatus = ord.GetOrderStatus(orderID);
+        Orders.OrderStatus orderStatus = ordersCrud.GetOrderStatus(orderID);
 
 
         require(orderStatus == Orders.OrderStatus.ORDER_ACTIVE);
-        require(author == msg.sender || adm.GetMaster(author) == msg.sender);
+        require(author == msg.sender || administratum.GetMaster(author) == msg.sender);
 
         require(token.transfer(msg.sender, frozenSum));
 
-        ord.SetOrderStatus(orderID, Orders.OrderStatus.ORDER_INACTIVE);
+        ordersCrud.SetOrderStatus(orderID, Orders.OrderStatus.ORDER_INACTIVE);
 
         emit OrderUpdated(orderID);
 
@@ -181,59 +181,59 @@ contract Market is Ownable, Pausable {
 
     function QuickBuy(uint askID, uint buyoutDuration) public whenNotPaused {
 
-        require(ord.GetOrderType(askID) == Orders.OrderType.ORDER_ASK);
-        require(ord.GetOrderStatus(askID) == Orders.OrderStatus.ORDER_ACTIVE);
+        require(ordersCrud.GetOrderType(askID) == Orders.OrderType.ORDER_ASK);
+        require(ordersCrud.GetOrderStatus(askID) == Orders.OrderStatus.ORDER_ACTIVE);
 
-        require(ord.GetOrderDuration(askID) >= buyoutDuration);
-        require(pr.GetProfileLevel(msg.sender) >= ord.GetOrderIdentityLevel(askID));
-        require(bl.Check(ord.GetOrderBlacklist(askID), msg.sender) == false);
+        require(ordersCrud.GetOrderDuration(askID) >= buyoutDuration);
+        require(profiles.GetProfileLevel(msg.sender) >= ordersCrud.GetOrderIdentityLevel(askID));
+        require(bl.Check(ordersCrud.GetOrderBlacklist(askID), msg.sender) == false);
         require(
-            bl.Check(msg.sender, adm.GetMaster(ord.GetOrderAuthor(askID))) == false
-            && bl.Check(ord.GetOrderAuthor(askID), msg.sender) == false);
+            bl.Check(msg.sender, administratum.GetMaster(ordersCrud.GetOrderAuthor(askID))) == false
+            && bl.Check(ordersCrud.GetOrderAuthor(askID), msg.sender) == false);
 
         PlaceOrder(
             Orders.OrderType.ORDER_BID,
-            adm.GetMaster(ord.GetOrderAuthor(askID)),
+            administratum.GetMaster(ordersCrud.GetOrderAuthor(askID)),
             buyoutDuration,
-            ord.GetOrderPrice(askID),
-            ord.GetOrderNetflags(askID),
+            ordersCrud.GetOrderPrice(askID),
+            ordersCrud.GetOrderNetflags(askID),
             ProfileRegistry.IdentityLevel.ANONYMOUS,
             address(0),
             bytes32(0),
-            ord.GetOrderBenchmarks(askID));
+            ordersCrud.GetOrderBenchmarks(askID));
 
-        OpenDeal(askID, ord.GetOrdersAmount());
+        OpenDeal(askID, ordersCrud.GetOrdersAmount());
     }
 
     // Deal functions
 
     function OpenDeal(uint _askID, uint _bidID) whenNotPaused public {
         require(
-            ord.GetOrderStatus(_askID) == Orders.OrderStatus.ORDER_ACTIVE
-            && ord.GetOrderStatus(_bidID) == Orders.OrderStatus.ORDER_ACTIVE);
-        require(ord.GetOrderCounterparty(_askID) == 0x0 || ord.GetOrderCounterparty(_askID) == adm.GetMaster(ord.GetOrderAuthor(_bidID)));
-        require(ord.GetOrderCounterparty(_bidID) == 0x0 || ord.GetOrderCounterparty(_bidID) == adm.GetMaster(ord.GetOrderAuthor(_askID)));
-        require(ord.GetOrderType(_askID) == Orders.OrderType.ORDER_ASK);
-        require(ord.GetOrderType(_bidID) == Orders.OrderType.ORDER_BID);
-        require(!bl.Check(ord.GetOrderBlacklist(_bidID), adm.GetMaster(ord.GetOrderAuthor(_askID))));
-        require(!bl.Check(ord.GetOrderBlacklist(_bidID), ord.GetOrderAuthor(_askID)));
-        require(!bl.Check(ord.GetOrderAuthor(_bidID), adm.GetMaster(ord.GetOrderAuthor(_askID))));
-        require(!bl.Check(ord.GetOrderAuthor(_bidID), ord.GetOrderAuthor(_askID)));
-        require(!bl.Check(ord.GetOrderBlacklist(_askID), ord.GetOrderAuthor(_bidID)));
-        require(!bl.Check(adm.GetMaster(ord.GetOrderAuthor(_askID)), ord.GetOrderAuthor(_bidID)));
-        require(!bl.Check(ord.GetOrderAuthor(_askID), ord.GetOrderAuthor(_bidID)));
-        require(ord.GetOrderPrice(_askID) <= ord.GetOrderPrice(_bidID));
-        require(ord.GetOrderDuration(_askID) >= ord.GetOrderDuration(_bidID));
+            ordersCrud.GetOrderStatus(_askID) == Orders.OrderStatus.ORDER_ACTIVE
+            && ordersCrud.GetOrderStatus(_bidID) == Orders.OrderStatus.ORDER_ACTIVE);
+        require(ordersCrud.GetOrderCounterparty(_askID) == 0x0 || ordersCrud.GetOrderCounterparty(_askID) == administratum.GetMaster(ordersCrud.GetOrderAuthor(_bidID)));
+        require(ordersCrud.GetOrderCounterparty(_bidID) == 0x0 || ordersCrud.GetOrderCounterparty(_bidID) == administratum.GetMaster(ordersCrud.GetOrderAuthor(_askID)));
+        require(ordersCrud.GetOrderType(_askID) == Orders.OrderType.ORDER_ASK);
+        require(ordersCrud.GetOrderType(_bidID) == Orders.OrderType.ORDER_BID);
+        require(!bl.Check(ordersCrud.GetOrderBlacklist(_bidID), administratum.GetMaster(ordersCrud.GetOrderAuthor(_askID))));
+        require(!bl.Check(ordersCrud.GetOrderBlacklist(_bidID), ordersCrud.GetOrderAuthor(_askID)));
+        require(!bl.Check(ordersCrud.GetOrderAuthor(_bidID), administratum.GetMaster(ordersCrud.GetOrderAuthor(_askID))));
+        require(!bl.Check(ordersCrud.GetOrderAuthor(_bidID), ordersCrud.GetOrderAuthor(_askID)));
+        require(!bl.Check(ordersCrud.GetOrderBlacklist(_askID), ordersCrud.GetOrderAuthor(_bidID)));
+        require(!bl.Check(administratum.GetMaster(ordersCrud.GetOrderAuthor(_askID)), ordersCrud.GetOrderAuthor(_bidID)));
+        require(!bl.Check(ordersCrud.GetOrderAuthor(_askID), ordersCrud.GetOrderAuthor(_bidID)));
+        require(ordersCrud.GetOrderPrice(_askID) <= ordersCrud.GetOrderPrice(_bidID));
+        require(ordersCrud.GetOrderDuration(_askID) >= ordersCrud.GetOrderDuration(_bidID));
         // profile level check
-        require(pr.GetProfileLevel(ord.GetOrderAuthor(_bidID)) >= ord.GetOrderIdentityLevel(_askID));
-        require(pr.GetProfileLevel(adm.GetMaster(ord.GetOrderAuthor(_askID))) >= ord.GetOrderIdentityLevel(_bidID)); //bug
+        require(profiles.GetProfileLevel(ordersCrud.GetOrderAuthor(_bidID)) >= ordersCrud.GetOrderIdentityLevel(_askID));
+        require(profiles.GetProfileLevel(administratum.GetMaster(ordersCrud.GetOrderAuthor(_askID))) >= ordersCrud.GetOrderIdentityLevel(_bidID)); //bug
 
-        bool[] memory askNetflags = ord.GetOrderNetflags(_askID);
+        bool[] memory askNetflags = ordersCrud.GetOrderNetflags(_askID);
         if (askNetflags.length < netflagsQuantity) {
             askNetflags = ResizeNetflags(askNetflags);
         }
 
-        bool[] memory bidNetflags = ord.GetOrderNetflags(_bidID);
+        bool[] memory bidNetflags = ordersCrud.GetOrderNetflags(_bidID);
         if (bidNetflags.length < netflagsQuantity) {
             bidNetflags = ResizeNetflags(bidNetflags);
         }
@@ -244,12 +244,12 @@ contract Market is Ownable, Pausable {
             require(!bidNetflags[i] || askNetflags[i]);
         }
 
-        uint64[] memory askBenchmarks = ord.GetOrderBenchmarks(_askID);
+        uint64[] memory askBenchmarks = ordersCrud.GetOrderBenchmarks(_askID);
         if (askBenchmarks.length < benchmarksQuantity) {
             askBenchmarks = ResizeBenchmarks(askBenchmarks);
         }
 
-        uint64[] memory bidBenchmarks = ord.GetOrderBenchmarks(_bidID);
+        uint64[] memory bidBenchmarks = ordersCrud.GetOrderBenchmarks(_bidID);
         if (bidBenchmarks.length < benchmarksQuantity) {
             bidBenchmarks = ResizeBenchmarks(bidBenchmarks);
         }
@@ -258,55 +258,55 @@ contract Market is Ownable, Pausable {
             require(askBenchmarks[i] >= bidBenchmarks[i]);
         }
 
-        ord.SetOrderStatus(_askID, Orders.OrderStatus.ORDER_INACTIVE);
-        ord.SetOrderStatus(_bidID, Orders.OrderStatus.ORDER_INACTIVE);
+        ordersCrud.SetOrderStatus(_askID, Orders.OrderStatus.ORDER_INACTIVE);
+        ordersCrud.SetOrderStatus(_bidID, Orders.OrderStatus.ORDER_INACTIVE);
 
         emit OrderUpdated(_askID);
         emit OrderUpdated(_bidID);
 
 
         // if deal is normal
-        if (ord.GetOrderDuration(_askID) != 0) {
-            uint endTime = block.timestamp.add(ord.GetOrderDuration(_bidID));
+        if (ordersCrud.GetOrderDuration(_askID) != 0) {
+            uint endTime = block.timestamp.add(ordersCrud.GetOrderDuration(_bidID));
         } else {
             endTime = 0;
             // `0` - for spot deal
         }
 
-        dl.IncreaseDealsAmount();
+        dealsCrud.IncreaseDealsAmount();
 
-        uint dealID = dl.GetDealsAmount();
+        uint dealID = dealsCrud.GetDealsAmount();
 
-        dl.SetDealBenchmarks(dealID, askBenchmarks);
-        dl.SetDealConsumerID(dealID, ord.GetOrderAuthor(_bidID));
-        dl.SetDealSupplierID(dealID, ord.GetOrderAuthor(_askID));
-        dl.SetDealMasterID(dealID, adm.GetMaster(ord.GetOrderAuthor(_askID)));
-        dl.SetDealAskID(dealID, _askID);
-        dl.SetDealBidID(dealID, _bidID);
-        dl.SetDealDuration(dealID, ord.GetOrderDuration(_bidID));
-        dl.SetDealPrice(dealID, ord.GetOrderPrice(_askID));
-        dl.SetDealStartTime(dealID, block.timestamp);
-        dl.SetDealEndTime(dealID, endTime);
-        dl.SetDealStatus(dealID, Deals.DealStatus.STATUS_ACCEPTED);
-        dl.SetDealBlockedBalance(dealID, ord.GetOrderFrozenSum(_bidID));
-        dl.SetDealTotalPayout(dealID, 0);
-        dl.SetDealLastBillTS(dealID, block.timestamp);
+        dealsCrud.SetDealBenchmarks(dealID, askBenchmarks);
+        dealsCrud.SetDealConsumerID(dealID, ordersCrud.GetOrderAuthor(_bidID));
+        dealsCrud.SetDealSupplierID(dealID, ordersCrud.GetOrderAuthor(_askID));
+        dealsCrud.SetDealMasterID(dealID, administratum.GetMaster(ordersCrud.GetOrderAuthor(_askID)));
+        dealsCrud.SetDealAskID(dealID, _askID);
+        dealsCrud.SetDealBidID(dealID, _bidID);
+        dealsCrud.SetDealDuration(dealID, ordersCrud.GetOrderDuration(_bidID));
+        dealsCrud.SetDealPrice(dealID, ordersCrud.GetOrderPrice(_askID));
+        dealsCrud.SetDealStartTime(dealID, block.timestamp);
+        dealsCrud.SetDealEndTime(dealID, endTime);
+        dealsCrud.SetDealStatus(dealID, Deals.DealStatus.STATUS_ACCEPTED);
+        dealsCrud.SetDealBlockedBalance(dealID, ordersCrud.GetOrderFrozenSum(_bidID));
+        dealsCrud.SetDealTotalPayout(dealID, 0);
+        dealsCrud.SetDealLastBillTS(dealID, block.timestamp);
 
 
 
-        emit DealOpened(dl.GetDealsAmount());
+        emit DealOpened(dealsCrud.GetDealsAmount());
 
-        ord.SetOrderDealID(_askID, dealID);
-        ord.SetOrderDealID(_bidID, dealID);
+        ordersCrud.SetOrderDealID(_askID, dealID);
+        ordersCrud.SetOrderDealID(_bidID, dealID);
     }
 
     function CloseDeal(uint dealID, BlacklistPerson blacklisted) public returns (bool){
-        require((dl.GetDealStatus(dealID) == Deals.DealStatus.STATUS_ACCEPTED));
-        require(msg.sender == dl.GetDealSupplierID(dealID) || msg.sender == dl.GetDealConsumerID(dealID) || msg.sender == dl.GetDealMasterID(dealID));
+        require((dealsCrud.GetDealStatus(dealID) == Deals.DealStatus.STATUS_ACCEPTED));
+        require(msg.sender == dealsCrud.GetDealSupplierID(dealID) || msg.sender == dealsCrud.GetDealConsumerID(dealID) || msg.sender == dealsCrud.GetDealMasterID(dealID));
 
-        if (block.timestamp <= dl.GetDealStartTime(dealID).add(dl.GetDealDuration(dealID))) {
+        if (block.timestamp <= dealsCrud.GetDealStartTime(dealID).add(dealsCrud.GetDealDuration(dealID))) {
             // after endTime
-            require(dl.GetDealConsumerID(dealID) == msg.sender);
+            require(dealsCrud.GetDealConsumerID(dealID) == msg.sender);
         }
         AddToBlacklist(dealID, blacklisted);
         InternalBill(dealID);
@@ -324,119 +324,119 @@ contract Market is Ownable, Pausable {
     function CreateChangeRequest(uint dealID, uint newPrice, uint newDuration) public returns (uint changeRequestID) {
 
         require(
-            msg.sender == dl.GetDealConsumerID(dealID)
-            || msg.sender ==  dl.GetDealMasterID(dealID)
-            || msg.sender == dl.GetDealSupplierID(dealID));
-        require(dl.GetDealStatus(dealID) == Deals.DealStatus.STATUS_ACCEPTED);
+            msg.sender == dealsCrud.GetDealConsumerID(dealID)
+            || msg.sender ==  dealsCrud.GetDealMasterID(dealID)
+            || msg.sender == dealsCrud.GetDealSupplierID(dealID));
+        require(dealsCrud.GetDealStatus(dealID) == Deals.DealStatus.STATUS_ACCEPTED);
 
-        if (dl.GetDealDuration(dealID) == 0) {
+        if (dealsCrud.GetDealDuration(dealID) == 0) {
             require(newDuration == 0);
         }
 
 
         Orders.OrderType requestType;
 
-        if (msg.sender == dl.GetDealConsumerID(dealID)) {
+        if (msg.sender == dealsCrud.GetDealConsumerID(dealID)) {
             requestType = Orders.OrderType.ORDER_BID;
         } else {
             requestType = Orders.OrderType.ORDER_ASK;
         }
 
-        uint currentID = cr.Write(dealID, requestType, newPrice, newDuration, ChangeRequests.RequestStatus.REQUEST_CREATED);
+        uint currentID = changeRequestsCrud.Write(dealID, requestType, newPrice, newDuration, ChangeRequests.RequestStatus.REQUEST_CREATED);
         emit DealChangeRequestSet(currentID);
 
         if (requestType == Orders.OrderType.ORDER_BID) {
-            uint oldID = cr.GetActualChangeRequest(dealID, 1);
-            uint matchingID = cr.GetActualChangeRequest(dealID, 0);
+            uint oldID = changeRequestsCrud.GetActualChangeRequest(dealID, 1);
+            uint matchingID = changeRequestsCrud.GetActualChangeRequest(dealID, 0);
             emit DealChangeRequestUpdated(oldID);
-            cr.SetChangeRequestStatus(oldID, ChangeRequests.RequestStatus.REQUEST_CANCELED);
-            cr.SetActualChangeRequest(dealID, 1, currentID);
+            changeRequestsCrud.SetChangeRequestStatus(oldID, ChangeRequests.RequestStatus.REQUEST_CANCELED);
+            changeRequestsCrud.SetActualChangeRequest(dealID, 1, currentID);
 
-            if (newDuration == dl.GetDealDuration(dealID) && newPrice > dl.GetDealPrice(dealID)) {
-                cr.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+            if (newDuration == dealsCrud.GetDealDuration(dealID) && newPrice > dealsCrud.GetDealPrice(dealID)) {
+                changeRequestsCrud.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
                 Bill(dealID);
-                dl.SetDealPrice(dealID, newPrice);
-                cr.SetActualChangeRequest(dealID, 1, 0);
+                dealsCrud.SetDealPrice(dealID, newPrice);
+                changeRequestsCrud.SetActualChangeRequest(dealID, 1, 0);
                 emit DealChangeRequestUpdated(requestsAmount);
-            } else if (cr.GetChangeRequestStatus(matchingID) == ChangeRequests.RequestStatus.REQUEST_CREATED
-                    && cr.GetChangeRequestDuration(matchingID) >= newDuration
-                    && cr.GetChangeRequestPrice(matchingID) <= newPrice) {
-
-                cr.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
-                cr.SetChangeRequestStatus(matchingID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
-                emit DealChangeRequestUpdated(cr.GetActualChangeRequest(dealID, 0));
-                cr.SetActualChangeRequest(dealID, 0, 0);
-                cr.SetActualChangeRequest(dealID, 1, 0);
+            } else if (changeRequestsCrud.GetChangeRequestStatus(matchingID) == ChangeRequests.RequestStatus.REQUEST_CREATED
+                    && changeRequestsCrud.GetChangeRequestDuration(matchingID) >= newDuration
+                    && changeRequestsCrud.GetChangeRequestPrice(matchingID) <= newPrice) {
+
+                changeRequestsCrud.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+                changeRequestsCrud.SetChangeRequestStatus(matchingID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+                emit DealChangeRequestUpdated(changeRequestsCrud.GetActualChangeRequest(dealID, 0));
+                changeRequestsCrud.SetActualChangeRequest(dealID, 0, 0);
+                changeRequestsCrud.SetActualChangeRequest(dealID, 1, 0);
                 Bill(dealID);
-                dl.SetDealPrice(dealID, cr.GetChangeRequestPrice(matchingID));
-                dl.SetDealDuration(dealID, newDuration);
+                dealsCrud.SetDealPrice(dealID, changeRequestsCrud.GetChangeRequestPrice(matchingID));
+                dealsCrud.SetDealDuration(dealID, newDuration);
                 emit DealChangeRequestUpdated(requestsAmount);
             } else {
                 return currentID;
             }
-            cr.SetChangeRequestStatus(cr.GetActualChangeRequest(dealID, 1), ChangeRequests.RequestStatus.REQUEST_CANCELED);
-            emit DealChangeRequestUpdated(cr.GetActualChangeRequest(dealID, 1));
-            cr.SetActualChangeRequest(dealID, 1, cr.GetChangeRequestsAmount());
+            changeRequestsCrud.SetChangeRequestStatus(changeRequestsCrud.GetActualChangeRequest(dealID, 1), ChangeRequests.RequestStatus.REQUEST_CANCELED);
+            emit DealChangeRequestUpdated(changeRequestsCrud.GetActualChangeRequest(dealID, 1));
+            changeRequestsCrud.SetActualChangeRequest(dealID, 1, changeRequestsCrud.GetChangeRequestsAmount());
         }
 
         if (requestType == Orders.OrderType.ORDER_ASK) {
-            matchingID = cr.GetActualChangeRequest(dealID, 1);
-            oldID = cr.GetActualChangeRequest(dealID, 0);
+            matchingID = changeRequestsCrud.GetActualChangeRequest(dealID, 1);
+            oldID = changeRequestsCrud.GetActualChangeRequest(dealID, 0);
             emit DealChangeRequestUpdated(oldID);
-            cr.SetChangeRequestStatus(oldID, ChangeRequests.RequestStatus.REQUEST_CANCELED);
-            cr.SetActualChangeRequest(dealID, 0, currentID);
+            changeRequestsCrud.SetChangeRequestStatus(oldID, ChangeRequests.RequestStatus.REQUEST_CANCELED);
+            changeRequestsCrud.SetActualChangeRequest(dealID, 0, currentID);
 
 
-            if (newDuration == dl.GetDealDuration(dealID) && newPrice < dl.GetDealPrice(dealID)) {
-                cr.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+            if (newDuration == dealsCrud.GetDealDuration(dealID) && newPrice < dealsCrud.GetDealPrice(dealID)) {
+                changeRequestsCrud.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
                 Bill(dealID);
-                dl.SetDealPrice(dealID, newPrice);
-                cr.SetActualChangeRequest(dealID, 0, 0);
+                dealsCrud.SetDealPrice(dealID, newPrice);
+                changeRequestsCrud.SetActualChangeRequest(dealID, 0, 0);
                 emit DealChangeRequestUpdated(currentID);
-            } else if (cr.GetChangeRequestStatus(matchingID) == ChangeRequests.RequestStatus.REQUEST_CREATED
-                && cr.GetChangeRequestDuration(matchingID) <= newDuration
-                && cr.GetChangeRequestPrice(matchingID) >= newPrice) {
+            } else if (changeRequestsCrud.GetChangeRequestStatus(matchingID) == ChangeRequests.RequestStatus.REQUEST_CREATED
+                && changeRequestsCrud.GetChangeRequestDuration(matchingID) <= newDuration
+                && changeRequestsCrud.GetChangeRequestPrice(matchingID) >= newPrice) {
 
-                cr.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
-                cr.SetChangeRequestStatus(cr.GetActualChangeRequest(dealID, 1), ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+                changeRequestsCrud.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+                changeRequestsCrud.SetChangeRequestStatus(changeRequestsCrud.GetActualChangeRequest(dealID, 1), ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
                 emit DealChangeRequestUpdated(matchingID); //bug
-                cr.SetActualChangeRequest(dealID, 0, 0);
-                cr.SetActualChangeRequest(dealID, 1, 0);
+                changeRequestsCrud.SetActualChangeRequest(dealID, 0, 0);
+                changeRequestsCrud.SetActualChangeRequest(dealID, 1, 0);
                 Bill(dealID);
-                dl.SetDealPrice(dealID, newPrice);
-                dl.SetDealDuration(dealID, cr.GetChangeRequestDuration(matchingID));
+                dealsCrud.SetDealPrice(dealID, newPrice);
+                dealsCrud.SetDealDuration(dealID, changeRequestsCrud.GetChangeRequestDuration(matchingID));
                 emit DealChangeRequestUpdated(currentID);
             } else {
                 return currentID;
             }
         }
 
-        dl.SetDealEndTime(dealID, dl.GetDealStartTime(dealID).add(dl.GetDealEndTime(dealID)));
+        dealsCrud.SetDealEndTime(dealID, dealsCrud.GetDealStartTime(dealID).add(dealsCrud.GetDealEndTime(dealID)));
         return currentID;
     }
 
     function CancelChangeRequest(uint changeRequestID) public returns (bool) {
-        uint dealID = cr.GetChangeRequestDealID(changeRequestID);
-        require(msg.sender == dl.GetDealSupplierID(dealID) || msg.sender == dl.GetDealMasterID(dealID) || msg.sender == dl.GetDealConsumerID(dealID));
-        require(cr.GetChangeRequestStatus(changeRequestID) != ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+        uint dealID = changeRequestsCrud.GetChangeRequestDealID(changeRequestID);
+        require(msg.sender == dealsCrud.GetDealSupplierID(dealID) || msg.sender == dealsCrud.GetDealMasterID(dealID) || msg.sender == dealsCrud.GetDealConsumerID(dealID));
+        require(changeRequestsCrud.GetChangeRequestStatus(changeRequestID) != ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
 
-        if (cr.GetChangeRequestType(changeRequestID) == Orders.OrderType.ORDER_ASK) {
-            if (msg.sender == dl.GetDealConsumerID(dealID)) {
-                cr.SetChangeRequestStatus(changeRequestID, ChangeRequests.RequestStatus.REQUEST_REJECTED);
+        if (changeRequestsCrud.GetChangeRequestType(changeRequestID) == Orders.OrderType.ORDER_ASK) {
+            if (msg.sender == dealsCrud.GetDealConsumerID(dealID)) {
+                changeRequestsCrud.SetChangeRequestStatus(changeRequestID, ChangeRequests.RequestStatus.REQUEST_REJECTED);
             } else {
-                cr.SetChangeRequestStatus(changeRequestID, ChangeRequests.RequestStatus.REQUEST_CANCELED);
+                changeRequestsCrud.SetChangeRequestStatus(changeRequestID, ChangeRequests.RequestStatus.REQUEST_CANCELED);
             }
-            cr.SetActualChangeRequest(dealID, 0, 0);
+            changeRequestsCrud.SetActualChangeRequest(dealID, 0, 0);
             emit DealChangeRequestUpdated(changeRequestID);
         }
 
-        if (cr.GetChangeRequestType(changeRequestID) == Orders.OrderType.ORDER_BID) {
-            if (msg.sender == dl.GetDealConsumerID(dealID)) {
-                cr.SetChangeRequestStatus(changeRequestID, ChangeRequests.RequestStatus.REQUEST_CANCELED);
+        if (changeRequestsCrud.GetChangeRequestType(changeRequestID) == Orders.OrderType.ORDER_BID) {
+            if (msg.sender == dealsCrud.GetDealConsumerID(dealID)) {
+                changeRequestsCrud.SetChangeRequestStatus(changeRequestID, ChangeRequests.RequestStatus.REQUEST_CANCELED);
             } else {
-                cr.SetChangeRequestStatus(changeRequestID, ChangeRequests.RequestStatus.REQUEST_REJECTED);
+                changeRequestsCrud.SetChangeRequestStatus(changeRequestID, ChangeRequests.RequestStatus.REQUEST_REJECTED);
             }
-            cr.SetActualChangeRequest(dealID, 1, 0);
+            changeRequestsCrud.SetActualChangeRequest(dealID, 1, 0);
             emit DealChangeRequestUpdated(changeRequestID);
         }
         return true;
@@ -457,52 +457,52 @@ contract Market is Ownable, Pausable {
 
     function InternalBill(uint dealID) internal returns (bool){
 
-        require(dl.GetDealStatus(dealID) == Deals.DealStatus.STATUS_ACCEPTED);
+        require(dealsCrud.GetDealStatus(dealID) == Deals.DealStatus.STATUS_ACCEPTED);
         require(
-            msg.sender == dl.GetDealSupplierID(dealID) ||
-            msg.sender == dl.GetDealConsumerID(dealID) ||
-            msg.sender == dl.GetDealMasterID(dealID));
+            msg.sender == dealsCrud.GetDealSupplierID(dealID) ||
+            msg.sender == dealsCrud.GetDealConsumerID(dealID) ||
+            msg.sender == dealsCrud.GetDealMasterID(dealID));
         uint paidAmount;
 
-        if (dl.GetDealDuration(dealID) != 0 && dl.GetDealLastBillTS(dealID) >= dl.GetDealEndTime(dealID)) {
+        if (dealsCrud.GetDealDuration(dealID) != 0 && dealsCrud.GetDealLastBillTS(dealID) >= dealsCrud.GetDealEndTime(dealID)) {
             // means we already billed deal after endTime
             return true;
-        } else if (dl.GetDealDuration(dealID) != 0
-            && block.timestamp > dl.GetDealEndTime(dealID)
-            && dl.GetDealLastBillTS(dealID) < dl.GetDealEndTime(dealID)) {
-            paidAmount = CalculatePayment(dl.GetDealPrice(dealID), dl.GetDealEndTime(dealID).sub(dl.GetDealLastBillTS(dealID)));
+        } else if (dealsCrud.GetDealDuration(dealID) != 0
+            && block.timestamp > dealsCrud.GetDealEndTime(dealID)
+            && dealsCrud.GetDealLastBillTS(dealID) < dealsCrud.GetDealEndTime(dealID)) {
+            paidAmount = CalculatePayment(dealsCrud.GetDealPrice(dealID), dealsCrud.GetDealEndTime(dealID).sub(dealsCrud.GetDealLastBillTS(dealID)));
         } else {
-            paidAmount = CalculatePayment(dl.GetDealPrice(dealID), block.timestamp.sub(dl.GetDealLastBillTS(dealID)));
+            paidAmount = CalculatePayment(dealsCrud.GetDealPrice(dealID), block.timestamp.sub(dealsCrud.GetDealLastBillTS(dealID)));
         }
 
-        if (paidAmount > dl.GetDealBlockedBalance(dealID)) {
-            if (token.balanceOf(dl.GetDealConsumerID(dealID)) >= paidAmount.sub(dl.GetDealBlockedBalance(dealID))) {
-                require(token.transferFrom(dl.GetDealConsumerID(dealID), this, paidAmount.sub(dl.GetDealBlockedBalance(dealID))));
-                dl.SetDealBlockedBalance(dealID, dl.GetDealBlockedBalance(dealID).add(paidAmount.sub(dl.GetDealBlockedBalance(dealID))));
+        if (paidAmount > dealsCrud.GetDealBlockedBalance(dealID)) {
+            if (token.balanceOf(dealsCrud.GetDealConsumerID(dealID)) >= paidAmount.sub(dealsCrud.GetDealBlockedBalance(dealID))) {
+                require(token.transferFrom(dealsCrud.GetDealConsumerID(dealID), this, paidAmount.sub(dealsCrud.GetDealBlockedBalance(dealID))));
+                dealsCrud.SetDealBlockedBalance(dealID, dealsCrud.GetDealBlockedBalance(dealID).add(paidAmount.sub(dealsCrud.GetDealBlockedBalance(dealID))));
             } else {
-                emit Billed(dealID, dl.GetDealBlockedBalance(dealID));
+                emit Billed(dealID, dealsCrud.GetDealBlockedBalance(dealID));
                 InternalCloseDeal(dealID);
-                require(token.transfer(dl.GetDealMasterID(dealID), dl.GetDealBlockedBalance(dealID)));
-                dl.SetDealTotalPayout(dealID, dl.GetDealTotalPayout(dealID).add(dl.GetDealBlockedBalance(dealID)));
-                dl.SetDealBlockedBalance(dealID, 0);
-                dl.SetDealEndTime(dealID, block.timestamp);
+                require(token.transfer(dealsCrud.GetDealMasterID(dealID), dealsCrud.GetDealBlockedBalance(dealID)));
+                dealsCrud.SetDealTotalPayout(dealID, dealsCrud.GetDealTotalPayout(dealID).add(dealsCrud.GetDealBlockedBalance(dealID)));
+                dealsCrud.SetDealBlockedBalance(dealID, 0);
+                dealsCrud.SetDealEndTime(dealID, block.timestamp);
                 return true;
             }
         }
 
-        require(token.transfer(dl.GetDealMasterID(dealID), paidAmount));
-        dl.SetDealBlockedBalance(dealID, dl.GetDealBlockedBalance(dealID).sub(paidAmount));
-        dl.SetDealTotalPayout(dealID, dl.GetDealTotalPayout(dealID).add(paidAmount));
-        dl.SetDealLastBillTS(dealID, block.timestamp);
+        require(token.transfer(dealsCrud.GetDealMasterID(dealID), paidAmount));
+        dealsCrud.SetDealBlockedBalance(dealID, dealsCrud.GetDealBlockedBalance(dealID).sub(paidAmount));
+        dealsCrud.SetDealTotalPayout(dealID, dealsCrud.GetDealTotalPayout(dealID).add(paidAmount));
+        dealsCrud.SetDealLastBillTS(dealID, block.timestamp);
         emit Billed(dealID, paidAmount);
         return true;
     }
 
     function ReserveNextPeriodFunds(uint dealID) internal returns (bool) {
         uint nextPeriod;
-        address consumerID = dl.GetDealConsumerID(dealID);
+        address consumerID = dealsCrud.GetDealConsumerID(dealID);
 
-        (uint duration, uint price, uint endTime, Deals.DealStatus status, uint blockedBalance, , ) = dl.GetDealParams(dealID);
+        (uint duration, uint price, uint endTime, Deals.DealStatus status, uint blockedBalance, , ) = dealsCrud.GetDealParams(dealID);
 
         if (duration == 0) {
             if (status == Deals.DealStatus.STATUS_CLOSED) {
@@ -526,7 +526,7 @@ contract Market is Ownable, Pausable {
 
             if (token.balanceOf(consumerID) >= nextPeriodSum) {
                 require(token.transferFrom(consumerID, this, nextPeriodSum));
-                dl.SetDealBlockedBalance(dealID, blockedBalance.add(nextPeriodSum));
+                dealsCrud.SetDealBlockedBalance(dealID, blockedBalance.add(nextPeriodSum));
             } else {
                 emit Billed(dealID, blockedBalance);
                 InternalCloseDeal(dealID);
@@ -538,13 +538,13 @@ contract Market is Ownable, Pausable {
     }
 
     function RefundRemainingFunds(uint dealID) internal returns (bool) {
-        address consumerID = dl.GetDealConsumerID(dealID);
+        address consumerID = dealsCrud.GetDealConsumerID(dealID);
 
-        uint blockedBalance = dl.GetDealBlockedBalance(dealID);
+        uint blockedBalance = dealsCrud.GetDealBlockedBalance(dealID);
 
         if (blockedBalance != 0) {
             token.transfer(consumerID, blockedBalance);
-            dl.SetDealBlockedBalance(dealID, 0);
+            dealsCrud.SetDealBlockedBalance(dealID, 0);
         }
         return true;
     }
@@ -557,7 +557,7 @@ contract Market is Ownable, Pausable {
     }
 
     function AddToBlacklist(uint dealID, BlacklistPerson role) internal {
-        (, address supplierID, address consumerID, address masterID, , , ) = dl.GetDealInfo(dealID);
+        (, address supplierID, address consumerID, address masterID, , , ) = dealsCrud.GetDealInfo(dealID);
 
         // only consumer can blacklist
         require(msg.sender == consumerID || role == BlacklistPerson.BLACKLIST_NOBODY);
@@ -569,17 +569,17 @@ contract Market is Ownable, Pausable {
     }
 
     function InternalCloseDeal(uint dealID) internal {
-        ( , address supplierID, address consumerID, address masterID, , , ) = dl.GetDealInfo(dealID);
+        ( , address supplierID, address consumerID, address masterID, , , ) = dealsCrud.GetDealInfo(dealID);
 
-        Deals.DealStatus status = dl.GetDealStatus(dealID);
+        Deals.DealStatus status = dealsCrud.GetDealStatus(dealID);
 
         if (status == Deals.DealStatus.STATUS_CLOSED) {
             return;
         }
         require((status == Deals.DealStatus.STATUS_ACCEPTED));
         require(msg.sender == consumerID || msg.sender == supplierID || msg.sender == masterID);
-        dl.SetDealStatus(dealID, Deals.DealStatus.STATUS_CLOSED);
-        dl.SetDealEndTime(dealID, block.timestamp);
+        dealsCrud.SetDealStatus(dealID, Deals.DealStatus.STATUS_CLOSED);
+        dealsCrud.SetDealEndTime(dealID, block.timestamp);
         emit DealUpdated(dealID);
     }
 
@@ -602,7 +602,7 @@ contract Market is Ownable, Pausable {
     // SETTERS
 
     function SetProfileRegistryAddress(address _newPR) public onlyOwner returns (bool) {
-        pr = ProfileRegistry(_newPR);
+        profiles = ProfileRegistry(_newPR);
         return true;
     }
 
@@ -618,12 +618,12 @@ contract Market is Ownable, Pausable {
     }
 
     function SetDealsAddress(address _newDeals) public onlyOwner returns (bool) {
-        dl = Deals(_newDeals);
+        dealsCrud = Deals(_newDeals);
         return true;
     }
 
     function SetOrdersAddress(address _newOrders) public onlyOwner returns (bool) {
-        ord = Orders(_newOrders);
+        ordersCrud = Orders(_newOrders);
         return  true;
     }
 
@@ -648,10 +648,10 @@ contract Market is Ownable, Pausable {
 
     function Migrate(address _newMarket) public onlyOwner returns (bool) {
         token.transfer(_newMarket, token.balanceOf(address(this)));
-        ord.transferOwnership(_newMarket);
-        dl.transferOwnership(_newMarket);
-        cr.transferOwnership(_newMarket);
-        super.pause();
+        ordersCrud.transferOwnership(_newMarket);
+        dealsCrud.transferOwnership(_newMarket);
+        changeRequestsCrud.transferOwnership(_newMarket);
+        pause();
 
     }
 }
diff --git a/blockchain/source/contracts/OracleUSD.sol b/blockchain/source/contracts/OracleUSD.sol
index a1f34bce6..f7e8fb5e5 100644
--- a/blockchain/source/contracts/OracleUSD.sol
+++ b/blockchain/source/contracts/OracleUSD.sol
@@ -20,11 +20,7 @@ contract OracleUSD is Ownable {
         emit PriceChanged(_price);
     }
 
-<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
-    function getCurrentPrice() public view returns (uint){
-=======
-    function getCurrentPrice()  public view returns (uint){
->>>>>>> some style mistakes fixed
+    function getCurrentPrice() public view returns (uint) {
         return currentPrice;
     }
 }
diff --git a/blockchain/source/contracts/ProfileRegistry.sol b/blockchain/source/contracts/ProfileRegistry.sol
index 236e8e9e2..b6a7441d3 100644
--- a/blockchain/source/contracts/ProfileRegistry.sol
+++ b/blockchain/source/contracts/ProfileRegistry.sol
@@ -53,11 +53,7 @@ contract ProfileRegistry is Ownable, Pausable {
         validators[msg.sender] = - 1;
     }
 
-<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function AddValidator(address _validator, int8 _level) public onlySonm whenNotPaused returns (address) {
-=======
-    function AddValidator(address _validator, int8 _level) public onlySonm whenNotPaused returns (address){
->>>>>>> some style mistakes fixed
         require(_level > 0);
         require(GetValidatorLevel(_validator) == 0);
         validators[_validator] = _level;
@@ -65,22 +61,14 @@ contract ProfileRegistry is Ownable, Pausable {
         return _validator;
     }
 
-<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function RemoveValidator(address _validator) public onlySonm whenNotPaused returns (address) {
-=======
-    function RemoveValidator(address _validator) public onlySonm whenNotPaused returns (address){
->>>>>>> some style mistakes fixed
         require(GetValidatorLevel(_validator) > 0);
         validators[_validator] = 0;
         emit ValidatorDeleted(_validator);
         return _validator;
     }
 
-<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function GetValidatorLevel(address _validator) public view returns (int8) {
-=======
-    function GetValidatorLevel(address _validator) public view returns (int8){
->>>>>>> some style mistakes fixed
         return validators[_validator];
     }
 
@@ -127,7 +115,6 @@ contract ProfileRegistry is Ownable, Pausable {
         emit CertificateUpdated(_id);
     }
 
-<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function GetCertificate(uint256 _id) public view returns (address, address, uint256, bytes) {
         return (certificates[_id].from, certificates[_id].to, certificates[_id].attributeType, certificates[_id].value);
     }
@@ -141,21 +128,6 @@ contract ProfileRegistry is Ownable, Pausable {
     }
 
     function GetProfileLevel(address _owner) public view returns (IdentityLevel) {
-=======
-    function GetCertificate(uint256 _id) public view returns (address, address, uint256, bytes){
-        return (certificates[_id].from, certificates[_id].to, certificates[_id].attributeType, certificates[_id].value);
-    }
-
-    function GetAttributeValue(address _owner, uint256 _type) public view returns (bytes){
-        return certificateValue[_owner][_type];
-    }
-
-    function GetAttributeCount(address _owner, uint256 _type) public view returns (uint256){
-        return certificateCount[_owner][_type];
-    }
-
-    function GetProfileLevel(address _owner) public view returns (IdentityLevel){
->>>>>>> some style mistakes fixed
         if (GetAttributeValue(_owner, 1401).length > 0) {
             return IdentityLevel.PROFESSIONAL;
         } else if (GetAttributeValue(_owner, 1301).length > 0) {
diff --git a/blockchain/source/contracts/SimpleGatekeeperWithLimit.sol b/blockchain/source/contracts/SimpleGatekeeperWithLimit.sol
index d795a1710..cad6ea383 100644
--- a/blockchain/source/contracts/SimpleGatekeeperWithLimit.sol
+++ b/blockchain/source/contracts/SimpleGatekeeperWithLimit.sol
@@ -123,11 +123,7 @@ contract SimpleGatekeeperWithLimit is Ownable {
         CommissionChanged(commission);
     }
 
-<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
-    function GetCommission() public view returns (uint256){
-=======
     function GetCommission() public view returns (uint256) {
->>>>>>> some style mistakes fixed
         return commission;
     }
 
diff --git a/blockchain/source/contracts/TestnetFaucet.sol b/blockchain/source/contracts/TestnetFaucet.sol
index 864183394..f954b58a3 100644
--- a/blockchain/source/contracts/TestnetFaucet.sol
+++ b/blockchain/source/contracts/TestnetFaucet.sol
@@ -19,20 +19,12 @@ contract TestnetFaucet is Ownable {
         return true;
     }
 
-<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function mintToken(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
-=======
-    function mintToken(address target, uint256 mintedAmount) public onlyOwner returns (bool){
->>>>>>> some style mistakes fixed
         token.mint(target, mintedAmount);
         return true;
     }
 
-<<<<<<< 72a9ea1ec3aa153afcfd9294eae0fe47986e4804
     function() public payable{
-=======
-    function() public payable {
->>>>>>> some style mistakes fixed
         getTokens();
     }
 
diff --git a/blockchain/source/migrations/10_set_market_for_blacklist.js b/blockchain/source/migrations/10_set_market_for_blacklist.js
index ad1796a4b..d0fa1e84e 100644
--- a/blockchain/source/migrations/10_set_market_for_blacklist.js
+++ b/blockchain/source/migrations/10_set_market_for_blacklist.js
@@ -3,13 +3,13 @@ let Blacklist = artifacts.require('./Blacklist.sol');
 
 module.exports = function (deployer, network) {
     if (network === 'private') {
-        // Blacklist.deployed()
-        //     .then(function (blacklist) {
-        //         blacklist.SetMarketAddress(Market.address, { gasPrice: 0 });
-        //     })
-        //     .catch(function (err) {
-        //         console.log(err);
-        //     });
+        Blacklist.deployed()
+            .then(function (blacklist) {
+                blacklist.SetMarketAddress(Market.address, { gasPrice: 0 });
+            })
+            .catch(function (err) {
+                console.log(err);
+            });
     } else if (network === 'master') {
         // blacklist haven't reason to deploy to mainnet
     } else if (network === 'rinkeby') {
diff --git a/blockchain/source/truffle.js b/blockchain/source/truffle.js
index 8ec701a3b..ceabbe533 100644
--- a/blockchain/source/truffle.js
+++ b/blockchain/source/truffle.js
@@ -30,7 +30,6 @@ module.exports = {
             port: 8535,
             network_id: '*', // eslint-disable-line camelcase
             gas: 100000000,
-            gasPrice: 1,
         },
         coverage: {
             host: 'localhost',

From 991089dccb55c71b01f2fda80354e81d37693816 Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Thu, 15 Nov 2018 17:22:17 +0300
Subject: [PATCH 12/18] fix: cr status bug

---
 blockchain/source/contracts/Market.sol | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/blockchain/source/contracts/Market.sol b/blockchain/source/contracts/Market.sol
index 4bb5ec6e3..93146fa36 100644
--- a/blockchain/source/contracts/Market.sol
+++ b/blockchain/source/contracts/Market.sol
@@ -353,6 +353,9 @@ contract Market is Ownable, Pausable {
             changeRequestsCrud.SetActualChangeRequest(dealID, 1, currentID);
 
             if (newDuration == dealsCrud.GetDealDuration(dealID) && newPrice > dealsCrud.GetDealPrice(dealID)) {
+                if (changeRequestsCrud.GetChangeRequestPrice(matchingID) <= newPrice) {
+                    changeRequestsCrud.SetChangeRequestStatus(matchingID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+                }
                 changeRequestsCrud.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
                 Bill(dealID);
                 dealsCrud.SetDealPrice(dealID, newPrice);
@@ -388,6 +391,9 @@ contract Market is Ownable, Pausable {
 
 
             if (newDuration == dealsCrud.GetDealDuration(dealID) && newPrice < dealsCrud.GetDealPrice(dealID)) {
+                if (changeRequestsCrud.GetChangeRequestPrice(matchingID) >= newPrice) {
+                    changeRequestsCrud.SetChangeRequestStatus(matchingID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+                }
                 changeRequestsCrud.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
                 Bill(dealID);
                 dealsCrud.SetDealPrice(dealID, newPrice);
@@ -398,7 +404,7 @@ contract Market is Ownable, Pausable {
                 && changeRequestsCrud.GetChangeRequestPrice(matchingID) >= newPrice) {
 
                 changeRequestsCrud.SetChangeRequestStatus(currentID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
-                changeRequestsCrud.SetChangeRequestStatus(changeRequestsCrud.GetActualChangeRequest(dealID, 1), ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
+                changeRequestsCrud.SetChangeRequestStatus(matchingID, ChangeRequests.RequestStatus.REQUEST_ACCEPTED);
                 emit DealChangeRequestUpdated(matchingID); //bug
                 changeRequestsCrud.SetActualChangeRequest(dealID, 0, 0);
                 changeRequestsCrud.SetActualChangeRequest(dealID, 1, 0);

From fb870b52df6fbfce6b072e4031b71a35335ebc05 Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Fri, 16 Nov 2018 13:19:02 +0300
Subject: [PATCH 13/18] fix: counterpartry bid matching

---
 blockchain/source/contracts/Market.sol | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/blockchain/source/contracts/Market.sol b/blockchain/source/contracts/Market.sol
index 93146fa36..7da141600 100644
--- a/blockchain/source/contracts/Market.sol
+++ b/blockchain/source/contracts/Market.sol
@@ -211,8 +211,10 @@ contract Market is Ownable, Pausable {
         require(
             ordersCrud.GetOrderStatus(_askID) == Orders.OrderStatus.ORDER_ACTIVE
             && ordersCrud.GetOrderStatus(_bidID) == Orders.OrderStatus.ORDER_ACTIVE);
-        require(ordersCrud.GetOrderCounterparty(_askID) == 0x0 || ordersCrud.GetOrderCounterparty(_askID) == administratum.GetMaster(ordersCrud.GetOrderAuthor(_bidID)));
-        require(ordersCrud.GetOrderCounterparty(_bidID) == 0x0 || ordersCrud.GetOrderCounterparty(_bidID) == administratum.GetMaster(ordersCrud.GetOrderAuthor(_askID)));
+        require(ordersCrud.GetOrderCounterparty(_askID) == 0x0 || ordersCrud.GetOrderCounterparty(_askID) == ordersCrud.GetOrderAuthor(_bidID));
+        require(ordersCrud.GetOrderCounterparty(_bidID) == 0x0
+            || ordersCrud.GetOrderCounterparty(_bidID) == administratum.GetMaster(ordersCrud.GetOrderAuthor(_askID))
+            || ordersCrud.GetOrderCounterparty(_bidID) == ordersCrud.GetOrderAuthor(_askID));
         require(ordersCrud.GetOrderType(_askID) == Orders.OrderType.ORDER_ASK);
         require(ordersCrud.GetOrderType(_bidID) == Orders.OrderType.ORDER_BID);
         require(!bl.Check(ordersCrud.GetOrderBlacklist(_bidID), administratum.GetMaster(ordersCrud.GetOrderAuthor(_askID))));

From b51d75153716083bd13f831aa36017cbef62a69f Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Fri, 16 Nov 2018 22:50:33 +0300
Subject: [PATCH 14/18] fix: migrations order

---
 .../source/migrations/{7_deploy_crud.js => 5_deploy_crud.js}      | 0
 .../{8_deploy_administratum.js => 6_deploy_administratum.js}      | 0
 .../source/migrations/{9_deploy_market.js => 7_deploy_market.js}  | 0
 ..._set_market_for_blacklist.js => 8_set_market_for_blacklist.js} | 0
 4 files changed, 0 insertions(+), 0 deletions(-)
 rename blockchain/source/migrations/{7_deploy_crud.js => 5_deploy_crud.js} (100%)
 rename blockchain/source/migrations/{8_deploy_administratum.js => 6_deploy_administratum.js} (100%)
 rename blockchain/source/migrations/{9_deploy_market.js => 7_deploy_market.js} (100%)
 rename blockchain/source/migrations/{10_set_market_for_blacklist.js => 8_set_market_for_blacklist.js} (100%)

diff --git a/blockchain/source/migrations/7_deploy_crud.js b/blockchain/source/migrations/5_deploy_crud.js
similarity index 100%
rename from blockchain/source/migrations/7_deploy_crud.js
rename to blockchain/source/migrations/5_deploy_crud.js
diff --git a/blockchain/source/migrations/8_deploy_administratum.js b/blockchain/source/migrations/6_deploy_administratum.js
similarity index 100%
rename from blockchain/source/migrations/8_deploy_administratum.js
rename to blockchain/source/migrations/6_deploy_administratum.js
diff --git a/blockchain/source/migrations/9_deploy_market.js b/blockchain/source/migrations/7_deploy_market.js
similarity index 100%
rename from blockchain/source/migrations/9_deploy_market.js
rename to blockchain/source/migrations/7_deploy_market.js
diff --git a/blockchain/source/migrations/10_set_market_for_blacklist.js b/blockchain/source/migrations/8_set_market_for_blacklist.js
similarity index 100%
rename from blockchain/source/migrations/10_set_market_for_blacklist.js
rename to blockchain/source/migrations/8_set_market_for_blacklist.js

From 0fe57a3b0ec29608b16c0c08141989d63032e891 Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Fri, 16 Nov 2018 22:51:01 +0300
Subject: [PATCH 15/18] feat: change onwable => administratable

---
 .../source/contracts/AdministratumCrud.sol    |  5 ++-
 .../source/contracts/ChangeRequests.sol       |  5 ++-
 blockchain/source/contracts/Deals.sol         | 41 ++-----------------
 blockchain/source/contracts/Market.sol        |  3 +-
 blockchain/source/contracts/Orders.sol        |  5 ++-
 5 files changed, 14 insertions(+), 45 deletions(-)

diff --git a/blockchain/source/contracts/AdministratumCrud.sol b/blockchain/source/contracts/AdministratumCrud.sol
index 53f820b78..5b9ba1efb 100644
--- a/blockchain/source/contracts/AdministratumCrud.sol
+++ b/blockchain/source/contracts/AdministratumCrud.sol
@@ -1,8 +1,8 @@
 pragma solidity ^0.4.23;
 
-import "zeppelin-solidity/contracts/ownership/Ownable.sol";
+import "./Administratable.sol";
 
-contract AdministratumCrud is Ownable {
+contract AdministratumCrud is Administratable {
 
     // events
     event WorkerAnnounced(address indexed worker, address indexed master);
@@ -24,6 +24,7 @@ contract AdministratumCrud is Ownable {
     //constructor
     constructor(){
         owner = msg.sender;
+        administrator = msg.sender;
     }
 
     function SetMaster(address _worker, address _master) public onlyOwner {
diff --git a/blockchain/source/contracts/ChangeRequests.sol b/blockchain/source/contracts/ChangeRequests.sol
index 844cbc643..170a4dd3a 100644
--- a/blockchain/source/contracts/ChangeRequests.sol
+++ b/blockchain/source/contracts/ChangeRequests.sol
@@ -1,11 +1,11 @@
 pragma solidity ^0.4.23;
 
-import "zeppelin-solidity/contracts/ownership/Ownable.sol";
+import "./Administratable.sol";
 import "zeppelin-solidity/contracts/math/SafeMath.sol";
 import "./Orders.sol";
 
 
-contract ChangeRequests is Ownable {
+contract ChangeRequests is Administratable {
     using SafeMath for uint256;
 
     mapping(uint => ChangeRequest) requests;
@@ -33,6 +33,7 @@ contract ChangeRequests is Ownable {
 
     constructor() public {
         owner = msg.sender;
+        administrator = msg.sender;
     }
 
     function Write(
diff --git a/blockchain/source/contracts/Deals.sol b/blockchain/source/contracts/Deals.sol
index e298c1634..7425663d2 100644
--- a/blockchain/source/contracts/Deals.sol
+++ b/blockchain/source/contracts/Deals.sol
@@ -1,9 +1,9 @@
 pragma solidity ^0.4.23;
 
-import "zeppelin-solidity/contracts/ownership/Ownable.sol";
+import "./Administratable.sol";
 
 
-contract Deals is Ownable {
+contract Deals is Administratable {
     //events
 
     //enums
@@ -48,44 +48,9 @@ contract Deals is Ownable {
     //Constructor
     constructor() public {
         owner = msg.sender;
+        administrator = msg.sender;
     }
 
-    function Write(
-        uint64[] _benchmarks,
-        address _supplierID,
-        address _consumerID,
-        address _masterID,
-        uint _askID,
-        uint _bidID,
-        uint _duration,
-        uint _price,
-        uint _startTime,
-        uint _endTime,
-        DealStatus _status,
-        uint _blockedBalance,
-        uint _totalPayout,
-        uint _lastBillTS) public onlyOwner returns(uint) {
-
-        dealsAmount += 1;
-
-        deals[dealsAmount].info.benchmarks = _benchmarks;
-        deals[dealsAmount].info.supplierID = _supplierID;
-        deals[dealsAmount].info.consumerID = _consumerID;
-        deals[dealsAmount].info.masterID = _masterID;
-        deals[dealsAmount].info.askID = _askID;
-        deals[dealsAmount].info.bidID = _bidID;
-        deals[dealsAmount].info.startTime = _startTime;
-        deals[dealsAmount].params.duration = _duration;
-        deals[dealsAmount].params.price = _price;
-        deals[dealsAmount].params.endTime = _endTime;
-        deals[dealsAmount].params.status = _status;
-        deals[dealsAmount].params.blockedBalance = _blockedBalance;
-        deals[dealsAmount].params.totalPayout = _totalPayout;
-        deals[dealsAmount].params.lastBillTS = _lastBillTS;
-
-
-        return dealsAmount;
-    }
 
     function SetDealBenchmarks(uint dealID, uint64[] _benchmarks) public onlyOwner {
         deals[dealID].info.benchmarks = _benchmarks;
diff --git a/blockchain/source/contracts/Market.sol b/blockchain/source/contracts/Market.sol
index 7da141600..fa7ccddde 100644
--- a/blockchain/source/contracts/Market.sol
+++ b/blockchain/source/contracts/Market.sol
@@ -212,7 +212,8 @@ contract Market is Ownable, Pausable {
             ordersCrud.GetOrderStatus(_askID) == Orders.OrderStatus.ORDER_ACTIVE
             && ordersCrud.GetOrderStatus(_bidID) == Orders.OrderStatus.ORDER_ACTIVE);
         require(ordersCrud.GetOrderCounterparty(_askID) == 0x0 || ordersCrud.GetOrderCounterparty(_askID) == ordersCrud.GetOrderAuthor(_bidID));
-        require(ordersCrud.GetOrderCounterparty(_bidID) == 0x0
+        require(
+            ordersCrud.GetOrderCounterparty(_bidID) == 0x0
             || ordersCrud.GetOrderCounterparty(_bidID) == administratum.GetMaster(ordersCrud.GetOrderAuthor(_askID))
             || ordersCrud.GetOrderCounterparty(_bidID) == ordersCrud.GetOrderAuthor(_askID));
         require(ordersCrud.GetOrderType(_askID) == Orders.OrderType.ORDER_ASK);
diff --git a/blockchain/source/contracts/Orders.sol b/blockchain/source/contracts/Orders.sol
index 741f1a036..63454ccd9 100644
--- a/blockchain/source/contracts/Orders.sol
+++ b/blockchain/source/contracts/Orders.sol
@@ -1,9 +1,9 @@
 pragma solidity ^0.4.23;
 
-import "zeppelin-solidity/contracts/ownership/Ownable.sol";
+import "./Administratable.sol";
 import "./ProfileRegistry.sol";
 
-contract Orders is Ownable {
+contract Orders is Administratable {
     //events
 
     //enums
@@ -53,6 +53,7 @@ contract Orders is Ownable {
 
     constructor() public {
         owner = msg.sender;
+        administrator = msg.sender;
     }
 
     function Write(

From dc07e536633e99205d531774b068bfb6dbb267bb Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Thu, 22 Nov 2018 16:33:16 +0300
Subject: [PATCH 16/18] rating fields commited

---
 blockchain/source/contracts/Orders.sol | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/blockchain/source/contracts/Orders.sol b/blockchain/source/contracts/Orders.sol
index 63454ccd9..330c5eb3f 100644
--- a/blockchain/source/contracts/Orders.sol
+++ b/blockchain/source/contracts/Orders.sol
@@ -38,6 +38,7 @@ contract Orders is Administratable {
         bytes32 tag;
         uint64[] benchmarks;
         uint frozenSum;
+        uint requiredRating;
     }
 
     struct OrderParams {
@@ -105,8 +106,9 @@ contract Orders is Administratable {
     function SetOrderNetflags(uint orderID, bool[] _netflags) public onlyOwner {
         orders[orderID].info.netflags = _netflags;
     }
-    function GetOrdersAmount() public view returns (uint) {
-        return ordersAmount;
+
+    function SetOrderRequiredRating(uint orderID, uint _requiredRating) public onlyOwner {
+        orders[orderID].info.requiredRating = _requiredRating;
     }
 
     function GetOrderInfo(uint orderID) public view
@@ -121,7 +123,8 @@ contract Orders is Administratable {
         address blacklist,
         bytes32 tag,
         uint64[] benchmarks,
-        uint frozenSum
+        uint frozenSum,
+        uint requiredRating
     ){
         OrderInfo memory info = orders[orderID].info;
         return (
@@ -135,7 +138,8 @@ contract Orders is Administratable {
         info.blacklist,
         info.tag,
         info.benchmarks,
-        info.frozenSum
+        info.frozenSum,
+        info.requiredRating
         );
     }
     function GetOrderType(uint orderID) public view returns (OrderType) {
@@ -181,6 +185,13 @@ contract Orders is Administratable {
         return orders[orderID].info.frozenSum;
     }
 
+    function GetOrderRequiredRating(uint orderID) public view returns (uint) {
+        return orders[orderID].info.requiredRating;
+    }
+
+    function GetOrdersAmount() public view returns (uint) {
+        return ordersAmount;
+    }
 
     function GetOrderParams(uint orderID) public view
     returns (

From 4dd15b5fbb998beb160ae22ad3ed1cdbb6bbb25a Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Thu, 22 Nov 2018 16:40:18 +0300
Subject: [PATCH 17/18] fix tuple err while generating abi

---
 blockchain/source/contracts/Deals.sol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/blockchain/source/contracts/Deals.sol b/blockchain/source/contracts/Deals.sol
index 7425663d2..7c811125a 100644
--- a/blockchain/source/contracts/Deals.sol
+++ b/blockchain/source/contracts/Deals.sol
@@ -39,7 +39,7 @@ contract Deals is Administratable {
         uint lastBillTS;
     }
 
-    mapping(uint => Deal) public deals;
+    mapping(uint => Deal) deals;
 
     mapping(address => uint[]) dealsID;
 

From 806b999502d95686a7f72d8b0f76e7721e7e9571 Mon Sep 17 00:00:00 2001
From: quasisamurai <quazisamurai@gmail.com>
Date: Tue, 27 Nov 2018 17:07:50 +0300
Subject: [PATCH 18/18] optimization enabled back

---
 blockchain/source/truffle.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/blockchain/source/truffle.js b/blockchain/source/truffle.js
index ceabbe533..c9f7480fe 100644
--- a/blockchain/source/truffle.js
+++ b/blockchain/source/truffle.js
@@ -59,7 +59,7 @@ module.exports = {
     },
     solc: {
         optimizer: {
-            enabled: false,
+            enabled: true,
             runs: 200,
         },
     },