@super-protocol/sdk-js 0.15.0 → 0.15.1

package/build/staticModels/Orders.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -25,98 +14,50 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var utils_1 = require("ethers/lib/utils");
-var logger_1 = __importDefault(require("../logger"));
-var utils_2 = require("../utils");
-var Order_1 = require("../types/Order");
-var Superpro_1 = __importDefault(require("./Superpro"));
-var TxManager_1 = __importDefault(require("../utils/TxManager"));
-var BlockchainConnector_1 = __importDefault(require("../connectors/BlockchainConnector"));
-var BlockchainEventsListener_1 = __importDefault(require("../connectors/BlockchainEventsListener"));
-var Orders = /** @class */ (function () {
-    function Orders() {
+const utils_1 = require("ethers/lib/utils");
+const logger_1 = __importDefault(require("../logger"));
+const utils_2 = require("../utils");
+const Order_1 = require("../types/Order");
+const Superpro_1 = __importDefault(require("./Superpro"));
+const TxManager_1 = __importDefault(require("../utils/TxManager"));
+const BlockchainConnector_1 = __importDefault(require("../connectors/BlockchainConnector"));
+const BlockchainEventsListener_1 = __importDefault(require("../connectors/BlockchainEventsListener"));
+const Order_2 = __importDefault(require("../models/Order"));
+class Orders {
+    static get address() {
+        return Superpro_1.default.address;
     }
-    Object.defineProperty(Orders, "address", {
-        get: function () {
-            return Superpro_1.default.address;
-        },
-        enumerable: false,
-        configurable: true
-    });
     /**
      * Function for fetching list of all orders ids
      * @returns list of orders ids
      */
-    Orders.getAll = function () {
+    static getAll() {
         var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var contract, ordersSet, ordersCount, orderId;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        contract = BlockchainConnector_1.default.getInstance().getContract();
-                        this.orders = (_a = this.orders) !== null && _a !== void 0 ? _a : [];
-                        ordersSet = new Set(this.orders);
-                        return [4 /*yield*/, contract.methods.getOrdersCount().call()];
-                    case 1:
-                        ordersCount = _b.sent();
-                        for (orderId = ordersSet.size + 1; orderId <= ordersCount; orderId++) {
-                            ordersSet.add(orderId.toString());
-                        }
-                        this.orders = Array.from(ordersSet);
-                        return [2 /*return*/, this.orders];
-                }
-            });
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = BlockchainConnector_1.default.getInstance().getContract();
+            this.orders = (_a = this.orders) !== null && _a !== void 0 ? _a : [];
+            const ordersSet = new Set(this.orders);
+            const ordersCount = yield contract.methods.getOrdersCount().call();
+            for (let orderId = ordersSet.size + 1; orderId <= ordersCount; orderId++) {
+                ordersSet.add(orderId.toString());
+            }
+            this.orders = Array.from(ordersSet);
+            return this.orders;
         });
-    };
+    }
     /**
      * Function for fetching orders count
      */
-    Orders.getCount = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var contract, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        contract = BlockchainConnector_1.default.getInstance().getContract();
-                        _a = Number;
-                        return [4 /*yield*/, contract.methods.getOrdersCount().call()];
-                    case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
-                }
-            });
+    static getCount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = BlockchainConnector_1.default.getInstance().getContract();
+            return Number(yield contract.methods.getOrdersCount().call());
         });
