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

package/docs/getting-started/quickstart.md

@@ -15,49 +15,32 @@ Let's create a Dash SDK client instance specifying both our mnemonic and the sch
 ```js
 const Dash = require('dash');
 const opts = {
-  apps: {
-    dashpay: {
-      contractId: '77w8Xqn25HwJhjodrHW133aXhjuTsTv9ozQaYpSHACE3',
-    },
-  },
   wallet: {
     mnemonic: "arena light cheap control apple buffalo indicate rare motor valid accident isolate",
   },
 };
 const client = new Dash.Client(opts);
-client.getWalletAccount().then(async (account) => {
+client.wallet.getAccount().then(async (account) => {
   // Do something
 })
 ```
 
-Quick note :
-
-- If no mnemonic is provided, the sub-instance `client.Wallet` will not be initialized (writing  capabilities of Dash Platform won't be usable).
+Quick note:
+If no `mnemonic` is provided or `mnemonic: null` is passed inside the `wallet` option, a new mnemonic will be generated.
 
-If you do not have a mnemonic, you can pass `null` to have one generated or omit that parameter to only use Dash.Client for `read-only` operations.
 
 ## Make a payment
 
 ```js
-client.getWalletAccount().then(async (account) => {
+client.wallet.getAccount().then(async (account) => {
   const transaction = account.createTransaction({
     recipient: 'yixnmigzC236WmTXp9SBZ42csyp9By6Hw8',
     amount: 0.12,
   });
-  account.broadcastTransaction(transaction);
+  await account.broadcastTransaction(transaction);
 });
 ```
 
-## Read a document
+## Interact with Dash Platform
 
-At the time of writing, you will need to have registered a data contract yourself. See [publishing a new contract](../examples/publishing-a-new-contract.md).
-
-```js
-
-client.platform.documents.get(
-  'tutorialContract.note',
-  { limit: 1 }, // Only retrieve 1 document
-).then(async (documents) => {
-  console.log(documents);
-});
-```
+See the [Tutorial section](https://dashplatform.readme.io/docs/tutorials-introduction) of the Dash Platform documentation for examples.

package/docs/getting-started/with-typescript.md

@@ -5,14 +5,17 @@ Create an index.ts file
 ```js
 import Dash from 'dash';
 const clientOpts = {
-  network: 'testnet',
   wallet: {
     mnemonic: null, // Will generate a new address, you should keep it.
   },
 };
 const client = new Dash.Client(clientOpts);
 
-client.isReady().then(()=> console.log('isReady'));
+const initializeAccount = async () => {
+  const account = await client.wallet.getAccount();
+  const balance = account.getTotalBalance();
+  console.log(`Account balance: ${balance}`)
+}
 ```
 
 Have a following `tsconfig.json` file

package/docs/index.html

@@ -14,10 +14,10 @@
 <script>
   window.$docsify = {
     alias: {
-      '.*?/changelog': 'https://raw.githubusercontent.com/dashevo/js-dash-sdk/master/CHANGELOG.md',
+      '.*?/changelog': 'https://github.com/dashevo/platform/tree/master/packages/js-dash-sdk/CHANGELOG.md',
     },
     name: 'Dash SDK',
-    repo: 'https://github.com/dashevo/js-dash-sdk',
+    repo: 'https://github.com/dashevo/platform/tree/master/packages/js-dash-sdk',
     loadSidebar: "_sidebar.md",
     maxLevel: 4,
     subMaxLevel: 2,

package/docs/platform/about-platform.md

@@ -1,12 +1,12 @@
 ### About Dash Platform
 
-The Dash Platform provide a technology stack on top of the Dash Network allowing the creation of feature-rich decentralized application. 
+The Dash Platform provides a technology stack on the top of Dash Network that allows creation of feature-rich decentralized applications. 
 
-You will learn more on the [Dash Platform Documentation - What is Dash Platform ?](https://dashplatform.readme.io/docs/introduction-what-is-dash-platform).
+You can learn more from the [Dash Platform Documentation - What is Dash Platform?](https://dashplatform.readme.io/docs/introduction-what-is-dash-platform)
 
 ### Platform components
 
-- DAPI: A decentralized API that is being run by all Masternode and offer a gRPC endpoints for retrieving payment chain metadata (block, transaction), aswell as application data (documents, contracts, identities). 
-- Drive : Application chain storage layer. Where the data defined by a Data Contract are managed.
-- DPNS : A Naming serving
+- DAPI: A decentralized API that runs on all Masternodes and offers gRPC endpoints for retrieving payment chain metadata (blocks, transactions), as well as application data (documents, contracts, identities). 
+- Drive: Application chain storage layer where the data defined by Data Contracts is stored and managed.
+- DPNS: Naming service provided by a Dash Platform App 
 

package/docs/platform/contracts/about-contracts.md

@@ -1,6 +1,6 @@
 ## What is a contract 
 
-Contracts are a [registered](../../examples/publishing-a-new-contract.md) set of rules defined in a [JSON Application Schema](../../getting-started/core-concepts#schemas).
+Contracts are registered sets of rules defined in a [JSON Application Schema](../../getting-started/core-concepts#app-schema-and-contracts).
 
-See more on the Dash Platform documentation about [Data Contract](https://dashplatform.readme.io/docs/explanation-platform-protocol-data-contract).
+See the Dash Platform documentation for more information about [Data Contracts](https://dashplatform.readme.io/docs/explanation-platform-protocol-data-contract).
 

package/docs/platform/contracts/create.md

@@ -3,10 +3,10 @@
 
 Parameters: 
 
-| parameters               | type              | required           | Description                                                       |  
-|--------------------------|-------------------|------------------	| -----------------------------------------------------------------	|
+| parameters               | type              | required           | Description                                                                                                            |  
+|--------------------------|-------------------|------------------	|------------------------------------------------------------------------------------------------------------------------|
 | **contractDefinitions**  | JSONDataContract  | yes                | The defined [JSON Application Schema](https://dashplatform.readme.io/docs/explanation-platform-protocol-data-contract) |
-| **identity**             | Identity          | yes                | A valid [registered `application` identity](../identities/register.md) |
+| **identity**             | Identity          | yes                | A valid [registered `application` identity](../identities/register.md)                                        |
 
 **Example**:
 
@@ -31,6 +31,6 @@ Parameters:
   const validationResult = client.platform.dpp.dataContract.validate(contract);
 ```
 
-**Note**: When your contract is created, it will only exist locally, use the [broadcast](../contracts/broadcast.md) method to register it.  
+**Note**: When your contract is created, it will only exist locally. Use the [publish](/contracts/publish.md) method to register it.  
 
-Returns : Contract.
+Returns: Contract.

package/docs/platform/contracts/get.md

@@ -9,4 +9,4 @@ Parameters:
 
 **Example**: `await client.platform.contracts.get('77w8Xqn25HwJhjodrHW133aXhjuTsTv9ozQaYpSHACE3')`
 
-Returns : Contract (or `null` if it's not a registered contract).
+Returns: Contract (or `null` if it's not a registered contract).

package/docs/platform/contracts/publish.md

@@ -3,8 +3,8 @@
 
 Parameters:
 
-| parameters                | type      | required       | Description                                                                   |
-|---------------------------|-----------|----------------| ------------------------------------------------------------------------------|
+| parameters                | type      | required       | Description                                                                     |
+|---------------------------|-----------|----------------|---------------------------------------------------------------------------------|
 | **contract**              | Contract  | yes            | A valid [created contract](../contracts/create.md)                     |
 | **identity**              | Identity  | yes            | A valid [registered `application` identity](../identities/register.md) |
 
@@ -14,7 +14,7 @@ const identityId = '';// Your identity identifier.
 const identity = await client.platform.identities.get(identityId);
 // See the contract.create documentation for more on how to create a dataContract
 const contract = await client.platform.contracts.create(contractDefinitions, identity);
-await platform.contracts.publish(contract, identity);
+await client.platform.contracts.publish(contract, identity);
 ```
 
 Returns : DataContractCreateTransition.

package/docs/platform/contracts/update.md

@@ -8,7 +8,4 @@ Parameters:
 | **contract**              | Contract  | yes            | A valid [created contract](/platform/contracts/create.md)                     |
 | **identity**              | Identity  | yes            | A valid [registered `application` identity](/platform/identities/register.md) |
 
-**Example**:
-You may check [following document](/examples/updating-a-contract.md) for an example on how to update a contract.
-
-Returns : DataContractUpdateTransition.
+Returns: DataContractUpdateTransition.

package/docs/platform/documents/broadcast.md

@@ -3,13 +3,13 @@
 
 Parameters: 
 
-| parameters                 | type       | required | Description                                                                 |  
-|----------------------------|------------|----------| ----------------------------------------------------------------------------|
-| **documents**              | Object     | yes      |                                                                             |
-| **documents.create**       | Document[] | no       | array of valid [created document](../documents/create.md) to create  |
-| **documents.replace**      | Document[] | no       | array of valid [created document](../documents/create.md) to replace |
-| **documents.delete**       | Document[] | no       | array of valid [created document](../documents/create.md) to delete  |
-| **identity**               | Identity   | yes      | A valid [registered identity](../identities/register.md)             |
+| parameters                 | type       | required | Description                                                                  |  
+|----------------------------|------------|----------|------------------------------------------------------------------------------|
+| **documents**              | Object     | yes      |                                                                              |
+| **documents.create**       | Document[] | no       | array of valid [created document](../documents/create.md) to create |
+| **documents.replace**      | Document[] | no       | array of valid [created document](../documents/create.md) to replace         |
+| **documents.delete**       | Document[] | no       | array of valid [created document](../documents/create.md) to delete          |
+| **identity**               | Identity   | yes      | A valid [registered identity](../identities/register.md)                     |
 
 
 **Example**:
@@ -17,13 +17,13 @@ Parameters:
 const identityId = '';// Your identity identifier
 const identity = await client.platform.identities.get(identityId);
 
-const helloWorldDocument = await platform.documents.create(
-      // Assume a contract helloWorldContract is registered with a field note
-      'helloWorldContract.note',
-      identity,
-     { message: 'Hello World'},
-  );
+const helloWorldDocument = await client.platform.documents.create(
+    // Assuming a contract tutorialContract is registered with a field note
+    'tutorialContract.note',
+    identity,
+    { message: 'Hello World'},
+);
 
-await platform.documents.broadcast({create: [helloWorldDocument]}, identity);
+await client.platform.documents.broadcast({ create: [helloWorldDocument] }, identity);
 ```
-Returns : documents.
+Returns: documents.

package/docs/platform/documents/create.md

@@ -3,18 +3,18 @@
 
 Parameters: 
 
-| parameters        | type    | required            | Description                                                       |  
-|-------------------|---------|------------------	| -----------------------------------------------------------------	|
+| parameters        | type    | required            | Description                                                        |  
+|-------------------|---------|------------------	|--------------------------------------------------------------------|
 | **dotLocator**    | string  | yes                 | Field of a specific application, under the form `appName.fieldName` |
-| **identity**      | Identity| yes                 | A valid [registered identity](../identities/register.md) |
-| **docOpts**       | Object  | yes                 | A valid data that match the data contract structure |
+| **identity**      | Identity| yes                 | A valid [registered identity](../identities/register.md)   |
+| **docOpts**       | Object  | yes                 | A valid data that match the data contract structure                |
 
 **Example**: 
 ```js
 const identityId = '';// Your identity identifier
 const identity = await client.platform.identities.get(identityId);
 
-const helloWorldDocument = await platform.documents.create(
+const helloWorldDocument = await client.platform.documents.create(
       // Assume a contract helloWorldContract is registered with a field note
       'helloWorldContract.note',
       identity,

package/docs/platform/documents/get.md

@@ -1,12 +1,12 @@
-**Usage**: `client.platform.documents.get(dotLocator, opts)`    
+**Usage**: `client.platform.documents.get(typeLocator, opts)`    
 **Description**: This method will allow you to fetch back documents matching the provided parameters. 
 
 Parameters: 
 
-| parameters        | type    | required         | Description                                                        |  
-|-------------------|---------|------------------| -------------------------------------------------------------------|
-| **dotLocator**    | string  | yes              | Field of a specific application, under the form `appName.fieldName`|
-| **opts**          | object  | no (default: {}) | Query options of the request                                       |
+| parameters      | type    | required         | Description                                                        |  
+|-----------------|---------|------------------| -------------------------------------------------------------------|
+| **typeLocator** | string  | yes              | Field of a specific application, under the form `appName.fieldName`|
+| **opts**        | object  | no (default: {}) | Query options of the request                                       |
 
 **Queries options**:
 
@@ -18,6 +18,7 @@ Parameters:
 | **startAt**       | integer | no               | number of objects to skip                                         |
 | **startAfter**    | integer | no               | exclusive skip                                                    |
 
+Learn more about query syntax at https://dashplatform.readme.io/docs/reference-query-syntax
 
 **Example**: 
 ```js

package/docs/platform/identities/about-identity.md

@@ -1,7 +1,7 @@
 ## What is an identity 
 
 An Identity is a blockchain-based identifier for individuals (users) and applications.  
-Identity is the atomic element that linked with additional applications can be extended to provide new functionality.
+Identities are the atomic element that, when linked with additional applications, can be extended to provide new functionality.
 
 Read more on the Dash Platform documentation about [Identity](https://dashplatform.readme.io/docs/explanation-identity).     
 You might also want to consult the usage for the [DPNS Name Service](../names/about-dpns.md) in order to attach a name to your created identity.

package/docs/platform/identities/get.md

@@ -9,4 +9,4 @@ Parameters:
 
 **Example**: `await client.platform.identities.get('3GegupTgRfdN9JMS8R6QXF3B2VbZtiw63eyudh1oMJAk')`
 
-Returns : Identity (or `null` if it does not exist).
+Returns: Identity (or `null` if it does not exist).

package/docs/platform/identities/register.md

@@ -11,4 +11,4 @@ Parameters:
 
 **Note**: The created identity will be associated to the active account. You might want to know more about how to [change your active account](../../examples/use-different-account.md).  
 
-Returns : Identity.
+Returns: Identity.

package/docs/platform/identities/topUp.md

@@ -14,9 +14,9 @@ Parameters:
 ```js 
 const identityId = '';// Your identity identifier
 const identity = await client.platform.identities.get(identityId);
-await platform.identities.topUp(identity, 10000);
+await client.platform.identities.topUp(identity.getId(), 10000);
 
 console.log(`New identity balance: ${identity.balance}`)
 ```
 
-Returns : Boolean.
+Returns: Boolean.

package/docs/platform/names/about-dpns.md

@@ -4,6 +4,6 @@ DPNS is a special Dash Platform Application that is intended to provide a naming
 
 Decoupling name from the blockchain identity enables a unique user experience coupled with the highest security while remaining compatible with [Decentralized Identifiers](https://www.w3.org/TR/did-core/).
 
-Limitation : max length of 63 characters on charset `0-9`,`A-Z`(case insensitive), `-`.
+Limitation: max length of 63 characters on charset `0-9`,`A-Z`(case insensitive), `-`.
 
 Domain names are linked to an Identity.

package/docs/platform/names/register.md

@@ -1,17 +1,17 @@
-**Usage**: `client.platform.names.register(name, identity)`    
+**Usage**: `client.platform.names.register(name, records, identity)`    
 **Description**: This method will create a DPNS record matching your identity to the user or appname defined.
 
 Parameters: 
 
-| parameters                       | type      | required       | Description                                                                   |  
-|----------------------------------|-----------|----------------| ----------------------------------------------------------------------------- |
+| parameters                       | type      | required       | Description                                                                                                                                                                                 |  
+|----------------------------------|-----------|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | **name**                         | String    | yes            | An alphanumeric (1-63 character) value used for human-identification (can contain `-` but not as the first or last character). If a name with no parent domain is entered, '.dash' is used. |
-| **records**                      | Object    | yes            | records object having only one of the following items                         |
-| **records.dashUniqueIdentityId** | String    | no             | Unique Identity ID for this name record                                       |
-| **records.dashAliasIdentityId**  | String    | no             | Used to signify that this name is the alias for another id                    |
-| **identity**                     | Identity  | yes            | A valid [registered identity](../identities/register.md)               |
+| **records**                      | Object    | yes            | records object having only one of the following items                                                                                                                                       |
+| **records.dashUniqueIdentityId** | String    | no             | Unique Identity ID for this name record                                                                                                                                                     |
+| **records.dashAliasIdentityId**  | String    | no             | Used to signify that this name is the alias for another id                                                                                                                                  |
+| **identity**                     | Identity  | yes            | A valid [registered identity](../identities/register.md)                                                                                                                           |
 
 
-**Example**: `await client.platform.identities.register('alice', { dashUniqueIdentityId: identity.getId() }, identity)`
+**Example**: `await client.platform.names.register('alice', { dashUniqueIdentityId: identity.getId() }, identity)`
 
-Return: the created domain document
+Returns: the created domain document

package/docs/platform/names/resolve.md

@@ -1,4 +1,4 @@
-**Usage**: `client.platform.names.resolve(name.domain)`    
+**Usage**: `client.platform.names.resolve('<name>.dash')`    
 **Description**: This method will allow you to resolve a DPNS record from its humanized name. 
 
 Parameters: 

package/docs/platform/names/resolveByRecord.md

@@ -1,18 +1,19 @@
-**Usage**: `client.platform.names.resolve(name.domain)`    
-**Description**: This method will allow you to resolve a DPNS record from its identity ID. 
+**Usage**: `client.platform.names.resolveByRecord(record, value)`    
+**Description**: This method will allow you to resolve a DPNS record by identity ID. 
 
 Parameters: 
 
-| parameters                | type      | required       | Description                                                                   |  
-|---------------------------|-----------|----------------| ----------------------------------------------------------------------------- |
-| **name**                  | String    | yes            | An alphanumeric (2-63) value used for human-identification (can contains `-`) |
+| parameters | type      | required       | Description                                                          |  
+|------------|-----------|----------------|----------------------------------------------------------------------|
+| **record** | String    | yes            | Type of the record (`dashUniqueIdentityId` or `dashAliasIdentityId`) |
+| **value**  | String    | yes            | Identifier value for the record                                      |
 
 **Example**: 
 
-This example will describe how to resolve names by the identity id, but other records field will works too.  
+This example will describe how to resolve names by the dash unique identity id.  
 ```js
 const identityId = '3ge4yjGinQDhxh2aVpyLTQaoka45BkijkoybfAkDepoN';
-const document = await client.platform.names.resolveByRecord('dashIdentity',identityId);
+const document = await client.platform.names.resolveByRecord('dashUniqueIdentityId', identityId);
 ```
 
-Returns : array of Document.
+Returns: array of Document.

package/docs/platform/names/search.md

@@ -19,4 +19,4 @@ const parentDomain = 'dash';
 const document = await client.platform.names.search(labelPrefix, parentDomain);
 ```
 
-Returns : Documents matching the label prefix on the parent domain.
+Returns: Documents matching the label prefix on the parent domain.

package/docs/usage/dashcorelib-primitives.md

@@ -1,13 +1,30 @@
+# Dashcore Lib primitives
+
+All Dashcore lib primitives are exposed via the `Core` namespace.
+
+```js
+const Dash = require('dash');
+const {
+  Core: {
+    Block,
+    Transaction,
+    Address,
+    // ...
+  }
+} = Dash;
+```
+
 ## Transaction 
 
-The Transaction primitive allows easy creation and manipulation of transactions. It also allows signing when provided with a privatekey.  
+The Transaction primitive allows creating and manipulating transactions. It also allows signing transactions with a private key.  
 Supports fee control and input/output access (which allows passing a specific script).
+
 ```js
-import { Transaction } from 'dash';
+const { Transaction } = Dash.Core;
 const tx = new Transaction(txProps)
 ```
 
-Access the [Transaction documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/transaction.md)
+Access the [Transaction documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/transaction.md)
 
 ## Address
 
@@ -15,100 +32,94 @@ Standardized representation of a Dash Address. Address can be instantiated from
 Pay-to-script-hash (P2SH) multi-signature addresses from an array of PublicKeys are also supported.  
 
 ```js
-import { Address } from 'dash';
+const { Address } = Dash.Core;
 ```
 
-Access the [Address documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/address.md)
+Access the [Address documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/address.md)
 
 ## Block
 
-Given a hexadecimal string representation of the block as input, the Block class allows you to have a deserialized representation of a Block or its header. It also allows validating the transactions in the block against the header merkle root.
+Given a binary representation of the block as input, the Block class allows you to have a deserialized representation of a Block or its header. It also allows validating the transactions in the block against the header merkle root.
 
-Transactions of the block can also be explored by iterating over elements in array (`block.transactions`).  
+The block's transactions can also be explored by iterating over elements in array (`block.transactions`).  
 
-`import { Block } from 'dash'`
+`const { Block } = Dash.Core;`
 
-Access the [Block documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/block.md)
+Access the [Block documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/block.md)
 
 ## UnspentOutput
 
 Representation of an UnspentOutput (also called UTXO as in Unspent Transaction Output).  
 Mostly useful in association with a Transaction and for Scripts. 
 
-`import { UnspentOutput } from 'dash'`
+`const { UnspentOutput } = Dash.Core.Transaction;`
 
-Access the [UnspentOutput documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/unspentoutput.md)
+Access the [UnspentOutput documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/unspentoutput.md)
 
 ## HDPublicKey
 
 Hierarchical Deterministic (HD) version of the PublicKey.  
 Used internally by Wallet-lib and for exchange between peers (DashPay)
 
-`import { HDPublicKey } from 'dash'`
+const { HDPublicKey } = Dash.Core;`
 
-Access the [HDKeys documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/hierarchical.md)
+Access the [HDKeys documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/hierarchical.md#hdpublickey)
 
 ## HDPrivateKey
 
 Hierarchical Deterministic (HD) version of the PrivateKey.  
 Used internally by Wallet-lib.
 
-`import { HDPrivateKey } from 'dash'`
+`const { HDPrivateKey } = Dash.Core;`
 
-Access the [HDKeys documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/hierarchical.md)
+Access the [HDKeys documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/hierarchical.md#hdprivatekey)
 
 ## PublicKey
 
-`import { PublicKey } from 'dash'`
+`const { PublicKey } = Dash.Core;`
 
-Access the [PublicKey documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/publickey.md)
+Access the [PublicKey documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/publickey.md)
 
 ## PrivateKey
 
-`import { PrivateKey } from 'dash'`
+`const { PrivateKey } = Dash.Core;`
 
-Access the [PrivateKey documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/privatekey.md)
+Access the [PrivateKey documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/privatekey.md)
 
 ## Mnemonic
 
 Implementation of [BIP39 Mnemonic code for generative deterministic keys](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).  
-Allow to generate random mnemonic on the language set needed, validate a mnemonic or get the HDPrivateKey associated.  
+Generates a random mnemonic with the chosen language, validates a mnemonic or returns the associated HDPrivateKey.  
 
-`import { Mnemonic } from 'dash'`
+`const { Mnemonic } = Dash.Core;`
 
-Access the [Mnemonic documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/mnemonic.md)
+Access the [Mnemonic documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/mnemonic.md)
 
 ## Network
 
-A representation of the internal parameters relative to the network used. By default, all primitives works with 'livenet', this class allow to have an testnet instance to used on the other primitives (such as Addresses), or for Wallet-lib.
+A representation of the internal parameters relative to the selected network. By default, all primitives works with 'livenet'.
 
-`import { Network } from 'dash'`
+`const { Network } = Dash.Core;`
 
 
-Access the [Network documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/networks.md)
+Access the [Network documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/networks.md)
 
 ## Script
 
-In Dash, transaction have in their inputs and outputs some script, very simple programming language with a stack-based evaluation and which is not Turing Complete.
-A valid Transaction is a transaction which output script are evaluated as valid.  
-
-Some operations of this language, such as OP_RETURN has been used to store hashes and B64 data on the payment chain.  
-Learn more on our walkthrough [Transaction script manipulation with the OP_RETURN example](/docs/walkthroughs/op_return/or_return.md)
-
-`import { Script } from 'dash'`
+`const { Script } = Dash.Core.Transaction;`
 
-Access the [Script documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/script.md)
+Access the [Script documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/script.md)
 
 
 ## Input
 
-`import { Input } from 'dash'`
+`const { Input } = Dash.Core.Transaction;`
 
-Access the [Transaction documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/transaction.md)
+Access the [Transaction documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/transaction.md#adding-inputs)
 
 
 ## Output
 
-`import { Output } from 'dash'`
+`const { Output } = Dash.Core.Transaction;`
 
-Access the [Transaction documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/transaction.md)
+Access the [Transaction documentation on dashevo/dashcore-lib](https://github.com/dashevo/dashcore-lib/blob/master/docs/core-concepts/transaction.md#handling-outputs)

package/docs/wallet/about-wallet-lib.md

@@ -1,7 +1,7 @@
 ### About Wallet-lib 
 
-When Dash.Client is initiated with a `mnemonic` property, a wallet instance is automatically created accessible via `client.wallet` as well as an `client.account` instance. 
+When Dash.Client is initiated with a `mnemonic` property, a wallet instance becomes accessible via `client.wallet` property.
 
-In order to ensure the sync-up with the network has happened, you will need to wait for the method `client.isReady()` to resolve. 
+To initialize the wallet account and synchronize with the network, use `client.wallet.getAccount()`.
 
-You will find else where the [complete documentation of Wallet-lib](https://github.com/dashevo/platform/tree/master/packages/wallet-lib), as we only cover the most basic pieces in this documentation.
+Find out more about the Wallet in its [complete documentation](https://dashevo.github.io/platform/Wallet-library/)

package/docs/wallet/accounts.md

@@ -1,7 +1,9 @@
 ## Getting an account
 
-A Wallet is actually a holders of multiple Account that hold the keys needed to make a payment.  
-So the first thing will be on accessing your account : 
+When Wallet is initialized with `mnemonic`, it holds multiple Accounts according to BIP44. 
+Each Account holds the keys needed to make a payments from it.
+
+Wallet's `getAccount` method used to access an account:
 
 ```js
 const client = new Dash.Client({
@@ -9,13 +11,15 @@ const client = new Dash.Client({
     mnemonic: "maximum blast eight orchard waste wood gospel siren parent deer athlete impact",
   },
 });
-client.isReady().then(()=>{
-  const {account} = client;
-  // Do something with account
-});
+
+const account = await client.wallet.getAccount()
+// Do something with account
 ```
 
 As optional parameter, an integer representing the account `index` can be passed as parameter. By default, index account on call is 0.
+```
+client.wallet.getAccount({ index: 1 })
+```
 
-You will also see that we wait for isReady to resolve before making any operation. This allow us to access an account instance that will have synced-up with network and that our UTXOS set are ready to be used for payment/signing.  
+Awaiting for the `getAccount()` promise is necessary to ensure the wallet is synced-up with the network and make sure that the UTXO set is ready to be used for payment/signing.