@super-protocol/sdk-js 0.6.0

package/build/BlockchainConnector.d.ts

@@ -0,0 +1,48 @@
+import { TransactionOptions } from "./types/Web3";
+import BlockchainTransaction from "./types/blockchainConnector/StorageAccess";
+import { TransactionReceipt } from "web3-core";
+declare class BlockchainConnector {
+    private static logger;
+    private static provider?;
+    static defaultActionAccount?: string;
+    /**
+     * Function for connecting to blockchain
+     * Used to setting up settings for blockchain connector
+     * Needs to run this function before using blockchain connector
+     */
+    static init(config: Config): Promise<void>;
+    /**
+     * Function for connecting provider action account
+     * Needs to run this function before using any set methods in blockchain connector
+     */
+    static initActionAccount(actionAccountKey: string, manageNonce?: boolean): Promise<string>;
+    /**
+     * Returns balance of blockchain platform tokens in wei
+     */
+    static getBalance(address: string): Promise<string>;
+    /**
+     * Returns balance of blockchain platform tokens in wei
+     */
+    static transfer(to: string, amount: string, transactionOptions?: TransactionOptions): Promise<TransactionReceipt>;
+    /**
+     * Fetch transactions for specific addresses starting with specific block until last block
+     * @param addresses - array of addresses to fetch transactions (from these addresses and to these addresses)
+     * @param startBlock - number of block to start fetching transactions (if empty fetch only for last block)
+     * @param lastBlock - number of block to last fetching transactions (if empty fetch only for last block)
+     * @param batchSize - block size for asynchronous transaction loading
+     * @returns {Promise<{
+     *   transactionsByAddress, - found transactions sorted by addresses
+     *   lastBlock, - number of last fetched block (can be used to start fetching from this block next time)
+     * }>}
+     */
+    static getTransactions(addresses: string[], startBlock?: number, lastBlock?: number, batchSize?: number): Promise<BlockchainTransaction>;
+    static disconnect(): void;
+}
+export declare type Config = {
+    contractAddress: string;
+    blockchainUrl?: string;
+    gasPrice?: string;
+    gasLimit?: number;
+    gasLimitMultiplier?: number;
+};
+export default BlockchainConnector;

package/build/BlockchainConnector.js