-    };
+    }
     /**
      * Function for creating orders
      * @param orderInfo - order info for new order
@@ -124,61 +65,37 @@ var Orders = /** @class */ (function () {
      * @param transactionOptions - object what contains alternative action account or gas limit (optional)
      * @returns {Promise<void>} - Does not return id of created order!
      */
-    Orders.createOrder = function (orderInfo, deposit, suspended, transactionOptions, checkTxBeforeSend) {
-        if (deposit === void 0) { deposit = "0"; }
-        if (suspended === void 0) { suspended = false; }
-        if (checkTxBeforeSend === void 0) { checkTxBeforeSend = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var contract, preparedInfo, orderInfoArguments;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        contract = BlockchainConnector_1.default.getInstance().getContract(transactionOptions);
-                        (0, utils_2.checkIfActionAccountInitialized)(transactionOptions);
-                        preparedInfo = __assign(__assign({}, orderInfo), { externalId: (0, utils_1.formatBytes32String)(orderInfo.externalId) });
-                        orderInfoArguments = (0, utils_2.objectToTuple)(preparedInfo, Order_1.OrderInfoStructure);
-                        if (!checkTxBeforeSend) return [3 /*break*/, 2];
-                        return [4 /*yield*/, TxManager_1.default.dryRun(contract.methods.createOrder, [orderInfoArguments, deposit, suspended], transactionOptions)];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2: return [4 /*yield*/, TxManager_1.default.execute(contract.methods.createOrder, [orderInfoArguments, deposit, suspended], transactionOptions)];
-                    case 3:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
+    static createOrder(orderInfo, deposit = "0", suspended = false, transactionOptions, checkTxBeforeSend = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = BlockchainConnector_1.default.getInstance().getContract(transactionOptions);
+            (0, utils_2.checkIfActionAccountInitialized)(transactionOptions);
+            const preparedInfo = Object.assign(Object.assign({}, orderInfo), { externalId: (0, utils_1.formatBytes32String)(orderInfo.externalId) });
+            const orderInfoArguments = (0, utils_2.objectToTuple)(preparedInfo, Order_1.OrderInfoStructure);
+            if (checkTxBeforeSend) {
+                yield TxManager_1.default.dryRun(contract.methods.createOrder, [orderInfoArguments, deposit, suspended], transactionOptions);
+            }
+            yield TxManager_1.default.execute(contract.methods.createOrder, [orderInfoArguments, deposit, suspended], transactionOptions);
         });
-    };
-    Orders.getByExternalId = function (consumer, externalId, fromBlock, toBlock) {
-        if (consumer === void 0) { consumer = ""; }
-        if (externalId === void 0) { externalId = ""; }
-        return __awaiter(this, void 0, void 0, function () {
-            var contract, filter, options, foundIds, notFound, response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        contract = BlockchainConnector_1.default.getInstance().getContract();
-                        filter = {
-                            consumer: consumer,
-                            externalId: (0, utils_1.formatBytes32String)(externalId),
-                        };
-                        options = { filter: filter };
-                        if (fromBlock)
-                            options.fromBlock = fromBlock;
-                        if (toBlock)
-                            options.toBlock = toBlock;
-                        return [4 /*yield*/, contract.getPastEvents("OrderCreated", options)];
-                    case 1:
-                        foundIds = _a.sent();
-                        notFound = __assign(__assign({}, filter), { offerId: "-1", parentOrderId: "-1", orderId: "-1" });
-                        response = foundIds.length > 0 ? foundIds[0].returnValues : notFound;
-                        response.externalId = (0, utils_1.parseBytes32String)(response.externalId);
-                        return [2 /*return*/, response];
-                }
-            });
+    }
+    static getByExternalId(consumer = "", externalId = "", fromBlock, toBlock) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = BlockchainConnector_1.default.getInstance().getContract();
+            const filter = {
+                consumer,
+                externalId: (0, utils_1.formatBytes32String)(externalId),
+            };
+            const options = { filter };
+            if (fromBlock)
+                options.fromBlock = fromBlock;
+            if (toBlock)
+                options.toBlock = toBlock;
+            const foundIds = yield contract.getPastEvents("OrderCreated", options);
+            const notFound = Object.assign(Object.assign({}, filter), { offerId: "-1", parentOrderId: "-1", orderId: "-1" });
+            const response = foundIds.length > 0 ? foundIds[0].returnValues : notFound;
+            response.externalId = (0, utils_1.parseBytes32String)(response.externalId);
+            return response;
         });
