@super-protocol/sdk-js 0.11.3-beta.0 → 0.11.6-beta.0

package/build/models/EtlModel.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { EtlModel as IEtlModel, EtlModelMetadata } from "@super-protocol/dto-js";
+import { EtlModelType } from "@super-protocol/dto-js/build/enum/EtlModel.enum";
+import { EtlModelSubtype } from "../types/EtlModel";
+export declare class EtlModel {
+    private etlModel;
+    static logger: import("pino").default.Logger<{
+        level: string;
+    } & import("pino").default.ChildLoggerOptions>;
+    constructor(etlModel: IEtlModel);
+    /**
+     * Create instance of EtlModel from Buffer
+     *
+     * @param data - packed EtlModel
+     * @returns instance of EtlModel
+     */
+    static unpack(data: Buffer): Promise<EtlModel>;
+    /**
+     * Packing EltModel
+     *
+     * @returns EltModel in binary format
+     */
+    pack(): Promise<Buffer>;
+    getType(): EtlModelType;
+    setType(type: EtlModelType): void;
+    getSubtype(): EtlModelSubtype;
+    setSubtype(subtype: EtlModelSubtype | null): void;
+    getMetadata(): EtlModelMetadata | void;
+    setMetadata(metadata: EtlModelMetadata | undefined): void;
+}

package/build/models/EtlModel.js

@@ -0,0 +1,108 @@
+"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 });
+exports.EtlModel = void 0;
+var logger_1 = __importDefault(require("../logger"));
+var ModelPackager_1 = require("../staticModels/ModelPackager");
+var EtlModel = /** @class */ (function () {
+    function EtlModel(etlModel) {
+        this.etlModel = etlModel;
+    }
+    /**
+     * Create instance of EtlModel from Buffer
+     *
+     * @param data - packed EtlModel
+     * @returns instance of EtlModel
+     */
+    EtlModel.unpack = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var etlModel, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, ModelPackager_1.ModelPackager.unpack(data)];
+                    case 1:
+                        etlModel = _a.sent();
+                        return [2 /*return*/, new EtlModel(etlModel)];
+                    case 2:
+                        error_1 = _a.sent();
+                        EtlModel.logger.error("Unable to unpack EtlModel");
+                        throw error_1;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Packing EltModel
+     *
+     * @returns EltModel in binary format
+     */
+    EtlModel.prototype.pack = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, ModelPackager_1.ModelPackager.pack(this.etlModel)];
+            });
+        });
+    };
+    EtlModel.prototype.getType = function () {
+        return this.etlModel.type;
+    };
+    EtlModel.prototype.setType = function (type) {
+        this.etlModel.type = type;
+    };
+    EtlModel.prototype.getSubtype = function () {
+        return this.etlModel.subtype;
+    };
+    EtlModel.prototype.setSubtype = function (subtype) {
+        this.etlModel.subtype = subtype;
+    };
+    EtlModel.prototype.getMetadata = function () {
+        return this.etlModel.metadata;
+    };
+    EtlModel.prototype.setMetadata = function (metadata) {
+        this.etlModel.metadata = metadata;
+    };
+    EtlModel.logger = logger_1.default.child({ name: EtlModel.name });
+    return EtlModel;
+}());
+exports.EtlModel = EtlModel;

package/build/models/TCB.d.ts

@@ -1,5 +1,5 @@
 import { TransactionOptions } from "../types/Web3";
-import { TcbStatus, PublicData, TcbEpochInfo, TcbVerifiedStatus } from "../types/Consensus";
+import { TcbData, TcbStatus, PublicData, TcbEpochInfo, TcbVerifiedStatus } from "../types/Consensus";
 declare class TCB {
     tcbId: string;
     private contract;
@@ -42,7 +42,7 @@ declare class TCB {
     /**
      * Function for fetching all TCB data
      */
-    get(): Promise<any>;
+    get(): Promise<TcbData>;
     /**
      * Function for fetching the given marks for recruited TCBs from the Tables of Consensus
      */
@@ -50,10 +50,6 @@ declare class TCB {
         blocksIds: string[];
         marks: TcbVerifiedStatus[];
     }>;
-    /**
-     * Function for fetching used TCB data
-     */
-    getPublicData(): Promise<PublicData>;
     /**
      * Function for fetching TCB status
      */

package/build/models/TCB.js

@@ -199,8 +199,14 @@ var TCB = /** @class */ (function () {
      */
     TCB.prototype.get = function () {
         return __awaiter(this, void 0, void 0, function () {
+            var tcb;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.contract.methods.getTcbById(this.tcbId).call()];
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.contract.methods.getTcbById(this.tcbId).call()];
+                    case 1:
+                        tcb = _a.sent();
+                        return [2 /*return*/, (0, utils_1.tupleToObject)(tcb, Consensus_1.TcbStructure)];
+                }
             });
         });
     };
