@super-protocol/sdk-js 0.10.1-beta.2 → 0.10.2-beta.0

package/build/models/Order.js

@@ -1,4 +1,15 @@
 "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) {
@@ -411,13 +422,14 @@ var Order = /** @class */ (function () {
     Order.prototype.createSubOrder = function (subOrderInfo, blocking, holdSum, transactionOptions) {
         if (holdSum === void 0) { holdSum = '0'; }
         return __awaiter(this, void 0, void 0, function () {
-            var tupleSubOrder, params;
+            var preparedInfo, tupleSubOrder, params;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         transactionOptions !== null && transactionOptions !== void 0 ? transactionOptions : this.checkInitOrder(transactionOptions);
                         (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
-                        tupleSubOrder = (0, utils_1.objectToTuple)(subOrderInfo, Order_1.OrderInfoStructure);
+                        preparedInfo = __assign(__assign({}, subOrderInfo), { externalId: (0, utils_2.formatBytes32String)(subOrderInfo.externalId) });
+                        tupleSubOrder = (0, utils_1.objectToTuple)(preparedInfo, Order_1.OrderInfoStructure);
                         params = {
                             blockParentOrder: blocking,
                             holdSum: holdSum,
@@ -448,7 +460,8 @@ var Order = /** @class */ (function () {
                         batch = new transactionOptions.web3.BatchRequest();
                         promises = subOrdersInfo.map(function (subOrderInfo) {
                             return new Promise(function (res, rej) {
-                                var tupleSubOrder = (0, utils_1.objectToTuple)(subOrderInfo, Order_1.OrderInfoStructure);
+                                var preparedInfo = __assign(__assign({}, subOrderInfo), { externalId: (0, utils_2.formatBytes32String)(subOrderInfo.externalId) });
+                                var tupleSubOrder = (0, utils_1.objectToTuple)(preparedInfo, Order_1.OrderInfoStructure);
                                 var params = {
                                     blockParentOrder: subOrderInfo.blocking,
                                     holdSum: subOrderInfo.holdSum,

package/build/staticModels/OrdersFactory.d.ts

@@ -36,7 +36,19 @@ declare class OrdersFactory {
      * @param transactionOptions - object what contains alternative action account or gas limit (optional)
      * @returns {Promise<void>} - Does not return id of created order!
      */
-    static createWorkflow(perentOrderInfo: OrderInfo, subOrdersInfo: OrderInfo[], holdDeposit?: string, transactionOptions?: TransactionOptions): Promise<void>;
+    static createWorkflow(parentOrderInfo: OrderInfo, subOrdersInfo: OrderInfo[], holdDeposit?: string, transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * Function for cancel workflow
+     * @param parentOrderId - Parent order id
+     * @returns {Promise<void>} - Does not return id of created order!
+     */
+    static cancelWorkflow(perentOrderId: string, transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * Function for withdraw workflow change
+     * @param parentOrderId - Parent order id
+     * @returns {Promise<void>} - Does not return id of created order!
+     */
+    static withdrawWorkflowChange(parentOrderId: string, transactionOptions?: TransactionOptions): Promise<void>;
     /**
      * Function for refilling order deposit
      * @param orderId - order id

package/build/staticModels/OrdersFactory.js

@@ -1,4 +1,15 @@
 "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) {
@@ -127,13 +138,14 @@ var OrdersFactory = /** @class */ (function () {
         if (holdDeposit === void 0) { holdDeposit = "0"; }
         if (suspended === void 0) { suspended = false; }
         return __awaiter(this, void 0, void 0, function () {
-            var contract, orderInfoArguments;
+            var contract, preparedInfo, orderInfoArguments;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         contract = BlockchainConnector_1.default.getContractInstance(transactionOptions);
                         (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
-                        orderInfoArguments = (0, utils_1.objectToTuple)(orderInfo, Order_1.OrderInfoStructure);
+                        preparedInfo = __assign(__assign({}, orderInfo), { externalId: (0, utils_2.formatBytes32String)(orderInfo.externalId) });
+                        orderInfoArguments = (0, utils_1.objectToTuple)(preparedInfo, Order_1.OrderInfoStructure);
                         return [4 /*yield*/, TxManager_1.default.execute(contract.methods.createOrder, [orderInfoArguments, holdDeposit, suspended], transactionOptions)];
                     case 1:
                         _a.sent();
@@ -176,18 +188,63 @@ var OrdersFactory = /** @class */ (function () {
      * @param transactionOptions - object what contains alternative action account or gas limit (optional)
      * @returns {Promise<void>} - Does not return id of created order!
      */
-    OrdersFactory.createWorkflow = function (perentOrderInfo, subOrdersInfo, holdDeposit, transactionOptions) {
+    OrdersFactory.createWorkflow = function (parentOrderInfo, subOrdersInfo, holdDeposit, transactionOptions) {
         if (holdDeposit === void 0) { holdDeposit = "0"; }
         return __awaiter(this, void 0, void 0, function () {
-            var contract, perentOrderInfoArgs, subOrdersInfoArgs;
+            var contract, preparedInfo, parentOrderInfoArgs, preparedSubOrdersInfo, subOrdersInfoArgs;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        contract = BlockchainConnector_1.default.getContractInstance(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        preparedInfo = __assign(__assign({}, parentOrderInfo), { externalId: (0, utils_2.formatBytes32String)(parentOrderInfo.externalId) });
+                        parentOrderInfoArgs = (0, utils_1.objectToTuple)(preparedInfo, Order_1.OrderInfoStructure);
+                        subOrdersInfo.forEach(function (o) { return (o.externalId = (0, utils_2.formatBytes32String)(o.externalId)); });
+                        preparedSubOrdersInfo = subOrdersInfo.map(function (o) { return (__assign(__assign({}, o), { externalId: (0, utils_2.formatBytes32String)(o.externalId) })); });
+                        subOrdersInfoArgs = (0, utils_1.objectToTuple)(preparedSubOrdersInfo, Order_1.OrderInfoStructureArray);
+                        return [4 /*yield*/, TxManager_1.default.execute(contract.methods.createWorkflow, [parentOrderInfoArgs, holdDeposit, subOrdersInfoArgs], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function for cancel workflow
+     * @param parentOrderId - Parent order id
+     * @returns {Promise<void>} - Does not return id of created order!
+     */
+    OrdersFactory.cancelWorkflow = function (perentOrderId, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var contract;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        contract = BlockchainConnector_1.default.getContractInstance(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        return [4 /*yield*/, TxManager_1.default.execute(contract.methods.cancelWorkflow, [perentOrderId], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function for withdraw workflow change
+     * @param parentOrderId - Parent order id
+     * @returns {Promise<void>} - Does not return id of created order!
+     */
+    OrdersFactory.withdrawWorkflowChange = function (parentOrderId, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var contract;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         contract = BlockchainConnector_1.default.getContractInstance(transactionOptions);
                         (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
-                        perentOrderInfoArgs = (0, utils_1.objectToTuple)(perentOrderInfo, Order_1.OrderInfoStructure);
-                        subOrdersInfoArgs = (0, utils_1.objectToTuple)(subOrdersInfo, Order_1.OrderInfoStructureArray);
-                        return [4 /*yield*/, TxManager_1.default.execute(contract.methods.createWorkflow, [perentOrderInfoArgs, holdDeposit, subOrdersInfoArgs], transactionOptions)];
+                        return [4 /*yield*/, TxManager_1.default.execute(contract.methods.withdrawWorkflowChange, [parentOrderId], transactionOptions)];
                     case 1:
                         _a.sent();
                         return [2 /*return*/];

package/build/types/Order.d.ts

@@ -30,6 +30,7 @@ export declare const OrderInfoStructure: {
         inputOffers: StringConstructor[];
         selectedOffers: StringConstructor[];
     };
+    externalId: StringConstructor;
 };
 export declare const OrderInfoStructureArray: {
     offer: StringConstructor;
@@ -42,6 +43,7 @@ export declare const OrderInfoStructureArray: {
         inputOffers: StringConstructor[];
         selectedOffers: StringConstructor[];
     };
+    externalId: StringConstructor;
 }[];
 export declare type OrderInfo = {
     offer: string;

package/build/types/Order.js

@@ -27,6 +27,7 @@ exports.OrderInfoStructure = {
     encryptedArgs: String,
     status: OrderStatus,
     args: exports.OrderArgsStructure,
+    externalId: String,
 };
 // Array of order info structures
 exports.OrderInfoStructureArray = [exports.OrderInfoStructure];

package/build/utils/NonceTracker.d.ts

@@ -6,6 +6,7 @@ declare class NonceTracker {
     constructor(web3: Web3);
     initAccount(address: string): Promise<void>;
     isManaged(address: string): boolean;
+    reinitialize(): Promise<void>;
     private checkAccount;
     getNonce(address: string): number;
     consumeNonce(address: string): number;

package/build/utils/NonceTracker.js

@@ -71,6 +71,32 @@ var NonceTracker = /** @class */ (function () {
     NonceTracker.prototype.isManaged = function (address) {
         return address in this.store;
     };
+    NonceTracker.prototype.reinitialize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(Object.keys(this.store).map(function (address) { return __awaiter(_this, void 0, void 0, function () {
+                            var txCount;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.web3.eth.getTransactionCount(address)];
+                                    case 1:
+                                        txCount = _a.sent();
+                                        NonceTracker.logger.trace("Account ".concat(address, " has been reinitialized with nonce: ").concat(txCount));
+                                        this.store[address] = txCount;
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                    case 1:
+                        _a.sent();
+                        NonceTracker.logger.trace("All accounts has been reinitialized");
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     NonceTracker.prototype.checkAccount = function (address) {
         if (this.isManaged(address)) {
             return;

package/build/utils/TxManager.d.ts

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

package/build/utils/TxManager.js

@@ -92,39 +92,42 @@ var TxManager = /** @class */ (function () {
     };
     TxManager.publishTransaction = function (txData, transactionOptions, transactionCall) {
         return __awaiter(this, void 0, void 0, function () {
-            var web3, options, estimatedGas, e_1, signingKey, signed;
+            var web3, options, estimatedGas, e_1, signingKey, signed, data, data, e_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         this.checkIfInitialized();
                         (0, utils_1.checkIfInitialized)();
                         (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        return [4 /*yield*/, this.onStartPublishing()];
+                    case 1:
+                        _a.sent();
                         web3 = (transactionOptions === null || transactionOptions === void 0 ? void 0 : transactionOptions.web3) || this.web3;
                         return [4 /*yield*/, (0, utils_1.createTransactionOptions)(__assign({}, transactionOptions))];
-                    case 1:
+                    case 2:
                         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];
+                        if (!transactionCall) return [3 /*break*/, 7];
                         estimatedGas = void 0;
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, transactionCall.estimateGas(txData)];
+                        _a.label = 3;
                     case 3:
-                        estimatedGas = _a.sent();
-                        return [3 /*break*/, 5];
+                        _a.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, transactionCall.estimateGas(txData)];
                     case 4:
+                        estimatedGas = _a.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
                         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;
+                        return [3 /*break*/, 6];
                     case 6:
+                        txData.gas = Math.ceil(estimatedGas * store_1.default.gasLimitMultiplier);
+                        _a.label = 7;
+                    case 7:
                         // TODO: Consider a better way to organize different strategies for publishing transactions.
                         if (!(0, utils_1.checkForUsingExternalTxManager)(transactionOptions)) {
                             if (this.nonceTracker.isManaged(options.from)) {
@@ -132,9 +135,12 @@ var TxManager = /** @class */ (function () {
                             }
                         }
                         signingKey = store_1.default.keys[options.from];
-                        if (!signingKey) return [3 /*break*/, 8];
+                        _a.label = 8;
+                    case 8:
+                        _a.trys.push([8, 14, , 16]);
+                        if (!signingKey) return [3 /*break*/, 11];
                         return [4 /*yield*/, web3.eth.accounts.signTransaction(txData, signingKey)];
-                    case 7:
+                    case 9:
                         signed = _a.sent();
                         if (!signed.rawTransaction) {
                             throw new Error("Failed to sign transaction");
@@ -143,17 +149,98 @@ var TxManager = /** @class */ (function () {
                             txHash: signed.transactionHash,
                             txData: lodash_1.default.omit(txData, ["data"]),
                         }, "Publishing signed transaction");
-                        return [2 /*return*/, web3.eth.sendSignedTransaction(signed.rawTransaction)];
-                    case 8:
+                        return [4 /*yield*/, web3.eth.sendSignedTransaction(signed.rawTransaction)];
+                    case 10:
+                        data = _a.sent();
+                        this.onFinishPublishing();
+                        return [2 /*return*/, data];
+                    case 11:
                         TxManager.logger.debug({
                             txData: lodash_1.default.omit(txData, ["data"]),
                         }, "Publishing unsigned transaction");
-                        return [2 /*return*/, web3.eth.sendTransaction(txData)];
+                        return [4 /*yield*/, web3.eth.sendTransaction(txData)];
+                    case 12:
+                        data = _a.sent();
+                        this.onFinishPublishing();
+                        return [2 /*return*/, data];
+                    case 13: return [3 /*break*/, 16];
+                    case 14:
+                        e_2 = _a.sent();
+                        TxManager.logger.error(e_2, "Error during transaction execution");
+                        return [4 /*yield*/, this.onError()];
+                    case 15:
+                        _a.sent();
+                        throw e_2;
+                    case 16: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TxManager.onStartPublishing = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.countOfPendingTransactions++;
+                        if (!this.transactionsOnHold)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.waitForPendingTransactions()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TxManager.onError = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.countOfPendingTransactions--;
+                        if (this.countOfPendingTransactions === 0)
+                            return [2 /*return*/];
+                        this.transactionsOnHold = [];
+                        return [4 /*yield*/, this.waitForPendingTransactions()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TxManager.onFinishPublishing = function () {
+        var _this = this;
+        this.countOfPendingTransactions--;
+        if (this.countOfPendingTransactions === 0 && this.transactionsOnHold) {
+            this.nonceTracker.reinitialize().then(function () {
+                var _a;
+                (_a = _this.transactionsOnHold) === null || _a === void 0 ? void 0 : _a.forEach(function (callback) { return callback(); });
+                _this.transactionsOnHold = undefined;
+            });
+        }
+    };
+    TxManager.waitForPendingTransactions = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, new Promise(function (resolve) {
+                            if (!_this.transactionsOnHold)
+                                return resolve();
+                            _this.transactionsOnHold.push(function () {
+                                resolve();
+                            });
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
                 }
             });
         });
     };
     TxManager.logger = logger_1.default.child({ className: "TxManager" });
+    TxManager.countOfPendingTransactions = 0;
     return TxManager;
 }());
 exports.default = TxManager;

package/package.json

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