@super-protocol/sdk-js 0.14.0-beta.0 → 0.14.1-beta.2

package/build/TIIGenerator.js

@@ -58,6 +58,7 @@ var crypto_1 = __importDefault(require("./crypto"));
 var Offer_1 = __importDefault(require("./models/Offer"));
 var Order_1 = __importDefault(require("./models/Order"));
 var TeeOffer_1 = __importDefault(require("./models/TeeOffer"));
+var TCB_1 = __importDefault(require("./models/TCB"));
 var dto_js_1 = require("@super-protocol/dto-js");
 var tee_lib_1 = require("@super-protocol/tee-lib");
 var TIIGenerator = /** @class */ (function () {
@@ -65,7 +66,7 @@ var TIIGenerator = /** @class */ (function () {
     }
     TIIGenerator.generateByOffer = function (offerId, solutionHashes, linkageString, resource, args, encryption) {
         return __awaiter(this, void 0, void 0, function () {
-            var teeOffer, teeOfferInfo, linkage, tlb, mac, rawTri, tri, compressedTri, _a, _b, _c, _d;
+            var teeOffer, teeOfferInfo, tcbId, tcb, linkage, tlb, mac, rawTri, tri, compressedTri, _a, _b, _c, _d;
             var _e, _f;
             return __generator(this, function (_g) {
                 switch (_g.label) {
@@ -74,13 +75,22 @@ var TIIGenerator = /** @class */ (function () {
                         return [4 /*yield*/, teeOffer.getInfo()];
                     case 1:
                         teeOfferInfo = _g.sent();
+                        return [4 /*yield*/, teeOffer.getActualTcbId()];
+                    case 2:
+                        tcbId = _g.sent();
+                        if (tcbId === "0") {
+                            throw Error("Tee offer isn't avaliable before added TCB");
+                        }
+                        return [4 /*yield*/, new TCB_1.default(tcbId).get()];
+                    case 3:
+                        tcb = _g.sent();
                         linkage = linkageString
                             ? JSON.parse(linkageString)
                             : {
                                 encoding: dto_js_1.Encoding.base64,
                                 mrenclave: "",
                             };
-                        tlb = new tee_lib_1.TLBlockSerializerV1().unserializeTlb(Buffer.from(teeOfferInfo.tlb, "base64"));
+                        tlb = new tee_lib_1.TLBlockSerializerV1().unserializeTlb(Buffer.from(tcb.quote, "base64"));
                         mac = encryption.authTag || encryption.mac;
                         rawTri = {
                             solutionHashes: solutionHashes.map(function (hash) { return ({
@@ -97,21 +107,21 @@ var TIIGenerator = /** @class */ (function () {
                         _b = (_a = Compression_1.Compression).encode;
                         _e = {};
                         return [4 /*yield*/, (0, node_gzip_1.gzip)(tri)];
-                    case 2:
+                    case 4:
                         compressedTri = _b.apply(_a, [(_e.data = _g.sent(),
                                 _e.type = Compression_1.Compression_TYPE.GZIP,
                                 _e)]).finish();
                         _d = (_c = JSON).stringify;
                         _f = {};
                         return [4 /*yield*/, crypto_1.default.encrypt(JSON.stringify(resource), JSON.parse(teeOfferInfo.argsPublicKey))];
-                    case 3:
+                    case 5:
                         _f.encryptedResource = _g.sent();
                         return [4 /*yield*/, crypto_1.default.encrypt(Buffer.from(compressedTri).toString(dto_js_1.Encoding.base64), {
                                 algo: dto_js_1.CryptoAlgorithm.ECIES,
                                 key: Buffer.from(tlb.data.teePubKeyData).toString("base64"),
                                 encoding: dto_js_1.Encoding.base64,
                             })];
-                    case 4: return [2 /*return*/, _d.apply(_c, [(_f.tri = _g.sent(),
+                    case 6: return [2 /*return*/, _d.apply(_c, [(_f.tri = _g.sent(),
                                 _f)])];
                 }
             });

package/build/constants.d.ts

@@ -6,3 +6,5 @@ export declare const defaultGasLimitMultiplier = 1.2;
 export declare const ONE_DAY: number;
 export declare const BLOCK_SIZE_TO_FETCH_TRANSACTION = 500;
 export declare const POLYGON_MATIC_EVENT_PATH = "0x0000000000000000000000000000000000001010";
+export declare const BLOCKCHAIN_CALL_RETRY_ATTEMPTS = 10;
+export declare const BLOCKCHAIN_CALL_RETRY_INTERVAL = 3000;

package/build/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.POLYGON_MATIC_EVENT_PATH = exports.BLOCK_SIZE_TO_FETCH_TRANSACTION = exports.ONE_DAY = exports.defaultGasLimitMultiplier = exports.defaultGasPriceMultiplier = exports.defaultGasPrice = exports.defaultGasLimit = exports.defaultBlockchainUrl = void 0;
+exports.BLOCKCHAIN_CALL_RETRY_INTERVAL = exports.BLOCKCHAIN_CALL_RETRY_ATTEMPTS = exports.POLYGON_MATIC_EVENT_PATH = exports.BLOCK_SIZE_TO_FETCH_TRANSACTION = exports.ONE_DAY = exports.defaultGasLimitMultiplier = exports.defaultGasPriceMultiplier = exports.defaultGasPrice = exports.defaultGasLimit = exports.defaultBlockchainUrl = void 0;
 exports.defaultBlockchainUrl = "http://127.0.0.1:8545";
 exports.defaultGasLimit = 7000000;
 exports.defaultGasPrice = "3000000000";
@@ -9,3 +9,5 @@ exports.defaultGasLimitMultiplier = 1.2;
 exports.ONE_DAY = 24 * 60 * 60;
 exports.BLOCK_SIZE_TO_FETCH_TRANSACTION = 500;
 exports.POLYGON_MATIC_EVENT_PATH = "0x0000000000000000000000000000000000001010";
+exports.BLOCKCHAIN_CALL_RETRY_ATTEMPTS = 10;
+exports.BLOCKCHAIN_CALL_RETRY_INTERVAL = 3000;

package/build/models/Offer.d.ts

@@ -73,6 +73,7 @@ declare class Offer {
      */
     getCheapestPrice(): Promise<string>;
     isOfferExists(): Promise<boolean>;
+    private checkIfOfferExistsWithInterval;
     /**
      * Function for fetching whether offer slot exists or not
      * @param slotId - Slot ID

package/build/models/Offer.js

@@ -59,6 +59,8 @@ var OptionInfo_1 = require("../types/OptionInfo");
 var SlotUsage_1 = require("../types/SlotUsage");
 var utils_2 = require("ethers/lib/utils");
 var TeeOffers_1 = __importDefault(require("../staticModels/TeeOffers"));
+var helpers_1 = require("../utils/helpers");
+var constants_1 = require("../constants");
 var Offer = /** @class */ (function () {
     function Offer(offerId) {
         this.id = offerId;
@@ -167,8 +169,13 @@ var Offer = /** @class */ (function () {
             var _a, offerInfoParams;
             return __generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, Offer.contract.methods.getValueOffer(this.id).call()];
+                    case 0: return [4 /*yield*/, this.checkIfOfferExistsWithInterval()];
                     case 1:
+                        if (!(_b.sent())) {
+                            throw Error("Offer ".concat(this.id, " does not exist"));
+                        }
+                        return [4 /*yield*/, Offer.contract.methods.getValueOffer(this.id).call()];
+                    case 2:
                         _a = _b.sent(), offerInfoParams = _a[2];
                         this.offerInfo = (0, utils_1.tupleToObject)(offerInfoParams, Offer_1.OfferInfoStructure);
                         return [2 /*return*/, this.offerInfo];
@@ -292,6 +299,29 @@ var Offer = /** @class */ (function () {
             });
         });
     };
+    Offer.prototype.checkIfOfferExistsWithInterval = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var offerExists;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, helpers_1.tryWithInterval)({
+                            handler: function () { return _this.isOfferExists(); },
+                            checkResult: function (exists) {
+                                if (!exists)
+                                    _this.logger.debug("Offer ".concat(_this.id, " exists: ").concat(exists));
+                                return { isResultOk: exists };
+                            },
+                            retryInterval: constants_1.BLOCKCHAIN_CALL_RETRY_INTERVAL,
+                            retryMax: constants_1.BLOCKCHAIN_CALL_RETRY_ATTEMPTS,
+                        })];
+                    case 1:
+                        offerExists = _a.sent();
+                        return [2 /*return*/, offerExists];
+                }
+            });
+        });
+    };
     /**
      * Function for fetching whether offer slot exists or not
      * @param slotId - Slot ID

package/build/models/Order.d.ts

@@ -38,6 +38,7 @@ declare class Order {
      * Function for fetching order info from blockchain
      */
     getOrderInfo(): Promise<OrderInfo>;
+    private checkIfOrderExistsWithInterval;
     getConsumer(): Promise<string>;
     /**
      * Function for fetching order result from blockchain

package/build/models/Order.js

@@ -68,6 +68,8 @@ var Superpro_1 = __importDefault(require("../staticModels/Superpro"));
 var TxManager_1 = __importDefault(require("../utils/TxManager"));
 var BlockchainEventsListener_1 = __importDefault(require("../connectors/BlockchainEventsListener"));
 var TeeOffers_1 = __importDefault(require("../staticModels/TeeOffers"));
+var helpers_1 = require("../utils/helpers");
+var constants_1 = require("../constants");
 var Order = /** @class */ (function () {
     function Order(orderId) {
         this.id = orderId;
@@ -147,7 +149,7 @@ var Order = /** @class */ (function () {
             var orderInfoParams;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.isExist()];
+                    case 0: return [4 /*yield*/, this.checkIfOrderExistsWithInterval()];
                     case 1:
                         if (!(_a.sent())) {
                             throw Error("Order ".concat(this.id, " does not exist"));
@@ -160,6 +162,29 @@ var Order = /** @class */ (function () {
             });
         });
     };
+    Order.prototype.checkIfOrderExistsWithInterval = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var offerExists;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, helpers_1.tryWithInterval)({
+                            handler: function () { return _this.isExist(); },
+                            checkResult: function (exists) {
+                                if (!exists)
+                                    _this.logger.debug("Order ".concat(_this.id, " exists: ").concat(exists));
+                                return { isResultOk: exists };
+                            },
+                            retryInterval: constants_1.BLOCKCHAIN_CALL_RETRY_INTERVAL,
+                            retryMax: constants_1.BLOCKCHAIN_CALL_RETRY_ATTEMPTS,
+                        })];
+                    case 1:
+                        offerExists = _a.sent();
+                        return [2 /*return*/, offerExists];
+                }
+            });
+        });
+    };
     Order.prototype.getConsumer = function () {
         return __awaiter(this, void 0, void 0, function () {
             var orderInfoParams;

package/build/models/TeeOffer.d.ts

@@ -8,6 +8,7 @@ import { TeeOfferSlot } from "../types/TeeOfferSlot";
 import { OptionInfo } from "../types/OptionInfo";
 import { SlotUsage } from "../types/SlotUsage";
 import { SlotInfo } from "../types/SlotInfo";
+import { GetTcbRequest } from "@super-protocol/dto-js";
 declare class TeeOffer {
     private static contract;
     private logger;
@@ -95,6 +96,15 @@ declare class TeeOffer {
      * @param transactionOptions - object what contains alternative action account or gas limit (optional)
      */
     deleteOption(optionId: string, transactionOptions?: TransactionOptions): Promise<void>;
+    initializeTcb(transactionOptions?: TransactionOptions): Promise<void>;
+    private initializeTcbAndAssignBlocks;
+    /**
+     * Function initialize TCB and returns list of anothers' TCB for their checking
+     * @param teeOfferId - id of TEE offer
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns tcbId and lists of anothers' TCB for their checking
+     */
+    getListsForVerification(transactionOptions?: TransactionOptions): Promise<GetTcbRequest>;
     /**
      * Function for fetching whether tee offer slot exists or not
      * @param slotId - Slot ID
@@ -133,6 +143,17 @@ declare class TeeOffer {
      * @param transactionOptions - object what contains alternative action account or gas limit (optional)
      */
     deleteSlot(slotId: string, transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * @param teeOfferId - TEE offer ID
+     * @returns {Promise<string>} - Actual TCB ID
+     */
+    getActualTcbId(): Promise<string>;
+    /**
+     * Function return last inited TCB of TEE offer
+     * @param teeOfferId - id of TEE offer
+     * */
+    getInitializedTcbId(): Promise<string>;
+    isTcbCreationAvailable(): Promise<boolean>;
     /**
      * Function for fetching TEE offer provider authority account from blockchain
      */
@@ -146,22 +167,10 @@ declare class TeeOffer {
      * Function for fetching TLB provider from blockchain
      */
     getTlb(): Promise<string>;
-    /**
-     * Function for fetching last TLB addition time for this TEE offer
-     */
-    getLastTlbAddedTime(): Promise<number>;
-    /**
-     * Function for fetching last TCB addition time for this TEE offer
-     */
-    getLastTcbAddedTime(): Promise<number>;
     /**
      * Function for fetching violationRate for this TEE offer
      */
     getViolationRate(): Promise<number>;
-    /**
-     * Function for fetching amount of total locked tokens
-     */
-    getTotalLocked(): Promise<number>;
     /**
      * Fetch new Origins (createdDate, createdBy, modifiedDate and modifiedBy)
      */

package/build/models/TeeOffer.js

@@ -61,6 +61,7 @@ var SlotUsage_1 = require("../types/SlotUsage");
 var utils_2 = require("ethers/lib/utils");
 var SlotInfo_1 = require("../types/SlotInfo");
 var TeeOffers_1 = __importDefault(require("../staticModels/TeeOffers"));
+var TCB_1 = __importDefault(require("../models/TCB"));
 var TeeOffer = /** @class */ (function () {
     function TeeOffer(offerId) {
         this.id = offerId;
@@ -308,6 +309,94 @@ var TeeOffer = /** @class */ (function () {
             });
         });
     };
+    TeeOffer.prototype.initializeTcb = function (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();
+                        (0, utils_1.checkIfActionAccountInitialized)();
+                        return [4 /*yield*/, TxManager_1.default.execute(contract.methods.initializeTcb, [this.id], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TeeOffer.prototype.initializeTcbAndAssignBlocks = function (transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tcbId, tcb;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.initializeTcb(transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.getInitializedTcbId()];
+                    case 2:
+                        tcbId = _a.sent();
+                        tcb = new TCB_1.default(tcbId);
+                        return [4 /*yield*/, tcb.assignLastBlocksToCheck(transactionOptions)];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, tcb.assignSuspiciousBlocksToCheck(transactionOptions)];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/, tcb];
+                }
+            });
+        });
+    };
+    /**
+     * Function initialize TCB and returns list of anothers' TCB for their checking
+     * @param teeOfferId - id of TEE offer
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns tcbId and lists of anothers' TCB for their checking
+     */
+    TeeOffer.prototype.getListsForVerification = function (transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tcb, blocksIds, tcbsForVerification, blockIndex, tcb_1, tcbInfo;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        (0, utils_1.checkIfActionAccountInitialized)();
+                        return [4 /*yield*/, this.initializeTcbAndAssignBlocks(transactionOptions)];
+                    case 1:
+                        tcb = _a.sent();
+                        return [4 /*yield*/, tcb.getCheckingBlocksMarks()];
+                    case 2:
+                        blocksIds = (_a.sent()).blocksIds;
+                        tcbsForVerification = [];
+                        blockIndex = 0;
+                        _a.label = 3;
+                    case 3:
+                        if (!(blockIndex < blocksIds.length)) return [3 /*break*/, 6];
+                        tcb_1 = new TCB_1.default(blocksIds[blockIndex]);
+                        return [4 /*yield*/, tcb_1.get()];
+                    case 4:
+                        tcbInfo = _a.sent();
+                        tcbsForVerification.push({
+                            tcbId: blocksIds[blockIndex].toString(),
+                            deviceId: tcbInfo.publicData.deviceID,
+                            properties: tcbInfo.publicData.properties,
+                            benchmark: tcbInfo.publicData.benchmark,
+                            quote: tcbInfo.quote,
+                            marks: tcbInfo.utilData.checkingBlockMarks,
+                            checkingBlocks: tcbInfo.utilData.checkingBlocks,
+                        });
+                        _a.label = 5;
+                    case 5:
+                        blockIndex++;
+                        return [3 /*break*/, 3];
+                    case 6: return [2 /*return*/, {
+                            tcbId: tcb.tcbId,
+                            tcbsForVerification: tcbsForVerification,
+                        }];
+                }
+            });
+        });
+    };
     /**
      * Function for fetching whether tee offer slot exists or not
      * @param slotId - Slot ID
@@ -471,6 +560,43 @@ var TeeOffer = /** @class */ (function () {
             });
         });
     };
+    /**
+     * @param teeOfferId - TEE offer ID
+     * @returns {Promise<string>} - Actual TCB ID
+     */
+    TeeOffer.prototype.getActualTcbId = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, TeeOffer.contract.methods.getActualTcbId(this.id).call()];
+            });
+        });
+    };
+    /**
+     * Function return last inited TCB of TEE offer
+     * @param teeOfferId - id of TEE offer
+     * */
+    TeeOffer.prototype.getInitializedTcbId = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, TeeOffer.contract.methods.getInitializedTcbId(this.id).call()];
+            });
+        });
+    };
+    TeeOffer.prototype.isTcbCreationAvailable = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, offerNotBlocked, newEpochStarted, halfEpochPassed, benchmarkVerified;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, TeeOffer.contract.methods
+                            .isTcbCreationAvailable(this.id)
+                            .call()];
+                    case 1:
+                        _a = _b.sent(), offerNotBlocked = _a[0], newEpochStarted = _a[1], halfEpochPassed = _a[2], benchmarkVerified = _a[3];
+                        return [2 /*return*/, offerNotBlocked && newEpochStarted && halfEpochPassed && benchmarkVerified];
+                }
+            });
+        });
+    };
     /**
      * Function for fetching TEE offer provider authority account from blockchain
      */
