@super-protocol/sdk-js 0.6.0

package/build/staticModels/ActiveOrders.js

@@ -0,0 +1,120 @@
+"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 ActiveOrdersList_json_1 = __importDefault(require("../contracts/ActiveOrdersList.json"));
+var utils_1 = require("../utils");
+var Superpro_1 = __importDefault(require("./Superpro"));
+var ActiveOrders = /** @class */ (function () {
+    function ActiveOrders() {
+    }
+    Object.defineProperty(ActiveOrders, "address", {
+        get: function () {
+            return Superpro_1.default.address;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    ActiveOrders.checkInit = function (transactionOptions) {
+        if (transactionOptions === null || transactionOptions === void 0 ? void 0 : transactionOptions.web3) {
+            (0, utils_1.checkIfInitialized)();
+            return new transactionOptions.web3.eth.Contract(ActiveOrdersList_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: "ActiveOrder",
+            address: Superpro_1.default.address,
+        });
+        return (this.contract = new store_1.default.web3.eth.Contract(ActiveOrdersList_json_1.default.abi, Superpro_1.default.address));
+    };
+    /**
+     * Function returns amount of active orders
+     * @returns {Promise<BigNumber>}
+     */
+    ActiveOrders.getListOfActiveOrdersSize = 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.getListOfActiveOrdersSize().call()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Function returns ids of active orders
+     * @returns {Promise<string[]>}
+     */
+    ActiveOrders.getListOfActiveOrdersRange = 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: "getListOfActiveOrdersRange" });
+                        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.getListOfActiveOrdersSize().call()];
+                    case 2:
+                        _a = (_b.sent());
+                        _b.label = 3;
+                    case 3:
+                        end = _a;
+                        return [4 /*yield*/, this.contract.methods.getListOfActiveOrdersRange(begin, end).call()];
+                    case 4: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    return ActiveOrders;
+}());
+exports.default = ActiveOrders;

package/build/staticModels/Consensus.d.ts

@@ -0,0 +1,63 @@
+import TCB from "../models/TCB";
+import { PublicData } from "../types/TcbData";
+import { TransactionOptions } from "../types/Web3";
+declare class Consensus {
+    static address: string;
+    private static contract;
+    private static logger;
+    static LEnough: (tcb: TCB) => Promise<boolean>;
+    static offers?: string[];
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    private static checkInit;
+    private static initTcb;
+    private static addToSupply;
+    private static addMarks;
+    /**
+     * Function initialize TCB and returns two lists of anothers' TCB addresses for their checking
+     * @param teeOfferAddress
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns two lists of anothers' TCB addresses for their checking
+     */
+    static getListsForVerification(teeOfferAddress: string, transactionOptions?: TransactionOptions): Promise<{
+        L1: string[];
+        L2: string[];
+    }>;
+    /**
+     * Add data to TeeConfirmationBlock and push it to Consensus
+     * @param teeOfferAddress - TCB's device offer, as key
+     * @param L1Marks - marks of LastBlocks
+     * @param L2Marks - marks of SuspiciousBlocks
+     * @param tcbData - TEE generated
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static addTCB(teeOfferAddress: string, L1Marks: number[], L2Marks: number[], tcbData: {
+        publicData: PublicData;
+        quote: string;
+    }, transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * Function stake and lock TCB's reward
+     * @param tcbAddress - TEE Offer's completed and valid TCB contract
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static claimRewards(tcbAddress: string, transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * Function unlock previously locked TCB rewards (by claimRewards)
+     * @param tcbAddress - TCB contract address
+     * @param unlockAmount - amount of tokens to unlock, max available amount = TeeOffer.getLockInfo(tcbAddress)
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static unlockRewards(tcbAddress: string, unlockAmount: number, transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * Function return last inited TCB of TEE offer
+     * @param teeOfferAddress
+     * */
+    static getInitedTcb(teeOfferAddress: string): Promise<string>;
+    /**
+     * Function return last inited TCB of TEE offer
+     * @param teeOfferAddress
+     * */
+    static getTimeInited(teeOfferAddress: string): Promise<number>;
+}
+export default Consensus;

package/build/staticModels/Consensus.js

