@super-protocol/sdk-js 0.6.0

package/build/providers/storage/StorjStorageProvider.js

@@ -0,0 +1,389 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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 (_) 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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var buffer_1 = require("buffer");
+var utils_1 = require("../../utils");
+var stream_1 = __importDefault(require("stream"));
+var logger_1 = __importDefault(require("../../logger"));
+var ethers_1 = require("ethers");
+var StorJStorageProvider = /** @class */ (function () {
+    function StorJStorageProvider(credentials) {
+        this.logger = logger_1.default.child({ className: "StorJStorageProvider" });
+        if (!(0, utils_1.isNodeJS)()) {
+            throw Error("StorageProvider: StorJ is supported only in the node.js execution environment");
+        }
+        this.bucket = "";
+        this.prefix = "";
+        if (credentials.bucket) {
+            this.bucket = credentials.bucket;
+            this.prefix = credentials.prefix;
+        }
+        else if (credentials.storageId) {
+            // back compatibility
+            this.bucket = credentials.storageId;
+        }
+        this.accessToken = credentials.token;
+    }
+    StorJStorageProvider.prototype.calculateStorageDeposit = function (offer, sizeMb, hours) {
+        return __awaiter(this, void 0, void 0, function () {
+            var offerInfo, properties;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, offer.getInfo()];
+                    case 1:
+                        offerInfo = _a.sent();
+                        properties = JSON.parse(offerInfo.properties);
+                        return [2 /*return*/, ethers_1.BigNumber.from(properties.priceMbPerHour).mul(sizeMb).mul(hours).toString()];
+                }
+            });
+        });
+    };
+    StorJStorageProvider.prototype.uploadFile = function (inputStream, remotePath, contentLength, progressListener) {
+        var inputStream_1, inputStream_1_1;
+        var e_1, _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var storj, options, project, uploader, totalWritten, buffer, e_1_1, uploadingError_1, abortingError_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.lazyStorj()];
+                    case 1:
+                        storj = _b.sent();
+                        options = new storj.UploadOptions();
+                        return [4 /*yield*/, this.lazyProject()];
+                    case 2:
+                        project = _b.sent();
+                        return [4 /*yield*/, project.uploadObject(this.bucket, this.prefix + remotePath, options)];
+                    case 3:
+                        uploader = _b.sent();
+                        totalWritten = 0;
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 19, , 24]);
+                        _b.label = 5;
+                    case 5:
+                        _b.trys.push([5, 11, 12, 17]);
+                        inputStream_1 = __asyncValues(inputStream);
+                        _b.label = 6;
+                    case 6: return [4 /*yield*/, inputStream_1.next()];
+                    case 7:
+                        if (!(inputStream_1_1 = _b.sent(), !inputStream_1_1.done)) return [3 /*break*/, 10];
+                        buffer = inputStream_1_1.value;
+                        return [4 /*yield*/, uploader.write(buffer, buffer.length)];
+                    case 8:
+                        _b.sent();
+                        totalWritten += buffer.length;
+                        if (!!progressListener) {
+                            progressListener(contentLength, totalWritten);
+                        }
+                        _b.label = 9;
+                    case 9: return [3 /*break*/, 6];
+                    case 10: return [3 /*break*/, 17];
+                    case 11:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 17];
+                    case 12:
+                        _b.trys.push([12, , 15, 16]);
+                        if (!(inputStream_1_1 && !inputStream_1_1.done && (_a = inputStream_1.return))) return [3 /*break*/, 14];
+                        return [4 /*yield*/, _a.call(inputStream_1)];
+                    case 13:
+                        _b.sent();
+                        _b.label = 14;
+                    case 14: return [3 /*break*/, 16];
+                    case 15:
+                        if (e_1) throw e_1.error;
+                        return [7 /*endfinally*/];
+                    case 16: return [7 /*endfinally*/];
+                    case 17: return [4 /*yield*/, uploader.commit()];
+                    case 18:
+                        _b.sent();
+                        return [3 /*break*/, 24];
+                    case 19:
+                        uploadingError_1 = _b.sent();
+                        _b.label = 20;
+                    case 20:
+                        _b.trys.push([20, 22, , 23]);
+                        return [4 /*yield*/, uploader.abort()];
+                    case 21:
+                        _b.sent();
+                        return [3 /*break*/, 23];
+                    case 22:
+                        abortingError_1 = _b.sent();
+                        logger_1.default.error({ err: abortingError_1 }, "Failed to abort file uploading");
+                        return [3 /*break*/, 23];
+                    case 23: throw uploadingError_1;
+                    case 24: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    StorJStorageProvider.prototype.downloadFile = function (remotePath, config, progressListener) {
+        return __awaiter(this, void 0, void 0, function () {
+            var storj, project, length, _a, options, downloader, loader;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.lazyStorj()];
+                    case 1:
+                        storj = _b.sent();
+                        return [4 /*yield*/, this.lazyProject()];
+                    case 2:
+                        project = _b.sent();
+                        _a = config.length;
+                        if (_a) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.getObjectSize(remotePath)];
+                    case 3:
+                        _a = (_b.sent());
+                        _b.label = 4;
+                    case 4:
+                        length = _a;
+                        options = new storj.DownloadOptions(config.offset || 0, length);
+                        return [4 /*yield*/, project.downloadObject(this.bucket, this.prefix + remotePath, options)];
+                    case 5:
+                        downloader = _b.sent();
+                        loader = function () {
+                            return __asyncGenerator(this, arguments, function () {
+                                var readBuffer, current, downloadResult, bytesRead;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            readBuffer = buffer_1.Buffer.alloc(StorJStorageProvider.DOWNLOAD_BUFFER_SIZE);
+                                            current = 0;
+                                            _a.label = 1;
+                                        case 1:
+                                            if (!(current < length)) return [3 /*break*/, 5];
+                                            return [4 /*yield*/, __await(downloader.read(readBuffer, readBuffer.length))];
+                                        case 2:
+                                            downloadResult = _a.sent();
+                                            bytesRead = downloadResult.bytes_read;
+                                            current += bytesRead;
+                                            return [4 /*yield*/, __await(buffer_1.Buffer.from(readBuffer.subarray(0, bytesRead)))];
+                                        case 3: return [4 /*yield*/, _a.sent()];
+                                        case 4:
+                                            _a.sent();
+                                            if (!!progressListener) {
+                                                progressListener(length, current);
+                                            }
+                                            return [3 /*break*/, 1];
+                                        case 5: return [2 /*return*/];
+                                    }
+                                });
+                            });
+                        };
+                        return [2 /*return*/, stream_1.default.Readable.from(loader()).on("close", function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, downloader.close()];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                }
+            });
+        });
+    };
+    StorJStorageProvider.prototype.deleteObject = function (remotePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var project;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.lazyProject()];
+                    case 1:
+                        project = _a.sent();
+                        return [4 /*yield*/, project.deleteObject(this.bucket, this.prefix + remotePath)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    StorJStorageProvider.prototype.listObjects = function (remotePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var storj, project, objects, result, key, value;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.lazyStorj()];
+                    case 1:
+                        storj = _a.sent();
+                        return [4 /*yield*/, this.lazyProject()];
+                    case 2:
+                        project = _a.sent();
+                        return [4 /*yield*/, project.listObjects(this.bucket, {
+                                recursive: true,
+                                cursor: "",
+                                prefix: this.prefix + remotePath,
+                                system: true,
+                                custom: true,
+                            })];
+                    case 3:
+                        objects = _a.sent();
+                        result = [];
+                        for (key in Object.keys(objects)) {
+                            value = objects[key];
+                            result.push({
+                                name: value.key,
+                                size: value.system.content_length,
+                                isFolder: value.is_prefix == 1,
+                                childrenCount: value.custom.count,
+                                createdAt: new Date(value.system.created * 1000), // TODO: check timezone
+                            });
+                        }
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    StorJStorageProvider.prototype.getObjectSize = function (remotePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var project, objectInfo;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.lazyProject()];
+                    case 1:
+                        project = _a.sent();
+                        return [4 /*yield*/, project.statObject(this.bucket, this.prefix + remotePath)];
+                    case 2:
+                        objectInfo = _a.sent();
+                        return [2 /*return*/, objectInfo.system.content_length];
+                }
+            });
+        });
+    };
+    StorJStorageProvider.prototype.getLastModified = function (remotePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var project, objectInfo;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.lazyProject()];
+                    case 1:
+                        project = _a.sent();
+                        return [4 /*yield*/, project.statObject(this.bucket, this.prefix + remotePath)];
+                    case 2:
+                        objectInfo = _a.sent();
+                        return [2 /*return*/, new Date(objectInfo.system.created * 1000)];
+                }
+            });
+        });
+    };
+    StorJStorageProvider.prototype.lazyStorj = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!!this._storj) return [3 /*break*/, 2];
+                        _a = this;
+                        return [4 /*yield*/, require("@super-protocol/uplink-nodejs")];
+                    case 1:
+                        _a._storj = _b.sent();
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, this._storj];
+                }
+            });
+        });
+    };
+    StorJStorageProvider.prototype.lazyAccess = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var storj, uplink, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!!this._access) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.lazyStorj()];
+                    case 1:
+                        storj = _b.sent();
+                        uplink = new storj.Uplink();
+                        _a = this;
+                        return [4 /*yield*/, uplink.parseAccess(this.accessToken)];
+                    case 2:
+                        _a._access = _b.sent();
+                        _b.label = 3;
+                    case 3: return [2 /*return*/, this._access];
+                }
+            });
+        });
+    };
+    StorJStorageProvider.prototype.lazyProject = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var access, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!!this._project) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.lazyAccess()];
+                    case 1:
+                        access = _b.sent();
+                        _a = this;
+                        return [4 /*yield*/, access.openProject()];
+                    case 2:
+                        _a._project = _b.sent();
+                        _b.label = 3;
+                    case 3: return [2 /*return*/, this._project];
+                }
+            });
+        });
+    };
+    StorJStorageProvider.DOWNLOAD_BUFFER_SIZE = 4194304; // 4mb
+    return StorJStorageProvider;
+}());
+exports.default = StorJStorageProvider;

