@super-protocol/sdk-js 0.6.0

package/build/models/Order.js

@@ -0,0 +1,540 @@
+"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 });
+var Order_1 = require("../types/Order");
+var logger_1 = __importDefault(require("../logger"));
+var Orders_json_1 = __importDefault(require("../contracts/Orders.json"));
+var store_1 = __importDefault(require("../store"));
+var utils_1 = require("../utils");
+var Origins_1 = require("../types/Origins");
+var utils_2 = require("ethers/lib/utils");
+var Superpro_1 = __importDefault(require("../staticModels/Superpro"));
+var TxManager_1 = __importDefault(require("../utils/TxManager"));
+var Order = /** @class */ (function () {
+    function Order(orderId) {
+        (0, utils_1.checkIfInitialized)();
+        this.id = orderId;
+        if (!Order.contract) {
+            Order.contract = new store_1.default.web3.eth.Contract(Orders_json_1.default.abi, Superpro_1.default.address);
+        }
+        this.logger = logger_1.default.child({ className: "Order", orderId: this.id });
+    }
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    Order.prototype.checkInitOrder = function (transactionOptions) {
+        if (transactionOptions === null || transactionOptions === void 0 ? void 0 : transactionOptions.web3) {
+            (0, utils_1.checkIfInitialized)();
+            return new transactionOptions.web3.eth.Contract(Orders_json_1.default.abi, Superpro_1.default.address);
+        }
+    };
+    /**
+     * Check if order exist
+     */
+    Order.prototype.isExist = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Order.contract.methods.isOrderValid(this.id).call()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Function for fetching order info from blockchain
+     */
+    Order.prototype.getOrderInfo = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var orderInfoParams;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Order.contract.methods.getOrder(this.id).call()];
+                    case 1:
+                        orderInfoParams = _a.sent();
+                        return [2 /*return*/, (this.orderInfo = (0, utils_1.tupleToObject)(orderInfoParams[1], Order_1.OrderInfoStructure))];
+                }
+            });
+        });
+    };
+    Order.prototype.getConsumer = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var orderInfoParams;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Order.contract.methods.getOrder(this.id).call()];
+                    case 1:
+                        orderInfoParams = _a.sent();
+                        this.consumer = orderInfoParams[0];
+                        return [2 /*return*/, this.consumer];
+                }
+            });
+        });
+    };
+    /**
+     * Function for fetching order result from blockchain
+     */
+    Order.prototype.getOrderResult = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var orderInfoParams, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Order.contract.methods.getOrder(this.id).call()];
+                    case 1:
+                        orderInfoParams = _a.sent();
+                        result = ['', '', orderInfoParams[2][1]];
+                        if (orderInfoParams[1][4] === Order_1.OrderStatus.Error)
+                            result[1] = orderInfoParams[2][0];
+                        else
+                            result[0] = orderInfoParams[2][0];
+                        return [2 /*return*/, this.orderResult = (0, utils_1.tupleToObject)(result, Order_1.OrderResultStructure)];
+                }
+            });
+        });
+    };
+    /**
+     * Function for fetching sub orders from blockchain
+     */
+    Order.prototype.getSubOrders = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this;
+                        return [4 /*yield*/, Order.contract.methods.getOrderSubOrders(this.id).call()];
+                    case 1:
+                        _a.subOrders = _b.sent();
+                        return [2 /*return*/, this.subOrders];
+                }
+            });
+        });
+    };
+    /**
+     * Function for fetching parent order from blockchain
+     */
+    Order.prototype.getParentOrder = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this;
+                        return [4 /*yield*/, Order.contract.methods.getOrderParentOrder(this.id).call()];
+                    case 1:
+                        _a.parentOrder = _b.sent();
+                        return [2 /*return*/, this.parentOrder];
+                }
+            });
+        });
+    };
+    /**
+     * Function for fetching order deposit spent from blockchain
+     */
+    Order.prototype.getDepositSpent = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Order.contract.methods.getDepositSpent(this.id).call()];
+            });
+        });
+    };
+    /**
+     * Fetch new Origins (createdDate, createdBy, modifiedDate and modifiedBy)
+     */
+    Order.prototype.getOrigins = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var origins;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Order.contract.methods.getOrderOrigins(this.id).call()];
+                    case 1:
+                        origins = _a.sent();
+                        // Converts blockchain array into object
+                        origins = (0, utils_1.tupleToObject)(origins, Origins_1.OriginsStructure);
+                        // Convert blockchain time seconds to js time milliseconds
+                        origins.createdDate = +origins.createdDate * 1000;
+                        origins.modifiedDate = +origins.modifiedDate * 1000;
+                        return [2 /*return*/, (this.origins = origins)];
+                }
+            });
+        });
+    };
+    /**
+     * Function for fetching parent order from blockchain
+     */
+    Order.prototype.getAwaitingPayment = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Order.contract.methods.getAwaitingPayment(this.id).call()];
+            });
+        });
+    };
+    /**
+     * Function for fetching start of processing date
+     */
+    Order.prototype.getStartDate = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Order.contract.methods.getStartDate(this.id).call()];
+            });
+        });
+    };
+    /**
+     * Function for fetching parent order from blockchain
+     */
+    Order.prototype.setAwaitingPayment = function (value, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        transactionOptions !== null && transactionOptions !== void 0 ? transactionOptions : this.checkInitOrder(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        return [4 /*yield*/, TxManager_1.default.execute(Order.contract.methods.setAwaitingPayment, [this.id, value], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Updates order price
+     */
+    Order.prototype.updateOrderPrice = function (price, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        transactionOptions !== null && transactionOptions !== void 0 ? transactionOptions : this.checkInitOrder(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        return [4 /*yield*/, TxManager_1.default.execute(Order.contract.methods.updateOrderPrice, [this.id, price], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Sets deposit spent
+     */
+    Order.prototype.setDepositSpent = function (value, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        transactionOptions !== null && transactionOptions !== void 0 ? transactionOptions : this.checkInitOrder(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        return [4 /*yield*/, TxManager_1.default.execute(Order.contract.methods.setDepositSpent, [this.id, value], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function for updating status of contract
+     */
+    Order.prototype.updateStatus = function (status, price, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        transactionOptions !== null && transactionOptions !== void 0 ? transactionOptions : this.checkInitOrder(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        if (!(status === Order_1.OrderStatus.Processing)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, TxManager_1.default.execute(Order.contract.methods.processOrder, [this.id], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (this.orderInfo)
+                            this.orderInfo.status = status;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function for updating status of contract
+     */
+    Order.prototype.cancelOrder = function (transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        transactionOptions !== null && transactionOptions !== void 0 ? transactionOptions : this.checkInitOrder(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        return [4 /*yield*/, TxManager_1.default.execute(Order.contract.methods.cancelOrder, [this.id], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Starts suspended order
+     */
+    Order.prototype.start = function (transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        transactionOptions !== null && transactionOptions !== void 0 ? transactionOptions : this.checkInitOrder(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        return [4 /*yield*/, TxManager_1.default.execute(Order.contract.methods.startOrder, [this.id], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Updates order result
+     */
+    Order.prototype.updateOrderResult = function (encryptedResult, transactionOptions) {
+        if (encryptedResult === void 0) { encryptedResult = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        transactionOptions !== null && transactionOptions !== void 0 ? transactionOptions : this.checkInitOrder(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        return [4 /*yield*/, TxManager_1.default.execute(Order.contract.methods.updateOrderResult, [this.id, encryptedResult], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Completes order
+     */
+    Order.prototype.complete = function (status, encryptedResult, encryptedError, // for SDK compatibility
+    transactionOptions) {
+        if (encryptedResult === void 0) { encryptedResult = ""; }
+        if (encryptedError === void 0) { encryptedError = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        transactionOptions !== null && transactionOptions !== void 0 ? transactionOptions : this.checkInitOrder(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        return [4 /*yield*/, TxManager_1.default.execute(Order.contract.methods.completeOrder, [this.id, status, status === Order_1.OrderStatus.Error ? encryptedError : encryptedResult], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function for creating sub orders for current order
+     * @param subOrderInfo - order info for new subOrder
+     * @param blocking - is sub order blocking
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns {Promise<void>} - Does not return address of created contract!
+     */
+    Order.prototype.createSubOrder = function (subOrderInfo, blocking, externalId, holdSum, transactionOptions) {
+        if (externalId === void 0) { externalId = "default"; }
+        if (holdSum === void 0) { holdSum = '0'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var tupleSubOrder, formattedExternalId, 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);
+                        formattedExternalId = (0, utils_2.formatBytes32String)(externalId);
+                        params = {
+                            blockParentOrder: blocking,
+                            externalId: formattedExternalId,
+                            holdSum: holdSum,
+                        };
+                        return [4 /*yield*/, TxManager_1.default.execute(Order.contract.methods.createSubOrder, [this.id, tupleSubOrder, params], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function for creating pack of sub orders (wokflow) for current order
+     * @param {Array<subOrderInfo>} - orders info for new subOrders
+     * @param transactionOptions - object what contains action account and web3 instance
+     * @returns {Promise<string[]>} - tx hashes
+     */
+    Order.prototype.createSubOrders = function (subOrdersInfo, transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var batch, promises, txs;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.checkInitOrder(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        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 formattedExternalId = (0, utils_2.formatBytes32String)(subOrderInfo.externalId);
+                                var params = {
+                                    blockParentOrder: subOrderInfo.blocking,
+                                    externalId: formattedExternalId,
+                                    holdSum: subOrderInfo.holdSum,
+                                };
+                                var request = Order.contract.methods.createSubOrder(_this.id, tupleSubOrder, params).send.request({
+                                    from: transactionOptions.from,
+                                    gasPrice: store_1.default.gasPrice,
+                                    gas: store_1.default.gasLimit,
+                                }, function (err, data) {
+                                    if (data)
+                                        res(data);
+                                    if (err)
+                                        rej(err);
+                                });
+                                batch.add(request);
+                            });
+                        });
+                        batch.execute();
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 1:
+                        txs = _a.sent();
+                        return [2 /*return*/, txs.reduce(function (a, b) { return a.concat(b); }, [])];
+                }
+            });
+        });
+    };
+    Order.prototype.getSubOrder = function (consumer, externalId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var filter, foundIds, notFound, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        filter = {
+                            consumer: consumer,
+                            externalId: (0, utils_2.formatBytes32String)(externalId),
+                        };
+                        return [4 /*yield*/, Order.contract.getPastEvents("SubOrderCreated", { filter: filter })];
+                    case 1:
+                        foundIds = _a.sent();
+                        notFound = { consumer: consumer, externalId: externalId, subOfferId: '-1', subOrderId: '-1', parentOrderId: '-1' };
+                        response = foundIds.length > 0 ? foundIds[0].returnValues : notFound;
+                        return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    /**
+     * Function for withdrawing profit from order
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    Order.prototype.withdrawProfit = function (transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        transactionOptions !== null && transactionOptions !== void 0 ? transactionOptions : this.checkInitOrder(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        return [4 /*yield*/, TxManager_1.default.execute(Order.contract.methods.withdrawProfit, [this.id], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function for withdrawing change from order
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    Order.prototype.withdrawChange = function (transactionOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        transactionOptions !== null && transactionOptions !== void 0 ? transactionOptions : this.checkInitOrder(transactionOptions);
+                        (0, utils_1.checkIfActionAccountInitialized)(transactionOptions);
+                        return [4 /*yield*/, TxManager_1.default.execute(Order.contract.methods.withdrawChange, [this.id], transactionOptions)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Function for adding event listeners to contract events
+     * @param callback - function for processing each order related with event
+     * @return unsubscribe - function unsubscribing from event
+     */
+    Order.prototype.onOrderStatusUpdated = function (callback) {
+        var _this = this;
+        var logger = this.logger.child({ method: "onOrderStatusUpdated" });
+        var subscription = Order.contract.events
+            .OrderStatusUpdated()
+            .on("data", function (event) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (event.returnValues.orderId != this.id) {
+                    return [2 /*return*/];
+                }
+                if (this.orderInfo)
+                    this.orderInfo.status = event.returnValues.status;
+                callback(event.returnValues.status);
+                return [2 /*return*/];
+            });
+        }); })
+            .on("error", function (error, receipt) {
+            if (receipt)
+                return; // Used to avoid logging of transaction rejected
+            logger.warn(error);
+        });
+        return function () { return subscription.unsubscribe(); };
+    };
+    return Order;
+}());
+exports.default = Order;

package/build/models/Provider.d.ts

@@ -0,0 +1,40 @@
+import { ProviderInfo } from "../types/Provider";
+import { Origins } from "../types/Origins";
+declare class Provider {
+    private static contractProviders;
+    private static contractProvidersOffers;
+    private logger;
+    providerInfo?: ProviderInfo;
+    violationRate?: number;
+    authority?: string;
+    valueOffers?: string[];
+    teeOffers?: string[];
+    origins?: Origins;
+    providerId: string;
+    constructor(providerId: string);
+    /**
+     * Function for fetching provider info from blockchain
+     */
+    getInfo(): Promise<ProviderInfo>;
+    /**
+     * Function for fetching provider authority address from blockchain
+     */
+    getAuthority(): Promise<string>;
+    /**
+     * Function for fetching all value offers for this provider
+     */
+    getValueOffers(): Promise<string[]>;
+    /**
+     * Function for fetching all TEE offers for this provider
+     */
+    getTeeOffers(): Promise<string[]>;
+    /**
+     * Function for fetching violationRate for this provider
+     */
+    getViolationRate(): Promise<number>;
+    /**
+     * Fetch new Origins (createdDate, createdBy, modifiedDate and modifiedBy)
+     */
+    getOrigins(): Promise<Origins>;
+}
+export default Provider;