@super-protocol/sdk-js 0.6.0

package/build/types/Web3.d.ts

@@ -0,0 +1,26 @@
+import Web3 from "web3";
+export declare type ContractEvent = {
+    returnValues: {
+        [key: string]: unknown;
+    };
+};
+export declare type TransactionOptions = {
+    from?: string;
+    gas?: number;
+    gasPrice?: string;
+    web3?: Web3;
+};
+export declare type Transaction = {
+    hash: string;
+    nonce: number;
+    blockHash: string | null;
+    blockNumber: number | null;
+    transactionIndex: number | null;
+    from: string;
+    to: string | null;
+    value: string;
+    gasPrice: string;
+    gas: number;
+    input: string;
+    timestamp: number;
+};

package/build/types/Web3.js

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

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

@@ -0,0 +1,8 @@
+import { Transaction } from "../Web3";
+declare type BlockchainTransaction = {
+    transactionsByAddress: {
+        [p: string]: Transaction[];
+    };
+    lastBlock: number;
+};
+export default BlockchainTransaction;

package/build/types/blockchainConnector/StorageAccess.js

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

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

@@ -0,0 +1,6 @@
+import { StorageType } from "@super-protocol/dto-js";
+declare type StorageAccess = {
+    storageType: StorageType;
+    credentials: any;
+};
+export default StorageAccess;

package/build/types/storage/StorageAccess.js

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

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

@@ -0,0 +1,5 @@
+import StorageAccess from "./StorageAccess";
+declare type StorageFileAccess = StorageAccess & {
+    filepath: string;
+};
+export default StorageFileAccess;

package/build/types/storage/StorageFileAccess.js

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

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

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

package/build/types/storage/StorageObject.js

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

package/build/utils/NonceTracker.d.ts

@@ -0,0 +1,12 @@
+import Web3 from "web3";
+declare class NonceTracker {
+    private web3;
+    private store;
+    constructor(web3: Web3);
+    initAccount(address: string): Promise<void>;
+    isManaged(address: string): boolean;
+    private checkAccount;
+    getNonce(address: string): number;
+    consumeNonce(address: string): number;
+}
+export default NonceTracker;

package/build/utils/NonceTracker.js

@@ -0,0 +1,84 @@
+"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 NonceTracker = /** @class */ (function () {
+    function NonceTracker(web3) {
+        this.web3 = web3;
+        this.store = {};
+    }
+    NonceTracker.prototype.initAccount = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txCount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (address in this.store) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.web3.eth.getTransactionCount(address)];
+                    case 1:
+                        txCount = _a.sent();
+                        if (address in this.store) {
+                            return [2 /*return*/];
+                        }
+                        this.store[address] = txCount;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NonceTracker.prototype.isManaged = function (address) {
+        return address in this.store;
+    };
+    NonceTracker.prototype.checkAccount = function (address) {
+        if (this.isManaged(address)) {
+            return;
+        }
+        throw Error("".concat(address, " account is not initialized. You must call initAccount before using it."));
+    };
+    NonceTracker.prototype.getNonce = function (address) {
+        this.checkAccount(address);
+        return this.store[address];
+    };
+    NonceTracker.prototype.consumeNonce = function (address) {
+        this.checkAccount(address);
+        return this.store[address]++;
+    };
+    return NonceTracker;
+}());
+exports.default = NonceTracker;

package/build/utils/TxManager.d.ts

@@ -0,0 +1,21 @@
+import { TransactionReceipt } from "web3-core";
+import { ContractSendMethod } from "web3-eth-contract";
+import { TransactionOptions } from "../types/Web3";
+import Web3 from "web3";
+declare type ArgumentsType = any | any[];
+declare type MethodReturnType = ContractSendMethod & {
+    _parent: {
+        _address: string;
+    };
+};
+declare class TxManager {
+    private static web3;
+    private static nonceTracker;
+    private static logger;
+    static init(web3: Web3): void;
+    private static checkIfInitialized;
+    static initAccount(address: string): Promise<void>;
+    static execute(method: (...args: ArgumentsType) => MethodReturnType, args: ArgumentsType, transactionOptions?: TransactionOptions, to?: string): Promise<TransactionReceipt>;
+    static publishTransaction(txData: Record<string, any>, transactionOptions?: TransactionOptions, transactionCall?: MethodReturnType): Promise<TransactionReceipt>;
+}
+export default TxManager;

