@super-protocol/sdk-js 0.6.0

package/build/crypto/nodejs/NativeCrypto.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ReadStream, WriteStream } from 'fs';
+import { Cipher, Decipher } from 'crypto';
+import { Encoding, EncryptionWithMacIV } from "@super-protocol/dto-js";
+/**
+ *
+ */
+declare class NativeCrypto {
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.mode === 'mode'
+     * ```
+     * but it doesn't work in browser
+     */
+    static readonly isCCM: (cipher: string) => boolean;
+    static readonly isGCM: (cipher: string) => boolean;
+    static readonly isOCB: (cipher: string) => boolean;
+    static readonly isECB: (cipher: string) => boolean;
+    static readonly isRC4: (cipher: string) => boolean;
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.keyLength
+     * ```
+     * but it doesn't work in browser
+     */
+    static getKeyLength(cipher: string): number;
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.ivLength
+     * ```
+     * but it doesn't work in browser
+     */
+    static getIVLength(cipher: string): number;
+    static createKey(cipher: string): Buffer;
+    static createIV(cipher: string): Buffer;
+    static createCipher(cipher: string, key: Buffer, iv: Buffer): Cipher;
+    static createDecipher(cipher: string, key: Buffer, iv?: Buffer, mac?: Buffer): Decipher;
+    static encrypt(key: Buffer, content: string, cipherName: string, outputEncoding?: Encoding, inputEncoding?: BufferEncoding): Partial<EncryptionWithMacIV>;
+    static encryptStream(key: Buffer, inputStream: ReadStream, outputStream: WriteStream, cipherName: any, encoding?: Encoding): Promise<Partial<EncryptionWithMacIV>>;
+    static decrypt(key: Buffer, content: string, cipherName: string, params?: {
+        iv: Buffer;
+        mac?: Buffer;
+    }, inputEncoding?: Encoding, outputEncoding?: BufferEncoding): string;
+    static decryptStream(key: Buffer, inputStream: ReadStream, outputStream: WriteStream, cipherName: string, params?: {
+        iv: Buffer;
+        mac: Buffer;
+    }): Promise<void>;
+}
+export default NativeCrypto;

package/build/crypto/nodejs/NativeCrypto.js

@@ -0,0 +1,214 @@
+"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 });
+var crypto_1 = require("crypto");
+var events_1 = require("events");
+var dto_js_1 = require("@super-protocol/dto-js");
+/**
+ *
+ */
+var NativeCrypto = /** @class */ (function () {
+    function NativeCrypto() {
+    }
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.keyLength
+     * ```
+     * but it doesn't work in browser
+     */
+    NativeCrypto.getKeyLength = function (cipher) {
+        if (/256\-xts/.test(cipher)) {
+            return 64;
+        }
+        if (/256|128\-xts|chacha20/.test(cipher)
+            && cipher !== 'aes-128-cbc-hmac-sha256') {
+            return 32;
+        }
+        if (/192|des\-ede3|desx|des3$/.test(cipher) ||
+            cipher === 'id-smime-alg-cms3deswrap') {
+            return 24;
+        }
+        if (/128|des\-ede/.test(cipher)) {
+            return 16;
+        }
+        if (/64|des/.test(cipher)) {
+            return 8;
+        }
+        if (/40/.test(cipher)) {
+            return 5;
+        }
+        return 16;
+    };
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.ivLength
+     * ```
+     * but it doesn't work in browser
+     */
+    NativeCrypto.getIVLength = function (cipher) {
+        if (this.isCCM(cipher) || this.isGCM(cipher) || this.isOCB(cipher)) {
+            return 12;
+        }
+        if (/wrap\-pad/.test(cipher)) {
+            return 4;
+        }
+        if (/wrap|cast|des|bf|blowfish|idea|rc2/.test(cipher)) {
+            return 8;
+        }
+        return 16;
+    };
+    NativeCrypto.createKey = function (cipher) {
+        var length = this.getKeyLength(cipher);
+        return (0, crypto_1.randomBytes)(length);
+    };
+    NativeCrypto.createIV = function (cipher) {
+        var length = this.getIVLength(cipher);
+        return (0, crypto_1.randomBytes)(length);
+    };
+    NativeCrypto.createCipher = function (cipher, key, iv) {
+        if (this.isECB(cipher) || this.isRC4(cipher)) {
+            return (0, crypto_1.createCipher)(cipher, key);
+        }
+        if (this.isCCM(cipher) || this.isOCB(cipher)) {
+            var options = {
+                authTagLength: 16,
+            };
+            return (0, crypto_1.createCipheriv)(cipher, key, iv, options);
+        }
+        return (0, crypto_1.createCipheriv)(cipher, key, iv);
+    };
+    NativeCrypto.createDecipher = function (cipher, key, iv, mac) {
+        if (iv) {
+            var options = {};
+            if (this.isCCM(cipher) || this.isOCB(cipher)) {
+                options.authTagLength = 16;
+            }
+            var decipher = (0, crypto_1.createDecipheriv)(cipher, key, iv, options);
+            if (mac) {
+                decipher.setAuthTag(mac);
+            }
+            return decipher;
+        }
+        else {
+            return (0, crypto_1.createDecipher)(cipher, key);
+        }
+    };
+    NativeCrypto.encrypt = function (key, content, cipherName, outputEncoding, 
+    // TODO: replace BufferEncoding with Encoding
+    inputEncoding) {
+        if (outputEncoding === void 0) { outputEncoding = dto_js_1.Encoding.base64; }
+        if (inputEncoding === void 0) { inputEncoding = 'binary'; }
+        var iv = this.createIV(cipherName);
+        var result = {};
+        var cipher = this.createCipher(cipherName, key, iv);
+        result.ciphertext = cipher.update(content, inputEncoding, outputEncoding);
+        result.ciphertext += cipher.final(outputEncoding);
+        if (!this.isECB(cipherName) && !this.isRC4(cipherName)) {
+            result.iv = iv.toString(outputEncoding);
+        }
+        if (this.isCCM(cipherName) || this.isGCM(cipherName) || this.isOCB(cipherName)) {
+            result.mac = cipher.getAuthTag().toString(outputEncoding);
+        }
+        return result;
+    };
+    NativeCrypto.encryptStream = function (key, inputStream, outputStream, cipherName, encoding) {
+        if (encoding === void 0) { encoding = dto_js_1.Encoding.base64; }
+        return __awaiter(this, void 0, void 0, function () {
+            var iv, result, cipher;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        iv = this.createIV(cipherName);
+                        result = {};
+                        cipher = this.createCipher(cipherName, key, iv);
+                        inputStream.pipe(cipher).pipe(outputStream);
+                        return [4 /*yield*/, (0, events_1.once)(outputStream, "finish")];
+                    case 1:
+                        _a.sent();
+                        result.iv = iv.toString(encoding);
+                        if (this.isCCM(cipherName) || this.isGCM(cipherName)) {
+                            result.mac = cipher.getAuthTag().toString(encoding);
+                        }
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    NativeCrypto.decrypt = function (key, content, cipherName, params, inputEncoding, 
+    // TODO: replace BufferEncoding with Encoding
+    outputEncoding) {
+        if (inputEncoding === void 0) { inputEncoding = dto_js_1.Encoding.base64; }
+        if (outputEncoding === void 0) { outputEncoding = 'binary'; }
+        var decipher = this.createDecipher(cipherName, key, params === null || params === void 0 ? void 0 : params.iv, params === null || params === void 0 ? void 0 : params.mac);
+        var decrypted = decipher.update(content, inputEncoding, outputEncoding);
+        decrypted += decipher.final(outputEncoding);
+        return decrypted;
+    };
+    NativeCrypto.decryptStream = function (key, inputStream, outputStream, cipherName, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var decipher;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        decipher = this.createDecipher(cipherName, key, params === null || params === void 0 ? void 0 : params.iv, params === null || params === void 0 ? void 0 : params.mac);
+                        inputStream.pipe(decipher).pipe(outputStream);
+                        return [4 /*yield*/, (0, events_1.once)(outputStream, "finish")];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.mode === 'mode'
+     * ```
+     * but it doesn't work in browser
+     */
+    NativeCrypto.isCCM = function (cipher) { return /ccm/i.test(cipher) || cipher === 'chacha20-poly1305'; };
+    NativeCrypto.isGCM = function (cipher) { return /gcm/i.test(cipher); };
+    NativeCrypto.isOCB = function (cipher) { return /ocb/i.test(cipher); };
+    NativeCrypto.isECB = function (cipher) { return /ecb/i.test(cipher) || cipher === 'des-ede' || cipher === 'des-ede3'; };
+    NativeCrypto.isRC4 = function (cipher) { return /^rc4/i.test(cipher); };
+    return NativeCrypto;
+}());
+exports.default = NativeCrypto;

