dash 3.22.0-dev.9 → 3.22.2

package/build/src/SDK/Client/Platform/methods/identities/internal/createAssetLockProof.js

@@ -35,7 +35,12 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         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 waitForCoreChainLockedHeight_1 = __importDefault(require("./waitForCoreChainLockedHeight"));
+var _a = require('@dashevo/wallet-lib/src/errors'), InstantLockTimeoutError = _a.InstantLockTimeoutError, TxMetadataTimeoutError = _a.TxMetadataTimeoutError;
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
  * @param {Platform} platform
@@ -46,22 +51,82 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 function createAssetLockProof(platform, assetLockTransaction, outputIndex) {
     return __awaiter(this, void 0, void 0, function () {
-        var account, dpp, instantLock;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
+        var account, dpp, _a, instantLockPromise, cancelInstantLock, _b, txMetadataPromise, cancelTxMetadata, cancelObtainCoreChainLockedHeight, rejectTimer, rejectionTimeout;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0: return [4 /*yield*/, platform.initialize()];
                 case 1:
-                    _a.sent();
+                    _c.sent();
                     return [4 /*yield*/, platform.client.getWalletAccount()];
                 case 2:
-                    account = _a.sent();
+                    account = _c.sent();
                     dpp = platform.dpp;
-                    return [4 /*yield*/, account.waitForInstantLock(assetLockTransaction.hash)];
-                case 3:
-                    instantLock = _a.sent();
-                    // Create poof that the transaction won't be double spend
-                    // @ts-ignore
-                    return [2 /*return*/, dpp.identity.createInstantAssetLockProof(instantLock, assetLockTransaction, outputIndex)];
+                    _a = account.waitForInstantLock(assetLockTransaction.hash), instantLockPromise = _a.promise, cancelInstantLock = _a.cancel;
+                    _b = account.waitForTxMetadata(assetLockTransaction.hash), txMetadataPromise = _b.promise, cancelTxMetadata = _b.cancel;
+                    rejectionTimeout = account.waitForTxMetadataTimeout > account.waitForInstantLockTimeout
+                        // @ts-ignore
+                        ? account.waitForTxMetadataTimeout + 360000 // wait for platform to sync core chain locked height
+                        // @ts-ignore
+                        : account.waitForInstantLockTimeout;
+                    return [2 /*return*/, Promise.race([
+                            // Wait for Instant Lock
+                            instantLockPromise
+                                .then(function (instantLock) {
+                                clearTimeout(rejectTimer);
+                                cancelTxMetadata();
+                                if (cancelObtainCoreChainLockedHeight) {
+                                    cancelObtainCoreChainLockedHeight();
+                                }
+                                // @ts-ignore
+                                return dpp.identity.createInstantAssetLockProof(instantLock, assetLockTransaction, outputIndex);
+                            })
+                                .catch(function (error) {
+                                if (error instanceof InstantLockTimeoutError) {
+                                    // Instant Lock is timed out.
+                                    // Allow chain proof to win the race
+                                    return new Promise(function () { });
+                                }
+                                return Promise.reject(error);
+                            }),
+                            // Wait for transaction is mined and platform chain synced core height to the transaction height
+                            txMetadataPromise
+                                .then(function (assetLockMetadata) {
+                                // @ts-ignore
+                                return waitForCoreChainLockedHeight_1.default(platform, assetLockMetadata.height)
+                                    .then(function (_a) {
+                                    var promise = _a.promise, cancel = _a.cancel;
+                                    cancelObtainCoreChainLockedHeight = cancel;
+                                    return promise;
+                                })
+                                    .then(function () {
+                                    clearTimeout(rejectTimer);
+                                    cancelInstantLock();
+                                    // @ts-ignore
+                                    return dpp.identity.createChainAssetLockProof(
+                                    // @ts-ignore
+                                    assetLockMetadata.height, assetLockTransaction.getOutPointBuffer(outputIndex));
+                                });
+                            })
+                                .catch(function (error) {
+                                if (error instanceof TxMetadataTimeoutError) {
+                                    // Instant Lock is timed out.
+                                    // Allow instant proof to win the race
+                                    return new Promise(function () { });
+                                }
+                                return Promise.reject(error);
+                            }),
+                            // Common timeout for getting proofs
+                            new Promise(function (_, reject) {
+                                rejectTimer = setTimeout(function () {
+                                    cancelTxMetadata();
+                                    if (cancelObtainCoreChainLockedHeight) {
+                                        cancelObtainCoreChainLockedHeight();
+                                    }
+                                    cancelInstantLock();
+                                    reject(new Error('Asset Lock Proof creation timeout'));
+                                }, rejectionTimeout);
+                            })
+                        ])];
             }
         });
     });

package/build/src/SDK/Client/Platform/methods/identities/internal/createAssetLockProof.js.map