package/build/utils/TxManager.js

@@ -0,0 +1,159 @@
+"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 NonceTracker_1 = __importDefault(require("./NonceTracker"));
+var logger_1 = __importDefault(require("../logger"));
+var store_1 = __importDefault(require("../store"));
+var utils_1 = require("../utils");
+var Superpro_1 = __importDefault(require("../staticModels/Superpro"));
+var constants_1 = require("../constants");
+var lodash_1 = __importDefault(require("lodash"));
+var TxManager = /** @class */ (function () {
+    function TxManager() {
+    }
+    TxManager.init = function (web3) {
+        this.web3 = web3;
+        this.nonceTracker = new NonceTracker_1.default(web3);
+    };
+    TxManager.checkIfInitialized = function () {
+        if (!this.web3) {
+            throw Error("TxManager should be initialized before using.");
+        }
+    };
+    TxManager.initAccount = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.nonceTracker.initAccount(address)];
+            });
+        });
+    };
+    TxManager.execute = function (method, args, transactionOptions, to) {
+        if (to === void 0) { to = Superpro_1.default.address; }
+        return __awaiter(this, void 0, void 0, function () {
+            var transaction, txData;
+            return __generator(this, function (_a) {
+                transaction = method.apply(void 0, args);
+                txData = {
+                    to: to,
+                    data: transaction.encodeABI(),
+                };
+                return [2 /*return*/, TxManager.publishTransaction(txData, transactionOptions, transaction)];
+            });
+        });
+    };
+    TxManager.publishTransaction = function (txData, transactionOptions, transactionCall) {
+        return __awaiter(this, void 0, void 0, function () {
+            var web3, options, estimatedGas, e_1, signingKey, signed;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.checkIfInitialized();
+                        (0, utils_1.checkIfInitialized)();
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        web3 = (transactionOptions === null || transactionOptions === void 0 ? void 0 : transactionOptions.web3) || this.web3;
+                        return [4 /*yield*/, (0, utils_1.createTransactionOptions)(__assign({}, transactionOptions))];
+                    case 1:
+                        options = _a.sent();
+                        if (!options.from) {
+                            throw Error("From account is undefined. You should pass it to transactionOptions or init action account.");
+                        }
+                        txData = __assign(__assign({}, options), txData);
+                        if (!transactionCall) return [3 /*break*/, 6];
+                        estimatedGas = void 0;
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, transactionCall.estimateGas(txData)];
+                    case 3:
+                        estimatedGas = _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        e_1 = _a.sent();
+                        TxManager.logger.debug({ error: e_1 }, "Fail to calculate estimated gas");
+                        estimatedGas = constants_1.defaultGasLimit;
+                        return [3 /*break*/, 5];
+                    case 5:
+                        txData.gas = Math.ceil(estimatedGas * store_1.default.gasLimitMultiplier);
+                        _a.label = 6;
+                    case 6:
+                        // TODO: Consider a better way to organize different strategies for publishing transactions.
+                        if (!(0, utils_1.checkForUsingExternalTxManager)(transactionOptions)) {
+                            if (this.nonceTracker.isManaged(options.from)) {
+                                txData.nonce = this.nonceTracker.consumeNonce(options.from);
+                            }
+                        }
+                        signingKey = store_1.default.keys[options.from];
+                        if (!signingKey) return [3 /*break*/, 8];
+                        return [4 /*yield*/, web3.eth.accounts.signTransaction(txData, signingKey)];
+                    case 7:
+                        signed = _a.sent();
+                        if (!signed.rawTransaction) {
+                            throw new Error("Failed to sign transaction");
+                        }
+                        TxManager.logger.debug({
+                            txHash: signed.transactionHash,
+                            txData: lodash_1.default.omit(txData, ["data"]),
+                        }, "Publishing signed transaction");
+                        return [2 /*return*/, web3.eth.sendSignedTransaction(signed.rawTransaction)];
+                    case 8:
+                        TxManager.logger.debug({
+                            txData: lodash_1.default.omit(txData, ["data"]),
+                        }, "Publishing unsigned transaction");
+                        return [2 /*return*/, web3.eth.sendTransaction(txData)];
+                }
+            });
+        });
+    };
+    TxManager.logger = logger_1.default.child({ className: "TxManager" });
+    return TxManager;
+}());
+exports.default = TxManager;