@@ -223,24 +229,6 @@ var TCB = /** @class */ (function () {
             });
         });
     };
-    /**
-     * Function for fetching used TCB data
-     */
-    TCB.prototype.getPublicData = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var publicDataParams, publicData;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.contract.methods.getPublicData().call()];
-                    case 1:
-                        publicDataParams = _a.sent();
-                        publicData = (0, utils_1.tupleToObject)(publicDataParams, Consensus_1.PublicDataStructure);
-                        publicData.deviceID = Buffer.from((0, utils_2.parseBytes32String)(publicData.deviceID), "base64").toString("hex");
-                        return [2 /*return*/, publicData];
-                }
-            });
-        });
-    };
     /**
      * Function for fetching TCB status
      */

package/build/models/TeeOffer.d.ts

@@ -44,6 +44,7 @@ declare class TeeOffer {
      * Fetch offer type from blockchain (works for TEE and Value offers)
      */
     getOfferType(): Promise<OfferType>;
+    isTeeOfferVerifying(): Promise<boolean>;
     /**
      * Function for fetching offer provider from blockchain
      */

package/build/models/TeeOffer.js

@@ -153,6 +153,16 @@ var TeeOffer = /** @class */ (function () {
             });
         });
     };
+    TeeOffer.prototype.isTeeOfferVerifying = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, TeeOffer.contract.methods.isTeeOfferVerifying(this.id).call()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Function for fetching offer provider from blockchain
      */

package/build/proto/Compression.d.ts

@@ -5,7 +5,8 @@ export interface Compression {
     data: Uint8Array;
 }
 export declare enum Compression_TYPE {
-    GZIP = 0
+    Uncompressed = 0,
+    GZIP = 1
 }
 export declare function compression_TYPEFromJSON(object: any): Compression_TYPE;
 export declare function compression_TYPEToJSON(object: Compression_TYPE): string;

package/build/proto/Compression.js

