feat: wait for state transition result (#180)

Author: antouhou

package-lock.json

@@ -31,10 +31,10 @@
   },
   "homepage": "https://github.com/dashevo/DashJS#readme",
   "dependencies": {
-    "@dashevo/dapi-client": "~0.17.2",
+    "@dashevo/dapi-client": "0.18.0-dev.2",
     "@dashevo/dashcore-lib": "~0.19.19",
-    "@dashevo/dpp": "~0.17.0",
-    "@dashevo/wallet-lib": "~7.17.2",
+    "@dashevo/dpp": "~0.18.0-dev.1",
+    "@dashevo/wallet-lib": "~7.18.0-dev.1",
     "bs58": "^4.0.1"
   },
   "devDependencies": {

package.json

@@ -0,0 +1,4 @@
+export interface IPlatformStateProof {
+    rootTreeProof: Buffer,
+    storeTreeProof: Buffer,
+}

src/SDK/Client/Client.spec.ts

@@ -0,0 +1,10 @@
+import { IPlatformStateProof } from "./IPlatformStateProof";
+
+export interface IStateTransitionResult {
+    proof?: IPlatformStateProof,
+    error?: {
+        code: number,
+        message: string,
+        data: any,
+    }
+}

src/SDK/Client/Platform/IPlatformStateProof.ts

@@ -19,6 +19,8 @@ import registerName from "./methods/names/register";
 import resolveName from "./methods/names/resolve";
 import resolveNameByRecord from "./methods/names/resolveByRecord";
 import searchName from "./methods/names/search";
+import broadcastStateTransition from "./broadcastStateTransition";
+import { IPlatformStateProof } from "./IPlatformStateProof";
 
 /**
  * Interface for PlatformOpts
@@ -91,6 +93,14 @@ export class Platform {
      */
     public contracts: Records;
 
+    /**
+     * Broadcasts state transition
+     * @param {Object} stateTransition
+     */
+    public broadcastStateTransition(stateTransition: any): Promise<IPlatformStateProof|void> {
+        return broadcastStateTransition(this, stateTransition);
+    };
+
     client: Client;
 
     /**

src/SDK/Client/Platform/IStateTransitionResult.ts

@@ -1,36 +1,61 @@
+import crypto from "crypto";
 import { Platform } from "./Platform";
-import { wait } from "../../../utils/wait";
+import { StateTransitionBroadcastError } from "../../../errors/StateTransitionBroadcastError";
+import { IStateTransitionResult } from "./IStateTransitionResult";
+import { IPlatformStateProof } from "./IPlatformStateProof";
 
 /**
  * @param {Platform} platform
  * @param stateTransition
- * @param identity
- * @param {number} [keyIndex=0]
  */
-export default async function broadcastStateTransition(platform: Platform, stateTransition: any, identity: any, keyIndex : number = 0) {
+export default async function broadcastStateTransition(platform: Platform, stateTransition: any): Promise<IPlatformStateProof|void> {
     const { client, dpp } = platform;
 
-    const account = await client.getWalletAccount();
-
-    // @ts-ignore
-    const { privateKey } = account.getIdentityHDKeyById(
-        identity.getId().toString(),
-        keyIndex,
-    );
-
-    stateTransition.sign(
-        identity.getPublicKeyById(keyIndex),
-        privateKey,
-    );
-
     const result = await dpp.stateTransition.validateStructure(stateTransition);
 
     if (!result.isValid()) {
         throw new Error(`StateTransition is invalid - ${JSON.stringify(result.getErrors())}`);
     }
 
-    await client.getDAPIClient().platform.broadcastStateTransition(stateTransition.toBuffer());
+    // Subscribing to future result
+    const hash = crypto.createHash('sha256')
+      .update(stateTransition.toBuffer())
+      .digest();
+
+    const stateTransitionResultPromise: IStateTransitionResult = client.getDAPIClient().platform.waitForStateTransitionResult(hash, { prove: true });
+
+    // Broadcasting state transition
+    try {
+        await client.getDAPIClient().platform.broadcastStateTransition(stateTransition.toBuffer());
+    } catch (e) {
+        let data;
+        let message;
+
+        if (e.data) {
+            data = e.data;
+        } else if (e.metadata) {
+            const errors = e.metadata.get('errors');
+            data = {};
+            data.errors = errors && errors.length > 0 ? JSON.parse(errors) : errors;
+        }
+
+        if (e.details) {
+            message = e.details;
+        } else {
+            message = e.message;
+        }
+
+        throw new StateTransitionBroadcastError(e.code, message, data);
+    }
+
+    // Waiting for result to return
+    const stateTransitionResult = await stateTransitionResultPromise;
+
+    let { error } = stateTransitionResult;
+
+    if (error) {
+        throw new StateTransitionBroadcastError(error.code, error.message, error.data);
+    }
 
-    // Wait some time for propagation
-    await wait(1000);
+    return stateTransitionResult.proof;
 }

src/SDK/Client/Platform/Platform.ts

@@ -1,3 +1,7 @@
+import { Platform } from "../../Platform";
+import broadcastStateTransition from "../../broadcastStateTransition";
+import { signStateTransition } from "../../signStateTransition";
+
 /**
  * Broadcast contract onto the platform
  *
@@ -6,26 +10,13 @@
  * @param identity - identity
  * @return dataContract
  */
-import { wait } from '../../../../../utils/wait';
-import { Platform } from "../../Platform";
-import broadcastStateTransition from "../../broadcastStateTransition";
-
 export default async function broadcast(this: Platform, dataContract: any, identity: any): Promise<any> {
     const { dpp } = this;
 
     const dataContractCreateTransition = dpp.dataContract.createStateTransition(dataContract);
 
-    await broadcastStateTransition(this, dataContractCreateTransition, identity);
-
-    // Wait some time for propagation
-    await wait(6000);
-
-    let fetchedContract;
-    do {
-        await wait(1000);
-
-        fetchedContract = await this.client.getDAPIClient().platform.getDataContract(dataContract.getId());
-    } while (!fetchedContract);
+    await signStateTransition(this, dataContractCreateTransition, identity);
+    await broadcastStateTransition(this, dataContractCreateTransition);
 
     return dataContractCreateTransition;
 }

src/SDK/Client/Platform/broadcastStateTransition.ts

@@ -1,91 +1,7 @@
-import { wait } from '../../../../../utils/wait';
-import {Platform} from "../../Platform";
+import { Platform } from "../../Platform";
 import broadcastStateTransition from '../../broadcastStateTransition';
 import Document from '@dashevo/dpp/lib/document/Document';
-
-/**
- * get Document DataContract name
- *
- * @param {Platform} platform
- * @param {Document} document
- *
- */
-function getDataContractName(platform: Platform, document: Document): string {
-    const appNames = platform.client.getApps().getNames();
-    const contractId = document.getDataContractId();
-    const dataContractName = appNames.find((name) => {
-        const clientAppDefinition = platform.client.getApps().get(name);
-
-        return clientAppDefinition.contractId.equals(contractId);
-    });
-
-    if (dataContractName === undefined) {
-        // we will never reach this code
-        throw new Error('DataContractAppDefinition was not found');
-    }
-
-    return dataContractName;
-}
-
-
-/**
- *
- * @param {Platform} platform
- * @param {Object} documents
- * @param {Document[]} [documents.create]
- * @param {Document[]} [documents.replace]
- * @param {Document[]} [documents.delete]
- */
-async function waitForPropagation(platform: Platform, documents: { create?: Document[], replace?: Document[], delete?: Document[]}): Promise<void> {
-    await wait(6000);
-
-    let fetchedDocuments;
-
-    if (documents.create && documents.create.length > 0) {
-        const [document] = documents.create;
-        const dataContractName = getDataContractName(platform, document);
-
-        do {
-            await wait(1000);
-
-            // @ts-ignore
-            fetchedDocuments = await platform.client.platform.documents.get(
-              `${dataContractName}.${document.getType()}`,
-              { where: [['$id', '==', document.getId()]] },
-            );
-        } while(fetchedDocuments.length === 0);
-    } else if (documents.replace && documents.replace.length > 0) {
-        const [document] = documents.replace;
-        const dataContractName = getDataContractName(platform, document);
-
-        let revision;
-
-        do {
-            await wait(1000);
-
-            // @ts-ignore
-            fetchedDocuments = await platform.client.platform.documents.get(
-              `${dataContractName}.${document.getType()}`,
-              { where: [['$id', '==', document.getId()]] },
-            );
-
-            revision = fetchedDocuments[0]?.revision || document.revision;
-        } while(revision === document.revision);
-    } else if (documents.delete && documents.delete.length > 0) {
-        const [document] = documents.delete;
-        const dataContractName = getDataContractName(platform, document);
-
-        do {
-            await wait(1000);
-
-            // @ts-ignore
-            fetchedDocuments = await platform.client.platform.documents.get(
-              `${dataContractName}.${document.getType()}`,
-              { where: [['$id', '==', document.getId()]] },
-            );
-        } while(fetchedDocuments.length > 0);
-    }
-}
+import { signStateTransition } from "../../signStateTransition";
 
 /**
  * Broadcast document onto the platform
@@ -102,10 +18,10 @@ export default async function broadcast(this: Platform, documents: { create?: Do
 
     const documentsBatchTransition = dpp.document.createStateTransition(documents);
 
-    await broadcastStateTransition(this, documentsBatchTransition, identity);
+    await signStateTransition(this, documentsBatchTransition, identity);
 
-    // Wait some time for propagation
-    await waitForPropagation(this, documents);
+    // Broadcast state transition also wait for the result to be obtained
+    await broadcastStateTransition(this, documentsBatchTransition);
 
     return documentsBatchTransition;
 }

src/SDK/Client/Platform/methods/contracts/broadcast.ts

@@ -1,8 +1,8 @@
 import { Platform } from "../../Platform";
-import { wait } from "../../../../../utils/wait";
 import createAssetLockTransaction from "../../createAssetLockTransaction";
 import createIdentityCreateTransition from "./internal/createIdentityCreateTransition";
 import createAssetLockProof from "./internal/createAssetLockProof";
+import broadcastStateTransition from "../../broadcastStateTransition";
 
 /**
  * Register identities to the platform
@@ -32,7 +32,7 @@ export default async function register(
         this, assetLockTransaction, assetLockOutputIndex, assetLockProof, assetLockPrivateKey
     );
 
-    await client.getDAPIClient().platform.broadcastStateTransition(identityCreateTransition.toBuffer());
+    await broadcastStateTransition(this, identityCreateTransition);
 
     // If state transition was broadcast without any errors, import identity to the account
     account.storage.insertIdentityIdAtIndex(
@@ -41,12 +41,5 @@ export default async function register(
         identityIndex,
     );
 
-    let fetchedIdentity;
-    do {
-        await wait(1000);
-
-        fetchedIdentity = await this.client.getDAPIClient().platform.getIdentity(identity.getId());
-    } while (!fetchedIdentity);
-
     return identity;
 }

src/SDK/Client/Platform/methods/documents/broadcast.ts

@@ -2,10 +2,10 @@
 import Identifier from "@dashevo/dpp/lib/Identifier";
 import {Platform} from "../../Platform";
 
-import { wait } from "../../../../../utils/wait";
 import createAssetLockTransaction from "../../createAssetLockTransaction";
 import createAssetLockProof from "./internal/createAssetLockProof";
 import createIdentityTopUpTransition from "./internal/createIdnetityTopUpTransition";
+import broadcastStateTransition from "../../broadcastStateTransition";
 
 /**
  * Register identities to the platform
@@ -37,10 +37,7 @@ export async function topUp(this: Platform, identityId: Identifier | string, amo
     const identityTopUpTransition = await createIdentityTopUpTransition(this, assetLockTransaction, assetLockOutputIndex, assetLockProof, assetLockPrivateKey, identityId);
 
     // Broadcast ST
-    await client.getDAPIClient().platform.broadcastStateTransition(identityTopUpTransition.toBuffer());
-
-    // Wait some time for propagation
-    await wait(1000);
+    await broadcastStateTransition(this, identityTopUpTransition);
 
     return true;
 }

src/SDK/Client/Platform/methods/identities/register.ts

@@ -0,0 +1,28 @@
+import {Platform} from "./Platform";
+
+/**
+ *
+ * @param {Platform} platform
+ * @param {AbstractStateTransition} stateTransition
+ * @param {Identity} identity
+ * @param {number} [keyIndex]
+ * @return {AbstractStateTransition}
+ */
+export async function signStateTransition(platform: Platform, stateTransition: any, identity: any, keyIndex: number = 0): Promise<any> {
+    const { client } = platform;
+
+    const account = await client.getWalletAccount();
+
+    // @ts-ignore
+    const { privateKey } = account.getIdentityHDKeyById(
+        identity.getId().toString(),
+        keyIndex,
+    );
+
+    stateTransition.sign(
+        identity.getPublicKeyById(keyIndex),
+        privateKey,
+    );
+
+    return stateTransition;
+}