package/build/utils.d.ts

@@ -0,0 +1,38 @@
+import { TransactionOptions } from "./types/Web3";
+import Web3 from "web3";
+/**
+ * Function for checking if BlockchainConnector initialized (required for get and set methods)
+ * Used in all models constructors
+ */
+export declare const checkIfInitialized: () => void;
+/**
+ * Function for checking if provider action account initialized (required for set methods)
+ * Used in all set methods
+ */
+export declare const checkIfActionAccountInitialized: (transactionOptions?: TransactionOptions) => void;
+/**
+ * Function for checking if current configuration supposed to use external transaction manager like MetaMask and etc.
+ */
+export declare const checkForUsingExternalTxManager: (transactionOptions?: TransactionOptions) => boolean;
+/**
+ * Updates gas price determined by the last few blocks median
+ */
+export declare const getGasPrice: (web3: Web3) => Promise<string>;
+/**
+ * Merge transaction options from arguments and from store
+ * Used in all set methods
+ */
+export declare const createTransactionOptions: (options?: TransactionOptions) => Promise<TransactionOptions>;
+export declare const isNodeJS: () => boolean;
+declare type FormatFunctions = {
+    $obj?: (value: unknown) => unknown;
+    $tuple?: (value: unknown) => unknown;
+};
+declare type FormatItem = Format | Object | ((value: unknown) => unknown) | null | FormatFunctions;
+declare type Format = FormatItem[] | {
+    [key: string]: FormatItem;
+};
+export declare const tupleToObject: <T>(data: unknown[], format: Format) => T;
+export declare const objectToTuple: (data: unknown, format: Format) => unknown[];
+export declare const getTimestamp: () => Promise<string | number>;
+export {};

package/build/utils.js

