[CI Skip] 1.9.1

skip-checks: true

.123trigger

@@ -1,2 +1,3 @@
-20
+21
  1.4.2
+1.6.2

.github/workflows/pr-any.yml

@@ -2,110 +2,18 @@ name: PR
 on: [pull_request]
 
 jobs:
-  lint:
-    name: Linting
-    runs-on: ubuntu-latest
+  pr:
     strategy:
       matrix:
-        node-version: [12.x]
-    steps:
-    - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: Config yarn cache
-      id: yarn-cache-dir-path
-      run: echo "::set-output name=dir::$(yarn cache dir)"
-    - uses: actions/cache@v1
-      id: yarn-cache
-      with:
-        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-yarn-
-    - name: lint
-      run: |
-        yarn install --immutable | grep -v 'YN0013'
-        yarn lint
-
-  test:
-    name: Testing
+        step: ['lint', 'test', 'build', 'docs']
+    name: ${{ matrix.step }}
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
     steps:
     - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+    - uses: actions/setup-node@v1
       with:
-        node-version: ${{ matrix.node-version }}
-    - name: Config yarn cache
-      id: yarn-cache-dir-path
-      run: echo "::set-output name=dir::$(yarn cache dir)"
-    - uses: actions/cache@v1
-      id: yarn-cache
-      with:
-        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-yarn-
-    - name: test
+        node-version: '12.x'
+    - name: ${{ matrix.step }}
       run: |
         yarn install --immutable | grep -v 'YN0013'
-        yarn test
-
-  build_code:
-    name: Build Code
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
-    steps:
-    - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: Config yarn cache
-      id: yarn-cache-dir-path
-      run: echo "::set-output name=dir::$(yarn cache dir)"
-    - uses: actions/cache@v1
-      id: yarn-cache
-      with:
-        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-yarn-
-    - name: build
-      run: |
-        yarn install --immutable | grep -v 'YN0013'
-        yarn build
-
-  build_docs:
-    name: Build Docs
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
-    steps:
-    - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: Config yarn cache
-      id: yarn-cache-dir-path
-      run: echo "::set-output name=dir::$(yarn cache dir)"
-    - uses: actions/cache@v1
-      id: yarn-cache
-      with:
-        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-yarn-
-    - name: build
-      run: |
-        yarn install --immutable | grep -v 'YN0013'
-        yarn docs
+        yarn ${{ matrix.step }}

.github/workflows/push-master.yml

@@ -5,82 +5,36 @@ on:
       - master
 
 jobs:
-  build_code:
-    name: Build Code
-    if: "! contains(github.event.head_commit.message, '[CI Skip]')"
-    runs-on: ubuntu-latest
+  master:
     strategy:
       matrix:
-        node-version: [12.x]
+        step: ['build:release', 'docs:release']
+    name: ${{ matrix.step }}
+    if: "! contains(github.event.head_commit.message, '[CI Skip]') && github.repository == 'polkadot-js/api'"
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v1
       with:
         token: ${{ secrets.GH_PAT }}
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+    - uses: actions/setup-node@v1
       with:
-        node-version: ${{ matrix.node-version }}
-    - name: Config yarn cache
-      id: yarn-cache-dir-path
-      run: echo "::set-output name=dir::$(yarn cache dir)"
-    - uses: actions/cache@v1
-      id: yarn-cache
-      with:
-        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-yarn-
-    - name: build
+        node-version: '12.x'
+    - name: ${{ matrix.step }}
       env:
         CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+        GH_PAGES_SRC: build-docs
         GH_PAT: ${{ secrets.GH_PAT }}
         GH_TOKEN: ${{ secrets.GH_PAT }}
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
       run: |
         yarn install --immutable | grep -v 'YN0013'
-        yarn polkadot-ci-ghact-build
-
-  build_docs:
-    name: Build Docs
-    if: "! contains(github.event.head_commit.message, '[CI Skip]')"
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
-    steps:
-    - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: Config yarn cache
-      id: yarn-cache-dir-path
-      run: echo "::set-output name=dir::$(yarn cache dir)"
-    - uses: actions/cache@v1
-      id: yarn-cache
-      with:
-        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-yarn-
-    - name: build
-      env:
-        GH_PAT: ${{ secrets.GH_PAT }}
-        GH_TOKEN: ${{ secrets.GH_PAT }}
-        GH_PAGES_SRC: build-docs
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      run: |
-        yarn install --immutable | grep -v 'YN0013'
-        yarn polkadot-ci-ghact-docs
+        yarn ${{ matrix.step }}
 
   dummy:
     name: Dummy
     if: "contains(github.event.head_commit.message, '[CI Skip]')"
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
     steps:
     - name: dummy
       run: |

.yarnrc.yml

@@ -1,4 +1,5 @@
 enableImmutableInstalls: false
+
 enableProgressBars: false
 
 nodeLinker: node-modules
@@ -7,4 +8,4 @@ plugins:
   - path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.js
     spec: "@yarnpkg/plugin-interactive-tools"
 
-yarnPath: .yarn/releases/yarn-berry.js
+yarnPath: .yarn/releases/yarn-rc.js

CHANGELOG.md