@@ -0,0 +1,373 @@
+"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"));
+// import ConsensusJSON from "../contracts/Consensus.json";
+var Offers_json_1 = __importDefault(require("../contracts/Offers.json"));
+var TCB_1 = __importDefault(require("../models/TCB"));
+var LastBlocks_1 = __importDefault(require("./LastBlocks"));
+var Suspicious_1 = __importDefault(require("./Suspicious"));
+var utils_1 = require("../utils");
+var constants_1 = require("../constants");
+var TcbData_1 = require("../types/TcbData");
+var Superpro_1 = __importDefault(require("./Superpro"));
+var TxManager_1 = __importDefault(require("../utils/TxManager"));
+var Consensus = /** @class */ (function () {
+    function Consensus() {
+    }
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    Consensus.checkInit = function (transactionOptions) {
+        if (transactionOptions === null || transactionOptions === void 0 ? void 0 : transactionOptions.web3) {
+            (0, utils_1.checkIfInitialized)();
+            // return new transactionOptions.web3.eth.Contract(<AbiItem[]>ConsensusJSON.abi, this.address);
+            // TODO: stub
+            return new transactionOptions.web3.eth.Contract(Offers_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: "Consensus" });
+        // return this.contract = new store.web3!.eth.Contract(<AbiItem[]>ConsensusJSON.abi, this.address);
+        // TODO: stub
+        this.contract = new store_1.default.web3.eth.Contract(Offers_json_1.default.abi, Superpro_1.default.address);
+        return this.contract;
+    };
+    Consensus.initTcb = function (teeOfferAddress, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tcbAddress;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, TxManager_1.default.execute(this.contract.methods.initTcb, [teeOfferAddress], transactionOptions)];
+                    case 1:
+                        _b.sent();
+                        return [4 /*yield*/, this.getInitedTcb(teeOfferAddress)];
+                    case 2:
+                        tcbAddress = _b.sent();
+                        return [2 /*return*/, new TCB_1.default(tcbAddress)];
+                }
+            });
+        });
+    };
+    Consensus.addToSupply = function (tcbAddress, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, TxManager_1.default.execute(this.contract.methods.addToSupply, [tcbAddress], transactionOptions)];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Consensus.addMarks = function (L1Marks, L2Marks, tcb, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var logger, needAddMarks, addAdjustedMarks, l1MarksDiff, l2MarksDiff;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        logger = this.logger.child({ method: "addTcbMarks" });
+                        needAddMarks = function (lType) { return __awaiter(_this, void 0, void 0, function () {
+                            var _b, _c, _d;
+                            return __generator(this, function (_e) {
+                                switch (_e.label) {
+                                    case 0:
+                                        if (!(lType == TcbData_1.LType.L1)) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, tcb.getL1()];
+                                    case 1:
+                                        _c = (_e.sent()).length;
+                                        return [4 /*yield*/, tcb.getL1Marks()];
+                                    case 2:
+                                        _b = _c - (_e.sent()).length;
+                                        return [3 /*break*/, 6];
+                                    case 3: return [4 /*yield*/, tcb.getL2()];
+                                    case 4:
+                                        _d = (_e.sent()).length;
+                                        return [4 /*yield*/, tcb.getL2Marks()];
+                                    case 5:
+                                        _b = _d - (_e.sent()).length;
+                                        _e.label = 6;
+                                    case 6: return [2 /*return*/, _b];
+                                }
+                            });
+                        }); };
+                        addAdjustedMarks = function (diff, marks, lType) { return __awaiter(_this, void 0, void 0, function () {
+                            var adjustedMarks;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        if (diff > marks.length) {
+                                            logger.error("Invalid L marks count");
+                                            return [2 /*return*/];
+                                        }
+                                        if (!(diff > 0)) return [3 /*break*/, 2];
+                                        adjustedMarks = marks.slice(diff * -1);
+                                        return [4 /*yield*/, tcb.addMarks(lType, adjustedMarks, transactionOptions)];
+                                    case 1:
+                                        _b.sent();
+                                        _b.label = 2;
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        return [4 /*yield*/, needAddMarks(TcbData_1.LType.L1)];
+                    case 1:
+                        l1MarksDiff = _b.sent();
+                        return [4 /*yield*/, needAddMarks(TcbData_1.LType.L2)];
+                    case 2:
+                        l2MarksDiff = _b.sent();
+                        return [4 /*yield*/, addAdjustedMarks(l1MarksDiff, L1Marks, TcbData_1.LType.L1)];
+                    case 3:
+                        _b.sent();
+                        return [4 /*yield*/, addAdjustedMarks(l2MarksDiff, L2Marks, TcbData_1.LType.L2)];
+                    case 4:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function initialize TCB and returns two lists of anothers' TCB addresses for their checking
+     * @param teeOfferAddress
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns two lists of anothers' TCB addresses for their checking
+     */
+    Consensus.getListsForVerification = function (teeOfferAddress, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var alreadyInited, tcbTimeInited, timestamp, tcb, _b, numberOfMissingL2, L1, L2;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this.checkInit();
+                        (0, utils_1.checkIfActionAccountInitialized)();
+                        return [4 /*yield*/, this.getInitedTcb(teeOfferAddress)];
+                    case 1:
+                        alreadyInited = _c.sent();
+                        return [4 /*yield*/, this.getTimeInited(teeOfferAddress)];
+                    case 2:
+                        tcbTimeInited = _c.sent();
+                        return [4 /*yield*/, (0, utils_1.getTimestamp)()];
+                    case 3:
+                        timestamp = _c.sent();
+                        if (!(tcbTimeInited !== 0 && tcbTimeInited + constants_1.ONE_DAY > timestamp)) return [3 /*break*/, 4];
+                        _b = new TCB_1.default(alreadyInited);
+                        return [3 /*break*/, 6];
+                    case 4: return [4 /*yield*/, this.initTcb(teeOfferAddress, transactionOptions)];
+                    case 5:
+                        _b = _c.sent();
+                        _c.label = 6;
+                    case 6:
+                        tcb = _b;
+                        return [4 /*yield*/, this.LEnough(tcb)];
+                    case 7:
+                        if (!!(_c.sent())) return [3 /*break*/, 11];
+                        return [4 /*yield*/, tcb.needL2toCompleted()];
+                    case 8:
+                        numberOfMissingL2 = +(_c.sent());
+                        return [4 /*yield*/, LastBlocks_1.default.getRandomL1(tcb.address, transactionOptions)];
+                    case 9:
+                        _c.sent();
+                        return [4 /*yield*/, Suspicious_1.default.getRandomL2(tcb.address, numberOfMissingL2, transactionOptions)];
+                    case 10:
+                        _c.sent();
+                        _c.label = 11;
+                    case 11: return [4 /*yield*/, tcb.getL1()];
+                    case 12:
+                        L1 = _c.sent();
+                        return [4 /*yield*/, tcb.getL2()];
+                    case 13:
+                        L2 = _c.sent();
+                        return [2 /*return*/, {
+                                L1: L1,
+                                L2: L2,
+                            }];
+                }
+            });
+        });
+    };
+    /**
+     * Add data to TeeConfirmationBlock and push it to Consensus
+     * @param teeOfferAddress - TCB's device offer, as key
+     * @param L1Marks - marks of LastBlocks
+     * @param L2Marks - marks of SuspiciousBlocks
+     * @param tcbData - TEE generated
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    Consensus.addTCB = function (teeOfferAddress, L1Marks, L2Marks, tcbData, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var logger, tcb, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this.checkInit();
+                        (0, utils_1.checkIfActionAccountInitialized)();
+                        logger = this.logger.child({ method: "addTCB" });
+                        _b = TCB_1.default.bind;
+                        return [4 /*yield*/, this.getInitedTcb(teeOfferAddress)];
+                    case 1:
+                        tcb = new (_b.apply(TCB_1.default, [void 0, _c.sent()]))();
+                        return [4 /*yield*/, this.LEnough(tcb)];
+                    case 2:
+                        if (!(_c.sent()))
+                            logger.error("L is not enough to complite TCB");
+                        // Can be upgraded to completion of TCB
+                        return [4 /*yield*/, tcb.addData(tcbData.publicData, tcbData.quote, transactionOptions)];
+                    case 3:
+                        // Can be upgraded to completion of TCB
+                        _c.sent();
+                        return [4 /*yield*/, this.addMarks(L1Marks, L2Marks, tcb, transactionOptions)];
+                    case 4:
+                        _c.sent();
+                        return [4 /*yield*/, this.addToSupply(tcb.address, transactionOptions)];
+                    case 5:
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function stake and lock TCB's reward
+     * @param tcbAddress - TEE Offer's completed and valid TCB contract
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    Consensus.claimRewards = function (tcbAddress, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var contract;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        contract = this.checkInit(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)();
+                        return [4 /*yield*/, TxManager_1.default.execute(contract.methods.claimRewards, [tcbAddress], transactionOptions)];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function unlock previously locked TCB rewards (by claimRewards)
+     * @param tcbAddress - TCB contract address
+     * @param unlockAmount - amount of tokens to unlock, max available amount = TeeOffer.getLockInfo(tcbAddress)
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    Consensus.unlockRewards = function (tcbAddress, unlockAmount, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var contract;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        contract = this.checkInit(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)();
+                        return [4 /*yield*/, TxManager_1.default.execute(contract.methods.unlockRewards, [tcbAddress, unlockAmount], transactionOptions)];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function return last inited TCB of TEE offer
+     * @param teeOfferAddress
+     * */
+    Consensus.getInitedTcb = function (teeOfferAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tcbAddress;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this.checkInit();
+                        return [4 /*yield*/, this.contract.methods.getInitedTcb(teeOfferAddress).call()];
+                    case 1:
+                        tcbAddress = _b.sent();
+                        return [2 /*return*/, tcbAddress];
+                }
+            });
+        });
+    };
+    /**
+     * Function return last inited TCB of TEE offer
+     * @param teeOfferAddress
+     * */
+    Consensus.getTimeInited = function (teeOfferAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tcbTimeInited;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this.checkInit();
+                        return [4 /*yield*/, this.contract.methods.getTimeInited(teeOfferAddress).call()];
+                    case 1:
+                        tcbTimeInited = +(_b.sent());
+                        return [2 /*return*/, tcbTimeInited];
+                }
+            });
+        });
+    };
+    var _a;
+    _a = Consensus;
+    Consensus.LEnough = function (tcb) { return __awaiter(void 0, void 0, void 0, function () {
+        var _b;
+        return __generator(_a, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, tcb.needL1toCompleted()];
+                case 1:
+                    _b = +(_c.sent()) === 0;
+                    if (!_b) return [3 /*break*/, 3];
+                    return [4 /*yield*/, tcb.needL2toCompleted()];
+                case 2:
+                    _b = +(_c.sent()) === 0;
+                    _c.label = 3;
+                case 3: return [2 /*return*/, _b];
+            }
+        });
+    }); };
+    return Consensus;
+}());
+exports.default = Consensus;