@@ -0,0 +1,259 @@
+"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 logger_1 = __importDefault(require("./logger"));
+var web3_1 = __importDefault(require("web3"));
+var store_1 = __importDefault(require("./store"));
+var constants_1 = require("./constants");
+var utils_1 = require("./utils");
+var Superpro_1 = __importDefault(require("./staticModels/Superpro"));
+var SuperproToken_1 = __importDefault(require("./staticModels/SuperproToken"));
+var TxManager_1 = __importDefault(require("./utils/TxManager"));
+var BlockchainConnector = /** @class */ (function () {
+    function BlockchainConnector() {
+    }
+    /**
+     * Function for connecting to blockchain
+     * Used to setting up settings for blockchain connector
+     * Needs to run this function before using blockchain connector
+     */
+    BlockchainConnector.init = function (config) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (store_1.default.isInitialized)
+                            return [2 /*return*/];
+                        url = (config === null || config === void 0 ? void 0 : config.blockchainUrl) || constants_1.defaultBlockchainUrl;
+                        if (/^(ws)|(wss)/.test(url)) {
+                            this.provider = new web3_1.default.providers.WebsocketProvider(url, {
+                                reconnect: {
+                                    auto: true,
+                                    delay: 5000,
+                                    maxAttempts: 5,
+                                    onTimeout: false,
+                                },
+                            });
+                            store_1.default.web3 = new web3_1.default(this.provider);
+                        }
+                        else {
+                            this.provider = new web3_1.default.providers.HttpProvider(url);
+                            store_1.default.web3 = new web3_1.default(this.provider);
+                        }
+                        if (config === null || config === void 0 ? void 0 : config.gasPrice)
+                            store_1.default.gasPrice = config.gasPrice;
+                        if (config === null || config === void 0 ? void 0 : config.gasLimit)
+                            store_1.default.gasLimit = config.gasLimit;
+                        if (config === null || config === void 0 ? void 0 : config.gasLimitMultiplier)
+                            store_1.default.gasLimitMultiplier = config.gasLimitMultiplier;
+                        Superpro_1.default.address = config.contractAddress;
+                        _a = SuperproToken_1.default;
+                        return [4 /*yield*/, Superpro_1.default.getTokenAddress()];
+                    case 1:
+                        _a.address = _b.sent();
+                        TxManager_1.default.init(store_1.default.web3);
+                        store_1.default.isInitialized = true;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function for connecting provider action account
+     * Needs to run this function before using any set methods in blockchain connector
+     */
+    BlockchainConnector.initActionAccount = function (actionAccountKey, manageNonce) {
+        if (manageNonce === void 0) { manageNonce = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var actionAccount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        (0, utils_1.checkIfInitialized)();
+                        actionAccount = store_1.default.web3.eth.accounts.wallet.add(actionAccountKey).address;
+                        if (!store_1.default.actionAccount)
+                            store_1.default.actionAccount = actionAccount;
+                        if (!store_1.default.keys[actionAccount])
+                            store_1.default.keys[actionAccount] = actionAccountKey;
+                        if (!this.defaultActionAccount)
+                            this.defaultActionAccount = actionAccount;
+                        if (!manageNonce) return [3 /*break*/, 2];
+                        return [4 /*yield*/, TxManager_1.default.initAccount(actionAccount)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, actionAccount];
+                }
+            });
+        });
+    };
+    /**
+     * Returns balance of blockchain platform tokens in wei
+     */
+    BlockchainConnector.getBalance = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                (0, utils_1.checkIfInitialized)();
+                return [2 /*return*/, store_1.default.web3.eth.getBalance(address)];
+            });
+        });
+    };
+    /**
+     * Returns balance of blockchain platform tokens in wei
+     */
+    BlockchainConnector.transfer = function (to, amount, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var transaction;
+            return __generator(this, function (_a) {
+                (0, utils_1.checkIfInitialized)();
+                (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                transaction = {
+                    to: to,
+                    value: amount,
+                };
+                return [2 /*return*/, TxManager_1.default.publishTransaction(transaction, transactionOptions)];
+            });
+        });
+    };
+    /**
+     * Fetch transactions for specific addresses starting with specific block until last block
+     * @param addresses - array of addresses to fetch transactions (from these addresses and to these addresses)
+     * @param startBlock - number of block to start fetching transactions (if empty fetch only for last block)
+     * @param lastBlock - number of block to last fetching transactions (if empty fetch only for last block)
+     * @param batchSize - block size for asynchronous transaction loading
+     * @returns {Promise<{
+     *   transactionsByAddress, - found transactions sorted by addresses
+     *   lastBlock, - number of last fetched block (can be used to start fetching from this block next time)
+     * }>}
+     */
+    BlockchainConnector.getTransactions = function (addresses, startBlock, lastBlock, batchSize) {
+        if (batchSize === void 0) { batchSize = constants_1.BLOCK_SIZE_TO_FETCH_TRANSACTION; }
+        return __awaiter(this, void 0, void 0, function () {
+            var endBlock, _a, blocksNumbersToFetch, activeStep, i, transactionsByAddress, i;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!lastBlock) return [3 /*break*/, 1];
+                        _a = lastBlock;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, store_1.default.web3.eth.getBlockNumber()];
+                    case 2:
+                        _a = _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        endBlock = _a;
+                        if (!startBlock)
+                            startBlock = Math.max(endBlock - 1000, 0);
+                        blocksNumbersToFetch = [[]];
+                        activeStep = blocksNumbersToFetch[0];
+                        for (i = startBlock; i <= endBlock; i++) {
+                            activeStep.push(i);
+                            if (activeStep.length >= batchSize) {
+                                blocksNumbersToFetch.push([]);
+                                activeStep = blocksNumbersToFetch[blocksNumbersToFetch.length - 1];
+                            }
+                        }
+                        transactionsByAddress = {};
+                        addresses.forEach(function (address) { return (transactionsByAddress[address] = []); });
+                        i = 0;
+                        _b.label = 4;
+                    case 4:
+                        if (!(i < blocksNumbersToFetch.length)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, Promise.all(blocksNumbersToFetch[i].map(function (blockNumber) { return __awaiter(_this, void 0, void 0, function () {
+                                var block;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, store_1.default.web3.eth.getBlock(blockNumber, true)];
+                                        case 1:
+                                            block = _a.sent();
+                                            if (block && block.transactions) {
+                                                block.transactions.forEach(function (transaction) {
+                                                    var address = null;
+                                                    if (addresses.includes(transaction.from))
+                                                        address = transaction.from;
+                                                    else if (transaction.to && addresses.includes(transaction.to))
+                                                        address = transaction.to;
+                                                    if (address) {
+                                                        transactionsByAddress[address].push(__assign(__assign({}, transaction), { timestamp: +block.timestamp * 1000, input: transaction.input }));
+                                                    }
+                                                });
+                                            }
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); }))];
+                    case 5:
+                        _b.sent();
+                        _b.label = 6;
+                    case 6:
+                        i++;
+                        return [3 /*break*/, 4];
+                    case 7: return [2 /*return*/, {
+                            transactionsByAddress: transactionsByAddress,
+                            lastBlock: endBlock,
+                        }];
+                }
+            });
+        });
+    };
+    BlockchainConnector.disconnect = function () {
+        var _a;
+        (_a = this.provider) === null || _a === void 0 ? void 0 : _a.disconnect(0, "");
+        store_1.default.isInitialized = false;
+        store_1.default.web3 = undefined;
+    };
+    BlockchainConnector.logger = logger_1.default.child({ className: "BlockchainConnector" });
+    return BlockchainConnector;
+}());
+exports.default = BlockchainConnector;

