dash 3.23.0-dev.1 → 3.23.0-dev.10

package/docs/wallet/signing-encrypt.md

@@ -1,22 +1,28 @@
-## Sign a Transaction/Transition a message
+## Obtain account
+```js
+const account = await client.wallet.getAccount();
+```
+
+## Sign a Transaction
+
 
 ```js
-const tx = new Dash.Transaction({
-//txOpts
+const tx = new Dash.Core.Transaction({
+  // ...txOpts
 });
-const signedTx = client.account.sign(tx);
+const signedTx = account.sign(tx);
 ```
 
 ## Encrypt a message
 
 ```js
   const message = 'Something';
-  const signedMessage = client.account.encrypt('AES',message,'secret');
+  const signedMessage = account.encrypt('AES', message, 'secret');
 ```
 
 ## Decrypt a message
 
 ```js
 const encrypted = 'U2FsdGVkX19JLa+1UpbMcut1/QFWLMlKUS+iqz+7Wl4=';
-const message = client.account.decrypt('AES',encrypted,'secret');
+const message = account.decrypt('AES', encrypted, 'secret');
 ```

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "dash",
-  "version": "3.23.0-dev.1",
+  "version": "3.23.0-dev.10",
   "description": "Dash library for JavaScript/TypeScript ecosystem (Wallet, DAPI, Primitives, BLS, ...)",
   "main": "build/src/index.js",
   "unpkg": "dist/dash.min.js",
+  "browser": "dist/dash.min.js",
   "types": "dist/src/index.d.ts",
   "scripts": {
     "start:dev": "nodemon --exec 'yarn run build && yarn run test:unit'",
-    "build": "yarn run build:ts",
-    "build:web": "yarn run build:ts && webpack --stats-error-details",
+    "start:ts": "tsc --watch",
+    "build": "yarn run build:ts && webpack --stats-error-details",
     "build:ts": "tsc",
     "lint": "",
     "test": "yarn run test:unit && yarn run test:functional && yarn run test:browsers",
     "test:browsers": "karma start ./karma.conf.js --single-run",
     "test:unit": "TS_NODE_COMPILER_OPTIONS={\"target\":\"es6\"} ts-mocha \"src/**/*.spec.ts\"",
     "test:functional": "yarn run build && mocha --recursive tests/functional/**/*.js",
-    "prepublishOnly": "yarn run build:web",
+    "prepublishOnly": "yarn run build",
     "prepare": "yarn run build"
   },
   "ultra": {
@@ -34,14 +35,14 @@
   },
   "homepage": "https://github.com/dashevo/DashJS#readme",
   "dependencies": {
-    "@dashevo/dapi-client": "~0.23.0-dev.1",
-    "@dashevo/dashcore-lib": "~0.19.30",
-    "@dashevo/dashpay-contract": "~0.23.0-dev.1",
-    "@dashevo/dpns-contract": "~0.23.0-dev.1",
-    "@dashevo/dpp": "~0.23.0-dev.1",
-    "@dashevo/grpc-common": "~0.23.0-dev.1",
-    "@dashevo/masternode-reward-shares-contract": "~0.23.0-dev.1",
-    "@dashevo/wallet-lib": "~7.23.0-dev.1",
+    "@dashevo/dapi-client": "~0.23.0-dev.10",
+    "@dashevo/dashcore-lib": "~0.19.44",
+    "@dashevo/dashpay-contract": "~0.23.0-dev.10",
+    "@dashevo/dpns-contract": "~0.23.0-dev.10",
+    "@dashevo/dpp": "~0.23.0-dev.10",
+    "@dashevo/grpc-common": "~0.23.0-dev.10",
+    "@dashevo/masternode-reward-shares-contract": "~0.23.0-dev.10",
+    "@dashevo/wallet-lib": "~7.23.0-dev.10",
     "bs58": "^4.0.1",
     "node-inspect-extracted": "^1.0.8"
   },