package/build/crypto/nodejs/RSA-Hybrid.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ReadStream, WriteStream } from "fs";
+import { Encryption, RSAHybridEncryption } from "@super-protocol/dto-js";
+import { KeyObject } from "crypto";
+declare class RSAHybrid {
+    static getKeyFingerprint(key: KeyObject): string;
+    private static publicEncrypt;
+    private static privateDecrypt;
+    static encrypt(content: string, encryption: Encryption): RSAHybridEncryption;
+    static encryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: Encryption): Promise<RSAHybridEncryption>;
+    static decrypt(encryption: RSAHybridEncryption): string;
+    static decryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: RSAHybridEncryption): Promise<void>;
+}
+export default RSAHybrid;

package/build/crypto/nodejs/RSA-Hybrid.js

@@ -0,0 +1,153 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var dto_js_1 = require("@super-protocol/dto-js");
+var crypto_1 = require("crypto");
+var NativeCrypto_1 = __importDefault(require("./NativeCrypto"));
+var RSAHybrid = /** @class */ (function () {
+    function RSAHybrid() {
+    }
+    RSAHybrid.getKeyFingerprint = function (key) {
+        var jsonKey = key.export({ format: "jwk" });
+        var buffer = Buffer.concat([
+            Buffer.from("ssh-rsa"),
+            Buffer.from(jsonKey.e || ""),
+            Buffer.from(jsonKey.n || ""),
+        ]);
+        var hex = (0, crypto_1.createHash)("md5").update(buffer).digest("hex");
+        return hex.match(/.{2}/g).join(":");
+    };
+    RSAHybrid.publicEncrypt = function (rsaKey, aesKey) {
+        var _a;
+        var publicKey = (0, crypto_1.createPublicKey)({
+            key: rsaKey,
+            format: "pem",
+        });
+        var encryptedKey = (0, crypto_1.publicEncrypt)({
+            key: publicKey,
+            padding: crypto_1.constants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: "sha256",
+        }, Buffer.from(aesKey));
+        var keyFingerprint = this.getKeyFingerprint(publicKey);
+        return _a = {},
+            _a[keyFingerprint] = encryptedKey.toString("base64"),
+            _a;
+    };
+    RSAHybrid.privateDecrypt = function (rsaKey, keys) {
+        var privateKey = (0, crypto_1.createPrivateKey)({
+            key: rsaKey,
+            format: "pem",
+        });
+        var keyFingerprint = this.getKeyFingerprint(privateKey);
+        var encryptedKey = keys[keyFingerprint];
+        var aesKey = (0, crypto_1.privateDecrypt)({
+            key: privateKey,
+            padding: crypto_1.constants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: "sha256",
+        }, Buffer.from(encryptedKey, "base64"));
+        return aesKey;
+    };
+    RSAHybrid.encrypt = function (content, encryption) {
+        var aesKey = (0, crypto_1.randomBytes)(32);
+        var keys = this.publicEncrypt(encryption.key, aesKey);
+        var encrypted = NativeCrypto_1.default.encrypt(aesKey, content, dto_js_1.Cipher.AES_256_GCM, encryption.encoding);
+        return __assign(__assign({}, encrypted), { encoding: encryption.encoding, algo: dto_js_1.CryptoAlgorithm.RSAHybrid, cipher: dto_js_1.Cipher.RSA_OAEP_AES_GCM, keys: JSON.stringify(keys) });
+    };
+    RSAHybrid.encryptStream = function (inputStream, outputStream, encryption) {
+        return __awaiter(this, void 0, void 0, function () {
+            var aesKey, keys, encrypted;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        aesKey = (0, crypto_1.randomBytes)(32);
+                        keys = this.publicEncrypt(encryption.key, aesKey);
+                        return [4 /*yield*/, NativeCrypto_1.default.encryptStream(aesKey, inputStream, outputStream, dto_js_1.Cipher.AES_256_GCM, encryption.encoding)];
+                    case 1:
+                        encrypted = (_a.sent());
+                        return [2 /*return*/, __assign(__assign({}, encrypted), { encoding: encryption.encoding, algo: dto_js_1.CryptoAlgorithm.RSAHybrid, cipher: dto_js_1.Cipher.RSA_OAEP_AES_GCM, keys: JSON.stringify(keys) })];
+                }
+            });
+        });
+    };
+    RSAHybrid.decrypt = function (encryption) {
+        var iv = Buffer.from(encryption.iv, encryption.encoding);
+        var mac = Buffer.from(encryption.mac, encryption.encoding);
+        var aesKey = this.privateDecrypt(encryption.key, JSON.parse(encryption.keys));
+        var decrypted = NativeCrypto_1.default.decrypt(aesKey, encryption.ciphertext, dto_js_1.Cipher.AES_256_GCM, {
+            iv: iv,
+            mac: mac,
+        }, encryption.encoding);
+        return decrypted;
+    };
+    RSAHybrid.decryptStream = function (inputStream, outputStream, encryption) {
+        return __awaiter(this, void 0, void 0, function () {
+            var iv, mac, aesKey;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        iv = Buffer.from(encryption.iv, encryption.encoding);
+                        mac = Buffer.from(encryption.mac, encryption.encoding);
+                        aesKey = this.privateDecrypt(encryption.key, JSON.parse(encryption.keys));
+                        return [4 /*yield*/, NativeCrypto_1.default.decryptStream(aesKey, inputStream, outputStream, dto_js_1.Cipher.AES_256_GCM, {
+                                iv: iv,
+                                mac: mac,
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return RSAHybrid;
+}());
+exports.default = RSAHybrid;

package/build/index.d.ts

@@ -0,0 +1,65 @@
+import BlockchainConnector from "./BlockchainConnector";
+export default BlockchainConnector;
+export * from "./BlockchainConnector";
+export { default as Crypto } from "./crypto";
+export { default as TIIGenerator } from "./TIIGenerator";
+export * from "./TIIGenerator";
+export { default as Consensus } from "./staticModels/Consensus";
+export * from "./staticModels/Consensus";
+export { default as LastBlocks } from "./staticModels/LastBlocks";
+export * from "./staticModels/LastBlocks";
+export { default as Suspicious } from "./staticModels/Suspicious";
+export * from "./staticModels/Suspicious";
+export { default as OrdersFactory } from "./staticModels/OrdersFactory";
+export * from "./staticModels/OrdersFactory";
+export { default as ActiveOrders } from "./staticModels/ActiveOrders";
+export * from "./staticModels/ActiveOrders";
+export { default as ActiveOffers } from "./staticModels/ActiveOffers";
+export * from "./staticModels/ActiveOffers";
+export { default as OffersFactory } from "./staticModels/OffersFactory";
+export * from "./staticModels/OffersFactory";
+export { default as TeeOffersFactory } from "./staticModels/TeeOffersFactory";
+export * from "./staticModels/TeeOffersFactory";
+export { default as ProviderRegistry } from "./staticModels/ProviderRegistry";
+export * from "./staticModels/ProviderRegistry";
+export { default as Staking } from "./staticModels/Staking";
+export * from "./staticModels/Staking";
+export { default as Voting } from "./staticModels/Voting";
+export * from "./staticModels/Voting";
+export { default as SuperproToken } from "./staticModels/SuperproToken";
+export * from "./staticModels/SuperproToken";
+export { default as Superpro } from "./staticModels/Superpro";
+export * from "./staticModels/Superpro";
+export { default as Epochs } from "./staticModels/Epochs";
+export * from "./staticModels/Epochs";
+export { default as Marks } from "./staticModels/Marks";
+export * from "./staticModels/Marks";
+export { default as Order } from "./models/Order";
+export * from "./models/Order";
+export { default as Provider } from "./models/Provider";
+export * from "./models/Provider";
+export { default as TeeOffer } from "./models/TeeOffer";
+export * from "./models/TeeOffer";
+export { default as Offer } from "./models/Offer";
+export * from "./models/Offer";
+export { default as Ballot } from "./models/Ballot";
+export * from "./models/Ballot";
+export { default as TCB } from "./models/TCB";
+export * from "./models/TCB";
+export * from "./types/Offer";
+export * from "./types/Epoch";
+export * from "./types/Marks";
+export * from "./types/Order";
+export * from "./types/TeeOffer";
+export * from "./types/Provider";
+export * from "./types/Staking";
+export * from "./types/Ballot";
+export * from "./types/Superpro";
+export * from "./types/TcbData";
+export * from "./types/Origins";
+export * as ChunkedStorageProvider from "./providers/storage/ChunksDownloadDecorator";
+export { default as StorageFileAccess } from "./types/storage/StorageFileAccess";
+export { default as StorageObject } from "./types/storage/StorageObject";
+export { default as StorageAccess } from "./types/storage/StorageAccess";
+export { default as getStorageProvider } from "./providers/storage/getStorageProvider";
+export { default as IStorageProvider } from "./providers/storage/IStorageProvider";

package/build/index.js

@@ -0,0 +1,117 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStorageProvider = exports.ChunkedStorageProvider = exports.TCB = exports.Ballot = exports.Offer = exports.TeeOffer = exports.Provider = exports.Order = exports.Marks = exports.Epochs = exports.Superpro = exports.SuperproToken = exports.Voting = exports.Staking = exports.ProviderRegistry = exports.TeeOffersFactory = exports.OffersFactory = exports.ActiveOffers = exports.ActiveOrders = exports.OrdersFactory = exports.Suspicious = exports.LastBlocks = exports.Consensus = exports.TIIGenerator = exports.Crypto = void 0;
+var BlockchainConnector_1 = __importDefault(require("./BlockchainConnector"));
+exports.default = BlockchainConnector_1.default;
+__exportStar(require("./BlockchainConnector"), exports);
+var crypto_1 = require("./crypto");
+Object.defineProperty(exports, "Crypto", { enumerable: true, get: function () { return __importDefault(crypto_1).default; } });
+var TIIGenerator_1 = require("./TIIGenerator");
+Object.defineProperty(exports, "TIIGenerator", { enumerable: true, get: function () { return __importDefault(TIIGenerator_1).default; } });
+__exportStar(require("./TIIGenerator"), exports);
+var Consensus_1 = require("./staticModels/Consensus");
+Object.defineProperty(exports, "Consensus", { enumerable: true, get: function () { return __importDefault(Consensus_1).default; } });
+__exportStar(require("./staticModels/Consensus"), exports);
+var LastBlocks_1 = require("./staticModels/LastBlocks");
+Object.defineProperty(exports, "LastBlocks", { enumerable: true, get: function () { return __importDefault(LastBlocks_1).default; } });
+__exportStar(require("./staticModels/LastBlocks"), exports);
+var Suspicious_1 = require("./staticModels/Suspicious");
+Object.defineProperty(exports, "Suspicious", { enumerable: true, get: function () { return __importDefault(Suspicious_1).default; } });
+__exportStar(require("./staticModels/Suspicious"), exports);
+var OrdersFactory_1 = require("./staticModels/OrdersFactory");
+Object.defineProperty(exports, "OrdersFactory", { enumerable: true, get: function () { return __importDefault(OrdersFactory_1).default; } });
+__exportStar(require("./staticModels/OrdersFactory"), exports);
+var ActiveOrders_1 = require("./staticModels/ActiveOrders");
+Object.defineProperty(exports, "ActiveOrders", { enumerable: true, get: function () { return __importDefault(ActiveOrders_1).default; } });
+__exportStar(require("./staticModels/ActiveOrders"), exports);
+var ActiveOffers_1 = require("./staticModels/ActiveOffers");
+Object.defineProperty(exports, "ActiveOffers", { enumerable: true, get: function () { return __importDefault(ActiveOffers_1).default; } });
+__exportStar(require("./staticModels/ActiveOffers"), exports);
+var OffersFactory_1 = require("./staticModels/OffersFactory");
+Object.defineProperty(exports, "OffersFactory", { enumerable: true, get: function () { return __importDefault(OffersFactory_1).default; } });
+__exportStar(require("./staticModels/OffersFactory"), exports);
+var TeeOffersFactory_1 = require("./staticModels/TeeOffersFactory");
+Object.defineProperty(exports, "TeeOffersFactory", { enumerable: true, get: function () { return __importDefault(TeeOffersFactory_1).default; } });
+__exportStar(require("./staticModels/TeeOffersFactory"), exports);
+var ProviderRegistry_1 = require("./staticModels/ProviderRegistry");
+Object.defineProperty(exports, "ProviderRegistry", { enumerable: true, get: function () { return __importDefault(ProviderRegistry_1).default; } });
+__exportStar(require("./staticModels/ProviderRegistry"), exports);
+var Staking_1 = require("./staticModels/Staking");
+Object.defineProperty(exports, "Staking", { enumerable: true, get: function () { return __importDefault(Staking_1).default; } });
+__exportStar(require("./staticModels/Staking"), exports);
+var Voting_1 = require("./staticModels/Voting");
+Object.defineProperty(exports, "Voting", { enumerable: true, get: function () { return __importDefault(Voting_1).default; } });
+__exportStar(require("./staticModels/Voting"), exports);
+var SuperproToken_1 = require("./staticModels/SuperproToken");
+Object.defineProperty(exports, "SuperproToken", { enumerable: true, get: function () { return __importDefault(SuperproToken_1).default; } });
+__exportStar(require("./staticModels/SuperproToken"), exports);
+var Superpro_1 = require("./staticModels/Superpro");
+Object.defineProperty(exports, "Superpro", { enumerable: true, get: function () { return __importDefault(Superpro_1).default; } });
+__exportStar(require("./staticModels/Superpro"), exports);
+var Epochs_1 = require("./staticModels/Epochs");
+Object.defineProperty(exports, "Epochs", { enumerable: true, get: function () { return __importDefault(Epochs_1).default; } });
+__exportStar(require("./staticModels/Epochs"), exports);
+var Marks_1 = require("./staticModels/Marks");
+Object.defineProperty(exports, "Marks", { enumerable: true, get: function () { return __importDefault(Marks_1).default; } });
+__exportStar(require("./staticModels/Marks"), exports);
+var Order_1 = require("./models/Order");
+Object.defineProperty(exports, "Order", { enumerable: true, get: function () { return __importDefault(Order_1).default; } });
+__exportStar(require("./models/Order"), exports);
+var Provider_1 = require("./models/Provider");
+Object.defineProperty(exports, "Provider", { enumerable: true, get: function () { return __importDefault(Provider_1).default; } });
+__exportStar(require("./models/Provider"), exports);
+var TeeOffer_1 = require("./models/TeeOffer");
+Object.defineProperty(exports, "TeeOffer", { enumerable: true, get: function () { return __importDefault(TeeOffer_1).default; } });
+__exportStar(require("./models/TeeOffer"), exports);
+var Offer_1 = require("./models/Offer");
+Object.defineProperty(exports, "Offer", { enumerable: true, get: function () { return __importDefault(Offer_1).default; } });
+__exportStar(require("./models/Offer"), exports);
+var Ballot_1 = require("./models/Ballot");
+Object.defineProperty(exports, "Ballot", { enumerable: true, get: function () { return __importDefault(Ballot_1).default; } });
+__exportStar(require("./models/Ballot"), exports);
+var TCB_1 = require("./models/TCB");
+Object.defineProperty(exports, "TCB", { enumerable: true, get: function () { return __importDefault(TCB_1).default; } });
+__exportStar(require("./models/TCB"), exports);
+__exportStar(require("./types/Offer"), exports);
+__exportStar(require("./types/Epoch"), exports);
+__exportStar(require("./types/Marks"), exports);
+__exportStar(require("./types/Order"), exports);
+__exportStar(require("./types/TeeOffer"), exports);
+__exportStar(require("./types/Provider"), exports);
+__exportStar(require("./types/Staking"), exports);
+__exportStar(require("./types/Ballot"), exports);
+__exportStar(require("./types/Superpro"), exports);
+__exportStar(require("./types/TcbData"), exports);
+__exportStar(require("./types/Origins"), exports);
+exports.ChunkedStorageProvider = __importStar(require("./providers/storage/ChunksDownloadDecorator"));
+var getStorageProvider_1 = require("./providers/storage/getStorageProvider");
+Object.defineProperty(exports, "getStorageProvider", { enumerable: true, get: function () { return __importDefault(getStorageProvider_1).default; } });

package/build/logger.d.ts

@@ -0,0 +1,4 @@
+declare const logger: import("pino").Logger<{
+    level: string;
+}>;
+export default logger;

package/build/logger.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var pino_1 = __importDefault(require("pino"));
+var logger = (0, pino_1.default)({ level: process.env.LOG_LEVEL || "trace" });
+exports.default = logger;

package/build/models/Ballot.d.ts

@@ -0,0 +1,13 @@
+import { BallotInfo } from "../types/Ballot";
+declare class Ballot {
+    address: string;
+    private contract;
+    private logger;
+    ballotInfo?: BallotInfo;
+    constructor(address: string);
+    /**
+     * Function for fetching order info from blockchain
+     */
+    getBallotInfo(): Promise<BallotInfo>;
+}
+export default Ballot;