-    };
+    }
     /**
      * Function for create workflow
      * @param parentOrderInfo - order info for new order
@@ -187,187 +104,156 @@ var Orders = /** @class */ (function () {
      * @param transactionOptions - object what contains alternative action account or gas limit (optional)
      * @returns {Promise<void>} - Does not return id of created order!
      */
-    Orders.createWorkflow = function (parentOrderInfo, subOrdersInfo, workflowDeposit, transactionOptions, checkTxBeforeSend) {
-        if (workflowDeposit === void 0) { workflowDeposit = "0"; }
-        if (checkTxBeforeSend === void 0) { checkTxBeforeSend = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var contract, preparedInfo, parentOrderInfoArgs, preparedSubOrdersInfo, subOrdersInfoArgs;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        contract = BlockchainConnector_1.default.getInstance().getContract(transactionOptions);
-                        (0, utils_2.checkIfActionAccountInitialized)(transactionOptions);
-                        preparedInfo = __assign(__assign({}, parentOrderInfo), { externalId: (0, utils_1.formatBytes32String)(parentOrderInfo.externalId) });
-                        parentOrderInfoArgs = (0, utils_2.objectToTuple)(preparedInfo, Order_1.OrderInfoStructure);
-                        preparedSubOrdersInfo = subOrdersInfo.map(function (o) { return (__assign(__assign({}, o), { externalId: (0, utils_1.formatBytes32String)(o.externalId) })); });
-                        subOrdersInfoArgs = (0, utils_2.objectToTuple)(preparedSubOrdersInfo, Order_1.OrderInfoStructureArray);
-                        if (!checkTxBeforeSend) return [3 /*break*/, 2];
-                        return [4 /*yield*/, TxManager_1.default.dryRun(contract.methods.createWorkflow, [parentOrderInfoArgs, workflowDeposit, subOrdersInfoArgs], transactionOptions)];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2: return [4 /*yield*/, TxManager_1.default.execute(contract.methods.createWorkflow, [parentOrderInfoArgs, workflowDeposit, subOrdersInfoArgs], transactionOptions)];
-                    case 3:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
+    static createWorkflow(parentOrderInfo, subOrdersInfo, workflowDeposit = "0", transactionOptions, checkTxBeforeSend = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = BlockchainConnector_1.default.getInstance().getContract(transactionOptions);
+            (0, utils_2.checkIfActionAccountInitialized)(transactionOptions);
+            const preparedInfo = Object.assign(Object.assign({}, parentOrderInfo), { externalId: (0, utils_1.formatBytes32String)(parentOrderInfo.externalId) });
+            const parentOrderInfoArgs = (0, utils_2.objectToTuple)(preparedInfo, Order_1.OrderInfoStructure);
+            const preparedSubOrdersInfo = subOrdersInfo.map((o) => (Object.assign(Object.assign({}, o), { externalId: (0, utils_1.formatBytes32String)(o.externalId) })));
+            const subOrdersInfoArgs = (0, utils_2.objectToTuple)(preparedSubOrdersInfo, Order_1.OrderInfoStructureArray);
+            if (checkTxBeforeSend) {
+                yield TxManager_1.default.dryRun(contract.methods.createWorkflow, [parentOrderInfoArgs, workflowDeposit, subOrdersInfoArgs], transactionOptions);
+            }
+            yield TxManager_1.default.execute(contract.methods.createWorkflow, [parentOrderInfoArgs, workflowDeposit, subOrdersInfoArgs], transactionOptions);
         });
-    };
+    }
     /**
      * Function for cancel workflow
      * @param parentOrderId - Parent order id
      * @returns {Promise<void>} - Does not return id of created order!
      */
-    Orders.cancelWorkflow = function (perentOrderId, transactionOptions) {
-        return __awaiter(this, void 0, void 0, function () {
-            var contract;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        contract = BlockchainConnector_1.default.getInstance().getContract(transactionOptions);
-                        (0, utils_2.checkIfActionAccountInitialized)(transactionOptions);
-                        return [4 /*yield*/, TxManager_1.default.execute(contract.methods.cancelWorkflow, [perentOrderId], transactionOptions)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
+    static cancelWorkflow(perentOrderId, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = BlockchainConnector_1.default.getInstance().getContract(transactionOptions);
+            (0, utils_2.checkIfActionAccountInitialized)(transactionOptions);
+            yield TxManager_1.default.execute(contract.methods.cancelWorkflow, [perentOrderId], transactionOptions);
         });
-    };
+    }
     /**
      * Function for withdraw workflow change
      * @param parentOrderId - Parent order id
      * @returns {Promise<void>} - Does not return id of created order!
      */
-    Orders.withdrawWorkflowChange = function (parentOrderId, transactionOptions) {
-        return __awaiter(this, void 0, void 0, function () {
-            var contract;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        contract = BlockchainConnector_1.default.getInstance().getContract(transactionOptions);
-                        (0, utils_2.checkIfActionAccountInitialized)(transactionOptions);
-                        return [4 /*yield*/, TxManager_1.default.execute(contract.methods.withdrawWorkflowChange, [parentOrderId], transactionOptions)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
+    static withdrawWorkflowChange(parentOrderId, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = BlockchainConnector_1.default.getInstance().getContract(transactionOptions);
+            (0, utils_2.checkIfActionAccountInitialized)(transactionOptions);
+            yield TxManager_1.default.execute(contract.methods.withdrawWorkflowChange, [parentOrderId], transactionOptions);
         });
-    };
+    }
     /**
      * Function for refilling order deposit
      * @param orderId - order id
      * @param amount - amount of tokens to refilling
      * @param transactionOptions - object what contains alternative action account or gas limit (optional)
      */
-    Orders.refillOrderDeposit = function (orderId, amount, transactionOptions) {
-        return __awaiter(this, void 0, void 0, function () {
-            var contract;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        contract = BlockchainConnector_1.default.getInstance().getContract(transactionOptions);
-                        (0, utils_2.checkIfActionAccountInitialized)(transactionOptions);
-                        return [4 /*yield*/, TxManager_1.default.execute(contract.methods.refillOrder, [orderId, amount], transactionOptions)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+    static refillOrderDeposit(orderId, amount, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = BlockchainConnector_1.default.getInstance().getContract(transactionOptions);
+            (0, utils_2.checkIfActionAccountInitialized)(transactionOptions);
+            yield TxManager_1.default.execute(contract.methods.refillOrder, [orderId, amount], transactionOptions);
+        });
+    }
+    static unlockProfitByOrderList(orderIds, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = BlockchainConnector_1.default.getInstance().getContract(transactionOptions);
+            (0, utils_2.checkIfActionAccountInitialized)(transactionOptions);
+            let executedCount;
+            try {
+                executedCount = +(yield TxManager_1.default.dryRun(contract.methods.unlockProfitByList, [orderIds], transactionOptions));
+            }
+            catch (e) {
+                executedCount = 0;
+            }
+            if (executedCount === orderIds.length) {
+                yield TxManager_1.default.execute(contract.methods.unlockProfitByList, [orderIds], transactionOptions);
+            }
+            else {
+                for (const orderId of orderIds) {
+                    yield new Order_2.default(orderId).unlockProfit();
                 }
-            });
+            }
         });
-    };
+    }
     /**
      * Function for adding event listeners on order created event in orders factory contract
      * @param callback - function for processing created order
      * @returns unsubscribe - unsubscribe function from event
      */
