[CI Skip] 0.96.1

* combine values

* findRecord newest

* constructor

* Add filterRecords

* Update interface

.123trigger

@@ -1 +1 @@
-6
+8

.circleci/config.yml

@@ -1,24 +0,0 @@
-version: 2
-jobs:
-  build:
-    branches:
-      ignore:
-        - gh-pages
-    working_directory: ~/polkadot-js
-    docker:
-      - image: circleci/node:10
-    steps:
-      - checkout
-      - restore_cache:
-          key: dependency-cache-{{ checksum "yarn.lock" }}
-      - run:
-          name: install-deps
-          command: yarn install --frozen-lockfile
-      - save_cache:
-          key: dependency-cache-{{ checksum "yarn.lock" }}
-          paths:
-            - ./node_modules
-            - ~/.cache/yarn
-      - run:
-          name: build
-          command: yarn polkadot-dev-circleci-build

.eslintrc.js

@@ -5,7 +5,7 @@ module.exports = {
   parserOptions: {
     ...base.parserOptions,
     project: [
-      './tsconfig.eslint.json'
+      './tsconfig.json'
     ]
   },
   rules: {

.github/workflows/pr-any.yml

@@ -1,4 +1,4 @@
-name: CI
+name: PR
 on: [pull_request]
 
 jobs:
@@ -51,7 +51,7 @@ jobs:
     - name: build
       run: |
         yarn install --frozen-lockfile
-        yarn build:split:code
+        yarn build
 
   build_docs:
     name: Build Docs
@@ -68,4 +68,4 @@ jobs:
     - name: build
       run: |
         yarn install --frozen-lockfile
-        yarn build:split:docs
+        yarn docs

.github/workflows/push-master.yml

@@ -0,0 +1,55 @@
+name: Master
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build_code:
+    name: Build Code
+    if: "! contains(github.event.head_commit.message, '[CI Skip]')"
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [12.x]
+    steps:
+    - uses: actions/checkout@v1
+      with:
+        token: ${{ secrets.GH_PAT }}
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - name: build
+      env:
+        CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+        GH_PAT: ${{ secrets.GH_PAT }}
+        GH_TOKEN: ${{ secrets.GH_PAT }}
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+      run: |
+        yarn install --frozen-lockfile
+        yarn polkadot-dev-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: 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 --frozen-lockfile
+        yarn polkadot-dev-ghact-docs

.travis.yml

@@ -1,28 +0,0 @@
-language: node_js
-node_js:
-  - "10"
-env:
-  global:
-    - CC_TEST_REPORTER_ID=b8983d04997f43ff9b9df9aa92904967547680e2a229af812b3cf14985713e84
-    - GH_PAGES_SRC="build-docs"
-cache:
-  yarn: true
-  directories:
-    - node_modules
-before_install:
-  - curl -o- -L https://yarnpkg.com/install.sh | bash
-  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
-  - chmod +x ./cc-test-reporter
-  - export PATH=$HOME/.yarn/bin::$(yarn global bin):$PATH
-before_script:
-  - ./cc-test-reporter before-build
-script:
-  - yarn polkadot-dev-travis-build
-after_script:
-  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT
-deploy:
-  skip_cleanup: true
-  provider: script
-  script: yarn polkadot-dev-travis-deploy
-  on:
-    branch: master

CHANGELOG.md

@@ -1,3 +1,27 @@
+# 0.96.1
+
+- Updated types for latest Kusama
+- Add `filterRecords` (in addition to `findRecord`) on submittable results
+- Various ABI v2 contract fixes
+- Update derive for elections (incl. RunnersUp) and heartbeat derives (with blocks & messages)
+- Add vesting totals & locked breakdowns to derive balances
+- Update council derives for the latest Substrate master support (with constants)
+- Derive cleanups, including sharing of instances between the API and internal to derives
+
+# 0.95.2
+
+- Temporary removal of `account_nextIndex` use, will be re-added in a future release
+
+# 0.95.1
+
+- Support Extrinsic V4 with additional signature indicator (Latest Polkadot/Substrate/Kusama)
+- Adjust subscription update checks to avoid duplicated data updates
+- Support Metadata V8 (exposes per-module `decl_error` definitions)
+- Support next generation contracts ABI (with additional type definitions)
+- Support for `BTreeMap<K, V>` types and definitions
+- All latest Polkadot & Substrate types (as per master branches)
+- **Breaking change** `Call.injectMethods` is moved to `Call.injectMetadata` to align with `Events` (This _should_ not be used externally, however mentioned as breaking here)
+
 # 0.94.1
 
 - Add handling of `Result<Ok, Error>` definitions

docs/SUMMARY.md

@@ -46,7 +46,7 @@
   - [Unsubscribe from listening](examples/promise/04_unsubscribe/README.md)
   - [Read chain state](examples/promise/05_read_storage/README.md)
   - [Make a transfer](examples/promise/06_make_transfer/README.md)
-  - [Display system events](examples/promise/08_system_events/README.md)(
+  - [Display system events](examples/promise/08_system_events/README.md)
   - [Transaction with events](examples/promise/09_transfer_events/README.md)
   - [Upgrade via sudo](examples/promise/10_upgrade_chain/README.md)
 - [ApiRx](examples/rx/README.md)

docs/examples/promise/05_read_storage_at/README.md

@@ -2,4 +2,4 @@
 
 In addition to querying the latest storage, you can make storage queries at a specific blockhash. Be aware that the node applies a pruning strategy and typically only keeps the last 256 blocks, unless run in archive mode.
 
-<<< @/docs/examples/promise/07_read_storage_at/index.js
+<<< @/docs/examples/promise/05_read_storage_at/index.js

docs/examples/rx/03_listen_to_balance_change/README.md

@@ -2,4 +2,4 @@
 
 This example shows how to instantiate a Polkadot API object and use it to connect to a node and retrieve balance updates.
 
-<<< @/docs/examples/rx/03_listent_to_balance_change/index.js
+<<< @/docs/examples/rx/03_listen_to_balance_change/index.js

docs/start/FAQ.md

@@ -23,3 +23,13 @@ As of this writing we don't have an explicit example of implementing the signer
 Some calls in Polkadot/Substrate can only be submitted as root, these are indicated by `ensure_root(origin)` in the Rust codebase. Root here does not refer to the actual account, i.e. `//Alice` on  a `--dev` chain, but rather that it cannot be submitted as a bare user transaction. This restriction applies to chain upgrades, changing balances or anything that modifies the state and/or chain operation.
 
 To submit these transactions, it needs to be send as a [wrapped transaction](api.tx.wrap.md#sudo-use) via either `sudo.sudo` (assuming you have access on your chain) or `democracy.proposal` (which would allow users of the chain to vote on it).
+
+## 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])`
+
+## 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).

docs/substrate/events.md

@@ -295,4 +295,4 @@ ___
 
 ### utility
 
-▸ **BatchExecuted**(`Vec<Result<Null,DispatchError>>`)
+▸ **BatchExecuted**(`Vec<DispatchResult>`)

lerna.json

@@ -9,5 +9,5 @@
   "packages": [
     "packages/*"
   ],
-  "version": "0.94.1"
+  "version": "0.96.1"
 }

package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.94.1",
+  "version": "0.96.1",
   "private": true,
   "engines": {
     "yarn": "^1.10.1"
@@ -9,17 +9,13 @@
   ],
   "resolutions": {
     "babel-core": "^7.0.0-bridge.0",
-    "typescript": "^3.6.3"
+    "typescript": "^3.7.2"
   },
   "scripts": {
-    "build": "yarn build:split:code && yarn build:split:docs",
-    "build:split:code": "yarn build:interfaces && polkadot-dev-build-ts",
-    "build:split:docs": "yarn run build:methodsdoc && polkadot-dev-build-docs",
-    "build:htmldoc": "yarn clean && typedoc --theme default --out docs/html",
+    "build": "yarn build:interfaces && polkadot-dev-build-ts",
     "build:interfaces": "node packages/types/src/scripts/interfacesTsWrapper.js",
-    "build:methodsdoc": "node packages/types/src/scripts/MetadataMdWrapper.js",
+    "docs": "node packages/types/src/scripts/MetadataMdWrapper.js && polkadot-dev-build-docs",
     "chain:info": "node packages/types/src/scripts/extractChainWrapper.js",
-    "check": "yarn lint",
     "lint": "eslint --ext .js,.jsx,.ts,.tsx . && tsc --noEmit --pretty",
     "clean": "polkadot-dev-clean-build",
     "postinstall": "polkadot-dev-yarn-only",
@@ -32,11 +28,10 @@
     "test:watch": "jest --coverage --watch"
   },
   "devDependencies": {
-    "@babel/core": "^7.6.2",
-    "@babel/register": "^7.6.2",
-    "@babel/runtime": "^7.6.2",
-    "@polkadot/dev": "^0.31.1",
-    "@polkadot/ts": "^0.1.73",
-    "gh-pages": "^2.1.1"
+    "@babel/core": "^7.7.0",
+    "@babel/register": "^7.7.0",
+    "@babel/runtime": "^7.6.3",
+    "@polkadot/dev": "^0.32.0-beta.13",
+    "@polkadot/ts": "^0.1.84"
   }
 }

packages/api-contract/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/api-contract",
-  "version": "0.94.1",
+  "version": "0.96.1",
   "description": "Interfaces for interacting with contracts and contract ABIs",
   "main": "index.js",
   "keywords": [
@@ -26,7 +26,7 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api-contract#readme",
   "dependencies": {
-    "@babel/runtime": "^7.6.2",
-    "@polkadot/types": "^0.94.1"
+    "@babel/runtime": "^7.7.1",
+    "@polkadot/types": "^0.96.1"
   }
 }

packages/api-contract/src/Abi.spec.ts

@@ -2,118 +2,21 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { ContractABIArg } from './types';
-
-import typesAbi from '../test/abi/types.json';
-import erc20Abi from '../test/contracts/Erc20.json';
+import incrementerAbi from '../test/contracts/incrementer.json';
 
 import { Abi } from '.';
 
 describe('Abi', (): void => {
-  describe('types encoding', (): void => {
-    let abi: Abi;
-
-    beforeAll((): void => {
-      abi = new Abi(typesAbi);
-    });
-
-    function check (method: string, args: ContractABIArg[], type: string | null): void {
-      const fn = abi.messages[method];
-
-      expect(fn.args).toEqual(args);
-      expect(fn.type).toEqual(type);
-    }
-
-    it('has the primitive method with args & return', (): void => {
-      check(
-        'primitive',
-        [
-          { name: 'bool', type: 'bool' },
-          { name: 'u32', type: 'u32' }
-        ],
-        'bool'
-      );
-    });
-
-    it('has the vector method with args & return', (): void => {
-      check(
-        'vector',
-        [
-          { name: 'vecU8', type: 'Vec<u8>' },
-          { name: 'vecU32', type: 'Vec<u32>' }
-        ],
-        'Vec<bool>'
-      );
-    });
-
-    it('has the vector_fixed method with args & return', (): void => {
-      check(
-        'vectorFixed',
-        [
-          { name: 'vecU8Length32', type: '[u8;32]' }
-        ],
-        '[u32;8]'
-      );
-    });
-
-    it('has the option method with args & return', (): void => {
-      check(
-        'option',
-        [
-          { name: 'optionU32', type: 'Option<u32>' }
-        ],
-        'Option<bool>'
-      );
-    });
-
-    it('has the result method with return (empty)', (): void => {
-      check(
-        'result',
-        [],
-        '()'
-      );
-    });
-
-    it('allows for nested args', (): void => {
-      check(
-        'nested',
-        [
-          { name: 'optionVec', type: 'Option<Vec<u32>>' }
-        ],
-        'Vec<(u32,u64)>'
-      );
-    });
-
-    describe('messages', (): void => {
-      it('fails when invalid args are supplied', (): void => {
-        expect(
-          (): Uint8Array => abi.messages.primitive(false)
-        ).toThrow(/Expected 2 arguments to contract messages.primitive, found 1/);
-      });
-
-      it('encodes primitives correctly', (): void => {
-        expect(
-          abi.messages.primitive(true, 0x12345678)
-        ).toEqual(new Uint8Array([
-          9 << 2, // total length (4 + 1 + 4)
-          0x67, 0x2b, 0, 0, // 11111 -> hex (LE)
-          1, // true
-          0x78, 0x56, 0x34, 0x12 // u32
-        ]));
-      });
-    });
-  });
-
-  describe('erc20', (): void => {
+  describe('incrementer', (): void => {
     let abi: Abi;
 
     beforeEach((): void => {
-      abi = new Abi(erc20Abi);
+      abi = new Abi(incrementerAbi);
     });
 
     it('has the attached methods', (): void => {
-      expect(Object.keys(abi.messages)).toEqual(
-        ['totalSupply', 'balanceOf', 'allowance', 'transfer', 'approve', 'transferFrom']
+      expect(Object.values(abi.abi.contract.messages).map(({ name }): string => name)).toEqual(
+        ['inc', 'get', 'compare']
       );
     });
   });

packages/api-contract/src/Abi.ts

@@ -2,30 +2,45 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { ContractABI, ContractABIFn, InterfaceAbi, AbiMessages } from './types';
-
+import { AbiConstructors, AbiMessages, ContractABI, ContractABIPre, ContractABIFn, InterfaceAbi } from './types';
 import { stringCamelCase } from '@polkadot/util';
 
-import { createMethod } from './method';
-import { validateAbi } from './validation';
+import ContractRegistry from './ContractRegistry';
 
-export default class ContractAbi implements InterfaceAbi {
+export default class ContractAbi extends ContractRegistry implements InterfaceAbi {
   public readonly abi: ContractABI;
 
-  public readonly deploy: ContractABIFn;
+  public readonly constructors: AbiConstructors;
 
-  public readonly messages: AbiMessages = {};
+  public readonly messages: AbiMessages;
 
-  public constructor (abi: ContractABI) {
-    validateAbi(abi);
+  constructor (abi: ContractABIPre) {
+    super(abi);
+    [this.abi, this.constructors, this.messages] = this.decodeAbi(abi);
+  }
 
-    this.abi = abi;
-    this.deploy = createMethod('deploy', abi.deploy);
+  private decodeAbi (abiPre: ContractABIPre): [ContractABI, ContractABIFn[], AbiMessages] {
+    this.validateAbi(abiPre);
 
-    abi.messages.forEach((method): void => {
-      const name = stringCamelCase(method.name);
+    const abi = this.convertAbi(abiPre);
+    const constructors = abi.contract.constructors.map(
+      (constructor, index): ContractABIFn => {
+        return this.createMessage(`constructor ${index}`, constructor);
+      }
+    );
 
-      this.messages[name] = createMethod(`messages.${name}`, method);
-    });
+    const messages: AbiMessages = abi.contract.messages.reduce(
+      (result: AbiMessages, message): AbiMessages => {
+        const name = stringCamelCase(message.name);
+
+        return {
+          ...result,
+          [name]: this.createMessage(`messages.${name}`, message)
+        };
+      },
+      {}
+    );
+
+    return [abi, constructors, messages];
   }
 }

packages/api-contract/src/ContractRegistry.ts

@@ -0,0 +1,219 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 { CodecArg, Constructor, TypeDef } from '@polkadot/types/types';
+import { ContractABIArgBasePre, ContractABIContract, ContractABIContractPre, ContractABIEvent, ContractABIEventPre, ContractABIFn, ContractABIFnArg, ContractABIMessage, ContractABIMessageBase, ContractABIMessagePre, ContractABI, ContractABIMessageCommon, ContractABIPre, ContractABIRange, ContractABIRangePre, ContractABIStorage, ContractABIStorageLayout, ContractABIStorageLayoutPre, ContractABIStoragePre, ContractABIStorageStruct, ContractABIStorageStructPre, ContractABITypePre } from './types';
+import { Compact, u32, createClass, createType, encodeType } from '@polkadot/types';
+
+import { assert, hexToU8a, isNumber, isString, isNull, isObject, isUndefined, stringCamelCase, isHex, hexToNumber } from '@polkadot/util';
+
+import MetaRegistry from './MetaRegistry';
+
+// parse a selector, this can be a number (older) or of [<hex>, <hex>, ...]. However,
+// just catch everything (since this is now non-standard for u32 anyway)
+function parseSelector (fnname: string, input: ContractABIMessageCommon['selector']): u32 {
+  if (isNumber(input)) {
+    return createType('u32', input);
+  } else if (isHex(input)) {
+    return createType('u32', hexToU8a(input));
+  } else if (typeof input === 'string') {
+    try {
+      const array = JSON.parse(input);
+
+      assert(array.length === 4, `${fnname}: Invalid selector length`);
+
+      return createType('u32', Uint8Array.from(
+        // the as number[] is here to pacify TS, it doesn't quite know how to handle the cb
+        (array as number[]).map((value: string | number): number =>
+          isHex(value)
+            ? hexToNumber(value.toString())
+            : value
+        )
+      ));
+    } catch (e) {
+      console.error(e);
+    }
+  }
+
+  throw new Error(`${fnname}: Unable to parse selector`);
+}
+
+function createArgClass (args: ContractABIFnArg[], baseDef: Record<string, string>): Constructor {
+  return createClass(
+    JSON.stringify(
+      args.reduce((base: Record<string, any>, { name, type }): Record<string, any> => {
+        base[name] = type.displayName || encodeType(type);
+
+        return base;
+      }, baseDef)
+    )
+  );
+}
+
+export default class ContractRegistry extends MetaRegistry {
+  // Contract ABI helpers
+  public validateArgs (name: string, args: ContractABIArgBasePre[]): void {
+    assert(Array.isArray(args), `Expected 'args' to exist on ${name}`);
+
+    args.forEach((arg): void => {
+      const unknownKeys = Object.keys(arg).filter((key): boolean => !['name', 'type'].includes(key));
+
+      assert(unknownKeys.length === 0, `Unknown keys ${unknownKeys.join(', ')} found in ABI args for ${name}`);
+      assert(isNumber(arg.name) && isString(this.stringAt(arg.name)), `${name} args should have valid name `);
+      assert(isNumber(arg.type.ty) && isObject(this.typeDefAt(arg.type.ty)), `${name} args should have valid type`);
+    });
+  }
+
+  public validateConstructors ({ contract: { constructors } }: ContractABIPre): void {
+    constructors.forEach((constructor: ContractABIMessagePre, index): void => {
+      const unknownKeys = Object.keys(constructor).filter((key): boolean => !['args', 'docs', 'name', 'selector'].includes(key));
+
+      assert(unknownKeys.length === 0, `Unknown keys ${unknownKeys.join(', ')} found in ABI constructor`);
+
+      this.validateArgs(`constructor ${index}`, constructor.args);
+    });
+  }
+
+  public validateMessages ({ contract: { messages } }: ContractABIPre): void {
+    messages.forEach((message): void => {
+      const unknownKeys = Object.keys(message).filter((key): boolean => !['args', 'docs', 'mutates', 'name', 'selector', 'return_type'].includes(key));
+      const fnname = `messages.${message.name}`;
+
+      assert(unknownKeys.length === 0, `Unknown keys ${unknownKeys.join(', ')} found in ABI args for messages.${message.name}`);
+
+      const { name, selector, return_type: returnType } = message;
+
+      assert(isNumber(name) && isString(this.stringAt(name)), `Expected name for ${fnname}`);
+      assert(isNull(returnType) || (isNumber(returnType.ty) && isObject(this.typeDefAt(returnType.ty))), `Expected return_type for ${fnname}`);
+
+      parseSelector(fnname, selector);
+      this.validateArgs(fnname, message.args);
+    });
+  }
+
+  public validateAbi (abi: ContractABIPre): void {
+    const unknownKeys = Object.keys(abi.contract).filter((key): boolean => !['constructors', 'docs', 'events', 'messages', 'name'].includes(key));
+
+    assert(unknownKeys.length === 0, `Unknown fields ${unknownKeys.join(', ')} found in ABI`);
+
+    const { contract: { constructors, messages, name } } = abi;
+
+    assert(constructors && messages && isString(this.stringAt(name)), 'ABI should have constructors, messages & name sections');
+
+    this.validateConstructors(abi);
+    this.validateMessages(abi);
+  }
+
+  public createMessage (name: string, message: Partial<ContractABIMessage> & ContractABIMessageBase): ContractABIFn {
+    const args = message.args.map(({ name, type }): ContractABIFnArg => {
+      assert(isObject(type), `Invalid type at index ${type}`);
+      return {
+        name: stringCamelCase(name),
+        type
+      };
+    });
+    const Clazz = createArgClass(args, isUndefined(message.selector) ? {} : { __selector: 'u32' });
+    const baseStruct: { [index: string]: any } = { __selector: isUndefined(message.selector) ? undefined : parseSelector(name, message.selector) };
+    const encoder = (...params: CodecArg[]): Uint8Array => {
+      assert(params.length === args.length, `Expected ${args.length} arguments to contract ${name}, found ${params.length}`);
+
+      const u8a = new Clazz(
+        args.reduce((mapped, { name }, index): Record<string, CodecArg> => {
+          mapped[name] = params[index];
+
+          return mapped;
+        }, { ...baseStruct })
+      ).toU8a();
+
+      return Compact.addLengthPrefix(u8a);
+    };
+
+    const fn = (encoder as ContractABIFn);
+
+    fn.args = args;
+    fn.isConstant = !(message.mutates || false);
+    fn.type = message.returnType || null;
+    return fn;
+  }
+
+  public convertAbi ({ contract, storage }: ContractABIPre): ContractABI {
+    return {
+      contract: this.convertContract(contract),
+      storage: this.convertStorage(storage)
+    };
+  }
+
+  public convertArgs (args: ContractABIArgBasePre[]): any[] {
+    return args.map(({ name, type, ...arg }) => ({ ...arg, name: this.stringAt(name), type: this.convertType(type) }));
+  }
+
+  public convertType ({ ty, display_name: displayNameIndices }: ContractABITypePre): TypeDef {
+    const displayName = this.stringsAt(displayNameIndices).join('::');
+    return this.typeDefAt(ty, { displayName });
+  }
+
+  public convertContract ({ constructors, messages, name, events, ...contract }: ContractABIContractPre): ContractABIContract {
+    return {
+      constructors: this.convertConstructors(constructors),
+      messages: messages.map(message => this.convertMessage(message)),
+      name: this.stringAt(name),
+      ...(events
+        ? { events: events.map(event => this.convertEvent(event)) }
+        : {}),
+      ...contract
+    };
+  }
+
+  public convertConstructors (constructors: ContractABIMessagePre[]): ContractABIMessage[] {
+    return constructors.map(
+      (constructor: ContractABIMessagePre): ContractABIMessage => {
+        return this.convertMessage(constructor);
+      }
+    );
+  }
+
+  public convertMessage ({ args, name, return_type: returnType, ...message }: ContractABIMessagePre): ContractABIMessage {
+    return {
+      ...message,
+      args: this.convertArgs(args),
+      name: this.stringAt(name),
+      returnType: returnType ? this.convertType(returnType) : null
+    };
+  }
+
+  public convertEvent ({ args }: ContractABIEventPre): ContractABIEvent {
+    return {
+      args: this.convertArgs(args)
+    };
+  }
+
+  public convertStorage (storage: ContractABIStoragePre): ContractABIStorage {
+    return this.convertStorageStruct(storage);
+  }
+
+  public convertStorageLayout (storageLayout: ContractABIStorageLayoutPre): ContractABIStorageLayout {
+    if ((storageLayout as ContractABIStorageStructPre)['struct.type']) {
+      return this.convertStorageStruct(storageLayout as ContractABIStorageStructPre);
+    } else {
+      return this.convertStorageRange(storageLayout as ContractABIRangePre);
+    }
+  }
+
+  public convertStorageStruct ({ 'struct.type': structType, 'struct.fields': structFields }: ContractABIStorageStructPre): ContractABIStorageStruct {
+    return {
+      'struct.type': this.typeDefAt(structType),
+      'struct.fields': structFields.map(({ name, layout }) => ({
+        name: this.stringAt(name),
+        layout: this.convertStorageLayout(layout)
+      }))
+    };
+  }
+
+  public convertStorageRange ({ 'range.elem_type': type, ...range }: ContractABIRangePre): ContractABIRange {
+    return {
+      ...range,
+      'range.elem_type': this.typeDefAt(type)
+    };
+  }
+}

packages/api-contract/src/MetaRegistry.spec.ts

@@ -0,0 +1,33 @@
+// Copyright 2017-2019 @polkadot/types 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 fs from 'fs';
+import path from 'path';
+
+import MetaRegistry from './MetaRegistry';
+
+import erc20Abi from '../test/contracts/Erc20.json';
+import sharedVecAbi from '../test/contracts/SharedVecV2.json';
+
+describe('MetaRegistry', (): void => {
+  describe('construction', (): void => {
+    it('initializes from a contract ABI (ERC20)', (): void => {
+      const metaRegistry = new MetaRegistry(erc20Abi);
+      fs.writeFile(path.join(__dirname, '../test/compare/erc20.test.json'), JSON.stringify(metaRegistry.typeDefs, null, 2), function (err): void {
+        if (err) throw err;
+      });
+
+      expect(true).toBe(true);
+    });
+
+    it('initializes from a contract ABI (SharedVec)', (): void => {
+      const metaRegistry = new MetaRegistry(sharedVecAbi);
+      fs.writeFile(path.join(__dirname, '../test/compare/shared-vec.test.json'), JSON.stringify(metaRegistry.typeDefs, null, 2), function (err): void {
+        if (err) throw err;
+      });
+
+      expect(true).toBe(true);
+    });
+  });
+});

packages/api-contract/src/MetaRegistry.ts

@@ -0,0 +1,348 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 { MetaRegistryItem, MetaRegistryJson, MetaTypeDefClikeEnum, MetaType, MetaTypeDefEnum, MetaTypeDefEnumVariant, MetaTypeDefEnumVariantStruct, MetaTypeDefEnumVariantTupleStruct, MetaTypeDefEnumVariantUnit, MetaTypeDefStruct, MetaTypeDefStructField, MetaTypeDefTupleStruct, MetaTypeDefUnion, MetaTypeIdCustom, MetaTypeIdVec, MetaTypeIdVecFixed, MetaTypeInfo, StringIndex, TypeDef, TypeDefInfo, TypeIndex } from '@polkadot/types/types';
+
+import { assert } from '@polkadot/util';
+import { displayType, withTypeString } from '@polkadot/types';
+
+const builtinMap: [(id: any) => boolean, MetaTypeInfo][] = [
+  [(id: any): boolean => typeof id === 'string', MetaTypeInfo.BuiltinPlain],
+  [(id: any): boolean => Array.isArray(id), MetaTypeInfo.BuiltinTuple],
+  [(id: any): boolean => !!(id['array.type']), MetaTypeInfo.BuiltinVecFixed],
+  [(id: any): boolean => !!(id['slice.type']), MetaTypeInfo.BuiltinVec]
+];
+
+const typeMap: [string, MetaTypeInfo][] = [
+  ['enum.variants', MetaTypeInfo.Enum],
+  ['clike_enum.variants', MetaTypeInfo.ClikeEnum],
+  ['struct.fields', MetaTypeInfo.Struct],
+  ['tuple_struct.types', MetaTypeInfo.TupleStruct]
+];
+
+function detectedType ({ def, id }: MetaType): MetaTypeInfo {
+  assert(!(def as MetaTypeDefUnion)['union.fields'], 'Invalid union type definition found');
+
+  const lookup = def === 'builtin'
+    ? builtinMap.find(([test]): boolean => test(id))
+    : typeMap.find(([test]): boolean => !!(def as any)[test]);
+
+  return lookup
+    ? lookup[1]
+    : MetaTypeInfo.Null;
+}
+
+class MetadataRegistryLookup {
+  protected _strings: string[] = [];
+
+  protected _types: MetaType[] = [];
+
+  public typeDefs: TypeDef[] = [];
+
+  constructor ({ registry: { strings, types } }: MetaRegistryJson) {
+    this._strings = strings;
+    this._types = types;
+  }
+
+  protected hasItemAt (index: number, variant: MetaRegistryItem): boolean {
+    switch (variant) {
+      case MetaRegistryItem.String:
+        return this._strings && !!this._strings[index - 1];
+      case MetaRegistryItem.Type:
+        return this._types && !!this._types[index - 1];
+      case MetaRegistryItem.TypeDef:
+        return this.typeDefs && !!this.typeDefs[index - 1];
+    }
+  }
+
+  protected itemAt (index: number, variant: MetaRegistryItem): any {
+    assert(this.hasItemAt(index, variant), `MetaRegistry: Invalid ${variant} index ${index} found in metadata`);
+
+    switch (variant) {
+      case MetaRegistryItem.String:
+        return this._strings[index - 1];
+      case MetaRegistryItem.Type:
+        return this._types[index - 1];
+      case MetaRegistryItem.TypeDef:
+        return this.typeDefs[index - 1];
+    }
+  }
+
+  protected itemsAt (indices: number[], variant: MetaRegistryItem): any[] {
+    return indices.map((index: number): string => this.itemAt(index, variant));
+  }
+
+  protected stringAt (index: StringIndex): string {
+    return this.itemAt(index, MetaRegistryItem.String);
+  }
+
+  public stringsAt (indices: StringIndex[]): string[] {
+    return this.itemsAt(indices, MetaRegistryItem.String);
+  }
+
+  public typeAt (index: TypeIndex): MetaType {
+    return this.itemAt(index, MetaRegistryItem.Type);
+  }
+
+  public typesAt (indices: TypeIndex[]): MetaType[] {
+    return this.itemsAt(indices, MetaRegistryItem.Type);
+  }
+
+  public hasTypeDefAt (index: TypeIndex): boolean {
+    return this.hasItemAt(index, MetaRegistryItem.TypeDef);
+  }
+
+  public typeDefAt (index: TypeIndex, extra: Pick<TypeDef, never> = {}): TypeDef {
+    return {
+      ...this.itemAt(index, MetaRegistryItem.TypeDef),
+      ...extra
+    };
+  }
+}
+
+export default class MetaRegistry extends MetadataRegistryLookup {
+  constructor (json: MetaRegistryJson) {
+    super(json);
+
+    // Generate TypeDefs for each provided registry type
+    this._types.forEach((_, index: number): void => this.setTypeDefAtIndex(index + 1));
+  }
+
+  public setTypeDefAtIndex (typeIndex: TypeIndex): void {
+    this.typeDefs[typeIndex - 1] = this.typeDefFromMetaType(this.typeAt(typeIndex), typeIndex);
+  }
+
+  private typeDefIdFields ({ id }: MetaType): Pick<TypeDef, never> {
+    const { 'custom.name': nameIndex, 'custom.namespace': namespaceIndices, 'custom.params': paramsIndices } = id as MetaTypeIdCustom;
+
+    if (!nameIndex) {
+      return {};
+    }
+
+    return {
+      name: this.stringAt(nameIndex),
+      ...(namespaceIndices && namespaceIndices.length
+        ? { namespace: this.stringsAt(namespaceIndices).join('::') }
+        : {}
+      ),
+      ...(paramsIndices && paramsIndices.length
+        ? { params: this.typesAt(paramsIndices).map((type): TypeDef => this.typeDefFromMetaType(type)) }
+        : {}
+      )
+    };
+  }
+
+  private typeDefDefFields (metaType: MetaType, typeIndex?: TypeIndex): Pick<TypeDef, never> {
+    let typeDef;
+
+    switch (detectedType(metaType)) {
+      case MetaTypeInfo.BuiltinPlain:
+        typeDef = this.typeDefForBuiltinPlain(metaType.id as string);
+        break;
+      case MetaTypeInfo.BuiltinTuple:
+        typeDef = this.typeDefForBuiltinTuple(metaType.id as TypeIndex[]);
+        break;
+      case MetaTypeInfo.BuiltinVec:
+        typeDef = this.typeDefForBuiltinVec(metaType.id as MetaTypeIdVec, typeIndex);
+        break;
+      case MetaTypeInfo.BuiltinVecFixed:
+        typeDef = this.typeDefForBuiltinVecFixed(metaType.id as MetaTypeIdVecFixed, typeIndex);
+        break;
+      case MetaTypeInfo.Enum:
+        typeDef = this.typeDefForEnum(metaType.def as MetaTypeDefEnum, metaType.id as MetaTypeIdCustom, typeIndex);
+        break;
+      case MetaTypeInfo.ClikeEnum:
+        typeDef = this.typeDefForClikeEnum(metaType.def as MetaTypeDefClikeEnum);
+        break;
+      case MetaTypeInfo.Struct:
+        typeDef = this.typeDefForStruct(metaType.def as MetaTypeDefStruct);
+        break;
+      case MetaTypeInfo.TupleStruct:
+        typeDef = this.typeDefForTupleStruct(metaType.def as MetaTypeDefTupleStruct);
+        break;
+      case MetaTypeInfo.Null:
+      default:
+        throw new Error(`Invalid type detected at index ${typeIndex}`);
+    }
+
+    return typeDef;
+  }
+
+  public typeDefFromMetaType (metaType: MetaType, typeIndex?: TypeIndex): TypeDef {
+    return withTypeString({
+      info: TypeDefInfo.Null,
+      type: '',
+      ...this.typeDefDefFields(metaType, typeIndex),
+      ...this.typeDefIdFields(metaType)
+    }) as TypeDef;
+  }
+
+  public typeDefFromMetaTypeAt (typeIndex: TypeIndex): TypeDef {
+    if (!this.hasTypeDefAt(typeIndex)) {
+      this.setTypeDefAtIndex(typeIndex);
+    }
+
+    return this.typeDefAt(typeIndex);
+  }
+
+  private typeDefForEnumVariant (variant: MetaTypeDefEnumVariant): Pick<TypeDef, any> {
+    const { 'unit_variant.name': unitNameIndex } = variant as MetaTypeDefEnumVariantUnit;
+
+    if (unitNameIndex) {
+      return {
+        info: TypeDefInfo.Plain,
+        name: this.stringAt(unitNameIndex),
+        type: 'Null'
+      };
+    }
+
+    const { 'tuple_struct_variant.name': tupleStructVariantNameIndex } = variant as MetaTypeDefEnumVariantTupleStruct;
+
+    if (tupleStructVariantNameIndex) {
+      return this.typeDefForTupleStruct(variant as MetaTypeDefEnumVariantTupleStruct);
+    }
+
+    const { 'struct_variant.name': structVariantNameIndex } = variant as MetaTypeDefEnumVariantStruct;
+
+    if (structVariantNameIndex) {
+      return this.typeDefForStruct(variant as MetaTypeDefEnumVariantStruct);
+    }
+
+    return {
+      info: TypeDefInfo.Null,
+      type: 'Null'
+    };
+  }
+
+  private typeDefForBuiltinPlain (id: string): Pick<TypeDef, never> {
+    return {
+      info: TypeDefInfo.Plain,
+      type: id
+    };
+  }
+
+  private typeDefForBuiltinTuple (id: TypeIndex[]): Pick<TypeDef, never> {
+    const sub = id.map((tupleTypeIndex: number): TypeDef => this.typeDefFromMetaTypeAt(tupleTypeIndex));
+
+    return {
+      info: TypeDefInfo.Tuple,
+      sub
+    };
+  }
+
+  private typeDefForBuiltinVec (id: MetaTypeIdVec, typeIndex?: TypeIndex): Pick<TypeDef, never> {
+    const { 'slice.type': vecTypeIndex } = id;
+
+    assert(!typeIndex || vecTypeIndex !== typeIndex, `MetaRegistry: self-referencing registry type at index ${typeIndex}`);
+
+    const type = displayType(this.typeDefFromMetaTypeAt(vecTypeIndex));
+    assert(type && type.length > 0, `MetaRegistry: Invalid builtin Vec type found at index ${typeIndex}`);
+
+    return {
+      info: TypeDefInfo.Vec,
+      type: `Vec<${type}>`,
+      sub: this.typeDefFromMetaTypeAt(vecTypeIndex)
+    };
+  }
+
+  private typeDefForBuiltinVecFixed (id: MetaTypeIdVecFixed, typeIndex?: TypeIndex): Pick<TypeDef, never> {
+    const { 'array.type': vecTypeIndex, 'array.len': vecLength } = id;
+
+    assert(!vecLength || vecLength <= 256, 'MetaRegistry: Only support for [Type; <length>], where length <= 256');
+    assert(!typeIndex || vecTypeIndex !== typeIndex, `MetaRegistry: self-referencing registry type at index ${typeIndex}`);
+
+    const type = displayType(this.typeDefFromMetaTypeAt(vecTypeIndex));
+    assert(type && type.length > 0, `MetaRegistry: Invalid vector type found at index ${typeIndex}`);
+
+    return {
+      info: TypeDefInfo.VecFixed,
+      ext: { length: vecLength, type },
+      type: `[${type};${vecLength}]`,
+      sub: this.typeDefFromMetaTypeAt(vecTypeIndex)
+    };
+  }
+
+  private typeDefForEnum (def: MetaTypeDefEnum, id: MetaTypeIdCustom, typeIndex?: TypeIndex): Pick<TypeDef, any> {
+    const name = id && this.stringAt(id['custom.name']);
+
+    switch (name) {
+      case 'Option':
+        return this.typeDefForOption(id, typeIndex);
+      case 'Result':
+        return this.typeDefForResult(id, typeIndex);
+      default: {
+        const sub = def['enum.variants'].map(variant => this.typeDefForEnumVariant(variant));
+
+        return {
+          info: TypeDefInfo.Enum,
+          sub
+        };
+      }
+    }
+  }
+
+  private typeDefForClikeEnum (def: MetaTypeDefClikeEnum): Pick<TypeDef, never> {
+    return {
+      info: TypeDefInfo.Enum,
+      sub: def['clike_enum.variants'].map(({ name: nameIndex, discriminant }): TypeDef => ({
+        ext: { discriminant },
+        info: TypeDefInfo.Plain,
+        name: this.stringAt(nameIndex),
+        type: 'Null'
+      }))
+    };
+  }
+
+  public typeDefForOption (id: MetaTypeIdCustom, typeIndex?: TypeIndex): Pick<TypeDef, any> {
+    assert(id['custom.params'] && id['custom.params'][0], `Invalid Option type defined at index ${typeIndex}`);
+
+    return {
+      info: TypeDefInfo.Option,
+      sub: this.typeDefFromMetaTypeAt(id['custom.params']![0])
+    };
+  }
+
+  public typeDefForResult (id: MetaTypeIdCustom, typeIndex?: TypeIndex): Pick<TypeDef, any> {
+    assert(id['custom.params'] && id['custom.params'][0] && id['custom.params'][1], `Invalid Result type defined at index ${typeIndex}`);
+
+    return {
+      info: TypeDefInfo.Result,
+      sub: id['custom.params']!.map((typeIndex): TypeDef => this.typeDefFromMetaTypeAt(typeIndex))
+    };
+  }
+
+  public typeDefForStruct (def: MetaTypeDefStruct | MetaTypeDefEnumVariantStruct): Pick<TypeDef, any> {
+    const structFields = (def as MetaTypeDefStruct)['struct.fields'] || (def as MetaTypeDefEnumVariantStruct)['struct_variant.fields'];
+    const structNameIndex = (def as MetaTypeDefEnumVariantStruct)['struct_variant.name'];
+
+    return withTypeString({
+      info: TypeDefInfo.Struct,
+      ...(structNameIndex
+        ? { name: this.stringAt(structNameIndex) }
+        : {}
+      ),
+      sub: structFields.map((field: MetaTypeDefStructField): TypeDef => ({
+        ...this.typeDefFromMetaTypeAt(field.type),
+        name: this.stringAt(field.name)
+      }))
+    });
+  }
+
+  private typeDefForTupleStruct (def: MetaTypeDefTupleStruct | MetaTypeDefEnumVariantTupleStruct): Pick<TypeDef, any> {
+    const tupleStructTypes = (def as MetaTypeDefTupleStruct)['tuple_struct.types'] || (def as MetaTypeDefEnumVariantTupleStruct)['tuple_struct_variant.types'];
+    const tupleStructNameIndex = (def as MetaTypeDefEnumVariantTupleStruct)['tuple_struct_variant.name'];
+
+    return withTypeString({
+      info: TypeDefInfo.Tuple,
+      ...(tupleStructNameIndex
+        ? { name: this.stringAt(tupleStructNameIndex) }
+        : {}
+      ),
+      sub: tupleStructTypes.map((fieldIndex: number, index: number): TypeDef => ({
+        ...this.typeDefFromMetaTypeAt(fieldIndex),
+        index
+      }))
+    });
+  }
+}

packages/api-contract/src/RxBase.ts

@@ -1,31 +0,0 @@
-// Copyright 2017-2019 @polkadot/api-contract 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 { SubmittableModuleExtrinsics } from '@polkadot/api/types';
-import { ApiObject, ContractABI, ContractBase } from './types';
-
-import { assert } from '@polkadot/util';
-
-import Abi from './Abi';
-
-// NOTE Experimental, POC, bound to change
-export default abstract class RxBase implements ContractBase<'rxjs'> {
-  public readonly abi: Abi;
-
-  public readonly api: ApiObject<'rxjs'>;
-
-  public readonly apiContracts: SubmittableModuleExtrinsics<'rxjs'>;
-
-  public constructor (api: ApiObject<'rxjs'>, abi: ContractABI | Abi) {
-    this.abi = abi instanceof Abi
-      ? abi
-      : new Abi(abi);
-    this.api = api;
-
-    // cater for substrate 2.x & 1.x (in order)
-    this.apiContracts = api.tx.contracts || api.tx.contract;
-
-    assert(this.apiContracts && this.apiContracts.putCode, 'You need to connect to a node with the contracts module, the metadata does not enable api.tx.contracts on this instance');
-  }
-}

packages/api-contract/src/RxBlueprint.ts

@@ -1,70 +0,0 @@
-// Copyright 2017-2019 @polkadot/api-contract 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 { SubmittableResultImpl } from '@polkadot/api/types';
-import { AccountId, Address, Hash } from '@polkadot/types/interfaces';
-import { IKeyringPair } from '@polkadot/types/types';
-import { ContractABI } from './types';
-
-import BN from 'bn.js';
-import { Observable } from 'rxjs';
-import { map } from 'rxjs/operators';
-import { ApiRx, SubmittableResult } from '@polkadot/api';
-import { createType } from '@polkadot/types';
-
-import Abi from './Abi';
-import RxBase from './RxBase';
-import RxContract from './RxContract';
-
-type BlueprintCreateResultSubscription = Observable<BlueprintCreateResult>;
-
-export interface BlueprintCreate {
-  signAndSend (account: IKeyringPair | string | AccountId | Address): BlueprintCreateResultSubscription;
-}
-
-class BlueprintCreateResult extends SubmittableResult {
-  public readonly contract?: RxContract;
-
-  public constructor (result: SubmittableResultImpl, contract?: RxContract) {
-    super(result);
-
-    this.contract = contract;
-  }
-}
-
-// NOTE Experimental, POC, bound to change
-export default class Blueprint extends RxBase {
-  public readonly codeHash: Hash;
-
-  public constructor (api: ApiRx, abi: ContractABI | Abi, codeHash: string | Hash) {
-    super(api, abi);
-
-    this.codeHash = createType('Hash', codeHash);
-  }
-
-  public deployContract (endowment: number | BN, maxGas: number | BN, ...params: any[]): BlueprintCreate {
-    const signAndSend = (account: IKeyringPair | string | AccountId | Address): BlueprintCreateResultSubscription => {
-      return this.apiContracts
-        .create(endowment, maxGas, this.codeHash, this.abi.deploy(...params))
-        .signAndSend(account)
-        .pipe(map(this.createResult));
-    };
-
-    return { signAndSend };
-  }
-
-  private createResult = (result: SubmittableResult): BlueprintCreateResult => {
-    let contract: RxContract | undefined;
-
-    if (result.isFinalized) {
-      const record = result.findRecord('contract', 'Instantiated');
-
-      if (record) {
-        contract = new RxContract(this.api, this.abi, record.event.data[1] as Address);
-      }
-    }
-
-    return new BlueprintCreateResult(result, contract);
-  }
-}

packages/api-contract/src/RxCode.ts

@@ -1,83 +0,0 @@
-// Copyright 2017-2019 @polkadot/api-contract 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 { SubmittableResultImpl } from '@polkadot/api/types';
-import { AccountId, Address, Hash } from '@polkadot/types/interfaces';
-import { IKeyringPair } from '@polkadot/types/types';
-import { ContractABI } from './types';
-
-import BN from 'bn.js';
-import { Observable } from 'rxjs';
-import { map } from 'rxjs/operators';
-import { ApiRx, SubmittableResult } from '@polkadot/api';
-import { compactAddLength, u8aToU8a } from '@polkadot/util';
-
-import Abi from './Abi';
-import RxBase from './RxBase';
-import RxBlueprint from './RxBlueprint';
-
-// Ok, tried, failed, eventually ... well, we are only trying with RxJs as a
-// start, so take a big fat shortcut with this version, real intended version
-// follows this and is commented out
-type CodePutCodeResultSubscription = Observable<CodePutCodeResult>;
-// type ICodePutCodeResultSubscription<ApiType> =
-//   ApiType extends 'rxjs'
-//     ? Observable<CodePutCodeResult>
-//     : Promise<() => void>;
-
-// unlike the ISubmittableExtrinsic, it doesn't extend IExtrinsic and only
-// implements one var iant of signAndSend - this is purely done to see what
-// is hanging where, with the bare-mainimum from a simplicity perspective
-// Very obvious is that it supports only 1 version of signAndSend
-// (we need to revisit this, but probably ok for initial?)
-// eslint-disable-next-line @typescript-eslint/interface-name-prefix
-export interface CodePutCode {
-  signAndSend (account: IKeyringPair | string | AccountId | Address): CodePutCodeResultSubscription;
-}
-
-class CodePutCodeResult extends SubmittableResult {
-  public readonly blueprint?: RxBlueprint;
-
-  public constructor (result: SubmittableResultImpl, blueprint?: RxBlueprint) {
-    super(result);
-
-    this.blueprint = blueprint;
-  }
-}
-
-// NOTE Experimental, POC, bound to change
-export default class RxCode extends RxBase {
-  public readonly code: Uint8Array;
-
-  public constructor (api: ApiRx, abi: ContractABI | Abi, wasm: string | Uint8Array) {
-    super(api, abi);
-
-    this.code = u8aToU8a(wasm);
-  }
-
-  public createBlueprint (maxGas: number | BN): CodePutCode {
-    const signAndSend = (account: IKeyringPair | string | AccountId | Address): CodePutCodeResultSubscription => {
-      return this.apiContracts
-        .putCode(maxGas, compactAddLength(this.code))
-        .signAndSend(account)
-        .pipe(map(this.createResult));
-    };
-
-    return { signAndSend };
-  }
-
-  private createResult = (result: SubmittableResultImpl): CodePutCodeResult => {
-    let blueprint: RxBlueprint | undefined;
-
-    if (result.isFinalized) {
-      const record = result.findRecord('contract', 'CodeStored');
-
-      if (record) {
-        blueprint = new RxBlueprint(this.api, this.abi, record.event.data[0] as Hash);
-      }
-    }
-
-    return new CodePutCodeResult(result, blueprint);
-  }
-}

packages/api-contract/src/RxContract.ts

@@ -1,41 +0,0 @@
-// Copyright 2017-2019 @polkadot/api-contract 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, Address } from '@polkadot/types/interfaces';
-import { IKeyringPair } from '@polkadot/types/types';
-import { ContractABI, ContractABIFn, InterfaceContract, InterfaceContractCalls } from './types';
-
-import BN from 'bn.js';
-import { Observable } from 'rxjs';
-import { ApiRx, SubmittableResult } from '@polkadot/api';
-import { createType } from '@polkadot/types';
-import Abi from './Abi';
-import RxBase from './RxBase';
-
-export type ContractCallResultSubscription = Observable<SubmittableResult>;
-
-export interface ContractCall {
-  signAndSend (account: IKeyringPair | string | AccountId | Address): ContractCallResultSubscription;
-}
-
-type CallResult = (value: BN | number, maxGas: BN | number, ...params: any[]) => ContractCall;
-
-// NOTE Experimental, POC, bound to change
-export default class RxContract extends RxBase implements InterfaceContract {
-  public readonly address: Address;
-
-  public readonly calls: InterfaceContractCalls = {};
-
-  public constructor (api: ApiRx, abi: ContractABI | Abi, address: string | AccountId | Address) {
-    super(api, abi);
-
-    this.address = createType('Address', address);
-
-    Object.entries(abi.messages).forEach(([name]): void => {
-      this.calls[name] = (fn: ContractABIFn): CallResult =>
-        (value: BN | number, maxGas: BN | number, ...params: any[]): ContractCall =>
-          this.apiContracts.call(this.address, value, maxGas, fn(...params));
-    });
-  }
-}

packages/api-contract/src/base/Blueprint.ts

@@ -0,0 +1,75 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 { ApiTypes, DecorateMethod, SubmittableResultImpl } from '@polkadot/api/types';
+import { AccountId, Address, Hash } from '@polkadot/types/interfaces';
+import { IKeyringPair } from '@polkadot/types/types';
+import { ApiObject, ContractABIPre } from '../types';
+
+import BN from 'bn.js';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { SubmittableResult } from '@polkadot/api';
+import { createType } from '@polkadot/types';
+import { assert } from '@polkadot/util';
+
+import Abi from '../Abi';
+import Contract from './Contract';
+import { BaseWithTx } from './util';
+
+type BlueprintCreateResultSubscription<ApiType extends ApiTypes> = Observable<BlueprintCreateResult<ApiType>>;
+
+export interface BlueprintCreate<ApiType extends ApiTypes> {
+  signAndSend (account: IKeyringPair | string | AccountId | Address): BlueprintCreateResultSubscription<ApiType>;
+}
+
+class BlueprintCreateResult<ApiType extends ApiTypes> extends SubmittableResult {
+  public readonly contract?: Contract<ApiType>;
+
+  constructor (result: SubmittableResultImpl, contract?: Contract<ApiType>) {
+    super(result);
+
+    this.contract = contract;
+  }
+}
+
+// NOTE Experimental, POC, bound to change
+export default class Blueprint<ApiType extends ApiTypes> extends BaseWithTx<ApiType> {
+  public readonly codeHash: Hash;
+
+  constructor (api: ApiObject<ApiType>, abi: ContractABIPre | Abi, decorateMethod: DecorateMethod<ApiType>, codeHash: string | Hash) {
+    super(api, abi, decorateMethod);
+
+    this.codeHash = createType('Hash', codeHash);
+  }
+
+  public deployContract (constructorIndex = 0, endowment: number | BN, maxGas: number | BN, ...params: any[]): BlueprintCreate<ApiType> {
+    assert(!!this.abi.constructors[constructorIndex], `Specified constructor index ${constructorIndex} does not exist`);
+
+    return {
+      signAndSend: this.decorateMethod(
+        (account: IKeyringPair | string | AccountId | Address): BlueprintCreateResultSubscription<ApiType> => {
+          return this.apiContracts
+            .create(endowment, maxGas, this.codeHash, this.abi.constructors[constructorIndex](...params))
+            .signAndSend(account)
+            .pipe(map(this.createResult));
+        }
+      )
+    };
+  }
+
+  private createResult = (result: SubmittableResult): BlueprintCreateResult<ApiType> => {
+    let contract: Contract<ApiType> | undefined;
+
+    if (result.isFinalized) {
+      const record = result.findRecord('contract', 'Instantiated');
+
+      if (record) {
+        contract = new Contract<ApiType>(this.api, this.abi, this.decorateMethod, record.event.data[1] as Address);
+      }
+    }
+
+    return new BlueprintCreateResult(result, contract);
+  }
+}

packages/api-contract/src/base/Code.ts

@@ -0,0 +1,71 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 { ApiTypes, DecorateMethod, SubmittableResultImpl } from '@polkadot/api/types';
+import { AccountId, Address, Hash } from '@polkadot/types/interfaces';
+import { IKeyringPair } from '@polkadot/types/types';
+import { ApiObject, ContractABIPre } from '../types';
+
+import BN from 'bn.js';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { SubmittableResult } from '@polkadot/api';
+import { compactAddLength, u8aToU8a } from '@polkadot/util';
+
+import Abi from '../Abi';
+import Blueprint from './Blueprint';
+import { BaseWithTx } from './util';
+
+type CodePutCodeResultSubscription<ApiType extends ApiTypes> = Observable<CodePutCodeResult<ApiType>>;
+
+// eslint-disable-next-line @typescript-eslint/interface-name-prefix
+export interface CodePutCode<ApiType extends ApiTypes> {
+  signAndSend (account: IKeyringPair | string | AccountId | Address): CodePutCodeResultSubscription<ApiType>;
+}
+
+class CodePutCodeResult<ApiType extends ApiTypes> extends SubmittableResult {
+  public readonly blueprint?: Blueprint<ApiType>;
+
+  constructor (result: SubmittableResultImpl, blueprint?: Blueprint<ApiType>) {
+    super(result);
+
+    this.blueprint = blueprint;
+  }
+}
+
+// NOTE Experimental, POC, bound to change
+export default class Code<ApiType extends ApiTypes> extends BaseWithTx<ApiType> {
+  public readonly code: Uint8Array;
+
+  constructor (api: ApiObject<ApiType>, abi: ContractABIPre | Abi, decorateMethod: DecorateMethod<ApiType>, wasm: string | Uint8Array) {
+    super(api, abi, decorateMethod);
+
+    this.code = u8aToU8a(wasm);
+  }
+
+  public createBlueprint = (maxGas: number | BN): CodePutCode<ApiType> => {
+    return {
+      signAndSend: this.decorateMethod(
+        (account: IKeyringPair | string | AccountId | Address): CodePutCodeResultSubscription<ApiType> => this.apiContracts
+          .putCode(maxGas, compactAddLength(this.code))
+          .signAndSend(account)
+          .pipe(map(this.createResult))
+      )
+    };
+  }
+
+  private createResult = (result: SubmittableResultImpl): CodePutCodeResult<ApiType> => {
+    let blueprint: Blueprint<ApiType> | undefined;
+
+    if (result.isFinalized) {
+      const record = result.findRecord('contract', 'CodeStored');
+
+      if (record) {
+        blueprint = new Blueprint<ApiType>(this.api, this.abi, this.decorateMethod, record.event.data[0] as Hash);
+      }
+    }
+
+    return new CodePutCodeResult(result, blueprint);
+  }
+}

packages/api-contract/src/base/Contract.ts

@@ -0,0 +1,97 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 { ApiTypes, DecorateMethod, ObsInnerType } from '@polkadot/api/types';
+import { AccountId, Address, ContractExecResult } from '@polkadot/types/interfaces';
+import { Codec, IKeyringPair } from '@polkadot/types/types';
+import { ApiObject, ContractABIMessage, ContractABIPre, ContractCallOutcome } from '../types';
+
+import BN from 'bn.js';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { SubmittableResult } from '@polkadot/api';
+import { createType } from '@polkadot/types';
+import Abi from '../Abi';
+import { formatData } from '../util';
+import { BaseWithTxAndRpcCall } from './util';
+
+type ContractCallTypes = 'tx' | 'rpc';
+
+type ContractCallResultSubscription<ApiType extends ApiTypes, CallType extends ContractCallTypes> = ApiType extends 'rxjs'
+  ? Observable<ContractCallResult<CallType>>
+  : Promise<ObsInnerType<ContractCallResult<CallType>>>;
+
+// eslint-disable-next-line @typescript-eslint/interface-name-prefix
+export interface ContractCall<ApiType extends ApiTypes, CallType extends ContractCallTypes> {
+  send (account: IKeyringPair | string | AccountId | Address): ContractCallResultSubscription<ApiType, CallType>;
+}
+
+export type ContractCallResult<CallType extends ContractCallTypes> = CallType extends 'rpc'
+  ? Observable<ContractCallOutcome>
+  : Observable<SubmittableResult>;
+
+export default class Contract<ApiType extends ApiTypes> extends BaseWithTxAndRpcCall<ApiType> {
+  public readonly address: Address;
+
+  public call (as: 'rpc', message: string, value: BN | number, gasLimit: BN | number, ...params: any[]): ContractCall<ApiType, 'rpc'>;
+  public call (as: 'tx', message: string, value: BN | number, gasLimit: BN | number, ...params: any[]): ContractCall<ApiType, 'tx'>;
+  public call<CallType extends ContractCallTypes> (as: CallType, message: string, value: BN | number, gasLimit: BN | number, ...params: any[]): ContractCall<ApiType, CallType> {
+    const { fn, def } = this.getMessage(message);
+
+    return {
+      send: this.decorateMethod(
+        as === 'rpc'
+          ? (account: IKeyringPair | string | AccountId | Address): ContractCallResult<'rpc'> => {
+            return this.rpcContractsCall(
+              createType('ContractCallRequest', {
+                origin: account,
+                dest: this.address.toString(),
+                value,
+                gasLimit,
+                inputData: fn(...params)
+              })
+            )
+              .pipe(
+                map((result: ContractExecResult): ContractCallOutcome =>
+                  this.createOutcome(result, createType('AccountId', account), def, params)
+                )
+              );
+          }
+          : (account: IKeyringPair | string | AccountId | Address): ContractCallResult<'tx'> => {
+            return this.apiContracts
+              .call(this.address, value, gasLimit, fn(...params))
+              .signAndSend(account);
+          }
+      )
+    };
+  }
+
+  private createOutcome (result: ContractExecResult, origin: AccountId, message: ContractABIMessage, params: any[]): ContractCallOutcome {
+    let output: Codec | null = null;
+
+    if (result.isSuccess) {
+      const { data } = result.asSuccess;
+
+      output = message.returnType
+        ? formatData(data, message.returnType)
+        : createType('Data', data);
+    }
+
+    return {
+      time: Date.now(),
+      message,
+      origin,
+      params,
+      result,
+      isSuccess: result.isSuccess,
+      output
+    };
+  }
+
+  constructor (api: ApiObject<ApiType>, abi: ContractABIPre | Abi, decorateMethod: DecorateMethod<ApiType>, address: string | AccountId | Address) {
+    super(api, abi, decorateMethod);
+
+    this.address = createType('Address', address);
+  }
+}

packages/api-contract/src/base/index.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2019 @polkadot/api 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 { default as Blueprint } from './Blueprint';
+export { default as Code } from './Code';
+export { default as Contract } from './Contract';

packages/api-contract/src/base/util.ts

@@ -0,0 +1,74 @@
+// Copyright 2017-2019 @polkadot/api 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 { ApiTypes, DecorateMethod, DecoratedRpc, SubmittableModuleExtrinsics } from '@polkadot/api/types';
+import { ApiObject, ContractABIMessage, ContractABIPre, ContractBase, ContractMessage } from '../types';
+import { RpcInterface } from '@polkadot/rpc-core/jsonrpc.types';
+
+import { assert, stringCamelCase } from '@polkadot/util';
+import Abi from '../Abi';
+
+export abstract class Base<ApiType extends ApiTypes> implements ContractBase<ApiType> {
+  public readonly abi: Abi;
+
+  public readonly api: ApiObject<ApiType>;
+
+  public readonly decorateMethod: DecorateMethod<ApiType>;
+
+  constructor (api: ApiObject<ApiType>, abi: ContractABIPre | Abi, decorateMethod: DecorateMethod<ApiType>) {
+    this.abi = abi instanceof Abi
+      ? abi
+      : new Abi(abi);
+    this.api = api;
+    this.decorateMethod = decorateMethod;
+  }
+
+  public get messages (): ContractMessage[] {
+    return this.abi.abi.contract.messages
+      .map(
+        (def: ContractABIMessage, index): ContractMessage => ({
+          index,
+          def,
+          fn: this.abi.messages[def.name] || this.abi.messages[stringCamelCase(name)]
+        })
+      );
+  }
+
+  public getMessage (nameOrIndex?: string | number): ContractMessage {
+    const index = nameOrIndex
+      ? typeof nameOrIndex === 'number'
+        ? nameOrIndex
+        : this.abi.abi.contract.messages.findIndex((message): boolean => nameOrIndex === message.name || nameOrIndex === stringCamelCase(message.name))
+      : 0;
+    const def = this.abi.abi.contract.messages[index];
+    assert(!!def, `Attempted to access a contract message that does not exist: ${typeof nameOrIndex === 'number' ? `index ${nameOrIndex}` : nameOrIndex}`);
+
+    const fn = this.abi.messages[def.name] || this.abi.messages[stringCamelCase(def.name)];
+    return { index, def, fn };
+  }
+}
+
+export abstract class BaseWithTx<ApiType extends ApiTypes> extends Base<ApiType> {
+  protected get apiContracts (): SubmittableModuleExtrinsics<'rxjs'> {
+    return this.api.rx.tx.contracts;
+  }
+
+  constructor (api: ApiObject<ApiType>, abi: ContractABIPre | Abi, decorateMethod: DecorateMethod<ApiType>) {
+    super(api, abi, decorateMethod);
+
+    assert(this.api.rx.tx.contracts && this.api.rx.tx.contracts.putCode, 'You need to connect to a node with the contracts module, the metadata does not enable api.tx.contracts on this instance');
+  }
+}
+
+export abstract class BaseWithTxAndRpcCall<ApiType extends ApiTypes> extends BaseWithTx<ApiType> {
+  protected get rpcContractsCall (): DecoratedRpc<'rxjs', RpcInterface>['contracts']['call'] {
+    return this.api.rx.rpc.contracts.call;
+  }
+
+  constructor (api: ApiObject<ApiType>, abi: ContractABIPre | Abi, decorateMethod: DecorateMethod<ApiType>) {
+    super(api, abi, decorateMethod);
+
+    assert(this.api.rx.rpc.contracts && this.api.rx.tx.contracts.call, 'You need to connect to a node with the contracts module, the metadata does not enable api.rpc.contracts.call on this instance');
+  }
+}

packages/api-contract/src/index.ts

@@ -3,6 +3,5 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 export { default as Abi } from './Abi';
-export { default as RxBlueprint } from './RxBlueprint';
-export { default as RxCode } from './RxCode';
-export { default as RxContract } from './RxContract';
+export * from './rx';
+export * from './promise';

packages/api-contract/src/method.ts

@@ -1,69 +0,0 @@
-// Copyright 2017-2019 @polkadot/api-contract 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 { CodecArg, Constructor } from '@polkadot/types/types';
-import { ContractABIFn, ContractABIFnArg, ContractABIMethod, ContractABIMethodBase, ContractABITypes } from './types';
-
-import { Compact, createClass } from '@polkadot/types';
-import { assert, isString, isUndefined, stringCamelCase } from '@polkadot/util';
-
-export function typeToString (type: ContractABITypes): string {
-  if (isString(type)) {
-    return type;
-  } else if (Array.isArray(type)) {
-    return `(${type.map((type): string => typeToString(type)).join(',')})`;
-  } else if (type['Option<T>']) {
-    return `Option<${typeToString(type['Option<T>'].T)}>`;
-  } else if (type['Result<T,E>']) {
-    return '()'; // Result is not supported, but only applicable for returns
-  } else if (type['Vec<T>']) {
-    return `Vec<${typeToString(type['Vec<T>'].T)}>`;
-  } else if (type['[T;n]']) {
-    return `[${typeToString(type['[T;n]'].T)};${type['[T;n]'].n}]`;
-  }
-
-  throw new Error(`Unknown type specified ${JSON.stringify(type)}`);
-}
-
-export function createArgClass (args: ContractABIFnArg[], baseDef: Record<string, string>): Constructor {
-  return createClass(
-    JSON.stringify(
-      args.reduce((base: Record<string, any>, { name, type }): Record<string, any> => {
-        base[name] = type;
-
-        return base;
-      }, baseDef)
-    )
-  );
-}
-
-export function createMethod (name: string, method: Partial<ContractABIMethod> & ContractABIMethodBase): ContractABIFn {
-  const args: ContractABIFnArg[] = method.args.map(({ name, type }): ContractABIFnArg => ({
-    name: stringCamelCase(name),
-    type: typeToString(type)
-  }));
-  const Clazz = createArgClass(args, isUndefined(method.selector) ? {} : { __selector: 'u32' });
-  const baseStruct: { [index: string]: any } = { __selector: method.selector };
-  const encoder = (...params: CodecArg[]): Uint8Array => {
-    assert(params.length === args.length, `Expected ${args.length} arguments to contract ${name}, found ${params.length}`);
-
-    const u8a = new Clazz(
-      args.reduce((mapped, { name }, index): Record<string, CodecArg> => {
-        mapped[name] = params[index];
-
-        return mapped;
-      }, { ...baseStruct })
-    ).toU8a();
-
-    return Compact.addLengthPrefix(u8a);
-  };
-
-  const fn = (encoder as ContractABIFn);
-
-  fn.args = args;
-  fn.isConstant = !(method.mutates || false);
-  fn.type = method.return_type ? typeToString(method.return_type) : null;
-
-  return fn;
-}

packages/api-contract/src/promise/PromiseBlueprint.ts

@@ -0,0 +1,18 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 } from '@polkadot/types/interfaces';
+import { ContractABIPre } from '../types';
+
+import { ApiPromise } from '@polkadot/api';
+import { decorateMethod } from '@polkadot/api/promise';
+
+import Abi from '../Abi';
+import Blueprint from '../base/Blueprint';
+
+export default class PromiseBlueprint extends Blueprint<'promise'> {
+  constructor (api: ApiPromise, abi: ContractABIPre | Abi, codeHash: string | Hash) {
+    super(api, abi, decorateMethod, codeHash);
+  }
+}

packages/api-contract/src/promise/PromiseCode.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 { ContractABIPre } from '../types';
+
+import { ApiPromise } from '@polkadot/api';
+import { decorateMethod } from '@polkadot/api/promise';
+
+import Abi from '../Abi';
+import Code from '../base/Code';
+
+export default class PromiseCode extends Code<'promise'> {
+  constructor (api: ApiPromise, abi: ContractABIPre | Abi, wasm: string | Uint8Array) {
+    super(api, abi, decorateMethod, wasm);
+  }
+}

packages/api-contract/src/promise/PromiseContract.ts

@@ -0,0 +1,18 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 { ContractABIPre } from '../types';
+
+import { ApiPromise } from '@polkadot/api';
+import { decorateMethod } from '@polkadot/api/promise';
+
+import Abi from '../Abi';
+import Contract from '../base/Contract';
+
+export default class PromiseContract extends Contract<'promise'> {
+  constructor (api: ApiPromise, abi: ContractABIPre | Abi, address: string | AccountId) {
+    super(api, abi, decorateMethod, address);
+  }
+}

packages/api-contract/src/promise/index.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 { default as PromiseBlueprint } from './PromiseBlueprint';
+export { default as PromiseCode } from './PromiseCode';
+export { default as PromiseContract } from './PromiseContract';

packages/api-contract/src/rx/RxBlueprint.ts

@@ -0,0 +1,18 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 } from '@polkadot/types/interfaces';
+import { ContractABIPre } from '../types';
+
+import { ApiRx } from '@polkadot/api';
+import { decorateMethod } from '@polkadot/api/rx';
+
+import Abi from '../Abi';
+import Blueprint from '../base/Blueprint';
+
+export default class RxBlueprint extends Blueprint<'rxjs'> {
+  constructor (api: ApiRx, abi: ContractABIPre | Abi, codeHash: string | Hash) {
+    super(api, abi, decorateMethod, codeHash);
+  }
+}

packages/api-contract/src/rx/RxCode.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 { ContractABIPre } from '../types';
+
+import { ApiRx } from '@polkadot/api';
+import { decorateMethod } from '@polkadot/api/rx';
+
+import Abi from '../Abi';
+import Code from '../base/Code';
+
+export default class RxCode extends Code<'rxjs'> {
+  constructor (api: ApiRx, abi: ContractABIPre | Abi, wasm: string | Uint8Array) {
+    super(api, abi, decorateMethod, wasm);
+  }
+}

packages/api-contract/src/rx/RxContract.ts

@@ -0,0 +1,18 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 { ContractABIPre } from '../types';
+
+import { ApiRx } from '@polkadot/api';
+import { decorateMethod } from '@polkadot/api/rx';
+
+import Abi from '../Abi';
+import Contract from '../base/Contract';
+
+export default class RxContract extends Contract<'rxjs'> {
+  constructor (api: ApiRx, abi: ContractABIPre | Abi, address: string | AccountId) {
+    super(api, abi, decorateMethod, address);
+  }
+}

packages/api-contract/src/rx/index.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2019 @polkadot/api-contract 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 { default as RxBlueprint } from './RxBlueprint';
+export { default as RxCode } from './RxCode';
+export { default as RxContract } from './RxContract';

packages/api-contract/src/types.ts

@@ -2,86 +2,191 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { SubmittableModuleExtrinsics } from '@polkadot/api/types';
-import { Address } from '@polkadot/types/interfaces';
-import { CodecArg } from '@polkadot/types/types';
+import { ApiTypes, DecorateMethod } from '@polkadot/api/types';
+import { AccountId, Address, ContractExecResult } from '@polkadot/types/interfaces';
+import { Codec, CodecArg } from '@polkadot/types/types';
+import { MetaRegistryJson, StringIndex, TypeIndex, TypeDef } from '@polkadot/types/codec/create/types';
 
+// import { Observable } from 'rxjs';
 import { ApiPromise, ApiRx } from '@polkadot/api';
 
-export type ApiObject<ApiType> = ApiType extends 'rxjs'
+export type ApiObject<ApiType extends ApiTypes> = ApiType extends 'rxjs'
   ? ApiRx
   : ApiPromise;
 
-export interface ContractABITypesStruct {
-  'Option<T>'?: {
-    T: ContractABITypes;
-  };
-  'Result<T,E>'?: {
-    T: ContractABITypes;
-    E: ContractABITypes;
-  };
-  'Vec<T>'?: {
-    T: ContractABITypes;
-  };
-  '[T;n]'?: {
-    T: ContractABITypes;
-    n: number;
-  };
+export interface ContractBase<ApiType extends ApiTypes> {
+  readonly abi: InterfaceAbi;
+  readonly api: ApiObject<ApiType>;
+  readonly decorateMethod: DecorateMethod<ApiType>;
+  getMessage: (name: string) => ContractMessage;
+  messages: ContractMessage[];
 }
 
-export type ContractABITypes = string | ContractABITypesStruct | (string | ContractABITypesStruct)[];
+export interface ContractABITypePre {
+  ty: TypeIndex;
+  display_name: StringIndex[];
+}
 
-export interface ContractABIArg {
+export interface ContractABIArgBasePre {
+  name: StringIndex;
+  type: ContractABITypePre;
+}
+
+export interface ContractABIArgBase {
   name: string;
-  type: ContractABITypes;
+  type: TypeDef;
 }
 
-export interface ContractABIMethodBase {
-  args: ContractABIArg[];
+export type ContractABIMessageArgPre = ContractABIArgBasePre;
+
+export type ContractABIMessageArg = ContractABIArgBase;
+
+export interface ContractABIMessageBase {
+  args: ContractABIMessageArg[];
 }
 
-export interface ContractABIMethod extends ContractABIMethodBase {
+export interface ContractABIMessageBasePre {
+  args: ContractABIMessageArgPre[];
+}
+
+export interface ContractABIMessageCommon {
+  docs?: ContractABIDocs;
   mutates?: boolean;
+  selector: string | number;
+}
+
+export interface ContractABIMessagePre extends ContractABIMessageCommon, ContractABIMessageBasePre {
+  name: StringIndex;
+  return_type: ContractABITypePre | null;
+}
+
+export interface ContractABIMessage extends ContractABIMessageCommon {
+  args: ContractABIMessageArg[];
   name: string;
-  selector: number;
-  return_type: ContractABITypes | null;
+  returnType: TypeDef | null;
+}
+
+export interface ContractABIContractCommon {
+  docs?: ContractABIDocs;
+}
+
+export interface ContractABIContractPre extends ContractABIContractCommon {
+  constructors: ContractABIMessagePre[];
+  messages: ContractABIMessagePre[];
+  name: StringIndex;
+  events?: ContractABIEventPre[];
+  docs?: ContractABIDocs;
+}
+
+export interface ContractABIContract extends ContractABIContractCommon {
+  constructors: ContractABIMessage[];
+  messages: ContractABIMessage[];
+  name: string;
+  events?: ContractABIEvent[];
+  docs?: ContractABIDocs;
+}
+
+export interface ContractABIPre extends MetaRegistryJson {
+  storage: ContractABIStoragePre;
+  contract: ContractABIContractPre;
 }
 
 export interface ContractABI {
-  deploy: ContractABIMethodBase;
-  messages: ContractABIMethod[];
-  name: string;
+  storage: ContractABIStorage;
+  contract: ContractABIContract;
 }
 
 export interface ContractABIFnArg {
   name: string;
-  type: string;
+  type: TypeDef;
 }
 
 export interface ContractABIMeta {
   args: ContractABIFnArg[];
   isConstant: boolean;
-  type: string | null;
+  type: TypeDef | null;
 }
 
 export interface ContractABIFn extends ContractABIMeta {
   (...args: CodecArg[]): Uint8Array;
 }
 
+export interface ContractABIEventArgBase {
+  indexed: boolean;
+}
+
+export interface ContractABIEventArgPre extends ContractABIArgBasePre, ContractABIEventArgBase {}
+
+export interface ContractABIEventArg extends ContractABIArgBase, ContractABIEventArgBase {}
+
+export type ContractABIDocs = string[];
+
+export interface ContractABIEventPre {
+  args: ContractABIEventArgPre[];
+}
+
+export interface ContractABIEvent {
+  args: ContractABIEventArg[];
+}
+
+export interface ContractABIRangeBase {
+  // can be number[] (old) or hex (new)
+  'range.offset': number[] | string;
+  'range.len': number;
+}
+
+export interface ContractABIRangePre extends ContractABIRangeBase {
+  'range.elem_type': TypeIndex;
+}
+
+export interface ContractABIRange extends ContractABIRangeBase {
+  'range.elem_type': TypeDef;
+}
+
+export type ContractABIStorageLayoutPre = ContractABIStorageStructPre | ContractABIRangePre;
+
+export type ContractABIStorageLayout = ContractABIStorageStruct | ContractABIRange;
+
+export interface ContractABIStorageStructFieldPre {
+  name: StringIndex;
+  layout: ContractABIStorageLayoutPre;
+}
+
+export interface ContractABIStorageStructField {
+  name: string;
+  layout: ContractABIStorageLayout;
+}
+
+export interface ContractABIStorageStructPre {
+  'struct.type': TypeIndex;
+  'struct.fields': ContractABIStorageStructFieldPre[];
+}
+
+export interface ContractABIStorageStruct {
+  'struct.type': TypeDef;
+  'struct.fields': ContractABIStorageStructField[];
+}
+
+export type ContractABIStoragePre = ContractABIStorageStructPre;
+
+export type ContractABIStorage = ContractABIStorageStruct;
+
+export interface ContractMessage {
+  index: number;
+  fn: ContractABIFn;
+  def: ContractABIMessage;
+}
+
+export type AbiConstructors = ContractABIFn[];
+
 export type AbiMessages = Record<string, ContractABIFn>;
 
 export interface InterfaceAbi {
   readonly abi: ContractABI;
-  readonly deploy: ContractABIFn;
+  readonly constructors: AbiConstructors;
   readonly messages: AbiMessages;
 }
 
-export interface ContractBase<ApiType> {
-  readonly abi: InterfaceAbi;
-  readonly api: ApiObject<ApiType>;
-  readonly apiContracts: SubmittableModuleExtrinsics<ApiType>;
-}
-
 export interface InterfaceContractCalls {
   [index: string]: Function;
 }
@@ -90,3 +195,13 @@ export interface InterfaceContract {
   readonly address: Address;
   readonly calls: InterfaceContractCalls;
 }
+
+export interface ContractCallOutcome {
+  time: number;
+  result: ContractExecResult;
+  origin: AccountId;
+  output: Codec | null;
+  params: any[];
+  isSuccess: boolean;
+  message: ContractABIMessage;
+}

packages/api-contract/src/util.ts

@@ -0,0 +1,21 @@
+// Copyright 2017-2019 @polkadot/rpc-core 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 { Codec, TypeDefInfo, TypeDef } from '@polkadot/types/types';
+
+import { Data, Option, createClass } from '@polkadot/types';
+import { createTypeUnsafe } from '@polkadot/types/codec';
+
+export function formatData (data: Data, { info, type }: TypeDef): Codec {
+  const u8a = data.toU8a();
+
+  if (info === TypeDefInfo.Option) {
+    return new Option(
+      createClass(type),
+      createTypeUnsafe(type, [u8a], true)
+    );
+  }
+
+  return createTypeUnsafe(type, [u8a], true);
+}

packages/api-contract/src/validation.ts

@@ -1,50 +0,0 @@
-// Copyright 2017-2019 @polkadot/api-contract 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 { ContractABI, ContractABIArg } from './types';
-
-import { assert, isNumber, isNull, isString, isObject } from '@polkadot/util';
-
-export function validateArgs (name: string, args: ContractABIArg[]): void {
-  assert(Array.isArray(args), `Expected 'args' to exist on ${name}`);
-
-  args.forEach((arg): void => {
-    const unknownKeys = Object.keys(arg).filter((key): boolean => !['name', 'type'].includes(key));
-
-    assert(unknownKeys.length === 0, `Unknown keys ${unknownKeys.join(', ')} found in ABI args for ${name}`);
-    assert(isString(arg.name), `${name} args should have valid name `);
-    assert(isString(arg.type) || isObject(arg.type), `${name} args should have valid type`);
-  });
-}
-
-export function validateDeploy ({ deploy }: ContractABI): void {
-  const unknownKeys = Object.keys(deploy).filter((key): boolean => !['args'].includes(key));
-
-  assert(unknownKeys.length === 0, `Unknown keys ${unknownKeys.join(', ')} found in ABI deploy`);
-
-  validateArgs('deploy', deploy.args);
-}
-
-export function validateMethods ({ messages }: ContractABI): void {
-  messages.forEach((method): void => {
-    const unknownKeys = Object.keys(method).filter((key): boolean => !['args', 'mutates', 'name', 'selector', 'return_type'].includes(key));
-
-    assert(unknownKeys.length === 0, `Unknown keys ${unknownKeys.join(', ')} found in ABI args for messages.${method.name}`);
-    assert(isString(method.name), `Expected name for messages.${method.name}`);
-    assert(isNumber(method.selector), `Expected selector for messages.${method.name}`);
-    assert(isNull(method.return_type) || isString(method.return_type) || isObject(method.return_type), `Expected return_type for messages.${method.name}`);
-
-    validateArgs(`messages.${method.name}`, method.args);
-  });
-}
-
-export function validateAbi (abi: ContractABI): void {
-  const unknownKeys = Object.keys(abi).filter((key): boolean => !['deploy', 'messages', 'name'].includes(key));
-
-  assert(unknownKeys.length === 0, `Unknown fields ${unknownKeys.join(', ')} found in ABI`);
-  assert(abi.deploy && abi.messages && isString(abi.name), 'ABI should have deploy, messages & name sections');
-
-  validateDeploy(abi);
-  validateMethods(abi);
-}

packages/api-contract/test/compare/flipper.test.json

@@ -0,0 +1,184 @@
+[
+  {
+    "info": 7,
+    "type": "{\"value\": {\"cell\": {\"cell\": ([u8;32])}}}",
+    "name": "Flipper",
+    "namespace": "flipper::normal",
+    "sub": [
+      {
+        "info": 7,
+        "type": "{\"cell\": {\"cell\": ([u8;32])}}",
+        "name": "value",
+        "namespace": "ink_core::storage::value",
+        "params": [
+          {
+            "info": 5,
+            "type": "bool"
+          }
+        ],
+        "sub": [
+          {
+            "info": 7,
+            "type": "{\"cell\": ([u8;32])}",
+            "name": "cell",
+            "namespace": "ink_core::storage::cell::sync_cell",
+            "params": [
+              {
+                "info": 5,
+                "type": "bool"
+              }
+            ],
+            "sub": [
+              {
+                "info": 8,
+                "type": "([u8;32])",
+                "name": "cell",
+                "namespace": "ink_core::storage::key",
+                "sub": [
+                  {
+                    "info": 10,
+                    "type": "[u8;32]",
+                    "ext": {
+                      "length": 32,
+                      "type": ""
+                    },
+                    "sub": {
+                      "info": 5,
+                      "type": "u8"
+                    },
+                    "index": 0
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "info": 7,
+    "type": "{\"cell\": {\"cell\": ([u8;32])}}",
+    "name": "Value",
+    "namespace": "ink_core::storage::value",
+    "params": [
+      {
+        "info": 5,
+        "type": "bool"
+      }
+    ],
+    "sub": [
+      {
+        "info": 7,
+        "type": "{\"cell\": ([u8;32])}",
+        "name": "cell",
+        "namespace": "ink_core::storage::cell::sync_cell",
+        "params": [
+          {
+            "info": 5,
+            "type": "bool"
+          }
+        ],
+        "sub": [
+          {
+            "info": 8,
+            "type": "([u8;32])",
+            "name": "cell",
+            "namespace": "ink_core::storage::key",
+            "sub": [
+              {
+                "info": 10,
+                "type": "[u8;32]",
+                "ext": {
+                  "length": 32,
+                  "type": ""
+                },
+                "sub": {
+                  "info": 5,
+                  "type": "u8"
+                },
+                "index": 0
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "info": 5,
+    "type": "bool"
+  },
+  {
+    "info": 7,
+    "type": "{\"cell\": ([u8;32])}",
+    "name": "SyncCell",
+    "namespace": "ink_core::storage::cell::sync_cell",
+    "params": [
+      {
+        "info": 5,
+        "type": "bool"
+      }
+    ],
+    "sub": [
+      {
+        "info": 8,
+        "type": "([u8;32])",
+        "name": "cell",
+        "namespace": "ink_core::storage::key",
+        "sub": [
+          {
+            "info": 10,
+            "type": "[u8;32]",
+            "ext": {
+              "length": 32,
+              "type": ""
+            },
+            "sub": {
+              "info": 5,
+              "type": "u8"
+            },
+            "index": 0
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "info": 8,
+    "type": "([u8;32])",
+    "name": "Key",
+    "namespace": "ink_core::storage::key",
+    "sub": [
+      {
+        "info": 10,
+        "type": "[u8;32]",
+        "ext": {
+          "length": 32,
+          "type": ""
+        },
+        "sub": {
+          "info": 5,
+          "type": "u8"
+        },
+        "index": 0
+      }
+    ]
+  },
+  {
+    "info": 10,
+    "type": "[u8;32]",
+    "ext": {
+      "length": 32,
+      "type": ""
+    },
+    "sub": {
+      "info": 5,
+      "type": "u8"
+    }
+  },
+  {
+    "info": 5,
+    "type": "u8"
+  }
+]

packages/api-contract/test/compare/incrementer.test.json

@@ -0,0 +1,188 @@
+[
+  {
+    "info": 9,
+    "type": "{ \"value\": \"{ \"cell\": \"{ \"cell\": \"([u8;32])\"} }<u32>\"} }<u32>\"} }",
+    "sub": [
+      {
+        "info": 9,
+        "type": "{ \"cell\": \"{ \"cell\": \"([u8;32])\"} }<u32>\"} }",
+        "sub": [
+          {
+            "info": 9,
+            "type": "{ \"cell\": \"([u8;32])\"} }",
+            "sub": [
+              {
+                "info": 10,
+                "type": "([u8;32])",
+                "sub": [
+                  {
+                    "info": 12,
+                    "type": "[u8;32]",
+                    "ext": {
+                      "length": 32,
+                      "type": "u8"
+                    },
+                    "sub": {
+                      "info": 6,
+                      "type": "u8"
+                    },
+                    "index": 0
+                  }
+                ],
+                "name": "cell",
+                "namespace": "ink_core::storage::key"
+              }
+            ],
+            "name": "cell",
+            "namespace": "ink_core::storage::cell::sync_cell",
+            "params": [
+              {
+                "info": 6,
+                "type": "u32"
+              }
+            ]
+          }
+        ],
+        "name": "value",
+        "namespace": "ink_core::storage::value",
+        "params": [
+          {
+            "info": 6,
+            "type": "u32"
+          }
+        ]
+      }
+    ],
+    "name": "Incrementer",
+    "namespace": "incrementer::normal"
+  },
+  {
+    "info": 9,
+    "type": "{ \"cell\": \"{ \"cell\": \"([u8;32])\"} }<u32>\"} }",
+    "sub": [
+      {
+        "info": 9,
+        "type": "{ \"cell\": \"([u8;32])\"} }",
+        "sub": [
+          {
+            "info": 10,
+            "type": "([u8;32])",
+            "sub": [
+              {
+                "info": 12,
+                "type": "[u8;32]",
+                "ext": {
+                  "length": 32,
+                  "type": "u8"
+                },
+                "sub": {
+                  "info": 6,
+                  "type": "u8"
+                },
+                "index": 0
+              }
+            ],
+            "name": "cell",
+            "namespace": "ink_core::storage::key"
+          }
+        ],
+        "name": "cell",
+        "namespace": "ink_core::storage::cell::sync_cell",
+        "params": [
+          {
+            "info": 6,
+            "type": "u32"
+          }
+        ]
+      }
+    ],
+    "name": "Value",
+    "namespace": "ink_core::storage::value",
+    "params": [
+      {
+        "info": 6,
+        "type": "u32"
+      }
+    ]
+  },
+  {
+    "info": 6,
+    "type": "u32"
+  },
+  {
+    "info": 9,
+    "type": "{ \"cell\": \"([u8;32])\"} }",
+    "sub": [
+      {
+        "info": 10,
+        "type": "([u8;32])",
+        "sub": [
+          {
+            "info": 12,
+            "type": "[u8;32]",
+            "ext": {
+              "length": 32,
+              "type": "u8"
+            },
+            "sub": {
+              "info": 6,
+              "type": "u8"
+            },
+            "index": 0
+          }
+        ],
+        "name": "cell",
+        "namespace": "ink_core::storage::key"
+      }
+    ],
+    "name": "SyncCell",
+    "namespace": "ink_core::storage::cell::sync_cell",
+    "params": [
+      {
+        "info": 6,
+        "type": "u32"
+      }
+    ]
+  },
+  {
+    "info": 10,
+    "type": "([u8;32])",
+    "sub": [
+      {
+        "info": 12,
+        "type": "[u8;32]",
+        "ext": {
+          "length": 32,
+          "type": "u8"
+        },
+        "sub": {
+          "info": 6,
+          "type": "u8"
+        },
+        "index": 0
+      }
+    ],
+    "name": "Key",
+    "namespace": "ink_core::storage::key"
+  },
+  {
+    "info": 12,
+    "type": "[u8;32]",
+    "ext": {
+      "length": 32,
+      "type": "u8"
+    },
+    "sub": {
+      "info": 6,
+      "type": "u8"
+    }
+  },
+  {
+    "info": 6,
+    "type": "u8"
+  },
+  {
+    "info": 6,
+    "type": "bool"
+  }
+]

packages/api-contract/test/contracts/FlipperV2.json

@@ -0,0 +1,201 @@
+{
+  "registry": {
+    "strings": [
+      "Flipper",
+      "flipper",
+      "normal",
+      "value",
+      "Value",
+      "ink_core",
+      "storage",
+      "cell",
+      "SyncCell",
+      "sync_cell",
+      "Key",
+      "key",
+      "flip",
+      "get"
+    ],
+    "types": [
+      {
+        "id": {
+          "custom.name": 1,
+          "custom.namespace": [
+            2,
+            3
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 4,
+              "type": 2
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 5,
+          "custom.namespace": [
+            6,
+            7,
+            4
+          ],
+          "custom.params": [
+            3
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 8,
+              "type": 4
+            }
+          ]
+        }
+      },
+      {
+        "id": "bool",
+        "def": "builtin"
+      },
+      {
+        "id": {
+          "custom.name": 9,
+          "custom.namespace": [
+            6,
+            7,
+            8,
+            10
+          ],
+          "custom.params": [
+            3
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 8,
+              "type": 5
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 11,
+          "custom.namespace": [
+            6,
+            7,
+            12
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "tuple_struct.types": [
+            6
+          ]
+        }
+      },
+      {
+        "id": {
+          "array.len": 32,
+          "array.type": 7
+        },
+        "def": "builtin"
+      },
+      {
+        "id": "u8",
+        "def": "builtin"
+      }
+    ]
+  },
+  "storage": {
+    "struct.type": 1,
+    "struct.fields": [
+      {
+        "name": 4,
+        "layout": {
+          "struct.type": 2,
+          "struct.fields": [
+            {
+              "name": 8,
+              "layout": {
+                "range.offset": [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+                ],
+                "range.len": 1,
+                "range.elem_type": 3
+              }
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "contract": {
+    "name": 1,
+    "deploy": {
+      "args": [],
+      "docs": [
+        "Initializes our state to `false` upon deploying our smart contract."
+      ]
+    },
+    "messages": [
+      {
+        "name": 13,
+        "selector": 970692492,
+        "mutates": true,
+        "args": [],
+        "return_type": null,
+        "docs": [
+          "Flips the current state of our smart contract."
+        ]
+      },
+      {
+        "name": 14,
+        "selector": 4266279973,
+        "mutates": false,
+        "args": [],
+        "return_type": 3,
+        "docs": [
+          "Returns the current state."
+        ]
+      }
+    ],
+    "events": [],
+    "docs": []
+  }
+}

packages/api-contract/test/contracts/Incrementer.json

@@ -1 +0,0 @@
-{"name":"Incrementer","deploy":{"args":[{"name":"init_value","type":"u32"}]},"messages":[{"name":"inc","selector":257544423,"mutates":true,"args":[{"name":"by","type":"u32"}],"return_type":null},{"name":"get","selector":4266279973,"mutates":false,"args":[],"return_type":"u32"},{"name":"compare","selector":363906316,"mutates":false,"args":[{"name":"with","type":"u32"}],"return_type":"bool"}]}

packages/api-contract/test/contracts/SharedVecV2.json

@@ -0,0 +1,935 @@
+{
+  "registry": {
+    "strings": [
+      "SharedVec",
+      "shared_vec",
+      "normal",
+      "mutators",
+      "HashMap",
+      "ink_core",
+      "storage",
+      "collections",
+      "hash_map",
+      "impls",
+      "AccountId",
+      "env",
+      "srml",
+      "types",
+      "Access",
+      "begin",
+      "Option",
+      "None",
+      "Some",
+      "end",
+      "len",
+      "Value",
+      "value",
+      "cell",
+      "SyncCell",
+      "sync_cell",
+      "Key",
+      "key",
+      "entries",
+      "SyncChunk",
+      "chunk",
+      "sync_chunk",
+      "Entry",
+      "Occupied",
+      "OccupiedEntry",
+      "val",
+      "Removed",
+      "cells_key",
+      "vec",
+      "Vec",
+      "cells",
+      "on_deploy",
+      "push",
+      "i32",
+      "Result",
+      "Ok",
+      "Err",
+      "register",
+      "mutator",
+      "set",
+      "at",
+      "u32",
+      "to",
+      "get",
+      "Mutate",
+      "Push",
+      "Register"
+    ],
+    "types": [
+      {
+        "id": {
+          "custom.name": 1,
+          "custom.namespace": [
+            2,
+            3
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 4,
+              "type": 2
+            },
+            {
+              "name": 39,
+              "type": 15
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 5,
+          "custom.namespace": [
+            6,
+            7,
+            8,
+            9,
+            10
+          ],
+          "custom.params": [
+            3,
+            6
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 21,
+              "type": 9
+            },
+            {
+              "name": 29,
+              "type": 12
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 11,
+          "custom.namespace": [
+            6,
+            12,
+            13,
+            14
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "tuple_struct.types": [
+            4
+          ]
+        }
+      },
+      {
+        "id": {
+          "array.len": 32,
+          "array.type": 5
+        },
+        "def": "builtin"
+      },
+      {
+        "id": "u8",
+        "def": "builtin"
+      },
+      {
+        "id": {
+          "custom.name": 15,
+          "custom.namespace": [
+            2
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 16,
+              "type": 7
+            },
+            {
+              "name": 20,
+              "type": 7
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 17,
+          "custom.namespace": [],
+          "custom.params": [
+            8
+          ]
+        },
+        "def": {
+          "enum.variants": [
+            {
+              "unit_variant.name": 18
+            },
+            {
+              "tuple_struct_variant.name": 19,
+              "tuple_struct_variant.types": [
+                8
+              ]
+            }
+          ]
+        }
+      },
+      {
+        "id": "u32",
+        "def": "builtin"
+      },
+      {
+        "id": {
+          "custom.name": 22,
+          "custom.namespace": [
+            6,
+            7,
+            23
+          ],
+          "custom.params": [
+            8
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 24,
+              "type": 10
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 25,
+          "custom.namespace": [
+            6,
+            7,
+            24,
+            26
+          ],
+          "custom.params": [
+            8
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 24,
+              "type": 11
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 27,
+          "custom.namespace": [
+            6,
+            7,
+            28
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "tuple_struct.types": [
+            4
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 30,
+          "custom.namespace": [
+            6,
+            7,
+            31,
+            32,
+            31
+          ],
+          "custom.params": [
+            13
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 38,
+              "type": 11
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 33,
+          "custom.namespace": [
+            6,
+            7,
+            8,
+            9,
+            10
+          ],
+          "custom.params": [
+            3,
+            6
+          ]
+        },
+        "def": {
+          "enum.variants": [
+            {
+              "tuple_struct_variant.name": 34,
+              "tuple_struct_variant.types": [
+                14
+              ]
+            },
+            {
+              "unit_variant.name": 37
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 35,
+          "custom.namespace": [
+            6,
+            7,
+            8,
+            9,
+            10
+          ],
+          "custom.params": [
+            3,
+            6
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 28,
+              "type": 3
+            },
+            {
+              "name": 36,
+              "type": 6
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 40,
+          "custom.namespace": [
+            6,
+            7,
+            8,
+            39,
+            10
+          ],
+          "custom.params": [
+            16
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 21,
+              "type": 9
+            },
+            {
+              "name": 41,
+              "type": 17
+            }
+          ]
+        }
+      },
+      {
+        "id": "i32",
+        "def": "builtin"
+      },
+      {
+        "id": {
+          "custom.name": 30,
+          "custom.namespace": [
+            6,
+            7,
+            31,
+            32,
+            31
+          ],
+          "custom.params": [
+            16
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 38,
+              "type": 11
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 45,
+          "custom.namespace": [],
+          "custom.params": [
+            19,
+            8
+          ]
+        },
+        "def": {
+          "enum.variants": [
+            {
+              "tuple_struct_variant.name": 46,
+              "tuple_struct_variant.types": [
+                19
+              ]
+            },
+            {
+              "tuple_struct_variant.name": 47,
+              "tuple_struct_variant.types": [
+                8
+              ]
+            }
+          ]
+        }
+      },
+      {
+        "id": [],
+        "def": "builtin"
+      },
+      {
+        "id": {
+          "custom.name": 45,
+          "custom.namespace": [],
+          "custom.params": [
+            16,
+            8
+          ]
+        },
+        "def": {
+          "enum.variants": [
+            {
+              "tuple_struct_variant.name": 46,
+              "tuple_struct_variant.types": [
+                16
+              ]
+            },
+            {
+              "tuple_struct_variant.name": 47,
+              "tuple_struct_variant.types": [
+                8
+              ]
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 17,
+          "custom.namespace": [],
+          "custom.params": [
+            16
+          ]
+        },
+        "def": {
+          "enum.variants": [
+            {
+              "unit_variant.name": 18
+            },
+            {
+              "tuple_struct_variant.name": 19,
+              "tuple_struct_variant.types": [
+                16
+              ]
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "storage": {
+    "struct.type": 1,
+    "struct.fields": [
+      {
+        "name": 4,
+        "layout": {
+          "struct.type": 2,
+          "struct.fields": [
+            {
+              "name": 21,
+              "layout": {
+                "struct.type": 9,
+                "struct.fields": [
+                  {
+                    "name": 24,
+                    "layout": {
+                      "range.offset": [
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0
+                      ],
+                      "range.len": 1,
+                      "range.elem_type": 8
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "name": 29,
+              "layout": {
+                "range.offset": [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  1
+                ],
+                "range.len": 4294967295,
+                "range.elem_type": 13
+              }
+            }
+          ]
+        }
+      },
+      {
+        "name": 39,
+        "layout": {
+          "struct.type": 15,
+          "struct.fields": [
+            {
+              "name": 21,
+              "layout": {
+                "struct.type": 9,
+                "struct.fields": [
+                  {
+                    "name": 24,
+                    "layout": {
+                      "range.offset": [
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        1,
+                        0,
+                        0,
+                        0,
+                        0
+                      ],
+                      "range.len": 1,
+                      "range.elem_type": 8
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "name": 41,
+              "layout": {
+                "range.offset": [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  1,
+                  0,
+                  0,
+                  0,
+                  1
+                ],
+                "range.len": 4294967295,
+                "range.elem_type": 16
+              }
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "contract": {
+    "name": 1,
+    "constructors": [
+      {
+        "name": 42,
+        "selector": 0,
+        "args": [],
+        "docs": [
+          "Initializes the value to the initial value."
+        ]
+      }
+    ],
+    "messages": [
+      {
+        "name": 43,
+        "selector": 865577567,
+        "mutates": true,
+        "args": [
+          {
+            "name": 23,
+            "type": {
+              "ty": 16,
+              "display_name": [
+                44
+              ]
+            }
+          }
+        ],
+        "return_type": {
+          "ty": 18,
+          "display_name": [
+            45
+          ]
+        },
+        "docs": [
+          "Pushes a new value to the shared vector.",
+          "",
+          "# Errors",
+          "",
+          "- If the caller does not have unlimited access rights."
+        ]
+      },
+      {
+        "name": 48,
+        "selector": 572030971,
+        "mutates": true,
+        "args": [
+          {
+            "name": 49,
+            "type": {
+              "ty": 3,
+              "display_name": [
+                11
+              ]
+            }
+          },
+          {
+            "name": 16,
+            "type": {
+              "ty": 7,
+              "display_name": [
+                17
+              ]
+            }
+          },
+          {
+            "name": 20,
+            "type": {
+              "ty": 7,
+              "display_name": [
+                17
+              ]
+            }
+          }
+        ],
+        "return_type": {
+          "ty": 18,
+          "display_name": [
+            45
+          ]
+        },
+        "docs": [
+          "Registers a new user with the given access rights.",
+          "",
+          "Can also be used to change access rights of an already existing user.",
+          "",
+          "# Errors",
+          "",
+          "- If the caller does not have unlimited access rights."
+        ]
+      },
+      {
+        "name": 50,
+        "selector": 2028185770,
+        "mutates": true,
+        "args": [
+          {
+            "name": 51,
+            "type": {
+              "ty": 8,
+              "display_name": [
+                52
+              ]
+            }
+          },
+          {
+            "name": 53,
+            "type": {
+              "ty": 16,
+              "display_name": [
+                44
+              ]
+            }
+          }
+        ],
+        "return_type": {
+          "ty": 20,
+          "display_name": [
+            45
+          ]
+        },
+        "docs": [
+          "Sets the value at the given position to the given value.",
+          "",
+          "Returns the previous value.",
+          "",
+          "# Errors",
+          "",
+          "- If the given position is out of bounds.",
+          "- If the caller does not have the required access rights."
+        ]
+      },
+      {
+        "name": 54,
+        "selector": 4266279973,
+        "mutates": false,
+        "args": [
+          {
+            "name": 51,
+            "type": {
+              "ty": 8,
+              "display_name": [
+                52
+              ]
+            }
+          }
+        ],
+        "return_type": {
+          "ty": 21,
+          "display_name": [
+            17
+          ]
+        },
+        "docs": [
+          "Returns the value of the shared vector at the given position",
+          "or `None` if the access is out of bounds."
+        ]
+      },
+      {
+        "name": 21,
+        "selector": 1403873684,
+        "mutates": false,
+        "args": [],
+        "return_type": {
+          "ty": 8,
+          "display_name": [
+            52
+          ]
+        },
+        "docs": [
+          "Returns the length of the shared vector."
+        ]
+      }
+    ],
+    "events": [
+      {
+        "name": 55,
+        "args": [
+          {
+            "name": 51,
+            "indexed": false,
+            "type": {
+              "ty": 8,
+              "display_name": [
+                52
+              ]
+            }
+          },
+          {
+            "name": 23,
+            "indexed": false,
+            "type": {
+              "ty": 16,
+              "display_name": [
+                44
+              ]
+            }
+          }
+        ],
+        "docs": [
+          "Fires whenever a mutator changes the vector."
+        ]
+      },
+      {
+        "name": 56,
+        "args": [
+          {
+            "name": 49,
+            "indexed": false,
+            "type": {
+              "ty": 3,
+              "display_name": [
+                11
+              ]
+            }
+          },
+          {
+            "name": 23,
+            "indexed": false,
+            "type": {
+              "ty": 16,
+              "display_name": [
+                44
+              ]
+            }
+          }
+        ],
+        "docs": [
+          "Fires whenever a mutator pushes the vector successfully."
+        ]
+      },
+      {
+        "name": 57,
+        "args": [
+          {
+            "name": 49,
+            "indexed": false,
+            "type": {
+              "ty": 3,
+              "display_name": [
+                11
+              ]
+            }
+          },
+          {
+            "name": 16,
+            "indexed": false,
+            "type": {
+              "ty": 7,
+              "display_name": [
+                17
+              ]
+            }
+          },
+          {
+            "name": 20,
+            "indexed": false,
+            "type": {
+              "ty": 7,
+              "display_name": [
+                17
+              ]
+            }
+          }
+        ],
+        "docs": [
+          "Fires whenever a new mutator is registered",
+          "or when a mutators access rights are changed."
+        ]
+      }
+    ],
+    "docs": []
+  }
+}

packages/api-contract/test/contracts/V2.json

@@ -0,0 +1,697 @@
+{
+  "registry": {
+    "strings": [
+      "RustStructures",
+      "structures",
+      "normal",
+      "my_tuple_struct",
+      "Value",
+      "ink_core",
+      "storage",
+      "value",
+      "TupleStruct",
+      "cell",
+      "SyncCell",
+      "sync_cell",
+      "Key",
+      "key",
+      "my_struct",
+      "Struct",
+      "first",
+      "seconds",
+      "my_clike_enum",
+      "ClikeEnum",
+      "FirstVariant",
+      "SecondVariant",
+      "ThirdVariant",
+      "my_enum",
+      "RustEnum",
+      "NoData",
+      "TupleVariant",
+      "StructVariant",
+      "second",
+      "my_union",
+      "Union"
+    ],
+    "types": [
+      {
+        "id": {
+          "custom.name": 1,
+          "custom.namespace": [
+            2,
+            3
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 4,
+              "type": 2
+            },
+            {
+              "name": 15,
+              "type": 9
+            },
+            {
+              "name": 19,
+              "type": 12
+            },
+            {
+              "name": 24,
+              "type": 15
+            },
+            {
+              "name": 30,
+              "type": 18
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 5,
+          "custom.namespace": [
+            6,
+            7,
+            8
+          ],
+          "custom.params": [
+            3
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 10,
+              "type": 6
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 9,
+          "custom.namespace": [
+            2
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "tuple_struct.types": [
+            4,
+            5
+          ]
+        }
+      },
+      {
+        "id": "u8",
+        "def": "builtin"
+      },
+      {
+        "id": "u16",
+        "def": "builtin"
+      },
+      {
+        "id": {
+          "custom.name": 11,
+          "custom.namespace": [
+            6,
+            7,
+            10,
+            12
+          ],
+          "custom.params": [
+            3
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 10,
+              "type": 7
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 13,
+          "custom.namespace": [
+            6,
+            7,
+            14
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "tuple_struct.types": [
+            8
+          ]
+        }
+      },
+      {
+        "id": {
+          "array.len": 32,
+          "array.type": 4
+        },
+        "def": "builtin"
+      },
+      {
+        "id": {
+          "custom.name": 5,
+          "custom.namespace": [
+            6,
+            7,
+            8
+          ],
+          "custom.params": [
+            10
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 10,
+              "type": 11
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 16,
+          "custom.namespace": [
+            2
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 17,
+              "type": 4
+            },
+            {
+              "name": 18,
+              "type": 5
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 11,
+          "custom.namespace": [
+            6,
+            7,
+            10,
+            12
+          ],
+          "custom.params": [
+            10
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 10,
+              "type": 7
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 5,
+          "custom.namespace": [
+            6,
+            7,
+            8
+          ],
+          "custom.params": [
+            13
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 10,
+              "type": 14
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 20,
+          "custom.namespace": [
+            2
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "clike_enum.variants": [
+            {
+              "name": 21,
+              "discriminant": 0
+            },
+            {
+              "name": 22,
+              "discriminant": 1
+            },
+            {
+              "name": 23,
+              "discriminant": 42
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 11,
+          "custom.namespace": [
+            6,
+            7,
+            10,
+            12
+          ],
+          "custom.params": [
+            13
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 10,
+              "type": 7
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 5,
+          "custom.namespace": [
+            6,
+            7,
+            8
+          ],
+          "custom.params": [
+            16
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 10,
+              "type": 17
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 25,
+          "custom.namespace": [
+            2
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "enum.variants": [
+            {
+              "unit_variant.name": 26
+            },
+            {
+              "tuple_struct_variant.name": 27,
+              "tuple_struct_variant.types": [
+                4,
+                5
+              ]
+            },
+            {
+              "struct_variant.name": 28,
+              "struct_variant.fields": [
+                {
+                  "name": 17,
+                  "type": 4
+                },
+                {
+                  "name": 29,
+                  "type": 5
+                }
+              ]
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 11,
+          "custom.namespace": [
+            6,
+            7,
+            10,
+            12
+          ],
+          "custom.params": [
+            16
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 10,
+              "type": 7
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 5,
+          "custom.namespace": [
+            6,
+            7,
+            8
+          ],
+          "custom.params": [
+            19
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 10,
+              "type": 20
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 31,
+          "custom.namespace": [
+            2
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "union.fields": [
+            {
+              "name": 17,
+              "type": 4
+            },
+            {
+              "name": 29,
+              "type": 5
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 11,
+          "custom.namespace": [
+            6,
+            7,
+            10,
+            12
+          ],
+          "custom.params": [
+            19
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 10,
+              "type": 7
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "storage": {
+    "struct.type": 1,
+    "struct.fields": [
+      {
+        "name": 4,
+        "layout": {
+          "struct.type": 2,
+          "struct.fields": [
+            {
+              "name": 10,
+              "layout": {
+                "range.offset": [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+                ],
+                "range.len": 1,
+                "range.elem_type": 3
+              }
+            }
+          ]
+        }
+      },
+      {
+        "name": 15,
+        "layout": {
+          "struct.type": 9,
+          "struct.fields": [
+            {
+              "name": 10,
+              "layout": {
+                "range.offset": [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  1
+                ],
+                "range.len": 1,
+                "range.elem_type": 10
+              }
+            }
+          ]
+        }
+      },
+      {
+        "name": 19,
+        "layout": {
+          "struct.type": 12,
+          "struct.fields": [
+            {
+              "name": 10,
+              "layout": {
+                "range.offset": [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  2
+                ],
+                "range.len": 1,
+                "range.elem_type": 13
+              }
+            }
+          ]
+        }
+      },
+      {
+        "name": 24,
+        "layout": {
+          "struct.type": 15,
+          "struct.fields": [
+            {
+              "name": 10,
+              "layout": {
+                "range.offset": [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  3
+                ],
+                "range.len": 1,
+                "range.elem_type": 16
+              }
+            }
+          ]
+        }
+      },
+      {
+        "name": 30,
+        "layout": {
+          "struct.type": 18,
+          "struct.fields": [
+            {
+              "name": 10,
+              "layout": {
+                "range.offset": [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  4
+                ],
+                "range.len": 1,
+                "range.elem_type": 19
+              }
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "contract": {
+    "name": 1,
+    "deploy": {
+      "args": [],
+      "docs": []
+    },
+    "messages": [],
+    "events": [],
+    "docs": []
+  }
+}

packages/api-contract/test/contracts/incrementer.json

@@ -0,0 +1,233 @@
+{
+  "registry": {
+    "strings": [
+      "Incrementer",
+      "incrementer",
+      "normal",
+      "value",
+      "Value",
+      "ink_core",
+      "storage",
+      "cell",
+      "SyncCell",
+      "sync_cell",
+      "Key",
+      "key",
+      "on_deploy",
+      "init_value",
+      "u32",
+      "inc",
+      "by",
+      "get",
+      "compare",
+      "with",
+      "bool"
+    ],
+    "types": [
+      {
+        "id": {
+          "custom.name": 1,
+          "custom.namespace": [
+            2,
+            3
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 4,
+              "type": 2
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 5,
+          "custom.namespace": [
+            6,
+            7,
+            4
+          ],
+          "custom.params": [
+            3
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 8,
+              "type": 4
+            }
+          ]
+        }
+      },
+      {
+        "id": "u32",
+        "def": "builtin"
+      },
+      {
+        "id": {
+          "custom.name": 9,
+          "custom.namespace": [
+            6,
+            7,
+            8,
+            10
+          ],
+          "custom.params": [
+            3
+          ]
+        },
+        "def": {
+          "struct.fields": [
+            {
+              "name": 8,
+              "type": 5
+            }
+          ]
+        }
+      },
+      {
+        "id": {
+          "custom.name": 11,
+          "custom.namespace": [
+            6,
+            7,
+            12
+          ],
+          "custom.params": []
+        },
+        "def": {
+          "tuple_struct.types": [
+            6
+          ]
+        }
+      },
+      {
+        "id": {
+          "array.len": 32,
+          "array.type": 7
+        },
+        "def": "builtin"
+      },
+      {
+        "id": "u8",
+        "def": "builtin"
+      },
+      {
+        "id": "bool",
+        "def": "builtin"
+      }
+    ]
+  },
+  "storage": {
+    "struct.type": 1,
+    "struct.fields": [
+      {
+        "name": 4,
+        "layout": {
+          "struct.type": 2,
+          "struct.fields": [
+            {
+              "name": 8,
+              "layout": {
+                "range.offset": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                "range.len": 1,
+                "range.elem_type": 3
+              }
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "contract": {
+    "name": 1,
+    "constructors": [
+      {
+        "name": 13,
+        "selector": "[\"0x00\",\"0x00\",\"0x00\",\"0x00\"]",
+        "args": [
+          {
+            "name": 14,
+            "type": {
+              "ty": 3,
+              "display_name": [
+                15
+              ]
+            }
+          }
+        ],
+        "docs": [
+          "Initializes the value to the initial value."
+        ]
+      }
+    ],
+    "messages": [
+      {
+        "name": 16,
+        "selector": "[\"0x0F\",\"0x59\",\"0xD0\",\"0xE7\"]",
+        "mutates": true,
+        "args": [
+          {
+            "name": 17,
+            "type": {
+              "ty": 3,
+              "display_name": [
+                15
+              ]
+            }
+          }
+        ],
+        "return_type": null,
+        "docs": [
+          "Flips the current state of our smart contract."
+        ]
+      },
+      {
+        "name": 18,
+        "selector": "[\"0xFE\",\"0x4A\",\"0x44\",\"0x25\"]",
+        "mutates": false,
+        "args": [],
+        "return_type": {
+          "ty": 3,
+          "display_name": [
+            15
+          ]
+        },
+        "docs": [
+          "Returns the current state."
+        ]
+      },
+      {
+        "name": 19,
+        "selector": "[\"0x15\",\"0xB0\",\"0xC5\",\"0x0C\"]",
+        "mutates": false,
+        "args": [
+          {
+            "name": 20,
+            "type": {
+              "ty": 3,
+              "display_name": [
+                15
+              ]
+            }
+          }
+        ],
+        "return_type": {
+          "ty": 8,
+          "display_name": [
+            21
+          ]
+        },
+        "docs": [
+          "Returns `true` if the internal value is greater than or equal to the provided value."
+        ]
+      }
+    ],
+    "events": [],
+    "docs": []
+  }
+}

packages/api-derive/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/api-derive",
-  "version": "0.94.1",
+  "version": "0.96.1",
   "description": "Common functions used across Polkadot, derived from RPC calls and storage queries.",
   "main": "index.js",
   "keywords": [
@@ -27,11 +27,11 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api-derive#readme",
   "dependencies": {
-    "@babel/runtime": "^7.6.2",
-    "@polkadot/api": "^0.94.1",
-    "@polkadot/types": "^0.94.1"
+    "@babel/runtime": "^7.7.1",
+    "@polkadot/api": "^0.96.1",
+    "@polkadot/types": "^0.96.1"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^1.5.1"
+    "@polkadot/keyring": "^1.7.0-beta.5"
   }
 }

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

@@ -5,17 +5,41 @@
 import { AccountId, AccountIndex, Address } from '@polkadot/types/interfaces';
 
 import { Observable, of } from 'rxjs';
-import { map, startWith } from 'rxjs/operators';
+import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { isU8a } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';
 import { createType } from '@polkadot/types';
-import { idToIndex } from './idToIndex';
-import { indexToId } from './indexToId';
-import { drr } from '../util/drr';
+
+import { drr } from '../util';
 
 export type AccountIdAndIndex = [AccountId?, AccountIndex?];
 
+function retrieve (api: ApiInterfaceRx, address: Address | AccountId | AccountIndex | string | null | undefined): Observable<AccountIdAndIndex> {
+  try {
+    // yes, this can fail, don't care too much, catch will catch it
+    const decoded = isU8a(address)
+      ? address
+      : decodeAddress((address || '').toString());
+
+    if (decoded.length === 32) {
+      const accountId = createType('AccountId', decoded);
+
+      return api.derive.accounts.idToIndex(accountId).pipe(
+        map((accountIndex): AccountIdAndIndex => [accountId, accountIndex] as AccountIdAndIndex)
+      );
+    }
+
+    const accountIndex = createType('AccountIndex', decoded);
+
+    return api.derive.accounts.indexToId(accountIndex).pipe(
+      map((accountId): AccountIdAndIndex => [accountId, accountIndex] as AccountIdAndIndex)
+    );
+  } catch (error) {
+    return of([undefined, undefined] as AccountIdAndIndex);
+  }
+}
+
 /**
  * @name idAndIndex
  * @param {(Address | AccountId | AccountIndex | string | null)} address - An accounts address in various formats.
@@ -30,32 +54,6 @@ export type AccountIdAndIndex = [AccountId?, AccountIndex?];
  * ```
  */
 export function idAndIndex (api: ApiInterfaceRx): (address?: Address | AccountId | AccountIndex | string | null) => Observable<AccountIdAndIndex> {
-  return (address?: Address | AccountId | AccountIndex | string | null): Observable<AccountIdAndIndex> => {
-    try {
-      // yes, this can fail, don't care too much, catch will catch it
-      const decoded = isU8a(address)
-        ? address
-        : decodeAddress((address || '').toString());
-
-      if (decoded.length === 32) {
-        const accountId = createType('AccountId', decoded);
-
-        return idToIndex(api)(accountId).pipe(
-          startWith(undefined),
-          map((accountIndex): AccountIdAndIndex => [accountId, accountIndex] as AccountIdAndIndex),
-          drr()
-        );
-      }
-
-      const accountIndex = createType('AccountIndex', decoded);
-
-      return indexToId(api)(accountIndex).pipe(
-        startWith(undefined),
-        map((accountId): AccountIdAndIndex => [accountId, accountIndex] as AccountIdAndIndex),
-        drr()
-      );
-    } catch (error) {
-      return of([undefined, undefined] as AccountIdAndIndex).pipe(drr());
-    }
-  };
+  return (address?: Address | AccountId | AccountIndex | string | null): Observable<AccountIdAndIndex> =>
+    retrieve(api, address).pipe(drr());
 }

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

@@ -3,13 +3,13 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { AccountId, AccountIndex } from '@polkadot/types/interfaces';
+import { AccountIndexes } from '../types';
 
 import { Observable } from 'rxjs';
 import { map, startWith } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 
-import { indexes, AccountIndexes } from './indexes';
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
 /**
  * @name idToIndex
@@ -27,12 +27,11 @@ import { drr } from '../util/drr';
  */
 export function idToIndex (api: ApiInterfaceRx): (accountId: AccountId | string) => Observable<AccountIndex | undefined> {
   return (accountId: AccountId | string): Observable<AccountIndex | undefined> =>
-    indexes(api)()
-      .pipe(
-        startWith({}),
-        map((indexes: AccountIndexes): AccountIndex | undefined =>
-          (indexes || {})[accountId.toString()]
-        ),
-        drr()
-      );
+    api.derive.accounts.indexes().pipe(
+      startWith({}),
+      map((indexes: AccountIndexes): AccountIndex | undefined =>
+        (indexes || {})[accountId.toString()]
+      ),
+      drr()
+    );
 }

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

@@ -6,3 +6,4 @@ export * from './idAndIndex';
 export * from './idToIndex';
 export * from './indexToId';
 export * from './indexes';
+export * from './info';

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

@@ -10,7 +10,7 @@ import { ApiInterfaceRx } from '@polkadot/api/types';
 import { ENUMSET_SIZE } from '@polkadot/types/primitive/Generic/AccountIndex';
 import { createType, ClassOf, Vec } from '@polkadot/types';
 
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
 /**
  * @name indexToId
@@ -26,19 +26,19 @@ import { drr } from '../util/drr';
  * ```
  */
 export function indexToId (api: ApiInterfaceRx): (accountIndex: AccountIndex | string) => Observable<AccountId | undefined> {
+  const querySection = api.query.indices || api.query.balances;
+
   return (_accountIndex: AccountIndex | string): Observable<AccountId | undefined> => {
-    const querySection = api.query.indices || api.query.balances;
     const accountIndex = _accountIndex instanceof ClassOf('AccountIndex')
       ? _accountIndex
       : createType('AccountIndex', _accountIndex);
 
-    return (querySection.enumSet<Vec<AccountId>>(accountIndex.div(ENUMSET_SIZE)))
-      .pipe(
-        startWith([]),
-        map((accounts): AccountId | undefined =>
-          (accounts || [])[accountIndex.mod(ENUMSET_SIZE).toNumber()]
-        ),
-        drr()
-      );
+    return querySection.enumSet<Vec<AccountId>>(accountIndex.div(ENUMSET_SIZE)).pipe(
+      startWith([]),
+      map((accounts): AccountId | undefined =>
+        (accounts || [])[accountIndex.mod(ENUMSET_SIZE).toNumber()]
+      ),
+      drr()
+    );
   };
 }

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

@@ -2,17 +2,16 @@
 // 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, AccountIndex } from '@polkadot/types/interfaces';
+import { AccountIndexes } from '../types';
 
 import { Observable } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
-import { ApiInterfaceRx } from '@polkadot/api/types';
 import { ENUMSET_SIZE } from '@polkadot/types/primitive/Generic/AccountIndex';
 import { createType } from '@polkadot/types';
 
-import { drr } from '../util/drr';
-
-export type AccountIndexes = Record<string, AccountIndex>;
+import { drr } from '../util';
 
 const enumsetSize = ENUMSET_SIZE.toNumber();
 
@@ -32,29 +31,27 @@ const enumsetSize = ENUMSET_SIZE.toNumber();
  * ```
  */
 export function indexes (api: ApiInterfaceRx): () => Observable<AccountIndexes> {
-  return (): Observable<AccountIndexes> => {
-    return (api.query.indices.nextEnumSet<AccountIndex>())
-      .pipe(
-        // use the nextEnumSet (which is a counter of the number of sets) to construct
-        // a range of values to query [0, 1, 2, ...]. Retrieve the full enum set for the
-        // specific index - each query can return up to ENUMSET_SIZE (64) records, each
-        // containing an AccountId
-        switchMap((next: AccountIndex): Observable<any> =>
-          api.query.indices.enumSet.multi([...Array(next.toNumber() + 1).keys()]) as Observable<any>
-        ),
-        map((all: (AccountId[] | undefined)[]): AccountIndexes =>
-          (all || []).reduce((result, list, outerIndex): AccountIndexes => {
-            (list || []).forEach((accountId, innerIndex): void => {
-              // re-create the index based on position 0 is [0][0] and likewise
-              // 64 (0..63 in first) is [1][0] (the first index value in set 2)
-              const index = (outerIndex * enumsetSize) + innerIndex;
+  return (): Observable<AccountIndexes> =>
+    api.query.indices.nextEnumSet<AccountIndex>().pipe(
+      // use the nextEnumSet (which is a counter of the number of sets) to construct
+      // a range of values to query [0, 1, 2, ...]. Retrieve the full enum set for the
+      // specific index - each query can return up to ENUMSET_SIZE (64) records, each
+      // containing an AccountId
+      switchMap((next: AccountIndex): Observable<any> =>
+        api.query.indices.enumSet.multi([...Array(next.toNumber() + 1).keys()]) as Observable<any>
+      ),
+      map((all: (AccountId[] | undefined)[]): AccountIndexes =>
+        (all || []).reduce((result, list, outerIndex): AccountIndexes => {
+          (list || []).forEach((accountId, innerIndex): void => {
+            // re-create the index based on position 0 is [0][0] and likewise
+            // 64 (0..63 in first) is [1][0] (the first index value in set 2)
+            const index = (outerIndex * enumsetSize) + innerIndex;
 
-              result[accountId.toString()] = createType('AccountIndex', index);
-            });
+            result[accountId.toString()] = createType('AccountIndex', index);
+          });
 
-            return result;
-          }, {} as AccountIndexes)),
-        drr()
-      );
-  };
+          return result;
+        }, {} as AccountIndexes)),
+      drr()
+    );
 }

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

@@ -0,0 +1,49 @@
+// Copyright 2017-2019 @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, AccountIndex, Address, Balance } from '@polkadot/types/interfaces';
+import { Codec } from '@polkadot/types/types';
+import { DeriveAccountInfo } from '../types';
+
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { Bytes, Option, u32 } from '@polkadot/types';
+import { u8aToString } from '@polkadot/util';
+
+import { drr } from '../util';
+
+function retrieveNick (api: ApiInterfaceRx, accountId?: AccountId): Observable<string | undefined> {
+  return accountId && api.query.nicks
+    ? api.query.nicks
+      .nameOf<Option<[Bytes, Balance] & Codec>>(accountId)
+      .pipe(
+        map((nameOf): string | undefined =>
+          nameOf?.isSome
+            ? u8aToString(nameOf.unwrap()[0]).substr(0, (api.consts.nicks.maxLength as u32).toNumber())
+            : undefined
+        )
+      )
+    : of(undefined);
+}
+
+/**
+ * @name info
+ * @description Returns aux. info with regards to an account, current that includes the accountId, accountIndex and nickname
+ */
+export function info (api: ApiInterfaceRx): (address?: AccountIndex | AccountId | Address | string | null) => Observable<DeriveAccountInfo> {
+  return (address?: AccountIndex | AccountId | Address | string | null): Observable<DeriveAccountInfo> =>
+    api.derive.accounts.idAndIndex(address).pipe(
+      switchMap(([accountId, accountIndex]): Observable<[DeriveAccountInfo, string?]> =>
+        combineLatest([
+          of({ accountId, accountIndex }),
+          retrieveNick(api, accountId)
+        ])
+      ),
+      map(([{ accountId, accountIndex }, nickname]): DeriveAccountInfo => ({
+        accountId, accountIndex, nickname
+      })),
+      drr()
+    );
+}

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

@@ -3,46 +3,39 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { AccountId, AccountIndex, Address, Balance, BalanceLock, BlockNumber, Index, VestingSchedule } from '@polkadot/types/interfaces';
+import { DerivedBalances } from '../types';
 
 import BN from 'bn.js';
 import { combineLatest, of, Observable } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { ClassOf, Option, createType } from '@polkadot/types';
+import { Option, Vec, createType } from '@polkadot/types';
 import { bnMax } from '@polkadot/util';
 
-import { idAndIndex } from '../accounts/idAndIndex';
-import { bestNumber } from '../chain/bestNumber';
-import { DerivedBalances } from '../types';
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
-type Result = [AccountId | undefined, BlockNumber | undefined, [Balance?, Balance?, BalanceLock[]?, Option<VestingSchedule>?, Index?]];
+type ResultBalance = [Balance, Balance, BalanceLock[], Option<VestingSchedule>];
+type Result = [AccountId, BlockNumber, ResultBalance, Index];
 
-function calcBalances ([accountId = createType('AccountId'), bestNumber = createType('Balance'), [freeBalance = createType('Balance'), reservedBalance = createType('Balance'), locks = [], vesting = new Option<VestingSchedule>(ClassOf('VestingSchedule'), null), accountNonce = createType('Balance')]]: Result): DerivedBalances {
+function calcBalances ([accountId, bestNumber, [freeBalance, reservedBalance, locks, vesting], accountNonce]: Result): DerivedBalances {
   let lockedBalance = createType('Balance');
+  let lockedBreakdown: BalanceLock[] = [];
 
   if (Array.isArray(locks)) {
     // only get the locks that are valid until passed the current block
-    const totals = locks.filter((value): boolean => bestNumber && value.until.gt(bestNumber));
+    lockedBreakdown = locks.filter(({ until }): boolean => bestNumber && until.gt(bestNumber));
+
     // get the maximum of the locks according to https://github.com/paritytech/substrate/blob/master/srml/balances/src/lib.rs#L699
-    lockedBalance = totals[0]
-      ? bnMax(...totals.map(({ amount }): Balance => amount)) as Balance
-      : createType('Balance');
+    if (lockedBreakdown.length) {
+      lockedBalance = createType('Balance', bnMax(...lockedBreakdown.map(({ amount }): Balance => amount)));
+    }
   }
 
   // offset = balance locked at genesis, perBlock is the unlock amount
-  const { offset, perBlock } = vesting.unwrapOr(createType('VestingSchedule'));
-  const vestedNow: BN = perBlock.mul(bestNumber);
-  const vestedBalance: BN = vestedNow.gt(offset)
-    ? freeBalance
-    : freeBalance.sub(offset).add(vestedNow);
-
-  // NOTE Workaround for this account on Alex (one of a couple reported) -
-  //   5F7BJL6Z4m8RLtK7nXEqqpEqhBbd535Z3CZeYF6ccvaQAY6N
-  // The locked is > the vested and ended up with the locked > free,
-  // i.e. related to https://github.com/paritytech/polkadot/issues/225
-  // (most probably due to movements from stash -> controller -> free)
-  const availableBalance: BN = bnMax(createType('Balance'), vestedBalance.sub(lockedBalance));
+  const { offset: vestingTotal, perBlock } = vesting.unwrapOr(createType('VestingSchedule'));
+  const vestedNow = createType('Balance', perBlock.mul(bestNumber));
+  const vestedBalance = createType('Balance', vestedNow.gt(vestingTotal) ? new BN(0) : bnMax(new BN(0), freeBalance.sub(vestingTotal).add(vestedNow)));
+  const availableBalance = createType('Balance', bnMax(new BN(0), (vestedBalance.gtn(0) ? vestedBalance : freeBalance).sub(lockedBalance)));
 
   return {
     accountId,
@@ -50,49 +43,58 @@ function calcBalances ([accountId = createType('AccountId'), bestNumber = create
     availableBalance,
     freeBalance,
     lockedBalance,
+    lockedBreakdown,
     reservedBalance,
     vestedBalance,
-    votingBalance: freeBalance.add(reservedBalance)
-  } as DerivedBalances;
+    vestingTotal,
+    votingBalance: createType('Balance', freeBalance.add(reservedBalance))
+  };
+}
+
+function queryBalances (api: ApiInterfaceRx, accountId: AccountId): Observable<ResultBalance> {
+  return api.queryMulti<[Balance, Balance, Vec<BalanceLock>, Option<VestingSchedule>]>([
+    [api.query.balances.freeBalance, accountId],
+    [api.query.balances.reservedBalance, accountId],
+    [api.query.balances.locks, accountId],
+    [api.query.balances.vesting, accountId]
+  ]);
 }
 
 /**
  * @name all
  * @param {( AccountIndex | AccountId | Address | string )} address - An accounts Id in different formats.
- * @returns An object containing the combined results of the storage queries for
- * all relevant fees as declared in the substrate chain spec.
+ * @returns An object containing the results of various balance queries
  * @example
  * <BR>
  *
  * ```javascript
  * const ALICE = 'F7Hs';
  *
- * api.derive.balances.all(ALICE, ([accountId, lockedBalance]) => {
+ * api.derive.balances.all(ALICE, ({ accountId, lockedBalance }) => {
  *   console.log(`The account ${accountId} has a locked balance ${lockedBalance} units.`);
  * });
  * ```
  */
 export function all (api: ApiInterfaceRx): (address: AccountIndex | AccountId | Address | string) => Observable<DerivedBalances> {
-  return (address: AccountIndex | AccountId | Address | string): Observable<DerivedBalances> => {
-    return idAndIndex(api)(address).pipe(
-      switchMap(([accountId]): Observable<Result> =>
+  return (address: AccountIndex | AccountId | Address | string): Observable<DerivedBalances> =>
+    api.derive.accounts.info(address).pipe(
+      switchMap(({ accountId }): Observable<Result> =>
         (accountId
           ? combineLatest([
             of(accountId),
-            bestNumber(api)(),
-            api.queryMulti([
-              [api.query.balances.freeBalance, accountId],
-              [api.query.balances.reservedBalance, accountId],
-              [api.query.balances.locks, accountId],
-              [api.query.balances.vesting, accountId],
-              [api.query.system.accountNonce, accountId]
-            ])
+            api.derive.chain.bestNumber(),
+            queryBalances(api, accountId),
+            // FIXME This is having issues with Kusama, only use accountNonce atm
+            // api.rpc.account && api.rpc.account.nextIndex
+            //   ? api.rpc.account.nextIndex(accountId)
+            //   // otherwise we end up with this: type 'Codec | Index' is not assignable to type 'Index'.
+            //   : api.query.system.accountNonce<Index>(accountId)
+            api.query.system.accountNonce<Index>(accountId)
           ])
-          : of([undefined, undefined, [undefined, undefined, undefined, undefined, undefined]])
-        ) as Observable<Result>
+          : of([createType('AccountId'), createType('BlockNumber'), [createType('Balance'), createType('Balance'), createType('Vec<BalanceLock>'), createType('Option<VestingSchedule>', null)], createType('Index')])
+        )
       ),
       map(calcBalances),
       drr()
     );
-  };
 }

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

@@ -3,37 +3,39 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
+import { Balance } from '@polkadot/types/interfaces';
 import { DerivedFees } from '../types';
 
-import BN from 'bn.js';
 import { Observable, of } from 'rxjs';
 import { map } from 'rxjs/operators';
 
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
-type Result = [BN, BN, BN, BN, BN];
+type Result = [Balance, Balance, Balance, Balance, Balance];
+
+function queryV2 (api: ApiInterfaceRx): Observable<Result> {
+  const paymentBase = api.consts.transactionPayment || api.consts.balances;
 
-function querySubtrateV2 (api: ApiInterfaceRx): Observable<Result> {
   return of([
     // get values from api.const for substrate versions post spec_version: 101
     // https://github.com/paritytech/substrate/pull/2883/files#diff-5e5e1c3aec9ddfde0a9054d062ab3db9R131
-    api.consts.balances.creationFee,
-    api.consts.balances.existentialDeposit,
-    api.consts.balances.transactionBaseFee,
-    api.consts.balances.transactionByteFee,
-    api.consts.balances.transferFee
-  ]) as any as Observable<Result>;
+    api.consts.balances.creationFee as Balance,
+    api.consts.balances.existentialDeposit as Balance,
+    api.consts.balances.transferFee as Balance,
+    paymentBase.transactionBaseFee as Balance,
+    paymentBase.transactionByteFee as Balance
+  ]);
 }
 
-function querySubtrateV1 (api: ApiInterfaceRx): Observable<Result> {
-  return api.queryMulti([
+function queryV1 (api: ApiInterfaceRx): Observable<Result> {
+  return api.queryMulti<Result>([
     // Support older versions and get values from storage
     api.query.balances.creationFee,
     api.query.balances.existentialDeposit,
+    api.query.balances.transferFee,
     api.query.balances.transactionBaseFee,
-    api.query.balances.transactionByteFee,
-    api.query.balances.transferFee
-  ]) as any as Observable<Result>;
+    api.query.balances.transactionByteFee
+  ]);
 }
 
 /**
@@ -44,19 +46,19 @@ function querySubtrateV1 (api: ApiInterfaceRx): Observable<Result> {
  * <BR>
  *
  * ```javascript
- * api.derive.balances.fees(([creationFee, transferFee]) => {
+ * api.derive.balances.fees(({ creationFee, transferFee }) => {
  *   console.log(`The fee for creating a new account on this chain is ${creationFee} units. The fee required for making a transfer is ${transferFee} units.`);
  * });
  * ```
  */
 export function fees (api: ApiInterfaceRx): () => Observable<DerivedFees> {
-  return (): Observable<DerivedFees> => {
-    return (
-      api.consts.balances
-        ? querySubtrateV2(api)
-        : querySubtrateV1(api)
-    ).pipe(
-      map(([creationFee, existentialDeposit, transactionBaseFee, transactionByteFee, transferFee]): DerivedFees => ({
+  const query = api.consts.balances
+    ? queryV2
+    : queryV1;
+
+  return (): Observable<DerivedFees> =>
+    query(api).pipe(
+      map(([creationFee, existentialDeposit, transferFee, transactionBaseFee, transactionByteFee]): DerivedFees => ({
         creationFee,
         existentialDeposit,
         transactionBaseFee,
@@ -65,5 +67,4 @@ export function fees (api: ApiInterfaceRx): () => Observable<DerivedFees> {
       })),
       drr()
     );
-  };
 }

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

@@ -8,17 +8,18 @@ import { combineLatest, Observable, of } from 'rxjs';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 
 import { DerivedBalances } from '../types';
-import { drr } from '../util/drr';
-import { all } from './all';
+import { drr } from '../util';
 
 export function votingBalances (api: ApiInterfaceRx): (addresses?: (AccountId | AccountIndex | Address | string)[]) => Observable<DerivedBalances[]> {
-  return (addresses?: (AccountId | AccountIndex | Address | string)[]): Observable<DerivedBalances[]> => {
-    return (
+  return (addresses?: (AccountId | AccountIndex | Address | string)[]): Observable<DerivedBalances[]> =>
+    (
       !addresses || !addresses.length
         ? of([] as DerivedBalances[])
-        : combineLatest(addresses.map(all(api)))
+        : combineLatest(
+          addresses.map((accountId): Observable<DerivedBalances> =>
+            api.derive.balances.all(accountId))
+        )
     ).pipe(
       drr()
     );
-  };
 }

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

@@ -3,27 +3,26 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { AccountId, AccountIndex, Address } from '@polkadot/types/interfaces';
+import { DerivedBalances } from '../types';
 
 import { Observable, of } from 'rxjs';
 import { switchMap } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { Vec } from '@polkadot/types';
 
-import { idAndIndex } from '../accounts/idAndIndex';
-import { DerivedBalances } from '../types';
-import { drr } from '../util/drr';
-import { votingBalances } from './votingBalances';
+import { drr } from '../util';
 
 export function votingBalancesNominatorsFor (api: ApiInterfaceRx): (address: AccountId | AccountIndex | Address | string) => Observable<DerivedBalances[]> {
-  return (address: AccountId | AccountIndex | Address | string): Observable<DerivedBalances[]> => {
-    return idAndIndex(api)(address).pipe(
-      switchMap(([accountId]): Observable<AccountId[]> =>
+  return (address: AccountId | AccountIndex | Address | string): Observable<DerivedBalances[]> =>
+    api.derive.accounts.info(address).pipe(
+      switchMap(({ accountId }): Observable<AccountId[]> =>
         accountId
-          ? (api.query.staking.nominatorsFor<Vec<AccountId>>(accountId))
+          ? api.query.staking.nominatorsFor<Vec<AccountId>>(accountId)
           : of([] as AccountId[])
       ),
-      switchMap(votingBalances(api)),
+      switchMap((accounts): Observable<DerivedBalances[]> =>
+        api.derive.balances.votingBalances(accounts)
+      ),
       drr()
     );
-  };
 }

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

@@ -2,13 +2,13 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { BlockNumber } from '@polkadot/types/interfaces';
+import { BlockNumber, Header } from '@polkadot/types/interfaces';
 
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
 /**
  * @name bestNumber
@@ -24,8 +24,8 @@ import { drr } from '../util/drr';
  */
 export function bestNumber (api: ApiInterfaceRx): () => Observable<BlockNumber> {
   return (): Observable<BlockNumber> =>
-    api.rpc.chain.subscribeNewHeads().pipe(
-      map((header): BlockNumber => header.number.unwrap()),
+    api.derive.chain.subscribeNewHeads().pipe(
+      map((header: Header): BlockNumber => header.number.unwrap()),
       drr()
     );
 }

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

@@ -8,7 +8,7 @@ import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
 /**
  * @name bestNumberFinalized

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

@@ -9,9 +9,7 @@ import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { createType } from '@polkadot/types';
 
-import { drr } from '../util/drr';
-import { bestNumber } from './bestNumber';
-import { bestNumberFinalized } from './bestNumberFinalized';
+import { drr } from '../util';
 
 /**
  * @name bestNumberLag
@@ -29,8 +27,8 @@ import { bestNumberFinalized } from './bestNumberFinalized';
 export function bestNumberLag (api: ApiInterfaceRx): () => Observable<BlockNumber> {
   return (): Observable<BlockNumber> =>
     combineLatest([
-      bestNumber(api)(),
-      bestNumberFinalized(api)()
+      api.derive.chain.bestNumber(),
+      api.derive.chain.bestNumberFinalized()
     ]).pipe(
       map(([bestNumber, bestNumberFinalized]): BlockNumber =>
         createType('BlockNumber', bestNumber.sub(bestNumberFinalized))

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

@@ -2,13 +2,16 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { Observable, combineLatest, of } from 'rxjs';
-import { catchError, map } from 'rxjs/operators';
+import { AccountId } from '@polkadot/types/interfaces';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 
+import { Observable, combineLatest, of } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+
+import { Vec } from '@polkadot/types';
+
 import { HeaderExtended } from '../type';
-import { drr } from '../util/drr';
-import { HeaderAndValidators } from './subscribeNewHeads';
+import { drr } from '../util';
 
 /**
  * @name bestNumberFinalized
@@ -26,12 +29,12 @@ import { HeaderAndValidators } from './subscribeNewHeads';
  */
 export function getHeader (api: ApiInterfaceRx): (hash: Uint8Array | string) => Observable<HeaderExtended | undefined> {
   return (hash: Uint8Array | string): Observable<HeaderExtended | undefined> =>
-    (combineLatest([
+    combineLatest([
       api.rpc.chain.getHeader(hash),
       api.query.session
-        ? api.query.session.validators.at(hash)
+        ? api.query.session.validators.at(hash) as Observable<Vec<AccountId>>
         : of([])
-    ]) as Observable<HeaderAndValidators>).pipe(
+    ]).pipe(
       map(([header, validators]): HeaderExtended =>
         new HeaderExtended(header, validators)
       ),

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

@@ -3,15 +3,12 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { AccountId, Header } from '@polkadot/types/interfaces';
 
-import { Observable, combineLatest, of } from 'rxjs';
-import { map, switchMap } from 'rxjs/operators';
+import { Observable, combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
 
 import { HeaderExtended } from '../type';
-import { drr } from '../util/drr';
-
-export type HeaderAndValidators = [Header, AccountId[]];
+import { drr } from '../util';
 
 /**
  * @name subscribeNewHeads
@@ -28,19 +25,11 @@ export type HeaderAndValidators = [Header, AccountId[]];
  */
 export function subscribeNewHeads (api: ApiInterfaceRx): () => Observable<HeaderExtended> {
   return (): Observable<HeaderExtended> =>
-    api.rpc.chain.subscribeNewHeads().pipe(
-      switchMap((header: Header): Observable<HeaderAndValidators> =>
-        (combineLatest([
-          of(header),
-          // theoretically we could combine at the first call with session.validators(), however
-          // we make 100% sure we actually get the validators at a specific block so when these
-          // change at an era boundary, we have the previous values to ensure our indexes are correct
-          api.query.session
-            ? api.query.session.validators.at(header.hash)
-            : of([])
-        ]) as Observable<HeaderAndValidators>)
-      ),
-      map(([header, validators]): HeaderExtended =>
+    combineLatest([
+      api.rpc.chain.subscribeNewHeads(),
+      api.derive.staking.validators()
+    ]).pipe(
+      map(([header, { validators }]): HeaderExtended =>
         new HeaderExtended(header, validators)
       ),
       drr()

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

@@ -9,7 +9,7 @@ import BN from 'bn.js';
 import { Observable, of } from 'rxjs';
 import { map } from 'rxjs/operators';
 
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
 type ResultV2 = [BN, BN, BN, BN, BN, BN, BN, BN, BN, BN];
 

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

@@ -12,7 +12,7 @@ import { Option } from '@polkadot/types';
 import { isNull } from '@polkadot/util';
 
 import { ReferendumInfoExtended } from '../type';
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
 export function constructInfo (index: BN | number, optionInfo?: Option<ReferendumInfo>): Option<ReferendumInfoExtended> {
   const info = optionInfo
@@ -28,13 +28,11 @@ export function constructInfo (index: BN | number, optionInfo?: Option<Referendu
 }
 
 export function referendumInfo (api: ApiInterfaceRx): (index: BN | number) => Observable<Option<ReferendumInfoExtended>> {
-  return (index: BN | number): Observable<Option<ReferendumInfoExtended>> => {
-    return (api.query.democracy.referendumInfoOf<Option<ReferendumInfo>>(index))
-      .pipe(
-        map((optionInfo): Option<ReferendumInfoExtended> =>
-          constructInfo(index, optionInfo)
-        ),
-        drr()
-      );
-  };
+  return (index: BN | number): Observable<Option<ReferendumInfoExtended>> =>
+    api.query.democracy.referendumInfoOf<Option<ReferendumInfo>>(index).pipe(
+      map((optionInfo): Option<ReferendumInfoExtended> =>
+        constructInfo(index, optionInfo)
+      ),
+      drr()
+    );
 }

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

@@ -11,12 +11,12 @@ import { ApiInterfaceRx } from '@polkadot/api/types';
 import { Option, Vec } from '@polkadot/types';
 
 import { ReferendumInfoExtended } from '../type';
-import { drr } from '../util/drr';
+import { drr } from '../util';
 import { constructInfo } from './referendumInfo';
 
 export function referendumInfos (api: ApiInterfaceRx): (ids?: (BN | number)[]) => Observable<Option<ReferendumInfoExtended>[]> {
-  return (ids: (BN | number)[] = []): Observable<Option<ReferendumInfoExtended>[]> => {
-    return (
+  return (ids: (BN | number)[] = []): Observable<Option<ReferendumInfoExtended>[]> =>
+    (
       !ids || !ids.length
         ? of([] as Option<ReferendumInfo>[])
         : api.query.democracy.referendumInfoOf.multi(ids) as Observable<Vec<Option<ReferendumInfo>>>
@@ -28,5 +28,4 @@ export function referendumInfos (api: ApiInterfaceRx): (ids?: (BN | number)[]) =
       ),
       drr()
     );
-  };
 }

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

@@ -11,18 +11,16 @@ import { ApiInterfaceRx } from '@polkadot/api/types';
 import { Vec, createType } from '@polkadot/types';
 
 import { DerivedBalances, DerivedReferendumVote } from '../types';
-import { drr } from '../util/drr';
-import { votes } from './votes';
-import { votingBalances } from '../balances/votingBalances';
+import { drr } from '../util';
 
 export function referendumVotesFor (api: ApiInterfaceRx): (referendumId: BN | number) => Observable<DerivedReferendumVote[]> {
   return (referendumId: BN | number): Observable<DerivedReferendumVote[]> =>
-    (api.query.democracy.votersFor<Vec<AccountId>>(referendumId)).pipe(
+    api.query.democracy.votersFor<Vec<AccountId>>(referendumId).pipe(
       switchMap((votersFor): Observable<[Vec<AccountId>, Vote[], DerivedBalances[]]> =>
         combineLatest([
           of(votersFor),
-          votes(api)(referendumId as BN, votersFor),
-          votingBalances(api)(votersFor)
+          api.derive.democracy.votes(referendumId as BN, votersFor),
+          api.derive.balances.votingBalances(votersFor)
         ])
       ),
       map(([votersFor, votes, balances]): DerivedReferendumVote[] =>

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

@@ -11,18 +11,17 @@ import { ApiInterfaceRx } from '@polkadot/api/types';
 import { Option } from '@polkadot/types';
 
 import { ReferendumInfoExtended } from '../type';
-import { drr } from '../util/drr';
-import { referendumInfos } from './referendumInfos';
+import { drr } from '../util';
 
 export function referendums (api: ApiInterfaceRx): () => Observable<Option<ReferendumInfoExtended>[]> {
   return (): Observable<Option<ReferendumInfoExtended>[]> =>
-    (api.queryMulti([
+    api.queryMulti<[ReferendumIndex, ReferendumIndex]>([
       api.query.democracy.nextTally,
       api.query.democracy.referendumCount
-    ]) as Observable<[ReferendumIndex?, ReferendumIndex?]>).pipe(
+    ]).pipe(
       switchMap(([nextTally, referendumCount]): Observable<Option<ReferendumInfoExtended>[]> =>
         referendumCount && nextTally && referendumCount.gt(nextTally) && referendumCount.gtn(0)
-          ? referendumInfos(api)(
+          ? api.derive.democracy.referendumInfos(
             [...Array(referendumCount.sub(nextTally).toNumber())].map((_, i): BN =>
               nextTally.addn(i)
             )

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

@@ -7,20 +7,18 @@ import { AccountId, Vote } from '@polkadot/types/interfaces';
 import BN from 'bn.js';
 import { Observable, of } from 'rxjs';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { Vec } from '@polkadot/types';
 
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
 export function votes (api: ApiInterfaceRx): (referendumId: BN, accountIds?: AccountId[]) => Observable<Vote[]> {
-  return (referendumId: BN, accountIds: AccountId[] = []): Observable<Vote[]> => {
-    return ((
+  return (referendumId: BN, accountIds: AccountId[] = []): Observable<Vote[]> =>
+    (
       !accountIds || !accountIds.length
-        ? of([])
-        : api.query.democracy.voteOf.multi(
+        ? of([] as Vote[])
+        : api.query.democracy.voteOf.multi<Vote>(
           accountIds.map((accountId): [BN, AccountId] =>
             [referendumId, accountId]
           )
         )
-    ) as Observable<Vec<Vote>>).pipe(drr());
-  };
+    ).pipe(drr());
 }

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

@@ -9,7 +9,7 @@ import { Observable } from 'rxjs';
 import { Vec } from '@polkadot/types';
 import { switchMap, map } from 'rxjs/operators';
 import { approvalFlagsToBools } from '../util/approvalFlagsToBools';
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
 /**
  * @name approvalsOf

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

@@ -11,7 +11,7 @@ import { ApiInterfaceRx } from '@polkadot/api/types';
 import { Vec } from '@polkadot/types';
 
 import { approvalFlagsToBools } from '../util/approvalFlagsToBools';
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
 /**
  * @name approvalsOfAt

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

@@ -2,27 +2,81 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { AccountId, BlockNumber, SetIndex, VoteIndex } from '@polkadot/types/interfaces';
+import { AccountId, Balance, BlockNumber, SetIndex, VoteIndex } from '@polkadot/types/interfaces';
+import { Codec } from '@polkadot/types/types';
 
-import BN from 'bn.js';
-import { Observable } from 'rxjs';
+import { Observable, combineLatest } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
+import { createType, Vec, u32 } from '@polkadot/types';
 
 import { DerivedElectionsInfo } from '../types';
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
-function query (api: ApiInterfaceRx): Observable<[[AccountId, BlockNumber][], AccountId[], BN, BN, SetIndex, BlockNumber, VoteIndex, SetIndex]> {
-  return api.queryMulti([
-    api.query.elections.members,
-    api.query.elections.candidates,
-    api.query.elections.candidateCount,
-    api.query.elections.desiredSeats,
-    api.query.elections.nextVoterSet,
-    api.query.elections.termDuration,
-    api.query.elections.voteCount,
-    api.query.elections.voterCount
-  ]) as any;
+type ResultElectionsInner = [u32, u32, Vec<[AccountId, BlockNumber] & Codec>, SetIndex, BlockNumber, VoteIndex, SetIndex];
+type ResultElections = [Vec<AccountId>, ResultElectionsInner];
+
+function deriveElections ([candidates, [candidateCount, desiredSeats, members, nextVoterSet, termDuration, voteCount, voterCount]]: ResultElections): DerivedElectionsInfo {
+  return {
+    candidates,
+    candidateCount,
+    desiredSeats,
+    nextVoterSet,
+    members: members.map(([accountId]): [AccountId, Balance] => [accountId, createType('Balance')]),
+    runnersUp: [],
+    termDuration,
+    voteCount,
+    voterCount
+  };
+}
+
+function queryElections (api: ApiInterfaceRx): Observable<DerivedElectionsInfo> {
+  // NOTE We have an issue where candidates can return `null` for an empty array
+  return combineLatest([
+    api.query.elections.candidates<Vec<AccountId>>(),
+    api.queryMulti<ResultElectionsInner>([
+      api.query.elections.candidateCount,
+      api.query.elections.desiredSeats,
+      api.query.elections.members,
+      api.query.elections.nextVoterSet,
+      api.query.elections.termDuration,
+      api.query.elections.voteCount,
+      api.query.elections.voterCount
+    ])
+  ]).pipe(map(deriveElections));
+}
+
+function derivePhragmen (candidates: AccountId[], members: [AccountId, Balance][], runnersUp: [AccountId, Balance][], candidacyBond: Balance, desiredSeats: u32, termDuration: BlockNumber, votingBond: Balance): DerivedElectionsInfo {
+  return {
+    candidates,
+    candidateCount: createType('u32', candidates.length),
+    candidacyBond,
+    desiredSeats,
+    members,
+    runnersUp,
+    termDuration,
+    votingBond
+  };
+}
+
+function queryPhragmen (api: ApiInterfaceRx): Observable<DerivedElectionsInfo> {
+  // NOTE We have an issue where candidates can return `null` for an empty array, hence
+  // we are not using multi queries here, so empty array is empty (instead of space-filled)
+  return combineLatest([
+    api.query.electionsPhragmen.candidates<Vec<AccountId>>(),
+    api.query.electionsPhragmen.members<Vec<[AccountId, Balance] & Codec>>(),
+    api.query.electionsPhragmen.runnersUp<Vec<[AccountId, Balance] & Codec>>()
+  ]).pipe(
+    map(([candidates, members, runnersUp]): DerivedElectionsInfo => derivePhragmen(
+      candidates,
+      members,
+      runnersUp,
+      api.consts.electionsPhragmen.candidacyBond as Balance,
+      api.consts.electionsPhragmen.desiredMembers as u32,
+      api.consts.electionsPhragmen.termDuration as BlockNumber,
+      api.consts.electionsPhragmen.votingBond as Balance
+    ))
+  );
 }
 
 /**
@@ -33,31 +87,16 @@ function query (api: ApiInterfaceRx): Observable<[[AccountId, BlockNumber][], Ac
  * <BR>
  *
  * ```javascript
- * api.derive.elections.info(([members, candidates]) => {
+ * api.derive.elections.info(({ members, candidates }) => {
  *   console.log(`There are currently ${members.length} council members and ${candidates.length} prospective council candidates.`);
  * });
  * ```
  */
 export function info (api: ApiInterfaceRx): () => Observable<DerivedElectionsInfo> {
-  return (): Observable<DerivedElectionsInfo> => {
-    return query(api).pipe(
-      map(([members, candidates, candidateCount, desiredSeats, nextVoterSet, termDuration, voteCount, voterCount]): DerivedElectionsInfo => ({
-        members: members.reduce(
-          (record: Record<string, BlockNumber>, [accountId, blockNumber]): Record<string, BlockNumber> => {
-            record[accountId.toString()] = blockNumber;
-            return record;
-          },
-          {}
-        ),
-        candidates,
-        candidateCount,
-        desiredSeats,
-        nextVoterSet,
-        termDuration,
-        voteCount,
-        voterCount
-      } as unknown as DerivedElectionsInfo)),
-      drr()
-    );
-  };
+  const query = api.query.electionsPhragmen
+    ? queryPhragmen
+    : queryElections;
+
+  return (): Observable<DerivedElectionsInfo> =>
+    query(api).pipe(drr());
 }

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

@@ -10,7 +10,8 @@ import { DerivedVoterPositions } from '../types';
 import BN from 'bn.js';
 import { of, combineLatest, Observable } from 'rxjs';
 import { switchMap, map } from 'rxjs/operators';
-import { drr } from '../util/drr';
+
+import { drr } from '../util';
 
 /**
  * @name voterPositions
@@ -34,6 +35,7 @@ export function voterPositions (api: ApiInterfaceRx): () => Observable<DerivedVo
       )),
       map((result: [BN, Vec<Option<AccountId>>[]]): DerivedVoterPositions => {
         const [setSize, voters] = result;
+
         return voters.reduce((result: DerivedVoterPositions, vec, setIndex): DerivedVoterPositions => {
           vec.forEach((e, index): void => {
             // re-create the index based on position 0 is [0][0] and likewise

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

@@ -10,8 +10,7 @@ import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { createType, Vec } from '@polkadot/types';
 
-import { drr } from '../util/drr';
-import { voterPositions } from './voterPositions';
+import { drr } from '../util';
 
 /**
  * @name voters
@@ -27,15 +26,14 @@ import { voterPositions } from './voterPositions';
  */
 export function voters (api: ApiInterfaceRx): () => Observable<Vec<AccountId>> {
   return (): Observable<Vec<AccountId>> =>
-    voterPositions(api)().pipe(
-      map(
-        (voterPositions: DerivedVoterPositions): Vec<AccountId> =>
-          createType(
-            'Vec<AccountId>',
-            Object.entries(voterPositions)
-              .sort((a, b): 0 | 1 | -1 => a[1].globalIndex.cmp(b[1].globalIndex))
-              .map(([accountId]): AccountId => createType('AccountId', accountId))
-          )
+    api.derive.elections.voterPositions().pipe(
+      map((voterPositions: DerivedVoterPositions): Vec<AccountId> =>
+        createType(
+          'Vec<AccountId>',
+          Object.entries(voterPositions)
+            .sort((a, b): number => a[1].globalIndex.cmp(b[1].globalIndex))
+            .map(([accountId]): AccountId => createType('AccountId', accountId))
+        )
       ),
       drr()
     );

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

@@ -3,36 +3,40 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { AccountId, SessionIndex } from '@polkadot/types/interfaces';
+import { DerivedHeartbeats } from '../types';
 
-import { of, Observable } from 'rxjs';
+import { of, Observable, combineLatest } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { Bytes, Vec } from '@polkadot/types';
+import { Bytes, Option, u32 } from '@polkadot/types';
 
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
 /**
  * @description Return a boolean array indicating whether the passed accounts had received heartbeats in the current session
  */
-export function receivedHeartbeats (api: ApiInterfaceRx): (addresses: (AccountId | string)[]) => Observable<boolean[]> {
-  return (addresses: (AccountId | string)[]): Observable<boolean[]> => {
-    return api.query.imOnline && api.query.imOnline.receivedHeartbeats
-      ? api.queryMulti<[SessionIndex, Vec<AccountId>]>([
-        api.query.session.currentIndex,
-        api.query.imOnline.keys
-      ]).pipe(
-        switchMap(([currentIndex, keys]): Observable<Bytes[]> =>
-          api.query.imOnline.receivedHeartbeats.multi(
-            addresses.map((address): [SessionIndex, number] =>
-              [currentIndex, keys.indexOf(address)]
-            )
-          )
+export function receivedHeartbeats (api: ApiInterfaceRx): () => Observable<DerivedHeartbeats> {
+  return (): Observable<DerivedHeartbeats> =>
+    api.query.imOnline?.receivedHeartbeats && api.query.imOnline.authoredBlocks
+      ? api.derive.staking.overview().pipe(
+        switchMap(({ currentIndex, validators }): Observable<[AccountId[], Option<Bytes>[], u32[]]> =>
+          combineLatest([
+            of(validators),
+            api.query.imOnline.receivedHeartbeats.multi<Option<Bytes>>(validators.map((_address, index): [SessionIndex, number] => [currentIndex, index])),
+            api.query.imOnline.authoredBlocks.multi<u32>(validators.map((address): [SessionIndex, AccountId] => [currentIndex, address]))
+          ])
         ),
-        map((heartbeats): boolean[] =>
-          heartbeats.map((heartbeat): boolean => !heartbeat.isEmpty)
+        map(([validators, heartbeats, numBlocks]): DerivedHeartbeats =>
+          validators.reduce((result: DerivedHeartbeats, validator, index): DerivedHeartbeats => ({
+            ...result,
+            [validator.toString()]: {
+              blockCount: numBlocks[index],
+              hasMessage: !heartbeats[index].isEmpty,
+              isOnline: !heartbeats[index].isEmpty || numBlocks[index].gtn(0)
+            }
+          }), {})
         ),
         drr()
       )
-      : of([...new Array(addresses.length).keys()].map((): boolean => false));
-  };
+      : of({});
 }

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

@@ -2,18 +2,19 @@
 // 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';
+import { BlockNumber } from '@polkadot/types/interfaces';
+import { DerivedSessionInfo } from '../types';
+
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 
-import { drr } from '../util/drr';
-import { info } from './info';
+import { drr } from '../util';
 
-export function eraLength (api: ApiInterfaceRx): () => Observable<BN> {
-  return (): Observable<BN> =>
-    info(api)().pipe(
-      map(({ eraLength }): BN => eraLength),
+export function eraLength (api: ApiInterfaceRx): () => Observable<BlockNumber> {
+  return (): Observable<BlockNumber> =>
+    api.derive.session.info().pipe(
+      map(({ eraLength }: DerivedSessionInfo): BlockNumber => eraLength),
       drr()
     );
 }

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

@@ -2,18 +2,19 @@
 // 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';
+import { BlockNumber } from '@polkadot/types/interfaces';
+import { DerivedSessionInfo } from '../types';
+
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 
-import { drr } from '../util/drr';
-import { info } from './info';
+import { drr } from '../util';
 
-export function eraProgress (api: ApiInterfaceRx): () => Observable<BN> {
-  return (): Observable<BN> =>
-    info(api)().pipe(
-      map(({ eraProgress }): BN => eraProgress),
+export function eraProgress (api: ApiInterfaceRx): () => Observable<BlockNumber> {
+  return (): Observable<BlockNumber> =>
+    api.derive.session.info().pipe(
+      map(({ eraProgress }: DerivedSessionInfo): BlockNumber => eraProgress),
       drr()
     );
 }

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

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

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

@@ -0,0 +1,27 @@
+// Copyright 2017-2019 @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, SessionIndex } from '@polkadot/types/interfaces';
+import { DeriveSessionIndexes } from '../types';
+
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { u32 } from '@polkadot/types';
+
+import { drr } from '../util';
+
+export function indexes (api: ApiInterfaceRx): () => Observable<DeriveSessionIndexes> {
+  return (): Observable<DeriveSessionIndexes> =>
+    api.queryMulti<[SessionIndex, EraIndex, u32]>([
+      api.query.session.currentIndex,
+      api.query.staking.currentEra,
+      api.query.staking.validatorCount
+    ]).pipe(
+      map(([currentIndex, currentEra, validatorCount]): DeriveSessionIndexes => ({
+        currentIndex, currentEra, validatorCount
+      })),
+      drr()
+    );
+}

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

@@ -2,135 +2,131 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { BlockNumber, EraIndex, SessionIndex } from '@polkadot/types/interfaces';
-import { DerivedSessionInfo } from '../types';
+import { BlockNumber, SessionIndex } from '@polkadot/types/interfaces';
+import { DerivedSessionInfo, DeriveSessionIndexes } from '../types';
 
-import BN from 'bn.js';
-import { Observable, combineLatest, of } from 'rxjs';
+import { Observable, combineLatest } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { Option, u64 } from '@polkadot/types';
+import { Option, u64, createType } from '@polkadot/types';
 
-import { drr } from '../util/drr';
-import { bestNumber } from '../chain';
+import { drr } from '../util';
 
-type Result0to94 = [BlockNumber, [SessionIndex, Option<BlockNumber>, BN, BN, SessionIndex]];
-type Result = [[boolean, boolean, u64, SessionIndex], [u64, u64, u64], [SessionIndex, EraIndex]];
+type ResultV1Session = [Option<BlockNumber>, BlockNumber, BlockNumber, SessionIndex];
+type ResultV1 = [BlockNumber, DeriveSessionIndexes, ResultV1Session];
 
-const ZERO = new BN(0);
-const ONE = new BN(1);
+type ResultSlots = [u64, u64, u64, SessionIndex];
+type ResultType = [boolean, u64, SessionIndex];
+type Result = [ResultType, DeriveSessionIndexes, ResultSlots];
 
 // internal helper to just split the logic - take all inputs, do the calculations and combine
-function createDerived0to94 ([bestNumber, [currentIndex, _lastLengthChange, sessionLength, lastEraLengthChange, sessionsPerEra]]: Result0to94): DerivedSessionInfo {
-  const lastLengthChange = _lastLengthChange
-    ? _lastLengthChange.unwrapOr(ZERO)
-    : ZERO;
+function createDerivedV1 ([bestNumber, { currentIndex, validatorCount }, [_lastLengthChange, sessionLength, lastEraLengthChange, sessionsPerEra]]: ResultV1): DerivedSessionInfo {
+  const lastLengthChange = _lastLengthChange?.unwrapOr(null) || createType('BlockNumber');
   const sessionProgress = bestNumber
     .sub(lastLengthChange)
     .add(sessionLength)
     .mod(sessionLength);
-  const currentEra = (currentIndex)
+  const currentEra = currentIndex
     .sub(lastEraLengthChange)
     .mod(sessionsPerEra);
+  const eraProgress = currentEra
+    .mul(sessionLength)
+    .add(sessionProgress);
 
   return {
-    currentEra,
+    currentEra: createType('EraIndex', currentEra),
     currentIndex,
-    eraLength: sessionLength.mul(sessionsPerEra),
-    eraProgress: currentEra
-      .mul(sessionLength)
-      .add(sessionProgress),
+    eraLength: createType('BlockNumber', sessionLength.mul(sessionsPerEra)),
+    eraProgress: createType('BlockNumber', eraProgress),
     isEpoch: false,
     lastEraLengthChange,
     lastLengthChange,
     sessionLength,
     sessionsPerEra,
-    sessionProgress
-  } as unknown as DerivedSessionInfo;
+    sessionProgress: createType('BlockNumber', sessionProgress),
+    validatorCount
+  };
 }
 
-function createDerived ([[hasBabe, isGenesisSlot, epochDuration, sessionsPerEra], [currentSlot, epochIndex, epochOrGenesisStartSlot], [currentIndex, currentEra]]: Result): DerivedSessionInfo {
-  const epochStartSlot = isGenesisSlot
-    ? epochIndex
-      .mul(epochDuration)
-      .add(epochOrGenesisStartSlot)
-    : epochOrGenesisStartSlot;
+function createDerivedLatest ([[hasBabe, epochDuration, sessionsPerEra], { currentIndex, currentEra, validatorCount }, [currentSlot, epochIndex, epochOrGenesisStartSlot, currentEraStartSessionIndex]]: Result): DerivedSessionInfo {
+  const epochStartSlot = epochIndex.mul(epochDuration).add(epochOrGenesisStartSlot);
   const sessionProgress = currentSlot.sub(epochStartSlot);
-  const eraProgress = epochIndex
-    .mod(sessionsPerEra)
-    .mul(epochDuration)
-    .add(sessionProgress);
+  const eraProgress = currentIndex.sub(currentEraStartSessionIndex).add(sessionProgress);
+
+  // console.log(sessionProgress);
 
   return {
     currentEra,
     currentIndex,
-    eraLength: sessionsPerEra.mul(epochDuration),
-    eraProgress,
+    eraLength: createType('BlockNumber', sessionsPerEra.mul(epochDuration)),
+    eraProgress: createType('BlockNumber', eraProgress),
     isEpoch: hasBabe,
-    lastEraLengthChange: ZERO,
-    lastLengthChange: epochStartSlot,
+    lastEraLengthChange: createType('BlockNumber'),
+    lastLengthChange: createType('BlockNumber', epochStartSlot),
     sessionLength: epochDuration,
     sessionsPerEra,
-    sessionProgress: sessionProgress
-  } as unknown as DerivedSessionInfo;
+    sessionProgress: createType('BlockNumber', sessionProgress),
+    validatorCount
+  };
+}
+
+function infoV1 (api: ApiInterfaceRx): Observable<DerivedSessionInfo> {
+  return combineLatest([
+    api.derive.chain.bestNumber(),
+    api.derive.session.indexes(),
+    api.queryMulti<ResultV1Session>([
+      api.query.session.lastLengthChange,
+      api.query.session.sessionLength,
+      api.query.staking.lastEraLengthChange,
+      api.query.staking.sessionsPerEra
+    ])
+  ]).pipe(
+    map(createDerivedV1)
+  );
+}
+
+function infoLatestAura (api: ApiInterfaceRx): Observable<DerivedSessionInfo> {
+  return api.derive.session.indexes().pipe(
+    map((indexes): DerivedSessionInfo =>
+      createDerivedLatest([
+        [false, createType('u64', 1), api.consts.staking.sessionsPerEra as SessionIndex],
+        indexes,
+        [createType('u64', 1), createType('u64', 1), createType('u64', 1), createType('SessionIndex', 1)]
+      ])
+    )
+  );
+}
+
+function infoLatestBabe (api: ApiInterfaceRx): Observable<DerivedSessionInfo> {
+  return combineLatest([
+    api.derive.session.indexes(),
+    api.queryMulti<ResultSlots>([
+      api.query.babe.currentSlot,
+      api.query.babe.epochIndex,
+      api.query.babe.genesisSlot,
+      api.query.staking.currentEraStartSessionIndex
+    ])
+  ]).pipe(
+    map(([indexes, slots]: [DeriveSessionIndexes, ResultSlots]): DerivedSessionInfo =>
+      createDerivedLatest([
+        [true, api.consts.babe.epochDuration as u64, api.consts.staking.sessionsPerEra as SessionIndex],
+        indexes,
+        slots
+      ])
+    )
+  );
 }
 
 /**
  * @description Retrieves all the session and era info and calculates specific values on it as the length of the session and eras
  */
 export function info (api: ApiInterfaceRx): () => Observable<DerivedSessionInfo> {
-  const hasBabe = !!api.consts.babe;
+  const query = api.consts.staking
+    ? api.consts.babe
+      ? infoLatestBabe // 2.x with Babe
+      : infoLatestAura // 2.x with Aura (not all info there)
+    : infoV1;
 
-  return (): Observable<DerivedSessionInfo> => {
-    // With substrate `spec_version 94`, the era and session has been explicitly exposed as `parameter_types`.
-    // pre-94 we had more info and needed to calculate (handle old/Alex first)
-    // https://github.com/paritytech/substrate/commit/dbf322620948935d2bbae214504e6c668c3073ed#diff-c29f42d6b931fa93ba038dbbbfec3055
-    return api.query.session.lastLengthChange
-      ? (
-        combineLatest([
-          bestNumber(api)(),
-          api.queryMulti([
-            api.query.session.currentIndex,
-            api.query.session.lastLengthChange,
-            api.query.session.sessionLength,
-            api.query.staking.lastEraLengthChange,
-            api.query.staking.sessionsPerEra
-          ])
-        ]) as any as Observable<Result0to94>
-      ).pipe(
-        map(createDerived0to94),
-        drr()
-      )
-      : (
-        combineLatest([
-          // sessionsPerEra:
-          // substrate spec_version >= 94 : get from parameter_types exposed as api.consts
-          // https://github.com/paritytech/substrate/pull/2802/files#diff-5e5e1c3aec9ddfde0a9054d062ab3db9R156
-          of([
-            hasBabe,
-            hasBabe && !!api.query.babe.genesisSlot,
-            hasBabe
-              ? api.consts.babe.epochDuration
-              : ONE,
-            api.consts.staking.sessionsPerEra
-          ]),
-          hasBabe
-            ? api.queryMulti([
-              api.query.babe.currentSlot,
-              api.query.babe.epochIndex,
-              api.query.babe.genesisSlot
-                ? api.query.babe.genesisSlot
-                : api.query.babe.epochStartSlot
-            ])
-            : of([ONE, ONE, ONE]),
-          api.queryMulti([
-            api.query.session.currentIndex,
-            api.query.staking.currentEra
-          ])
-        ]) as unknown as Observable<Result>
-      ).pipe(
-        map(createDerived),
-        drr()
-      );
-  };
+  return (): Observable<DerivedSessionInfo> =>
+    query(api).pipe(drr());
 }

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

@@ -2,18 +2,19 @@
 // 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';
+import { BlockNumber } from '@polkadot/types/interfaces';
+import { DerivedSessionInfo } from '../types';
+
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 
-import { drr } from '../util/drr';
-import { info } from './info';
+import { drr } from '../util';
 
-export function sessionProgress (api: ApiInterfaceRx): () => Observable<BN> {
-  return (): Observable<BN> =>
-    info(api)().pipe(
-      map(({ sessionProgress }): BN => sessionProgress),
+export function sessionProgress (api: ApiInterfaceRx): () => Observable<BlockNumber> {
+  return (): Observable<BlockNumber> =>
+    api.derive.session.info().pipe(
+      map(({ sessionProgress }: DerivedSessionInfo): BlockNumber => sessionProgress),
       drr()
     );
 }

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

@@ -2,31 +2,31 @@
 // 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 } from '@polkadot/types/interfaces';
 import { Codec } from '@polkadot/types/types';
 
 import { Observable, combineLatest, of } from 'rxjs';
 import { switchMap } from 'rxjs/operators';
-import { ApiInterfaceRx } from '@polkadot/api/types';
 import { Option } from '@polkadot/types';
 
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
 /**
  * @description From the list of stash accounts, retrieve the list of controllers
  */
 export function controllers (api: ApiInterfaceRx): () => Observable<[AccountId[], Option<AccountId>[]]> {
   return (): Observable<[AccountId[], Option<AccountId>[]]> =>
-    api.query.staking
-      .validators<[AccountId[]] & Codec>()
-      .pipe(
-        switchMap(([stashIds]): Observable<[AccountId[], Option<AccountId>[]]> =>
-          combineLatest([
-            of(stashIds),
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-            api.query.staking.bonded.multi(stashIds) as Observable<Option<AccountId>[]>
-          ])
-        ),
-        drr()
-      );
+    api.query.staking.validators<[AccountId[]] & Codec>().pipe(
+      switchMap(([stashIds]): Observable<[AccountId[], Option<AccountId>[]]> =>
+        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)
+        ])
+      ),
+      drr()
+    );
 }

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

@@ -4,4 +4,6 @@
 
 export * from './controllers';
 export * from './info';
+export * from './overview';
 export * from './recentlyOffline';
+export * from './validators';

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

@@ -2,13 +2,11 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { AccountId, BlockNumber } from '@polkadot/types/interfaces/runtime';
-import { Keys } from '@polkadot/types/interfaces/session';
-import { Exposure, RewardDestination, StakingLedger, UnlockChunk, ValidatorPrefs } from '@polkadot/types/interfaces/staking';
+import { AccountId, Balance, BlockNumber, Exposure, Keys, RewardDestination, StakingLedger, UnlockChunk, ValidatorPrefs } from '@polkadot/types/interfaces';
 import { Codec } from '@polkadot/types/types';
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { DerivedStaking, DerivedUnlocking } from '../types';
+import { DerivedRecentlyOffline, DerivedStaking, DerivedUnlocking } from '../types';
 
 import BN from 'bn.js';
 import { combineLatest, Observable, of } from 'rxjs';
@@ -17,14 +15,24 @@ import { createType, Option, Vec } from '@polkadot/types';
 
 import { isUndefined } from '@polkadot/util';
 
-import { bestNumber } from '../chain/bestNumber';
-import { eraLength } from '../session/eraLength';
-import { recentlyOffline } from './recentlyOffline';
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
-type MultiResult = [Option<Keys>, [
-  Option<AccountId> | Vec<[AccountId, Keys] & Codec>, Option<StakingLedger>, [AccountId[]], RewardDestination, Exposure, [ValidatorPrefs]
-]];
+interface ParseInput {
+  accountId: AccountId;
+  bestNumber: BlockNumber;
+  controllerId: AccountId;
+  eraLength: BlockNumber;
+  recentlyOffline?: DerivedRecentlyOffline;
+  nominators: AccountId[];
+  rewardDestination: RewardDestination;
+  queuedKeys?: [AccountId, Keys][];
+  stakers: Exposure;
+  stakingLedger: Option<StakingLedger>;
+  stashId: AccountId;
+  validatorPrefs: ValidatorPrefs;
+  nextKeys?: Option<Keys>;
+  nextKeyFor?: Option<AccountId>;
+}
 
 // groups the supplied chunks by era, i.e. { [era]: BN(total of values) }
 function groupByEra (list: UnlockChunk[]): Record<string, BN> {
@@ -40,15 +48,16 @@ function groupByEra (list: UnlockChunk[]): Record<string, BN> {
 }
 
 // calculate the remining blocks in a specific unlock era
-function remainingBlocks (era: BN, eraLength: BN, bestNumber: BlockNumber): BN {
+function remainingBlocks (era: BN, eraLength: BN, bestNumber: BlockNumber): BlockNumber {
   const remaining = eraLength.mul(era).sub(bestNumber);
 
-  return remaining.lten(0)
+  return createType('BlockNumber', remaining.lten(0)
     ? new BN(0)
-    : remaining;
+    : remaining
+  );
 }
 
-function calculateUnlocking (stakingLedger: StakingLedger | undefined, eraLength: BN, bestNumber: BlockNumber): DerivedUnlocking | undefined {
+function calculateUnlocking (stakingLedger: StakingLedger | undefined, eraLength: BN, bestNumber: BlockNumber): DerivedUnlocking[] | undefined {
   if (isUndefined(stakingLedger)) {
     return undefined;
   }
@@ -63,27 +72,27 @@ function calculateUnlocking (stakingLedger: StakingLedger | undefined, eraLength
 
   // group the Unlockchunks that have the same era and sum their values
   const groupedResult = groupByEra(unlockingChunks);
-  const results = Object.entries(groupedResult).map(([eraString, value]): { value: BN; remainingBlocks: BN } => ({
-    value,
+  const results = Object.entries(groupedResult).map(([eraString, value]): DerivedUnlocking => ({
+    value: createType('Balance', value),
     remainingBlocks: remainingBlocks(createType('BlockNumber', eraString), eraLength, bestNumber)
   }));
 
   return results.length ? results : undefined;
 }
 
-function redeemableSum (stakingLedger: StakingLedger | undefined, eraLength: BN, bestNumber: BlockNumber): BN {
+function redeemableSum (stakingLedger: StakingLedger | undefined, eraLength: BN, bestNumber: BlockNumber): Balance {
   if (isUndefined(stakingLedger)) {
-    return new BN(0);
+    return createType('Balance');
   }
 
-  return stakingLedger.unlocking.reduce((total, { era, value }): BN => {
+  return createType('Balance', stakingLedger.unlocking.reduce((total, { era, value }): BN => {
     return remainingBlocks(era.unwrap(), eraLength, bestNumber).eqn(0)
       ? total.add(value.unwrap())
       : total;
-  }, new BN(0));
+  }, new BN(0)));
 }
 
-function unwrapSessionIds (stashId: AccountId, queuedKeys: Option<AccountId> | Vec<[AccountId, Keys] & Codec>, nextKeys: Option<Keys>): { nextSessionIds: AccountId[]; nextSessionId?: AccountId; sessionIds: AccountId[]; sessionId?: AccountId } {
+function unwrapSessionIds (stashId: AccountId, queuedKeys: Option<AccountId> | [AccountId, Keys][], nextKeys: Option<Keys>): { nextSessionIds: AccountId[]; sessionIds: AccountId[] } {
   // for 2.x we have a Vec<(ValidatorId,Keys)> of the keys
   if (Array.isArray(queuedKeys)) {
     const sessionIds = (queuedKeys.find(([currentId]): boolean =>
@@ -92,9 +101,7 @@ function unwrapSessionIds (stashId: AccountId, queuedKeys: Option<AccountId> | V
     const nextSessionIds = nextKeys.unwrapOr([] as AccountId[]);
 
     return {
-      nextSessionId: nextSessionIds[0],
       nextSessionIds,
-      sessionId: sessionIds[0],
       sessionIds
     };
   }
@@ -105,85 +112,112 @@ function unwrapSessionIds (stashId: AccountId, queuedKeys: Option<AccountId> | V
     : [];
 
   return {
-    nextSessionId: nextSessionIds[0],
     nextSessionIds,
-    sessionId: nextSessionIds[0],
     sessionIds: nextSessionIds
   };
 }
 
-function retrieveMulti (api: ApiInterfaceRx, stashId: AccountId, controllerId: AccountId): Observable<MultiResult> {
+function parseResult ({ accountId, controllerId, stashId, eraLength, bestNumber, recentlyOffline = {}, nextKeyFor = createType('Option<AccountId>', null), queuedKeys, stakingLedger, nominators, rewardDestination, stakers, validatorPrefs, nextKeys = createType('Option<Keys>', null) }: ParseInput): DerivedStaking {
+  const _stakingLedger = stakingLedger.unwrapOr(undefined);
+
+  return {
+    accountId,
+    controllerId,
+    nominators,
+    offline: recentlyOffline[stashId.toString()],
+    redeemable: redeemableSum(_stakingLedger, eraLength, bestNumber),
+    rewardDestination,
+    stakers,
+    stakingLedger: _stakingLedger,
+    stashId,
+    unlocking: calculateUnlocking(_stakingLedger, eraLength, bestNumber),
+    validatorPrefs,
+    ...unwrapSessionIds(stashId, queuedKeys || nextKeyFor, nextKeys)
+  };
+}
+
+type MultiResultV1 = [Option<AccountId>, Option<StakingLedger>, [Vec<AccountId>], RewardDestination, Exposure, [ValidatorPrefs] & Codec];
+
+function retrieveInfoV1 (api: ApiInterfaceRx, accountId: AccountId, stashId: AccountId, controllerId: AccountId): Observable<DerivedStaking> {
   return combineLatest([
-    // TODO We really want this as part of the multi, however can only do that
-    // once we drop substrate 1.x support (nulti requires values for all)
-    api.query.session.nextKeys
-      ? api.query.session.nextKeys<Option<Keys>>(api.consts.session.dedupKeyPrefix, stashId)
-      : of(createType('Option<Keys>', null)),
+    api.derive.chain.bestNumber(),
+    api.derive.session.eraLength(),
+    api.derive.staking.recentlyOffline(),
     api.queryMulti([
-      api.query.session.queuedKeys
-        ? [api.query.session.queuedKeys]
-        : [api.query.session.nextKeyFor, controllerId],
+      [api.query.session.nextKeyFor, controllerId],
       [api.query.staking.ledger, controllerId],
       [api.query.staking.nominators, stashId],
       [api.query.staking.payee, stashId],
       [api.query.staking.stakers, stashId],
       [api.query.staking.validators, stashId]
-    ])
-  ]) as Observable<MultiResult>;
+    ]) as Observable<MultiResultV1>
+  ]).pipe(map(([
+    bestNumber, eraLength, recentlyOffline,
+    [nextKeyFor, stakingLedger, [nominators], rewardDestination, stakers, [validatorPrefs]]
+  ]: [BlockNumber, BlockNumber, DerivedRecentlyOffline, MultiResultV1]): DerivedStaking =>
+    parseResult({
+      accountId, controllerId, stashId, eraLength, bestNumber, recentlyOffline, nextKeyFor, stakingLedger, nominators, rewardDestination, stakers, validatorPrefs
+    })
+  ));
 }
 
-function retrieveInfo (api: ApiInterfaceRx, stashId: AccountId, controllerId: AccountId): Observable<DerivedStaking> {
-  return combineLatest([
-    eraLength(api)(),
-    bestNumber(api)(),
-    recentlyOffline(api)(),
-    retrieveMulti(api, stashId, controllerId)
-  ]).pipe(
-    map(([eraLength, bestNumber, recentlyOffline, [nextKeys, [queuedKeys, _stakingLedger, [nominators], rewardDestination, stakers, [validatorPrefs]]]]): DerivedStaking => {
-      const stakingLedger = _stakingLedger.unwrapOr(undefined);
+type MultiResultV2 = [Option<StakingLedger>, [Vec<AccountId>], RewardDestination, Exposure, [ValidatorPrefs], Option<Keys>];
 
-      return {
-        accountId: stashId,
-        controllerId,
-        nominators,
-        offline: recentlyOffline[stashId.toString()],
-        redeemable: redeemableSum(stakingLedger, eraLength, bestNumber),
-        rewardDestination,
-        stakers,
-        stakingLedger,
-        stashId,
-        unlocking: calculateUnlocking(stakingLedger, eraLength, bestNumber),
-        validatorPrefs,
-        ...unwrapSessionIds(stashId, queuedKeys, nextKeys)
-      };
+function retrieveInfoV2 (api: ApiInterfaceRx, accountId: AccountId, stashId: AccountId, controllerId: AccountId): Observable<DerivedStaking> {
+  return combineLatest([
+    api.derive.chain.bestNumber(),
+    api.derive.session.eraLength(),
+    api.query.session.queuedKeys<Vec<[AccountId, Keys] & Codec>>(),
+    api.queryMulti([
+      [api.query.staking.ledger, controllerId],
+      [api.query.staking.nominators, stashId],
+      [api.query.staking.payee, stashId],
+      [api.query.staking.stakers, stashId],
+      [api.query.staking.validators, stashId],
+      [api.query.session.nextKeys, [api.consts.session.dedupKeyPrefix, stashId]]
+    ]) as Observable<MultiResultV2>
+  ]).pipe(map(([
+    bestNumber, eraLength, queuedKeys,
+    [stakingLedger, [nominators], rewardDestination, stakers, [validatorPrefs], nextKeys]
+  ]: [BlockNumber, BlockNumber, [AccountId, Keys][], MultiResultV2]): DerivedStaking =>
+    parseResult({
+      accountId, controllerId, stashId, eraLength, bestNumber, queuedKeys, stakingLedger, nominators, rewardDestination, stakers, validatorPrefs, nextKeys
     })
-  );
+  ));
+}
+
+function retrieveV1 (api: ApiInterfaceRx, controllerId: AccountId): Observable<DerivedStaking> {
+  return api.query.staking
+    .ledger<Option<StakingLedger>>(controllerId)
+    .pipe(
+      switchMap((stakingLedger): Observable<DerivedStaking> =>
+        stakingLedger.isSome
+          ? retrieveInfoV1(api, controllerId, stakingLedger.unwrap().stash, controllerId)
+          : of({ accountId: controllerId, nextSessionIds: [], sessionIds: [] })
+      )
+    );
+}
+
+function retrieveV2 (api: ApiInterfaceRx, stashId: AccountId): Observable<DerivedStaking> {
+  return api.query.staking
+    .bonded<Option<AccountId>>(stashId)
+    .pipe(
+      switchMap((controllerId): Observable<DerivedStaking> =>
+        controllerId.isSome
+          ? retrieveInfoV2(api, stashId, stashId, controllerId.unwrap())
+          : of({ accountId: stashId, nextSessionIds: [], sessionIds: [] })
+      )
+    );
 }
 
 /**
  * @description From a stash, retrieve the controllerId and fill in all the relevant staking details
  */
 export function info (api: ApiInterfaceRx): (_accountId: Uint8Array | string) => Observable<DerivedStaking> {
-  return (_accountId: Uint8Array | string): Observable<DerivedStaking> => {
-    const accountId = createType('AccountId', _accountId);
+  const query = api.consts.session
+    ? retrieveV2
+    : retrieveV1;
 
-    return (
-      // NOTE For 2.x-only support, only the first path is required, therefore we
-      // can replace this with `.bonded<Option<AccountId>>(accountId)` - in 2.x
-      // the session.validators return the stashes (as expected)
-      api.queryMulti<[Option<AccountId>, Option<StakingLedger>]>([
-        [api.query.staking.bonded, accountId], // try to map to controller
-        [api.query.staking.ledger, accountId] // try to map to stash (1.x only)
-      ])
-    ).pipe(
-      switchMap(([controllerId, stakingLedger]): Observable<DerivedStaking> =>
-        controllerId.isSome
-          ? retrieveInfo(api, accountId, controllerId.unwrap())
-          : stakingLedger.isSome
-            ? retrieveInfo(api, stakingLedger.unwrap().stash, accountId)
-            : of({ accountId, nextSessionIds: [], sessionIds: [] })
-      ),
-      drr()
-    );
-  };
+  return (accountId: Uint8Array | string): Observable<DerivedStaking> =>
+    query(api, createType('AccountId', accountId)).pipe(drr());
 }

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

@@ -0,0 +1,65 @@
+// Copyright 2017-2019 @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, Exposure, Keys, RewardDestination, ValidatorPrefs } from '@polkadot/types/interfaces';
+import { ITuple } from '@polkadot/types/types';
+import { DerivedStakingStash } from '../types';
+
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Option, Vec } from '@polkadot/types';
+
+import { drr } from '../util';
+
+// NOTE Unused ATM, preparing for V2-only
+
+type Result = [Option<AccountId>, [Vec<AccountId>], RewardDestination, Exposure, ValidatorPrefs, Option<Keys>?];
+type ResultV1 = [Option<AccountId>, ITuple<[Vec<AccountId>]>, RewardDestination, Exposure, ValidatorPrefs];
+type ResultV2 = [Option<AccountId>, ITuple<[Vec<AccountId>]>, RewardDestination, Exposure, ValidatorPrefs, Option<Keys>];
+
+function parse (stashId: AccountId, [_controllerId, [nominators], rewardDestination, stakers, validatorPrefs, _nextKeys]: Result): DerivedStakingStash {
+  return {
+    controllerId: _controllerId.unwrapOr(undefined),
+    nextKeys: _nextKeys?.unwrapOr(undefined),
+    nominators,
+    rewardDestination,
+    stakers,
+    stashId,
+    validatorPrefs
+  };
+}
+
+function retrieveV1 (api: ApiInterfaceRx, stashId: AccountId): Observable<Result> {
+  return api.queryMulti<ResultV1>([
+    [api.query.staking.bonded, stashId],
+    [api.query.staking.nominators, stashId],
+    [api.query.staking.payee, stashId],
+    [api.query.staking.stakers, stashId],
+    [api.query.staking.validators, stashId]
+  ]);
+}
+
+function retrieveV2 (api: ApiInterfaceRx, stashId: AccountId): Observable<Result> {
+  return api.queryMulti<ResultV2>([
+    [api.query.staking.bonded, stashId],
+    [api.query.staking.nominators, stashId],
+    [api.query.staking.payee, stashId],
+    [api.query.staking.stakers, stashId],
+    [api.query.staking.validators, stashId],
+    [api.query.session.nextKeys, [api.consts.session.dedupKeyPrefix, stashId]]
+  ]);
+}
+
+export function infoStash (api: ApiInterfaceRx): (stashId: AccountId) => Observable<DerivedStakingStash> {
+  const query = api.consts.session
+    ? retrieveV2
+    : retrieveV1;
+
+  return (stashId: AccountId): Observable<DerivedStakingStash> =>
+    query(api, stashId).pipe(
+      map((result): DerivedStakingStash => parse(stashId, result)),
+      drr()
+    );
+}

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

@@ -0,0 +1,38 @@
+// Copyright 2017-2019 @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 { EraPoints } from '@polkadot/types/interfaces';
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { DerivedStakingOverview } from '../types';
+
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { createType } from '@polkadot/types';
+
+import { drr } from '../util';
+
+/**
+ * @description Retrieve the staking overview, including elected and points earned
+ */
+export function overview (api: ApiInterfaceRx): () => Observable<DerivedStakingOverview> {
+  return (): Observable<DerivedStakingOverview> =>
+    combineLatest([
+      api.derive.session.indexes(),
+      api.derive.staking.validators()
+    ]).pipe(
+      switchMap(([{ currentEra, currentIndex, validatorCount }, { currentElected, validators }]) =>
+        combineLatest([
+          of({ currentElected, currentEra, currentIndex, validators, validatorCount }),
+          // this will change on a per block basis, keep it innermost (and it needs eraIndex)
+          api.query.staking.currentEraPointsEarned
+            ? api.query.staking.currentEraPointsEarned<EraPoints>(currentEra)
+            : of(createType('EraPoints'))
+        ])
+      ),
+      map(([{ currentElected, currentEra, currentIndex, validators, validatorCount }, eraPoints]): DerivedStakingOverview => ({
+        currentElected, currentEra, currentIndex, eraPoints, validators, validatorCount
+      })),
+      drr()
+    );
+}

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

@@ -11,7 +11,7 @@ import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { DerivedRecentlyOffline } from '../types';
 
-import { drr } from '../util/drr';
+import { drr } from '../util';
 
 type OfflineResult = [AccountId, BlockNumber, BN][] & Codec;
 

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

@@ -0,0 +1,29 @@
+// Copyright 2017-2019 @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 { DeriveStakingValidators } from '../types';
+
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Vec } from '@polkadot/types';
+
+import { drr } from '../util';
+
+/**
+ * @description Retrieve latest list of validators
+ */
+export function validators (api: ApiInterfaceRx): () => Observable<DeriveStakingValidators> {
+  return (): Observable<DeriveStakingValidators> =>
+    api.queryMulti<[Vec<AccountId>, Vec<AccountId>]>([
+      api.query.session.validators,
+      api.query.staking.currentElected
+    ]).pipe(
+      map(([validators, currentElected]): DeriveStakingValidators => ({
+        currentElected, validators
+      })),
+      drr()
+    );
+}

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

@@ -19,7 +19,7 @@ const _Header: Constructor<Header> = Struct.with(runtimeTypes.types.Header as an
 export default class HeaderExtended extends _Header {
   private _author?: AccountId;
 
-  public constructor (header?: Header, sessionValidators?: AccountId[]) {
+  constructor (header?: Header, sessionValidators?: AccountId[]) {
     super(header);
 
     this._author = this.extractAuthor(sessionValidators);

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

@@ -20,7 +20,7 @@ const _ReferendumInfo: Constructor<ReferendumInfo> = Struct.with(democracyTypes.
 export default class ReferendumInfoExtended extends _ReferendumInfo {
   private _index: ReferendumIndex;
 
-  public constructor (value: ReferendumInfo | ReferendumInfoExtended, index?: BN | number) {
+  constructor (value: ReferendumInfo | ReferendumInfoExtended, index?: BN | number) {
     super(value);
 
     this._index = value instanceof ReferendumInfoExtended

packages/api-derive/src/types.ts

@@ -2,19 +2,30 @@
 // 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, Exposure, Index, RewardDestination, SetIndex, StakingLedger, ValidatorPrefs, Vote, VoteIndex } from '@polkadot/types/interfaces';
+import { AccountId, AccountIndex, Balance, BalanceLock, BlockNumber, EraIndex, EraPoints, Exposure, Index, Keys, RewardDestination, SessionIndex, SetIndex, StakingLedger, ValidatorPrefs, Vote, VoteIndex } from '@polkadot/types/interfaces';
 
 import BN from 'bn.js';
+import { u32 } from '@polkadot/types';
+
+export type AccountIndexes = Record<string, AccountIndex>;
+
+export interface DeriveAccountInfo {
+  accountId?: AccountId;
+  accountIndex?: AccountIndex;
+  nickname?: string;
+}
 
 export interface DerivedBalances {
   accountId: AccountId;
   accountNonce: Index;
-  freeBalance: BN;
-  lockedBalance: BN;
-  availableBalance: BN;
-  reservedBalance: BN;
-  votingBalance: BN;
-  vestedBalance: BN;
+  freeBalance: Balance;
+  lockedBalance: Balance;
+  lockedBreakdown: BalanceLock[];
+  availableBalance: Balance;
+  reservedBalance: Balance;
+  votingBalance: Balance;
+  vestedBalance: Balance;
+  vestingTotal: Balance;
 }
 
 export type DerivedBalancesMap = Record<string, DerivedBalances>;
@@ -33,24 +44,35 @@ export interface DerivedContractFees {
 }
 
 export interface DerivedElectionsInfo {
-  members: Record<string, BlockNumber>;
   candidates: AccountId[];
-  candidateCount: BN;
-  desiredSeats: BN;
-  nextVoterSet: SetIndex;
+  candidateCount: u32;
+  candidacyBond?: Balance;
+  desiredSeats: u32;
+  members: [AccountId, Balance][];
+  nextVoterSet?: SetIndex;
+  runnersUp: [AccountId, Balance][];
   termDuration: BlockNumber;
-  voteCount: VoteIndex;
-  voterCount: SetIndex;
+  voteCount?: VoteIndex;
+  voterCount?: SetIndex;
+  votingBond?: Balance;
 }
 
 export interface DerivedFees {
-  creationFee: BN;
-  existentialDeposit: BN;
-  transactionBaseFee: BN;
-  transactionByteFee: BN;
-  transferFee: BN;
+  creationFee: Balance;
+  existentialDeposit: Balance;
+  transactionBaseFee: Balance;
+  transactionByteFee: Balance;
+  transferFee: Balance;
 }
 
+export interface DerivedHeartbeatAuthor {
+  blockCount: u32;
+  hasMessage: boolean;
+  isOnline: boolean;
+}
+
+export type DerivedHeartbeats = Record<string, DerivedHeartbeatAuthor>;
+
 export interface RecentlyOffline {
   blockNumber: BlockNumber;
   count: BN;
@@ -64,17 +86,21 @@ export interface DerivedReferendumVote {
   vote: Vote;
 }
 
-export interface DerivedSessionInfo {
-  currentEra: BN;
-  currentIndex: BN;
-  eraLength: BN;
-  eraProgress: BN;
+export interface DeriveSessionIndexes {
+  currentEra: EraIndex;
+  currentIndex: SessionIndex;
+  validatorCount: u32;
+}
+
+export interface DerivedSessionInfo extends DeriveSessionIndexes {
+  eraLength: BlockNumber;
+  eraProgress: BlockNumber;
   isEpoch: boolean;
-  lastEraLengthChange: BN;
-  lastLengthChange: BN;
-  sessionLength: BN;
-  sessionsPerEra: BN;
-  sessionProgress: BN;
+  lastEraLengthChange: BlockNumber;
+  lastLengthChange: BlockNumber;
+  sessionLength: BlockNumber;
+  sessionsPerEra: SessionIndex;
+  sessionProgress: BlockNumber;
 }
 
 export type DerivedStakingAccount = [AccountId, DerivedStakingOnlineStatus];
@@ -92,26 +118,37 @@ export interface DerivedStakingOnlineStatus {
   }[];
 }
 
-export interface DerivedStaking extends DerivedStakingOnlineStatus {
-  accountId: AccountId;
+export interface DeriveStakingValidators {
+  currentElected: AccountId[];
+  validators: AccountId[];
+}
+
+export interface DerivedStakingStash {
   controllerId?: AccountId;
-  // @deprecated Use nextSessionIds instead
-  nextSessionId?: AccountId;
-  nextSessionIds: AccountId[];
   nominators?: AccountId[];
-  redeemable?: BN;
   rewardDestination?: RewardDestination;
-  // @deprecated Use sessionIds instead
-  sessionId?: AccountId;
-  sessionIds: AccountId[];
+  nextKeys?: Keys;
   stakers?: Exposure;
-  stakingLedger?: StakingLedger;
   stashId?: AccountId;
-  unlocking?: DerivedUnlocking;
   validatorPrefs?: ValidatorPrefs;
 }
 
-export type DerivedUnlocking = { remainingBlocks: BN; value: BN }[];
+export interface DerivedStaking extends DerivedStakingOnlineStatus, DerivedStakingStash {
+  accountId: AccountId;
+  nextSessionIds: AccountId[];
+  redeemable?: Balance;
+  sessionIds: AccountId[];
+  stakingLedger?: StakingLedger;
+  unlocking?: DerivedUnlocking[];
+}
+
+export interface DerivedStakingOverview extends DeriveSessionIndexes {
+  currentElected: AccountId[];
+  eraPoints: EraPoints;
+  validators: AccountId[];
+}
+
+export type DerivedUnlocking = { remainingBlocks: BlockNumber; value: Balance };
 
 export interface VoterPosition {
   globalIndex: BN;

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

@@ -2,27 +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 { catchError, distinctUntilChanged, publishReplay, refCount } from 'rxjs/operators';
-import { Observable } from 'rxjs';
-import { logger } from '@polkadot/util';
+import { drr as drrBase, DrrResult } from '@polkadot/rpc-core/rxjs';
 
-type DrrResult = <T> (source$: Observable<T>) => Observable<T>;
-
-const l = logger('drr');
-
-/**
- * Shorthand for distinctUntilChanged(), publishReplay(1) and refCount().
- *
- * @ignore
- */
-export const drr = (): DrrResult => <T> (source$: Observable<T>): Observable<T> =>
-  source$.pipe(
-    catchError((error): Observable<never> => {
-      l.error(error);
-
-      throw error;
-    }),
-    distinctUntilChanged(),
-    publishReplay(1),
-    refCount()
-  );
+export const drr = (): DrrResult =>
+  drrBase({ skipTimeout: true });

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

@@ -3,3 +3,5 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 export * from './approvalFlagsToBools';
+export * from './drr';
+export * from './memo';