@@ -63,7 +64,7 @@
     "dotenv-safe": "^8.2.0",
     "events": "^3.3.0",
     "https-browserify": "^1.0.0",
-    "karma": "^6.3.4",
+    "karma": "^6.4.1",
     "karma-chai": "^0.1.0",
     "karma-chrome-launcher": "^3.1.0",
     "karma-firefox-launcher": "^2.1.1",
@@ -71,7 +72,8 @@
     "karma-mocha-reporter": "^2.2.5",
     "karma-webpack": "^5.0.0",
     "mocha": "^9.1.2",
-    "nodemon": "^2.0.4",
+    "net": "^1.0.2",
+    "nodemon": "^2.0.20",
     "os-browserify": "^0.3.0",
     "path-browserify": "^1.0.1",
     "process": "^0.11.10",
@@ -81,8 +83,10 @@
     "stream-browserify": "^3.0.0",
     "stream-http": "^3.2.0",
     "string_decoder": "^1.3.0",
+    "terser-webpack-plugin": "^5.3.1",
+    "tls": "^0.0.1",
     "ts-loader": "^8.0.2",
-    "ts-mocha": "^8.0.0",
+    "ts-mocha": "^9.0.2",
     "ts-mock-imports": "^1.3.0",
     "ts-node": "^10.4.0",
     "typescript": "^3.9.5",

package/src/SDK/Client/Client.spec.ts

@@ -11,7 +11,6 @@ import { StateTransitionBroadcastError } from '../../errors/StateTransitionBroad
 const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
 // @ts-ignore
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
-const GetIdentityResponse = require("@dashevo/dapi-client/lib/methods/platform/getIdentity/GetIdentityResponse");
 const GetDataContractResponse = require("@dashevo/dapi-client/lib/methods/platform/getDataContract/GetDataContractResponse");
 
 import { createIdentityFixtureInAccount } from '../../test/fixtures/createIdentityFixtureInAccount';
@@ -68,7 +67,6 @@ describe('Dash - Client', function suite() {
     transportMock.getBlockHeaderByHash
         .returns(BlockHeader.fromString(blockHeaderFixture));
 
-    dapiClientMock.platform.getIdentity.resolves(new GetIdentityResponse(identityFixture.toBuffer(), getResponseMetadataFixture()));
     dapiClientMock.platform.getDataContract.resolves(new GetDataContractResponse(dataContractFixture.toBuffer(), getResponseMetadataFixture()));
   });
 