@@ -1,6 +1,47 @@
+# 1.9.1 Apr 1, 2020
+
+**Breaking change** (TypeScript with derives only) The return type names for `api.derive.*` have been adjusted for consistency, all starting with `Derive*` (previously a mixture of `Derived*` and `Derive*`)
+**Breaking change** (derives only) Additional cleanups of democracy proposal & referenda derives, including support for new Polkadot/Substrate vote retrievals
+- Tx signing via `signAndSend` & `signAsync` now tries to use the last finalized block (depending on finalized drift)
+- Add support for `api.rpc.childstate.*` Substrate RPCs, older nodes with still populate `api.rpc.state.*` with the child methods
+- Adjust `Error.message` on RPC failures to not include the (already known) method signature
+- Split `@polkadot/types/known` into `@polkadot/types-known`, allowing for base API overrides
+- Extended `api.derive.democracy` to cater for dispatchQueue and externals
+- Extended `api.derive.council` to cater for new phragmen elections
+- Use new `queryStorageAt` for query `.entries`, removing unneeded subscriptions (use as available)
+- Fix `BTreeSet` initialization when it forms part of query interfaces
+- Fix encoding for `Vec<u8>`-related types as part of constants
+- Internal adjustment of interface type locations (no impact on imports via `@polkadot/types/interfaces`)
+
+# 1.8.1 Mar 22, 2020
+
+- **Breaking change** The format for any custom RPCs have been changed (alongside API-internal changes) to allow for better RPC management. If you are currently using custom RPCs (or planning to do so), look at the [updated documentation](https://polkadot.js.org/api/start/rpc.custom.html)
+- **Breaking change** Alongside API RPC changes, the `@polkadot/jsonrpc` package has been removed. Since it was never documented and only used internally, this should not have adverse impacts. All RPC definitions itself has now been moved to the relevant modules inside `@polkadot/types/interfaces`
+- **Important** Substrate has an updated democracy module. If using an older chain add the `ReferendumInfo: 'ReferendumInfoTo239'` type when using referendums
+- The `isRetracted` Extrinsic status is now a warning, not a fatal error, correctly aligning with Polkadot/Substrate
+- The Substrate extrinsic phase definitions has been expanded with `Initialization` to align with the latest versions
+- Add support for all known substrate RPC methods
+- Extend account derives to include status flags, e.g. `isCouncil`, `isSudo`, ...
+- Adjusted referendum derives to cater for bot new/old democracy. Derived `referendumInfo` now includes `status` field, not `info`
+- Add `initWasm` flag to API options. When set to `false` does not init the WASM portion (leaving it to the user elsewhere)
+
+# 1.7.1 Mar 17, 2020
+
+- **Important** Current versions of Polkadot/Substrate have dropped support for linked maps on storage entries. If you are using these queries to retrieve all entries, for instance `staking.{nominators,validators}()` and using an upgraded chain, you need to swap to retrieving entries via `.entries()` or `.keys()` for the keys.
+- Pull in support and types for latest Polkadot/Substrate
+- Add support for the new Substrate `state_getKeysPaged` RPC, including use in storage keys
+- Move `derive.staking.controllers` to `derive.staking.stashes`, reflecting actual content
+- Cater for adjusted storage (non-linked mapped) for `derive.staking.stashes` queries (with old-compat)
+- Expanded `derive.staking.*` derives, including addition of `derive.staking.own*`
+- Re-add fixed (with tests) checks for query args, previously disabled in 1.6.2
+
+# 1.6.2 Mar 12, 2020
+
+- Revert checks for query args, not working on `.at()` queries (proper fix in next version)
+
 # 1.6.1 Mar 12, 2020
 
-- **Breaking change** `api.rpc.state.queryStorage(...)` now full decodes the `Vec<StorageChangeSet>` and returns a decoded `[Hash, Codec[]][]` when using this RPC.
+- **Breaking change** `api.rpc.state.queryStorage(...)` now fully decodes the `Vec<StorageChangeSet>` and returns a decoded `[Hash, Codec[]][]` when using this RPC.
 - `StorageKey` now has an `.args` property, decoded from meta where `twox64_concat` or `blake128_concat` are used on maps
 - Fix `api.query.*.*.entries` type conversions to return exact types (not `Option` in some cases)
 - Add `api.query.*.*.keys` to retrieve only the storage keys, similar to `.entries`

copy-to-apps.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 function copy_folder () {
   SRC="packages/$1/build"
@@ -18,6 +18,5 @@ copy_folder "api-derive"
 copy_folder "metadata"
 copy_folder "rpc-core"
 copy_folder "rpc-provider"
-copy_folder "jsonrpc"
 copy_folder "types"
 copy_folder "typegen"

docs/.vuepress/config.js

@@ -43,6 +43,7 @@ module.exports = {
           ['start/api.tx.wrap.md', 'Complex transactions'],
           ['start/types.basics.md', 'Type basics'],
           ['start/types.extend.md', 'Extending types'],
+          ['start/rpc.custom.md', 'Custom RPC'],
           ['start/types.create.md', 'Creating types'],
           ['start/typescript.md', 'TypeScript interfaces'],
           ['start/typescript.user.md', 'TypeScript user generated'],

docs/examples/promise/05_read_storage/index.js

@@ -24,7 +24,7 @@ async function main () {
   if (validators && validators.length > 0) {
     // Retrieve the balances for all validators
     const validatorBalances = await Promise.all(
-      validators.map(authorityId =>
+      validators.map((authorityId) =>
         api.query.system.account(authorityId)
       )
     );

docs/examples/rx/05_read_storage/index.js

@@ -22,7 +22,7 @@ function main () {
         // In the next step, we're checking if the node has active validators.
         // If it does, we're making another call to the api to get the balances for all validators
         const balances = (validators && validators.length > 0)
-          ? combineLatest(validators.map(authorityId => api.query.system.account(authorityId).pipe(first())))
+          ? combineLatest(validators.map((authorityId) => api.query.system.account(authorityId).pipe(first())))
           : of(null);
 
         // We're combining the results together with the emitted value 'validators',

docs/start/.TODOS.md

@@ -1,5 +0,0 @@
-... somewhere also need a signer injection section, something along the lines of the singlesigner or this https://github.com/polkadot-js/tools/blob/master/packages/signer-cli/src/cmdSubmit.ts#L12
-
-... DoubleMap & LinkedMap examples
-
-... api.derive

docs/start/FAQ.md

@@ -34,13 +34,13 @@ To submit these transactions, it needs to be send as a [wrapped transaction](api
 
 ## How do I call a function with a Tuple input
 
-Tuples, as defined in the Polkadot/Substrate types appear as `(TypeA, TypeB)`. For instance we may have an `(AccountId, u64)` input as defined in the metadata or as part of the user types. To specify a Tuple as an input, wrap it is an  array format, for instance to call `query.module.get((u32, u64))` where a `(u32, u64)` Tuple input is expected, you would do  `query.module.get([123, 456])`
+Tuples, as defined in the Polkadot/Substrate types appear as `(TypeA, TypeB)`. For instance we may have an `(AccountId, u64)` input as defined in the metadata or as part of the user types. To specify a Tuple as an input, wrap it in an  array format, for instance to call `query.module.get((u32, u64))` where a `(u32, u64)` Tuple input is expected, you would do  `query.module.get([123, 456])`
 
 ## How long do transactions live
 
 Polkadot/Substrate supports both immortal and mortal transactions. For immortal, this means that the transaction has an infinite lifetime, for mortals, the transactions expire after a defined period. By default the API sends mortal transactions when no explicit extrinsic era has been specified. This means that all transaction has a limited lifetime and will expire if not included in the period set.
 
-The length for this transaction validity is set to 50 blocks, which translates to 5 minutes assuming a default of 6 second blocktimes. (10 blocks per minute in this default configuration).
+The length for this transaction validity is set to 5 minutes, calculated based on the blocktime for the chain. (10 blocks per minute in this default 6s Substrate configuration).
 
 ## My chain does not support system.account queries
 
@@ -49,3 +49,11 @@ The API always tracks the latest Substrate master in terms of examples. This mea
 It is possible that you are connecting to an older chain that has not been upgraded yet. For these chains, this storage entry won't be available (yet). To query the nonce on older chains, you can do a query to `api.query.system.accountNonce(<account>)` and balances can be retrieved via `api.query.balances.freeBalance(<account>)`.
 
 Likewise, if your chain has been upgraded recently and you are still using the old `system.accountNonce` or `balances.freeBalance` queries in your code (which is now not available in the chain metadata), you need to update it to query the new location.
+
+## I cannot send transactions from my node-template-based chain
+
+For the API defaults, the API always the type definitions as specified by the Substrate master fully-featured node. This means that any customizations needs to be applied as types should there be differences in specific user-implementations.
+
+The Substrate node-template has added customizations for some types in the default template, specifically around the `Address` and `Lookup` types, removing indices lookups from addresses. This means that the transaction payload saves 2 bytes for a transfer and is an approach followed by other chains as well, notably Polkadot & Kusama.
+
+Due to these customizations and differences that bleed through to the transaction formats, out-of-the-box the node-template will have issues when sending transactions. To fix this, you would need to add [the customized Address types into your API](types.extend.md#impact-on-extrinsics) instances (or UIs), allowing the API to have the information required to adjust the encoding.

docs/start/api.query.other.md

@@ -22,7 +22,7 @@ const [{ data: balanceNow }, { data: balancePrev }] = await Promise.all([
 console.log(`The delta was ${balanceNow.free.sub(balancePrev.free)}`);
 ```
 
-In the above example, we introduce the `.at(<hash>[, ...params])` query. For all `.at` queries, the first parameter is always the block hash at which we want to make the query, in our example we use both the last retrieved block and the parent thereof. The params are optional as per the type of query made, for instance to retrieve the timestamp for a previous block, it would be -
+In the above example, we introduce the `.at(<hash>[, ...params]): Type` query. For all `.at` queries, the first parameter is always the block hash at which we want to make the query, in our example we use both the last retrieved block and the parent thereof. The params are optional as per the type of query made, for instance to retrieve the timestamp for a previous block, it would be -
 
 ```js
 ...
@@ -35,6 +35,46 @@ The `.at` queries are all single-shot, i.e. there are no subscription option to
 
 An additional point to take care of (briefly mentioned above), is state pruning. By default a Polkadot/Substrate node will only keep state for the last 256 blocks, unless it is explicitly run in archive mode. This means that querying state further back than the pruning period will result in an error returned from the Node. (Generally most public RPC nodes only run with default settings, which includes aggressive state pruning)
 
+## State for a range of blocks
+
+In addition to the `.at` queries, you can also query state starting at a specific historic block and up to either a specified or the latest blocks. This is done via the `.range([from, to?], <...opt params>): [Hash, Type][]` query. As an example -
+
+```js
+...
+// Retrieve the current block header
+const lastHdr = await api.rpc.chain.getHeader();
+const startHdr = await api.rpc.chain.getBlockHash(lastHdr.number.unwrap().subn(500));
+
+// retrieve the range of changes
+const changes = await api.query.system.account.range([startHdr]);
+
+changes.forEach(([hash, value]) => {
+  console.log(hash.toHex(), value.toHuman());
+});
+```
+
+## Map keys & entries
+
+When working maps and double-maps, it is possible to retrieve a list of all the keys and entries for the map. For this we can use the `.entries(<args>): [StorageKey, Type][]` queries. For example we may want to know the current list of validator exposures at a current era in the staking module -
+
+```js
+...
+// Retrieve the active era
+const activeEra = await api.query.staking.activeEra();
+
+// retrieve all exposures int the active era
+const exposures = await api.query.staking.erasStakers.entries(activeEra.index);
+
+exposures.forEach(([key, exposure]) => {
+  console.log('key arguments:', key.args.map((k) => k.toHuman()));
+  console.log('     exposure:', exposure.toHuman());
+});
+```
+
+Here we are querying a double-map, so we supply 1 argument. No arguments on double-maps will be very costly, retrieving all the eras and associated entries. Additionally when `twox64_concat` & `blake2_concat` is used, the key `.args` will contain decoded values of the params, in this case it will contain the actual `AccountId` of the staker. (Since that was not supplied)
+
+In the same way as above we can simply do `.keys(activeEra.index): StorageKey[]` to retrieve all the keys here, including the individual keys args decoding, as available on maps with decodable hashing functions.
+
 ## State entries
 
 In addition to using `api.query` to make actual on-chain queries, it can also be used to retrieve some information on the state entries. For instance to retrieve both the hash and size of an existing entry, we can make the following calls -

docs/start/api.tx.subs.md

@@ -62,6 +62,23 @@ const unsub = await api.tx.balances
 
 Be aware that when a transaction status is `isFinalized`, it means it is included, but it may still have failed - for instance if you try to send a larger amount that you have free, the transaction is included in a block, however from a end-user perspective the transaction failed since the transfer did not occur. In these cases a `system.ExtrinsicFailed` event will be available in the events array.
 
+## Payment information
+
+The Polkadot/Substrate RPC endpoints exposes weight/payment information that takes an encoded extrinsic and calculates the on-chain weight fees for it. A wrapper for this is available on the tx itself, taking exactly the same parameters as you would pass to a normal `.signAndSend` operation, specifically `.paymentInfo(sender, <any options>)`. To expand on our previous example -
+
+```js
+// construct a transaction
+const transfer = api.tx.balances.transfer(BOB, 12345);
+
+// retrieve the payment info
+const { partialFee, weight } = await transfer.paymentInfo(alice);
+
+console.log(`transaction will have a weight of ${weight}, with ${partialFee.toHuman()} weight fees`);
+
+// send the tx
+transfer.signAndSend(alice, ({ events = [], status }) => { ... });
+```
+
 ## Complex transactions
 
 In many cases transactions can carry quite complex information, be it for passing objects or proposing changes. In the next section we will take a dive [into complex transactions, including those wrapped for sudo](api.tx.wrap.md).

docs/start/rpc.custom.md

@@ -0,0 +1,51 @@
+# Custom RPC
+
+In previous sections we looked at the injection of types, as in use and defined in modules from the node. Another area that can be customized is RC definitions, and like with the types, the API provides the capability to add user-defined RPCs (in addition to the Polkadot/Substrate base) to allow use of these RPCs via the API.
+
+## Custom definitions
+
+RPCs are exposed as a method on a specific module, this means that once available you can call any rpc via the `api.rpc.<module>.<method>(...params[])` endpoints. To extend with user-defined RPCs, the injection can happen at the time of API creation with the addition of the `rpc` key (in addition to any other params, such as `types` or `provider`) -
+
+```js
+...
+const api = await ApiPromise.create({
+  rpc: {
+    firstModule: {
+      testMethod: {
+        description: 'Just a test method',
+        params: [
+          {
+            name: 'index',
+            type: 'u64'
+          }
+        ],
+        type: 'Balance'
+      }
+    }
+  }
+});
+```
+
+In the above example we have defined a new method, which is now available on the RPCs as `api.rpc.firstModule.testMethod(u64) => Promise<Balance>`. Do be aware that while defined, the method will only appear if it is in the list as returned by `api.rpc.rpc.methods()`, which is the list of known RPCs the node exposes. When making changes to the node, always ensure that it does expose the RPC method correctly, otherwise it will not be decorated.
+
+## Definition breakdown
+
+While the above example should be self-explanatory, it is important to understand teh structure. The `rpc: { ... }` definitions are keyed first and foremost by the name of the module exposing the RPC. This means that when we have 2 modules `firstModule` & `testModule`, the first-level structure would follow the following pattern,
+
+```js
+...
+const api = await ApiPromise.create({
+  rpc: {
+    firstModule: { ... },
+    testModule: { ... }
+  }
+});
+```
+
+Inside the specific module definitions, the key is the actual expose RPC method. As we have seen in the first example, we expose a `testMethod` on `firstModule`. For the method definitions, apart from the description, we have definitions for the params and return a single result `type`.
+
+Params itself, as an array, contains fields for `name`, `type` and an optional flag `isOptional` that indicates that the field is not required when making the call. (And example of this use would be in cases such as `state.getStorage(key, blockHash?)` where the last param is optional)
+
+## Type creation
+
+While the API always converts all the inputs into the underlying type required by the operation, be it for RPC, query or transaction, in some cases you may want to [create an instance of a type](types.create.md) yourself.

docs/start/types.extend.md

@@ -201,6 +201,6 @@ const api = await ApiPromise.create({
 
 Always look at customization and understand the impacts, replicating these changes between the node and the API. For the above the `Address` type is used in the construction of the `UncheckedExtrinsic` type, while the lookup type is applicable on transactions such as `balances.transfer(to: LookupSource, value: Balance)`
 
-## Type creation
+## Custom RPC
 
-While the API always converts all the inputs into the underlying type required by the operation, in some cases you may want to [create an instance of a type](types.create.md) yourself.
+In addition to customizing modules and types on your node, you can also add custom RPC definitions. Like the type definitions in ths section, [these can be defined and passed to the API](rpc.custom.md) for decoration.

docs/start/typescript.user.md

@@ -1,6 +1,6 @@
 # TypeScript user generated
 
-In the previous section we looked at the TypeScript definitions that are available and is generated from both the chain and definitions. Here we will expand upon the use of the infrastructure created to define types as part of the `@polkadot/types` library and see how to use them to generate your onw definitions and chain types.
+In the previous section we looked at the TypeScript definitions that are available and is generated from both the chain and definitions. Here we will expand upon the use of the infrastructure created to define types as part of the `@polkadot/types` library and see how to use them to generate your own definitions and chain types.
 
 ## Definitions
 

jest.config.js

@@ -7,30 +7,20 @@ module.exports = Object.assign({}, config, {
     '@polkadot/api-contract(.*)$': '<rootDir>/packages/api-contract/src/$1',
     '@polkadot/api-derive(.*)$': '<rootDir>/packages/api-derive/src/$1',
     '@polkadot/api(.*)$': '<rootDir>/packages/api/src/$1',
-    '@polkadot/jsonrpc(.*)$': '<rootDir>/packages/jsonrpc/src/$1',
     '@polkadot/metadata(.*)$': '<rootDir>/packages/metadata/src/$1',
     '@polkadot/rpc-(core|provider)(.*)$': '<rootDir>/packages/rpc-$1/src/$2',
+    '@polkadot/types-known(.*)$': '<rootDir>/packages/types-known/src/$1',
     '@polkadot/types(.*)$': '<rootDir>/packages/types/src/$1'
   },
   modulePathIgnorePatterns: [
     '<rootDir>/packages/api/build',
     '<rootDir>/packages/api-derive/build',
     '<rootDir>/packages/api-contract/build',
-    '<rootDir>/packages/jsonrpc/build',
     '<rootDir>/packages/metadata/build',
     '<rootDir>/packages/rpc-core/build',
     '<rootDir>/packages/rpc-provider/build',
-    '<rootDir>/packages/types/build'
+    '<rootDir>/packages/types/build',
+    '<rootDir>/packages/types-known/build'
   ],
-  globals: {
-    ws_local: 'ws://127.0.0.1:9944/',
-    ws_local_substrate_master: 'ws://127.0.0.1:9945/',
-    ws_local_substrate_1: 'ws://127.0.0.1:9946/',
-    ws_local_substrate_2: 'ws://127.0.0.1:9947/',
-    ws_local_polkadot_master: 'ws://127.0.0.1:9948/',
-    ws_local_polkadot_alex: 'ws://127.0.0.1:9949/',
-    ws_substrate_1: 'wss://substrate-rpc.parity.io/',
-    ws_polkadot_alex: 'wss://poc3-rpc.polkadot.io/'
-  },
   resolver: './jest.resolver.js'
 });

lerna.json

@@ -9,5 +9,5 @@
   "packages": [
     "packages/*"
   ],
-  "version": "1.6.1"
+  "version": "1.9.1"
 }

package.json

@@ -12,7 +12,9 @@
   "scripts": {
     "build": "yarn build:interfaces && polkadot-dev-build-ts && (cd packages/typegen && copyfiles scripts/* build)",
     "build:interfaces": "polkadot-types-internal-interfaces",
+    "build:release": "polkadot-ci-ghact-build",
     "docs": "polkadot-types-internal-metadata && polkadot-dev-build-docs",
+    "docs:release": "polkadot-ci-ghact-docs",
     "chain:info": "polkadot-types-chain-info",
     "lint": "polkadot-dev-run-lint",
     "clean": "polkadot-dev-clean-build",
@@ -22,12 +24,13 @@
     "test:watch": "polkadot-dev-run-test --watch"
   },
   "devDependencies": {
-    "@babel/core": "^7.8.4",
-    "@babel/register": "^7.8.3",
-    "@babel/runtime": "^7.8.4",
-    "@polkadot/dev": "^0.50.30",
-    "@polkadot/ts": "^0.3.7",
+    "@babel/core": "^7.9.0",
+    "@babel/register": "^7.9.0",
+    "@babel/runtime": "^7.9.2",
+    "@polkadot/dev": "^0.51.9",
+    "@polkadot/ts": "^0.3.14",
     "@polkadot/typegen": "workspace:packages/typegen",
+    "@types/jest": "^25.1.4",
     "copyfiles": "^2.2.0"
   }
 }

packages/api-contract/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/api-contract",
-  "version": "1.6.1",
+  "version": "1.9.1",
   "description": "Interfaces for interacting with contracts and contract ABIs",
   "main": "index.js",
   "keywords": [
@@ -26,11 +26,11 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api-contract#readme",
   "dependencies": {
-    "@babel/runtime": "^7.8.4",
-    "@polkadot/api": "1.6.1",
-    "@polkadot/rpc-core": "1.6.1",
-    "@polkadot/types": "1.6.1",
-    "@polkadot/util": "^2.6.2",
+    "@babel/runtime": "^7.9.2",
+    "@polkadot/api": "1.9.1",
+    "@polkadot/rpc-core": "1.9.1",
+    "@polkadot/types": "1.9.1",
+    "@polkadot/util": "^2.7.1",
     "bn.js": "^5.1.1",
     "rxjs": "^6.5.4"
   }

packages/api-contract/src/ContractRegistry.ts

@@ -158,10 +158,10 @@ export default class ContractRegistry extends MetaRegistry {
   public convertContract ({ constructors, messages, name, events, ...contract }: ContractABIContractPre): ContractABIContract {
     return {
       constructors: this.convertConstructors(constructors),
-      messages: messages.map(message => this.convertMessage(message)),
+      messages: messages.map((message) => this.convertMessage(message)),
       name: this.stringAt(name),
       ...(events
-        ? { events: events.map(event => this.convertEvent(event)) }
+        ? { events: events.map((event) => this.convertEvent(event)) }
         : {}),
       ...contract
     };

packages/api-contract/src/MetaRegistry.ts

@@ -275,7 +275,7 @@ export default class MetaRegistry extends MetadataRegistryLookup {
       case 'Result':
         return this.typeDefForResult(id, typeIndex);
       default: {
-        const sub = def['enum.variants'].map(variant => this.typeDefForEnumVariant(variant));
+        const sub = def['enum.variants'].map((variant) => this.typeDefForEnumVariant(variant));
 
         return {
           info: TypeDefInfo.Enum,

packages/api-contract/src/types.ts

@@ -7,7 +7,6 @@ import { AccountId, Address, ContractExecResult } from '@polkadot/types/interfac
 import { Codec, CodecArg } from '@polkadot/types/types';
 import { MetaRegistryJson, StringIndex, TypeIndex, TypeDef } from '@polkadot/types/create/types';
 
-// import { Observable } from 'rxjs';
 import { ApiPromise, ApiRx } from '@polkadot/api';
 
 export type ApiObject<ApiType extends ApiTypes> = ApiType extends 'rxjs'

packages/api-contract/src/util.ts

@@ -2,7 +2,7 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { Codec, Registry, TypeDefInfo, TypeDef } from '@polkadot/types/types';
+import { Codec, Registry, TypeDef, TypeDefInfo } from '@polkadot/types/types';
 
 import { Option, Raw, createClass, createTypeUnsafe } from '@polkadot/types';
 

packages/api-derive/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/api-derive",
-  "version": "1.6.1",
+  "version": "1.9.1",
   "description": "Common functions used across Polkadot, derived from RPC calls and storage queries.",
   "main": "index.js",
   "keywords": [
@@ -27,18 +27,18 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api-derive#readme",
   "dependencies": {
-    "@babel/runtime": "^7.8.4",
-    "@polkadot/api": "1.6.1",
-    "@polkadot/rpc-core": "1.6.1",
-    "@polkadot/rpc-provider": "1.6.1",
-    "@polkadot/types": "1.6.1",
-    "@polkadot/util": "^2.6.2",
-    "@polkadot/util-crypto": "^2.6.2",
+    "@babel/runtime": "^7.9.2",
+    "@polkadot/api": "1.9.1",
+    "@polkadot/rpc-core": "1.9.1",
+    "@polkadot/rpc-provider": "1.9.1",
+    "@polkadot/types": "1.9.1",
+    "@polkadot/util": "^2.7.1",
+    "@polkadot/util-crypto": "^2.7.1",
     "bn.js": "^5.1.1",
     "memoizee": "^0.4.14",
     "rxjs": "^6.5.4"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^2.6.2"
+    "@polkadot/keyring": "^2.7.1"
   }
 }

packages/api-derive/src/accounts/idAndIndex.ts

@@ -7,7 +7,6 @@ import { AccountId, AccountIndex, Address } from '@polkadot/types/interfaces';
 import { Observable, of } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { createType } from '@polkadot/types';
 import { isU8a } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';
 
@@ -23,14 +22,14 @@ function retrieve (api: ApiInterfaceRx, address: Address | AccountId | AccountIn
       : decodeAddress((address || '').toString());
 
     if (decoded.length === 32) {
-      const accountId = createType(api.registry, 'AccountId', decoded);
+      const accountId = api.registry.createType('AccountId', decoded);
 
       return api.derive.accounts.idToIndex(accountId).pipe(
         map((accountIndex): AccountIdAndIndex => [accountId, accountIndex])
       );
     }
 
-    const accountIndex = createType(api.registry, 'AccountIndex', decoded);
+    const accountIndex = api.registry.createType('AccountIndex', decoded);
 
     return api.derive.accounts.indexToId(accountIndex).pipe(
       map((accountId): AccountIdAndIndex => [accountId, accountIndex])

packages/api-derive/src/accounts/indexToId.ts

@@ -9,14 +9,14 @@ import { Observable, of } from 'rxjs';
 import { map, startWith } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { ENUMSET_SIZE } from '@polkadot/types/generic/AccountIndex';
-import { Option, Vec, createType } from '@polkadot/types';
+import { Option, Vec } from '@polkadot/types';
 
 import { memo } from '../util';
 
 function queryEnumSet (api: ApiInterfaceRx, _accountIndex: AccountIndex | string): Observable<AccountId | undefined> {
   const accountIndex = _accountIndex instanceof api.registry.createClass('AccountIndex')
     ? _accountIndex
-    : createType(api.registry, 'AccountIndex', _accountIndex);
+    : api.registry.createType('AccountIndex', _accountIndex);
 
   return api.query.indices.enumSet<Vec<AccountId>>(accountIndex.div(ENUMSET_SIZE)).pipe(
     startWith([]),

packages/api-derive/src/accounts/indexes.ts

@@ -9,7 +9,7 @@ import { AccountIndexes } from '../types';
 import { Observable, of } from 'rxjs';
 import { map, startWith, switchMap } from 'rxjs/operators';
 import { ENUMSET_SIZE } from '@polkadot/types/generic/AccountIndex';
-import { Vec, createType } from '@polkadot/types';
+import { Vec } from '@polkadot/types';
 
 import { memo } from '../util';
 
@@ -31,7 +31,7 @@ function queryEnumSet (api: ApiInterfaceRx): Observable<AccountIndexes> {
           // 64 (0..63 in first) is [1][0] (the first index value in set 2)
           const index = (outerIndex * enumsetSize) + innerIndex;
 
-          indexes[accountId.toString()] = createType(api.registry, 'AccountIndex', index);
+          indexes[accountId.toString()] = api.registry.createType('AccountIndex', index);
         });
 
         return indexes;

packages/api-derive/src/accounts/info.ts

@@ -5,11 +5,11 @@
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { AccountId, AccountIndex, Address, Balance, Registration } from '@polkadot/types/interfaces';
 import { ITuple } from '@polkadot/types/types';
-import { DeriveAccountInfo, DeriveAccountRegistration } from '../types';
+import { DeriveAccountFlags, DeriveAccountInfo, DeriveAccountRegistration } from '../types';
 
 import { Observable, combineLatest, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
-import { Bytes, Data, Option, u32 } from '@polkadot/types';
+import { Bytes, Data, Option, u32, Vec } from '@polkadot/types';
 import { u8aToString } from '@polkadot/util';
 
 import { memo } from '../util';
@@ -22,6 +22,12 @@ function dataAsString (data: Data): string | undefined {
       : undefined;
 }
 
+function includedWrapper (accountId?: AccountId): (_: AccountId) => boolean {
+  return function (id: AccountId): boolean {
+    return id.eq(accountId);
+  };
+}
+
 function retrieveNick (api: ApiInterfaceRx, accountId?: AccountId): Observable<string | undefined> {
   return ((
     accountId && api.query.nicks?.nameOf
@@ -109,6 +115,39 @@ function retrieveIdentity (api: ApiInterfaceRx, accountId?: AccountId): Observab
   );
 }
 
+function retrieveFlags (api: ApiInterfaceRx, accountId?: AccountId): Observable<DeriveAccountFlags> {
+  const councilSection = api.query.electionsPhragmen ? 'electionsPhragmen' : 'elections';
+
+  return combineLatest([
+    api.query[councilSection]?.members
+      ? api.query[councilSection].members<Vec<ITuple<[AccountId, Balance]>>>()
+      : of(undefined),
+    api.query.council?.members
+      ? api.query.council.members()
+      : of([]),
+    api.query.technicalCommittee?.members
+      ? api.query.technicalCommittee.members()
+      : of([]),
+    api.query.society?.members
+      ? api.query.society.members()
+      : of([]),
+    api.query.sudo?.key
+      ? api.query.sudo.key()
+      : of(undefined)
+  ]).pipe(
+    map(([electionsMembers, councilMembers, technicalCommitteeMembers, societyMembers, sudoKey]): DeriveAccountFlags => {
+      const checkIncluded = includedWrapper(accountId);
+
+      return {
+        isCouncil: (electionsMembers?.map(([id]) => id) || councilMembers || []).some(checkIncluded),
+        isTechCommittee: technicalCommitteeMembers.some(checkIncluded),
+        isSociety: societyMembers.some(checkIncluded),
+        isSudo: !!sudoKey && sudoKey.eq(accountId)
+      };
+    })
+  );
+}
+
 /**
  * @name info
  * @description Returns aux. info with regards to an account, current that includes the accountId, accountIndex and nickname
@@ -116,15 +155,16 @@ function retrieveIdentity (api: ApiInterfaceRx, accountId?: AccountId): Observab
 export function info (api: ApiInterfaceRx): (address?: AccountIndex | AccountId | Address | string | null) => Observable<DeriveAccountInfo> {
   return memo((address?: AccountIndex | AccountId | Address | string | null): Observable<DeriveAccountInfo> =>
     api.derive.accounts.idAndIndex(address).pipe(
-      switchMap(([accountId, accountIndex]): Observable<[Partial<DeriveAccountInfo>, DeriveAccountRegistration, string?]> =>
+      switchMap(([accountId, accountIndex]): Observable<[Partial<DeriveAccountInfo>, DeriveAccountFlags, DeriveAccountRegistration, string?]> =>
         combineLatest([
           of({ accountId, accountIndex }),
+          retrieveFlags(api, accountId),
           retrieveIdentity(api, accountId),
           retrieveNick(api, accountId)
         ])
       ),
-      map(([{ accountId, accountIndex }, identity, nickname]): DeriveAccountInfo => ({
-        accountId, accountIndex, identity, nickname
+      map(([{ accountId, accountIndex }, flags, identity, nickname]): DeriveAccountInfo => ({
+        accountId, accountIndex, ...flags, identity, nickname
       }))
     ));
 }

packages/api-derive/src/balances/account.ts

@@ -4,18 +4,17 @@
 
 import { AccountId, AccountData, AccountIndex, AccountInfo, Address, Balance, Index } from '@polkadot/types/interfaces';
 import { ITuple } from '@polkadot/types/types';
-import { DerivedBalancesAccount } from '../types';
+import { DeriveBalancesAccount } from '../types';
 
-import { combineLatest, of, Observable } from 'rxjs';
+import { Observable, combineLatest, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { createType } from '@polkadot/types';
 
 import { memo } from '../util';
 
 type Result = [Balance, Balance, Balance, Balance, Index];
 
-function calcBalances (api: ApiInterfaceRx, [accountId, [freeBalance, reservedBalance, frozenFee, frozenMisc, accountNonce]]: [AccountId, Result]): DerivedBalancesAccount {
+function calcBalances (api: ApiInterfaceRx, [accountId, [freeBalance, reservedBalance, frozenFee, frozenMisc, accountNonce]]: [AccountId, Result]): DeriveBalancesAccount {
   return {
     accountId,
     accountNonce,
@@ -23,7 +22,7 @@ function calcBalances (api: ApiInterfaceRx, [accountId, [freeBalance, reservedBa
     frozenFee,
     frozenMisc,
     reservedBalance,
-    votingBalance: createType(api.registry, 'Balance', freeBalance.add(reservedBalance))
+    votingBalance: api.registry.createType('Balance', freeBalance.add(reservedBalance))
   };
 }
 
@@ -35,7 +34,7 @@ function queryBalancesFree (api: ApiInterfaceRx, accountId: AccountId): Observab
     [api.query.system.accountNonce, accountId]
   ]).pipe(
     map(([freeBalance, reservedBalance, accountNonce]): Result =>
-      [freeBalance, reservedBalance, createType(api.registry, 'Balance'), createType(api.registry, 'Balance'), accountNonce]
+      [freeBalance, reservedBalance, api.registry.createType('Balance'), api.registry.createType('Balance'), accountNonce]
     )
   );
 }
@@ -80,8 +79,8 @@ function queryCurrent (api: ApiInterfaceRx, accountId: AccountId): Observable<Re
  * });
  * ```
  */
-export function account (api: ApiInterfaceRx): (address: AccountIndex | AccountId | Address | string) => Observable<DerivedBalancesAccount> {
-  return memo((address: AccountIndex | AccountId | Address | string): Observable<DerivedBalancesAccount> =>
+export function account (api: ApiInterfaceRx): (address: AccountIndex | AccountId | Address | string) => Observable<DeriveBalancesAccount> {
+  return memo((address: AccountIndex | AccountId | Address | string): Observable<DeriveBalancesAccount> =>
     api.derive.accounts.info(address).pipe(
       switchMap(({ accountId }): Observable<[AccountId, Result]> =>
         (accountId
@@ -93,9 +92,9 @@ export function account (api: ApiInterfaceRx): (address: AccountIndex | AccountI
                 ? queryBalancesAccount(api, accountId)
                 : queryBalancesFree(api, accountId)
           ])
-          : of([createType(api.registry, 'AccountId'), [createType(api.registry, 'Balance'), createType(api.registry, 'Balance'), createType(api.registry, 'Balance'), createType(api.registry, 'Balance'), createType(api.registry, 'Index')]])
+          : of([api.registry.createType('AccountId'), [api.registry.createType('Balance'), api.registry.createType('Balance'), api.registry.createType('Balance'), api.registry.createType('Balance'), api.registry.createType('Index')]])
         )
       ),
-      map((result): DerivedBalancesAccount => calcBalances(api, result))
+      map((result): DeriveBalancesAccount => calcBalances(api, result))
     ));
 }

packages/api-derive/src/balances/all.ts

@@ -3,22 +3,22 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { AccountId, AccountIndex, Address, Balance, BalanceLock, BalanceLockTo212, BlockNumber, VestingInfo, VestingSchedule } from '@polkadot/types/interfaces';
-import { DerivedBalancesAccount, DerivedBalancesAll } from '../types';
+import { DeriveBalancesAccount, DeriveBalancesAll } from '../types';
 
 import BN from 'bn.js';
-import { combineLatest, of, Observable } from 'rxjs';
+import { Observable, combineLatest, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { Option, Vec, createType } from '@polkadot/types';
+import { Option, Vec } from '@polkadot/types';
 import { bnMax } from '@polkadot/util';
 
 import { memo } from '../util';
 
 type ResultBalance = [VestingInfo | null, (BalanceLock | BalanceLockTo212)[]];
-type Result = [DerivedBalancesAccount, BlockNumber, ResultBalance];
+type Result = [DeriveBalancesAccount, BlockNumber, ResultBalance];
 
-function calcBalances (api: ApiInterfaceRx, [{ accountId, accountNonce, freeBalance, frozenFee, frozenMisc, reservedBalance, votingBalance }, bestNumber, [vesting, locks]]: Result): DerivedBalancesAll {
-  let lockedBalance = createType(api.registry, 'Balance');
+function calcBalances (api: ApiInterfaceRx, [{ accountId, accountNonce, freeBalance, frozenFee, frozenMisc, reservedBalance, votingBalance }, bestNumber, [vesting, locks]]: Result): DeriveBalancesAll {
+  let lockedBalance = api.registry.createType('Balance');
   let lockedBreakdown: (BalanceLock | BalanceLockTo212)[] = [];
   let allLocked = false;
 
@@ -32,16 +32,16 @@ function calcBalances (api: ApiInterfaceRx, [{ accountId, accountNonce, freeBala
 
     // get the maximum of the locks according to https://github.com/paritytech/substrate/blob/master/srml/balances/src/lib.rs#L699
     if (notAll.length) {
-      lockedBalance = createType(api.registry, 'Balance', bnMax(...notAll.map(({ amount }): Balance => amount)));
+      lockedBalance = api.registry.createType('Balance', bnMax(...notAll.map(({ amount }): Balance => amount)));
     }
   }
 
   // Calculate the vesting balances,
   //  - offset = balance locked at startingBlock
   //  - perBlock is the unlock amount
-  const { locked: vestingTotal, perBlock, startingBlock } = vesting || createType(api.registry, 'VestingInfo');
+  const { locked: vestingTotal, perBlock, startingBlock } = vesting || api.registry.createType('VestingInfo');
   const isStarted = bestNumber.gt(startingBlock);
-  const vestedBalance = createType(api.registry, 'Balance', isStarted ? perBlock.mul(bestNumber.sub(startingBlock)) : 0);
+  const vestedBalance = api.registry.createType('Balance', isStarted ? perBlock.mul(bestNumber.sub(startingBlock)) : 0);
   const isVesting = isStarted && vestedBalance.lt(vestingTotal);
 
   // The available balance & vested has an interplay here
@@ -53,7 +53,7 @@ function calcBalances (api: ApiInterfaceRx, [{ accountId, accountNonce, freeBala
   // ""
   const floating = freeBalance.sub(lockedBalance);
   const extraReceived = isVesting ? freeBalance.sub(vestingTotal) : new BN(0);
-  const availableBalance = createType(api.registry, 'Balance', allLocked ? 0 : bnMax(new BN(0), isVesting && floating.gt(vestedBalance) ? vestedBalance.add(extraReceived) : floating));
+  const availableBalance = api.registry.createType('Balance', allLocked ? 0 : bnMax(new BN(0), isVesting && floating.gt(vestedBalance) ? vestedBalance.add(extraReceived) : floating));
 
   return {
     accountId,
@@ -84,7 +84,7 @@ function queryOld (api: ApiInterfaceRx, accountId: AccountId): Observable<Result
       if (optVesting.isSome) {
         const { offset: locked, perBlock, startingBlock } = optVesting.unwrap();
 
-        vestingNew = createType(api.registry, 'VestingInfo', { locked, perBlock, startingBlock });
+        vestingNew = api.registry.createType('VestingInfo', { locked, perBlock, startingBlock });
       }
 
       return [vestingNew, locks];
@@ -102,7 +102,7 @@ function queryCurrent (api: ApiInterfaceRx, accountId: AccountId): Observable<Re
       ])
       : api.query.balances.locks(accountId).pipe(
         map((locks): [Vec<BalanceLock>, Option<VestingInfo>] =>
-          [locks, createType(api.registry, 'Option<VestingInfo>')]
+          [locks, api.registry.createType('Option<VestingInfo>')]
         )
       )
   ).pipe(
@@ -127,8 +127,8 @@ function queryCurrent (api: ApiInterfaceRx, accountId: AccountId): Observable<Re
  * });
  * ```
  */
-export function all (api: ApiInterfaceRx): (address: AccountIndex | AccountId | Address | string) => Observable<DerivedBalancesAll> {
-  return memo((address: AccountIndex | AccountId | Address | string): Observable<DerivedBalancesAll> =>
+export function all (api: ApiInterfaceRx): (address: AccountIndex | AccountId | Address | string) => Observable<DeriveBalancesAll> {
+  return memo((address: AccountIndex | AccountId | Address | string): Observable<DeriveBalancesAll> =>
     api.derive.balances.account(address).pipe(
       switchMap((account): Observable<Result> =>
         (!account.accountId.isEmpty
@@ -139,9 +139,9 @@ export function all (api: ApiInterfaceRx): (address: AccountIndex | AccountId |
               ? queryCurrent(api, account.accountId)
               : queryOld(api, account.accountId)
           ])
-          : of([account, createType(api.registry, 'BlockNumber'), [null, createType(api.registry, 'Vec<BalanceLock>')]])
+          : of([account, api.registry.createType('BlockNumber'), [null, api.registry.createType('Vec<BalanceLock>')]])
         )
       ),
-      map((result): DerivedBalancesAll => calcBalances(api, result))
+      map((result): DeriveBalancesAll => calcBalances(api, result))
     ));
 }

packages/api-derive/src/balances/fees.ts

@@ -4,11 +4,10 @@
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { Balance } from '@polkadot/types/interfaces';
-import { DerivedFees } from '../types';
+import { DeriveFees } from '../types';
 
 import { Observable, of } from 'rxjs';
 import { map } from 'rxjs/operators';
-import { createType } from '@polkadot/types';
 
 import { memo } from '../util';
 
@@ -25,19 +24,19 @@ import { memo } from '../util';
  * });
  * ```
  */
-export function fees (api: ApiInterfaceRx): () => Observable<DerivedFees> {
-  return memo((): Observable<DerivedFees> =>
+export function fees (api: ApiInterfaceRx): () => Observable<DeriveFees> {
+  return memo((): Observable<DeriveFees> =>
     of([
       // deprecated - remove
-      (api.consts.balances?.creationFee as Balance) || createType(api.registry, 'Balance'),
-      (api.consts.balances?.transferFee as Balance) || createType(api.registry, 'Balance'),
+      (api.consts.balances?.creationFee as Balance) || api.registry.createType('Balance'),
+      (api.consts.balances?.transferFee as Balance) || api.registry.createType('Balance'),
 
       // current
-      (api.consts.balances?.existentialDeposit as Balance) || createType(api.registry, 'Balance'),
-      (api.consts.transactionPayment?.transactionBaseFee as Balance) || createType(api.registry, 'Balance'),
-      (api.consts.transactionPayment?.transactionByteFee as Balance) || createType(api.registry, 'Balance')
+      (api.consts.balances?.existentialDeposit as Balance) || api.registry.createType('Balance'),
+      (api.consts.transactionPayment?.transactionBaseFee as Balance) || api.registry.createType('Balance'),
+      (api.consts.transactionPayment?.transactionByteFee as Balance) || api.registry.createType('Balance')
     ]).pipe(
-      map(([creationFee, transferFee, existentialDeposit, transactionBaseFee, transactionByteFee]): DerivedFees => ({
+      map(([creationFee, transferFee, existentialDeposit, transactionBaseFee, transactionByteFee]): DeriveFees => ({
         creationFee,
         existentialDeposit,
         transactionBaseFee,

packages/api-derive/src/balances/votingBalances.ts

@@ -3,20 +3,21 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { AccountId, AccountIndex, Address } from '@polkadot/types/interfaces';
-import { DerivedBalancesAccount } from '../types';
+import { DeriveBalancesAccount } from '../types';
 
-import { combineLatest, Observable, of } from 'rxjs';
+import { Observable, combineLatest, of } from 'rxjs';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 
 import { memo } from '../util';
 
-export function votingBalances (api: ApiInterfaceRx): (addresses?: (AccountId | AccountIndex | Address | string)[]) => Observable<DerivedBalancesAccount[]> {
-  return memo((addresses?: (AccountId | AccountIndex | Address | string)[]): Observable<DerivedBalancesAccount[]> =>
+export function votingBalances (api: ApiInterfaceRx): (addresses?: (AccountId | AccountIndex | Address | string)[]) => Observable<DeriveBalancesAccount[]> {
+  return memo((addresses?: (AccountId | AccountIndex | Address | string)[]): Observable<DeriveBalancesAccount[]> =>
     !addresses || !addresses.length
-      ? of([] as DerivedBalancesAccount[])
+      ? of([] as DeriveBalancesAccount[])
       : combineLatest(
-        addresses.map((accountId): Observable<DerivedBalancesAccount> =>
-          api.derive.balances.account(accountId))
+        addresses.map((accountId): Observable<DeriveBalancesAccount> =>
+          api.derive.balances.account(accountId)
+        )
       )
   );
 }

packages/api-derive/src/chain/bestNumberLag.ts

@@ -7,7 +7,6 @@ import { BlockNumber } from '@polkadot/types/interfaces';
 import { Observable, combineLatest } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { createType } from '@polkadot/types';
 
 import { memo } from '../util';
 
@@ -31,7 +30,7 @@ export function bestNumberLag (api: ApiInterfaceRx): () => Observable<BlockNumbe
       api.derive.chain.bestNumberFinalized()
     ]).pipe(
       map(([bestNumber, bestNumberFinalized]): BlockNumber =>
-        createType(api.registry, 'BlockNumber', bestNumber.sub(bestNumberFinalized))
+        api.registry.createType('BlockNumber', bestNumber.sub(bestNumberFinalized))
       )
     ));
 }

packages/api-derive/src/collective/proposals.ts

@@ -4,17 +4,17 @@
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { Hash, Proposal, Votes } from '@polkadot/types/interfaces';
-import { DerivedCollectiveProposal } from '../types';
+import { DeriveCollectiveProposal } from '../types';
 
-import { combineLatest, Observable, of } from 'rxjs';
+import { Observable, combineLatest, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
 import { Option } from '@polkadot/types';
 
 type Result = [Hash[], Option<Proposal>[], Option<Votes>[]];
 
-function parse ([hashes, proposals, votes]: Result): DerivedCollectiveProposal[] {
+function parse ([hashes, proposals, votes]: Result): DeriveCollectiveProposal[] {
   return proposals
-    .map((proposalOpt, index): DerivedCollectiveProposal | null =>
+    .map((proposalOpt, index): DeriveCollectiveProposal | null =>
       proposalOpt.isSome
         ? {
           hash: hashes[index],
@@ -23,11 +23,11 @@ function parse ([hashes, proposals, votes]: Result): DerivedCollectiveProposal[]
         }
         : null
     )
-    .filter((proposal): proposal is DerivedCollectiveProposal => !!proposal);
+    .filter((proposal): proposal is DeriveCollectiveProposal => !!proposal);
 }
 
-export function proposals (api: ApiInterfaceRx, section: 'council' | 'technicalCommittee'): () => Observable<DerivedCollectiveProposal[]> {
-  return (): Observable<DerivedCollectiveProposal[]> =>
+export function proposals (api: ApiInterfaceRx, section: 'council' | 'technicalCommittee'): () => Observable<DeriveCollectiveProposal[]> {
+  return (): Observable<DeriveCollectiveProposal[]> =>
     api.query[section]?.proposals
       ? api.query[section].proposals().pipe(
         switchMap((hashes: Hash[]): Observable<Result> =>
@@ -41,5 +41,5 @@ export function proposals (api: ApiInterfaceRx, section: 'council' | 'technicalC
         ),
         map(parse)
       )
-      : of([] as DerivedCollectiveProposal[]);
+      : of([] as DeriveCollectiveProposal[]);
 }

packages/api-derive/src/contracts/fees.ts

@@ -3,12 +3,11 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { DerivedContractFees } from '../types';
+import { DeriveContractFees } from '../types';
 
 import BN from 'bn.js';
 import { Observable, of } from 'rxjs';
 import { map } from 'rxjs/operators';
-import { createType } from '@polkadot/types';
 
 import { memo } from '../util';
 
@@ -18,8 +17,8 @@ type ResultV2 = [BN, BN, BN, BN, BN, BN, BN, BN, BN];
 function queryConstants (api: ApiInterfaceRx): Observable<ResultV2> {
   return of([
     // deprecated
-    api.consts.contracts.creationFee || createType(api.registry, 'Balance'),
-    api.consts.contracts.transferFee || createType(api.registry, 'Balance'),
+    api.consts.contracts.creationFee || api.registry.createType('Balance'),
+    api.consts.contracts.transferFee || api.registry.createType('Balance'),
 
     // current
     api.consts.contracts.callBaseFee,
@@ -45,10 +44,10 @@ function queryConstants (api: ApiInterfaceRx): Observable<ResultV2> {
  * });
  * ```
  */
-export function fees (api: ApiInterfaceRx): () => Observable<DerivedContractFees> {
-  return memo((): Observable<DerivedContractFees> => {
+export function fees (api: ApiInterfaceRx): () => Observable<DeriveContractFees> {
+  return memo((): Observable<DeriveContractFees> => {
     return queryConstants(api).pipe(
-      map(([creationFee, transferFee, callBaseFee, contractFee, rentByteFee, rentDepositOffset, tombstoneDeposit, transactionBaseFee, transactionByteFee]): DerivedContractFees => ({
+      map(([creationFee, transferFee, callBaseFee, contractFee, rentByteFee, rentDepositOffset, tombstoneDeposit, transactionBaseFee, transactionByteFee]): DeriveContractFees => ({
         callBaseFee,
         contractFee,
         creationFee,

packages/api-derive/src/council/index.ts

@@ -3,3 +3,5 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 export * from './proposals';
+export * from './votes';
+export * from './votesOf';

packages/api-derive/src/council/proposals.ts

@@ -3,12 +3,12 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { DerivedCollectiveProposals } from '../types';
+import { DeriveCollectiveProposals } from '../types';
 
 import { Observable } from 'rxjs';
 import { proposals as collectiveProposals } from '../collective';
 import { memo } from '../util';
 
-export function proposals (api: ApiInterfaceRx): () => Observable<DerivedCollectiveProposals> {
+export function proposals (api: ApiInterfaceRx): () => Observable<DeriveCollectiveProposals> {
   return memo(collectiveProposals(api, 'council'));
 }

packages/api-derive/src/council/types.ts

@@ -0,0 +1,12 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { AccountId, Balance } from '@polkadot/types/interfaces';
+
+export interface DeriveCouncilVote {
+  stake: Balance;
+  votes: AccountId[];
+}
+
+export type DeriveCouncilVotes = [AccountId, DeriveCouncilVote][];

packages/api-derive/src/council/votes.ts

@@ -0,0 +1,88 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { AccountId, Balance } from '@polkadot/types/interfaces';
+import { ITuple } from '@polkadot/types/types';
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { DeriveCouncilVote, DeriveCouncilVotes } from '../types';
+
+import { Observable, combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Vec } from '@polkadot/types';
+
+function retrieveStakeOf (api: ApiInterfaceRx): Observable<[AccountId, Balance][]> {
+  const elections = (api.query.electionsPhragmen || api.query.elections);
+
+  return elections.stakeOf.creator.meta.type.asMap.linked.isTrue
+    ? elections.stakeOf<ITuple<[Vec<AccountId>, Vec<Balance>]>>().pipe(
+      map(([voters, stake]) =>
+        voters.map((voter, index): [AccountId, Balance] => [voter, stake[index]])
+      )
+    )
+    : elections.stakeOf.entries<Balance>().pipe(
+      map((entries) =>
+        entries.map(([key, stake]) => [key.args[0] as AccountId, stake])
+      )
+    );
+}
+
+function retrieveVoteOf (api: ApiInterfaceRx): Observable<[AccountId, AccountId[]][]> {
+  const elections = (api.query.electionsPhragmen || api.query.elections);
+
+  return elections.votesOf.creator.meta.type.asMap.linked.isTrue
+    ? elections.votesOf<ITuple<[Vec<AccountId>, Vec<Vec<AccountId>>]>>().pipe(
+      map(([voters, votes]) =>
+        voters.map((voter, index) => [voter, votes[index]])
+      )
+    )
+    : elections.votesOf.entries<Vec<AccountId>>().pipe(
+      map((entries) =>
+        entries.map(([key, votes]) => [key.args[0] as AccountId, votes])
+      )
+    );
+}
+
+function retrievePrev (api: ApiInterfaceRx): Observable<DeriveCouncilVotes> {
+  return combineLatest([retrieveStakeOf(api), retrieveVoteOf(api)]).pipe(
+    map(([stakes, votes]): DeriveCouncilVotes => {
+      const result: DeriveCouncilVotes = [];
+
+      votes.forEach(([voter, votes]): void => {
+        result.push([voter, { stake: api.registry.createType('Balance'), votes }]);
+      });
+
+      stakes.forEach(([staker, stake]): void => {
+        const entry = result.find(([voter]) => voter.eq(staker));
+
+        if (entry) {
+          entry[1].stake = stake;
+        } else {
+          result.push([staker, { stake, votes: [] }]);
+        }
+      });
+
+      return result;
+    })
+  );
+}
+
+function retrieveCurrent (api: ApiInterfaceRx): Observable<DeriveCouncilVotes> {
+  const elections = (api.query.electionsPhragmen || api.query.elections);
+
+  return elections.voting.entries<ITuple<[Balance, Vec<AccountId>]>>().pipe(
+    map((entries): DeriveCouncilVotes =>
+      entries.map(([key, [stake, votes]]): [AccountId, DeriveCouncilVote] =>
+        [key.args[0] as AccountId, { stake, votes }]
+      )
+    )
+  );
+}
+
+export function votes (api: ApiInterfaceRx): () => Observable<DeriveCouncilVotes> {
+  // since we are using entries, we are not adding a memo
+  return (): Observable<DeriveCouncilVotes> =>
+    (api.query.electionsPhragmen || api.query.elections).stakeOf
+      ? retrievePrev(api)
+      : retrieveCurrent(api);
+}

packages/api-derive/src/council/votesOf.ts

@@ -0,0 +1,23 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { AccountId } from '@polkadot/types/interfaces';
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { DeriveCouncilVote } from '../types';
+
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+export function votesOf (api: ApiInterfaceRx): (accountId: string | Uint8Array | AccountId) => Observable<DeriveCouncilVote> {
+  // no memo, votes actually pulls the entries without a memo (using entries)
+  return (accountId: string | Uint8Array | AccountId): Observable<DeriveCouncilVote> =>
+    api.derive.council.votes().pipe(
+      map((votes): DeriveCouncilVote =>
+        (
+          votes.find(([from]) => from.eq(accountId)) ||
+          [null, { stake: api.registry.createType('Balance'), votes: [] as AccountId[] }]
+        )[1]
+      )
+    );
+}

packages/api-derive/src/democracy/_referendumInfo.ts

@@ -0,0 +1,32 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { ReferendumInfo, ReferendumInfoTo239 } from '@polkadot/types/interfaces';
+import { DeriveReferendum } from '../types';
+
+import BN from 'bn.js';
+import { Observable, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Option } from '@polkadot/types';
+
+import { memo } from '../util';
+import { getStatus, parseImage } from './util';
+
+export function _referendumInfo (api: ApiInterfaceRx): (index: BN, info: Option<ReferendumInfo | ReferendumInfoTo239>) => Observable<DeriveReferendum | null> {
+  return memo((index: BN, info: Option<ReferendumInfo | ReferendumInfoTo239>): Observable<DeriveReferendum | null> => {
+    const status = getStatus(info);
+
+    return status
+      ? api.query.democracy.preimages(status.proposalHash).pipe(
+        map((preimage): DeriveReferendum => ({
+          index: api.registry.createType('ReferendumIndex', index),
+          image: parseImage(api, preimage),
+          imageHash: status.proposalHash,
+          status
+        }))
+      )
+      : of(null);
+  });
+}

packages/api-derive/src/democracy/_referendumVotes.ts

@@ -0,0 +1,84 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { AccountId, Vote, Voting, VotingDirectVote } from '@polkadot/types/interfaces';
+import { DeriveBalancesAccount, DeriveReferendum, DeriveReferendumVote, DeriveReferendumVotes } from '../types';
+
+import BN from 'bn.js';
+import { Observable, of, combineLatest } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { Vec } from '@polkadot/types';
+
+import { memo } from '../util';
+import { calcVotes } from './util';
+
+function votesPrev (api: ApiInterfaceRx, referendumId: BN): Observable<DeriveReferendumVote[]> {
+  return api.query.democracy.votersFor<Vec<AccountId>>(referendumId).pipe(
+    switchMap((votersFor): Observable<[Vec<AccountId>, Vote[], DeriveBalancesAccount[]]> =>
+      combineLatest([
+        of(votersFor),
+        votersFor.length
+          ? api.query.democracy.voteOf.multi<Vote>(
+            votersFor.map((accountId): [BN | number, AccountId] =>
+              [referendumId, accountId]
+            )
+          )
+          : of([]),
+        api.derive.balances.votingBalances(votersFor)
+      ])
+    ),
+    map(([votersFor, votes, balances]): DeriveReferendumVote[] =>
+      votersFor.map((accountId, index): DeriveReferendumVote => ({
+        accountId,
+        balance: balances[index].votingBalance || api.registry.createType('Balance'),
+        vote: votes[index] || api.registry.createType('Vote')
+      }))
+    )
+  );
+}
+
+function votesCurr (api: ApiInterfaceRx, referendumId: BN): Observable<DeriveReferendumVote[]> {
+  return api.query.democracy.votingOf.entries<Voting>().pipe(
+    map((allVoting): DeriveReferendumVote[] =>
+      allVoting
+        .map(([key, voting]): [AccountId, Voting] => [key.args[0] as AccountId, voting])
+        // FIXME We are ignoring delegated votes
+        .filter(([, voting]) => voting.isDirect)
+        .map(([accountId, voting]): [AccountId, VotingDirectVote[]] => [
+          accountId,
+          voting.asDirect.votes.filter(([idx]) => idx.eq(referendumId))
+        ])
+        .filter(([, directVotes]) => !!directVotes.length)
+        .reduce((result: DeriveReferendumVote[], [accountId, votes]) =>
+          // FIXME We are ignoring split votes
+          votes.reduce((result: DeriveReferendumVote[], [, vote]): DeriveReferendumVote[] => {
+            if (vote.isStandard) {
+              result.push({
+                accountId,
+                ...vote.asStandard
+              });
+            }
+
+            return result;
+          }, result), []
+        )
+    )
+  );
+}
+
+export function _referendumVotes (api: ApiInterfaceRx): (referendum: DeriveReferendum) => Observable<DeriveReferendumVotes> {
+  return memo((referendum: DeriveReferendum): Observable<DeriveReferendumVotes> =>
+    combineLatest([
+      api.derive.democracy.sqrtElectorate(),
+      api.query.democracy.votingOf
+        ? votesCurr(api, referendum.index)
+        : votesPrev(api, referendum.index)
+    ]).pipe(
+      map(([sqrtElectorate, votes]) =>
+        calcVotes(sqrtElectorate, referendum, votes)
+      )
+    )
+  );
+}

packages/api-derive/src/democracy/_referendumsVotes.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { DeriveReferendum, DeriveReferendumVotes } from '../types';
+
+import { Observable, of, combineLatest } from 'rxjs';
+
+import { memo } from '../util';
+
+export function _referendumsVotes (api: ApiInterfaceRx): (referendums: DeriveReferendum[]) => Observable<DeriveReferendumVotes[]> {
+  return memo((referendums: DeriveReferendum[]): Observable<DeriveReferendumVotes[]> =>
+    referendums.length
+      ? combineLatest(
+        referendums.map((referendum): Observable<DeriveReferendumVotes> =>
+          api.derive.democracy._referendumVotes(referendum)
+        )
+      )
+      : of([])
+  );
+}

packages/api-derive/src/democracy/dispatchQueue.ts

@@ -0,0 +1,38 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { BlockNumber, Hash, ReferendumIndex } from '@polkadot/types/interfaces';
+import { ITuple } from '@polkadot/types/types';
+import { DeriveDispatch } from '../types';
+
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { Vec } from '@polkadot/types';
+
+import { memo } from '../util';
+
+export function dispatchQueue (api: ApiInterfaceRx): () => Observable<DeriveDispatch[]> {
+  return memo((): Observable<DeriveDispatch[]> =>
+    api.query.democracy?.dispatchQueue
+      ? api.query.democracy.dispatchQueue<Vec<ITuple<[BlockNumber, Hash, ReferendumIndex]>>>().pipe(
+        switchMap((dispatches) =>
+          combineLatest([
+            of(dispatches),
+            api.derive.democracy.preimages(
+              dispatches.map(([, hash]) => hash))
+          ])
+        ),
+        map(([dispatches, images]) =>
+          dispatches.map(([at, imageHash, index], dispatchIndex): DeriveDispatch => ({
+            at,
+            index,
+            image: images[dispatchIndex],
+            imageHash
+          }))
+        )
+      )
+      : of([])
+  );
+}

packages/api-derive/src/democracy/index.ts

@@ -2,8 +2,15 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
+export * from './_referendumsVotes';
+export * from './_referendumVotes';
+export * from './_referendumInfo';
+export * from './dispatchQueue';
+export * from './nextExternal';
+export * from './preimage';
+export * from './preimages';
 export * from './proposals';
-export * from './referendumInfos';
 export * from './referendums';
-export * from './referendumVotesFor';
-export * from './votes';
+export * from './referendumsActive';
+export * from './referendumsInfo';
+export * from './sqrtElectorate';

packages/api-derive/src/democracy/nextExternal.ts

@@ -0,0 +1,40 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { Hash, VoteThreshold } from '@polkadot/types/interfaces';
+import { ITuple } from '@polkadot/types/types';
+import { DeriveProposalExternal } from '../types';
+
+import { Observable, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { Option } from '@polkadot/types';
+
+import { memo } from '../util';
+
+function withImage (api: ApiInterfaceRx, nextOpt: Option<ITuple<[Hash, VoteThreshold]>>): Observable<DeriveProposalExternal | null> {
+  if (nextOpt.isNone) {
+    return of(null);
+  }
+
+  const [imageHash, threshold] = nextOpt.unwrap();
+
+  return api.derive.democracy.preimage(imageHash).pipe(
+    map((image): DeriveProposalExternal => ({
+      image,
+      imageHash,
+      threshold
+    }))
+  );
+}
+
+export function nextExternal (api: ApiInterfaceRx): () => Observable<DeriveProposalExternal | null> {
+  return memo((): Observable<DeriveProposalExternal | null> =>
+    api.query.democracy?.nextExternal
+      ? api.query.democracy.nextExternal<Option<ITuple<[Hash, VoteThreshold]>>>().pipe(
+        switchMap((nextOpt) => withImage(api, nextOpt))
+      )
+      : of(null)
+  );
+}

packages/api-derive/src/democracy/preimage.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { AccountId, Balance, BlockNumber, Hash } from '@polkadot/types/interfaces';
+import { ITuple } from '@polkadot/types/types';
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { DeriveProposalImage } from '../types';
+
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Bytes, Option } from '@polkadot/types';
+
+import { memo } from '../util';
+import { parseImage } from './util';
+
+type PreImage = Option<ITuple<[Bytes, AccountId, Balance, BlockNumber]>>;
+
+export function preimage (api: ApiInterfaceRx): (hash: Hash) => Observable<DeriveProposalImage | undefined> {
+  return memo((hashes: Hash[]): Observable<DeriveProposalImage | undefined> =>
+    api.query.democracy.preimages<PreImage>(hashes).pipe(
+      map((imageOpt) => parseImage(api, imageOpt))
+    )
+  );
+}

packages/api-derive/src/democracy/preimages.ts

@@ -0,0 +1,29 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { AccountId, Balance, BlockNumber, Hash } from '@polkadot/types/interfaces';
+import { ITuple } from '@polkadot/types/types';
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { DeriveProposalImage } from '../types';
+
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Bytes, Option } from '@polkadot/types';
+
+import { memo } from '../util';
+import { parseImage } from './util';
+
+type PreImage = Option<ITuple<[Bytes, AccountId, Balance, BlockNumber]>>;
+
+export function preimages (api: ApiInterfaceRx): (hashes: Hash[]) => Observable<(DeriveProposalImage | undefined)[]> {
+  return memo((hashes: Hash[]): Observable<(DeriveProposalImage | undefined)[]> =>
+    api.query.democracy.preimages.multi<PreImage>(hashes).pipe(
+      map((images): (DeriveProposalImage | undefined)[] =>
+        images.map((imageOpt) =>
+          parseImage(api, imageOpt)
+        )
+      )
+    )
+  );
+}

packages/api-derive/src/democracy/proposals.ts

@@ -2,61 +2,35 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { AccountId, Balance, BlockNumber, Hash, PropIndex, Proposal } from '@polkadot/types/interfaces';
+import { AccountId, Balance, Hash, PropIndex } from '@polkadot/types/interfaces';
 import { ITuple } from '@polkadot/types/types';
-import { DeriveProposal } from '../types';
+import { DeriveProposalImage, DeriveProposal } from '../types';
 
 import { Observable, combineLatest, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { Bytes, Option, Vec, createType } from '@polkadot/types';
+import { Option, Vec } from '@polkadot/types';
 
 import { memo } from '../util';
 
-export type PreImage = Option<ITuple<[Bytes, AccountId, Balance, BlockNumber]>>;
-
 type Depositors = Option<ITuple<[Balance, Vec<AccountId>]>>;
 type Proposals = Vec<ITuple<[PropIndex, Hash, AccountId]>>;
 
-interface Result {
-  depositors: Depositors[];
-  preimages: PreImage[];
-  proposals: Proposals;
-}
-
-function parse (api: ApiInterfaceRx, { depositors, proposals, preimages }: Result): DeriveProposal[] {
+function parse ([proposals, images, depositors]: [Proposals, (DeriveProposalImage | undefined)[], Depositors[]]): DeriveProposal[] {
   return proposals
     .filter(([, , proposer], index): boolean =>
       !!(depositors[index]?.isSome) && !proposer.isEmpty
     )
-    .map(([propIndex, hash, proposer], index): DeriveProposal => {
-      const preimage = preimages[index].unwrapOr(null);
-      const depositor = depositors[index].unwrap();
-      let proposal: undefined | Proposal;
-
-      // we could end up in a situation where the proposal is non-decodable, e.g. after an upgrade
-      if (preimage) {
-        try {
-          proposal = createType(api.registry, 'Proposal', preimage[0].toU8a(true));
-        } catch (error) {
-          console.error(error);
-        }
-      }
+    .map(([index, imageHash, proposer], proposalIndex): DeriveProposal => {
+      const [balance, seconds] = depositors[proposalIndex].unwrap();
 
       return {
-        balance: depositor[0],
-        hash,
-        index: propIndex,
-        preimage: preimage
-          ? {
-            at: preimage[3],
-            balance: preimage[2],
-            proposer: preimage[1]
-          }
-          : undefined,
-        proposal,
+        balance,
+        index,
+        image: images[proposalIndex],
+        imageHash,
         proposer,
-        seconds: depositor[1]
+        seconds
       };
     });
 }
@@ -68,16 +42,14 @@ export function proposals (api: ApiInterfaceRx): () => Observable<DeriveProposal
         switchMap((proposals) =>
           combineLatest([
             of(proposals),
-            api.query.democracy.preimages.multi<PreImage>(
+            api.derive.democracy.preimages(
               proposals.map(([, hash]): Hash => hash)),
             api.query.democracy.depositOf.multi<Depositors>(
               proposals.map(([index]): PropIndex => index))
           ])
         ),
-        map(([proposals, preimages, depositors]): DeriveProposal[] =>
-          parse(api, { depositors, proposals, preimages })
-        )
+        map(parse)
       )
-      : of([] as DeriveProposal[])
+      : of([])
   );
 }

packages/api-derive/src/democracy/referendumInfo.ts

@@ -1,64 +0,0 @@
-// Copyright 2017-2020 @polkadot/api-derive authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-import { ReferendumInfo } from '@polkadot/types/interfaces/democracy';
-import { DerivedReferendum } from '../types';
-import { PreImage } from './proposals';
-
-import BN from 'bn.js';
-import { Observable, of } from 'rxjs';
-import { map, switchMap } from 'rxjs/operators';
-import { ApiInterfaceRx } from '@polkadot/api/types';
-import { Option, createType } from '@polkadot/types';
-
-import { memo } from '../util';
-
-function constructInfo (api: ApiInterfaceRx, index: BN | number, _info: Option<ReferendumInfo>, _preimage?: PreImage): DerivedReferendum | null {
-  const preImage = _preimage?.isSome
-    ? _preimage.unwrap()
-    : null;
-  const info = _info.unwrapOr(null);
-
-  if (!info) {
-    return null;
-  }
-
-  return {
-    index: createType(api.registry, 'PropIndex', index),
-    info,
-    hash: info.proposalHash,
-    proposal: preImage
-      ? createType(api.registry, 'Proposal', preImage[0].toU8a(true))
-      : undefined,
-    preimage: preImage
-      ? {
-        at: preImage[3],
-        balance: preImage[2],
-        proposer: preImage[1]
-      }
-      : undefined
-  };
-}
-
-export function retrieveInfo (api: ApiInterfaceRx, index: BN | number, info: Option<ReferendumInfo>): Observable<DerivedReferendum | null> {
-  return ((
-    info?.isSome
-      ? api.query.democracy.preimages(info.unwrap().proposalHash)
-      : of(undefined)
-  ) as Observable<PreImage | undefined>).pipe(
-    map((preimage?: PreImage): DerivedReferendum | null =>
-      constructInfo(api, index, info, preimage)
-    )
-  );
-}
-
-export function referendumInfo (api: ApiInterfaceRx): (index: BN | number) => Observable<DerivedReferendum | null> {
-  return memo((index: BN | number): Observable<DerivedReferendum | null> =>
-    api.query.democracy.referendumInfoOf<Option<ReferendumInfo>>(index).pipe(
-      switchMap((info): Observable<DerivedReferendum | null> =>
-        retrieveInfo(api, index, info)
-      )
-    )
-  );
-}

packages/api-derive/src/democracy/referendumInfos.ts

@@ -1,35 +0,0 @@
-// Copyright 2017-2020 @polkadot/api-derive authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-import { ReferendumInfo } from '@polkadot/types/interfaces/democracy';
-import { DerivedReferendum } from '../types';
-
-import BN from 'bn.js';
-import { Observable, combineLatest, of } from 'rxjs';
-import { map, switchMap } from 'rxjs/operators';
-import { ApiInterfaceRx } from '@polkadot/api/types';
-import { Option } from '@polkadot/types';
-
-import { memo } from '../util';
-import { retrieveInfo } from './referendumInfo';
-
-export function referendumInfos (api: ApiInterfaceRx): (ids?: (BN | number)[]) => Observable<DerivedReferendum[]> {
-  return memo((ids: (BN | number)[] = []): Observable<DerivedReferendum[]> =>
-    (
-      !ids?.length
-        ? of([] as Option<ReferendumInfo>[])
-        : api.query.democracy.referendumInfoOf.multi<Option<ReferendumInfo>>(ids)
-    ).pipe(
-      switchMap((infos): Observable<(DerivedReferendum | null)[]> =>
-        combineLatest(
-          ...ids.map((id, index): Observable<DerivedReferendum | null> =>
-            retrieveInfo(api, id, infos[index])
-          )
-        )
-      ),
-      map((infos): DerivedReferendum[] =>
-        infos.filter((referendum): referendum is DerivedReferendum => !!referendum)
-      )
-    ));
-}

packages/api-derive/src/democracy/referendumVotesFor.ts

@@ -1,34 +0,0 @@
-// Copyright 2017-2020 @polkadot/api-derive authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-import { AccountId, Vote } from '@polkadot/types/interfaces';
-
-import BN from 'bn.js';
-import { combineLatest, Observable, of } from 'rxjs';
-import { map, switchMap } from 'rxjs/operators';
-import { ApiInterfaceRx } from '@polkadot/api/types';
-import { Vec, createType } from '@polkadot/types';
-
-import { DerivedBalancesAccount, DerivedReferendumVote } from '../types';
-import { memo } from '../util';
-
-export function referendumVotesFor (api: ApiInterfaceRx): (referendumId: BN | number) => Observable<DerivedReferendumVote[]> {
-  return memo((referendumId: BN | number): Observable<DerivedReferendumVote[]> =>
-    api.query.democracy.votersFor<Vec<AccountId>>(referendumId).pipe(
-      switchMap((votersFor): Observable<[Vec<AccountId>, Vote[], DerivedBalancesAccount[]]> =>
-        combineLatest([
-          of(votersFor),
-          api.derive.democracy.votes(referendumId, votersFor),
-          api.derive.balances.votingBalances(votersFor)
-        ])
-      ),
-      map(([votersFor, votes, balances]): DerivedReferendumVote[] =>
-        votersFor.map((accountId, index): DerivedReferendumVote => ({
-          accountId,
-          balance: balances[index].votingBalance || createType(api.registry, 'Balance'),
-          vote: votes[index] || createType(api.registry, 'Vote')
-        } as DerivedReferendumVote))
-      )
-    ));
-}

packages/api-derive/src/democracy/referendums.ts

@@ -2,33 +2,29 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { ReferendumIndex } from '@polkadot/types/interfaces/democracy';
-import { DerivedReferendum } from '../types';
-
-import BN from 'bn.js';
-import { Observable, of } from 'rxjs';
-import { switchMap } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
+import { DeriveReferendumExt } from '../types';
+
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
 
 import { memo } from '../util';
 
-export function referendums (api: ApiInterfaceRx): () => Observable<DerivedReferendum[]> {
-  return memo((): Observable<DerivedReferendum[]> =>
-    api.query.democracy?.lowestUnbaked
-      ? api.queryMulti<[ReferendumIndex, ReferendumIndex]>([
-        api.query.democracy.lowestUnbaked,
-        api.query.democracy.referendumCount
-      ]).pipe(
-        switchMap(([earliest, referendumCount]): Observable<DerivedReferendum[]> =>
-          referendumCount?.gt(earliest) && referendumCount?.gtn(0)
-            ? api.derive.democracy.referendumInfos(
-              [...Array(referendumCount.sub(earliest).toNumber())].map((_, i): BN =>
-                earliest.addn(i)
-              )
-            )
-            : of([])
-        )
+export function referendums (api: ApiInterfaceRx): () => Observable<DeriveReferendumExt[]> {
+  return memo((): Observable<DeriveReferendumExt[]> =>
+    api.derive.democracy.referendumsActive().pipe(
+      switchMap((referendums) =>
+        combineLatest([
+          of(referendums),
+          api.derive.democracy._referendumsVotes(referendums)
+        ])
+      ),
+      map(([referendums, votes]) =>
+        referendums.map((referendum, index): DeriveReferendumExt => ({
+          ...referendum,
+          ...votes[index]
+        }))
       )
-      : of([] as DerivedReferendum[])
+    )
   );
 }

packages/api-derive/src/democracy/referendumsActive.ts

@@ -0,0 +1,32 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { ReferendumIndex } from '@polkadot/types/interfaces';
+import { DeriveReferendum } from '../types';
+
+import BN from 'bn.js';
+import { Observable, of } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+
+import { memo } from '../util';
+
+export function referendumsActive (api: ApiInterfaceRx): () => Observable<DeriveReferendum[]> {
+  return memo((): Observable<DeriveReferendum[]> =>
+    api.query.democracy?.lowestUnbaked
+      ? api.queryMulti<[ReferendumIndex, ReferendumIndex]>([
+        api.query.democracy.lowestUnbaked,
+        api.query.democracy.referendumCount
+      ]).pipe(
+        switchMap(([first, total]): Observable<DeriveReferendum[]> =>
+          total.gt(first)
+            ? api.derive.democracy.referendumsInfo(
+              [...Array(total.sub(first).toNumber())].map((_, i): BN => first.addn(i))
+            )
+            : of([])
+        )
+      )
+      : of([])
+  );
+}

packages/api-derive/src/democracy/referendumsInfo.ts

@@ -0,0 +1,33 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { ReferendumInfo } from '@polkadot/types/interfaces';
+import { DeriveReferendum } from '../types';
+
+import BN from 'bn.js';
+import { Observable, of, combineLatest } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { Option } from '@polkadot/types';
+
+import { memo } from '../util';
+
+export function referendumsInfo (api: ApiInterfaceRx): (ids: BN[]) => Observable<DeriveReferendum[]> {
+  return memo((ids: BN[]): Observable<DeriveReferendum[]> =>
+    ids.length
+      ? api.query.democracy.referendumInfoOf.multi<Option<ReferendumInfo>>(ids).pipe(
+        switchMap((infos): Observable<(DeriveReferendum | null)[]> =>
+          combineLatest(
+            ids.map((id, index): Observable<DeriveReferendum | null> =>
+              api.derive.democracy._referendumInfo(id, infos[index])
+            )
+          )
+        ),
+        map((infos) =>
+          infos.filter((referendum): referendum is DeriveReferendum => !!referendum)
+        )
+      )
+      : of([])
+  );
+}

packages/api-derive/src/democracy/sqrtElectorate.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+
+import BN from 'bn.js';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { bnSqrt } from '@polkadot/util';
+
+import { memo } from '../util';
+
+export function sqrtElectorate (api: ApiInterfaceRx): () => Observable<BN> {
+  return memo((): Observable<BN> =>
+    api.query.balances.totalIssuance().pipe(
+      map((totalIssuance) =>
+        bnSqrt(totalIssuance)
+      )
+    )
+  );
+}

packages/api-derive/src/democracy/types.ts

@@ -0,0 +1,69 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { AccountId, Balance, BlockNumber, Hash, Proposal, PropIndex, ReferendumInfoTo239, ReferendumStatus, Vote, ReferendumIndex, VoteThreshold } from '@polkadot/types/interfaces';
+
+import BN from 'bn.js';
+import { Vec } from '@polkadot/types';
+
+export interface DeriveDispatch {
+  at: BlockNumber;
+  index: ReferendumIndex;
+  imageHash: Hash;
+  image?: DeriveProposalImage;
+}
+
+export interface DeriveProposalImage {
+  at: BlockNumber;
+  balance: Balance;
+  proposal?: Proposal;
+  proposer: AccountId;
+}
+
+export interface DeriveProposal {
+  balance?: Balance;
+  index: PropIndex;
+  image?: DeriveProposalImage;
+  imageHash: Hash;
+  proposer: AccountId;
+  seconds: Vec<AccountId>;
+}
+
+export interface DeriveProposalExternal {
+  image?: DeriveProposalImage;
+  imageHash: Hash;
+  threshold: VoteThreshold;
+}
+
+export interface DeriveReferendum {
+  index: ReferendumIndex;
+  image?: DeriveProposalImage;
+  imageHash: Hash;
+  status: ReferendumStatus | ReferendumInfoTo239;
+}
+
+export interface DeriveReferendumVote {
+  accountId: AccountId;
+  balance: Balance;
+  vote: Vote;
+}
+
+export interface DeriveReferendumVoteState {
+  allAye: DeriveReferendumVote[];
+  allNay: DeriveReferendumVote[];
+  voteCount: number;
+  voteCountAye: number;
+  voteCountNay: number;
+  votedAye: BN;
+  votedNay: BN;
+  votedTotal: BN;
+}
+
+export interface DeriveReferendumVotes extends DeriveReferendumVoteState {
+  isPassing: boolean;
+  votes: DeriveReferendumVote[];
+}
+
+export interface DeriveReferendumExt extends DeriveReferendum, DeriveReferendumVotes {
+}

packages/api-derive/src/democracy/util.ts

@@ -0,0 +1,163 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { AccountId, Balance, BlockNumber, Proposal, ReferendumInfo, ReferendumInfoTo239, ReferendumStatus, Tally, VoteThreshold } from '@polkadot/types/interfaces';
+import { ITuple } from '@polkadot/types/types';
+import { DeriveProposalImage, DeriveReferendum, DeriveReferendumVote, DeriveReferendumVotes, DeriveReferendumVoteState } from '../types';
+
+import BN from 'bn.js';
+import { Bytes, Option } from '@polkadot/types';
+import { bnSqrt } from '@polkadot/util';
+
+function isOldInfo (info: ReferendumInfo | ReferendumInfoTo239): info is ReferendumInfoTo239 {
+  return !!(info as ReferendumInfoTo239).proposalHash;
+}
+
+function isCurrentStatus (status: ReferendumStatus | ReferendumInfoTo239): status is ReferendumStatus {
+  return !!(status as ReferendumStatus).tally;
+}
+
+export function compareRationals (n1: BN, d1: BN, n2: BN, d2: BN): boolean {
+  while (true) {
+    const q1 = n1.div(d1);
+    const q2 = n2.div(d2);
+
+    if (q1.lt(q2)) {
+      return true;
+    } else if (q2.lt(q1)) {
+      return false;
+    }
+
+    const r1 = n1.mod(d1);
+    const r2 = n2.mod(d2);
+
+    if (r2.isZero()) {
+      return false;
+    } else if (r1.isZero()) {
+      return true;
+    }
+
+    n1 = d2;
+    n2 = d1;
+    d1 = r2;
+    d2 = r1;
+  }
+}
+
+function isPassing (threshold: VoteThreshold, sqrtElectorate: BN, { votedAye, votedNay, votedTotal }: DeriveReferendumVoteState): boolean {
+  const sqrtVoters = bnSqrt(votedTotal);
+
+  return sqrtVoters.isZero()
+    ? false
+    : threshold.isSimplemajority
+      ? votedAye.gt(votedNay)
+      : threshold.isSupermajorityapproval
+        ? compareRationals(votedNay, sqrtVoters, votedAye, sqrtElectorate)
+        : compareRationals(votedNay, sqrtElectorate, votedAye, sqrtVoters);
+}
+
+function calcVotesPrev (votesFor: DeriveReferendumVote[]): DeriveReferendumVoteState {
+  return votesFor.reduce((state: DeriveReferendumVoteState, derived): DeriveReferendumVoteState => {
+    const { balance, vote } = derived;
+    const isDefault = vote.conviction.index === 0;
+    const counted = balance
+      .muln(isDefault ? 1 : vote.conviction.index)
+      .divn(isDefault ? 10 : 1);
+
+    if (vote.isAye) {
+      state.allAye.push(derived);
+      state.voteCountAye++;
+      state.votedAye = state.votedAye.add(counted);
+    } else {
+      state.allNay.push(derived);
+      state.voteCountNay++;
+      state.votedNay = state.votedNay.add(counted);
+    }
+
+    state.voteCount++;
+    state.votedTotal = state.votedTotal.add(counted);
+
+    return state;
+  }, {
+    allAye: [],
+    allNay: [],
+    voteCount: 0,
+    voteCountAye: 0,
+    voteCountNay: 0,
+    votedAye: new BN(0),
+    votedNay: new BN(0),
+    votedTotal: new BN(0)
+  });
+}
+
+function calcVotesCurrent (tally: Tally, votes: DeriveReferendumVote[]): DeriveReferendumVoteState {
+  const allAye: DeriveReferendumVote[] = [];
+  const allNay: DeriveReferendumVote[] = [];
+
+  votes.forEach((derived): void => {
+    if (derived.vote.isAye) {
+      allAye.push(derived);
+    } else {
+      allNay.push(derived);
+    }
+  });
+
+  return {
+    allAye,
+    allNay,
+    voteCount: allAye.length + allNay.length,
+    voteCountAye: allAye.length,
+    voteCountNay: allNay.length,
+    votedAye: tally.ayes,
+    votedNay: tally.nays,
+    votedTotal: tally.turnout
+  };
+}
+
+export function calcVotes (sqrtElectorate: BN, referendum: DeriveReferendum, votes: DeriveReferendumVote[]): DeriveReferendumVotes {
+  const state = isCurrentStatus(referendum.status)
+    ? calcVotesCurrent(referendum.status.tally, votes)
+    : calcVotesPrev(votes);
+
+  return {
+    ...state,
+    isPassing: isPassing(referendum.status.threshold, sqrtElectorate, state),
+    votes
+  };
+}
+
+export function getStatus (info: Option<ReferendumInfo | ReferendumInfoTo239>): ReferendumStatus | ReferendumInfoTo239 | null {
+  if (info.isNone) {
+    return null;
+  }
+
+  const unwrapped = info.unwrap();
+
+  if (isOldInfo(unwrapped)) {
+    return unwrapped;
+  } else if (unwrapped.isOngoing) {
+    return unwrapped.asOngoing;
+  }
+
+  // done, we don't include it here... only currently active
+  return null;
+}
+
+export function parseImage (api: ApiInterfaceRx, imageOpt: Option<ITuple<[Bytes, AccountId, Balance, BlockNumber]>>): DeriveProposalImage | undefined {
+  if (imageOpt.isNone) {
+    return;
+  }
+
+  let proposal: Proposal | undefined;
+  const [bytes, proposer, balance, at] = imageOpt.unwrap();
+
+  try {
+    proposal = api.registry.createType('Proposal', bytes.toU8a(true));
+  } catch (error) {
+    console.error(error);
+  }
+
+  return { at, balance, proposal, proposer };
+}

packages/api-derive/src/democracy/votes.ts

@@ -1,23 +0,0 @@
-// Copyright 2017-2020 @polkadot/api-derive authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-import { AccountId, Vote } from '@polkadot/types/interfaces';
-
-import BN from 'bn.js';
-import { Observable, of } from 'rxjs';
-import { ApiInterfaceRx } from '@polkadot/api/types';
-
-import { memo } from '../util';
-
-export function votes (api: ApiInterfaceRx): (referendumId: BN | number, accountIds?: AccountId[]) => Observable<Vote[]> {
-  return memo((referendumId: BN | number, accountIds: AccountId[] = []): Observable<Vote[]> =>
-    !accountIds || !accountIds.length
-      ? of([] as Vote[])
-      : api.query.democracy.voteOf.multi<Vote>(
-        accountIds.map((accountId): [BN | number, AccountId] =>
-          [referendumId, accountId]
-        )
-      )
-  );
-}

packages/api-derive/src/elections/info.ts

@@ -8,16 +8,16 @@ import { ITuple } from '@polkadot/types/types';
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { createType, Vec, u32 } from '@polkadot/types';
+import { Vec, u32 } from '@polkadot/types';
 
-import { DerivedElectionsInfo } from '../types';
+import { DeriveElectionsInfo } from '../types';
 import { memo } from '../util';
 
 function sortAccounts ([, balanceA]: ITuple<[AccountId, Balance]>, [, balanceB]: ITuple<[AccountId, Balance]>): number {
   return balanceB.cmp(balanceA);
 }
 
-function queryElections (api: ApiInterfaceRx): Observable<DerivedElectionsInfo> {
+function queryElections (api: ApiInterfaceRx): Observable<DeriveElectionsInfo> {
   const section = api.query.electionsPhragmen ? 'electionsPhragmen' : 'elections';
 
   return api.queryMulti<[Vec<AccountId>, Vec<AccountId>, Vec<ITuple<[AccountId, Balance]>>, Vec<ITuple<[AccountId, Balance]>>]>([
@@ -26,14 +26,14 @@ function queryElections (api: ApiInterfaceRx): Observable<DerivedElectionsInfo>
     api.query[section].members,
     api.query[section].runnersUp
   ]).pipe(
-    map(([councilMembers, candidates, members, runnersUp]): DerivedElectionsInfo => ({
+    map(([councilMembers, candidates, members, runnersUp]): DeriveElectionsInfo => ({
       candidates,
-      candidateCount: createType(api.registry, 'u32', candidates.length),
+      candidateCount: api.registry.createType('u32', candidates.length),
       candidacyBond: api.consts[section].candidacyBond as Balance,
       desiredSeats: api.consts[section].desiredMembers as u32,
       members: members.length
         ? members.sort(sortAccounts)
-        : councilMembers.map((accountId): [AccountId, Balance] => [accountId, createType(api.registry, 'Balance')]),
+        : councilMembers.map((accountId): [AccountId, Balance] => [accountId, api.registry.createType('Balance')]),
       runnersUp: runnersUp.sort(sortAccounts),
       termDuration: api.consts[section].termDuration as BlockNumber,
       votingBond: api.consts[section].votingBond as Balance
@@ -54,6 +54,6 @@ function queryElections (api: ApiInterfaceRx): Observable<DerivedElectionsInfo>
  * });
  * ```
  */
-export function info (api: ApiInterfaceRx): () => Observable<DerivedElectionsInfo> {
-  return memo((): Observable<DerivedElectionsInfo> => queryElections(api));
+export function info (api: ApiInterfaceRx): () => Observable<DeriveElectionsInfo> {
+  return memo((): Observable<DeriveElectionsInfo> => queryElections(api));
 }

packages/api-derive/src/imOnline/receivedHeartbeats.ts

@@ -3,9 +3,9 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { AccountId } from '@polkadot/types/interfaces';
-import { DerivedHeartbeats } from '../types';
+import { DeriveHeartbeats } from '../types';
 
-import { of, Observable, combineLatest } from 'rxjs';
+import { Observable, of, combineLatest } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { Bytes, Option, u32 } from '@polkadot/types';
@@ -15,8 +15,8 @@ import { memo } from '../util';
 /**
  * @description Return a boolean array indicating whether the passed accounts had received heartbeats in the current session
  */
-export function receivedHeartbeats (api: ApiInterfaceRx): () => Observable<DerivedHeartbeats> {
-  return memo((): Observable<DerivedHeartbeats> =>
+export function receivedHeartbeats (api: ApiInterfaceRx): () => Observable<DeriveHeartbeats> {
+  return memo((): Observable<DeriveHeartbeats> =>
     api.query.imOnline?.receivedHeartbeats
       ? api.derive.staking.overview().pipe(
         switchMap(({ currentIndex, validators }): Observable<[AccountId[], Option<Bytes>[], u32[]]> =>
@@ -28,8 +28,8 @@ export function receivedHeartbeats (api: ApiInterfaceRx): () => Observable<Deriv
               validators.map((address) => [currentIndex, address]))
           ])
         ),
-        map(([validators, heartbeats, numBlocks]): DerivedHeartbeats =>
-          validators.reduce((result: DerivedHeartbeats, validator, index): DerivedHeartbeats => ({
+        map(([validators, heartbeats, numBlocks]): DeriveHeartbeats =>
+          validators.reduce((result: DeriveHeartbeats, validator, index): DeriveHeartbeats => ({
             ...result,
             [validator.toString()]: {
               blockCount: numBlocks[index],

packages/api-derive/src/index.spec.ts

@@ -49,10 +49,8 @@ describe('derive', (): void => {
     testFunction(api)('chain', 'bestNumber', []);
     testFunction(api)('chain', 'bestNumberFinalized', []);
 
-    testFunction(api)('democracy', 'referendumInfos', []);
+    testFunction(api)('democracy', 'proposals', []);
     testFunction(api)('democracy', 'referendums', []);
-    testFunction(api)('democracy', 'referendumVotesFor', []);
-    testFunction(api)('democracy', 'votes', []);
 
     testFunction(api)('elections', 'info', []);
 
@@ -61,7 +59,7 @@ describe('derive', (): void => {
     testFunction(api)('session', 'sessionProgress', []);
 
     testFunction(api)('staking', 'account', []);
-    testFunction(api)('staking', 'controllers', []);
+    testFunction(api)('staking', 'stashes', []);
   });
 
   describe('custom', (): void => {

packages/api-derive/src/index.ts

@@ -21,10 +21,11 @@ import * as society from './society';
 import * as staking from './staking';
 import * as technicalCommittee from './technicalCommittee';
 import * as treasury from './treasury';
+import * as tx from './tx';
 
 export * from './type';
 
-export const derive = { accounts, balances, chain, contracts, council, democracy, elections, imOnline, parachains, session, society, staking, technicalCommittee, treasury };
+export const derive = { accounts, balances, chain, contracts, council, democracy, elections, imOnline, parachains, session, society, staking, technicalCommittee, treasury, tx };
 
 type DeriveSection<Section> = {
   [Method in keyof Section]: Section[Method] extends AnyFunction

packages/api-derive/src/parachains/info.ts

@@ -9,7 +9,6 @@ import { Active, DidUpdate, Heads, ParaInfoResult, PendingSwap, RelayDispatchQue
 import { Observable, of } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { createType } from '@polkadot/types';
 
 import { memo } from '../util';
 
@@ -92,7 +91,7 @@ export function info (api: ApiInterfaceRx): (id: ParaId | number) => Observable<
       ])
         .pipe(
           map((result: Result): DeriveParachainFull | null =>
-            parse(createType(api.registry, 'ParaId', id), result)
+            parse(api.registry.createType('ParaId', id), result)
           )
         )
       : of(null)

packages/api-derive/src/session/eraProgress.ts

@@ -12,7 +12,7 @@ import { memo } from '../util';
 
 export function eraProgress (api: ApiInterfaceRx): () => Observable<BlockNumber> {
   return memo((): Observable<BlockNumber> =>
-    api.derive.session.info().pipe(
+    api.derive.session.progress().pipe(
       map((info) => info.eraProgress)
     ));
 }

packages/api-derive/src/session/index.ts

@@ -6,4 +6,5 @@ export * from './eraLength';
 export * from './eraProgress';
 export * from './indexes';
 export * from './info';
+export * from './progress';
 export * from './sessionProgress';

packages/api-derive/src/session/indexes.ts

@@ -8,7 +8,7 @@ import { DeriveSessionIndexes } from '../types';
 
 import { Observable, of } from 'rxjs';
 import { map } from 'rxjs/operators';
-import { createType, Option, u32 } from '@polkadot/types';
+import { Option, u32 } from '@polkadot/types';
 
 import { memo } from '../util';
 
@@ -34,7 +34,7 @@ function queryNoActive (api: ApiInterfaceRx): Observable<Result> {
   ]).pipe(
     map(([currentEra, currentIndex, validatorCount]): Result => [
       currentEra,
-      createType(api.registry, 'Option<Moment>'),
+      api.registry.createType('Option<Moment>'),
       currentEra,
       currentIndex,
       validatorCount
@@ -56,7 +56,7 @@ function query (api: ApiInterfaceRx): Observable<Result> {
       return [
         activeEra,
         activeEraStart,
-        currentEra.unwrapOr(createType(api.registry, 'EraIndex')),
+        currentEra.unwrapOr(api.registry.createType('EraIndex')),
         currentIndex,
         validatorCount
       ];
@@ -67,11 +67,11 @@ function query (api: ApiInterfaceRx): Observable<Result> {
 // empty set when none is available
 function empty (api: ApiInterfaceRx): Observable<Result> {
   return of([
-    createType(api.registry, 'EraIndex'),
-    createType(api.registry, 'Option<Moment>'),
-    createType(api.registry, 'EraIndex'),
-    createType(api.registry, 'SessionIndex', 1),
-    createType(api.registry, 'u32')
+    api.registry.createType('EraIndex'),
+    api.registry.createType('Option<Moment>'),
+    api.registry.createType('EraIndex'),
+    api.registry.createType('SessionIndex', 1),
+    api.registry.createType('u32')
   ]);
 }
 

packages/api-derive/src/session/info.ts

@@ -3,110 +3,69 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { SessionIndex } from '@polkadot/types/interfaces';
-import { DerivedSessionInfo, DeriveSessionIndexes } from '../types';
+import { DeriveSessionInfo, DeriveSessionIndexes } from '../types';
 
-import { Observable, combineLatest, of } from 'rxjs';
-import { map, switchMap } from 'rxjs/operators';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { createType, Option, u64 } from '@polkadot/types';
+import { u64 } from '@polkadot/types';
 
 import { memo } from '../util';
 
-type ResultSlots = [u64, u64, u64, Option<SessionIndex>];
-type ResultSlotsFlat = [u64, u64, u64, SessionIndex];
 type ResultType = [boolean, u64, SessionIndex];
-type Result = [ResultType, DeriveSessionIndexes, ResultSlotsFlat];
-
-function createDerived (api: ApiInterfaceRx, [[hasBabe, epochDuration, sessionsPerEra], { activeEra, activeEraStart, currentEra, currentIndex, validatorCount }, [currentSlot, epochIndex, epochOrGenesisStartSlot, activeEraStartSessionIndex]]: Result): DerivedSessionInfo {
-  const epochStartSlot = epochIndex.mul(epochDuration).add(epochOrGenesisStartSlot);
-  const sessionProgress = currentSlot.sub(epochStartSlot);
-  const eraProgress = currentIndex.sub(activeEraStartSessionIndex).mul(epochDuration).add(sessionProgress);
+type Result = [ResultType, DeriveSessionIndexes];
 
+function createDerive (api: ApiInterfaceRx, [[hasBabe, epochDuration, sessionsPerEra], { activeEra, activeEraStart, currentEra, currentIndex, validatorCount }]: Result): DeriveSessionInfo {
   return {
     activeEra,
     activeEraStart,
     currentEra,
     currentIndex,
-    eraLength: createType(api.registry, 'BlockNumber', sessionsPerEra.mul(epochDuration)),
-    eraProgress: createType(api.registry, 'BlockNumber', eraProgress),
+    eraLength: api.registry.createType('BlockNumber', sessionsPerEra.mul(epochDuration)),
     isEpoch: hasBabe,
     sessionLength: epochDuration,
     sessionsPerEra,
-    sessionProgress: createType(api.registry, 'BlockNumber', sessionProgress),
     validatorCount
   };
 }
 
-function queryAura (api: ApiInterfaceRx): Observable<DerivedSessionInfo> {
+function queryAura (api: ApiInterfaceRx): Observable<DeriveSessionInfo> {
   return api.derive.session.indexes().pipe(
-    map((indexes): DerivedSessionInfo =>
-      createDerived(api, [
+    map((indexes): DeriveSessionInfo =>
+      createDerive(api, [
         [
           false,
-          createType(api.registry, 'u64', 1),
-          api.consts.staking?.sessionsPerEra || createType(api.registry, 'SessionIndex', 1)
+          api.registry.createType('u64', 1),
+          api.consts.staking?.sessionsPerEra || api.registry.createType('SessionIndex', 1)
         ],
-        indexes,
-        [
-          createType(api.registry, 'u64', 1),
-          createType(api.registry, 'u64', 1),
-          createType(api.registry, 'u64', 1),
-          createType(api.registry, 'SessionIndex', 1)
-        ]
+        indexes
       ])
     )
   );
 }
 
-function queryBabe (api: ApiInterfaceRx): Observable<[DeriveSessionIndexes, ResultSlotsFlat]> {
+function queryBabe (api: ApiInterfaceRx): Observable<DeriveSessionInfo> {
   return api.derive.session.indexes().pipe(
-    switchMap((indexes): Observable<[DeriveSessionIndexes, ResultSlots]> =>
-      combineLatest([
-        of(indexes),
-        api.queryMulti<ResultSlots>([
-          api.query.babe.currentSlot,
-          api.query.babe.epochIndex,
-          api.query.babe.genesisSlot,
-          [api.query.staking.erasStartSessionIndex, indexes.activeEra]
-        ])
+    map((indexes) =>
+      createDerive(api, [
+        [
+          true,
+          api.consts.babe.epochDuration,
+          api.consts.staking.sessionsPerEra
+        ],
+        indexes
       ])
-    ),
-    map(([indexes, [currentSlot, epochIndex, genesisSlot, optStartIndex]]): [DeriveSessionIndexes, ResultSlotsFlat] => [
-      indexes, [currentSlot, epochIndex, genesisSlot, optStartIndex.unwrapOr(createType(api.registry, 'SessionIndex', 1))]
-    ])
+    )
   );
 }
 
-function queryBabeNoHistory (api: ApiInterfaceRx): Observable<[DeriveSessionIndexes, ResultSlotsFlat]> {
-  return combineLatest([
-    api.derive.session.indexes(),
-    api.queryMulti<ResultSlotsFlat>([
-      api.query.babe.currentSlot,
-      api.query.babe.epochIndex,
-      api.query.babe.genesisSlot,
-      api.query.staking.currentEraStartSessionIndex
-    ])
-  ]);
-}
-
 /**
  * @description Retrieves all the session and era query and calculates specific values on it as the length of the session and eras
  */
-export function info (api: ApiInterfaceRx): () => Observable<DerivedSessionInfo> {
-  return memo((): Observable<DerivedSessionInfo> =>
+export function info (api: ApiInterfaceRx): () => Observable<DeriveSessionInfo> {
+  return memo((): Observable<DeriveSessionInfo> =>
     api.consts.babe
-      ? (api.query.staking.erasStartSessionIndex
-        ? queryBabe(api) // 2.x with Babe
-        : queryBabeNoHistory(api)
-      ).pipe(
-        map(([indexes, slots]: [DeriveSessionIndexes, ResultSlotsFlat]): DerivedSessionInfo =>
-          createDerived(api, [
-            [true, api.consts.babe.epochDuration, api.consts.staking.sessionsPerEra],
-            indexes,
-            slots
-          ])
-        )
-      )
+      ? queryBabe(api)
       : queryAura(api)
   );
 }

packages/api-derive/src/session/progress.ts

@@ -0,0 +1,90 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { SessionIndex } from '@polkadot/types/interfaces';
+import { DeriveSessionInfo, DeriveSessionProgress } from '../types';
+
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { Option, u64 } from '@polkadot/types';
+
+import { memo } from '../util';
+
+type ResultSlots = [u64, u64, u64, Option<SessionIndex>];
+type ResultSlotsFlat = [u64, u64, u64, SessionIndex];
+
+function createDerive (api: ApiInterfaceRx, info: DeriveSessionInfo, [currentSlot, epochIndex, epochOrGenesisStartSlot, activeEraStartSessionIndex]: ResultSlotsFlat): DeriveSessionProgress {
+  const epochStartSlot = epochIndex.mul(info.sessionLength).add(epochOrGenesisStartSlot);
+  const sessionProgress = currentSlot.sub(epochStartSlot);
+  const eraProgress = info.currentIndex.sub(activeEraStartSessionIndex).mul(info.sessionLength).add(sessionProgress);
+
+  return {
+    ...info,
+    eraProgress: api.registry.createType('BlockNumber', eraProgress),
+    sessionProgress: api.registry.createType('BlockNumber', sessionProgress)
+  };
+}
+
+function queryAura (api: ApiInterfaceRx): Observable<DeriveSessionProgress> {
+  return api.derive.session.info().pipe(
+    map((info): DeriveSessionProgress =>
+      createDerive(api, info, [
+        api.registry.createType('u64', 1),
+        api.registry.createType('u64', 1),
+        api.registry.createType('u64', 1),
+        api.registry.createType('SessionIndex', 1)
+      ])
+    )
+  );
+}
+
+function queryBabe (api: ApiInterfaceRx): Observable<[DeriveSessionInfo, ResultSlotsFlat]> {
+  return api.derive.session.info().pipe(
+    switchMap((info): Observable<[DeriveSessionInfo, ResultSlots]> =>
+      combineLatest([
+        of(info),
+        api.queryMulti<ResultSlots>([
+          api.query.babe.currentSlot,
+          api.query.babe.epochIndex,
+          api.query.babe.genesisSlot,
+          [api.query.staking.erasStartSessionIndex, info.activeEra]
+        ])
+      ])
+    ),
+    map(([info, [currentSlot, epochIndex, genesisSlot, optStartIndex]]): [DeriveSessionInfo, ResultSlotsFlat] => [
+      info, [currentSlot, epochIndex, genesisSlot, optStartIndex.unwrapOr(api.registry.createType('SessionIndex', 1))]
+    ])
+  );
+}
+
+function queryBabeNoHistory (api: ApiInterfaceRx): Observable<[DeriveSessionInfo, ResultSlotsFlat]> {
+  return combineLatest([
+    api.derive.session.info(),
+    api.queryMulti<ResultSlotsFlat>([
+      api.query.babe.currentSlot,
+      api.query.babe.epochIndex,
+      api.query.babe.genesisSlot,
+      api.query.staking.currentEraStartSessionIndex
+    ])
+  ]);
+}
+
+/**
+ * @description Retrieves all the session and era query and calculates specific values on it as the length of the session and eras
+ */
+export function progress (api: ApiInterfaceRx): () => Observable<DeriveSessionProgress> {
+  return memo((): Observable<DeriveSessionProgress> =>
+    api.consts.babe
+      ? (api.query.staking.erasStartSessionIndex
+        ? queryBabe(api) // 2.x with Babe
+        : queryBabeNoHistory(api)
+      ).pipe(
+        map(([info, slots]: [DeriveSessionInfo, ResultSlotsFlat]): DeriveSessionProgress =>
+          createDerive(api, info, slots)
+        )
+      )
+      : queryAura(api)
+  );
+}

packages/api-derive/src/session/sessionProgress.ts

@@ -12,7 +12,7 @@ import { memo } from '../util';
 
 export function sessionProgress (api: ApiInterfaceRx): () => Observable<BlockNumber> {
   return memo((): Observable<BlockNumber> =>
-    api.derive.session.info().pipe(
+    api.derive.session.progress().pipe(
       map((info) => info.sessionProgress)
     ));
 }

packages/api-derive/src/session/types.ts

@@ -14,11 +14,14 @@ export interface DeriveSessionIndexes {
   validatorCount: u32;
 }
 
-export interface DerivedSessionInfo extends DeriveSessionIndexes {
+export interface DeriveSessionInfo extends DeriveSessionIndexes {
   eraLength: BlockNumber;
-  eraProgress: BlockNumber;
   isEpoch: boolean;
   sessionLength: BlockNumber;
   sessionsPerEra: SessionIndex;
+}
+
+export interface DeriveSessionProgress extends DeriveSessionInfo {
+  eraProgress: BlockNumber;
   sessionProgress: BlockNumber;
 }

packages/api-derive/src/society/candidates.ts

@@ -7,7 +7,7 @@ import { AccountId, BalanceOf, Bid, BidKind } from '@polkadot/types/interfaces';
 import { ITuple } from '@polkadot/types/types';
 import { DeriveSocietyCandidate } from '../types';
 
-import { combineLatest, of, Observable } from 'rxjs';
+import { Observable, combineLatest, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
 import { Option, Vec } from '@polkadot/types';
 

packages/api-derive/src/society/members.ts

@@ -6,7 +6,7 @@ import { ApiInterfaceRx } from '@polkadot/api/types';
 import { AccountId } from '@polkadot/types/interfaces';
 import { DeriveSocietyMember } from '../types';
 
-import { combineLatest, Observable } from 'rxjs';
+import { Observable, combineLatest } from 'rxjs';
 import { switchMap } from 'rxjs/operators';
 
 import { memo } from '../util';
@@ -18,9 +18,11 @@ export function members (api: ApiInterfaceRx): () => Observable<DeriveSocietyMem
   return memo((): Observable<DeriveSocietyMember[]> =>
     api.query.society.members<AccountId[]>().pipe(
       switchMap((members): Observable<DeriveSocietyMember[]> =>
-        combineLatest(members.map((accountId): Observable<DeriveSocietyMember> =>
-          api.derive.society.member(accountId)
-        ))
+        combineLatest(
+          members.map((accountId): Observable<DeriveSocietyMember> =>
+            api.derive.society.member(accountId)
+          )
+        )
       )
     )
   );

packages/api-derive/src/staking/account.ts

@@ -3,13 +3,12 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { Balance, BlockNumber, StakingLedger, UnlockChunk } from '@polkadot/types/interfaces';
-import { DerivedSessionInfo, DerivedStakingAccount, DerivedStakingQuery, DerivedUnlocking } from '../types';
+import { Balance, StakingLedger, UnlockChunk } from '@polkadot/types/interfaces';
+import { DeriveSessionInfo, DeriveStakingAccount, DeriveStakingQuery, DeriveUnlocking } from '../types';
 
 import BN from 'bn.js';
-import { combineLatest, Observable } from 'rxjs';
+import { Observable, combineLatest } from 'rxjs';
 import { map } from 'rxjs/operators';
-import { createType } from '@polkadot/types';
 
 import { isUndefined } from '@polkadot/util';
 
@@ -28,27 +27,13 @@ function groupByEra (list: UnlockChunk[]): Record<string, BN> {
   }, {});
 }
 
-// calculate the remaining blocks in a specific unlock era
-function remainingBlocks (api: ApiInterfaceRx, era: BN, sessionInfo: DerivedSessionInfo): BlockNumber {
-  const remaining = era.sub(sessionInfo.currentEra);
-
-  // on the Rust side the current-era >= era-for-unlock (removal done on >)
-  return createType(api.registry, 'BlockNumber', remaining.gtn(0)
-    ? remaining
-      .subn(1)
-      .mul(sessionInfo.eraLength)
-      .add(sessionInfo.eraLength.sub(sessionInfo.eraProgress))
-    : 0
-  );
-}
-
-function calculateUnlocking (api: ApiInterfaceRx, stakingLedger: StakingLedger | undefined, sessionInfo: DerivedSessionInfo): DerivedUnlocking[] | undefined {
+function calculateUnlocking (api: ApiInterfaceRx, stakingLedger: StakingLedger | undefined, sessionInfo: DeriveSessionInfo): DeriveUnlocking[] | undefined {
   if (isUndefined(stakingLedger)) {
     return undefined;
   }
 
   const unlockingChunks = stakingLedger.unlocking.filter(({ era }): boolean =>
-    remainingBlocks(api, era.unwrap(), sessionInfo).gtn(0)
+    era.unwrap().sub(sessionInfo.activeEra).gtn(0)
   );
 
   if (!unlockingChunks.length) {
@@ -57,27 +42,27 @@ function calculateUnlocking (api: ApiInterfaceRx, stakingLedger: StakingLedger |
 
   // group the unlock chunks that have the same era and sum their values
   const groupedResult = groupByEra(unlockingChunks);
-  const results = Object.entries(groupedResult).map(([eraString, value]): DerivedUnlocking => ({
-    value: createType(api.registry, 'Balance', value),
-    remainingBlocks: remainingBlocks(api, new BN(eraString), sessionInfo)
+  const results = Object.entries(groupedResult).map(([eraString, value]): DeriveUnlocking => ({
+    remainingEras: new BN(eraString).sub(sessionInfo.activeEra),
+    value: api.registry.createType('Balance', value)
   }));
 
   return results.length ? results : undefined;
 }
 
-function redeemableSum (api: ApiInterfaceRx, stakingLedger: StakingLedger | undefined, sessionInfo: DerivedSessionInfo): Balance {
+function redeemableSum (api: ApiInterfaceRx, stakingLedger: StakingLedger | undefined, sessionInfo: DeriveSessionInfo): Balance {
   if (isUndefined(stakingLedger)) {
-    return createType(api.registry, 'Balance');
+    return api.registry.createType('Balance');
   }
 
-  return createType(api.registry, 'Balance', stakingLedger.unlocking.reduce((total, { era, value }): BN => {
-    return remainingBlocks(api, era.unwrap(), sessionInfo).eqn(0)
+  return api.registry.createType('Balance', stakingLedger.unlocking.reduce((total, { era, value }): BN => {
+    return sessionInfo.activeEra.gte(era.unwrap())
       ? total.add(value.unwrap())
       : total;
   }, new BN(0)));
 }
 
-function parseResult (api: ApiInterfaceRx, sessionInfo: DerivedSessionInfo, query: DerivedStakingQuery): DerivedStakingAccount {
+function parseResult (api: ApiInterfaceRx, sessionInfo: DeriveSessionInfo, query: DeriveStakingQuery): DeriveStakingAccount {
   return {
     ...query,
     redeemable: redeemableSum(api, query.stakingLedger, sessionInfo),
@@ -88,13 +73,13 @@ function parseResult (api: ApiInterfaceRx, sessionInfo: DerivedSessionInfo, quer
 /**
  * @description From a stash, retrieve the controllerId and fill in all the relevant staking details
  */
-export function account (api: ApiInterfaceRx): (accountId: Uint8Array | string) => Observable<DerivedStakingAccount> {
-  return memo((accountId: Uint8Array | string): Observable<DerivedStakingAccount> =>
+export function account (api: ApiInterfaceRx): (accountId: Uint8Array | string) => Observable<DeriveStakingAccount> {
+  return memo((accountId: Uint8Array | string): Observable<DeriveStakingAccount> =>
     combineLatest([
       api.derive.session.info(),
       api.derive.staking.query(accountId)
     ]).pipe(
-      map(([sessionInfo, query]: [DerivedSessionInfo, DerivedStakingQuery]) =>
+      map(([sessionInfo, query]: [DeriveSessionInfo, DeriveStakingQuery]) =>
         parseResult(api, sessionInfo, query))
     ));
 }

packages/api-derive/src/staking/controllers.ts

@@ -1,33 +0,0 @@
-// Copyright 2017-2020 @polkadot/api-derive authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-import { ApiInterfaceRx } from '@polkadot/api/types';
-import { AccountId, ValidatorPrefs } from '@polkadot/types/interfaces';
-import { ITuple } from '@polkadot/types/types';
-
-import { Observable, combineLatest, of } from 'rxjs';
-import { switchMap } from 'rxjs/operators';
-import { Option, Vec } from '@polkadot/types';
-
-import { memo } from '../util';
-
-type DeriveControllers = [AccountId[], Option<AccountId>[]];
-
-/**
- * @description From the list of stash accounts, retrieve the list of controllers
- */
-export function controllers (api: ApiInterfaceRx): () => Observable<DeriveControllers> {
-  return memo((): Observable<[AccountId[], Option<AccountId>[]]> =>
-    api.query.staking.validators<ITuple<[Vec<AccountId>, Vec<ValidatorPrefs>]>>().pipe(
-      switchMap(([stashIds]): Observable<DeriveControllers> =>
-        combineLatest([
-          of(stashIds),
-          // for V2, don't return all the controllers, we call bonded at a later point
-          api.consts.session
-            ? of([])
-            : api.query.staking.bonded.multi<Option<AccountId>>(stashIds)
-        ])
-      )
-    ));
-}

packages/api-derive/src/staking/electedInfo.ts

@@ -4,25 +4,27 @@
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { AccountId } from '@polkadot/types/interfaces';
-import { DerivedStakingQuery, DerivedStakingElected } from '../types';
+import { DeriveStakingQuery, DeriveStakingElected } from '../types';
 
 import { Observable, combineLatest, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
 
 import { memo } from '../util';
 
-export function electedInfo (api: ApiInterfaceRx): () => Observable<DerivedStakingElected> {
-  return memo((): Observable<DerivedStakingElected> =>
+export function electedInfo (api: ApiInterfaceRx): () => Observable<DeriveStakingElected> {
+  return memo((): Observable<DeriveStakingElected> =>
     api.derive.staking.validators().pipe(
-      switchMap(({ nextElected }): Observable<[AccountId[], DerivedStakingQuery[]]> =>
+      switchMap(({ nextElected }): Observable<[AccountId[], DeriveStakingQuery[]]> =>
         combineLatest([
           of(nextElected),
-          combineLatest(nextElected.map((accountId): Observable<DerivedStakingQuery> =>
-            api.derive.staking.query(accountId)
-          ))
+          combineLatest(
+            nextElected.map((accountId): Observable<DeriveStakingQuery> =>
+              api.derive.staking.query(accountId)
+            )
+          )
         ])
       ),
-      map(([nextElected, info]): DerivedStakingElected => ({
+      map(([nextElected, info]): DeriveStakingElected => ({
         info,
         nextElected
       }))

packages/api-derive/src/staking/erasExposure.ts

@@ -8,12 +8,14 @@ import { DeriveEraExposure, DeriveEraNominatorExposure, DeriveEraValidatorExposu
 
 import BN from 'bn.js';
 import { Observable, combineLatest, of } from 'rxjs';
-import { map, switchMap, take } from 'rxjs/operators';
+import { map, switchMap } from 'rxjs/operators';
 import { StorageKey } from '@polkadot/types';
 
 import { memo } from '../util';
 
-function mapStakers (era: EraIndex, stakers: [StorageKey, Exposure][]): DeriveEraExposure {
+type KeysAndExposures = [StorageKey, Exposure][];
+
+function mapStakers (era: EraIndex, stakers: KeysAndExposures): DeriveEraExposure {
   const nominators: DeriveEraNominatorExposure = {};
   const validators: DeriveEraValidatorExposure = {};
 
@@ -33,27 +35,23 @@ function mapStakers (era: EraIndex, stakers: [StorageKey, Exposure][]): DeriveEr
   return { era, nominators, validators };
 }
 
+export function eraExposure (api: ApiInterfaceRx): (era: EraIndex) => Observable<DeriveEraExposure> {
+  return memo((era: EraIndex): Observable<DeriveEraExposure> =>
+    api.query.staking.erasStakersClipped.entries(era).pipe(
+      map((stakers) => mapStakers(era, stakers))
+    )
+  );
+}
+
 export function erasExposure (api: ApiInterfaceRx): (withActive?: boolean | BN | number) => Observable<DeriveEraExposure[]> {
   return memo((withActive?: boolean | BN | number): Observable<DeriveEraExposure[]> =>
     api.derive.staking.erasHistoric(withActive).pipe(
-      switchMap((eras): Observable<[EraIndex[], [StorageKey, Exposure][][]]> =>
-        combineLatest([
-          of(eras),
-          eras.length
-            ? combineLatest(
-              // we could just do entries over the full set, however the set can be quite large - split it into
-              // batches - may need to re-visit this, or alternatively use pages keys for exceptionally large sets
-              eras.map((era): Observable<[StorageKey, Exposure][]> =>
-                api.query.staking.erasStakersClipped.entries(era).pipe(take(1))
-              )
-            )
-            : of([])
-        ])
-      ),
-      map(([eras, erasStakers]): DeriveEraExposure[] =>
-        eras.map((era, index): DeriveEraExposure =>
-          mapStakers(era, erasStakers[index])
-        )
+      switchMap((eras): Observable<DeriveEraExposure[]> =>
+        eras.length
+          ? combineLatest(
+            eras.map((era) => api.derive.staking.eraExposure(era))
+          )
+          : of([])
       )
     )
   );

packages/api-derive/src/staking/erasPrefs.ts

@@ -0,0 +1,46 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { EraIndex, ValidatorPrefs } from '@polkadot/types/interfaces';
+import { DeriveEraPrefs, DeriveEraValPrefs } from '../types';
+
+import BN from 'bn.js';
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { StorageKey } from '@polkadot/types';
+
+import { memo } from '../util';
+
+function mapPrefs (era: EraIndex, all: [StorageKey, ValidatorPrefs][]): DeriveEraPrefs {
+  const validators: DeriveEraValPrefs = {};
+
+  all.forEach(([key, prefs]): void => {
+    validators[key.args[1].toString()] = prefs;
+  });
+
+  return { era, validators };
+}
+
+export function eraPrefs (api: ApiInterfaceRx): (era: EraIndex) => Observable<DeriveEraPrefs> {
+  return memo((era: EraIndex): Observable<DeriveEraPrefs> =>
+    api.query.staking.erasValidatorPrefs.entries(era).pipe(
+      map((prefs) => mapPrefs(era, prefs))
+    )
+  );
+}
+
+export function erasPrefs (api: ApiInterfaceRx): (withActive?: boolean | BN | number) => Observable<DeriveEraPrefs[]> {
+  return memo((withActive?: boolean | BN | number): Observable<DeriveEraPrefs[]> =>
+    api.derive.staking.erasHistoric(withActive).pipe(
+      switchMap((eras): Observable<DeriveEraPrefs[]> =>
+        eras.length
+          ? combineLatest(
+            eras.map((era) => api.derive.staking.eraPrefs(era))
+          )
+          : of([])
+      )
+    )
+  );
+}

packages/api-derive/src/staking/erasSlashes.ts

@@ -0,0 +1,55 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { BalanceOf, EraIndex, Perbill } from '@polkadot/types/interfaces';
+import { ITuple } from '@polkadot/types/types';
+import { DeriveEraSlashes, DeriveEraValSlash } from '../types';
+
+import BN from 'bn.js';
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { Option, StorageKey } from '@polkadot/types';
+
+import { memo } from '../util';
+
+function mapSlashes (era: EraIndex, noms: [StorageKey, Option<BalanceOf>][], vals: [StorageKey, Option<ITuple<[Perbill, BalanceOf]>>][]): DeriveEraSlashes {
+  const nominators: DeriveEraValSlash = {};
+  const validators: DeriveEraValSlash = {};
+
+  noms.forEach(([key, optBalance]): void => {
+    nominators[key.args[1].toString()] = optBalance.unwrap();
+  });
+
+  vals.forEach(([key, optRes]): void => {
+    validators[key.args[1].toString()] = optRes.unwrapOrDefault()[1];
+  });
+
+  return { era, nominators, validators };
+}
+
+export function eraSlashes (api: ApiInterfaceRx): (era: EraIndex) => Observable<DeriveEraSlashes> {
+  return memo((era: EraIndex): Observable<DeriveEraSlashes> =>
+    combineLatest([
+      api.query.staking.nominatorSlashInEra.entries(era),
+      api.query.staking.validatorSlashInEra.entries(era)
+    ]).pipe(
+      map(([noms, vals]) => mapSlashes(era, noms, vals))
+    )
+  );
+}
+
+export function erasSlashes (api: ApiInterfaceRx): (withActive?: boolean | BN | number) => Observable<DeriveEraSlashes[]> {
+  return memo((withActive?: boolean | BN | number): Observable<DeriveEraSlashes[]> =>
+    api.derive.staking.erasHistoric(withActive).pipe(
+      switchMap((eras): Observable<DeriveEraSlashes[]> =>
+        eras.length
+          ? combineLatest(
+            eras.map((era) => api.derive.staking.eraSlashes(era))
+          )
+          : of([])
+      )
+    )
+  );
+}

packages/api-derive/src/staking/index.ts

@@ -6,12 +6,17 @@ export * from './account';
 export * from './erasExposure';
 export * from './erasHistoric';
 export * from './erasPoints';
+export * from './erasPrefs';
 export * from './erasRewards';
-export * from './controllers';
+export * from './erasSlashes';
 export * from './electedInfo';
 export * from './overview';
+export * from './ownExposure';
+export * from './ownSlashes';
 export * from './query';
 export * from './stakerExposure';
 export * from './stakerPoints';
 export * from './stakerRewards';
+export * from './stakerSlashes';
+export * from './stashes';
 export * from './validators';

packages/api-derive/src/staking/overview.ts

@@ -2,24 +2,23 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { AccountId, EraIndex, EraPoints, EraRewardPoints, RewardPoint } from '@polkadot/types/interfaces';
+import { AccountId, EraPoints, EraRewardPoints, RewardPoint } from '@polkadot/types/interfaces';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { DerivedStakingOverview } from '../types';
+import { DeriveStakingOverview } from '../types';
 
 import { Observable, combineLatest, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
-import { createType } from '@polkadot/types';
 
 import { memo } from '../util';
 
-function retrievePointsPrev (api: ApiInterfaceRx, activeEra: EraIndex, currentElected: AccountId[]): Observable<EraRewardPoints> {
-  return api.query.staking.currentEraPointsEarned<EraPoints>(activeEra).pipe(
+function retrievePointsPrev (api: ApiInterfaceRx, currentElected: AccountId[]): Observable<EraRewardPoints> {
+  return api.query.staking.currentEraPointsEarned<EraPoints>().pipe(
     map(({ individual, total }): EraRewardPoints =>
-      createType(api.registry, 'EraRewardPoints', {
+      api.registry.createType('EraRewardPoints', {
         total,
         individual: new Map<AccountId, RewardPoint>(
           individual
-            .map((points): RewardPoint => createType(api.registry, 'RewardPoint', points))
+            .map((points): RewardPoint => api.registry.createType('RewardPoint', points))
             .map((points, index): [AccountId, RewardPoint] => [currentElected[index], points])
         )
       })
@@ -30,8 +29,8 @@ function retrievePointsPrev (api: ApiInterfaceRx, activeEra: EraIndex, currentEl
 /**
  * @description Retrieve the staking overview, including elected and points earned
  */
-export function overview (api: ApiInterfaceRx): () => Observable<DerivedStakingOverview> {
-  return memo((): Observable<DerivedStakingOverview> =>
+export function overview (api: ApiInterfaceRx): () => Observable<DeriveStakingOverview> {
+  return memo((): Observable<DeriveStakingOverview> =>
     combineLatest([
       api.derive.session.indexes(),
       api.derive.staking.validators()
@@ -42,11 +41,11 @@ export function overview (api: ApiInterfaceRx): () => Observable<DerivedStakingO
           api.query.staking.erasRewardPoints
             ? api.query.staking.erasRewardPoints<EraRewardPoints>(indexes.activeEra)
             : api.query.staking.currentEraPointsEarned
-              ? retrievePointsPrev(api, indexes.activeEra, nextElected)
-              : of(createType(api.registry, 'EraRewardPoints'))
+              ? retrievePointsPrev(api, nextElected)
+              : of(api.registry.createType('EraRewardPoints'))
         ])
       ),
-      map(([info, eraPoints]): DerivedStakingOverview => ({
+      map(([info, eraPoints]): DeriveStakingOverview => ({
         ...info, eraPoints
       }))
     ));

packages/api-derive/src/staking/ownExposure.ts

@@ -0,0 +1,37 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { DeriveOwnExposure } from '../types';
+
+import BN from 'bn.js';
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+
+import { memo } from '../util';
+
+export function ownExposure (api: ApiInterfaceRx): (accountId: Uint8Array | string, withActive?: boolean | BN | number) => Observable<DeriveOwnExposure[]> {
+  return memo((accountId: Uint8Array | string, withActive?: boolean | BN | number): Observable<DeriveOwnExposure[]> => {
+    return api.derive.staking.erasHistoric(withActive).pipe(
+      switchMap((eras) =>
+        eras.length
+          ? combineLatest(
+            eras.map((era) => combineLatest([
+              of(era),
+              api.query.staking.erasStakersClipped(era, accountId),
+              api.query.staking.erasStakers(era, accountId)
+            ]))
+          )
+          : of([])
+      ),
+      map((result): DeriveOwnExposure[] =>
+        result.map(([era, clipped, exposure]): DeriveOwnExposure => ({
+          clipped,
+          era,
+          exposure
+        }))
+      )
+    );
+  });
+}

packages/api-derive/src/staking/ownSlashes.ts

@@ -0,0 +1,40 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { DeriveStakerSlashes } from '../types';
+
+import BN from 'bn.js';
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+
+import { memo } from '../util';
+
+export function ownSlashes (api: ApiInterfaceRx): (accountId: Uint8Array | string, withActive?: boolean | BN | number) => Observable<DeriveStakerSlashes[]> {
+  return memo((accountId: Uint8Array | string, withActive?: boolean | BN | number): Observable<DeriveStakerSlashes[]> => {
+    return api.derive.staking.erasHistoric(withActive).pipe(
+      switchMap((eras) =>
+        eras.length
+          ? combineLatest(
+            eras.map((era) => combineLatest([
+              of(era),
+              api.query.staking.nominatorSlashInEra(era, accountId),
+              api.query.staking.validatorSlashInEra(era, accountId)
+            ]))
+          )
+          : of([])
+      ),
+      map((result): DeriveStakerSlashes[] =>
+        result.map(([era, optNom, optVal]): DeriveStakerSlashes => ({
+          era,
+          total: optVal.isSome
+            ? optVal.unwrap()[1]
+            : optNom.isSome
+              ? optNom.unwrap()
+              : api.registry.createType('Balance')
+        }))
+      )
+    );
+  });
+}

packages/api-derive/src/staking/query.ts

@@ -5,15 +5,15 @@
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { AccountId, Exposure, Keys, Nominations, RewardDestination, ValidatorPrefs } from '@polkadot/types/interfaces';
 import { ITuple } from '@polkadot/types/types';
-import { DerivedStakingQuery } from '../types';
+import { DeriveStakingQuery } from '../types';
 
-import { combineLatest, Observable, of } from 'rxjs';
+import { Observable, combineLatest, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
-import { createType, Option, Vec } from '@polkadot/types';
+import { Option, Vec } from '@polkadot/types';
 
 import { memo } from '../util';
 
-type MultiResult = [Option<AccountId>, Option<ITuple<[Nominations]>>, RewardDestination, ITuple<[ValidatorPrefs]>, Option<Keys>, Exposure];
+type MultiResult = [Option<AccountId>, Option<ITuple<[Nominations]> | Nominations>, RewardDestination, ITuple<[ValidatorPrefs]> | ValidatorPrefs, Option<Keys>, Exposure];
 
 function unwrapSessionIds (stashId: AccountId, queuedKeys: [AccountId, Keys][], nextKeys: Option<Keys>): { nextSessionIds: AccountId[]; sessionIds: AccountId[] } {
   const sessionIds = (queuedKeys.find(([currentId]): boolean =>
@@ -55,20 +55,27 @@ function retrieveCurr (api: ApiInterfaceRx, stashId: AccountId): Observable<Mult
   );
 }
 
-function retrieveController (api: ApiInterfaceRx, stashId: AccountId, [queuedKeys, [controllerIdOpt, nominatorsOpt, rewardDestination, [validatorPrefs], nextKeys, exposure]]: [Vec<ITuple<[AccountId, Keys]>>, MultiResult]): Observable<DerivedStakingQuery> {
+function retrieveController (api: ApiInterfaceRx, stashId: AccountId, [queuedKeys, [controllerIdOpt, nominatorsOpt, rewardDestination, validatorPrefs, nextKeys, exposure]]: [Vec<ITuple<[AccountId, Keys]>>, MultiResult]): Observable<DeriveStakingQuery> {
   const controllerId = controllerIdOpt.unwrapOr(null);
+  const nominators = nominatorsOpt.unwrapOr(null);
 
   return controllerId
     ? api.query.staking.ledger(controllerId).pipe(
-      map((stakingLedgerOpt): DerivedStakingQuery => ({
+      map((stakingLedgerOpt): DeriveStakingQuery => ({
         accountId: stashId,
         controllerId,
         exposure,
-        nominators: nominatorsOpt.unwrapOr([{ targets: [] }])[0].targets,
+        nominators: nominators
+          ? Array.isArray(nominators)
+            ? nominators[0].targets
+            : nominators.targets
+          : [],
         rewardDestination,
         stakingLedger: stakingLedgerOpt.unwrapOr(undefined),
         stashId,
-        validatorPrefs,
+        validatorPrefs: Array.isArray(validatorPrefs)
+          ? validatorPrefs[0]
+          : validatorPrefs,
         ...unwrapSessionIds(stashId, queuedKeys, nextKeys)
       }))
     )
@@ -78,9 +85,9 @@ function retrieveController (api: ApiInterfaceRx, stashId: AccountId, [queuedKey
 /**
  * @description From a stash, retrieve the controllerId and all relevant details
  */
-export function query (api: ApiInterfaceRx): (accountId: Uint8Array | string) => Observable<DerivedStakingQuery> {
-  return memo((accountId: Uint8Array | string): Observable<DerivedStakingQuery> => {
-    const stashId = createType(api.registry, 'AccountId', accountId);
+export function query (api: ApiInterfaceRx): (accountId: Uint8Array | string) => Observable<DeriveStakingQuery> {
+  return memo((accountId: Uint8Array | string): Observable<DeriveStakingQuery> => {
+    const stashId = api.registry.createType('AccountId', accountId);
 
     return combineLatest([
       api.query.session.queuedKeys<Vec<ITuple<[AccountId, Keys]>>>(),
@@ -88,15 +95,15 @@ export function query (api: ApiInterfaceRx): (accountId: Uint8Array | string) =>
         ? retrieveCurr(api, stashId)
         : retrievePrev(api, stashId)
     ]).pipe(
-      switchMap((result): Observable<DerivedStakingQuery> =>
+      switchMap((result): Observable<DeriveStakingQuery> =>
         retrieveController(api, stashId, result)
       )
     );
   });
 }
 
-export function queryMulti (api: ApiInterfaceRx): (...accountIds: (Uint8Array | string)[]) => Observable<DerivedStakingQuery[]> {
-  return memo((...accountIds: (Uint8Array | string)[]): Observable<DerivedStakingQuery[]> =>
+export function queryMulti (api: ApiInterfaceRx): (...accountIds: (Uint8Array | string)[]) => Observable<DeriveStakingQuery[]> {
+  return memo((...accountIds: (Uint8Array | string)[]): Observable<DeriveStakingQuery[]> =>
     combineLatest(
       accountIds.map((accountId) => api.derive.staking.query(accountId))
     )

packages/api-derive/src/staking/stakerRewards.ts

@@ -4,7 +4,7 @@
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { Balance } from '@polkadot/types/interfaces';
-import { DeriveEraPoints, DeriveEraRewards, DeriveStakerExposure, DeriveStakerReward } from '../types';
+import { DeriveEraPoints, DeriveEraPrefs, DeriveEraRewards, DeriveEraValPrefs, DeriveStakerExposure, DeriveStakerReward } from '../types';
 
 import BN from 'bn.js';
 import { Observable, combineLatest } from 'rxjs';
@@ -12,18 +12,24 @@ import { map } from 'rxjs/operators';
 
 import { memo } from '../util';
 
-type Result = [DeriveEraPoints[], DeriveEraRewards[], DeriveStakerExposure[]];
-const ZERO = new BN(0);
+type Result = [DeriveEraPoints[], DeriveEraPrefs[], DeriveEraRewards[], DeriveStakerExposure[]];
 
-function parseRewards (api: ApiInterfaceRx, stakerId: string, [erasPoints, erasRewards, exposures]: Result): DeriveStakerReward[] {
+const ZERO = new BN(0);
+const COMM_DIV = new BN(1_000_000_000);
+
+function parseRewards (api: ApiInterfaceRx, stakerId: string, [erasPoints, erasPrefs, erasRewards, exposures]: Result): DeriveStakerReward[] {
   return exposures.map(({ era, isEmpty, isValidator, nominating, validators: eraValidators }): DeriveStakerReward => {
     const { eraPoints, validators: allValPoints } = erasPoints.find((p) => p.era.eq(era)) || { eraPoints: new BN(0), validators: {} };
-    const { eraReward } = erasRewards.find((r) => r.era.eq(era)) || { eraReward: new BN(0) };
+    const { eraReward } = erasRewards.find((r) => r.era.eq(era)) || { eraReward: ZERO };
+    const { validators: allValPrefs } = erasPrefs.find((p) => p.era.eq(era)) || { validators: {} as DeriveEraValPrefs };
     const validators: Record<string, Balance> = {};
     let total = ZERO;
 
     Object.entries(eraValidators).forEach(([validatorId, exposure]): void => {
-      const valPoints = allValPoints[validatorId] || new BN(0);
+      const valPoints = allValPoints[validatorId] || ZERO;
+      const valComm = allValPrefs[validatorId]?.commission.unwrap() || ZERO;
+      const avail = eraReward.mul(valPoints).div(eraPoints);
+      const valCut = valComm.mul(avail).div(COMM_DIV);
       const expTotal = exposure.total.unwrap();
       let value: BN | undefined;
 
@@ -40,7 +46,7 @@ function parseRewards (api: ApiInterfaceRx, stakerId: string, [erasPoints, erasR
             : ZERO;
         }
 
-        value = eraReward.mul(valPoints).mul(staked).div(eraPoints).div(expTotal);
+        value = avail.sub(valCut).mul(staked).div(expTotal).add(validatorId === stakerId ? valCut : ZERO);
         total = total.add(value);
       }
 
@@ -64,6 +70,7 @@ export function stakerRewards (api: ApiInterfaceRx): (accountId: Uint8Array | st
 
     return combineLatest([
       api.derive.staking.erasPoints(startEra),
+      api.derive.staking.erasPrefs(startEra),
       api.derive.staking.erasRewards(startEra),
       api.derive.staking.stakerExposure(stakerId, startEra)
     ]).pipe(

packages/api-derive/src/staking/stakerSlashes.ts

@@ -0,0 +1,27 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { DeriveStakerSlashes } from '../types';
+
+import BN from 'bn.js';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+import { memo } from '../util';
+
+export function stakerSlashes (api: ApiInterfaceRx): (accountId: Uint8Array | string, withActive?: boolean | BN | number) => Observable<DeriveStakerSlashes[]> {
+  return memo((accountId: Uint8Array | string, withActive?: boolean | BN | number): Observable<DeriveStakerSlashes[]> => {
+    const stakerId = api.registry.createType('AccountId', accountId).toString();
+
+    return api.derive.staking.erasSlashes(withActive).pipe(
+      map((slashes): DeriveStakerSlashes[] =>
+        slashes.map(({ era, nominators, validators }): DeriveStakerSlashes => ({
+          era,
+          total: nominators[stakerId] || validators[stakerId] || api.registry.createType('Balance')
+        }))
+      )
+    );
+  });
+}

packages/api-derive/src/staking/stashes.ts

@@ -0,0 +1,28 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { AccountId, ValidatorPrefs } from '@polkadot/types/interfaces';
+import { ITuple } from '@polkadot/types/types';
+
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Vec } from '@polkadot/types';
+
+import { memo } from '../util';
+
+/**
+ * @description Retrieve the list of all validator stashes
+ */
+export function stashes (api: ApiInterfaceRx): () => Observable<AccountId[]> {
+  return memo((): Observable<AccountId[]> =>
+    api.query.staking.validators.creator.meta.type.asMap.linked.isTrue
+      ? api.query.staking.validators<ITuple<[Vec<AccountId>, Vec<ValidatorPrefs>]>>().pipe(
+        map(([stashIds]) => stashIds)
+      )
+      : api.query.staking.validators.keys().pipe(
+        map((keys) => keys.map((key) => key.args[0] as AccountId))
+      )
+  );
+}

packages/api-derive/src/staking/types.ts

@@ -2,22 +2,39 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { AccountId, Balance, BlockNumber, EraIndex, EraRewardPoints, Exposure, Keys, RewardDestination, RewardPoint, StakingLedger, ValidatorPrefs } from '@polkadot/types/interfaces';
+import { AccountId, Balance, EraIndex, EraRewardPoints, Exposure, Keys, RewardDestination, RewardPoint, StakingLedger, ValidatorPrefs } from '@polkadot/types/interfaces';
 import { DeriveSessionIndexes } from '../session/types';
 
+import BN from 'bn.js';
+
 export type DeriveEraValPoints = Record<string, RewardPoint>;
 
+export type DeriveEraValPrefs = Record<string, ValidatorPrefs>;
+
+export type DeriveEraValSlash = Record<string, Balance>;
+
 export interface DeriveEraPoints {
   era: EraIndex;
   eraPoints: RewardPoint;
   validators: DeriveEraValPoints;
 }
 
+export interface DeriveEraPrefs {
+  era: EraIndex;
+  validators: DeriveEraValPrefs;
+}
+
 export interface DeriveEraRewards {
   era: EraIndex;
   eraReward: Balance;
 }
 
+export interface DeriveEraSlashes {
+  era: EraIndex;
+  nominators: DeriveEraValSlash;
+  validators: DeriveEraValSlash;
+}
+
 export interface DeriveStakerPoints {
   era: EraIndex;
   eraPoints: RewardPoint;
@@ -34,6 +51,14 @@ export interface DeriveEraExposure {
   validators: DeriveEraValidatorExposure;
 }
 
+export interface DeriveOwnExposure {
+  clipped: Exposure;
+  era: EraIndex;
+  exposure: Exposure;
+}
+
+export type DeriveOwnSlashes = DeriveStakerSlashes;
+
 export interface DeriveStakerExposure {
   era: EraIndex;
   isEmpty: boolean;
@@ -51,9 +76,14 @@ export interface DeriveStakerReward {
   total: Balance;
 }
 
-export interface DerivedStakingElected {
+export interface DeriveStakerSlashes {
+  era: EraIndex;
+  total: Balance;
+}
+
+export interface DeriveStakingElected {
   nextElected: AccountId[];
-  info: DerivedStakingQuery[];
+  info: DeriveStakingQuery[];
 }
 
 export interface DeriveStakingValidators {
@@ -61,7 +91,7 @@ export interface DeriveStakingValidators {
   validators: AccountId[];
 }
 
-export interface DerivedStakingStash {
+export interface DeriveStakingStash {
   controllerId?: AccountId;
   exposure?: Exposure;
   nominators?: AccountId[];
@@ -72,25 +102,25 @@ export interface DerivedStakingStash {
   validatorPrefs?: ValidatorPrefs;
 }
 
-export interface DerivedStakingQuery extends DerivedStakingStash {
+export interface DeriveStakingQuery extends DeriveStakingStash {
   accountId: AccountId;
   nextSessionIds: AccountId[];
   sessionIds: AccountId[];
   stakingLedger?: StakingLedger;
 }
 
-export interface DerivedStakingAccount extends DerivedStakingQuery {
+export interface DeriveStakingAccount extends DeriveStakingQuery {
   redeemable?: Balance;
-  unlocking?: DerivedUnlocking[];
+  unlocking?: DeriveUnlocking[];
 }
 
-export interface DerivedStakingOverview extends DeriveSessionIndexes {
+export interface DeriveStakingOverview extends DeriveSessionIndexes {
   eraPoints: EraRewardPoints;
   nextElected: AccountId[];
   validators: AccountId[];
 }
 
-export type DerivedUnlocking = {
-  remainingBlocks: BlockNumber;
+export type DeriveUnlocking = {
+  remainingEras: BN;
   value: Balance;
 };

packages/api-derive/src/staking/validators.ts

@@ -7,21 +7,25 @@ import { AccountId } from '@polkadot/types/interfaces';
 import { DeriveStakingValidators } from '../types';
 
 import { Observable, combineLatest, of } from 'rxjs';
-import { map, switchMap, take } from 'rxjs/operators';
+import { map, switchMap } from 'rxjs/operators';
 import { StorageKey } from '@polkadot/types';
 
 import { memo } from '../util';
 
-function queryNextStakers (api: ApiInterfaceRx): Observable<AccountId[]> {
-  // only populate for next era in the last session, so track both here - entries are not
-  // subscriptions, so we need a trigger - currentIndex acts as that trigger to refresh
-  return api.derive.session.indexes().pipe(
-    switchMap(({ activeEra }): Observable<StorageKey[]> =>
-      api.query.staking.erasStakers.keys(activeEra.addn(1)).pipe(take(1))
-    ),
-    map((keys): AccountId[] =>
-      keys.map((key): AccountId => key.args[1] as AccountId)
-    )
+export function nextElected (api: ApiInterfaceRx): () => Observable<AccountId[]> {
+  return memo((): Observable<AccountId[]> =>
+    api.query.staking.erasStakers
+      ? api.derive.session.indexes().pipe(
+        // only populate for next era in the last session, so track both here - entries are not
+        // subscriptions, so we need a trigger - currentIndex acts as that trigger to refresh
+        switchMap(({ currentEra }): Observable<StorageKey[]> =>
+          api.query.staking.erasStakers.keys(currentEra)
+        ),
+        map((keys): AccountId[] =>
+          keys.map((key): AccountId => key.args[1] as AccountId)
+        )
+      )
+      : api.query.staking.currentElected<AccountId[]>()
   );
 }
 
@@ -38,9 +42,7 @@ export function validators (api: ApiInterfaceRx): () => Observable<DeriveStaking
         ? api.query.session.validators()
         : of([]),
       api.query.staking
-        ? api.query.staking.erasStakers
-          ? queryNextStakers(api)
-          : api.query.staking.currentElected<AccountId[]>()
+        ? api.derive.staking.nextElected()
         : of([])
     ]).pipe(
       map(([validators, nextElected]): DeriveStakingValidators => ({

packages/api-derive/src/technicalCommittee/proposals.ts

@@ -3,12 +3,12 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { DerivedCollectiveProposals } from '../types';
+import { DeriveCollectiveProposals } from '../types';
 
 import { Observable } from 'rxjs';
 import { proposals as collectiveProposals } from '../collective';
 import { memo } from '../util';
 
-export function proposals (api: ApiInterfaceRx): () => Observable<DerivedCollectiveProposals> {
+export function proposals (api: ApiInterfaceRx): () => Observable<DeriveCollectiveProposals> {
   return memo(collectiveProposals(api, 'technicalCommittee'));
 }

packages/api-derive/src/treasury/proposals.ts

@@ -4,11 +4,11 @@
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { ProposalIndex, TreasuryProposal } from '@polkadot/types/interfaces';
-import { DerivedCollectiveProposals, DerivedTreasuryProposal, DerivedTreasuryProposals } from '../types';
+import { DeriveCollectiveProposals, DeriveTreasuryProposal, DeriveTreasuryProposals } from '../types';
 
 import { Observable, combineLatest, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
-import { createType, Option } from '@polkadot/types';
+import { Option } from '@polkadot/types';
 
 import { memo } from '../util';
 
@@ -16,13 +16,13 @@ interface Result {
   allIds: ProposalIndex[];
   allProposals: Option<TreasuryProposal>[];
   approvalIds: ProposalIndex[];
-  councilProposals: DerivedCollectiveProposals;
+  councilProposals: DeriveCollectiveProposals;
   proposalCount: ProposalIndex;
 }
 
-function parseResult (_api: ApiInterfaceRx, { allIds, allProposals, approvalIds, councilProposals, proposalCount }: Result): DerivedTreasuryProposals {
-  const approvals: DerivedTreasuryProposal[] = [];
-  const proposals: DerivedTreasuryProposal[] = [];
+function parseResult (_api: ApiInterfaceRx, { allIds, allProposals, approvalIds, councilProposals, proposalCount }: Result): DeriveTreasuryProposals {
+  const approvals: DeriveTreasuryProposal[] = [];
+  const proposals: DeriveTreasuryProposal[] = [];
   const councilTreasury = councilProposals.filter(({ proposal: { methodName, sectionName } }): boolean =>
     sectionName === 'treasury' &&
     ['approveProposal', 'rejectProposal'].includes(methodName)
@@ -47,7 +47,7 @@ function parseResult (_api: ApiInterfaceRx, { allIds, allProposals, approvalIds,
   return { approvals, proposalCount, proposals };
 }
 
-function retrieveProposals (api: ApiInterfaceRx, proposalCount: ProposalIndex, approvalIds: ProposalIndex[]): Observable<DerivedTreasuryProposals> {
+function retrieveProposals (api: ApiInterfaceRx, proposalCount: ProposalIndex, approvalIds: ProposalIndex[]): Observable<DeriveTreasuryProposals> {
   const proposalIds: ProposalIndex[] = [];
   const count = proposalCount.toNumber();
 
@@ -55,7 +55,7 @@ function retrieveProposals (api: ApiInterfaceRx, proposalCount: ProposalIndex, a
     const isApproval = approvalIds.some((id): boolean => id.eqn(index));
 
     if (!isApproval) {
-      proposalIds.push(createType(api.registry, 'ProposalIndex', index));
+      proposalIds.push(api.registry.createType('ProposalIndex', index));
     }
   }
 
@@ -65,7 +65,7 @@ function retrieveProposals (api: ApiInterfaceRx, proposalCount: ProposalIndex, a
     api.query.treasury.proposals.multi<Option<TreasuryProposal>>(allIds),
     api.derive.council.proposals()
   ]).pipe(
-    map(([allProposals, councilProposals]: [Option<TreasuryProposal>[], DerivedCollectiveProposals]): DerivedTreasuryProposals =>
+    map(([allProposals, councilProposals]: [Option<TreasuryProposal>[], DeriveCollectiveProposals]): DeriveTreasuryProposals =>
       parseResult(api, { allIds, allProposals, approvalIds, councilProposals, proposalCount })
     )
   );
@@ -74,8 +74,8 @@ function retrieveProposals (api: ApiInterfaceRx, proposalCount: ProposalIndex, a
 /**
  * @description Retrieve all active and approved treasury proposals, along with their info
  */
-export function proposals (api: ApiInterfaceRx): () => Observable<DerivedTreasuryProposals> {
-  return memo((): Observable<DerivedTreasuryProposals> =>
+export function proposals (api: ApiInterfaceRx): () => Observable<DeriveTreasuryProposals> {
+  return memo((): Observable<DeriveTreasuryProposals> =>
     api.query.treasury
       ? combineLatest([
         api.query.treasury.proposalCount(),
@@ -87,8 +87,8 @@ export function proposals (api: ApiInterfaceRx): () => Observable<DerivedTreasur
       )
       : of({
         approvals: [],
-        proposalCount: createType(api.registry, 'ProposalIndex'),
+        proposalCount: api.registry.createType('ProposalIndex'),
         proposals: []
-      } as DerivedTreasuryProposals)
+      } as DeriveTreasuryProposals)
   );
 }

packages/api-derive/src/tx/constants.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import BN from 'bn.js';
+
+export const MAX_FINALITY_LAG = new BN(5);

packages/api-derive/src/tx/events.ts

@@ -0,0 +1,30 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { EventRecord, Hash, SignedBlock } from '@polkadot/types/interfaces';
+
+import { Observable, combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ApiInterfaceRx } from '@polkadot/api/types';
+
+import { memo } from '../util';
+
+interface Result {
+  block: SignedBlock;
+  events: EventRecord[];
+}
+
+export function events (api: ApiInterfaceRx): (at: Hash) => Observable<Result> {
+  return memo((at: Hash): Observable<Result> =>
+    combineLatest([
+      api.query.system.events.at(at),
+      api.rpc.chain.getBlock(at)
+    ]).pipe(
+      map(([events, block]) => ({
+        block,
+        events
+      }))
+    )
+  );
+}

packages/api-derive/src/tx/index.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+export * from './events';
+export * from './signingInfo';

packages/api-derive/src/tx/signingInfo.ts

@@ -0,0 +1,69 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { Header, Index } from '@polkadot/types/interfaces';
+import { AnyNumber, Codec, IExtrinsicEra } from '@polkadot/types/types';
+
+import BN from 'bn.js';
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { isNumber, isUndefined } from '@polkadot/util';
+
+interface Result {
+  header: Header | null;
+  mortalLength: number;
+  nonce: Index;
+}
+
+// default here to 5 min eras, adjusted based on the actual blocktime
+const FALLBACK_PERIOD = new BN(6 * 1000);
+const MAX_FINALITY_LAG = new BN(5);
+const MORTAL_PERIOD = new BN(5 * 60 * 1000);
+
+function latestNonce (api: ApiInterfaceRx, address: string): Observable<Index> {
+  return api.derive.balances.account(address).pipe(
+    map(({ accountNonce }): Index => accountNonce)
+  );
+}
+
+function signingHeader (api: ApiInterfaceRx): Observable<Header> {
+  return combineLatest([
+    api.rpc.chain.getHeader(),
+    api.rpc.chain.getFinalizedHead().pipe(
+      switchMap((hash) => api.rpc.chain.getHeader(hash))
+    )
+  ]).pipe(
+    map(([current, finalized]): Header =>
+      // determine the hash to use, current when lag > max, else finalized
+      current.number.unwrap().sub(finalized.number.unwrap()).gt(MAX_FINALITY_LAG)
+        ? current
+        : finalized
+    )
+  );
+}
+
+export function signingInfo (api: ApiInterfaceRx): (address: string, nonce?: AnyNumber | Codec, era?: IExtrinsicEra | number) => Observable<Result> {
+  // no memo, we want to do this fresh on each run
+  return (address: string, nonce?: AnyNumber | Codec, era?: IExtrinsicEra | number): Observable<Result> =>
+    combineLatest([
+      // retrieve nonce if none was specified
+      isUndefined(nonce)
+        ? latestNonce(api, address)
+        : of(api.registry.createType('Index', nonce)),
+      // if no era (create) or era > 0 (mortal), do block retrieval
+      (isUndefined(era) || (isNumber(era) && era > 0))
+        ? signingHeader(api)
+        : of(null)
+    ]).pipe(
+      map(([nonce, header]) => ({
+        header,
+        nonce,
+        mortalLength: MORTAL_PERIOD
+          .div(api.consts.babe?.expectedBlockTime || api.consts.timestamp?.minimumPeriod.muln(2) || FALLBACK_PERIOD)
+          .add(MAX_FINALITY_LAG)
+          .toNumber()
+      }))
+    );
+}

packages/api-derive/src/type/ReferendumInfoExtended.ts

@@ -1,57 +0,0 @@
-// Copyright 2017-2020 @polkadot/api-derive authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-import { ReferendumIndex, ReferendumInfo } from '@polkadot/types/interfaces/democracy';
-import { AnyJson, Constructor, Registry } from '@polkadot/types/types';
-
-import BN from 'bn.js';
-import democracyTypes from '@polkadot/types/interfaces/democracy/definitions';
-import { Struct } from '@polkadot/types';
-
-// We can ignore the properties, added via Struct.with
-const _ReferendumInfo: Constructor<ReferendumInfo> = Struct.with(democracyTypes.types.ReferendumInfo as any) as any;
-
-/**
- * @name ReferendumInfoExtended
- * @description
- * A [[ReferendumInfo]] with an additional `index` field
- */
-export default class ReferendumInfoExtended extends _ReferendumInfo {
-  readonly #index: ReferendumIndex;
-
-  constructor (registry: Registry, value: ReferendumInfo | ReferendumInfoExtended, index?: BN | number) {
-    super(registry, value);
-
-    this.#index = value instanceof ReferendumInfoExtended
-      ? value.index
-      : registry.createType('ReferendumIndex', index);
-  }
-
-  /**
-   * @description Convenience getter, returns the referendumIndex
-   */
-  public get index (): ReferendumIndex {
-    return this.#index;
-  }
-
-  /**
-   * @description Creates a human-friendly JSON representation
-   */
-  public toHuman (isExtended?: boolean): AnyJson {
-    return {
-      ...super.toHuman(isExtended) as { [index: string]: AnyJson },
-      index: this.index.toHuman(isExtended)
-    };
-  }
-
-  /**
-   * @description Creates the JSON representation
-   */
-  public toJSON (): AnyJson {
-    return {
-      ...super.toJSON() as { [index: string]: AnyJson },
-      index: this.index.toJSON()
-    };
-  }
-}

packages/api-derive/src/type/index.ts

@@ -3,4 +3,3 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 export { default as HeaderExtended } from './HeaderExtended';
-export { default as ReferendumInfoExtended } from './ReferendumInfoExtended';