@@ -9,11 +9,15 @@ var minimal_1 = __importDefault(require("protobufjs/minimal"));
 exports.protobufPackage = "";
 var Compression_TYPE;
 (function (Compression_TYPE) {
-    Compression_TYPE[Compression_TYPE["GZIP"] = 0] = "GZIP";
+    Compression_TYPE[Compression_TYPE["Uncompressed"] = 0] = "Uncompressed";
+    Compression_TYPE[Compression_TYPE["GZIP"] = 1] = "GZIP";
 })(Compression_TYPE = exports.Compression_TYPE || (exports.Compression_TYPE = {}));
 function compression_TYPEFromJSON(object) {
     switch (object) {
         case 0:
+        case "Uncompressed":
+            return Compression_TYPE.Uncompressed;
+        case 1:
         case "GZIP":
             return Compression_TYPE.GZIP;
         default:
@@ -23,6 +27,8 @@ function compression_TYPEFromJSON(object) {
 exports.compression_TYPEFromJSON = compression_TYPEFromJSON;
 function compression_TYPEToJSON(object) {
     switch (object) {
+        case Compression_TYPE.Uncompressed:
+            return "Uncompressed";
         case Compression_TYPE.GZIP:
             return "GZIP";
         default:

package/build/staticModels/Consensus.d.ts

@@ -10,7 +10,7 @@ declare class Consensus {
      * @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<{
+    static getListsForVerification(teeOfferId: string, initializeTcbForce?: boolean, transactionOptions?: TransactionOptions): Promise<{
         tcbId: string;
         checkingTcbData: CheckingTcbData[];
     }>;

package/build/staticModels/Consensus.js

@@ -55,7 +55,7 @@ var Consensus = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Consensus.initializeTcbAndAssignBlocks = function (teeOfferId, transactionOptions) {
+    Consensus.initializeTcbAndAssignBlocks = function (teeOfferId, initializeTcbForce, transactionOptions) {
         return __awaiter(this, void 0, void 0, function () {
             var tcbId, tcb, timeInitialized, isFirstOffersTcb, isCreatedMoreThenOneDayAgo, _a;
             return __generator(this, function (_b) {
@@ -72,7 +72,7 @@ var Consensus = /** @class */ (function () {
                         return [4 /*yield*/, (0, utils_1.getTimestamp)()];
                     case 3:
                         isCreatedMoreThenOneDayAgo = _a < +(_b.sent());
-                        if (!(isFirstOffersTcb || isCreatedMoreThenOneDayAgo)) return [3 /*break*/, 8];
+                        if (!(isFirstOffersTcb || isCreatedMoreThenOneDayAgo || initializeTcbForce)) return [3 /*break*/, 8];
                         return [4 /*yield*/, this.initializeTcb(teeOfferId, transactionOptions)];
                     case 4:
                         _b.sent();
@@ -114,14 +114,15 @@ var Consensus = /** @class */ (function () {
      * @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) {
+    Consensus.getListsForVerification = function (teeOfferId, initializeTcbForce, transactionOptions) {
+        if (initializeTcbForce === void 0) { initializeTcbForce = false; }
         return __awaiter(this, void 0, void 0, function () {
             var tcb, blocksIds, checkingTcbData, 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)];
+                        return [4 /*yield*/, this.initializeTcbAndAssignBlocks(teeOfferId, initializeTcbForce, transactionOptions)];
                     case 1:
                         tcb = _a.sent();
                         return [4 /*yield*/, tcb.getCheckingBlocksMarks()];

package/build/staticModels/ModelPackager.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+export declare class ModelPackager {
+    private static readonly logger;
+    private static compressors;
+    /**
+     * Compressing message with best algorithm
+     *
+     * @param message - message
+     * @returns Compressed message in bytes representation
+     */
+    static pack<T = unknown>(message: T): Promise<Buffer>;
+    /**
+     * Uncompressing message
+     *
+     * @param message - message with bytes representation
+     * @returns original message
+     */
+    static unpack<T = unknown>(message: Buffer): Promise<T>;
+}

package/build/staticModels/ModelPackager.js

@@ -0,0 +1,116 @@
+"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 });
+exports.ModelPackager = void 0;
+var logger_1 = __importDefault(require("../logger"));
+var Compression_1 = require("../proto/Compression");
+var compressors_1 = require("../utils/compressors");
+var ModelPackager = /** @class */ (function () {
+    function ModelPackager() {
+    }
+    /**
+     * Compressing message with best algorithm
+     *
+     * @param message - message
+     * @returns Compressed message in bytes representation
+     */
+    ModelPackager.pack = function (message) {
+        return __awaiter(this, void 0, void 0, function () {
+            var promises, options, minimal, encoded;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        promises = ModelPackager.compressors.map(function (Compressor) { return __awaiter(_this, void 0, void 0, function () {
+                            var compressorInstance, data;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        compressorInstance = new Compressor();
+                                        return [4 /*yield*/, compressorInstance.compress(message)];
+                                    case 1:
+                                        data = _a.sent();
+                                        return [2 /*return*/, {
+                                                compressionType: Compressor.type,
+                                                data: data,
+                                                size: data.byteLength,
+                                            }];
+                                }
+                            });
+                        }); });
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 1:
+                        options = _a.sent();
+                        options.sort(function (first, second) { return first.size - second.size; });
+                        minimal = options[0];
+                        encoded = Compression_1.Compression.encode({
+                            type: minimal.compressionType,
+                            data: minimal.data,
+                        }).finish();
+                        return [2 /*return*/, Buffer.from(encoded)];
+                }
+            });
+        });
+    };
+    /**
+     * Uncompressing message
+     *
+     * @param message - message with bytes representation
+     * @returns original message
+     */
+    ModelPackager.unpack = function (message) {
+        return __awaiter(this, void 0, void 0, function () {
+            var decoded, Compressor;
+            return __generator(this, function (_a) {
+                decoded = Compression_1.Compression.decode(message);
+                Compressor = ModelPackager.compressors.find(function (CompressorClass) { return CompressorClass.type === decoded.type; });
+                if (!Compressor) {
+                    throw new Error("Cannot unpack message. Compressor ".concat(decoded.type, " isn't supported"));
+                }
+                return [2 /*return*/, new Compressor().decompress(Buffer.from(decoded.data))];
+            });
+        });
+    };
+    ModelPackager.logger = logger_1.default.child({ className: ModelPackager.name });
+    ModelPackager.compressors = [compressors_1.GzipCompressor, compressors_1.UncompressedCompressor];
+    return ModelPackager;
+}());
+exports.ModelPackager = ModelPackager;

package/build/types/Compressor.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+export interface Compressor<T> {
+    compress: (content: T) => Promise<Buffer>;
+    decompress: (bytes: Buffer) => Promise<T>;
+}

package/build/types/Compressor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/types/Consensus.d.ts

@@ -46,6 +46,32 @@ export declare type TcbEpochInfo = {
     index: number;
     valid: boolean;
 };
+export declare const TcbStructure: {
+    quote: StringConstructor;
+    timeInitialized: NumberConstructor;
+    timeAdded: NumberConstructor;
+    publicData: {
+        teeOffer: StringConstructor;
+        deviceID: StringConstructor;
+        benchmark: NumberConstructor;
+        properties: StringConstructor;
+    };
+    utilData: {};
+    status: typeof TcbStatus;
+    epoch: {
+        index: NumberConstructor;
+        valid: BooleanConstructor;
+    };
+};
+export declare type TcbData = {
+    quote: string;
+    timeInitialized: number;
+    timeAdded: number;
+    publicData: PublicData;
+    utilData: any;
+    status: TcbStatus;
+    epoch: TcbEpochInfo;
+};
 export declare type EpochInfo = {
     startDate: number;
     endDate: number;

package/build/types/Consensus.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TcbEpochInfoStructure = exports.TcbStatus = exports.EpochStructure = exports.PublicDataStructure = exports.TcbVerifiedStatus = void 0;
+exports.TcbStructure = exports.TcbEpochInfoStructure = exports.TcbStatus = exports.EpochStructure = exports.PublicDataStructure = exports.TcbVerifiedStatus = void 0;
 var TcbVerifiedStatus;
 (function (TcbVerifiedStatus) {
     TcbVerifiedStatus["Valid"] = "0";
@@ -36,3 +36,12 @@ exports.TcbEpochInfoStructure = {
     index: Number,
     valid: Boolean,
 };
+exports.TcbStructure = {
+    quote: String,
+    timeInitialized: Number,
+    timeAdded: Number,
+    publicData: exports.PublicDataStructure,
+    utilData: {},
+    status: TcbStatus,
+    epoch: exports.TcbEpochInfoStructure,
+};

package/build/types/EtlModel.d.ts

@@ -0,0 +1,2 @@
+import { EtlModelImageSubtype, EtlModelStandardSubtype } from "@super-protocol/dto-js/build/enum/EtlModel.enum";
+export declare type EtlModelSubtype = EtlModelStandardSubtype | EtlModelImageSubtype | null;

package/build/types/EtlModel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/utils/NonceTracker.d.ts

@@ -1,14 +1,19 @@
 import Web3 from "web3";
 declare class NonceTracker {
     private web3;
-    private store;
-    private static logger;
-    constructor(web3: Web3);
-    initAccount(address: string): Promise<void>;
-    isManaged(address: string): boolean;
-    reinitialize(): Promise<void>;
-    private checkAccount;
-    getNonce(address: string): number;
-    consumeNonce(address: string): number;
+    private address;
+    private logger;
+    private txCount?;
+    private transactionsOnHold;
+    private countOfPendingTransactions;
+    constructor(web3: Web3, address: string);
+    initAccount(): Promise<void>;
+    getNonce(): number;
+    consumeNonce(): number;
+    onTransactionStartPublishing(): Promise<void>;
+    onTransactionPublished(): void;
+    onTransactionError(): Promise<void>;
+    private waitForPendingTransactions;
+    private sendHoldTransactions;
 }
 export default NonceTracker;

package/build/utils/NonceTracker.js

@@ -41,79 +41,115 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var logger_1 = __importDefault(require("../logger"));
 var NonceTracker = /** @class */ (function () {
-    function NonceTracker(web3) {
+    function NonceTracker(web3, address) {
         this.web3 = web3;
-        this.store = {};
-        NonceTracker.logger.trace("Created NonceTracker");
+        this.address = address;
+        this.countOfPendingTransactions = 0;
+        this.logger = logger_1.default.child({ className: "NonceTracker", address: address });
+        this.logger.trace("Created NonceTracker");
     }
-    NonceTracker.prototype.initAccount = function (address) {
+    NonceTracker.prototype.initAccount = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var txCount;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0:
-                        if (address in this.store) {
-                            return [2 /*return*/];
-                        }
-                        return [4 /*yield*/, this.web3.eth.getTransactionCount(address)];
+                        _a = this;
+                        return [4 /*yield*/, this.web3.eth.getTransactionCount(this.address)];
                     case 1:
-                        txCount = _a.sent();
-                        if (address in this.store) {
-                            return [2 /*return*/];
-                        }
-                        NonceTracker.logger.trace("Initialized ".concat(address, " account with nonce: ").concat(txCount));
-                        this.store[address] = txCount;
+                        _a.txCount = _b.sent();
+                        this.logger.trace("Initialized ".concat(this.address, " account with nonce: ").concat(this.txCount));
                         return [2 /*return*/];
                 }
             });
         });
     };
-    NonceTracker.prototype.isManaged = function (address) {
-        return address in this.store;
+    NonceTracker.prototype.getNonce = function () {
+        if (this.txCount === undefined)
+            throw Error("NonceTracker for address ".concat(this.address, " is not initialized"));
+        this.logger.trace("Get nonce: ".concat(this.txCount));
+        return this.txCount;
     };
-    NonceTracker.prototype.reinitialize = function () {
+    NonceTracker.prototype.consumeNonce = function () {
+        if (this.txCount === undefined)
+            throw Error("NonceTracker for address ".concat(this.address, " is not initialized"));
+        this.logger.trace("Consume nonce: ".concat(this.txCount + 1));
+        return this.txCount++;
+    };
+    NonceTracker.prototype.onTransactionStartPublishing = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, Promise.all(Object.keys(this.store).map(function (address) { return __awaiter(_this, void 0, void 0, function () {
-                            var txCount;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, this.web3.eth.getTransactionCount(address)];
-                                    case 1:
-                                        txCount = _a.sent();
-                                        NonceTracker.logger.trace("Account ".concat(address, " has been reinitialized with nonce: ").concat(txCount));
-                                        this.store[address] = txCount;
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); }))];
+                    case 0:
+                        if (!this.transactionsOnHold) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.waitForPendingTransactions()];
                     case 1:
                         _a.sent();
-                        NonceTracker.logger.trace("All accounts has been reinitialized");
+                        _a.label = 2;
+                    case 2:
+                        this.countOfPendingTransactions++;
                         return [2 /*return*/];
                 }
             });
         });
     };
-    NonceTracker.prototype.checkAccount = function (address) {
-        if (this.isManaged(address)) {
-            return;
+    NonceTracker.prototype.onTransactionPublished = function () {
+        this.countOfPendingTransactions--;
+        if (this.countOfPendingTransactions === 0) {
+            this.sendHoldTransactions();
         }
-        throw Error("".concat(address, " account is not initialized. You must call initAccount before using it."));
     };
-    NonceTracker.prototype.getNonce = function (address) {
-        this.checkAccount(address);
-        NonceTracker.logger.trace("Get nonce: ".concat(this.store[address]));
-        return this.store[address];
+    NonceTracker.prototype.onTransactionError = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.countOfPendingTransactions--;
+                        if (!this.transactionsOnHold)
+                            this.transactionsOnHold = [];
+                        if (!(this.countOfPendingTransactions === 0)) return [3 /*break*/, 1];
+                        this.sendHoldTransactions();
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.waitForPendingTransactions()];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NonceTracker.prototype.waitForPendingTransactions = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve) {
+                        if (!_this.transactionsOnHold)
+                            return resolve();
+                        _this.transactionsOnHold.push(function () {
+                            resolve();
+                        });
+                    })];
+            });
+        });
     };
-    NonceTracker.prototype.consumeNonce = function (address) {
-        this.checkAccount(address);
-        NonceTracker.logger.trace("Consume nonce: ".concat(this.store[address] + 1));
-        return this.store[address]++;
+    NonceTracker.prototype.sendHoldTransactions = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.transactionsOnHold)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.initAccount()];
+                    case 1:
+                        _a.sent();
+                        this.transactionsOnHold.forEach(function (callback) { return callback(); });
+                        this.transactionsOnHold = undefined;
+                        return [2 /*return*/];
+                }
+            });
+        });
     };