@@ -533,37 +659,6 @@ var TeeOffer = /** @class */ (function () {
             });
         });
     };
-    /**
-     * Function for fetching last TLB addition time for this TEE offer
-     */
-    TeeOffer.prototype.getLastTlbAddedTime = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this;
-                        return [4 /*yield*/, TeeOffer.contract.methods.getTeeOfferLastTlbAddedTime().call()];
-                    case 1:
-                        _a.tlbAddedTime = _b.sent();
-                        return [2 /*return*/, this.tlbAddedTime];
-                }
-            });
-        });
-    };
-    /**
-     * Function for fetching last TCB addition time for this TEE offer
-     */
-    TeeOffer.prototype.getLastTcbAddedTime = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                // this.tcbAddedTime = await TeeOffer.contract.methods.getLastTcbAddedTime().call();
-                // return this.tcbAddedTime!;
-                // TODO: stub
-                return [2 /*return*/, 0];
-            });
-        });
-    };
     /**
      * Function for fetching violationRate for this TEE offer
      */
@@ -582,19 +677,6 @@ var TeeOffer = /** @class */ (function () {
             });
         });
     };
-    /**
-     * Function for fetching amount of total locked tokens
-     */
-    TeeOffer.prototype.getTotalLocked = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                // this.totalLocked = await TeeOffer.contract.methods.getTotalLocked().call();
-                // return this.totalLocked!;
-                // TODO: stub
-                return [2 /*return*/, 0];
-            });
-        });
-    };
     /**
      * Fetch new Origins (createdDate, createdBy, modifiedDate and modifiedBy)
      */