package/build/providers/storage/getStorageProvider.d.ts

@@ -0,0 +1,4 @@
+import StorageAccess from "../../types/storage/StorageAccess";
+import IStorageProvider from "./IStorageProvider";
+declare const _default: (storageAccess: StorageAccess) => IStorageProvider;
+export default _default;

package/build/providers/storage/getStorageProvider.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var dto_js_1 = require("@super-protocol/dto-js");
+var StorjStorageProvider_1 = __importDefault(require("./StorjStorageProvider"));
+exports.default = (function (storageAccess) {
+    var key = storageAccess.storageType;
+    switch (key) {
+        case dto_js_1.StorageType.StorJ:
+            return new StorjStorageProvider_1.default(storageAccess.credentials);
+        default:
+            throw Error("Unsupported storageType ".concat(key));
+    }
+});

package/build/staticModels/ActiveOffers.d.ts

@@ -0,0 +1,29 @@
+import { BigNumber } from "ethers";
+import { TransactionOptions } from "../types/Web3";
+declare class ActiveOffers {
+    private static contract;
+    private static logger;
+    static offers?: string[];
+    static get address(): string;
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    private static checkInit;
+    static getListOfActiveOffersSize(): Promise<BigNumber>;
+    static getActiveOffersEventsQueueLength(): Promise<BigNumber>;
+    /**
+     * Function returns ids of active offers (value and TEE)
+     * Attention! Check active offers events queue length before calling this function, for actualy status it should be equal to 0.
+     * @param begin The first element of range.
+     * @param end One past the final element in the range.
+     * @returns {Promise<string[]>}
+     */
+    static getListOfActiveOffersRange(begin?: BigNumber | number, end?: BigNumber | number): Promise<string[]>;
+    /**
+     * Function updates information about the list of current offers
+     * @param maxProcessedEvents - maximum number of events to process (affects gas cost of operation)
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static updateListOfActiveOffers(maxProcessedEvents: number, transactionOptions?: TransactionOptions): Promise<void>;
+}
+export default ActiveOffers;

package/build/staticModels/ActiveOffers.js

@@ -0,0 +1,144 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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 (_) 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 store_1 = __importDefault(require("../store"));
+var logger_1 = __importDefault(require("../logger"));
+var ActiveOffersList_json_1 = __importDefault(require("../contracts/ActiveOffersList.json"));
+var utils_1 = require("../utils");
+var Superpro_1 = __importDefault(require("./Superpro"));
+var TxManager_1 = __importDefault(require("../utils/TxManager"));
+var ActiveOffers = /** @class */ (function () {
+    function ActiveOffers() {
+    }
+    Object.defineProperty(ActiveOffers, "address", {
+        get: function () {
+            return Superpro_1.default.address;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    ActiveOffers.checkInit = function (transactionOptions) {
+        if (transactionOptions === null || transactionOptions === void 0 ? void 0 : transactionOptions.web3) {
+            (0, utils_1.checkIfInitialized)();
+            return new transactionOptions.web3.eth.Contract(ActiveOffersList_json_1.default.abi, Superpro_1.default.address);
+        }
+        if (this.contract)
+            return this.contract;
+        (0, utils_1.checkIfInitialized)();
+        this.logger = logger_1.default.child({ className: "ActiveOffers" });
+        return (this.contract = new store_1.default.web3.eth.Contract(ActiveOffersList_json_1.default.abi, Superpro_1.default.address));
+    };
+    ActiveOffers.getListOfActiveOffersSize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.checkInit();
+                        return [4 /*yield*/, this.contract.methods.getListOfActiveOffersSize().call()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    ActiveOffers.getActiveOffersEventsQueueLength = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.checkInit();
+                return [2 /*return*/, this.contract.methods.getActiveOffersEventsQueueLength().call()];
+            });
+        });
+    };
+    /**
+     * Function returns ids of active offers (value and TEE)
+     * Attention! Check active offers events queue length before calling this function, for actualy status it should be equal to 0.
+     * @param begin The first element of range.
+     * @param end One past the final element in the range.
+     * @returns {Promise<string[]>}
+     */
+    ActiveOffers.getListOfActiveOffersRange = function (begin, end) {
+        return __awaiter(this, void 0, void 0, function () {
+            var logger, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this.checkInit();
+                        logger = this.logger.child({ method: "getListOfActiveOffersRange" });
+                        begin = begin !== null && begin !== void 0 ? begin : 0;
+                        if (!(end !== null && end !== void 0)) return [3 /*break*/, 1];
+                        _a = end;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.contract.methods.getListOfActiveOffersSize().call()];
+                    case 2:
+                        _a = (_b.sent());
+                        _b.label = 3;
+                    case 3:
+                        end = _a;
+                        return [4 /*yield*/, this.contract.methods.getListOfActiveOffersRange(begin, end).call()];
+                    case 4: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Function updates information about the list of current offers
+     * @param maxProcessedEvents - maximum number of events to process (affects gas cost of operation)
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    ActiveOffers.updateListOfActiveOffers = function (maxProcessedEvents, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.checkInit();
+                        return [4 /*yield*/, TxManager_1.default.execute(this.contract.methods.updateListOfActiveOffers, [maxProcessedEvents], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return ActiveOffers;
+}());
+exports.default = ActiveOffers;

package/build/staticModels/ActiveOrders.d.ts

@@ -0,0 +1,21 @@
+import { BigNumber } from "ethers";
+declare class ActiveOrders {
+    private static contract;
+    private static logger;
+    static get address(): string;
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    private static checkInit;
+    /**
+     * Function returns amount of active orders
+     * @returns {Promise<BigNumber>}
+     */
+    static getListOfActiveOrdersSize(): Promise<BigNumber>;
+    /**
+     * Function returns ids of active orders
+     * @returns {Promise<string[]>}
+     */
+    static getListOfActiveOrdersRange(begin?: BigNumber | number, end?: BigNumber | number): Promise<string[]>;
+}
+export default ActiveOrders;