@@ -1 +1 @@
-{"version":3,"file":"createAssetLockProof.js","sourceRoot":"","sources":["../../../../../../../../src/SDK/Client/Platform/methods/identities/internal/createAssetLockProof.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA;;;;;;;GAOG;AACH,SAA8B,oBAAoB,CAAC,QAAmB,EAAE,oBAAiC,EAAE,WAAmB;;;;;wBAC1H,qBAAM,QAAQ,CAAC,UAAU,EAAE,EAAA;;oBAA3B,SAA2B,CAAC;oBAEZ,qBAAM,QAAQ,CAAC,MAAM,CAAC,gBAAgB,EAAE,EAAA;;oBAAlD,OAAO,GAAG,SAAwC;oBAChD,GAAG,GAAK,QAAQ,IAAb,CAAc;oBAEP,qBAAM,OAAO,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAA;;oBAAzE,WAAW,GAAG,SAA2D;oBAC7E,yDAAyD;oBAEzD,aAAa;oBACb,sBAAO,GAAG,CAAC,QAAQ,CAAC,2BAA2B,CAAC,WAAW,EAAE,oBAAoB,EAAE,WAAW,CAAC,EAAC;;;;CACnG;AAXD,uCAWC"}
+{"version":3,"file":"createAssetLockProof.js","sourceRoot":"","sources":["../../../../../../../../src/SDK/Client/Platform/methods/identities/internal/createAssetLockProof.ts"],"names":[],"mappings":"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"}

package/build/src/SDK/Client/Platform/methods/identities/internal/waitForCoreChainLockedHeight.js

@@ -0,0 +1,103 @@
+"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 systemIds_1 = require("@dashevo/dpns-contract/lib/systemIds");
+function waitForCoreChainLockedHeight(platform, expectedCoreHeight) {
+    return __awaiter(this, void 0, void 0, function () {
+        function cancel() {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            isCanceled = true;
+        }
+        var interval, isCanceled, timeout, coreChainLockedHeight, promise;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, platform.initialize()];
+                case 1:
+                    _a.sent();
+                    interval = 5000;
+                    isCanceled = false;
+                    coreChainLockedHeight = 0;
+                    promise = new Promise(function (resolve, reject) {
+                        function obtainCoreChainLockedHeight() {
+                            return __awaiter(this, void 0, void 0, function () {
+                                var identityResponse, metadata, e_1;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 2, , 3]);
+                                            return [4 /*yield*/, platform.identities.get(systemIds_1.ownerId)];
+                                        case 1:
+                                            identityResponse = _a.sent();
+                                            if (!identityResponse) {
+                                                reject(new Error('Identity using to obtain core chain locked height is not present'));
+                                                return [2 /*return*/];
+                                            }
+                                            metadata = identityResponse.getMetadata();
+                                            coreChainLockedHeight = metadata.getCoreChainLockedHeight();
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            e_1 = _a.sent();
+                                            reject(e_1);
+                                            return [2 /*return*/];
+                                        case 3:
+                                            if (coreChainLockedHeight >= expectedCoreHeight) {
+                                                resolve();
+                                                return [2 /*return*/];
+                                            }
+                                            if (!isCanceled) {
+                                                timeout = setTimeout(obtainCoreChainLockedHeight, interval);
+                                            }
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            });
+                        }
+                        obtainCoreChainLockedHeight();
+                    });
+                    return [2 /*return*/, {
+                            promise: promise,
+                            cancel: cancel,
+                        }];
+            }
+        });
+    });
+}
+exports.default = waitForCoreChainLockedHeight;
+//# sourceMappingURL=waitForCoreChainLockedHeight.js.map