@@ -819,6 +901,15 @@ var TeeOffer = /** @class */ (function () {
     __decorate([
         (0, utils_1.incrementMethodCall)()
     ], TeeOffer.prototype, "deleteOption", null);
+    __decorate([
+        (0, utils_1.incrementMethodCall)()
+    ], TeeOffer.prototype, "initializeTcb", null);
+    __decorate([
+        (0, utils_1.incrementMethodCall)()
+    ], TeeOffer.prototype, "initializeTcbAndAssignBlocks", null);
+    __decorate([
+        (0, utils_1.incrementMethodCall)()
+    ], TeeOffer.prototype, "getListsForVerification", null);
     __decorate([
         (0, utils_1.incrementMethodCall)()
     ], TeeOffer.prototype, "addSlot", null);

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

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import IStorageProvider, { DownloadConfig } from "./IStorageProvider";
+import { Readable } from "stream";
+import StorageObject from "../../types/storage/StorageObject";
+export type S3ClientConfig = {
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint: string;
+    bucket: string;
+};
+export declare class S3StorageProvider implements IStorageProvider {
+    private readonly s3Client;
+    private readonly bucket;
+    private readonly multipartChunkSizeInBytes;
+    constructor(storageAccess: S3ClientConfig);
+    uploadFile(inputStream: Readable, remotePath: string, contentLength: number, progressListener?: ((total: number, current: number) => void) | undefined): Promise<void>;
+    private multipartUpload;
+    deleteObject(remotePath: string): Promise<void>;
+    downloadFile(remotePath: string, config: DownloadConfig, progressListener?: ((total: number, current: number) => void) | undefined): Promise<Readable>;
+    listObjects(remotePath: string): Promise<StorageObject[]>;
+    private getMetadata;
+    getObjectSize(remotePath: string): Promise<number>;
+    getLastModified(remotePath: string): Promise<Date>;
+}

package/build/providers/storage/S3StorageProvider.js

@@ -0,0 +1,357 @@
+"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 (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 __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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3StorageProvider = void 0;
+var aws_sdk_1 = require("aws-sdk");
+var S3StorageProvider = /** @class */ (function () {
+    function S3StorageProvider(storageAccess) {
+        this.multipartChunkSizeInBytes = 64 * 1024 * 1024; // 64MB
+        var accessKeyId = storageAccess.accessKeyId, secretAccessKey = storageAccess.secretAccessKey, endpoint = storageAccess.endpoint, bucket = storageAccess.bucket;
+        if (!accessKeyId)
+            throw new Error("Access key id is undefined");
+        if (!secretAccessKey)
+            throw new Error("Secret access is undefined");
+        if (!endpoint)
+            throw new Error("Endpoint is undefined");
+        if (!bucket)
+            throw new Error("Bucket is undefined");
+        this.bucket = bucket;
+        this.s3Client = new aws_sdk_1.S3({
+            credentials: {
+                accessKeyId: accessKeyId,
+                secretAccessKey: secretAccessKey,
+            },
+            endpoint: endpoint,
+            s3ForcePathStyle: true,
+            signatureVersion: "v4",
+            httpOptions: { timeout: 0 },
+        });
+    }
+    S3StorageProvider.prototype.uploadFile = function (inputStream, remotePath, contentLength, progressListener) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // For performance & cost optimization
+                        // https://docs.storj.io/dcs/api-reference/s3-compatible-gateway/multipart-upload/multipart-part-size
+                        if (inputStream.readableHighWaterMark >= this.multipartChunkSizeInBytes) {
+                            return [2 /*return*/, this.multipartUpload(inputStream, remotePath, contentLength, progressListener)];
+                        }
+                        return [4 /*yield*/, this.s3Client
+                                .putObject({
+                                Body: inputStream,
+                                Bucket: this.bucket,
+                                Key: remotePath,
+                                ContentLength: contentLength,
+                            })
+                                .on("httpUploadProgress", function (_a) {
+                                var total = _a.total, loaded = _a.loaded;
+                                return progressListener === null || progressListener === void 0 ? void 0 : progressListener(total, loaded);
+                            })
+                                .promise()];
+                    case 1:
+                        result = _a.sent();
+                        if (result.$response.error) {
+                            throw result.$response.error;
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    S3StorageProvider.prototype.multipartUpload = function (inputStream, remotePath, contentLength, progressListener) {
+        var _a, inputStream_1, inputStream_1_1;
+        var _b, e_1, _c, _d;
+        return __awaiter(this, void 0, void 0, function () {
+            var multipart, totalWritten, partNumber, uploadId, parts, buffer, response, e_1_1, doneParams, uploadingError_1;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, this.s3Client
+                            .createMultipartUpload({
+                            Bucket: this.bucket,
+                            Key: remotePath,
+                        })
+                            .promise()];
+                    case 1:
+                        multipart = _e.sent();
+                        if (!multipart.UploadId) {
+                            throw new Error("UploadId property is empty");
+                        }
+                        _e.label = 2;
+                    case 2:
+                        _e.trys.push([2, 19, , 21]);
+                        totalWritten = 0;
+                        partNumber = 0;
+                        uploadId = multipart.UploadId;
+                        parts = [];
+                        _e.label = 3;
+                    case 3:
+                        _e.trys.push([3, 11, 12, 17]);
+                        _a = true, inputStream_1 = __asyncValues(inputStream);
+                        _e.label = 4;
+                    case 4: return [4 /*yield*/, inputStream_1.next()];
+                    case 5:
+                        if (!(inputStream_1_1 = _e.sent(), _b = inputStream_1_1.done, !_b)) return [3 /*break*/, 10];
+                        _d = inputStream_1_1.value;
+                        _a = false;
+                        _e.label = 6;
+                    case 6:
+                        _e.trys.push([6, , 8, 9]);
+                        buffer = _d;
+                        partNumber++;
+                        return [4 /*yield*/, this.s3Client
+                                .uploadPart({
+                                Body: buffer,
+                                Bucket: this.bucket,
+                                Key: remotePath,
+                                UploadId: uploadId,
+                                PartNumber: partNumber,
+                            })
+                                .promise()];
+                    case 7:
+                        response = _e.sent();
+                        parts.push({
+                            ETag: response.ETag,
+                            PartNumber: partNumber,
+                        });
+                        totalWritten += buffer.length;
+                        if (!!progressListener) {
+                            progressListener(contentLength, totalWritten);
+                        }
+                        return [3 /*break*/, 9];
+                    case 8:
+                        _a = true;
+                        return [7 /*endfinally*/];
+                    case 9: return [3 /*break*/, 4];
+                    case 10: return [3 /*break*/, 17];
+                    case 11:
+                        e_1_1 = _e.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 17];
+                    case 12:
+                        _e.trys.push([12, , 15, 16]);
+                        if (!(!_a && !_b && (_c = inputStream_1.return))) return [3 /*break*/, 14];
+                        return [4 /*yield*/, _c.call(inputStream_1)];
+                    case 13:
+                        _e.sent();
+                        _e.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:
+                        doneParams = {
+                            Bucket: this.bucket,
+                            Key: remotePath,
+                            UploadId: multipart.UploadId,
+                            MultipartUpload: { Parts: parts },
+                        };
+                        return [4 /*yield*/, this.s3Client.completeMultipartUpload(doneParams).promise()];
+                    case 18:
+                        _e.sent();
+                        return [3 /*break*/, 21];
+                    case 19:
+                        uploadingError_1 = _e.sent();
+                        return [4 /*yield*/, this.s3Client
+                                .abortMultipartUpload({
+                                Bucket: this.bucket,
+                                Key: remotePath,
+                                UploadId: multipart.UploadId,
+                            })
+                                .promise()];
+                    case 20:
+                        _e.sent();
+                        throw uploadingError_1;
+                    case 21: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    S3StorageProvider.prototype.deleteObject = function (remotePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var deleteResult;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.s3Client
+                            .deleteObject({
+                            Bucket: this.bucket,
+                            Key: remotePath,
+                        })
+                            .promise()];
+                    case 1:
+                        deleteResult = _a.sent();
+                        if (deleteResult.$response.error) {
+                            throw deleteResult.$response.error;
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    S3StorageProvider.prototype.downloadFile = function (remotePath, config, progressListener) {
+        return __awaiter(this, void 0, void 0, function () {
+            var getObjectParams, start, end, downloadStream, current, fileBytesSize_1, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        getObjectParams = {
+                            Bucket: this.bucket,
+                            Key: remotePath,
+                        };
+                        if (config) {
+                            start = config.offset || 0;
+                            end = start + (config.length || 0);
+                            getObjectParams.Range = "bytes=".concat(start, "-").concat(end || "");
+                        }
+                        downloadStream = this.s3Client.getObject(getObjectParams).createReadStream();
+                        current = 0;
+                        if (!progressListener) return [3 /*break*/, 3];
+                        _a = config.length;
+                        if (_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.getObjectSize(remotePath)];
+                    case 1:
+                        _a = (_b.sent());
+                        _b.label = 2;
+                    case 2:
+                        fileBytesSize_1 = _a;
+                        downloadStream.on("data", function (chunk) {
+                            current += chunk.length;
+                            progressListener(fileBytesSize_1, current);
+                        });
+                        _b.label = 3;
+                    case 3: return [2 /*return*/, downloadStream];
+                }
+            });
+        });
+    };
+    S3StorageProvider.prototype.listObjects = function (remotePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prefix, listObjects, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        prefix = remotePath.endsWith("/") ? remotePath : "".concat(remotePath, "/");
+                        return [4 /*yield*/, this.s3Client
+                                .listObjectsV2({
+                                Bucket: this.bucket,
+                                Prefix: prefix,
+                            })
+                                .promise()];
+                    case 1:
+                        listObjects = _a.sent();
+                        if (listObjects.$response.error) {
+                            throw listObjects.$response.error;
+                        }
+                        result = [];
+                        if (listObjects.Contents) {
+                            result = listObjects.Contents.map(function (object) { return ({
+                                name: object.Key || "",
+                                createdAt: object.LastModified || new Date(),
+                                size: object.Size || 0,
+                            }); });
+                        }
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    S3StorageProvider.prototype.getMetadata = function (remotePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var getObjectParams, metadata;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        getObjectParams = {
+                            Bucket: this.bucket,
+                            Key: remotePath,
+                        };
+                        return [4 /*yield*/, this.s3Client.headObject(getObjectParams).promise()];
+                    case 1:
+                        metadata = _a.sent();
+                        if (metadata.$response.error) {
+                            throw metadata.$response.error;
+                        }
+                        return [2 /*return*/, metadata];
+                }
+            });
+        });
+    };
+    S3StorageProvider.prototype.getObjectSize = function (remotePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var metadata;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getMetadata(remotePath)];
+                    case 1:
+                        metadata = _a.sent();
+                        if (metadata.ContentLength === undefined) {
+                            throw new Error("ContentLength property is empty");
+                        }
+                        return [2 /*return*/, metadata.ContentLength || 0];
+                }
+            });
+        });
+    };
+    S3StorageProvider.prototype.getLastModified = function (remotePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var metadata;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getMetadata(remotePath)];
+                    case 1:
+                        metadata = _a.sent();
+                        if (!metadata.LastModified) {
+                            throw new Error("LastModified property is empty");
+                        }
+                        return [2 /*return*/, metadata.LastModified];
+                }
+            });
+        });
+    };
+    return S3StorageProvider;
+}());
+exports.S3StorageProvider = S3StorageProvider;

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

