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

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,81 +1,40 @@
 # 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)
+[![Release Packages](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, ...)
 
-Dash library allows you to connect to DAPI and receive or broadcast payments on the Dash Network, manage identifies, register data contracts, retrieve or submit documents on the Dash Platform, all within a single library.
+Dash library provides access via [DAPI](https://dashplatform.readme.io/docs/explanation-dapi) to use both the Dash Core network and Dash Platform on [supported networks](https://github.com/dashevo/platform/#supported-networks). The Dash Core network can be used to broadcast and receive payments. Dash Platform can be used to manage identities, register data contracts for applications, and submit or retrieve application data via documents.
 
 ## Install
 
-### Browser
-
-```html
-<script src="https://unpkg.com/dash"></script>
-```
-
-### Node
-
+### From NPM
 In order to use this library, you will need to add our [NPM package](https://www.npmjs.com/dash) to your project.
 
-Having [NodeJS](https://nodejs.org/) installed, just type :
+Having [NodeJS](https://nodejs.org/) installed, just type:
 
 ```bash
 npm install dash
 ```
 
-## Usage
-
-```js
-const Dash = require('dash');
-
-const client = new Dash.Client({
-  network: 'evonet',
-  wallet: {
-    mnemonic: 'arena light cheap control apple buffalo indicate rare motor valid accident isolate',
-  },
-});
-
-// Accessing an account allows you to transact with the Dash Network
-client.getWalletAccount().then(async (account) => {
-  console.log('Funding address', account.getUnusedAddress().address);
-
-  const balance = account.getConfirmedBalance();
-  console.log('Confirmed Balance', balance);
-
-  if (balance > 0) {
-    // Creating an identity is the basis of all interactions with the Dash Platform
-    const identity = await client.platform.identities.register();
-
-    // Prepare a new document containing a simple hello world sent to a hypothetical tutorial contract
-    const document = await client.platform.documents.create(
-      'tutorialContract.note',
-      identity,
-      { message: 'Hello World' },
-    );
-
-    // Broadcast the document into a new state transition
-    await client.platform.documents.broadcast({ create: [document] }, identity);
-  }
-});
+### From unpkg
+```html
+<script src="https://unpkg.com/dash"></script>
 ```
 
-### Use-cases examples
+### Usage examples
 
 - [Generate a mnemonic](examples/generate-a-new-mnemonic.md)
 - [Receive money and display balance](examples/receive-money-and-check-balance.md)
 - [Pay to another address](examples/pay-to-another-address.md)
-- [Use a local evonet](examples/use-local-evonet.md)
-- [Publishing a new contract](examples/publishing-a-new-contract.md)
 - [Use another BIP44 account](examples/use-different-account.md)
 
-### Tutorial
+### Dash Platform Tutorials
 
-- [Register an identity](https://dashplatform.readme.io/docs/tutorial-register-an-identity)
-- [Register a Name for an Identity](https://dashplatform.readme.io/docs/tutorial-register-a-name-for-an-identity)
+See the [Tutorial section](https://dashplatform.readme.io/docs/tutorials-introduction) of the Dash Platform documentation for examples.
 
 ## Licence
 

package/docs/_sidebar.md

@@ -4,32 +4,15 @@
     - [Working with multiple apps](getting-started/multiple-apps.md)
     - [Dash Platform Applications](getting-started/dash-platform-applications.md)
     - [About Schemas](getting-started/about-schemas.md)
-    - [With TypeScript](getting-started/with-typescript.md)
 
 - Examples
     - [Generate a mnemonic](/examples/generate-a-new-mnemonic.md)
     - [Receive money and display balance](/examples/receive-money-and-check-balance.md)
     - [Pay to another address](/examples/pay-to-another-address.md)
-    - [Use a local evonet](/examples/use-local-evonet.md)
     - [Fetch an identity from its name](/examples/fetch-an-identity-from-its-name.md)
-    - [Publishing new contract](/examples/publishing-a-new-contract.md)
-    - [Updating an existing contract](/examples/updating-a-contract.md)
     - [Use another BIP44 account](/examples/use-different-account.md)
     - [Sign and verify messages](/examples/sign-and-verify-messages.md)
 
-- Tutorial
-    - [Register an identity](https://dashplatform.readme.io/docs/tutorial-register-an-identity)
-    - [Register a Name for an Identity](https://dashplatform.readme.io/docs/tutorial-register-a-name-for-an-identity)
-
-- Snippets
-    - [Create and fund wallet](https://github.com/dashevo/DashJS/tree/master/examples/node/create-and-fund-wallet.js)
-    - [Register identity](https://github.com/dashevo/DashJS/tree/master/examples/node/register-identity.js)
-    - [Register name](https://github.com/dashevo/DashJS/tree/master/examples/node/register-name.js)
-    - [Retrieve Contract](https://github.com/dashevo/DashJS/tree/master/examples/node/retrieve-contract.js)
-    - [Retrieve Documents](https://github.com/dashevo/DashJS/tree/master/examples/node/retrieve-documents.js)
-    - [Retrieve Identity](https://github.com/dashevo/DashJS/tree/master/examples/node/retrieve-identity.js)
-    - [Retrieve Name](https://github.com/dashevo/DashJS/tree/master/examples/node/retrieve-name.js)
-
 - Usage
     - [DAPI](usage/dapi.md)
     - [Platform](platform/about-platform.md)

package/docs/examples/fetch-an-identity-from-its-name.md

@@ -1,7 +1,7 @@
-## Fetching an identity from it's name
+## Fetching an identity from its name
 
-Assuming you have created an identity and attached a name to it (see how to [register an identity](https://dashplatform.readme.io/docs/tutorial-register-an-identity) and how to [attach it to a name](https://dashplatform.readme.io/docs/tutorial-register-a-name-for-an-identity).   
-You will then be able to directly recover an identity from its names. See below: 
+Assuming you have created an identity and attached a name to it (see how to [register an identity](https://dashplatform.readme.io/docs/tutorial-register-an-identity) and how to [attach it to a name](https://dashplatform.readme.io/docs/tutorial-register-a-name-for-an-identity)),
+you will then be able to directly recover an identity from its names. See below: 
 
 ```js
 const client = new Dash.Client({
@@ -12,11 +12,7 @@ const client = new Dash.Client({
 
 // This is the name previously registered in DPNS.
 const identityName = 'alice';
-client.isReady().then(getIdentity);
 
-async function getIdentity() {
-    const {identities, names} = client.platform;
-    const identityId = (await names.get(identityName)).data.records.dashIdentity;
-    const identity = await identities.get(identityId);
-}
+const nameDocument = await client.platform.names.resolve(`${identityName}.dash`);
+const identity = await client.platform.identities.get(nameDocument.ownerId);
 ```

package/docs/examples/generate-a-new-mnemonic.md

@@ -25,7 +25,7 @@ console.log({mnemonic});
 const Dash = require("dash");
 const {Mnemonic} = Dash.Core;
 
-const mnemnonic = new Mnemonic.toString()
+const mnemnonic = new Mnemonic().toString()
 ```
 
 ### Language selection 

package/docs/examples/pay-to-another-address.md

@@ -4,22 +4,25 @@ In order to pay, you need to have an [existing balance](../examples/receive-mone
 The below code will allow you to pay to a single address a specific amount of satoshis.
 
 ```js
-const Dash = require("dash");
-const mnemonic = ''// your mnemonic here.
+const Dash = require('dash');
+
+const mnemonic = ''; // your mnemonic here.
 const client = new Dash.Client({
-  mnemonic,
+  wallet: {
+    mnemonic,
+  },
 });
 
-client.isReady().then(payToRecipient);
-
-async function payToRecipient() {
-    const {account} = client;
-    const transaction = account.createTransaction({
-      recipient:"yNPbcFfabtNmmxKdGwhHomdYfVs6gikbPf",
-      satoshis:10000
-    });
-    const transactionId = await account.broadcastTransaction(transaction);
+async function payToRecipient(account) {
+  const transaction = account.createTransaction({
+    recipient: 'yNPbcFfabtNmmxKdGwhHomdYfVs6gikbPf',
+    satoshis: 10000,
+  });
+  const transactionId = await account.broadcastTransaction(transaction);
 }
+
+client.wallet.getAccount().then(payToRecipient);
+
 ```
 
-See more on create [transaction options here](https://dashevo.github.io/wallet-lib/#/usage/account?id=create-transaction).
+See more on create [transaction options here](https://dashevo.github.io/platform/Wallet-library/account/createTransaction/).

package/docs/examples/receive-money-and-check-balance.md

@@ -1,76 +1,92 @@
 ## Receive money and display balance
 
-Initialize the SDK Client with your [generated mnemonic](../examples/generate-a-new-mnemonic.md) passed as an option.  
-By default, the SDK Client will work on Evonet, the only network having DAPI at the time of writing.
+Initialize the SDK Client with your [generated mnemonic](../examples/generate-a-new-mnemonic.md) passed as an option.
 
 ```js
 const Dash = require("dash");
 const mnemonic = ''// your mnemonic here.
 const client = new Dash.Client({
-  mnemonic,
+  wallet: {
+    mnemonic,
+  }
 });
+
+async function showBalance() {
+  const account = await client.wallet.getAccount();
+  const totalBalance = account.getTotalBalance();
+  console.log(`Account's total balance: ${totalBalance} duffs`);
+}
 ```
 
-Having set up your `client` instance, you be able to access the `account` and `wallet` instance generated from your mnemonic.
+Having your `client` instance set up, you will be able to access the `account` and `wallet` instance generated from your mnemonic.
 
-You can read more on [how to use a different account](../examples/use-different-account.md) as by default, you are on the first BIP44 account. 
+By default `getAccount()` returns the first BIP44 account. 
+You can read more on [how to use a different account](../examples/use-different-account.md).
 
 
 ## Generate a receiving address
 
-In a client, you have two different type of payment address, `external`, which are those used to receive you money from outside.   
-And `internal`, which is used internally for the chance of a payment you do to someone.  
-For your privacy, you might want to generate a new address at each payment.
+Dash wallet supports two different types of addresses: 
+- `external` addresses used for receiving funds from other addresses
+- `internal` addresses used for change outputs of outgoing transactions  
+- 
+For your privacy, you might want to generate a new address for each payment:
 
 ```js
-   client.isReady().then(generateNewAddress);
-   async function generateNewAddress(){
-     const {address} = client.account.getUnusedAddress();
-     console.log(`New address: ${address}`)
-   }
+async function generateUnusedAddress() {
+  const account = await client.wallet.getAccount();
+  const { address } = account.getUnusedAddress();
+  console.log(`Unused external address: ${address}`);
+}
 ```
 
 This above code will generate a new unique (never used) address. 
 
-## Display your balance
+## Displaying your balance
+
+_Dash Wallet returns the balance in duffs (1 Dash is equal to 100.000.000 duffs)_
 
-There are three different balances, the `getTotalBalance()` that gives you the sum of `confirmed` and `unconfirmed` transactions (not included in a block). ```
-You probably most of the time want to rely of your confirmed balance when you check fund before a payment.  
-Value is in satoshis (smallest unit).
+`getTotalBalance()` function takes into account `confirmed` and `unconfirmed` transactions (not included in a block).
+It is recommended to check the confirmed balance before making a payment:
 
 ```js
-   client.isReady().then(displayBalance);
-   async function displayBalance(){
-     const balance = client.account.getConfirmedBalance();
-     console.log(`Balance: ${balance}`)
-   }
+async function showBalance() {
+  const account = await client.wallet.getAccount();
+  const totalBalance = account.getTotalBalance();
+  const confirmedBalance = account.getConfirmedBalance();
+  const unconfirmedBalance = account.getUnconfirmedBalance();
+  console.log(`Account balance:
+    Confirmed: ${confirmedBalance}
+    Unconfirmed: ${unconfirmedBalance}
+    Total: ${totalBalance}
+  `);
+}
 ```
-
-Or you might want to look-up for the `.getUnconfirmedBalance()` to have only the unconfirmed amount. 
+ 
 
 ## Listen for event on received transaction 
 
-When a new unconfirmed transaction is received, you can receive notice of it, to perform a validation on the address and perform an action if needed.   
+When a new unconfirmed transaction is received, you can receive an event, and then validate the address or perform an action if needed.   
 
 ```js
-  client.account.events.on('FETCHED/UNCONFIRMED_TRANSACTION', (data)=>{
-    console.log('FETCHED/UNCONFIRMED_TRANSACTION');
-    console.dir(data)
+// FETCHED/UNCONFIRMED_TRANSACTION event is currently disabled
+
+async function listenUnconfirmedTransaction() {
+  const account = await client.wallet.getAccount();
+  account.on('FETCHED/UNCONFIRMED_TRANSACTION', (data) => {
+    console.dir(data);
   });
+}
 ```
 
-The return element can be used in coordination with a `new Dash.Core.Transaction()`
-
-## Get an address 
-
-In case you want to retrieve a specific address index : 
-
-```js
-  const {address} = client.account.getAddress(2);
-```
+## Get address at specific index 
 
-## Get an internal address 
+In case you want to retrieve an address at specific index: 
 
 ```js
-  const {address} = client.account.getAddress(2, 'internal');
+async function getAddressAtIndex() {
+  const account = await client.wallet.getAccount();
+  const { address: externalAddress } = account.getAddress(2);
+  const { address: internalAddress } = account.getAddress(2, 'internal');
+}
 ```

package/docs/examples/sign-and-verify-messages.md

@@ -1,14 +1,24 @@
 ## Sign and verify messages
 
-Dash SDK exports the Message constructor inside the Core namespace `new Dash.Core.Message`.   
-
-You can refer to its documentation : https://github.com/dashevo/dashcore-message/blob/master/README.md
+Dash SDK exports the Message constructor inside the Core namespace `new Dash.Core.Message`
 
 ```js
-const pk = new Dash.Core.PrivateKey();
-const message = new Dash.Core.Message('hello, world');
-const signed = account.sign(message, pk);
-const verify = message.verify(pk.toAddress().toString(), signed.toString());
-```
+const Dash = require('dash');
+
+const mnemonic = '';
 
-See [code snippet](https://github.com/dashevo/platform/blob/master/packages/js-dash-sdk/examples/node/sign-and-verify-messages.js).
+const client = new Dash.Client({
+  wallet: {
+    mnemonic,
+  },
+});
+
+async function signAndVerify() {
+  const account = await client.wallet.getAccount();
+
+  const pk = new Dash.Core.PrivateKey();
+  const message = new Dash.Core.Message('hello, world');
+  const signed = account.sign(message, pk);
+  const verified = message.verify(pk.toAddress().toString(), signed.toString());
+}
+```

package/docs/examples/use-different-account.md

@@ -1,23 +1,11 @@
 ## Using a different account 
 
-Because the Client uses mostly a mnemonic to initialize itself, you can access to the other account defined by the [BIP44](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki).
+Clients initialized with a mnemonic support multiple accounts as defined in [BIP44](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki).
 
-As an helper for users and internal reference for `client.platform`. 
-By default, accessing to `client.account` is equivalent of `client.wallet.getAccount({index:0})`. 
-Therefore usage might varies if you need to deal with platform or not. 
+By default `client.wallet.getAccount()` returns the account at index `0`.
 
-
-### Access to account without platform
-```js  
-   const account = await client.getWalletAccount({index:1});
+To access other accounts, pass the `index` option:
 ```
+const secondAccount = await client.wallet.getAccount({ index: 1 })
+``` 
 
-### Access to account with platform.
-
-When calling `getWalletAccount`, the client will locally store the index options you have passed to it, which will be used for your platform related calls.
-
-```js
-async function changeAccount(){
-   await client.getWalletAccount({index:2});
-}
-```

package/docs/getting-started/core-concepts.md

@@ -8,21 +8,22 @@ At the core of Dash is the Payment Chain. In order to be able to transact on it,
 
 In order to access your UTXO, you will have to provide a valid mnemonic that will unlock the Wallet and automatically fetch the associated UTXOs.
 
-When an SDK instance is created, you can access your wallet via the `client.wallet` variable, with the [wallet-lib Wallet doc](https://dashevo.github.io/wallet-lib/#/usage/wallet)
+When an SDK instance is created, you can access your wallet via the `client.wallet` variable. (Check [wallet-lib documentation](https://dashevo.github.io/platform/Wallet-library/) for more details)
 
 ## Account
 
-Since the introduction of deterministic wallets ([BIP44](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki)), a Wallet is a representation of multiple accounts.
+Since the introduction of deterministic wallets ([BIP44](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki)), a wallet is represented by multiple accounts.
 
 It is the instance you will use most of the time for receiving or broadcasting payments.
 
-You can access your account with `client.getWalletAccount()` and see [how to use a different account](../examples/use-different-account.md) if you need to get a specific account index.
+You can access your account with `client.getWalletAccount()`. See [how to use a different account](../examples/use-different-account.md) if you need to get an account at a specific index.
 
 ## App Schema and Contracts
 
-The Dash Platform Chain, provides to developers the ability to create applications. Each application requires a set of rules and conditions describe in a portable document in the form of a JSON Schema.
+The Dash Platform Chain provides developers with the ability to create applications. 
+Each application requires a set of rules and conditions described as a portable document in the form of a JSON Schema.
 
 When registered, those applications schemas are called contracts and contains a contractId (namespace : `client.platform.contracts`).  
 By default, this library supports Dash Platform Name Service (DPNS) (to attach a name to an identity), under the namespace `client.platform.names` for testnet.  
 
-You can read more on [how to use DPNS on a local Evonet devnet](../examples/use-local-evonet.md) or [how to use multiple apps](../getting-started/multiple-apps.md).
+See: [how to use multiple apps](../getting-started/multiple-apps.md)

package/docs/getting-started/dash-platform-applications.md

@@ -4,4 +4,4 @@ DPNS is handled in the Dash SDK Client under the namespace `client.platform.name
 
 ## DashPay
 
-Registration of the contract on Evonet occurred in Q4 2020. Its functionality is not incorporated with the Dash SDK at this time.
+The DashPay contract is registered on testnet under contract id `Bwr4WHCPz5rFVAD87RqTs3izo4zpzwsEdKPWUT1NS1C7`. Its functionality is not incorporated with the Dash SDK at this time.