-    Orders.onCreated = function (callback) {
-        var _this = this;
-        var contract = BlockchainEventsListener_1.default.getInstance().getContract();
-        var logger = this.logger.child({ method: "onOrderCreated" });
-        var subscription = contract.events
+    static onCreated(callback) {
+        const contract = BlockchainEventsListener_1.default.getInstance().getContract();
+        const logger = this.logger.child({ method: "onOrderCreated" });
+        const subscription = contract.events
             .OrderCreated()
-            .on("data", function (event) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                //consumer: string, externalId: string, offerId: string, orderId: string
-                callback(event.returnValues.consumer, (0, utils_1.parseBytes32String)(event.returnValues.externalId), event.returnValues.offerId, event.returnValues.parentOrderId, event.returnValues.orderId, {
-                    index: event.blockNumber,
-                    hash: event.blockHash,
-                });
-                return [2 /*return*/];
+            .on("data", (event) => __awaiter(this, void 0, void 0, function* () {
+            //consumer: string, externalId: string, offerId: string, orderId: string
+            callback(event.returnValues.consumer, (0, utils_1.parseBytes32String)(event.returnValues.externalId), event.returnValues.offerId, event.returnValues.parentOrderId, event.returnValues.orderId, {
+                index: event.blockNumber,
+                hash: event.blockHash,
             });
-        }); })
-            .on("error", function (error, receipt) {
+        }))
+            .on("error", (error, receipt) => {
             if (receipt)
                 return; // Used to avoid logging of transaction rejected
             logger.warn(error);
         });
-        return function () { return subscription.unsubscribe(); };
-    };
+        return () => subscription.unsubscribe();
+    }
     /**
      * Function for adding event listeners on order started event in orders contract
      * @param callback - function for processing suborder filled event
      * @param orderId - order id
      * @returns unsubscribe - unsubscribe function from event
      */