@@ -11,7 +11,8 @@ export default class StorJStorageProvider implements IStorageProvider {
     private _access?;
     private _project?;
     private _storj?;
-    constructor(credentials: any);
+    private maximumConcurrent?;
+    constructor(credentials: any, maximumConcurrent?: number);
     uploadFile(inputStream: stream.Readable, remotePath: string, contentLength: number, progressListener?: (total: number, current: number) => void): Promise<void>;
     downloadFile(remotePath: string, config: DownloadConfig, progressListener?: (total: number, current: number) => void): Promise<stream.Readable>;
     deleteObject(remotePath: string): Promise<void>;

package/build/providers/storage/StorjStorageProvider.js

@@ -63,7 +63,7 @@ var utils_1 = require("../../utils");
 var stream_1 = __importDefault(require("stream"));
 var logger_1 = __importDefault(require("../../logger"));
 var StorJStorageProvider = /** @class */ (function () {
-    function StorJStorageProvider(credentials) {
+    function StorJStorageProvider(credentials, maximumConcurrent) {
         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");
@@ -79,6 +79,7 @@ var StorJStorageProvider = /** @class */ (function () {
             this.bucket = credentials.storageId;
         }
         this.accessToken = credentials.token;
+        this.maximumConcurrent = maximumConcurrent;
     }
     StorJStorageProvider.prototype.uploadFile = function (inputStream, remotePath, contentLength, progressListener) {
         var _a, inputStream_1, inputStream_1_1;
@@ -367,7 +368,7 @@ var StorJStorageProvider = /** @class */ (function () {
                     case 1:
                         access = _b.sent();
                         _a = this;
-                        return [4 /*yield*/, access.openProject()];
+                        return [4 /*yield*/, access.openProject(this.maximumConcurrent)];
                     case 2:
                         _a._project = _b.sent();
                         _b.label = 3;

package/build/providers/storage/getStorageProvider.js

@@ -5,11 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var dto_js_1 = require("@super-protocol/dto-js");
 var StorjStorageProvider_1 = __importDefault(require("./StorjStorageProvider"));
+var S3StorageProvider_1 = require("./S3StorageProvider");
 exports.default = (function (storageAccess) {
     var key = storageAccess.storageType;
     switch (key) {
         case dto_js_1.StorageType.StorJ:
-            return new StorjStorageProvider_1.default(storageAccess.credentials);
+            return new StorjStorageProvider_1.default(storageAccess.credentials, storageAccess.maximumConcurrent);
+        case dto_js_1.StorageType.S3:
+            return new S3StorageProvider_1.S3StorageProvider(storageAccess.credentials);
         default:
             throw Error("Unsupported storageType ".concat(key));
     }

package/build/staticModels/Consensus.d.ts

@@ -1,39 +1,22 @@
 import { EpochInfo } from "../types/Consensus";
-import { GetTcbRequest } from "@super-protocol/dto-js";
 import { TransactionOptions, BlockInfo } from "../types/Web3";
 import { ConsensusConstants } from "../types/Consensus";
 declare class Consensus {
     private static readonly logger;
     private static tcbIds?;
     static get address(): string;
-    private static initializeTcbAndAssignBlocks;
     /**
      * Function for fetching list of all tcb ids
      * @returns list of tcb ids
      */
     static getAllTcbs(): Promise<string[]>;
-    static initializeTcb(teeOfferId: string, transactionOptions?: TransactionOptions): Promise<void>;
     static unlockProfitByTcbList(tcbIds: string[], transactionOptions?: TransactionOptions): Promise<void>;
-    static isTcbCreationAvailable(teeOfferId: string): Promise<boolean>;
-    /**
-     * Function initialize TCB and returns list of anothers' TCB for their checking
-     * @param teeOfferId - id of TEE offer
-     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
-     * @returns tcbId and lists of anothers' TCB for their checking
-     */
-    static getListsForVerification(teeOfferId: string, transactionOptions?: TransactionOptions): Promise<GetTcbRequest>;
-    /**
-     * Function return last inited TCB of TEE offer
-     * @param teeOfferId - id of TEE offer
-     * */
-    static getInitializedTcbId(teeOfferId: string): Promise<string>;
     static getEpochTime(time: number): Promise<{
         epochStart: number;
         epochEnd: number;
         epochIndex: number;
     }>;
     static getEpoch(epochIndex: number): Promise<EpochInfo>;
-    static getActualTcbId(teeOfferId: string): Promise<string>;
     static getSuspiciousBlockTable(): Promise<string[]>;
     static getSuspiciousBlockTableSize(): Promise<string[]>;
     static getLastBlockTable(): Promise<string[]>;

package/build/staticModels/Consensus.js

@@ -57,29 +57,6 @@ var Consensus = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Consensus.initializeTcbAndAssignBlocks = function (teeOfferId, transactionOptions) {
-        return __awaiter(this, void 0, void 0, function () {
-            var tcbId, tcb;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.initializeTcb(teeOfferId, transactionOptions)];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this.getInitializedTcbId(teeOfferId)];
-                    case 2:
-                        tcbId = _a.sent();
-                        tcb = new TCB_1.default(tcbId);
-                        return [4 /*yield*/, tcb.assignLastBlocksToCheck(transactionOptions)];
-                    case 3:
-                        _a.sent();
-                        return [4 /*yield*/, tcb.assignSuspiciousBlocksToCheck(transactionOptions)];
-                    case 4:
-                        _a.sent();
-                        return [2 /*return*/, tcb];
-                }
-            });
-        });
-    };
     /**
      * Function for fetching list of all tcb ids
      * @returns list of tcb ids
@@ -105,22 +82,6 @@ var Consensus = /** @class */ (function () {
             });
         });
     };
-    Consensus.initializeTcb = function (teeOfferId, 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();
-                        (0, utils_1.checkIfActionAccountInitialized)();
-                        return [4 /*yield*/, TxManager_1.default.execute(contract.methods.initializeTcb, [teeOfferId], transactionOptions)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
     Consensus.unlockProfitByTcbList = function (tcbIds, transactionOptions) {
         return __awaiter(this, void 0, void 0, function () {
             var contract, executedCount, e_1, _i, tcbIds_1, tcbId;
@@ -164,85 +125,6 @@ var Consensus = /** @class */ (function () {
             });
         });
     };
-    Consensus.isTcbCreationAvailable = function (teeOfferId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var contract, _a, offerNotBlocked, newEpochStarted, halfEpochPassed, benchmarkVerified;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        contract = BlockchainConnector_1.default.getInstance().getContract();
-                        return [4 /*yield*/, contract.methods
-                                .isTcbCreationAvailable(teeOfferId)
-                                .call()];
-                    case 1:
-                        _a = _b.sent(), offerNotBlocked = _a[0], newEpochStarted = _a[1], halfEpochPassed = _a[2], benchmarkVerified = _a[3];
-                        return [2 /*return*/, offerNotBlocked && newEpochStarted && halfEpochPassed && benchmarkVerified];
-                }
-            });
-        });
-    };
-    /**
-     * Function initialize TCB and returns list of anothers' TCB for their checking
-     * @param teeOfferId - id of TEE offer
-     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
-     * @returns tcbId and lists of anothers' TCB for their checking
-     */
-    Consensus.getListsForVerification = function (teeOfferId, transactionOptions) {
-        return __awaiter(this, void 0, void 0, function () {
-            var tcb, blocksIds, tcbsForVerification, blockIndex, tcb_1, tcbInfo;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        (0, utils_1.checkIfActionAccountInitialized)();
-                        return [4 /*yield*/, this.initializeTcbAndAssignBlocks(teeOfferId, transactionOptions)];
-                    case 1:
-                        tcb = _a.sent();
-                        return [4 /*yield*/, tcb.getCheckingBlocksMarks()];
-                    case 2:
-                        blocksIds = (_a.sent()).blocksIds;
-                        tcbsForVerification = [];
-                        blockIndex = 0;
-                        _a.label = 3;
-                    case 3:
-                        if (!(blockIndex < blocksIds.length)) return [3 /*break*/, 6];
-                        tcb_1 = new TCB_1.default(blocksIds[blockIndex]);
-                        return [4 /*yield*/, tcb_1.get()];
-                    case 4:
-                        tcbInfo = _a.sent();
-                        tcbsForVerification.push({
-                            tcbId: blocksIds[blockIndex].toString(),
-                            deviceId: tcbInfo.publicData.deviceID,
-                            properties: tcbInfo.publicData.properties,
-                            benchmark: tcbInfo.publicData.benchmark,
-                            quote: tcbInfo.quote,
-                            marks: tcbInfo.utilData.checkingBlockMarks,
-                            checkingBlocks: tcbInfo.utilData.checkingBlocks,
-                        });
-                        _a.label = 5;
-                    case 5:
-                        blockIndex++;
-                        return [3 /*break*/, 3];
-                    case 6: return [2 /*return*/, {
-                            tcbId: tcb.tcbId,
-                            tcbsForVerification: tcbsForVerification,
-                        }];
-                }
-            });
-        });
-    };
-    /**
-     * Function return last inited TCB of TEE offer
-     * @param teeOfferId - id of TEE offer
-     * */
-    Consensus.getInitializedTcbId = function (teeOfferId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var contract;
-            return __generator(this, function (_a) {
-                contract = BlockchainConnector_1.default.getInstance().getContract();
-                return [2 /*return*/, contract.methods.getInitializedTcbId(teeOfferId).call()];
-            });
-        });
-    };
     Consensus.getEpochTime = function (time) {
         return __awaiter(this, void 0, void 0, function () {
             var contract, _a, epochStart, epochEnd, epochIndex;
@@ -275,15 +157,6 @@ var Consensus = /** @class */ (function () {
             });
         });
     };