package/build/staticModels/Epochs.d.ts

@@ -0,0 +1,23 @@
+import { Epoch } from "../types/Epoch";
+declare class Epochs {
+    static address: string;
+    private static contract;
+    private static logger;
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    private static checkInit;
+    /**
+     * Function for fetching epoch info by index
+     */
+    static getEpoch(index: number): Promise<Epoch>;
+    /**
+     * Function for fetching TCB reward by epoch
+     */
+    static getReward(tcbAddress: string): Promise<number>;
+    /**
+     * Function for fetching TCB last blocks list size
+     */
+    static count(): Promise<number>;
+}
+export default Epochs;

package/build/staticModels/Epochs.js

@@ -0,0 +1,97 @@
+"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 logger_1 = __importDefault(require("../logger"));
+// import EpochsJSON from "../contracts/Epochs.json";
+var utils_1 = require("../utils");
+var Epochs = /** @class */ (function () {
+    function Epochs() {
+    }
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    Epochs.checkInit = function () {
+        if (this.contract)
+            return;
+        (0, utils_1.checkIfInitialized)();
+        // this.contract = new store.web3!.eth.Contract(<AbiItem[]>EpochsJSON.abi, this.address);
+        this.logger = logger_1.default.child({ className: "Epochs" });
+    };
+    /**
+     * Function for fetching epoch info by index
+     */
+    Epochs.getEpoch = function (index) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        startDate: 0,
+                        endDate: 0,
+                        reward: 0,
+                        benchmark: 0,
+                        reparation: 0,
+                        reparationBenchmark: 0,
+                    }];
+            });
+        });
+    };
+    /**
+     * Function for fetching TCB reward by epoch
+     */
+    Epochs.getReward = function (tcbAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, 0];
+            });
+        });
+    };
+    /**
+     * Function for fetching TCB last blocks list size
+     */
+    Epochs.count = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, 0];
+            });
+        });
+    };
+    return Epochs;
+}());
+exports.default = Epochs;