@@ -0,0 +1,195 @@
+"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.getTimestamp = exports.objectToTuple = exports.tupleToObject = exports.isNodeJS = exports.createTransactionOptions = exports.getGasPrice = exports.checkForUsingExternalTxManager = exports.checkIfActionAccountInitialized = exports.checkIfInitialized = void 0;
+var store_1 = __importDefault(require("./store"));
+var lodash_1 = require("lodash");
+/**
+ * Function for checking if BlockchainConnector initialized (required for get and set methods)
+ * Used in all models constructors
+ */
+var checkIfInitialized = function () {
+    if (!store_1.default.isInitialized)
+        throw new Error("BlockchainConnector is not initialized, needs to run 'await BlockchainConnector.init(CONFIG)' first");
+};
+exports.checkIfInitialized = checkIfInitialized;
+/**
+ * Function for checking if provider action account initialized (required for set methods)
+ * Used in all set methods
+ */
+var checkIfActionAccountInitialized = function (transactionOptions) {
+    if (!store_1.default.actionAccount && !(transactionOptions === null || transactionOptions === void 0 ? void 0 : transactionOptions.web3))
+        throw new Error("Provider action account is not initialized, needs to run 'BlockchainConnector.initActionAccount(SECRET_KEY)' first");
+};
+exports.checkIfActionAccountInitialized = checkIfActionAccountInitialized;
+/**
+ * Function for checking if current configuration supposed to use external transaction manager like MetaMask and etc.
+ */
+var checkForUsingExternalTxManager = function (transactionOptions) {
+    // TODO: Agree on more proper way of signaling, that we use an external transaction manager, than just passing a web3 instance.
+    return !!(transactionOptions === null || transactionOptions === void 0 ? void 0 : transactionOptions.web3);
+};
+exports.checkForUsingExternalTxManager = checkForUsingExternalTxManager;
+/**
+ * Updates gas price determined by the last few blocks median
+ */
+var getGasPrice = function (web3) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, web3.eth.getGasPrice()];
+    });
+}); };
+exports.getGasPrice = getGasPrice;
+/**
+ * Merge transaction options from arguments and from store
+ * Used in all set methods
+ */
+var createTransactionOptions = function (options) { return __awaiter(void 0, void 0, void 0, function () {
+    var web3, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                if (!options)
+                    options = {};
+                if (!options.from)
+                    options.from = store_1.default.actionAccount;
+                if (!options.gas)
+                    options.gas = store_1.default.gasLimit;
+                if (!!options.gasPrice) return [3 /*break*/, 3];
+                if (!store_1.default.gasPrice) return [3 /*break*/, 1];
+                options.gasPrice = store_1.default.gasPrice;
+                return [3 /*break*/, 3];
+            case 1:
+                web3 = options.web3 || store_1.default.web3;
+                if (!web3) {
+                    throw Error("web3 is undefined, define it in transaction options or initialize BlockchainConnector with web3 instance.");
+                }
+                _a = options;
+                return [4 /*yield*/, (0, exports.getGasPrice)(web3)];
+            case 2:
+                _a.gasPrice = _b.sent();
+                _b.label = 3;
+            case 3:
+                delete options.web3;
+                return [2 /*return*/, options];
+        }
+    });
+}); };
+exports.createTransactionOptions = createTransactionOptions;
+var isNodeJS = function () {
+    // @ts-ignore
+    return typeof window === "undefined";
+};
+exports.isNodeJS = isNodeJS;
+var tupleToObject = function (data, format) {
+    var processItem = function (dataItem, formatItem) {
+        if (formatItem === null || formatItem === void 0 ? void 0 : formatItem.$obj) {
+            return formatItem.$obj(dataItem);
+        }
+        else if (typeof formatItem === "function") {
+            return formatItem(dataItem);
+        }
+        else if (typeof formatItem === "object" && typeof dataItem === "object") {
+            return (0, exports.tupleToObject)(dataItem, formatItem);
+        }
+        else {
+            return dataItem;
+        }
+    };
+    if ((0, lodash_1.isArray)(format)) {
+        var result = data.map(function (dataItem, index) {
+            var formatItem = index < format.length ? format[index] : format[format.length - 1];
+            return processItem(dataItem, formatItem);
+        });
+        return result;
+    }
+    else {
+        var result_1 = {};
+        Object.keys(format).forEach(function (key, index) {
+            var formatItem = format[key];
+            var dataItem = data[index];
+            result_1[key] = processItem(dataItem, formatItem);
+        });
+        return result_1;
+    }
+};
+exports.tupleToObject = tupleToObject;
+var objectToTuple = function (data, format) {
+    var processItem = function (dataItem, formatItem) {
+        if (formatItem === null || formatItem === void 0 ? void 0 : formatItem.$tuple) {
+            return formatItem.$tuple(dataItem);
+        }
+        else if (typeof formatItem === "object" && typeof dataItem === "object") {
+            return (0, exports.objectToTuple)(dataItem, formatItem);
+        }
+        else {
+            return dataItem;
+        }
+    };
+    if ((0, lodash_1.isArray)(format)) {
+        return data.map(function (dataItem, index) {
+            var formatItem = index < format.length ? format[index] : format[format.length - 1];
+            return processItem(dataItem, formatItem);
+        });
+    }
+    else {
+        return Object.keys(format).map(function (key) {
+            var dataItem = data[key];
+            var formatItem = format[key];
+            return processItem(dataItem, formatItem);
+        });
+    }
+};
+exports.objectToTuple = objectToTuple;
+var getTimestamp = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var endBlockIndex, block;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, store_1.default.web3.eth.getBlockNumber()];
+            case 1:
+                endBlockIndex = _a.sent();
+                return [4 /*yield*/, store_1.default.web3.eth.getBlock(endBlockIndex, true)];
+            case 2:
+                block = _a.sent();
+                return [2 /*return*/, block.timestamp];
+        }
+    });
+}); };
+exports.getTimestamp = getTimestamp;

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@super-protocol/sdk-js",
+  "version": "0.6.0",
+  "main": "build/index.js",
+  "license": "MIT",
+  "files": [
+    "build/**/*"
+  ],
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk node_modules/.bin/jest -i",
+    "prettier": "prettier --write ./src/**/* ./test/**/*",
+    "lint": "eslint --ext .ts src",
+    "lint:fix": "eslint --ext .ts src --fix",
+    "build": "rm -rf ./build && tsc",
+    "prepare": "npm run build",
+    "docs": "typedoc src/index.ts --excludePrivate --plugin typedoc-plugin-markdown --out ./auto-docs",
+    "docs-cleanup": "rm -rf auto-docs",
+    "bump": "npm version prerelease --preid=beta && git push && git push --tags",
+    "patch:beta": "npm version prepatch --preid=beta && git push && git push --tags",
+    "minor:beta": "npm version preminor --preid=beta && git push && git push --tags",
+    "major:beta": "npm version premajor --preid=beta && git push && git push --tags",
+    "patch": "npm version patch && git push && git push --tags",
+    "minor": "npm version minor && git push && git push --tags",
+    "major": "npm version major && git push && git push --tags",
+    "dto:update": "npm run dto:clean && npm run dto:generate",
+    "dto:clean": "rm -rf ./src/proto/*",
+    "dto:generate": "cd ./dto/src && protoc --plugin=../../node_modules/.bin/protoc-gen-ts_proto --ts_proto_opt=esModuleInterop=true --ts_proto_opt=unrecognizedEnum=false --ts_proto_out=../../src/proto ./*"
+  },
+  "devDependencies": {
+    "@types/eccrypto": "^1.1.3",
+    "@types/jest": "^27.0.3",
+    "@types/lodash": "^4.14.176",
+    "@types/node": "^17.0.0",
+    "@types/node-gzip": "^1.1.0",
+    "@typescript-eslint/eslint-plugin": "^5.8.0",
+    "@typescript-eslint/parser": "^5.8.0",
+    "eslint": "^8.5.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-tsdoc": "^0.2.14",
+    "jest": "^27.3.1",
+    "pandoc-bin": "^0.2.0",
+    "prettier": "^2.4.1",
+    "ts-jest": "^27.0.7",
+    "ts-proto": "^1.110.4",
+    "typedoc": "^0.22.11",
+    "typedoc-plugin-markdown": "^3.11.12",
+    "typescript": "^4.4.4",
+    "ts-protoc-gen": "^0.15.0"
+  },
+  "dependencies": {
+    "@super-protocol/dto-js": "0.0.13",
+    "@super-protocol/tee-lib": "^0.1.2",
+    "@super-protocol/uplink-nodejs": "1.2.12",
+    "eccrypto": "^1.1.6",
+    "ethers": "^5.5.3",
+    "hybrid-crypto-js": "^0.2.4",
+    "lodash": "^4.17.21",
+    "node-gzip": "^1.1.2",
+    "pino": "^7.2.0",
+    "protobufjs": "^6.11.2",
+    "web3": "^1.7.1"
+  },
+  "repository": "git://github.com/Super-Protocol/sdk-js.git"
+}