-    Consensus.getActualTcbId = function (teeOfferId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var contract;
-            return __generator(this, function (_a) {
-                contract = BlockchainConnector_1.default.getInstance().getContract();
-                return [2 /*return*/, contract.methods.getActualTcbId(teeOfferId).call()];
-            });
-        });
-    };
     Consensus.getSuspiciousBlockTable = function () {
         return __awaiter(this, void 0, void 0, function () {
             var contract;

package/build/types/storage/StorageAccess.d.ts

@@ -2,5 +2,6 @@ import { StorageType } from "@super-protocol/dto-js";
 type StorageAccess = {
     storageType: StorageType;
     credentials: any;
+    maximumConcurrent?: number;
 };
 export default StorageAccess;

package/build/types/storage/StorageObject.d.ts

@@ -1,8 +1,8 @@
 type StorageObject = {
     name: string;
     size: number;
-    isFolder: boolean;
-    childrenCount: number;
+    isFolder?: boolean;
+    childrenCount?: number;
     createdAt: Date;
 };
 export default StorageObject;

package/build/utils/helpers/tryWithInterval.d.ts

@@ -6,6 +6,7 @@ export interface TryWithIntervalParams<T> {
     checkError?: (err: unknown) => {
         retryable: boolean;
     };
+    startDelay?: number;
     retryInterval: number;
     retryMax: number;
 }

package/build/utils/helpers/tryWithInterval.js

@@ -38,12 +38,12 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryWithInterval = void 0;
 var tryWithInterval = function (params) { return __awaiter(void 0, void 0, void 0, function () {
-    var checkedTimes, handler, checkResult, checkError, retryInterval, retryMax;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
+    var checkedTimes, handler, checkResult, checkError, _a, startDelay, retryInterval, retryMax;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
             case 0:
                 checkedTimes = 0;
-                handler = params.handler, checkResult = params.checkResult, checkError = params.checkError, retryInterval = params.retryInterval, retryMax = params.retryMax;
+                handler = params.handler, checkResult = params.checkResult, checkError = params.checkError, _a = params.startDelay, startDelay = _a === void 0 ? 0 : _a, retryInterval = params.retryInterval, retryMax = params.retryMax;
                 return [4 /*yield*/, new Promise(function (resolve, reject) {
                         var checkTimes = function () {
                             checkedTimes += 1;
@@ -83,9 +83,9 @@ var tryWithInterval = function (params) { return __awaiter(void 0, void 0, void
                                 }
                             });
                         }); };
-                        setTimeout(timeoutFn, retryInterval);
+                        setTimeout(timeoutFn, startDelay);
                     })];
-            case 1: return [2 /*return*/, _a.sent()];
+            case 1: return [2 /*return*/, _b.sent()];
         }
     });
 }); };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@super-protocol/sdk-js",
-  "version": "0.14.0-beta.0",
+  "version": "0.14.1-beta.2",
   "main": "build/index.js",
   "license": "MIT",
   "files": [
@@ -52,9 +52,10 @@
     "typescript": "^4.4.4"
   },
   "dependencies": {
-    "@super-protocol/dto-js": "0.0.24",
+    "@super-protocol/dto-js": "0.0.28",
     "@super-protocol/tee-lib": "^0.1.2",
-    "@super-protocol/uplink-nodejs": "1.2.12",
+    "@super-protocol/uplink-nodejs": "1.2.16",
+    "aws-sdk": "^2.1418.0",
     "ethers": "^5.5.3",
     "hybrid-crypto-js": "^0.2.4",
     "lodash": "^4.17.21",
@@ -64,5 +65,8 @@
     "web3": "^1.7.1",
     "web3-parse-receipt-events": "^1.0.2"
   },
-  "repository": "git://github.com/Super-Protocol/sdk-js.git"
+  "repository": "git://github.com/Super-Protocol/sdk-js.git",
+  "resolutions": {
+    "wrap-ansi": "7.0.0"
+  }
 }