-    NonceTracker.logger = logger_1.default.child({ className: "NonceTracker" });
     return NonceTracker;
 }());
 exports.default = NonceTracker;

package/build/utils/TxManager.d.ts

@@ -10,18 +10,12 @@ declare type MethodReturnType = ContractSendMethod & {
 };
 declare class TxManager {
     private static web3;
-    private static nonceTracker;
     private static logger;
-    private static transactionsOnHold;
-    private static countOfPendingTransactions;
+    private static nonceTrackers;
     static init(web3: Web3): void;
     private static checkIfInitialized;
     static initAccount(address: string): Promise<void>;
     static execute(method: (...args: ArgumentsType) => MethodReturnType, args: ArgumentsType, transactionOptions?: TransactionOptions, to?: string): Promise<TransactionReceipt>;
     static publishTransaction(txData: Record<string, any>, transactionOptions?: TransactionOptions, transactionCall?: MethodReturnType): Promise<TransactionReceipt>;
-    private static onStartPublishing;
-    private static onError;
-    private static onFinishPublishing;
-    private static waitForPendingTransactions;
 }
 export default TxManager;

package/build/utils/TxManager.js

@@ -62,7 +62,6 @@ var TxManager = /** @class */ (function () {
     }
     TxManager.init = function (web3) {
         this.web3 = web3;
-        this.nonceTracker = new NonceTracker_1.default(web3);
     };
     TxManager.checkIfInitialized = function () {
         if (!this.web3) {
@@ -72,7 +71,16 @@ var TxManager = /** @class */ (function () {
     TxManager.initAccount = function (address) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.nonceTracker.initAccount(address)];
+                switch (_a.label) {
+                    case 0:
+                        if (this.nonceTrackers[address])
+                            return [2 /*return*/];
+                        this.nonceTrackers[address] = new NonceTracker_1.default(this.web3, address);
+                        return [4 /*yield*/, this.nonceTrackers[address].initAccount()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
             });
         });
     };
@@ -92,55 +100,55 @@ var TxManager = /** @class */ (function () {
     };
     TxManager.publishTransaction = function (txData, transactionOptions, transactionCall) {
         return __awaiter(this, void 0, void 0, function () {
-            var web3, options, estimatedGas, e_1, signingKey, signed, data, data, e_2;
+            var web3, options, estimatedGas, e_1, nonceTracker, signingKey, transactionResultData, signed, e_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         this.checkIfInitialized();
                         (0, utils_1.checkIfInitialized)();
                         (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
-                        return [4 /*yield*/, this.onStartPublishing()];
-                    case 1:
-                        _a.sent();
                         web3 = (transactionOptions === null || transactionOptions === void 0 ? void 0 : transactionOptions.web3) || this.web3;
                         return [4 /*yield*/, (0, utils_1.createTransactionOptions)(__assign({}, transactionOptions))];
-                    case 2:
+                    case 1:
                         options = _a.sent();
                         if (!options.from) {
                             throw Error("From account is undefined. You should pass it to transactionOptions or init action account.");
                         }
                         txData = __assign(__assign({}, options), txData);
-                        if (!transactionCall) return [3 /*break*/, 7];
+                        if (!transactionCall) return [3 /*break*/, 6];
                         estimatedGas = void 0;
-                        _a.label = 3;
-                    case 3:
-                        _a.trys.push([3, 5, , 6]);
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
                         return [4 /*yield*/, transactionCall.estimateGas(txData)];
-                    case 4:
+                    case 3:
                         estimatedGas = _a.sent();
-                        return [3 /*break*/, 6];
-                    case 5:
+                        return [3 /*break*/, 5];
+                    case 4:
                         e_1 = _a.sent();
                         TxManager.logger.debug({ error: e_1 }, "Fail to calculate estimated gas");
                         estimatedGas = constants_1.defaultGasLimit;
-                        return [3 /*break*/, 6];
-                    case 6:
+                        return [3 /*break*/, 5];
+                    case 5:
                         txData.gas = Math.ceil(estimatedGas * store_1.default.gasLimitMultiplier);
-                        _a.label = 7;
+                        _a.label = 6;
+                    case 6:
+                        if (!(!(0, utils_1.checkForUsingExternalTxManager)(transactionOptions) && this.nonceTrackers[options.from])) return [3 /*break*/, 8];
+                        nonceTracker = this.nonceTrackers[options.from];
+                        return [4 /*yield*/, nonceTracker.onTransactionStartPublishing()];
                     case 7:
-                        // TODO: Consider a better way to organize different strategies for publishing transactions.
-                        if (!(0, utils_1.checkForUsingExternalTxManager)(transactionOptions)) {
-                            if (this.nonceTracker.isManaged(options.from)) {
-                                txData.nonce = this.nonceTracker.consumeNonce(options.from);
-                            }
-                        }
-                        signingKey = store_1.default.keys[options.from];
+                        _a.sent();
+                        txData.nonce = nonceTracker.consumeNonce();
                         _a.label = 8;
                     case 8:
-                        _a.trys.push([8, 14, , 16]);
-                        if (!signingKey) return [3 /*break*/, 11];
-                        return [4 /*yield*/, web3.eth.accounts.signTransaction(txData, signingKey)];
+                        signingKey = store_1.default.keys[options.from];
+                        _a.label = 9;
                     case 9:
+                        _a.trys.push([9, 15, , 18]);
+                        transactionResultData = void 0;
+                        if (!signingKey) return [3 /*break*/, 12];
+                        return [4 /*yield*/, web3.eth.accounts.signTransaction(txData, signingKey)];
+                    case 10:
                         signed = _a.sent();
                         if (!signed.rawTransaction) {
                             throw new Error("Failed to sign transaction");
@@ -150,97 +158,37 @@ var TxManager = /** @class */ (function () {
                             txData: lodash_1.default.omit(txData, ["data"]),
                         }, "Publishing signed transaction");
                         return [4 /*yield*/, web3.eth.sendSignedTransaction(signed.rawTransaction)];
-                    case 10:
-                        data = _a.sent();
-                        this.onFinishPublishing();
-                        return [2 /*return*/, data];
                     case 11:
+                        transactionResultData = _a.sent();
+                        return [3 /*break*/, 14];
+                    case 12:
                         TxManager.logger.debug({
                             txData: lodash_1.default.omit(txData, ["data"]),
                         }, "Publishing unsigned transaction");
                         return [4 /*yield*/, web3.eth.sendTransaction(txData)];
-                    case 12:
-                        data = _a.sent();
-                        this.onFinishPublishing();
-                        return [2 /*return*/, data];
-                    case 13: return [3 /*break*/, 16];
+                    case 13:
+                        transactionResultData = _a.sent();
+                        _a.label = 14;
                     case 14:
+                        if (nonceTracker)
+                            nonceTracker.onTransactionPublished();
+                        return [2 /*return*/, transactionResultData];
+                    case 15:
                         e_2 = _a.sent();
                         TxManager.logger.error(e_2, "Error during transaction execution");
-                        return [4 /*yield*/, this.onError()];
-                    case 15:
+                        if (!nonceTracker) return [3 /*break*/, 17];
+                        return [4 /*yield*/, nonceTracker.onTransactionError()];
+                    case 16:
                         _a.sent();
-                        throw e_2;
-                    case 16: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    TxManager.onStartPublishing = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.countOfPendingTransactions++;
-                        if (!this.transactionsOnHold)
-                            return [2 /*return*/];
-                        return [4 /*yield*/, this.waitForPendingTransactions()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    TxManager.onError = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.countOfPendingTransactions--;
-                        if (this.countOfPendingTransactions === 0)
-                            return [2 /*return*/];
-                        this.transactionsOnHold = [];
-                        return [4 /*yield*/, this.waitForPendingTransactions()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    TxManager.onFinishPublishing = function () {
-        var _this = this;
-        this.countOfPendingTransactions--;
-        if (this.countOfPendingTransactions === 0 && this.transactionsOnHold) {
-            this.nonceTracker.reinitialize().then(function () {
-                var _a;
-                (_a = _this.transactionsOnHold) === null || _a === void 0 ? void 0 : _a.forEach(function (callback) { return callback(); });
-                _this.transactionsOnHold = undefined;
-            });
-        }
-    };
-    TxManager.waitForPendingTransactions = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, new Promise(function (resolve) {
-                            if (!_this.transactionsOnHold)
-                                return resolve();
-                            _this.transactionsOnHold.push(function () {
-                                resolve();
-                            });
-                        })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+                        _a.label = 17;
+                    case 17: throw e_2;
+                    case 18: return [2 /*return*/];
                 }
             });
         });
     };
     TxManager.logger = logger_1.default.child({ className: "TxManager" });
-    TxManager.countOfPendingTransactions = 0;
+    TxManager.nonceTrackers = {};
     return TxManager;
 }());
 exports.default = TxManager;

package/build/utils/compressors/GzipCompressor.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Compression_TYPE } from "../../proto/Compression";
+import { Compressor } from "../../types/Compressor";
+export declare class GzipCompressor<T> implements Compressor<T> {
+    static type: Compression_TYPE;
+    compress(content: T): Promise<Buffer>;
+    decompress(bytes: Buffer): Promise<T>;
+}

