diff --git a/docs.json b/docs.json
new file mode 100644
index 000000000..7cf928535
--- /dev/null
+++ b/docs.json
@@ -0,0 +1,46 @@
+{
+	"name": "eosjs",
+	"generators": [
+    {
+			"name": "collate_markdown",
+			"options": {
+				"docs_dir": "docs"
+			}
+		},
+		{
+			"name": "typedoc",
+			"options": {
+        "theme": "markdown",
+        "exclude": ["**/index*","**/*.test.ts","**/rpc-web*"],
+        "ignoreCompilerErrors": true,
+        "includeDeclarations": false,
+        "excludeExternals": true,
+        "excludeProtected": true,
+        "excludePrivate": true,
+        "typescript": {
+          "include": [
+            "src/**/*.js"
+          ]
+        }
+      }
+		}
+	],
+  "filters": [
+    {
+      "name": "search_replace",
+      "options": {
+        "search": "numeric.md#",
+        "replace": "#",
+        "filepattern": "numeric.md"
+      }
+    },
+    {
+      "name": "search_replace",
+      "options": {
+        "search": "serialize.md#",
+        "replace": "#",
+        "filepattern": "serialize.md"
+      }
+    }
+  ]
+}
diff --git a/docs/00_introduction.md b/docs/00_introduction.md
new file mode 100644
index 000000000..b8a654291
--- /dev/null
+++ b/docs/00_introduction.md
@@ -0,0 +1,8 @@
+`eosjs` is a Javascript library which provides an API for integrating with EOSIO-based blockchains using the [EOSIO Nodeos RPC API](https://developers.eos.io/eosio-nodeos/reference).  The documentation for `eosjs` is structured in the following way:
+
+* [Installation](02_installation.md) explains how to install `eosjs` using `npm` or `yarn`.
+* [Basic Usage](basic-usage/) provides information related to importing `eosjs` in various Javascript environments.  The [basic-usage](basic-usage/03_basic-usage.md) document specifically provides brief explanations of the components provided by `eosjs` as well as their typical use cases.
+* [FAQ](faq/) provides answers to frequently asked questions surrounding the `eosjs` software.
+* [How-To Guides](how-to-guides/) provides how-tos on everything from getting block information to proposing and signing multi-sig transactions.
+* [Troubleshooting](troubleshooting/) provides possible exceptions encountered when developing with `eosjs` and their most common causes.
+* [Technical Overview](01_technical-overview.md) provides a high-level overview of how `eosjs` works.
\ No newline at end of file
diff --git a/docs/01_technical-overview.md b/docs/01_technical-overview.md
new file mode 100644
index 000000000..27ba182e1
--- /dev/null
+++ b/docs/01_technical-overview.md
@@ -0,0 +1,23 @@
+As stated in the [introduction](00_introduction.md), `eosjs` integrates with EOSIO-based blockchains using the [EOSIO Nodeos RPC API](https://developers.eos.io/eosio-nodeos/reference).
+
+In general, there are two objects that are used to interact with a blockchain via `eosjs`: the `JsonRpc` object, and the `Api` object.
+
+## JsonRpc
+The `JsonRpc` object is typically used when signing is not necessary.  Some examples include [getting block information](how-to-guides/00_how-to-get-block-information.md), [getting transaction information](how-to-guides/02_how-to-get-transaction-information.md), or [getting table information](how-to-guides/09_how-to-get-table-information.md).  
+
+The requests made by the `JsonRpc` object will either use a built-in `fetch` library, or [the `fetch` library passed in by the user](basic-usage/01_commonjs.md) to issue requests to the endpoint specified when instantiating the `JsonRpc` object.  When the various methods ([get_abi](https://github.com/EOSIO/eosjs/blob/master/src/eosjs-jsonrpc.ts#L66), [get_account](https://github.com/EOSIO/eosjs/blob/master/src/eosjs-jsonrpc.ts#L71), [get_block_header_state](https://github.com/EOSIO/eosjs/blob/master/src/eosjs-jsonrpc.ts#L76), etc) of the `JsonRpc` object are invoked, the calls are delegated to the `JsonRpc` object's [fetch function](https://github.com/EOSIO/eosjs/blob/master/src/eosjs-jsonrpc.ts#L42-L63), which in turn, delegate the requests to the `fetch` library.
+
+## Api
+The `Api` object is typically used when transacting on an EOSIO-based blockchain.  Some examples include [staking](how-to-guides/03_how-to-stake.md), [creating an account](how-to-guides/05_how-to-create-an-account.md), or [proposing multi-sig transactions](how-to-guides/13_how-to-propose-a-multisig-transaction.md).
+
+The typical use of the `Api` object is to call its [`transact` method](https://github.com/EOSIO/eosjs/blob/master/src/eosjs-api.ts#L214-L254).  This method performs a number of steps depending on the input passed to it:
+
+* The `transact` method first checks if the **chainId** was set in the `Api` constructor, and if not, uses the [`JsonRpc` object's](#jsonrpc) [`get_info`](https://github.com/EOSIO/eosjs/blob/master/src/eosjs-jsonrpc.ts#L101) method to retrieve the **chainId**.  
+* The `transact` method then checks if the `blocksBehind` and `expiration` fields are set and well-formed in the [optional configuration object, as specified in *How to Submit a Transaction*](how-to-guides/01_how-to-submit-a-transaction.md#).  
+    * If so, the block *blocksBehind* the head block retrieved from [`JsonRpc`'s `get_info`](https://github.com/EOSIO/eosjs/blob/master/src/eosjs-jsonrpc.ts#L101) is set as the reference block and the transaction header is serialized using this reference block and the `expiration` field.
+* The `transact` method then checks if the appropriate TAPOS fields are present in the transaction ([they can either be specified directly in the transaction or in the optional configuration object](how-to-guides/01_how-to-submit-a-transaction.md#)) and throws an Error if not.
+* The necessary `abi`s for a transaction are then retrieved for the case when `transact` is expected to sign the transaction.
+* The `actions` are serialized using the `eosjs-serialize` `ser` object.
+* The entire transaction is then [serialized](https://github.com/EOSIO/eosjs/blob/master/src/eosjs-api.ts#L154-L166), also using the `eosjs-serialize` `ser` object.
+* The transaction is then optionally signed, using the `signatureProvider`, the previously retrieved `abi`s, the private keys of the `signatureProvider`, and the `chainId`.
+* The transaction is then optionally broadcasted using `JsonRpc`'s [`push_transaction`](https://github.com/EOSIO/eosjs/blob/master/src/eosjs-jsonrpc.ts#L187).
\ No newline at end of file
diff --git a/docs/02_installation.md b/docs/02_installation.md
new file mode 100644
index 000000000..4c0b4e9ac
--- /dev/null
+++ b/docs/02_installation.md
@@ -0,0 +1,9 @@
+`eosjs` can be installed via [`yarn`](https://yarnpkg.com/en/)
+```javascript
+yarn add eosjs
+```
+
+or [`npm`](https://www.npmjs.com/)
+```javascript
+npm install eosjs
+```
\ No newline at end of file
diff --git a/docs/2.-Transaction-Examples.md b/docs/2.-Transaction-Examples.md
deleted file mode 100644
index d59dbd9d3..000000000
--- a/docs/2.-Transaction-Examples.md
+++ /dev/null
@@ -1,178 +0,0 @@
-# Transactions
-
-To send transactions and trigger actions on the blockchain, you must have an instance of `Api`.
-
-The signature provider must contain the private keys corresponding to the actors and permission requirements of the actions being executed.
-
-
-## CommonJS
-
-```javascript
-const { Api, JsonRpc } = require('eosjs');
-const { JsSignatureProvider } = require('eosjs/dist/eosjs-jssig');  // development only
-const fetch = require('node-fetch');                                // node only
-const { TextDecoder, TextEncoder } = require('util');               // node only
-const { TextEncoder, TextDecoder } = require('text-encoding');      // React Native, IE11, and Edge Browsers only
-
-const privateKeys = [privateKey1];
-
-const signatureProvider = new JsSignatureProvider(privateKeys);
-const rpc = new JsonRpc('http://127.0.0.1:8888', { fetch });
-const api = new Api({ rpc, signatureProvider, textDecoder: new TextDecoder(), textEncoder: new TextEncoder() });
-```
-
-## ES Modules
-
-```javascript
-import { Api, JsonRpc } from 'eosjs';
-import { JsSignatureProvider } from 'eosjs/dist/eosjs-jssig';  // development only
-
-const privateKeys = [privateKey1];
-
-const signatureProvider = new JsSignatureProvider(privateKeys);
-const rpc = new JsonRpc('http://127.0.0.1:8888');
-const api = new Api({ rpc, signatureProvider })
-```
-
-## Examples
-
-### Buy ram
-
-```javascript
-const result = await api.transact({
-  actions: [{
-    account: 'eosio',
-    name: 'buyrambytes',
-    authorization: [{
-      actor: 'useraaaaaaaa',
-      permission: 'active',
-    }],
-    data: {
-      payer: 'useraaaaaaaa',
-      receiver: 'useraaaaaaaa',
-      bytes: 8192,
-    },
-  }]
-}, {
-  blocksBehind: 3,
-  expireSeconds: 30,
-});
-```
-
-### Stake
-
-```javascript
-const result = await api.transact({
-  actions: [{
-    account: 'eosio',
-    name: 'delegatebw',
-    authorization: [{
-      actor: 'useraaaaaaaa',
-      permission: 'active',
-    }],
-    data: {
-      from: 'useraaaaaaaa',
-      receiver: 'useraaaaaaaa',
-      stake_net_quantity: '1.0000 SYS',
-      stake_cpu_quantity: '1.0000 SYS',
-      transfer: false,
-    }
-  }]
-}, {
-  blocksBehind: 3,
-  expireSeconds: 30,
-});
-```
-
-## Example: Unstake
-
-```javascript
-const result = await api.transact({
-  actions: [{
-    account: 'eosio',
-    name: 'undelegatebw',
-    authorization: [{
-      actor: 'useraaaaaaaa',
-      permission: 'active',
-    }],
-    data: {
-      from: 'useraaaaaaaa',
-      receiver: 'useraaaaaaaa',
-      unstake_net_quantity: '1.0000 SYS',
-      unstake_cpu_quantity: '1.0000 SYS',
-      transfer: false,
-    }
-  }]
-}, {
-  blocksBehind: 3,
-  expireSeconds: 30,
-});
-```
-
-### Create New Account (multiple actions)
-
-```javascript
-const result = await api.transact({
-  actions: [{
-    account: 'eosio',
-    name: 'newaccount',
-    authorization: [{
-      actor: 'useraaaaaaaa',
-      permission: 'active',
-    }],
-    data: {
-      creator: 'useraaaaaaaa',
-      name: 'mynewaccount',
-      owner: {
-        threshold: 1,
-        keys: [{
-          key: 'PUB_R1_6FPFZqw5ahYrR9jD96yDbbDNTdKtNqRbze6oTDLntrsANgQKZu',
-          weight: 1
-        }],
-        accounts: [],
-        waits: []
-      },
-      active: {
-        threshold: 1,
-        keys: [{
-          key: 'PUB_R1_6FPFZqw5ahYrR9jD96yDbbDNTdKtNqRbze6oTDLntrsANgQKZu',
-          weight: 1
-        }],
-        accounts: [],
-        waits: []
-      },
-    },
-  },
-  {
-    account: 'eosio',
-    name: 'buyrambytes',
-    authorization: [{
-      actor: 'useraaaaaaaa',
-      permission: 'active',
-    }],
-    data: {
-      payer: 'useraaaaaaaa',
-      receiver: 'mynewaccount',
-      bytes: 8192,
-    },
-  },
-  {
-    account: 'eosio',
-    name: 'delegatebw',
-    authorization: [{
-      actor: 'useraaaaaaaa',
-      permission: 'active',
-    }],
-    data: {
-      from: 'useraaaaaaaa',
-      receiver: 'mynewaccount',
-      stake_net_quantity: '1.0000 SYS',
-      stake_cpu_quantity: '1.0000 SYS',
-      transfer: false,
-    }
-  }]
-}, {
-  blocksBehind: 3,
-  expireSeconds: 30,
-});
-```
diff --git a/docs/4.-Reading blockchain-Examples.md b/docs/4.-Reading blockchain-Examples.md
deleted file mode 100644
index ec3a96170..000000000
--- a/docs/4.-Reading blockchain-Examples.md	
+++ /dev/null
@@ -1,164 +0,0 @@
-# Reading blockchain
-
-Reading blockchain state only requires an instance of `JsonRpc` connected to a node.
-
-```javascript
-const { JsonRpc } = require('eosjs');
-const fetch = require('node-fetch');           // node only; not needed in browsers
-const rpc = new JsonRpc('http://localhost:8888', { fetch });
-```
-
-## Examples
-
-### Get table rows
-
-Get the first 10 token balances of account _testacc_.
-
-```javascript
-const resp = await rpc.get_table_rows({
-    json: true,              // Get the response as json
-    code: 'eosio.token',     // Contract that we target
-    scope: 'testacc',        // Account that owns the data
-    table: 'accounts',       // Table name
-    limit: 10,               // Maximum number of rows that we want to get
-    reverse: false,          // Optional: Get reversed data
-    show_payer: false,       // Optional: Show ram payer
-});
-
-console.log(resp.rows);
-```
-Output:
-
-```json
-{
-  "rows": [{
-      "balance": "100.0000 HAK"
-    }
-  ],
-  "more": false
-}
-```
-
-### Get one row by index
-
-```javascript
-const resp = await rpc.get_table_rows({
-    json: true,                 // Get the response as json
-    code: 'contract',           // Contract that we target
-    scope: 'contract',          // Account that owns the data
-    table: 'profiles',          // Table name
-    lower_bound: 'testacc',     // Table primary key value
-    limit: 1,                   // Here we limit to 1 to get only the
-    reverse: false,             // Optional: Get reversed data
-    show_payer: false,          // Optional: Show ram payer
-});
-console.log(resp.rows);
-```
-Output:
-
-```json
-{
-  "rows": [{
-      "user": "testacc",
-      "age": 21,
-      "surname": "Martin"
-    }
-  ],
-  "more": false
-}
-```
-
-### Get one row by secondary index
-
-```javascript
-const resp = await rpc.get_table_rows({
-    json: true,                 // Get the response as json
-    code: 'contract',           // Contract that we target
-    scope: 'contract',          // Account that owns the data
-    table: 'profiles',          // Table name
-    table_key: 'age',           // Table secondaray key name
-    lower_bound: 21,            // Table secondary key value
-    limit: 1,                   // Here we limit to 1 to get only row
-    reverse: false,             // Optional: Get reversed data
-    show_payer: false,          // Optional: Show ram payer
-});
-console.log(resp.rows);
-```
-Output:
-
-```json
-{
-  "rows": [{
-      "user": "testacc",
-      "age": 21,
-      "surname": "Martin"
-    }
-  ],
-  "more": false
-}
-```
-
-### Get currency balance
-
-```javascript
-console.log(await rpc.get_currency_balance('eosio.token', 'testacc', 'HAK'));
-```
-Output:
-
-```json
-[ "1000000000.0000 HAK" ]
-```
-
-### Get account info
-
-```javascript
-console.log(await rpc.get_account('testacc'));
-```
-Output:
-
-```json
-{ "account_name": "testacc",
-  "head_block_num": 1079,
-  "head_block_time": "2018-11-10T00:45:53.500",
-  "privileged": false,
-  "last_code_update": "1970-01-01T00:00:00.000",
-  "created": "2018-11-10T00:37:05.000",
-  "ram_quota": -1,
-  "net_weight": -1,
-  "cpu_weight": -1,
-  "net_limit": { "used": -1, "available": -1, "max": -1 },
-  "cpu_limit": { "used": -1, "available": -1, "max": -1 },
-  "ram_usage": 2724,
-  "permissions":
-   [ { "perm_name": "active", "parent": "owner", "required_auth": [] },
-     { "perm_name": "owner", "parent": "", "required_auth": [] } ],
-  "total_resources": null,
-  "self_delegated_bandwidth": null,
-  "refund_request": null,
-  "voter_info": null }
-```
-
-### Get block
-
-```javascript
-console.log(await rpc.get_block(1));
-```
-Output:
-
-```json
-{ "timestamp": "2018-06-01T12:00:00.000",
-  "producer": "",
-  "confirmed": 1,
-  "previous": "0000000000000000000000000000000000000000000000000000000000000000",
-  "transaction_mroot": "0000000000000000000000000000000000000000000000000000000000000000",
-  "action_mroot": "cf057bbfb72640471fd910bcb67639c22df9f92470936cddc1ade0e2f2e7dc4f",
-  "schedule_version": 0,
-  "new_producers": null,
-  "header_extensions": [],
-  "producer_signature": "SIG_K1_111111111111111111111111111111111111111111111111111111111111111116uk5ne",
-  "transactions": [],
-  "block_extensions": [],
-  "id": "00000001bcf2f448225d099685f14da76803028926af04d2607eafcf609c265c",
-  "block_num": 1,
-  "ref_block_prefix": 2517196066 }
-```
diff --git a/docs/3.-Browsers.md b/docs/basic-usage/00_browser.md
similarity index 72%
rename from docs/3.-Browsers.md
rename to docs/basic-usage/00_browser.md
index 35a485069..90275f30a 100644
--- a/docs/3.-Browsers.md
+++ b/docs/basic-usage/00_browser.md
@@ -1,16 +1,14 @@
-# Browsers
-
-## Usage
-`npm run build-web` or `yarn build-web`
-
-Reuse the `api` object for all transactions; it caches ABIs to reduce network usage. Only call `new eosjs_api.Api(...)` once.
-
+To use `eosjs` in a browser run `npm run build-web` or `yarn build-web`.  This will create the `dist-web` folder and web distribution modules.
 ```html
 <pre style="width: 100%; height: 100%; margin:0px; "></pre>
 
 <script src='dist-web/eosjs-api.js'></script>
 <script src='dist-web/eosjs-jsonrpc.js'></script>
 <script src='dist-web/eosjs-jssig.js'></script>
+```
+
+To cache ABIs and reduce network usage, reuse the `api` object for all transactions.  This implies you should only call `new eosjs_api.Api(...)` once.
+```html
 <script>
   let pre = document.getElementsByTagName('pre')[0];
   const defaultPrivateKey = "5JtUScZK2XEp3g9gh7F8bwtPTRAkASmNrrftmx4AxDKD5K4zDnr"; // bob
@@ -50,8 +48,7 @@ Reuse the `api` object for all transactions; it caches ABIs to reduce network us
 ```
 
 ## Debugging
-
 If you would like readable source files for debugging, change the file reference to the `-debug.js` files inside `dist-web/debug` directory.  These files should only be used for development as they are over 10 times as large as the minified versions, and importing the debug versions will increase loading times for the end user.
 
 ## IE11 and Edge Support
-If you need to support IE11 or Edge you will also need to install a text-encoding polyfill as eosjs Signing is dependent on the TextEncoder which IE11 and Edge do not provide.  Pass the TextEncoder and TextDecoder to the API constructor as demonstrated in the [ES 2015 example](#node-es-2015).  Refer to the documentation here https://github.com/inexorabletash/text-encoding to determine the best way to include it in your project.
+If you need to support IE11 or Edge you will also need to install a text-encoding polyfill, as eosjs Signing is dependent on the TextEncoder which IE11 and Edge do not provide.  Pass the TextEncoder and TextDecoder to the API constructor as demonstrated in the [CommonJS example](01_commonjs.md).  Refer to the documentation [here](https://github.com/inexorabletash/text-encoding) to determine the best way to include it in your project.
\ No newline at end of file
diff --git a/docs/basic-usage/01_commonjs.md b/docs/basic-usage/01_commonjs.md
new file mode 100644
index 000000000..8f0dce52d
--- /dev/null
+++ b/docs/basic-usage/01_commonjs.md
@@ -0,0 +1,13 @@
+To import `eosjs` using commonjs syntax follow the code below.
+```javascript
+const { Api, JsonRpc } = require('eosjs');
+const { JsSignatureProvider } = require('eosjs/dist/eosjs-jssig');  // development only
+const fetch = require('node-fetch'); //node only
+const { TextDecoder, TextEncoder } = require('util'); //node only
+
+const privateKeys = [privateKey1];
+
+const signatureProvider = new JsSignatureProvider(privateKeys);
+const rpc = new JsonRpc('http://127.0.0.1:8888', { fetch }); //required to read blockchain state
+const api = new Api({ rpc, signatureProvider, textDecoder: new TextDecoder(), textEncoder: new TextEncoder() }); //required to submit transactions
+```
\ No newline at end of file
diff --git a/docs/basic-usage/02_es-modules.md b/docs/basic-usage/02_es-modules.md
new file mode 100644
index 000000000..55f8adc44
--- /dev/null
+++ b/docs/basic-usage/02_es-modules.md
@@ -0,0 +1,11 @@
+To import `eosjs` using [ES module syntax](https://en.wikipedia.org/wiki/ECMAScript) the following code is provided.
+```javascript
+import { Api, JsonRpc } from 'eosjs';
+import { JsSignatureProvider } from 'eosjs/dist/eosjs-jssig';  // development only
+
+const privateKeys = [privateKey1];
+
+const signatureProvider = new JsSignatureProvider(privateKeys);
+const rpc = new JsonRpc('http://127.0.0.1:8888'); //required to read blockchain state
+const api = new Api({ rpc, signatureProvider }); //required to submit transactions
+```
\ No newline at end of file
diff --git a/docs/basic-usage/index.md b/docs/basic-usage/index.md
new file mode 100644
index 000000000..6c14e4d62
--- /dev/null
+++ b/docs/basic-usage/index.md
@@ -0,0 +1,16 @@
+The `eosjs` package provides two objects: an `Api` object and a `JsonRpc` object.  An explanation of their expected parameters and usage is provided below.
+
+## JsonRpc
+The `JsonRpc` object takes the node you wish to connect to in the form of a string as a required constructor argument, as well as an optional `fetch` object (see [CommonJS](01_commonjs.md) for an example).  
+
+Note that reading blockchain state requires only an instance of `JsonRpc` connected to a node and not the `Api` object.
+
+## Api
+To send transactions and trigger actions on the blockchain, you must have an instance of `Api`. This `Api` instance is required to receive a SignatureProvider object in it's constructor.
+
+The SignatureProvider object must contain the private keys corresponding to the actors and permission requirements of the actions being executed.
+
+## JsSignatureProvider
+The Api constructor requires a SignatureProvider. SignatureProviders implement the `dist/eosjs-api-interfaces.SignatureProvider` interface. For development purpose only, a `JsSignatureProvider` object is also provided via the `dist/eosjs-jssig` import to stand-in for an easy option for a signature provider during development, but should only be used in development, as it is not secure.
+
+In production code, it is recommended that you use a secure vault outside of the context of the webpage (which will also implement the `eosjs-api-interfaces.SignatureProvider` interface) to ensure security when signing transactions.
diff --git a/docs/faq/00_what-is-a-signature-provider.md b/docs/faq/00_what-is-a-signature-provider.md
new file mode 100644
index 000000000..110a60dd7
--- /dev/null
+++ b/docs/faq/00_what-is-a-signature-provider.md
@@ -0,0 +1,3 @@
+`eosjs` provides an example implementation of the [`SignatureProvider` interface](https://github.com/EOSIO/eosjs/blob/849c03992e6ce3cb4b6a11bf18ab17b62136e5c9/src/eosjs-api-interfaces.ts#L60) called [`JsSignatureProvider`](https://github.com/EOSIO/eosjs/blob/849c03992e6ce3cb4b6a11bf18ab17b62136e5c9/src/eosjs-jssig.ts#L11).
+
+Although `JsSignatureProvider` is insecure and should not be used in production, it provides a basic example of what a `SignatureProvider` is and does.  `JsSignatureProvider` simply takes a list of private keys as strings in its constructor and maps these private keys to their respective public keys.  When [`JsSignatureProvider`'s `sign`](https://github.com/EOSIO/eosjs/blob/849c03992e6ce3cb4b6a11bf18ab17b62136e5c9/src/eosjs-jssig.ts#L33) is called, a buffer of the `chainId` and `serializedTransaction` is created and [`eosjs-ecc`'s `ecc` object](https://github.com/EOSIO/eosjs-ecc/blob/7ec577cad54e17da6168fdfb11ec2b09d6f0e7f0/src/index.js#L4) is used to sign the buffer with the private key corresponding to the required public key.
\ No newline at end of file
diff --git a/docs/faq/01_example-signature-providers.md b/docs/faq/01_example-signature-providers.md
new file mode 100644
index 000000000..05162984a
--- /dev/null
+++ b/docs/faq/01_example-signature-providers.md
@@ -0,0 +1,3 @@
+Since it is not recommended that you use `JsSignatureProvider`, a list of `SignatureProvider`s is provided below, along with a link to the documentation:
+
+* [Ledger Signature Provider](https://github.com/EOSIO/eosjs-ledger-signature-provider)
\ No newline at end of file
diff --git a/docs/how-to-guides/00_how-to-get-block-information.md b/docs/how-to-guides/00_how-to-get-block-information.md
new file mode 100644
index 000000000..163d13c6c
--- /dev/null
+++ b/docs/how-to-guides/00_how-to-get-block-information.md
@@ -0,0 +1,27 @@
+To get block information call `get_block` on the rpc object passing in the block number as a required argument.
+```javascript
+(async () => { 
+  await rpc.get_block(1) //get the first block
+})();
+```
+
+The block data is returned as JSON.
+```json
+{ 
+  "timestamp": "2018-06-01T12:00:00.000",
+  "producer": "",
+  "confirmed": 1,
+  "previous": "0000000000000000000000000000000000000000000000000000000000000000",
+  "transaction_mroot": "0000000000000000000000000000000000000000000000000000000000000000",
+  "action_mroot": "cf057bbfb72640471fd910bcb67639c22df9f92470936cddc1ade0e2f2e7dc4f",
+  "schedule_version": 0,
+  "new_producers": null,
+  "header_extensions": [],
+  "producer_signature": "SIG_K1_111111111111111111111111111111111111111111111111111111111111111116uk5ne",
+  "transactions": [],
+  "block_extensions": [],
+  "id": "00000001bcf2f448225d099685f14da76803028926af04d2607eafcf609c265c",
+  "block_num": 1,
+  "ref_block_prefix": 2517196066 
+}
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/01_how-to-submit-a-transaction.md b/docs/how-to-guides/01_how-to-submit-a-transaction.md
new file mode 100644
index 000000000..31368d372
--- /dev/null
+++ b/docs/how-to-guides/01_how-to-submit-a-transaction.md
@@ -0,0 +1,75 @@
+To submit a transaction, call `transact` on the api object, passing in two parameters.
+
+The first parameter specifies the actions in the transaction, and their corresponding authorizations, as well as any data necessary for the action to execute.  An example for the [`buyrambytes` action](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.system/include/eosio.system/eosio.system.hpp#L1028) is shown below.
+```javascript
+{ 
+   actions: [{
+     account: 'eosio',
+     name: 'buyrambytes',
+     authorization: [{
+       actor: 'useraaaaaaaa',
+       permission: 'active',
+     }],
+     data: {
+       payer: 'useraaaaaaaa',
+       receiver: 'useraaaaaaaa',
+       bytes: 8192,
+     },
+   }]
+}
+```
+The second parameter is an [optional configuration object parameter](https://github.com/EOSIO/eosjs/blob/master/src/eosjs-api.ts#L215).  This optional parameter can override the default values of `broadcast: true` and `sign: true`, and can be used to fill [TAPOS](https://eosio.stackexchange.com/questions/2362/what-is-transaction-as-proof-of-stake-tapos-and-when-would-a-smart-contract) fields with the specified `blocksBehind` and `expireSeconds` if necessary.  These fields are required if the first parameter specified above does not itself contain the TAPOS fields `expiration`, `ref_block_num`, and `ref_block_prefix`.  In this case it does not, so the fields are necessary.
+```javascript
+{
+  blocksBehind: 3,
+  expireSeconds: 30,
+}
+```
+Below is a complete example transaction to call the `buyrambytes` action with `useraaaaaaaa`'s active permission, `useraaaaaaaa` is also both the payer and receiver of **8192** bytes of RAM.  
+The transaction will reference the block 3 blocks behind the head block, and will automatically expire the transaction 30 seconds after the time present in this referenced block.
+```javascript
+(async () => {
+  await api.transact({
+   actions: [{
+     account: 'eosio',
+     name: 'buyrambytes',
+     authorization: [{
+       actor: 'useraaaaaaaa',
+       permission: 'active',
+     }],
+     data: {
+       payer: 'useraaaaaaaa',
+       receiver: 'useraaaaaaaa',
+       bytes: 8192,
+     },
+   }]
+  }, {
+   blocksBehind: 3,
+   expireSeconds: 30,
+  });
+})();
+```
+
+Alternatively, the transaction could be submitted without the optional configuration object by specifying the TAPOS fields `expiration`, `ref_block_num`, and `ref_block_prefix` explicity in the action.
+```javascript
+(async () => {
+  await api.transact({
+   expiration: '2019-09-19T16:39:15',
+   ref_block_num: '50477227',
+   ref_block_prefix: '1022379673',
+   actions: [{
+     account: 'eosio',
+     name: 'buyrambytes',
+     authorization: [{
+       actor: 'useraaaaaaaa',
+       permission: 'active',
+     }],
+     data: {
+       payer: 'useraaaaaaaa',
+       receiver: 'useraaaaaaaa',
+       bytes: 8192,
+     },
+   }]
+  });
+})();
+```
diff --git a/docs/how-to-guides/02_how-to-get-transaction-information.md b/docs/how-to-guides/02_how-to-get-transaction-information.md
new file mode 100644
index 000000000..d9b06ea7a
--- /dev/null
+++ b/docs/how-to-guides/02_how-to-get-transaction-information.md
@@ -0,0 +1,40 @@
+**Note** that [`history_get_transaction`](https://github.com/EOSIO/eosjs/blob/849c03992e6ce3cb4b6a11bf18ab17b62136e5c9/src/eosjs-jsonrpc.ts#L205) below uses the deprecated `/v1/history/get_transaction` endpoint of a node.
+
+To get a transaction's information, call [`history_get_transaction`](https://github.com/EOSIO/eosjs/blob/849c03992e6ce3cb4b6a11bf18ab17b62136e5c9/src/eosjs-jsonrpc.ts#L205) on the rpc object passing in the transaction's id and optionally, it's block number as arguments.
+```javascript
+(async () => {
+  await rpc.history_get_transaction('b3598da4e007173e6d1b94d7be306299dd0a6813d114cf9a08c8e88a5756f1eb', 46632826)
+})();
+```
+
+The transaction info is returned as JSON.
+```javascript
+{
+  id: 'b3598da4e007173e6d1b94d7be306299dd0a6813d114cf9a08c8e88a5756f1eb',
+  trx: {
+    receipt: {
+      status: 'executed',
+      cpu_usage_us: 2070,
+      net_usage_words: 14,
+      trx: [Array]
+    },
+    trx: {
+      expiration: '2019-08-28T03:45:47',
+      ref_block_num: 36720,
+      ref_block_prefix: 654845510,
+      max_net_usage_words: 0,
+      max_cpu_usage_ms: 0,
+      delay_sec: 0,
+      context_free_actions: [],
+      actions: [Array],
+      transaction_extensions: [],
+      signatures: [Array],
+      context_free_data: []
+    }
+  },
+  block_time: '2019-08-28T03:45:21.500',
+  block_num: 46632826,
+  last_irreversible_block: 46784285,
+  traces: []
+}
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/03_how-to-stake.md b/docs/how-to-guides/03_how-to-stake.md
new file mode 100644
index 000000000..548ef9da9
--- /dev/null
+++ b/docs/how-to-guides/03_how-to-stake.md
@@ -0,0 +1,27 @@
+To stake resources, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`delegatebw`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.system/include/eosio.system/eosio.system.hpp#L692) action of the `eosio` account.
+
+In the example shown below `useraaaaaaaa` stakes **1.0000 SYS** of NET and CPU to the account `mynewaccount`.
+```javascript
+(async () => {
+  await api.transact({
+    actions: [{
+      account: 'eosio',
+      name: 'delegatebw',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: {
+        from: 'useraaaaaaaa',
+        receiver: 'mynewaccount',
+        stake_net_quantity: '1.0000 SYS',
+        stake_cpu_quantity: '1.0000 SYS',
+        transfer: false,
+      }
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+  });
+})();
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/04_how-to-unstake.md b/docs/how-to-guides/04_how-to-unstake.md
new file mode 100644
index 000000000..dc921af64
--- /dev/null
+++ b/docs/how-to-guides/04_how-to-unstake.md
@@ -0,0 +1,27 @@
+To unstake resources, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`undelegatebw`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.system/include/eosio.system/eosio.system.hpp#L1000) action of the `eosio` account.
+
+In the example shown below `useraaaaaaaa` unstakes **1.0000 SYS** of NET and CPU from the account `mynewaccount`.
+```javascript
+(async () => {
+  await api.transact({
+    actions: [{
+      account: 'eosio',
+      name: 'undelegatebw',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: {
+        from: 'useraaaaaaaa',
+        receiver: 'mynewaccount',
+        stake_net_quantity: '1.0000 SYS',
+        stake_cpu_quantity: '1.0000 SYS',
+        transfer: false,
+      }
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+  });
+})();
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/05_how-to-create-an-account.md b/docs/how-to-guides/05_how-to-create-an-account.md
new file mode 100644
index 000000000..432bf453a
--- /dev/null
+++ b/docs/how-to-guides/05_how-to-create-an-account.md
@@ -0,0 +1,147 @@
+To create a new account submit three actions to the `eosio` account using the `actions` array as shown in [how-to-submit-a-transaction](01_how-to-submit-a-transaction.md).
+
+## newaccount
+The first action is the [`newaccount`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.system/include/eosio.system/native.hpp#L178) action.  In the example shown below `useraaaaaaaa` creates new account `mynewaccount` with owner and active public key `PUB_R1_6FPFZqw5ahYrR9jD96yDbbDNTdKtNqRbze6oTDLntrsANgQKZu`.  Ideally, these should be different public keys.
+
+```javascript
+  {
+    account: 'eosio',
+    name: 'newaccount',
+    authorization: [{
+      actor: 'useraaaaaaaa',
+      permission: 'active',
+    }],
+    data: {
+      creator: 'useraaaaaaaa',
+      name: 'mynewaccount',
+      owner: {
+        threshold: 1,
+        keys: [{
+          key: 'PUB_R1_6FPFZqw5ahYrR9jD96yDbbDNTdKtNqRbze6oTDLntrsANgQKZu',
+          weight: 1
+        }],
+        accounts: [],
+        waits: []
+      },
+      active: {
+        threshold: 1,
+        keys: [{
+          key: 'PUB_R1_6FPFZqw5ahYrR9jD96yDbbDNTdKtNqRbze6oTDLntrsANgQKZu',
+          weight: 1
+        }],
+        accounts: [],
+        waits: []
+      },
+    }
+  }
+```
+
+## buyrambytes
+The second action is the [`buyrambytes`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.system/include/eosio.system/eosio.system.hpp#L1028) action.  In the example shown below `useraaaaaaaa` pays for **8192** bytes of RAM for the account `mynewaccount` created in the [first action](#newaccount).
+
+```javascript
+  {
+    account: 'eosio',
+    name: 'buyrambytes',
+    authorization: [{
+      actor: 'useraaaaaaaa',
+      permission: 'active',
+    }],
+    data: {
+      payer: 'useraaaaaaaa',
+      receiver: 'mynewaccount',
+      bytes: 8192,
+    },
+  }
+```
+
+## delegatebw
+The third action is the [`delegatebw`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.system/include/eosio.system/eosio.system.hpp#L692) action.  In the example shown below `useraaaaaaaa` delegates **1.0000 SYS** of NET and CPU to the account `mynewaccount` created in the [first action](#newaccount).
+```javascript
+  {
+    account: 'eosio',
+    name: 'delegatebw',
+    authorization: [{
+      actor: 'useraaaaaaaa',
+      permission: 'active',
+    }],
+    data: {
+      from: 'useraaaaaaaa',
+      receiver: 'mynewaccount',
+      stake_net_quantity: '1.0000 SYS',
+      stake_cpu_quantity: '1.0000 SYS',
+      transfer: false,
+    }
+  }
+```
+
+## Create An Account
+Below the three actions are submitted as one transaction using the `Api` object.
+
+```javascript
+(async () => {
+  await api.transact({
+    actions: [{
+      account: 'eosio',
+      name: 'newaccount',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: {
+        creator: 'useraaaaaaaa',
+        name: 'mynewaccount',
+        owner: {
+          threshold: 1,
+          keys: [{
+            key: 'PUB_R1_6FPFZqw5ahYrR9jD96yDbbDNTdKtNqRbze6oTDLntrsANgQKZu',
+            weight: 1
+          }],
+          accounts: [],
+          waits: []
+        },
+        active: {
+          threshold: 1,
+          keys: [{
+            key: 'PUB_R1_6FPFZqw5ahYrR9jD96yDbbDNTdKtNqRbze6oTDLntrsANgQKZu',
+            weight: 1
+          }],
+          accounts: [],
+          waits: []
+        },
+      },
+    },
+    {
+      account: 'eosio',
+      name: 'buyrambytes',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: {
+        payer: 'useraaaaaaaa',
+        receiver: 'mynewaccount',
+        bytes: 8192,
+      },
+    },
+    {
+      account: 'eosio',
+      name: 'delegatebw',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: {
+        from: 'useraaaaaaaa',
+        receiver: 'mynewaccount',
+        stake_net_quantity: '1.0000 SYS',
+        stake_cpu_quantity: '1.0000 SYS',
+        transfer: false,
+      }
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+  });
+})();
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/06_how-to-deploy-a-smart-contract.md b/docs/how-to-guides/06_how-to-deploy-a-smart-contract.md
new file mode 100644
index 000000000..dbd5e516f
--- /dev/null
+++ b/docs/how-to-guides/06_how-to-deploy-a-smart-contract.md
@@ -0,0 +1,167 @@
+In order to deploy a smart contract using `eosjs`, call the [`setcode`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.system/include/eosio.system/native.hpp#L294) followed by the [`setabi`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.system/include/eosio.system/native.hpp#L281) actions of the `eosio` account.
+
+## setcode
+`setcode` takes the name of the account where the smart contract will be deployed to and the smart contract **.wasm** file.  The smart contract **.wasm** file should be a hex string.  Assuming that a valid **.wasm** file is located at `/mypath/my_smart_contract.wasm`, converting a smart contract to a hex string can be accomplished using the code below.
+```javascript
+const fs = require('fs')
+const wasmFilePath = '/mypath/my_smart_contract.wasm'
+const wasmHexString = fs.readFileSync(wasmFilePath).toString('hex')
+```
+
+In the example shown below `useraaaaaaaa` sets the account `useraaaaaaaa`'s code to the smart contract located at `/mypath/my_smart_contract.wasm`'s hex string representation. 
+```javascript
+        {
+          account: 'eosio',
+          name: 'setcode',
+          authorization: [
+            {
+              actor: 'useraaaaaaaa',
+              permission: 'active',
+            },
+          ],
+          data: {
+            account: 'useraaaaaaaa',
+            code: wasmHexString,
+          },
+        }
+```
+
+## setabi
+`setabi` takes the name of the account where the smart contract will be deployed to and the serialized **.abi** file corresponding to the **.wasm** used in the [`setcode`](#setcode) action corresponding to this `setabi` action.  The following code is provided to serialize **.abi** files.
+
+```javascript
+const fs = require('fs')
+
+const buffer = new Serialize.SerialBuffer({
+    textEncoder: api.textEncoder,
+    textDecoder: api.textDecoder,
+})
+
+const abiFilePath = '/mypath/my_smart_contract.abi'
+let abiJSON = JSON.parse(fs.readFileSync(abiFilePath, 'utf8'))
+const abiDefinitions = api.abiTypes.get('abi_def')
+
+abiJSON = abiDefinitions.fields.reduce(
+    (acc, { name: fieldName }) =>
+        Object.assign(acc, { [fieldName]: acc[fieldName] || [] }),
+        abiJSON
+    )
+abiDefinitions.serialize(buffer, abiJSON)
+serializedAbiHexString = Buffer.from(buffer.asUint8Array()).toString('hex')
+```
+Note that the `api` object from [initialization](../basic-usage/01_commonjs.md) is used for it's `textEncoder`and `textDecoder` objects, as well as it's [`abiTypes`](https://github.com/EOSIO/eosjs/blob/849c03992e6ce3cb4b6a11bf18ab17b62136e5c9/src/eosjs-api.ts#L72) map.
+
+This line in particular:
+```javascript
+abiJSON = abiDefinitions.fields.reduce(
+    (acc, { name: fieldName }) =>
+        Object.assign(acc, { [fieldName]: acc[fieldName] || [] }),
+        abiJSON
+    )
+```
+ensures that the **.abi** file contains [the fields that an **.abi** file is expected to contain](https://github.com/EOSIO/eosjs/blob/849c03992e6ce3cb4b6a11bf18ab17b62136e5c9/src/abi.abi.json#L151).  Note that if an expected field is missing, the call to `serialize` will [throw an exception](https://github.com/EOSIO/eosjs/blob/849c03992e6ce3cb4b6a11bf18ab17b62136e5c9/src/eosjs-serialize.ts#L644) indicating the missing field.
+
+## Deploying a Smart Contract
+Below the two actions are submitted as one transaction using the `Api` object.
+```javascript
+(async () => {
+  await api.transact({
+      actions: [
+        {
+          account: 'eosio',
+          name: 'setcode',
+          authorization: [
+            {
+              actor: 'useraaaaaaaa',
+              permission: 'active',
+            },
+          ],
+          data: {
+            account: 'useraaaaaaaa',
+            code: wasmHexString,
+          },
+        },
+        {
+          account: 'eosio',
+          name: 'setabi',
+          authorization: [
+            {
+              actor: 'useraaaaaaaa',
+              permission: 'active',
+            },
+          ],
+          data: {
+            account: 'useraaaaaaaa',
+            abi: serializedAbiHexString,
+          },
+        },
+      ],
+    },
+    {
+      blocksBehind: 3,
+      expireSeconds: 30,
+    });
+})();
+```
+
+The entire code is provided below for reference.
+```javascript
+const wasmFilePath = '/mypath/my_smart_contract.wasm'
+const abiFilePath = '/mypath/my_smart_contract.abi'
+
+const wasmHexString = fs.readFileSync(wasmFilePath).toString('hex')
+
+const buffer = new Serialize.SerialBuffer({
+    textEncoder: api.textEncoder,
+    textDecoder: api.textDecoder,
+})
+
+let abiJSON = JSON.parse(fs.readFileSync(abiFilePath, 'utf8'))
+const abiDefinitions = api.abiTypes.get('abi_def')
+abiJSON = abiDefinitions.fields.reduce(
+    (acc, { name: fieldName }) =>
+        Object.assign(acc, { [fieldName]: acc[fieldName] || [] }),
+        abiJSON
+    )
+abiDefinitions.serialize(buffer, abiJSON)
+serializedAbiHexString = Buffer.from(buffer.asUint8Array()).toString('hex')
+
+await api.transact(
+    {
+      actions: [
+        {
+          account: 'eosio',
+          name: 'setcode',
+          authorization: [
+            {
+              actor: 'useraaaaaaaa',
+              permission: 'active',
+            },
+          ],
+          data: {
+            account: 'useraaaaaaaa',
+            code: wasmFilePath,
+          },
+        },
+        {
+          account: 'eosio',
+          name: 'setabi',
+          authorization: [
+            {
+              actor: 'useraaaaaaaa',
+              permission: 'active',
+            },
+          ],
+          data: {
+            account: 'useraaaaaaaa',
+            abi: serializedAbiHexString,
+          },
+        },
+      ],
+    },
+    {
+      blocksBehind: 3,
+      expireSeconds: 30,
+    }
+  )
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/07_how-to-get-account-information.md b/docs/how-to-guides/07_how-to-get-account-information.md
new file mode 100644
index 000000000..720f27ca1
--- /dev/null
+++ b/docs/how-to-guides/07_how-to-get-account-information.md
@@ -0,0 +1,29 @@
+To get a specific account's information call `get_account` on the rpc object passing in the account name as a function argument.
+```javascript
+(async () => {
+  await rpc.get_account('alice') //get alice's account info.  This assumes the account 'alice' has been created on the chain specified in the rpc object.
+})();
+```
+
+The account info is returned as JSON.
+```json
+{ "account_name": "testacc",
+  "head_block_num": 1079,
+  "head_block_time": "2018-11-10T00:45:53.500",
+  "privileged": false,
+  "last_code_update": "1970-01-01T00:00:00.000",
+  "created": "2018-11-10T00:37:05.000",
+  "ram_quota": -1,
+  "net_weight": -1,
+  "cpu_weight": -1,
+  "net_limit": { "used": -1, "available": -1, "max": -1 },
+  "cpu_limit": { "used": -1, "available": -1, "max": -1 },
+  "ram_usage": 2724,
+  "permissions":
+   [ { "perm_name": "active", "parent": "owner", "required_auth": [] },
+     { "perm_name": "owner", "parent": "", "required_auth": [] } ],
+  "total_resources": null,
+  "self_delegated_bandwidth": null,
+  "refund_request": null,
+  "voter_info": null }
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/08_how-to-transfer-an-eosio-token.md b/docs/how-to-guides/08_how-to-transfer-an-eosio-token.md
new file mode 100644
index 000000000..8f1d184d3
--- /dev/null
+++ b/docs/how-to-guides/08_how-to-transfer-an-eosio-token.md
@@ -0,0 +1,26 @@
+To transfer an eosio token, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`transfer`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.token/include/eosio.token/eosio.token.hpp#L83) action of the account storing the token you wish to transfer.
+
+In the example shown below `useraaaaaaaa` transfers **1.0000 EOS** token stored in the `eosio.token` account from `useraaaaaaaa` to `userbbbbbbbb`.
+```javascript
+(async () => {
+  await api.transact({
+    actions: [{
+      account: 'eosio.token',
+      name: 'transfer',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: {
+        from: 'useraaaaaaaa',
+        to: 'userbbbbbbbb',
+        quantity: '1.0000 EOS',
+        memo: 'some memo'
+      }
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+  });
+})();
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/09_how-to-get-table-information.md b/docs/how-to-guides/09_how-to-get-table-information.md
new file mode 100644
index 000000000..7c5c3e37d
--- /dev/null
+++ b/docs/how-to-guides/09_how-to-get-table-information.md
@@ -0,0 +1,90 @@
+There are many ways to retrieve data stored in smart contract tables.  A few are provided below.
+
+## Get Table Rows
+In the example shown below, the `eosio.token` smart contract's table `accounts` is queried with the scope `testacc`.  The data is returned as **json**, in-order, and limited to **10 rows**.  The RAM payer for the returned row is also not shown.
+```javascript
+(async () => {
+  await rpc.get_table_rows({
+    json: true,               // Get the response as json
+    code: 'eosio.token',      // Contract that we target
+    scope: 'testacc',         // Account that owns the data
+    table: 'accounts',        // Table name
+    limit: 10,                // Maximum number of rows that we want to get
+    reverse: false,           // Optional: Get reversed data
+    show_payer: false          // Optional: Show ram payer
+  });
+})();
+```
+Above we console log the response from the EOSIO network.  An example of an expected response is shown below.
+```javascript
+{
+  rows: [ { balance: '68.3081 EOS' }, { balance: '200.0000 JUNGLE' } ],
+  more: false
+}
+```
+Note that since `more: false` was returned, if can be inferred that there are only 2 rows with scope `testacc` in the `accounts` table of the `eosio.token` smart contract.
+
+## Get Currency Balance
+Rather than using the `get_table_rows` method, a token balance can also be retrieved using the `get_currency_balance` method.  This method takes an `account` which is a smart contract storing the tokens, an `account` who has a balance in the token table of the specified smart contract, and the `symbol` of the token to retrieve the currency balance for.
+
+In the example shown below, the balance of the user `testacc`'s tokens with the symbol `EOS` stored in the `eosio.token` smart contract is retrieved.
+```javascript
+(async () => {
+  console.log(await rpc.get_currency_balance('eosio.token', 'testacc', 'EOS'));
+})();
+```
+Above we console log the response from the EOSIO network.  An example of an expected response is shown below.
+```javascript
+[ '68.3081 EOS' ]
+```
+
+## Query By Index
+A `lower_bound` parameter can also be passed to the `get_table_rows` method.  This parameter allows you to query for a particular value of the primary key in the table.  Using this in conjunction with `limit: 1` allows you to query for 1 row of a table.
+
+In the example shown below, the `contract` smart contract's table `profiles` is queried with the scope `contract` for the row with primary key `testacc`.  The `limit` is **1** which implies that only 1 row with value `testacc` will be returned.
+```javascript
+(async () => {
+  console.log(await rpc.get_table_rows({
+    json: true,                 // Get the response as json
+    code: 'contract',           // Contract that we target
+    scope: 'contract',          // Account that owns the data
+    table: 'profiles',          // Table name
+    lower_bound: 'testacc',     // Table primary key value
+    limit: 1,                   // Here we limit to 1 to get only the single row with primary key equal to 'testacc'
+    reverse: false,             // Optional: Get reversed data
+    show_payer: false,          // Optional: Show ram payer
+  }));
+})();
+```
+Above we console log the response from the EOSIO network.  An example of an expected response is shown below.
+```javascript
+{
+  "rows": [{
+      "user": "testacc",
+      "age": 21,
+      "surname": "Martin"
+    }
+  ],
+  "more": false
+}
+```
+
+## Query By Secondary Index
+Finally, the `lower_bound` parameter can be used in conjunction with the `table_key` parameter to query an index different from the primary key.
+
+In the example shown below, the `contract` smart contract's table `profiles` is queried with the scope `contract` for the rows with secondary index `age` equal to **21**.  The `limit` is **1** which implies that only 1 row with the age **21** will be returned.
+```javascript
+(async () => {
+  console.log(await rpc.get_table_rows({
+    json: true,                 // Get the response as json
+    code: 'contract',           // Contract that we target
+    scope: 'contract',          // Account that owns the data
+    table: 'profiles',          // Table name
+    table_key: 'age',           // Table secondary key name
+    lower_bound: 21,            // Table secondary key value
+    limit: 1,                   // Here we limit to 1 to get only row
+    reverse: false,             // Optional: Get reversed data
+    show_payer: false,          // Optional: Show ram payer
+  }));
+})();
+```
diff --git a/docs/how-to-guides/10_how-to-create-permissions.md b/docs/how-to-guides/10_how-to-create-permissions.md
new file mode 100644
index 000000000..e74e4368b
--- /dev/null
+++ b/docs/how-to-guides/10_how-to-create-permissions.md
@@ -0,0 +1,46 @@
+To create new permissions, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`updateauth`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.bios/include/eosio.bios/eosio.bios.hpp#L205) action of the `eosio` account.
+
+In the example shown below `useraaaaaaaa` creates a new permission called `my_new_permission` on the account `useraaaaaaaa`, with the public key `PUB_R1_6FPFZqw5ahYrR9jD96yDbbDNTdKtNqRbze6oTDLntrsANgQKZu`.
+```javascript
+const authorization_object = { 
+  threshold: 1, 
+  accounts: [{
+    permission: {
+      actor: "useraaaaaaaa", 
+      permission: "active"
+    }, 
+    weight: 1 
+  }], 
+  keys: [{ 
+    key: 'PUB_R1_6FPFZqw5ahYrR9jD96yDbbDNTdKtNqRbze6oTDLntrsANgQKZu', 
+    weight: 1 
+  }],
+  waits: []
+};
+
+const updateauth_input = {
+  account: 'useraaaaaaaa',
+  permission: 'my_new_permission',
+  parent: 'active',
+  auth: authorization_object
+};
+
+(async () => {
+  await api.transact({
+    actions: [
+    {
+      account: 'eosio',
+      name: 'updateauth',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: updateauth_input,
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+  });
+})();
+```
+You can check that the new permission exists on the account using [`get_account`](07_how-to-get-account-information.md)
\ No newline at end of file
diff --git a/docs/how-to-guides/11_how-to-delete-permissions.md b/docs/how-to-guides/11_how-to-delete-permissions.md
new file mode 100644
index 000000000..d29b5c7e8
--- /dev/null
+++ b/docs/how-to-guides/11_how-to-delete-permissions.md
@@ -0,0 +1,27 @@
+To delete permissions, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`deleteauth`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.bios/include/eosio.bios/eosio.bios.hpp#L219) action of the `eosio` account.
+
+In the example shown below `useraaaaaaaa` deletes the permission `my_new_permission` on the account `useraaaaaaaa`.
+```javascript
+const deleteauth_input = {
+  account: 'useraaaaaaaa',
+  permission: 'my_new_permission',
+};
+
+(async () => {
+  await api.transact({
+    actions: [
+    {
+      account: 'eosio',
+      name: 'deleteauth',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: delete_auth_data,
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+  });
+})();
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/12_how-to-link-permissions.md b/docs/how-to-guides/12_how-to-link-permissions.md
new file mode 100644
index 000000000..cc5e62f36
--- /dev/null
+++ b/docs/how-to-guides/12_how-to-link-permissions.md
@@ -0,0 +1,28 @@
+To link an existing permission, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`linkauth`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.bios/include/eosio.bios/eosio.bios.hpp#L240) action of the `eosio` account.
+
+In the example shown below `useraaaaaaaa` links the permission `action_perm` to the contract `useraaaaaaaa`'s `contract_action` action.
+```javascript
+const linkauth_input = {
+  account: 'useraaaaaaaa',      // the permission's owner to be linked and the payer of the RAM needed to store this link
+  code: 'useraaaaaaaa',         // the owner of the action to be linked
+  type: 'contract_action',      // the action to be linked
+  requirement: 'action_perm',   // the permission to be linked
+};
+
+(async () => {
+  await api.transact({
+    actions: [{
+      account: 'eosio',
+      name: 'linkauth',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: linkauth_input,
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+  }));
+})();
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/12_how-to-unlink-permissions.md b/docs/how-to-guides/12_how-to-unlink-permissions.md
new file mode 100644
index 000000000..60f84fed7
--- /dev/null
+++ b/docs/how-to-guides/12_how-to-unlink-permissions.md
@@ -0,0 +1,27 @@
+To unlink an existing permission, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`unlinkauth`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.bios/include/eosio.bios/eosio.bios.hpp#L255) action of the `eosio` account.
+
+In the example shown below `useraaaaaaaa` unlinks the permissions present on the contract `useraaaaaaaa`'s `contract_action` action.
+```javascript
+const unlinkauth_input = {
+  account: 'useraaaaaaaa',      // the permission's owner to be linked and the payer of the RAM needed to store this link
+  code: 'useraaaaaaaa',         // the owner of the action to be linked
+  type: 'contract_action'       // the action to be linked
+};
+
+(async () => {
+  await api.transact({
+    actions: [{
+      account: 'eosio',
+      name: 'unlinkauth',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: unlinkauth_input,
+    }]
+  }, {
+   blocksBehind: 3,
+   expireSeconds: 30,
+  });
+})();
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/13_how-to-propose-a-multisig-transaction.md b/docs/how-to-guides/13_how-to-propose-a-multisig-transaction.md
new file mode 100644
index 000000000..c350f1d63
--- /dev/null
+++ b/docs/how-to-guides/13_how-to-propose-a-multisig-transaction.md
@@ -0,0 +1,188 @@
+To propose a transaction, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`propose`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.msig/include/eosio.msig/eosio.msig.hpp#L39) action of the `eosio.msig` account.
+
+## Serializing Actions
+The `data` field of the `propose` action has a `tx` field, which is a [`transaction`](https://github.com/EOSIO/eosio.contracts/blob/6ca72e709faba179726a20571929a9eeaea47d08/tests/test_contracts/eosio.msig.old/eosio.msig.abi#L48) type.  This `transaction` type contains an [`action`](https://github.com/EOSIO/eosio.contracts/blob/6ca72e709faba179726a20571929a9eeaea47d08/tests/test_contracts/eosio.msig.old/eosio.msig.abi#L21) type, which contains [`bytes`](https://github.com/EOSIO/eosio.contracts/blob/6ca72e709faba179726a20571929a9eeaea47d08/tests/test_contracts/eosio.msig.old/eosio.msig.abi#L27) as it's `data` field.  Because of this, we must first serialize a list of [`action`](https://github.com/EOSIO/eosio.contracts/blob/6ca72e709faba179726a20571929a9eeaea47d08/tests/test_contracts/eosio.msig.old/eosio.msig.abi#L21) objects.
+
+## serializeActions
+In the example shown below, a transaction for the `eosio` `updateauth` action is serialized using the `api` object's `serializeActions` method.
+```javascript
+const actions = [
+  {
+    account: 'eosio',
+    name: 'updateauth',
+    authorization: [
+      {
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }
+    ],
+    data: {
+      account: 'useraaaaaaaa',
+      permission: 'active',
+      parent: '',
+      auth: {
+        threshold: 1,
+        keys: [
+          {
+            key: 'PUB_R1_6FPFZqw5ahYrR9jD96yDbbDNTdKtNqRbze6oTDLntrsANgQKZu',
+            weight: 1
+          }
+        ],
+        accounts:[],
+        waits:[]
+      }
+    }
+  }
+];
+
+(async () => {
+  const serialized_actions = await api.serializeActions(actions)
+}
+```
+An example output of `serialized_actions` call made above is shown below.
+```javascript
+[
+  {
+    account: 'eosio',
+    name: 'updateauth',
+    authorization: [ [Object] ],
+    data: 'F0F0C30F3FFCF0C300000000A8ED3232000000000000000001000000010003FD9ABF3D22615D5621BF74D2D0A652992DE1338E552AD85D5EAF1F39DCAADDB301000000'
+  }
+]
+```
+
+## Propose Input
+In the example shown below, the `serialized_actions` list created above is used in the `actions` field of the `proposeInput`'s `trx` field.
+
+[Below](#propose) `useraaaaaaaa` proposes a multi-sig transaction, which calls the `updateauth` action of the `eosio` account (see [`actions`](#serializeactions) above).  This proposal is called `changeowner` and both `useraaaaaaaa` and `userbbbbbbbb` must sign the multi-sig transaction before `2019-09-14T16:39:15`.
+```javascript
+const proposeInput = {
+    proposer: 'useraaaaaaaa',
+    proposal_name: 'changeowner',
+    requested: [
+      {
+        actor: 'useraaaaaaaa',
+        permission: 'active'
+      },
+      {
+        actor: 'userbbbbbbbb',
+        permission: 'active'
+      }
+    ],
+    trx: {
+      expiration: '2019-09-14T16:39:15',
+      ref_block_num: 0,
+      ref_block_prefix: 0,
+      max_net_usage_words: 0,
+      max_cpu_usage_ms: 0,
+      delay_sec: 0,
+      context_free_actions: [],
+      actions: serialized_actions,
+      transaction_extensions: []
+    }
+  };
+```
+
+## Propose
+In the example below, a transaction is submitted to the `propose` action of the `eosio.msig` contract using the `proposeInput` object created [above](#propose-input).
+```javascript
+await api.transact({
+  actions: [{
+    account: 'eosio.msig',
+    name: 'propose',
+    authorization: [{
+      actor: 'useraaaaaaaa',
+      permission: 'active',
+    }],
+    data: proposeInput,
+  }]
+}, {
+  blocksBehind: 3,
+  expireSeconds: 30,
+  broadcast: true,
+  sign: true
+});
+```
+
+## Propose a Multi-sig Transaction
+Below all three steps to propose a multi-sig transaction are provided.
+
+```javascript
+// CREATE ACTION TO PROPOSE
+const actions = [
+  {
+    account: 'eosio',
+    name: 'updateauth',
+    authorization: [
+      {
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }
+    ], data: {
+      account: 'useraaaaaaaa',
+      permission: 'active',
+      parent: '',
+      auth: {
+        threshold: 1,
+        keys: [
+          {
+            key: 'PUB_R1_6FPFZqw5ahYrR9jD96yDbbDNTdKtNqRbze6oTDLntrsANgQKZu',
+            weight: 1
+          }
+        ],
+        accounts:[],
+        waits:[]
+      }
+    },
+  }
+];
+
+(async () => {
+  const serialized_actions = await api.serializeActions(actions)
+
+  // BUILD THE MULTISIG PROPOSE TRANSACTION
+  proposeInput = {
+    proposer: 'useraaaaaaaa',
+    proposal_name: 'changeowner',
+    requested: [
+      {
+        actor: 'useraaaaaaaa',
+        permission: 'active'
+      },
+      {
+        actor: 'userbbbbbbbb',
+        permission: 'active'
+      }
+    ],
+    trx: {
+      expiration: '2019-09-16T16:39:15',
+      ref_block_num: 0,
+      ref_block_prefix: 0,
+      max_net_usage_words: 0,
+      max_cpu_usage_ms: 0,
+      delay_sec: 0,
+      context_free_actions: [],
+      actions: serialized_actions,
+      transaction_extensions: []
+    }
+  };
+
+  //PROPOSE THE TRANSACTION
+  const result = await api.transact({
+    actions: [{
+      account: 'eosio.msig',
+      name: 'propose',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: proposeInput,
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+    broadcast: true,
+    sign: true
+  });
+})();
+```
diff --git a/docs/how-to-guides/14_how-to-approve-a-multisig-transaction.md b/docs/how-to-guides/14_how-to-approve-a-multisig-transaction.md
new file mode 100644
index 000000000..b9b5057a4
--- /dev/null
+++ b/docs/how-to-guides/14_how-to-approve-a-multisig-transaction.md
@@ -0,0 +1,30 @@
+To approve a multi-sig transaction, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`approve`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.msig/include/eosio.msig/eosio.msig.hpp#L58) action of the `eosio.msig` account.
+
+In the example shown below `userbbbbbbbb` approves the `changeowner` proposal, previously proposed by `useraaaaaaaa` using `userbbbbbbbb`'s `active` permission.
+```javascript
+(async () => {
+  await api.transact({
+    actions: [{
+      account: 'eosio.msig',
+      name: 'approve',
+      authorization: [{
+        actor: 'userbbbbbbbb',
+        permission: 'active',
+      }],
+      data: {
+        proposer: 'useraaaaaaaa',
+        proposal_name: 'changeowner',
+        level: {
+          actor: 'userbbbbbbbb',
+          permission: 'active',
+        }
+      },
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+    broadcast: true,
+    sign: true
+  });
+})();
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/15_how-to-unapprove-a-multisig-transaction.md b/docs/how-to-guides/15_how-to-unapprove-a-multisig-transaction.md
new file mode 100644
index 000000000..300e5141b
--- /dev/null
+++ b/docs/how-to-guides/15_how-to-unapprove-a-multisig-transaction.md
@@ -0,0 +1,30 @@
+To unapprove a multi-sig transaction, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`unapprove`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.msig/include/eosio.msig/eosio.msig.hpp#L73) action of the `eosio.msig` account.
+
+In the example shown below `userbbbbbbbb` unapproves the `changeowner` proposal, previously proposed by `useraaaaaaaa` using `userbbbbbbbb`'s `active` permission.
+```javascript
+(async () => {
+  await api.transact({
+    actions: [{
+      account: 'eosio.msig',
+      name: 'unapprove',
+      authorization: [{
+        actor: 'userbbbbbbbb',
+        permission: 'active',
+      }],
+      data: {
+        proposer: 'useraaaaaaaa',
+        proposal_name: 'changeowner',
+        level: {
+          actor: 'userbbbbbbbb',
+          permission: 'active',
+        }
+      },
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+    broadcast: true,
+    sign: true
+  });
+})();
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/16_how-to-cancel-a-multisig-transaction.md b/docs/how-to-guides/16_how-to-cancel-a-multisig-transaction.md
new file mode 100644
index 000000000..15e7a44d0
--- /dev/null
+++ b/docs/how-to-guides/16_how-to-cancel-a-multisig-transaction.md
@@ -0,0 +1,29 @@
+To cancel a multi-sig transaction, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`cancel`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.msig/include/eosio.msig/eosio.msig.hpp#L88) action of the `eosio.msig` account.
+
+In the example shown below `useraaaaaaaa` cancels the `changeowner` proposal, previously proposed by `useraaaaaaaa`.
+```javascript
+(async () => {
+  await api.transact({
+    actions: [{
+      account: 'eosio.msig',
+      name: 'cancel',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: {
+        proposer: 'useraaaaaaaa',
+        proposal_name: 'changeowner',
+        canceler: 'useraaaaaaaa'
+      },
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+    broadcast: true,
+    sign: true
+  });
+})();
+```
+
+**Note** that if a previously proposed transaction has yet to expire, only the proposer of the transaction can cancel it.
\ No newline at end of file
diff --git a/docs/how-to-guides/17_how-to-execute-a-multisig-transaction.md b/docs/how-to-guides/17_how-to-execute-a-multisig-transaction.md
new file mode 100644
index 000000000..90c356707
--- /dev/null
+++ b/docs/how-to-guides/17_how-to-execute-a-multisig-transaction.md
@@ -0,0 +1,29 @@
+If a multi-sig transaction has been approved by the appropriate parties prior to the proposed transaction's expiration timestamp, it can be executed.
+
+To execute a multi-sig transaction, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`exec`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.msig/include/eosio.msig/eosio.msig.hpp#L109) action of the `eosio.msig` account.
+
+In the example shown below `userbbbbbbbb` executes the `changeowner` proposal, previously proposed by `useraaaaaaaa`.
+```javascript
+(async () => {
+  await api.transact({
+    actions: [{
+      account: 'eosio.msig',
+      name: 'exec',
+      authorization: [{
+        actor: 'userbbbbbbbb',
+        permission: 'active',
+      }],
+      data: {
+        proposer: 'useraaaaaaaa',
+        proposal_name: 'changeowner',
+        executer: 'userbbbbbbbb'
+      },
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+    broadcast: true,
+    sign: true
+  });
+})();
+```
\ No newline at end of file
diff --git a/docs/how-to-guides/18_how-to-vote.md b/docs/how-to-guides/18_how-to-vote.md
new file mode 100644
index 000000000..093bf5cb7
--- /dev/null
+++ b/docs/how-to-guides/18_how-to-vote.md
@@ -0,0 +1,55 @@
+To vote for a block produder, [submit a transaction](01_how-to-submit-a-transaction.md) to the [`voteproducer`](https://github.com/EOSIO/eosio.contracts/blob/52fbd4ac7e6c38c558302c48d00469a4bed35f7c/contracts/eosio.system/include/eosio.system/eosio.system.hpp#L1130) action of the `eosio` account.
+
+In the example shown below `useraaaaaaaa` votes for producers `userbbbbbbbb` and `usercccccccc`.
+```javascript
+(async () => {
+  await api.transact({
+    actions: [{
+      account: 'eosio',
+      name: 'voteproducer',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: {
+        voter: 'useraaaaaaaa',
+        proxy: '',
+        producers: ['userbbbbbbbb', 'usercccccccc']
+      },
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+    broadcast: true,
+    sign: true
+  });
+})();
+```
+
+`useraaaaaaaa` can also delegate their vote to a proxy.  In the example shown below, `useraaaaaaaa` delegates their vote to the proxy `userbbbbbbbb`.
+```javascript
+(async () => {
+  await api.transact({
+    actions: [{
+      account: 'eosio',
+      name: 'voteproducer',
+      authorization: [{
+        actor: 'useraaaaaaaa',
+        permission: 'active',
+      }],
+      data: {
+        voter: 'useraaaaaaaa',
+        proxy: 'userbbbbbbbb',
+        producers: []
+      },
+    }]
+  }, {
+    blocksBehind: 3,
+    expireSeconds: 30,
+    broadcast: true,
+    sign: true
+  });
+})();
+```
+
+**Note** that if the `proxy` field is used, the `producers` list must be empty, and vice verse, if the `producers` list is used, the `proxy` field must be an empty string.
\ No newline at end of file
diff --git a/docs/how-to-guides/19_how-to-set-the-network.md b/docs/how-to-guides/19_how-to-set-the-network.md
new file mode 100644
index 000000000..3d5dff4dd
--- /dev/null
+++ b/docs/how-to-guides/19_how-to-set-the-network.md
@@ -0,0 +1,11 @@
+To change the network used by `eosjs`, pass in the URL of a node connected to the network of interest to `JsonRpc`.
+
+In the examples shown in the `basic-usage` section, it was assumed that a local node running on port `8888` was used.
+```javascript
+const rpc = new JsonRpc('http://127.0.0.1:8888');
+```
+
+However, the address and port of any node on any network can be used by passing in the URL of the node as a string to the `JsonRpc` object.  Assuming there is a node running at the IP address `192.168.2.1` listening for requests on port `9999`, we could connect to this node and it's network with the following line of code.
+```javascript
+const rpc = new JsonRpc('http://192.168.2.1:9999');
+```
\ No newline at end of file
diff --git a/docs/troubleshooting/00_connectivity.md b/docs/troubleshooting/00_connectivity.md
new file mode 100644
index 000000000..63b3c576f
--- /dev/null
+++ b/docs/troubleshooting/00_connectivity.md
@@ -0,0 +1,60 @@
+While troubleshooting network connectivity it is advisable to issue a `rpc.get_info()` request to rule out the possibility of `Api` object misconfiguration or authorization related problems.  Given the `JsonRpc` object only requires a node URL, this approach isolates problems to simple node connectivity problems.
+
+Below are a number of ways a `rpc.get_info()` request can fail and what they could potentially mean.
+
+## invalid json response body
+```javascript
+(node:66636) UnhandledPromiseRejectionWarning: FetchError: invalid json response body at http://www.some-node-url.com/v1/chain/get_info reason: Unexpected token < in JSON at position 0
+```
+
+This typically means you have connected to a computer that is not running EOSIO software.  For example, if you instantiate a `JsonRpc` object as follows:
+
+```javascript
+const rpc = new JsonRpc('http://some-node-url.com', { fetch });
+```
+
+You would see the exception above when issuing a `rpc.get_info()` request since the computer at `http://some-node-url.com` is not running EOSIO software.
+
+## ETIMEDOUT
+```javascript
+(node:68313) UnhandledPromiseRejectionWarning: FetchError: request to http://some-node-url.com:8000/v1/chain/get_info failed, reason: connect ETIMEDOUT 53.140.50.180:8000
+```
+
+This typically implies you have connected to a node that *is* running EOSIO software, but have entered the incorrect port, or left off the port number altogether.
+
+## Indefinite Hanging
+If the `rpc.get_info()` request never returns, but also never throws an exception, it is likely that you've connected to a node running EOSIO software, but have misconfigured the protocol (http/https).
+
+## Only absolute URLs are supported
+```javascript
+(node:72394) UnhandledPromiseRejectionWarning: TypeError: Only absolute URLs are supported
+```
+
+This typically implies you've entered an empty string as the first argument to `JsonRpc` as shown below.
+
+```javascript
+const rpc = new JsonRpc('', { fetch });
+```
+
+## Only HTTP(S) protocols are supported
+```javascript
+(node:72612) UnhandledPromiseRejectionWarning: TypeError: Only HTTP(S) protocols are supported
+```
+This typically implies you've left off the protocol from the absolute URL string (i.e. `127.0.0.1:8888` rather than `http://127.0.0.1:8888`).
+
+
+## ENOTFOUND
+```javascript
+(node:72822) UnhandledPromiseRejectionWarning: FetchError: request to http://www.some-node-url.com:8888/v1/chain/get_info failed, reason: getaddrinfo ENOTFOUND www.some-node-url.com
+```
+This typically implies you've misconfigured the domain name of the absolute URL in some way.  Adding `www.` erroneously or removing `.com` at the end of the domain name could be possible mistakes.
+
+## f is not a function
+```javascript
+(node:74052) UnhandledPromiseRejectionWarning: TypeError: f is not a function
+```
+This typically implies the absolute URL string of the node was not passed to the `JsonRpc` object as show below
+
+```javascript
+const rpc = new JsonRpc({ fetch });
+```
diff --git a/docs/troubleshooting/01_missing-authorizations.md b/docs/troubleshooting/01_missing-authorizations.md
new file mode 100644
index 000000000..5baeeb217
--- /dev/null
+++ b/docs/troubleshooting/01_missing-authorizations.md
@@ -0,0 +1,52 @@
+Below are a number of ways authorization related requests can fail and what the failure could potentially mean.
+
+## transaction declares authority but does not have signatures for it.
+```javascript
+(node:99019) UnhandledPromiseRejectionWarning: Error: transaction declares authority '{"actor":"useraaaaaaaa","permission":"active"}', but does not have signatures for it.
+```
+
+This exception can occur for a number of different reasons.
+
+It could be that the private key supplied to the signature provider is incorrect for the actor in which the transaction is being signed for.  It could also be that the `actor` field of the `authorization` object is incorrect.  Finally, it could be that the `permission` specified is incorrect or does not exist for the specified actor.
+
+## Invalid checksum
+```javascript
+Error: Invalid checksum, 01b93f != 5df6e0e2
+```
+
+This typically implies the private key supplied to the `JsSignatureProvider` object is malformed or invalid.
+
+## Cannot read property 'length' of undefined
+```javascript
+(node:97736) UnhandledPromiseRejectionWarning: TypeError: Cannot read property 'length' of undefined
+```
+
+This typically implies you have not supplied an `authorization` field in the `action` supplied to the `transact` method of the `api` object.
+
+For example, the below request would cause the above exception, since the `authorization` field is not present.
+```javascript
+(async () => {
+  await api.transact({
+   actions: [{
+     account: 'eosio',
+     name: 'buyrambytes',
+     data: {
+       payer: 'useraaaaaaaa',
+       receiver: 'useraaaaaaaa',
+       bytes: 8192,
+     },
+   }]
+  }, {
+   blocksBehind: 3,
+   expireSeconds: 30,
+  });
+})();
+```
+
+## missing permission_level
+```javascript
+(node:472) UnhandledPromiseRejectionWarning: Error: missing permission_level.permission (type=name)
+```
+
+This means that you have left either the `actor` or `permission` field off of the `authorization` object of an action.
+
diff --git a/src/eosjs-api-interfaces.ts b/src/eosjs-api-interfaces.ts
index 0fe95e3cd..959849f16 100644
--- a/src/eosjs-api-interfaces.ts
+++ b/src/eosjs-api-interfaces.ts
@@ -1,4 +1,7 @@
-// copyright defined in eosjs/LICENSE.txt
+/**
+ * @module Javascript-API
+ * copyright defined in eosjs/LICENSE.txt
+ */
 
 import { Abi, PushTransactionArgs } from './eosjs-rpc-interfaces';
 
diff --git a/src/eosjs-rpc-interfaces.ts b/src/eosjs-rpc-interfaces.ts
index b8193ee4c..c4e88678e 100644
--- a/src/eosjs-rpc-interfaces.ts
+++ b/src/eosjs-rpc-interfaces.ts
@@ -1,4 +1,7 @@
-// copyright defined in eosjs/LICENSE.txt
+/**
+ * @module RPC-API-Methods
+ * copyright defined in eosjs/LICENSE.txt
+ */
 
 /** Structured format for abis */
 export interface Abi {