package/build/src/SDK/Client/Platform/methods/identities/internal/waitForCoreChainLockedHeight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"waitForCoreChainLockedHeight.js","sourceRoot":"","sources":["../../../../../../../../src/SDK/Client/Platform/methods/identities/internal/waitForCoreChainLockedHeight.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,kEAA8E;AAE9E,SAA8B,4BAA4B,CACxD,QAAmB,EACnB,kBAA2B;;QA8C3B,SAAS,MAAM;YACb,IAAI,OAAO,EAAE;gBACX,YAAY,CAAC,OAAO,CAAC,CAAC;aACvB;YAED,UAAU,GAAG,IAAI,CAAC;QACpB,CAAC;;;;wBAlDD,qBAAM,QAAQ,CAAC,UAAU,EAAE,EAAA;;oBAA3B,SAA2B,CAAC;oBAEtB,QAAQ,GAAG,IAAI,CAAC;oBAElB,UAAU,GAAG,KAAK,CAAC;oBAInB,qBAAqB,GAAG,CAAC,CAAC;oBAExB,OAAO,GAAG,IAAI,OAAO,CAAC,UAAC,OAAO,EAAE,MAAM;wBAC1C,SAAe,2BAA2B;;;;;;;4CAEb,qBAAM,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,mBAAW,CAAC,EAAA;;4CAA7D,gBAAgB,GAAG,SAA0C;4CAEnE,IAAI,CAAC,gBAAgB,EAAE;gDACpB,MAAM,CAAC,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAC,CAAC;gDAEtF,sBAAO;6CACT;4CAEK,QAAQ,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;4CAEhD,qBAAqB,GAAG,QAAQ,CAAC,wBAAwB,EAAE,CAAC;;;;4CAE5D,MAAM,CAAC,GAAC,CAAC,CAAC;4CAEV,sBAAO;;4CAGT,IAAI,qBAAqB,IAAI,kBAAkB,EAAE;gDAC/C,OAAO,EAAE,CAAC;gDAEV,sBAAO;6CACR;4CAED,IAAI,CAAC,UAAU,EAAE;gDACf,OAAO,GAAG,UAAU,CAAC,2BAA2B,EAAE,QAAQ,CAAC,CAAC;6CAC7D;;;;;yBACF;wBAED,2BAA2B,EAAE,CAAC;oBAChC,CAAC,CAAC,CAAC;oBAUH,sBAAO;4BACL,OAAO,SAAA;4BACP,MAAM,QAAA;yBACP,EAAA;;;;CACF;AA5DD,+CA4DC"}

package/dist/src/SDK/Client/Platform/methods/identities/internal/waitForCoreChainLockedHeight.d.ts

@@ -0,0 +1,5 @@
+import { Platform } from "../../../Platform";
+export default function waitForCoreChainLockedHeight(platform: Platform, expectedCoreHeight: number): Promise<{
+    promise: Promise<any>;
+    cancel: Function;
+}>;

package/dist/src/SDK/SDK.d.ts

@@ -97,6 +97,7 @@ export declare namespace SDK {
             REHYDRATE_STATE_FAILED: string;
             REHYDRATE_STATE_SUCCESS: string;
             INSTANT_LOCK: string;
+            TX_METADATA: string;
         };
         plugins: {
             StandardPlugin: typeof import("@dashevo/wallet-libsrc/plugins/StandardPlugin");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dash",
-  "version": "3.22.0-dev.9",
+  "version": "3.22.2",
   "description": "Dash library for JavaScript/TypeScript ecosystem (Wallet, DAPI, Primitives, BLS, ...)",
   "main": "build/src/index.js",
   "unpkg": "dist/dash.min.js",
@@ -34,14 +34,14 @@
   },
   "homepage": "https://github.com/dashevo/DashJS#readme",
   "dependencies": {
-    "@dashevo/dapi-client": "~0.22.0-dev.9",
-    "@dashevo/dashcore-lib": "~0.19.30",
-    "@dashevo/dashpay-contract": "~0.22.0-dev.9",
-    "@dashevo/dpns-contract": "~0.22.0-dev.9",
-    "@dashevo/dpp": "~0.22.0-dev.9",
-    "@dashevo/grpc-common": "~0.22.0-dev.9",
-    "@dashevo/masternode-reward-shares-contract": "~0.22.0-dev.9",
-    "@dashevo/wallet-lib": "~7.22.0-dev.9",
+    "@dashevo/dapi-client": "~0.22.2",
+    "@dashevo/dashcore-lib": "~0.19.31",
+    "@dashevo/dashpay-contract": "~0.22.2",
+    "@dashevo/dpns-contract": "~0.22.2",
+    "@dashevo/dpp": "~0.22.2",
+    "@dashevo/grpc-common": "~0.22.2",
+    "@dashevo/masternode-reward-shares-contract": "~0.22.2",
+    "@dashevo/wallet-lib": "~7.22.2",
     "bs58": "^4.0.1",
     "node-inspect-extracted": "^1.0.8"
   },

package/src/SDK/Client/Platform/methods/identities/internal/createAssetLockProof.ts

@@ -1,6 +1,10 @@
 import { Transaction } from "@dashevo/dashcore-lib";
 import { Platform } from "../../../Platform";
 
+import waitForCoreChainLockedHeight from "./waitForCoreChainLockedHeight";
+
+const { InstantLockTimeoutError, TxMetadataTimeoutError } = require('@dashevo/wallet-lib/src/errors');
+
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
  * @param {Platform} platform