package/build/utils/compressors/GzipCompressor.js

@@ -0,0 +1,65 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GzipCompressor = void 0;
+var node_gzip_1 = require("node-gzip");
+var Compression_1 = require("../../proto/Compression");
+var GzipCompressor = /** @class */ (function () {
+    function GzipCompressor() {
+    }
+    GzipCompressor.prototype.compress = function (content) {
+        var stringified = JSON.stringify(content);
+        return (0, node_gzip_1.gzip)(stringified);
+    };
+    GzipCompressor.prototype.decompress = function (bytes) {
+        return __awaiter(this, void 0, void 0, function () {
+            var stringified;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, node_gzip_1.ungzip)(bytes)];
+                    case 1:
+                        stringified = _a.sent();
+                        return [2 /*return*/, JSON.parse(stringified.toString())];
+                }
+            });
+        });
+    };
+    GzipCompressor.type = Compression_1.Compression_TYPE.GZIP;
+    return GzipCompressor;
+}());
+exports.GzipCompressor = GzipCompressor;

package/build/utils/compressors/UncompressedCompressor.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Compression_TYPE } from "../../proto/Compression";
+import { Compressor } from "../../types/Compressor";
+export declare class UncompressedCompressor<T = unknown> implements Compressor<T> {
+    static type: Compression_TYPE;
+    compress(content: T): Promise<Buffer>;
+    decompress(bytes: Buffer): Promise<T>;
+}

package/build/utils/compressors/UncompressedCompressor.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UncompressedCompressor = void 0;
+var Compression_1 = require("../../proto/Compression");
+var UncompressedCompressor = /** @class */ (function () {
+    function UncompressedCompressor() {
+    }
+    UncompressedCompressor.prototype.compress = function (content) {
+        var stringified = JSON.stringify(content);
+        return Promise.resolve(Buffer.from(stringified));
+    };
+    UncompressedCompressor.prototype.decompress = function (bytes) {
+        var stringified = bytes.toString();
+        return Promise.resolve(JSON.parse(stringified));
+    };
+    UncompressedCompressor.type = Compression_1.Compression_TYPE.Uncompressed;
+    return UncompressedCompressor;
+}());
+exports.UncompressedCompressor = UncompressedCompressor;

package/build/utils/compressors/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./GzipCompressor";
+export * from "./UncompressedCompressor";

package/build/utils/compressors/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./GzipCompressor"), exports);
+__exportStar(require("./UncompressedCompressor"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@super-protocol/sdk-js",
-  "version": "0.11.3-beta.0",
+  "version": "0.11.6-beta.0",
   "main": "build/index.js",
   "license": "MIT",
   "files": [