@@ -269,7 +267,7 @@ describe('Dash - Client', function suite() {
       const interceptedSt = await client.platform.dpp.stateTransition.createFromBuffer(serializedSt);
 
       // .to.be.true() doesn't work after TS compilation in Chrome
-      expect(await interceptedSt.verifySignature(identityFixture.getPublicKeyById(0))).to.be.equal(true);
+      expect(await interceptedSt.verifySignature(identityFixture.getPublicKeyById(1))).to.be.equal(true);
 
       const documentTransitions = interceptedSt.getTransitions();
 
@@ -313,7 +311,7 @@ describe('Dash - Client', function suite() {
       const interceptedSt = await client.platform.dpp.stateTransition.createFromBuffer(serializedSt);
 
       // .to.be.true() doesn't work after TS compilation in Chrome
-      expect(await interceptedSt.verifySignature(identityFixture.getPublicKeyById(0))).to.be.equal(true);
+      expect(await interceptedSt.verifySignature(identityFixture.getPublicKeyById(1))).to.be.equal(true);
       expect(interceptedSt.getEntropy()).to.be.deep.equal(dataContractFixture.entropy);
       expect(interceptedSt.getDataContract().toObject()).to.be.deep.equal(dataContractFixture.toObject());
     });

package/src/SDK/Client/Platform/Platform.ts

@@ -4,6 +4,8 @@ import DashPlatformProtocol from "@dashevo/dpp";
 import Client from "../Client";
 import { IStateTransitionResult } from './IStateTransitionResult';
 
+import createAssetLockTransaction from "./createAssetLockTransaction";
+
 import broadcastDocument from "./methods/documents/broadcast";
 import createDocument from "./methods/documents/create";
 import getDocument from "./methods/documents/get";
@@ -17,6 +19,10 @@ import getIdentity from "./methods/identities/get";
 import registerIdentity from "./methods/identities/register";
 import topUpIdentity from "./methods/identities/topUp";
 import updateIdentity from "./methods/identities/update";
+import createIdentityCreateTransition from "./methods/identities/internal/createIdentityCreateTransition";
+import createIdentityTopUpTransition from "./methods/identities/internal/createIdnetityTopUpTransition";
+import createAssetLockProof from "./methods/identities/internal/createAssetLockProof";
+import waitForCoreChainLockedHeight from "./methods/identities/internal/waitForCoreChainLockedHeight";
 
 import registerName from "./methods/names/register";
 import resolveName from "./methods/names/resolve";
@@ -67,6 +73,13 @@ interface Identities {
     register: Function,
     topUp: Function,
     update: Function,
+    utils: {
+      createAssetLockTransaction: Function
+      createAssetLockProof: Function
+      createIdentityCreateTransition: Function
+      createIdentityTopUpTransition: Function
+      waitForCoreChainLockedHeight: Function
+    }
 }
 
 interface DataContracts {
@@ -147,6 +160,13 @@ export class Platform {
             get: getIdentity.bind(this),
             topUp: topUpIdentity.bind(this),
             update: updateIdentity.bind(this),
+            utils: {
+                createAssetLockProof: createAssetLockProof.bind(this),
+                createAssetLockTransaction: createAssetLockTransaction.bind(this),
+                createIdentityCreateTransition: createIdentityCreateTransition.bind(this),
+                createIdentityTopUpTransition: createIdentityTopUpTransition.bind(this),
+                waitForCoreChainLockedHeight: waitForCoreChainLockedHeight.bind(this),
+            }
         };
 
         this.client = options.client;
@@ -175,3 +195,4 @@ export class Platform {
         await this.dpp.initialize();
     }
 }
+

package/src/SDK/Client/Platform/broadcastStateTransition.ts

@@ -12,21 +12,30 @@ const GrpcError = require('@dashevo/grpc-common/lib/server/error/GrpcError');
 
 /**
  * @param {Platform} platform
+ * @param {Object} [options]
+ * @param {boolean} [options.skipValidation=false]
+ *
  * @param stateTransition
  */
-export default async function broadcastStateTransition(platform: Platform, stateTransition: any): Promise<IStateTransitionResult|void> {
+export default async function broadcastStateTransition(
+  platform: Platform,
+  stateTransition: any,
+  options: { skipValidation?: boolean; } = {},
+): Promise<IStateTransitionResult|void> {
     const { client, dpp } = platform;
 
-    const result = await dpp.stateTransition.validateBasic(stateTransition);
+    if (!options.skipValidation) {
+      const result = await dpp.stateTransition.validateBasic(stateTransition);
 
-    if (!result.isValid()) {
+      if (!result.isValid()) {
         const consensusError = result.getFirstError();
 
         throw new StateTransitionBroadcastError(
-            consensusError.getCode(),
-            consensusError.message,
-            consensusError,
+          consensusError.getCode(),
+          consensusError.message,
+          consensusError,
         );
+      }
     }
 
     // Subscribing to future result

package/src/SDK/Client/Platform/createAssetLockTransaction.ts

@@ -7,12 +7,13 @@ const ASSET_LOCK_OUTPUT_INDEX = 0;
 
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
- * @param {Platform} platform
+ * @param {Platform} this
  * @param {number} fundingAmount - amount of dash to fund the identity's credits
  * @return {Promise<{transaction: Transaction, privateKey: PrivateKey}>} - transaction and one time private key
  * that can be used to sign registration/top-up state transition
  */
-export default async function createAssetLockTransaction(platform : Platform, fundingAmount): Promise<{ transaction: Transaction, privateKey: PrivateKey, outputIndex: number }> {
+export async function createAssetLockTransaction(this : Platform, fundingAmount): Promise<{ transaction: Transaction, privateKey: PrivateKey, outputIndex: number }> {
+    const platform = this;
     const account = await platform.client.getWalletAccount();
 
     // @ts-ignore
@@ -61,3 +62,5 @@ export default async function createAssetLockTransaction(platform : Platform, fu
         outputIndex: ASSET_LOCK_OUTPUT_INDEX,
     };
 }
+
+export default createAssetLockTransaction;

package/src/SDK/Client/Platform/methods/contracts/publish.ts

@@ -17,7 +17,7 @@ export default async function publish(this: Platform, dataContract: any, identit
 
     const dataContractCreateTransition = dpp.dataContract.createDataContractCreateTransition(dataContract);
 
-    await signStateTransition(this, dataContractCreateTransition, identity);
+    await signStateTransition(this, dataContractCreateTransition, identity, 1);
     await broadcastStateTransition(this, dataContractCreateTransition);
 
     return dataContractCreateTransition;

package/src/SDK/Client/Platform/methods/contracts/update.ts

@@ -24,7 +24,7 @@ export default async function update(this: Platform, dataContract: any, identity
 
   const dataContractUpdateTransition = dpp.dataContract.createDataContractUpdateTransition(updatedDataContract);
 
-  await signStateTransition(this, dataContractUpdateTransition, identity);
+  await signStateTransition(this, dataContractUpdateTransition, identity, 1);
   await broadcastStateTransition(this, dataContractUpdateTransition);
 
   // Update app with updated data contract if available

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

@@ -20,7 +20,7 @@ export default async function broadcast(this: Platform, documents: { create?: Do
 
     const documentsBatchTransition = dpp.document.createStateTransition(documents);
 
-    await signStateTransition(this, documentsBatchTransition, identity);
+    await signStateTransition(this, documentsBatchTransition, identity, 1);
 
     // Broadcast state transition also wait for the result to be obtained
     await broadcastStateTransition(this, documentsBatchTransition);

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

@@ -7,13 +7,14 @@ const { InstantLockTimeoutError, TxMetadataTimeoutError } = require('@dashevo/wa
 
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
- * @param {Platform} platform
+ * @param {Platform} this
  * @param {Transaction} assetLockTransaction
  * @param {number} outputIndex - index of the funding output in the asset lock transaction
  * @return {AssetLockProof} - asset lock proof to be used in the state transition
  * that can be used to sign registration/top-up state transition
  */
-export default async function createAssetLockProof(platform : Platform, assetLockTransaction: Transaction, outputIndex: number): Promise<any> {
+export async function createAssetLockProof(this : Platform, assetLockTransaction: Transaction, outputIndex: number): Promise<any> {
+    const platform = this;
     await platform.initialize();
 
     const account = await platform.client.getWalletAccount();
@@ -119,3 +120,5 @@ export default async function createAssetLockProof(platform : Platform, assetLoc
       })
     ]);
 }
+
+export default createAssetLockProof;

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

@@ -4,13 +4,14 @@ import IdentityPublicKey from "@dashevo/dpp/lib/identity/IdentityPublicKey"
 
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
- * @param {Platform} platform
+ * @param {Platform} this
  * @param {AssetLockProof} assetLockProof - asset lock transaction proof for the identity create transition
  * @param {PrivateKey} assetLockPrivateKey - private key used in asset lock
  * @return {{identity: Identity, identityCreateTransition: IdentityCreateTransition}} - identity, state transition and index of the key used to create it
  * that can be used to sign registration/top-up state transition
  */
-export default async function createIdentityCreateTransition(platform : Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey): Promise<{ identity: any, identityCreateTransition: any, identityIndex: number }> {
+export async function createIdentityCreateTransition(this : Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey): Promise<{ identity: any, identityCreateTransition: any, identityIndex: number }> {
+    const platform = this;
     await platform.initialize();
 
     const account = await platform.client.getWalletAccount();
@@ -19,22 +20,50 @@ export default async function createIdentityCreateTransition(platform : Platform
     const identityIndex = await account.getUnusedIdentityIndex();
 
     // @ts-ignore
-    const { privateKey: identityPrivateKey } = account.identities.getIdentityHDKeyByIndex(identityIndex, 0);
-    const identityPublicKey = identityPrivateKey.toPublicKey();
+    const { privateKey: identityMasterPrivateKey } = account.identities.getIdentityHDKeyByIndex(identityIndex, 0);
+    const identityMasterPublicKey = identityMasterPrivateKey.toPublicKey();
+
+    const { privateKey: identitySecondPrivateKey } = account.identities.getIdentityHDKeyByIndex(identityIndex, 1);
+    const identitySecondPublicKey = identitySecondPrivateKey.toPublicKey();
 
     // Create Identity
     // @ts-ignore
     const identity = dpp.identity.create(
         assetLockProof, [{
-          key: identityPublicKey,
+          key: identityMasterPublicKey,
           purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
           securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER
-        }]
+        },
+        {
+          key: identitySecondPublicKey,
+          purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+          securityLevel: IdentityPublicKey.SECURITY_LEVELS.HIGH
+      }
+      ]
     );
 
-    // Create ST
+     // Create ST
     const identityCreateTransition = dpp.identity.createIdentityCreateTransition(identity);
 
+    // Create key proofs
+
+    const [masterKey, secondKey] = identityCreateTransition.getPublicKeys();
+
+    await identityCreateTransition.signByPrivateKey(identityMasterPrivateKey, IdentityPublicKey.TYPES.ECDSA_SECP256K1);
+
+    masterKey.setSignature(identityCreateTransition.getSignature());
+
+    identityCreateTransition.setSignature(undefined);
+
+  await identityCreateTransition.signByPrivateKey(identitySecondPrivateKey, IdentityPublicKey.TYPES.ECDSA_SECP256K1);
+
+  secondKey.setSignature(identityCreateTransition.getSignature());
+
+  identityCreateTransition.setSignature(undefined);
+
+
+  // Sign and validate state transition
+
     await identityCreateTransition.signByPrivateKey(assetLockPrivateKey, IdentityPublicKey.TYPES.ECDSA_SECP256K1);
 
     const result = await dpp.stateTransition.validateBasic(identityCreateTransition);
@@ -45,3 +74,5 @@ export default async function createIdentityCreateTransition(platform : Platform
 
     return { identity, identityCreateTransition, identityIndex };
 }
+
+export default createIdentityCreateTransition;

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

@@ -4,14 +4,15 @@ import IdentityPublicKey from "@dashevo/dpp/lib/identity/IdentityPublicKey"
 
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
- * @param {Platform} platform
+ * @param {Platform} this
  * @param {AssetLockProof} assetLockProof - asset lock transaction proof for the identity create transition
  * @param {PrivateKey} assetLockPrivateKey - private key used in asset lock
  * @param {string|Buffer|Identifier} identityId
  * @return {{identity: Identity, identityCreateTransition: IdentityCreateTransition}} - identity, state transition and index of the key used to create it
  * that can be used to sign registration/top-up state transition
  */
-export default async function createIdentityTopUpTransition(platform : Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey, identityId: any): Promise<any> {
+export async function createIdentityTopUpTransition(this : Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey, identityId: any): Promise<any> {
+    const platform = this;
     await platform.initialize();
 
     const { dpp } = platform;
@@ -31,3 +32,5 @@ export default async function createIdentityTopUpTransition(platform : Platform,
 
     return identityTopUpTransition;
 }
+
+export default createIdentityTopUpTransition;

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

@@ -2,10 +2,11 @@ import { Platform } from "../../../Platform";
 
 import { ownerId as dpnsOwnerId } from "@dashevo/dpns-contract/lib/systemIds";
 
-export default async function waitForCoreChainLockedHeight(
-  platform : Platform,
+export async function waitForCoreChainLockedHeight(
+  this : Platform,
   expectedCoreHeight : number,
 ): Promise<{ promise: Promise<any>, cancel: Function }> {
+  const platform = this;
   await platform.initialize();
 
   const interval = 5000;
@@ -64,6 +65,6 @@ export default async function waitForCoreChainLockedHeight(
   }
 }
 
-
+export default waitForCoreChainLockedHeight;
 
 

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

@@ -1,8 +1,6 @@
 import { Platform } from "../../Platform";
-import createAssetLockTransaction from "../../createAssetLockTransaction";
-import createIdentityCreateTransition from "./internal/createIdentityCreateTransition";
-import createAssetLockProof from "./internal/createAssetLockProof";
 import broadcastStateTransition from "../../broadcastStateTransition";
+import {wait} from "../../../../../utils/wait";
 
 /**
  * Register identities to the platform
@@ -12,7 +10,7 @@ import broadcastStateTransition from "../../broadcastStateTransition";
  */
 export default async function register(
   this: Platform,
-  fundingAmount : number = 10000
+  fundingAmount : number = 100000
 ): Promise<any> {
     await this.initialize();
 
@@ -24,15 +22,17 @@ export default async function register(
         transaction: assetLockTransaction,
         privateKey: assetLockPrivateKey,
         outputIndex: assetLockOutputIndex
-    } = await createAssetLockTransaction(this, fundingAmount);
+    } = await this.identities.utils.createAssetLockTransaction(fundingAmount);
 
     // Broadcast Asset Lock transaction
     await account.broadcastTransaction(assetLockTransaction);
-    const assetLockProof = await createAssetLockProof(this, assetLockTransaction, assetLockOutputIndex);
 
-    const { identity, identityCreateTransition, identityIndex } = await createIdentityCreateTransition(
-        this, assetLockProof, assetLockPrivateKey
-    );
+    const assetLockProof = await this.identities.utils
+      .createAssetLockProof(assetLockTransaction, assetLockOutputIndex);
+
+    const { identity, identityCreateTransition, identityIndex } = await this.identities.utils
+      .createIdentityCreateTransition(assetLockProof, assetLockPrivateKey);
+
     await broadcastStateTransition(this, identityCreateTransition);
 
     // If state transition was broadcast without any errors, import identity to the account
@@ -43,5 +43,29 @@ export default async function register(
       identityIndex,
     );
 
+    // Fetch identity from the network because the current identity object
+    // doesn't have metadata and balance information. Due to replication lag
+    // some nodes couldn't have it yet, so we need to try multiple times
+    const maxAttempts = 20;
+    let attempt = 0;
+    let registeredIdentity: any = null; // We don't have Identity type yet
+
+    while (registeredIdentity === null && attempt < maxAttempts) {
+      await wait(100);
+
+      registeredIdentity = await this.identities.get(identity.getId());
+      attempt++;
+    }
+
+    if (registeredIdentity === null) {
+      throw new Error(`Can't fetch created identity with id ${identity.getId()}`);
+    }
+
+    // We cannot just return registeredIdentity as we want to
+    // keep additional information (assetLockProof and transaction) instance
+    identity.setMetadata(registeredIdentity.getMetadata());
+    identity.setBalance(registeredIdentity.getBalance());
+    identity.setPublicKeys(registeredIdentity.getPublicKeys());
+
     return identity;
 }

package/src/SDK/Client/Platform/methods/identities/topUp.ts

@@ -1,10 +1,6 @@
-// @ts-ignore
 import Identifier from "@dashevo/dpp/lib/Identifier";
 import {Platform} from "../../Platform";
 
-import createAssetLockTransaction from "../../createAssetLockTransaction";
-import createAssetLockProof from "./internal/createAssetLockProof";
-import createIdentityTopUpTransition from "./internal/createIdnetityTopUpTransition";
 import broadcastStateTransition from "../../broadcastStateTransition";
 
 /**
@@ -28,15 +24,16 @@ export async function topUp(this: Platform, identityId: Identifier | string, amo
         transaction: assetLockTransaction,
         privateKey: assetLockPrivateKey,
         outputIndex: assetLockOutputIndex
-    } = await createAssetLockTransaction(this, amount);
+    } = await this.identities.utils.createAssetLockTransaction(amount);
 
     // Broadcast Asset Lock transaction
     await account.broadcastTransaction(assetLockTransaction);
     // Create a proof for the asset lock transaction
-    const assetLockProof = await createAssetLockProof(this, assetLockTransaction, assetLockOutputIndex);
+    const assetLockProof = await this.identities.utils
+      .createAssetLockProof(assetLockTransaction, assetLockOutputIndex);
 
-    // @ts-ignore
-    const identityTopUpTransition = await createIdentityTopUpTransition(this, assetLockProof, assetLockPrivateKey, identityId);
+    const identityTopUpTransition = await this.identities.utils
+      .createIdentityTopUpTransition(assetLockProof, assetLockPrivateKey, identityId);
 
     // Broadcast ST
     await broadcastStateTransition(this, identityTopUpTransition);

package/src/SDK/Client/Platform/methods/identities/update.ts

@@ -11,6 +11,7 @@ import broadcastStateTransition from "../../broadcastStateTransition";
  * @param {Platform} this - bound instance class
  * @param {Identity} identity - identity to update
  * @param {{add: IdentityPublicKey[]; disable: IdentityPublicKey[]}} publicKeys - public keys to add
+ * @param {Object<string, any>} privateKeys - public keys to add
  *
  * @returns {boolean}
  */
@@ -18,6 +19,7 @@ export async function update(
   this: Platform,
   identity: Identity,
   publicKeys: { add?: IdentityPublicKey[]; disable?: IdentityPublicKey[] },
+  privateKeys: { string, any },
   ): Promise<any> {
   await this.initialize();
 
@@ -28,7 +30,39 @@ export async function update(
     publicKeys,
   );
 
-  await signStateTransition(this, identityUpdateTransition, identity);
+  const signerKeyIndex = 0;
+
+  // Create key proofs
+  if (identityUpdateTransition.getPublicKeysToAdd()) {
+    const signerKey = identity.getPublicKeys()[signerKeyIndex];
+
+    // must be run sequentially! will not work with Promise.all!
+    // more info at https://jrsinclair.com/articles/2019/how-to-run-async-js-in-parallel-or-sequential/
+
+    const starterPromise = Promise.resolve(null);
+
+    await identityUpdateTransition.getPublicKeysToAdd().reduce(
+      (previousPromise, publicKey) => previousPromise.then(async () => {
+        const privateKey = privateKeys[publicKey.getId()];
+
+        if (!privateKey) {
+          throw new Error(`Private key for key ${publicKey.getId()} not found`);
+        }
+
+        identityUpdateTransition.setSignaturePublicKeyId(signerKey.getId());
+
+        await identityUpdateTransition.signByPrivateKey(privateKey, publicKey.getType());
+
+        publicKey.setSignature(identityUpdateTransition.getSignature());
+
+        identityUpdateTransition.setSignature(undefined);
+        identityUpdateTransition.setSignaturePublicKeyId(undefined);
+      }),
+      starterPromise,
+    );
+  }
+
+  await signStateTransition(this, identityUpdateTransition, identity, signerKeyIndex);
 
   const result = await dpp.stateTransition.validateBasic(identityUpdateTransition);