@@ -15,9 +19,103 @@ export default async function createAssetLockProof(platform : Platform, assetLoc
     const account = await platform.client.getWalletAccount();
     const { dpp } = platform;
 
-    let instantLock = await account.waitForInstantLock(assetLockTransaction.hash);
     // Create poof that the transaction won't be double spend
 
+    const {
+      promise: instantLockPromise,
+      cancel: cancelInstantLock
+    } = account.waitForInstantLock(assetLockTransaction.hash);
+
+    const {
+      promise: txMetadataPromise,
+      cancel: cancelTxMetadata,
+    } = account.waitForTxMetadata(assetLockTransaction.hash);
+
+    let cancelObtainCoreChainLockedHeight;
+
+    let rejectTimer;
+
     // @ts-ignore
-    return dpp.identity.createInstantAssetLockProof(instantLock, assetLockTransaction, outputIndex);
+    const rejectionTimeout = account.waitForTxMetadataTimeout > account.waitForInstantLockTimeout
+      // @ts-ignore
+      ? account.waitForTxMetadataTimeout + 360000 // wait for platform to sync core chain locked height
+      // @ts-ignore
+      : account.waitForInstantLockTimeout;
+
+    return Promise.race([
+      // Wait for Instant Lock
+      instantLockPromise
+        .then((instantLock) => {
+          clearTimeout(rejectTimer);
+
+          cancelTxMetadata();
+
+          if (cancelObtainCoreChainLockedHeight) {
+            cancelObtainCoreChainLockedHeight();
+          }
+
+          // @ts-ignore
+          return dpp.identity.createInstantAssetLockProof(
+            instantLock,
+            assetLockTransaction,
+            outputIndex,
+          );
+        })
+        .catch((error) => {
+          if (error instanceof InstantLockTimeoutError) {
+            // Instant Lock is timed out.
+            // Allow chain proof to win the race
+            return new Promise(() => {});
+          }
+
+          return Promise.reject(error);
+        }),
+
+      // Wait for transaction is mined and platform chain synced core height to the transaction height
+      txMetadataPromise
+        .then((assetLockMetadata) => {
+          // @ts-ignore
+          return waitForCoreChainLockedHeight(platform, assetLockMetadata.height)
+            .then(({ promise, cancel }) => {
+              cancelObtainCoreChainLockedHeight = cancel;
+
+              return promise;
+            })
+            .then(() => {
+              clearTimeout(rejectTimer);
+              cancelInstantLock();
+
+              // @ts-ignore
+              return dpp.identity.createChainAssetLockProof(
+                // @ts-ignore
+                assetLockMetadata.height,
+                assetLockTransaction.getOutPointBuffer(outputIndex),
+              );
+            })
+        })
+        .catch((error) => {
+          if (error instanceof TxMetadataTimeoutError) {
+            // Instant Lock is timed out.
+            // Allow instant proof to win the race
+            return new Promise(() => {});
+          }
+
+          return Promise.reject(error);
+        }),
+
+      // Common timeout for getting proofs
+      new Promise((_, reject) => {
+        rejectTimer = setTimeout(() => {
+          cancelTxMetadata();
+
+          if (cancelObtainCoreChainLockedHeight) {
+            cancelObtainCoreChainLockedHeight();
+          }
+
+          cancelInstantLock();
+
+          reject(new Error('Asset Lock Proof creation timeout'));
+        }, rejectionTimeout)
+      })
+    ]);
 }

package/src/SDK/Client/Platform/methods/identities/internal/waitForCoreChainLockedHeight.ts

@@ -0,0 +1,69 @@
+import { Platform } from "../../../Platform";
+
+import { ownerId as dpnsOwnerId } from "@dashevo/dpns-contract/lib/systemIds";
+
+export default async function waitForCoreChainLockedHeight(
+  platform : Platform,
+  expectedCoreHeight : number,
+): Promise<{ promise: Promise<any>, cancel: Function }> {
+  await platform.initialize();
+
+  const interval = 5000;
+
+  let isCanceled = false;
+
+  let timeout: ReturnType<typeof setTimeout>;
+
+  let coreChainLockedHeight = 0;
+
+  const promise = new Promise((resolve, reject) => {
+    async function obtainCoreChainLockedHeight() {
+      try {
+        const identityResponse = await platform.identities.get(dpnsOwnerId);
+
+        if (!identityResponse) {
+           reject(new Error('Identity using to obtain core chain locked height is not present'));
+
+           return;
+        }
+
+        const metadata = identityResponse.getMetadata();
+
+        coreChainLockedHeight = metadata.getCoreChainLockedHeight();
+      } catch (e) {
+        reject(e);
+
+        return;
+      }
+
+      if (coreChainLockedHeight >= expectedCoreHeight) {
+        resolve();
+
+        return;
+      }
+
+      if (!isCanceled) {
+        timeout = setTimeout(obtainCoreChainLockedHeight, interval);
+      }
+    }
+
+    obtainCoreChainLockedHeight();
+  });
+
+  function cancel() {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+
+    isCanceled = true;
+  }
+
+  return {
+    promise,
+    cancel,
+  }
+}
+
+
+
+