-    Orders.onStarted = function (callback, orderId) {
-        var _this = this;
-        var contract = BlockchainEventsListener_1.default.getInstance().getContract();
-        var logger = this.logger.child({ method: "onOrderStarted" });
-        var subscription = contract.events
+    static onStarted(callback, orderId) {
+        const contract = BlockchainEventsListener_1.default.getInstance().getContract();
+        const logger = this.logger.child({ method: "onOrderStarted" });
+        const subscription = contract.events
             .OrderStarted()
-            .on("data", function (event) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (orderId && event.returnValues.orderId != orderId) {
-                    return [2 /*return*/];
-                }
-                callback(event.returnValues.orderId, event.returnValues.consumer, {
-                    index: event.blockNumber,
-                    hash: event.blockHash,
-                });
-                return [2 /*return*/];
+            .on("data", (event) => __awaiter(this, void 0, void 0, function* () {
+            if (orderId && event.returnValues.orderId != orderId) {
+                return;
+            }
+            callback(event.returnValues.orderId, event.returnValues.consumer, {
+                index: event.blockNumber,
+                hash: event.blockHash,
             });
-        }); })
-            .on("error", function (error, receipt) {
+        }))
+            .on("error", (error, receipt) => {
             if (receipt)
                 return; // Used to avoid logging of transaction rejected
             logger.warn(error);
         });
-        return function () { return subscription.unsubscribe(); };
-    };
+        return () => subscription.unsubscribe();
+    }
     /**
      * Function for adding event listeners on order updated status event in orders contract
      * @param callback - function for processing order updated status event
      * @param orderId - order id
      * @returns unsubscribe - unsubscribe function from event
      */
