dash 3.23.0-dev.1 → 3.23.0-dev.4

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

@@ -39,6 +39,13 @@ interface Identities {
     register: Function;
     topUp: Function;
     update: Function;
+    utils: {
+        createAssetLockTransaction: Function;
+        createAssetLockProof: Function;
+        createIdentityCreateTransition: Function;
+        createIdentityTopUpTransition: Function;
+        waitForCoreChainLockedHeight: Function;
+    };
 }
 interface DataContracts {
     update: Function;

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

@@ -2,6 +2,11 @@ import { Platform } from "./Platform";
 import { IStateTransitionResult } from "./IStateTransitionResult";
 /**
  * @param {Platform} platform
+ * @param {Object} [options]
+ * @param {boolean} [options.skipValidation=false]
+ *
  * @param stateTransition
  */
-export default function broadcastStateTransition(platform: Platform, stateTransition: any): Promise<IStateTransitionResult | void>;
+export default function broadcastStateTransition(platform: Platform, stateTransition: any, options?: {
+    skipValidation?: boolean;
+}): Promise<IStateTransitionResult | void>;

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

@@ -2,13 +2,14 @@ import { PrivateKey, Transaction } from "@dashevo/dashcore-lib";
 import { Platform } from "./Platform";
 /**
  * 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 function createAssetLockTransaction(platform: Platform, fundingAmount: any): Promise<{
+export declare function createAssetLockTransaction(this: Platform, fundingAmount: any): Promise<{
     transaction: Transaction;
     privateKey: PrivateKey;
     outputIndex: number;
 }>;
+export default createAssetLockTransaction;

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

@@ -2,10 +2,11 @@ import { Transaction } from "@dashevo/dashcore-lib";
 import { Platform } from "../../../Platform";
 /**
  * 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 function createAssetLockProof(platform: Platform, assetLockTransaction: Transaction, outputIndex: number): Promise<any>;
+export declare function createAssetLockProof(this: Platform, assetLockTransaction: Transaction, outputIndex: number): Promise<any>;
+export default createAssetLockProof;

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

@@ -2,14 +2,15 @@ import { PrivateKey } from "@dashevo/dashcore-lib";
 import { Platform } from "../../../Platform";
 /**
  * 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 function createIdentityCreateTransition(platform: Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey): Promise<{
+export declare function createIdentityCreateTransition(this: Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey): Promise<{
     identity: any;
     identityCreateTransition: any;
     identityIndex: number;
 }>;
+export default createIdentityCreateTransition;

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

@@ -2,11 +2,12 @@ import { PrivateKey } from "@dashevo/dashcore-lib";
 import { Platform } from "../../../Platform";
 /**
  * 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 function createIdentityTopUpTransition(platform: Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey, identityId: any): Promise<any>;
+export declare function createIdentityTopUpTransition(this: Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey, identityId: any): Promise<any>;
+export default createIdentityTopUpTransition;

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

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

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

@@ -7,11 +7,15 @@ import IdentityPublicKey from "@dashevo/dpp/lib/identity/IdentityPublicKey";
  * @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}
  */
 export declare function update(this: Platform, identity: Identity, publicKeys: {
     add?: IdentityPublicKey[];
     disable?: IdentityPublicKey[];
+}, privateKeys: {
+    string: any;
+    any: any;
 }): Promise<any>;
 export default update;

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

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { Client as _Client } from './Client';
 import { Platform as _Platform } from './Platform';
+import { StateTransitionBroadcastError } from '../errors/StateTransitionBroadcastError';
 import { Wallet as _Wallet, Account as _Account, DerivableKeyChain as _KeyChain } from '@dashevo/wallet-lib';
 export declare namespace SDK {
     let DAPIClient: any;
@@ -62,6 +63,7 @@ export declare namespace SDK {
                 UNKNOWN: string;
             };
             STORAGE: {
+                version: number;
                 autosaveIntervalTime: number;
             };
             TXIN_OUTPOINT_TXID_BYTES: number;
@@ -185,5 +187,12 @@ export declare namespace SDK {
             };
         };
     };
+    let PlatformProtocol: any;
+    let Essentials: {
+        Buffer: typeof Buffer;
+    };
+    let Errors: {
+        StateTransitionBroadcastError: typeof StateTransitionBroadcastError;
+    };
 }
 export { SDK as default };

package/docs/README.md

@@ -1,8 +1,8 @@
 # Dash SDK
 
 [![NPM Version](https://img.shields.io/npm/v/dash)](https://www.npmjs.org/package/dash)
-[![Build Status](https://github.com/dashevo/js-dash-sdk/actions/workflows/test_and_release.yml/badge.svg)](https://github.com/dashevo/dashcore-lib/actions/workflows/test_and_release.yml)
-[![Release Date](https://img.shields.io/github/release-date/dashevo/js-dash-sdk)](https://github.com/dashevo/js-dash-sdk/releases/latest)
+[![Build Status](https://github.com/dashevo/platform/actions/workflows/release.yml/badge.svg)](https://github.com/dashevo/platform/actions/workflows/release.yml)
+[![Release Date](https://img.shields.io/github/release-date/dashevo/platform)](https://github.com/dashevo/platform/releases/latest)
 [![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen)](https://github.com/RichardLitt/standard-readme)
 
 Dash library for JavaScript/TypeScript ecosystem (Wallet, DAPI, Primitives, BLS, ...)

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "dash",
-  "version": "3.23.0-dev.1",
+  "version": "3.23.0-dev.4",
   "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.4",
+    "@dashevo/dashcore-lib": "~0.19.39",
+    "@dashevo/dashpay-contract": "~0.23.0-dev.4",
+    "@dashevo/dpns-contract": "~0.23.0-dev.4",
+    "@dashevo/dpp": "~0.23.0-dev.4",
+    "@dashevo/grpc-common": "~0.23.0-dev.4",
+    "@dashevo/masternode-reward-shares-contract": "~0.23.0-dev.4",
+    "@dashevo/wallet-lib": "~7.23.0-dev.4",
     "bs58": "^4.0.1",
     "node-inspect-extracted": "^1.0.8"
   },
@@ -71,6 +72,7 @@
     "karma-mocha-reporter": "^2.2.5",
     "karma-webpack": "^5.0.0",
     "mocha": "^9.1.2",
+    "net": "^1.0.2",
     "nodemon": "^2.0.4",
     "os-browserify": "^0.3.0",
     "path-browserify": "^1.0.1",
@@ -81,6 +83,8 @@
     "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-mock-imports": "^1.3.0",

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,7 +1,4 @@
 import { Platform } from "../../Platform";
-import createAssetLockTransaction from "../../createAssetLockTransaction";
-import createIdentityCreateTransition from "./internal/createIdentityCreateTransition";
-import createAssetLockProof from "./internal/createAssetLockProof";
 import broadcastStateTransition from "../../broadcastStateTransition";
 
 /**
@@ -12,7 +9,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 +21,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 +42,14 @@ export default async function register(
       identityIndex,
     );
 
+    // Current identity object will not have metadata or balance information
+    const registeredIdentity = await this.identities.get(identity.getId().toString());
+
+    // 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;
 }