package/build/TIIGenerator.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { TRI } from './proto/TRI';
+import { Encryption, Hash, Linkage, Resource } from "@super-protocol/dto-js";
+declare class TIIGenerator {
+    static generateByOffer(offerId: string, solutionHashes: Hash[], linkageString: string | undefined, resource: Resource, args: any, encryption: Encryption): Promise<string>;
+    static generate(orderId: string, resource: Resource, args: any, encryption: Encryption): Promise<string>;
+    static getSolutionHashesAndLinkage(inputOffers: string[]): Promise<{
+        hashes: Hash[];
+        linkage?: string;
+    }>;
+    static getTRI(tii: string, decryptionKey: Buffer): Promise<TRI>;
+    static getUrl(tii: string, decryptionKey: Buffer): Promise<string>;
+    static getResource<T>(tii: string, decryptionKey: Buffer): Promise<T>;
+}
+export declare type TeeRunInfo = {
+    solutionHashes: Hash[];
+    linkage: Linkage;
+    args: any;
+    encryption: Encryption;
+};
+export default TIIGenerator;

package/build/TIIGenerator.js

@@ -0,0 +1,251 @@
+"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 node_gzip_1 = require("node-gzip");
+var lodash_1 = __importDefault(require("lodash"));
+var Compression_1 = require("./proto/Compression");
+var TRI_1 = require("./proto/TRI");
+var crypto_1 = __importDefault(require("./crypto"));
+var Offer_1 = __importDefault(require("./models/Offer"));
+var Order_1 = __importDefault(require("./models/Order"));
+var TeeOffer_1 = __importDefault(require("./models/TeeOffer"));
+var dto_js_1 = require("@super-protocol/dto-js");
+var tee_lib_1 = require("@super-protocol/tee-lib");
+var TIIGenerator = /** @class */ (function () {
+    function TIIGenerator() {
+    }
+    TIIGenerator.generateByOffer = function (offerId, solutionHashes, linkageString, resource, args, encryption) {
+        return __awaiter(this, void 0, void 0, function () {
+            var teeOffer, teeOfferInfo, linkage, tlb, mac, rawTri, tri, compressedTri, _a, _b, _c, _d;
+            var _e, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        teeOffer = new TeeOffer_1.default(offerId);
+                        return [4 /*yield*/, teeOffer.getInfo()];
+                    case 1:
+                        teeOfferInfo = _g.sent();
+                        linkage = linkageString ? JSON.parse(linkageString) : {
+                            encoding: dto_js_1.Encoding.base64,
+                            mrenclave: '',
+                        };
+                        tlb = new tee_lib_1.TLBlockSerializerV1().unserializeTlb(Buffer.from(teeOfferInfo.tlb, "base64"));
+                        mac = encryption.authTag || encryption.mac;
+                        rawTri = {
+                            solutionHashes: solutionHashes.map(function (hash) { return ({
+                                type: hash.algo,
+                                hash: Buffer.from(hash.hash, hash.encoding),
+                            }); }),
+                            mrenclave: Buffer.from(linkage.mrenclave, linkage.encoding),
+                            args: JSON.stringify(args || ''),
+                            encryption: __assign(__assign({}, encryption), { ciphertext: encryption.ciphertext ? Buffer.from(encryption.ciphertext, encryption.encoding) : undefined, key: encryption.key ? Buffer.from(encryption.key, encryption.encoding) : undefined, iv: encryption.iv ? Buffer.from(encryption.iv, encryption.encoding) : undefined, mac: mac ? Buffer.from(mac, encryption.encoding) : undefined }),
+                        };
+                        tri = TRI_1.TRI.encode(rawTri).finish();
+                        _b = (_a = Compression_1.Compression).encode;
+                        _e = {};
+                        return [4 /*yield*/, (0, node_gzip_1.gzip)(tri)];
+                    case 2:
+                        compressedTri = _b.apply(_a, [(_e.data = _g.sent(),
+                                _e.type = Compression_1.Compression_TYPE.GZIP,
+                                _e)]).finish();
+                        _d = (_c = JSON).stringify;
+                        _f = {};
+                        return [4 /*yield*/, crypto_1.default.encrypt(JSON.stringify(resource), JSON.parse(teeOfferInfo.argsPublicKey))];
+                    case 3:
+                        _f.encryptedResource = _g.sent();
+                        return [4 /*yield*/, crypto_1.default.encrypt(Buffer.from(compressedTri).toString(dto_js_1.Encoding.base64), {
+                                algo: dto_js_1.CryptoAlgorithm.ECIES,
+                                key: Buffer.from(tlb.data.teePubKeyData).toString("base64"),
+                                encoding: dto_js_1.Encoding.base64,
+                            })];
+                    case 4: return [2 /*return*/, _d.apply(_c, [(_f.tri = _g.sent(),
+                                _f)])];
+                }
+            });
+        });
+    };
+    TIIGenerator.generate = function (orderId, resource, args, encryption) {
+        return __awaiter(this, void 0, void 0, function () {
+            var order, parentOrderAddress, parentOrder, parentOrderInfo, _a, hashes, linkage;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        order = new Order_1.default(orderId);
+                        return [4 /*yield*/, order.getParentOrder()];
+                    case 1:
+                        parentOrderAddress = _b.sent();
+                        parentOrder = new Order_1.default(parentOrderAddress);
+                        return [4 /*yield*/, parentOrder.getOrderInfo()];
+                    case 2:
+                        parentOrderInfo = _b.sent();
+                        return [4 /*yield*/, this.getSolutionHashesAndLinkage(parentOrderInfo.args.inputOffers)];
+                    case 3:
+                        _a = _b.sent(), hashes = _a.hashes, linkage = _a.linkage;
+                        return [2 /*return*/, this.generateByOffer(parentOrderInfo.offer, hashes, linkage, resource, args, encryption)];
+                }
+            });
+        });
+    };
+    TIIGenerator.getSolutionHashesAndLinkage = function (inputOffers) {
+        return __awaiter(this, void 0, void 0, function () {
+            var solutionHashes, solutionLinkage, anyLinkage;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        solutionHashes = [];
+                        return [4 /*yield*/, Promise.all(inputOffers.map(function (offerAddress) { return __awaiter(_this, void 0, void 0, function () {
+                                var offer, offerInfo, restrictions;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            offer = new Offer_1.default(offerAddress);
+                                            return [4 /*yield*/, offer.getInfo()];
+                                        case 1:
+                                            offerInfo = _a.sent();
+                                            if (offerInfo.hash) {
+                                                solutionHashes.push(JSON.parse(offerInfo.hash));
+                                            }
+                                            restrictions = lodash_1.default
+                                                .intersection(offerInfo.restrictions.offers, inputOffers)
+                                                .filter(function (restrictedOfferAddress) { return restrictedOfferAddress !== offer.id; });
+                                            if (restrictions.length) {
+                                                solutionLinkage = offerInfo.linkage;
+                                            }
+                                            else {
+                                                anyLinkage = offerInfo.linkage;
+                                            }
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, {
+                                hashes: solutionHashes,
+                                linkage: solutionLinkage || anyLinkage,
+                            }];
+                }
+            });
+        });
+    };
+    TIIGenerator.getTRI = function (tii, decryptionKey) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var tiiObj, tri, compression, decompressed, _d, decoded;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        tiiObj = JSON.parse(tii);
+                        tiiObj.tri.key = decryptionKey.toString(tiiObj.tri.encoding);
+                        return [4 /*yield*/, crypto_1.default.decrypt(tiiObj.tri)];
+                    case 1:
+                        tri = _e.sent();
+                        compression = Compression_1.Compression.decode(Buffer.from(tri, tiiObj.tri.encoding));
+                        _d = compression.type;
+                        switch (_d) {
+                            case Compression_1.Compression_TYPE.GZIP: return [3 /*break*/, 2];
+                        }
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, (0, node_gzip_1.ungzip)(compression.data)];
+                    case 3:
+                        decompressed = _e.sent();
+                        return [3 /*break*/, 5];
+                    case 4: throw Error('Unknown compression method');
+                    case 5:
+                        decoded = TRI_1.TRI.decode(decompressed);
+                        if ((_a = decoded.encryption) === null || _a === void 0 ? void 0 : _a.iv) {
+                            decoded.encryption.iv = Buffer.from(decoded.encryption.iv).toString(tiiObj.tri.encoding);
+                        }
+                        if ((_b = decoded.encryption) === null || _b === void 0 ? void 0 : _b.key) {
+                            decoded.encryption.key = Buffer.from(decoded.encryption.key).toString(tiiObj.tri.encoding);
+                        }
+                        if ((_c = decoded.encryption) === null || _c === void 0 ? void 0 : _c.mac) {
+                            decoded.encryption.mac = Buffer.from(decoded.encryption.mac).toString(tiiObj.tri.encoding);
+                        }
+                        return [2 /*return*/, decoded];
+                }
+            });
+        });
+    };
+    TIIGenerator.getUrl = function (tii, decryptionKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, TIIGenerator.getResource(tii, decryptionKey)];
+                    case 1:
+                        res = _a.sent();
+                        return [2 /*return*/, res.url];
+                }
+            });
+        });
+    };
+    TIIGenerator.getResource = function (tii, decryptionKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encryptedResource, resource;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        encryptedResource = JSON.parse(tii).encryptedResource;
+                        encryptedResource.key = decryptionKey.toString(encryptedResource.encoding);
+                        return [4 /*yield*/, crypto_1.default.decrypt(encryptedResource)];
+                    case 1:
+                        resource = _a.sent();
+                        return [2 /*return*/, JSON.parse(resource)];
+                }
+            });
+        });
+    };
+    return TIIGenerator;
+}());
+exports.default = TIIGenerator;

package/build/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const defaultBlockchainUrl = "ws://127.0.0.1:8545";
+export declare const defaultGasLimit = 7000000;
+export declare const defaultGasPrice = "30000000000";
+export declare const defaultGasLimitMultiplier = 1.2;
+export declare const zeroAddress = "0";
+export declare const ONE_DAY: number;
+export declare const BLOCK_SIZE_TO_FETCH_TRANSACTION = 500;

package/build/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLOCK_SIZE_TO_FETCH_TRANSACTION = exports.ONE_DAY = exports.zeroAddress = exports.defaultGasLimitMultiplier = exports.defaultGasPrice = exports.defaultGasLimit = exports.defaultBlockchainUrl = void 0;
+exports.defaultBlockchainUrl = "ws://127.0.0.1:8545";
+exports.defaultGasLimit = 7000000;
+exports.defaultGasPrice = "30000000000";
+exports.defaultGasLimitMultiplier = 1.2;
+exports.zeroAddress = "0";
+exports.ONE_DAY = 24 * 60 * 60;
+exports.BLOCK_SIZE_TO_FETCH_TRANSACTION = 500;