@super-protocol/sdk-js 0.11.4-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/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/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.4-beta.0",
+  "version": "0.11.6-beta.0",
   "main": "build/index.js",
   "license": "MIT",
   "files": [