-    Orders.onStatusUpdated = function (callback, orderId) {
-        var _this = this;
-        var contract = BlockchainEventsListener_1.default.getInstance().getContract();
-        var logger = this.logger.child({ method: "onOrdersStatusUpdated" });
-        var subscription = contract.events
+    static onStatusUpdated(callback, orderId) {
+        const contract = BlockchainEventsListener_1.default.getInstance().getContract();
+        const logger = this.logger.child({ method: "onOrdersStatusUpdated" });
+        const subscription = contract.events
             .OrderStatusUpdated()
-            .on("data", function (event) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (orderId && event.returnValues.orderId != orderId) {
-                    return [2 /*return*/];
-                }
-                callback(event.returnValues.orderId, event.returnValues.status, {
-                    index: event.blockNumber,
-                    hash: event.blockHash,
-                });
-                return [2 /*return*/];
+            .on("data", (event) => __awaiter(this, void 0, void 0, function* () {
+            if (orderId && event.returnValues.orderId != orderId) {
+                return;
+            }
+            callback(event.returnValues.orderId, event.returnValues.status, {
+                index: event.blockNumber,
+                hash: event.blockHash,
             });
-        }); })
-            .on("error", function (error, receipt) {
+        }))
+            .on("error", (error, receipt) => {
             if (receipt)
                 return; // Used to avoid logging of transaction rejected
             logger.warn(error);
         });
-        return function () { return subscription.unsubscribe(); };
-    };
+        return () => subscription.unsubscribe();
+    }
     /**
      * Function for adding event listeners on order refilled event in orders contract
      * @param callback - function for processing order refilled event
@@ -375,65 +261,57 @@ var Orders = /** @class */ (function () {
      * @param orderId - order id
      * @returns unsubscribe - unsubscribe function from event
      */
-    Orders.onDepositRefilled = function (callback, consumer, orderId) {
-        var _this = this;
-        var contract = BlockchainEventsListener_1.default.getInstance().getContract();
-        var logger = this.logger.child({ method: "onOrderDepositRefilled" });
-        var subscription = contract.events
+    static onDepositRefilled(callback, consumer, orderId) {
+        const contract = BlockchainEventsListener_1.default.getInstance().getContract();
+        const logger = this.logger.child({ method: "onOrderDepositRefilled" });
+        const subscription = contract.events
             .OrderDepositRefilled()
-            .on("data", function (event) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (orderId && event.returnValues.orderId != orderId) {
-                    return [2 /*return*/];
-                }
-                if (consumer && event.returnValues.consumer != consumer) {
-                    return [2 /*return*/];
-                }
-                callback(event.returnValues.orderId, event.returnValues.consumer, event.returnValues.amount, {
-                    index: event.blockNumber,
-                    hash: event.blockHash,
-                });
-                return [2 /*return*/];
+            .on("data", (event) => __awaiter(this, void 0, void 0, function* () {
+            if (orderId && event.returnValues.orderId != orderId) {
+                return;
+            }
+            if (consumer && event.returnValues.consumer != consumer) {
+                return;
+            }
+            callback(event.returnValues.orderId, event.returnValues.consumer, event.returnValues.amount, {
+                index: event.blockNumber,
+                hash: event.blockHash,
             });
-        }); })
-            .on("error", function (error, receipt) {
+        }))
+            .on("error", (error, receipt) => {
             if (receipt)
                 return; // Used to avoid logging of transaction rejected
             logger.warn(error);
         });
-        return function () { return subscription.unsubscribe(); };
-    };
+        return () => subscription.unsubscribe();
+    }
     /**
      * Function for adding event listeners on order changed withdrawn event in orders contract
      * @param callback - function for processing order changed withdrawn event
      * @param orderId - order id
      * @returns unsubscribe - unsubscribe function from event
      */
-    Orders.onChangedWithdrawn = function (callback, orderId) {
-        var _this = this;
-        var contract = BlockchainEventsListener_1.default.getInstance().getContract();
-        var logger = this.logger.child({ method: "onOrderChangedWithdrawn" });
-        var subscription = contract.events
+    static onChangedWithdrawn(callback, orderId) {
+        const contract = BlockchainEventsListener_1.default.getInstance().getContract();
+        const logger = this.logger.child({ method: "onOrderChangedWithdrawn" });
+        const subscription = contract.events
             .OrderChangedWithdrawn()
-            .on("data", function (event) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (orderId && event.returnValues.orderId != orderId) {
-                    return [2 /*return*/];
-                }
-                callback(event.returnValues.orderId, event.returnValues.consumer, event.returnValues.change, {
-                    index: event.blockNumber,
-                    hash: event.blockHash,
-                });
-                return [2 /*return*/];
+            .on("data", (event) => __awaiter(this, void 0, void 0, function* () {
+            if (orderId && event.returnValues.orderId != orderId) {
+                return;
+            }
+            callback(event.returnValues.orderId, event.returnValues.consumer, event.returnValues.change, {
+                index: event.blockNumber,
+                hash: event.blockHash,
             });
-        }); })
-            .on("error", function (error, receipt) {
+        }))
+            .on("error", (error, receipt) => {
             if (receipt)
                 return; // Used to avoid logging of transaction rejected
             logger.warn(error);
         });
-        return function () { return subscription.unsubscribe(); };
-    };
+        return () => subscription.unsubscribe();
+    }
     /**
      * Function for adding event listeners on order changed refunded event in orders contract
      * @param callback - function for processing order changed refunded event
@@ -441,34 +319,30 @@ var Orders = /** @class */ (function () {
      * @param orderId - order id
      * @returns unsubscribe - unsubscribe function from event
      */
-    Orders.onProfitWithdrawn = function (callback, orderId, tokenReceiver) {
-        var _this = this;
-        var contract = BlockchainEventsListener_1.default.getInstance().getContract();
-        var logger = this.logger.child({ method: "onOrderProfitWithdrawn" });
-        var subscription = contract.events
+    static onProfitWithdrawn(callback, orderId, tokenReceiver) {
+        const contract = BlockchainEventsListener_1.default.getInstance().getContract();
+        const logger = this.logger.child({ method: "onOrderProfitWithdrawn" });
+        const subscription = contract.events
             .OrderProfitWithdrawn()
-            .on("data", function (event) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (orderId && event.returnValues.orderId != orderId) {
-                    return [2 /*return*/];
-                }
-                if (tokenReceiver && event.returnValues.tokenReceiver != tokenReceiver) {
-                    return [2 /*return*/];
-                }
-                callback(event.returnValues.orderId, event.returnValues.tokenReceiver, event.returnValues.profit, {
-                    index: event.blockNumber,
-                    hash: event.blockHash,
-                });
-                return [2 /*return*/];
+            .on("data", (event) => __awaiter(this, void 0, void 0, function* () {
+            if (orderId && event.returnValues.orderId != orderId) {
+                return;
+            }
+            if (tokenReceiver && event.returnValues.tokenReceiver != tokenReceiver) {
+                return;
+            }
+            callback(event.returnValues.orderId, event.returnValues.tokenReceiver, event.returnValues.profit, {
+                index: event.blockNumber,
+                hash: event.blockHash,
             });
-        }); })
-            .on("error", function (error, receipt) {
+        }))
+            .on("error", (error, receipt) => {
             if (receipt)
                 return; // Used to avoid logging of transaction rejected
             logger.warn(error);
         });
-        return function () { return subscription.unsubscribe(); };
-    };
+        return () => subscription.unsubscribe();
+    }
     /**
      * Function for adding event listeners on order awaiting payment event in orders contract
      * @param callback - function for processing order awaiting payment event
@@ -476,34 +350,30 @@ var Orders = /** @class */ (function () {
      * @param orderId - order id
      * @returns unsubscribe - unsubscribe function from event
      */
-    Orders.onAwaitingPaymentChanged = function (callback, consumer, orderId) {
-        var _this = this;
-        var contract = BlockchainEventsListener_1.default.getInstance().getContract();
-        var logger = this.logger.child({ method: "onOrderAwaitingPaymentChanged" });
-        var subscription = contract.events
+    static onAwaitingPaymentChanged(callback, consumer, orderId) {
+        const contract = BlockchainEventsListener_1.default.getInstance().getContract();
+        const logger = this.logger.child({ method: "onOrderAwaitingPaymentChanged" });
+        const subscription = contract.events
             .OrderAwaitingPaymentChanged()
-            .on("data", function (event) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (orderId && event.returnValues.orderId != orderId) {
-                    return [2 /*return*/];
-                }
-                if (consumer && event.returnValues.consumer != consumer) {
-                    return [2 /*return*/];
-                }
-                callback(event.returnValues.orderId, event.returnValues.consumer, event.returnValues.awaitingPayment, {
-                    index: event.blockNumber,
-                    hash: event.blockHash,
-                });
-                return [2 /*return*/];
+            .on("data", (event) => __awaiter(this, void 0, void 0, function* () {
+            if (orderId && event.returnValues.orderId != orderId) {
+                return;
+            }
+            if (consumer && event.returnValues.consumer != consumer) {
+                return;
+            }
+            callback(event.returnValues.orderId, event.returnValues.consumer, event.returnValues.awaitingPayment, {
+                index: event.blockNumber,
+                hash: event.blockHash,
             });
-        }); })
-            .on("error", function (error, receipt) {
+        }))
+            .on("error", (error, receipt) => {
             if (receipt)
                 return; // Used to avoid logging of transaction rejected
             logger.warn(error);
         });
-        return function () { return subscription.unsubscribe(); };
-    };
+        return () => subscription.unsubscribe();
+    }
     /**
      * Function for adding event listeners on order encrypted result updated event in orders contract
      * @param callback - function for processing order encrypted result updated event
@@ -511,34 +381,30 @@ var Orders = /** @class */ (function () {
      * @param orderId - order id
      * @returns unsubscribe - unsubscribe function from event
      */
-    Orders.onEncryptedResultUpdated = function (callback, consumer, orderId) {
-        var _this = this;
-        var contract = BlockchainEventsListener_1.default.getInstance().getContract();
-        var logger = this.logger.child({ method: "onOrderEncryptedResultUpdated" });
-        var subscription = contract.events
+    static onEncryptedResultUpdated(callback, consumer, orderId) {
+        const contract = BlockchainEventsListener_1.default.getInstance().getContract();
+        const logger = this.logger.child({ method: "onOrderEncryptedResultUpdated" });
+        const subscription = contract.events
             .OrderEncryptedResultUpdated()
-            .on("data", function (event) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (orderId && event.returnValues.orderId != orderId) {
-                    return [2 /*return*/];
-                }
-                if (consumer && event.returnValues.consumer != consumer) {
-                    return [2 /*return*/];
-                }
-                callback(event.returnValues.orderId, event.returnValues.consumer, event.returnValues.encryptedResult, {
-                    index: event.blockNumber,
-                    hash: event.blockHash,
-                });
-                return [2 /*return*/];
+            .on("data", (event) => __awaiter(this, void 0, void 0, function* () {
+            if (orderId && event.returnValues.orderId != orderId) {
+                return;
+            }
+            if (consumer && event.returnValues.consumer != consumer) {
+                return;
+            }
+            callback(event.returnValues.orderId, event.returnValues.consumer, event.returnValues.encryptedResult, {
+                index: event.blockNumber,
+                hash: event.blockHash,
             });
-        }); })
-            .on("error", function (error, receipt) {
+        }))
+            .on("error", (error, receipt) => {
             if (receipt)
                 return; // Used to avoid logging of transaction rejected
             logger.warn(error);
         });
-        return function () { return subscription.unsubscribe(); };
-    };
+        return () => subscription.unsubscribe();
+    }
     /**
      * Function for adding event listeners on OrderOptionsDepositSpentChanged event in orders contract
      * @param callback - function for processing order encrypted result updated event
@@ -546,34 +412,30 @@ var Orders = /** @class */ (function () {
      * @param orderId - order id
      * @returns unsubscribe - unsubscribe function from event
      */
-    Orders.onOptionsDepositSpentChanged = function (callback, consumer, orderId) {
-        var _this = this;
-        var contract = BlockchainEventsListener_1.default.getInstance().getContract();
-        var logger = this.logger.child({ method: "onOrderOptionsDepositSpentChanged" });
-        var subscription = contract.events
+    static onOptionsDepositSpentChanged(callback, consumer, orderId) {
+        const contract = BlockchainEventsListener_1.default.getInstance().getContract();
+        const logger = this.logger.child({ method: "onOrderOptionsDepositSpentChanged" });
+        const subscription = contract.events
             .OrderOptionsDepositSpentChanged()
-            .on("data", function (event) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (orderId && event.returnValues.orderId != orderId) {
-                    return [2 /*return*/];
-                }
-                if (consumer && event.returnValues.consumer != consumer) {
-                    return [2 /*return*/];
-                }
-                callback(event.returnValues.consumer, event.returnValues.orderId, event.returnValues.value, {
-                    index: event.blockNumber,
-                    hash: event.blockHash,
-                });
-                return [2 /*return*/];
+            .on("data", (event) => __awaiter(this, void 0, void 0, function* () {
+            if (orderId && event.returnValues.orderId != orderId) {
+                return;
+            }
+            if (consumer && event.returnValues.consumer != consumer) {
+                return;
+            }
+            callback(event.returnValues.consumer, event.returnValues.orderId, event.returnValues.value, {
+                index: event.blockNumber,
+                hash: event.blockHash,
             });
-        }); })
-            .on("error", function (error, receipt) {
+        }))
+            .on("error", (error, receipt) => {
             if (receipt)
                 return; // Used to avoid logging of transaction rejected
             logger.warn(error);
         });
-        return function () { return subscription.unsubscribe(); };
-    };
+        return () => subscription.unsubscribe();
+    }
     /**
      * Function for adding event listeners on onOrderProfitUnlocked event in orders contract
      * @param callback - function for processing order encrypted result updated event
@@ -581,44 +443,39 @@ var Orders = /** @class */ (function () {
      * @param orderId - order id
      * @returns unsubscribe - unsubscribe function from event
      */
-    Orders.onOProfitUnlocked = function (callback, tokenReceiver, orderId) {
-        var _this = this;
-        var contract = BlockchainEventsListener_1.default.getInstance().getContract();
-        var logger = this.logger.child({ method: "onOrderProfitUnlocked" });
-        var subscription = contract.events
+    static onOProfitUnlocked(callback, tokenReceiver, orderId) {
+        const contract = BlockchainEventsListener_1.default.getInstance().getContract();
+        const logger = this.logger.child({ method: "onOrderProfitUnlocked" });
+        const subscription = contract.events
             .OrderProfitUnlocked()
-            .on("data", function (event) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (orderId && event.returnValues.orderId != orderId) {
-                    return [2 /*return*/];
-                }
-                if (tokenReceiver && event.returnValues.tokenReceiver != tokenReceiver) {
-                    return [2 /*return*/];
-                }
-                callback(event.returnValues.tokenReceiver, event.returnValues.orderId, event.returnValues.profit, {
-                    index: event.blockNumber,
-                    hash: event.blockHash,
-                });
-                return [2 /*return*/];
+            .on("data", (event) => __awaiter(this, void 0, void 0, function* () {
+            if (orderId && event.returnValues.orderId != orderId) {
+                return;
+            }
+            if (tokenReceiver && event.returnValues.tokenReceiver != tokenReceiver) {
+                return;
+            }
+            callback(event.returnValues.tokenReceiver, event.returnValues.orderId, event.returnValues.profit, {
+                index: event.blockNumber,
+                hash: event.blockHash,
             });
-        }); })
-            .on("error", function (error, receipt) {
+        }))
+            .on("error", (error, receipt) => {
             if (receipt)
                 return; // Used to avoid logging of transaction rejected
             logger.warn(error);
         });
-        return function () { return subscription.unsubscribe(); };
-    };
-    Orders.logger = logger_1.default.child({ className: "Orders" });
-    __decorate([
-        (0, utils_2.incrementMethodCall)()
-    ], Orders, "createOrder", null);
-    __decorate([
-        (0, utils_2.incrementMethodCall)()
-    ], Orders, "getByExternalId", null);
-    __decorate([
-        (0, utils_2.incrementMethodCall)()
-    ], Orders, "createWorkflow", null);
-    return Orders;
-}());
+        return () => subscription.unsubscribe();
+    }
+}
+Orders.logger = logger_1.default.child({ className: "Orders" });
+__decorate([
+    (0, utils_2.incrementMethodCall)()
+], Orders, "createOrder", null);
+__decorate([
+    (0, utils_2.incrementMethodCall)()
+], Orders, "getByExternalId", null);
+__decorate([
+    (0, utils_2.incrementMethodCall)()
+], Orders, "createWorkflow", null);
 exports.default = Orders;