[CI Skip] release/stable 2.9.1

skip-checks: true

.123trigger

@@ -4,4 +4,4 @@
 1.11.2
 1.12.2
 1.17.2
-1.31.2
+1.31.22.8.2

.babelrc.js

@@ -1,4 +0,0 @@
-// Copyright 2017-2020 @polkadot/api authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-module.exports = require('./babel.config.js');

.eslintignore

@@ -1,5 +0,0 @@
-.eslintrc.js
-**/build/*
-**/coverage/*
-**/node_modules/*
-docs/examples/promise/90_typegen/*

.eslintrc.js

@@ -1,10 +1,19 @@
 // Copyright 2017-2020 @polkadot/api authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-const base = require('@polkadot/dev/config/eslint');
+const base = require('@polkadot/dev/config/eslint.cjs');
 
 module.exports = {
   ...base,
+  ignorePatterns: [
+    '.eslintrc.js',
+    '.github/**',
+    '.vscode/**',
+    '.yarn/**',
+    '**/build/*',
+    '**/coverage/*',
+    '**/node_modules/*'
+  ],
   parserOptions: {
     ...base.parserOptions,
     project: [

.github/workflows/pr-any.yml

@@ -9,7 +9,7 @@ jobs:
     name: ${{ matrix.step }}
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
     - name: ${{ matrix.step }}
       run: |
         yarn install --immutable | grep -v 'YN0013'

.github/workflows/push-master.yml

@@ -13,7 +13,7 @@ jobs:
     if: "! startsWith(github.event.head_commit.message, '[CI Skip]') && github.repository == 'polkadot-js/api'"
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
       with:
         token: ${{ secrets.GH_PAT }}
     - name: ${{ matrix.step }}

.nvmrc

@@ -1 +1 @@
-10
+12

CHANGELOG.md

@@ -1,5 +1,95 @@
 # CHANGELOG
 
+## 2.9.1 Nov 30, 2020
+
+Upgrade priority: Low. No major changes when on at least 2.8.2. Users encouraged to upgrade to at least that patch.
+
+- **Breaking change** The API will now not attempt to queue calls made while not connected and send on connection. Rather when making a call and the RPC node is not connected, an error will be thrown.
+
+Contributed:
+
+- Add typegen capability for custom RPCs (Thanks to https://github.com/holygits)
+
+Changes:
+
+- Remove rpc-core send queue, only allow sends while connected
+- Adjust staking derive for `electedInfo` to contain details of current validators
+- Extract identity-only derive from `accounts.info` for simpler reusability
+- Add types for Substrate master node (to allow for consistent swapping to `MultiAddress`)
+- Adjust `Bytes` with `.slice` to be consistent for `Uint8array` extensions (already released in 2.8.2 as a bugfix)
+
+
+## 2.8.1 Nov 23, 2020
+
+Upgrade priority: Low. Recommended if using Substrate master with new `MultiAddress`.
+
+Contributed:
+
+- Export `derive.chain.getBlock` (Thanks to https://github.com/lovesh)
+
+Changes:
+
+- Expand `MultiAddress` construction with multi type detection
+- Rename `GenericLookupSource` to `IndicesLookupSource` (internal use)
+- Cleanup list retrievals with `Raw` data results for undecodable entries
+- Export actual version via `RegistryMetadata`
+- Dedupe bn.js (one version shared between dependencies)
+
+
+## 2.7.1 Nov 16, 2020
+
+Upgrade priority: Medium. Recommended for users of Polkadot/Kusama and api-contract users.
+
+Changes:
+
+- Allow for `ExtrinsicSignature` overrides (defaults to `MultiSignature`)
+- Update api-contract `Blueprint` to allow for optional salt (auto if not provided)
+- Support for ink! `.contract` files (in addition to ABI `.json`)
+- Fix contract event decoding with pass-through of raw `Bytes`
+- Fix support for enum encoding in api-contract
+- Support new contract `Schedule` type as per Substrate
+- Update Kusama/Polkadot known upgrade blocks
+- Adjust typegen generated `@polkadot/types` imports
+- Adjust internal `@polkadot/types` imports/exports (overall bundle sizes)
+
+
+## 2.6.1 Nov 9, 2020
+
+Upgrade priority: Low. Should be done alongside an update to `@polkadot/util` to 4.0
+
+Changes:
+
+- Adjust auto-gas to contract RPC call to 5 * 10 ^ 12 (align with Rust)
+- Adjust derive `AccountId` check to take Ethereum-compatible chains into account
+- Fallback for chains with invalid council proposal data in derives
+- Bump static v12 Metadata (tests) to latest Substrate version
+- Bump `@polkadot/{util,util-crypto}` to 4.0 (optimized WASM layers)
+
+
+## 2.5.1 Nov 2, 2020
+
+Upgrade priority: Low. Recommended for `api-contract` developers.
+
+- **Breaking change** Substrate changed the `ContractExecResult` from `api.rpc.contracts.call`. The API does have pass-through support for both old and new variants via the `Contract` interface, however it means the structure has changed to accommodate the new Substrate structure. Refer to the [docs for the latest interface](https://polkadot.js.org/docs/api-contract/start/contract.read) (including `isSuccess/isError` -> `isOk/isErr`, and the availability of the `gasConsumed`)
+
+Contributed:
+
+- Dedup similar types on generation (Thanks to https://github.com/monitz87)
+
+Changes:
+
+- `Contract` execution will now return contract events decoded in the result
+- Add `.dryRun` on extrinsics (alongside `.paymentInfo` usage)
+- Add `system_syncState` and `syncstate_genSyncSpec` RPCs
+- Enhance error reporting, `Call` indicates explicit call as found
+- Adjust internal metadata decoration and use as exposed from `@types/metadata`
+- Expand Rococo known types to cater for v1 (specVersion 10)
+- `registry.hash` now returns an `H256` object (as opposed to raw Uint8Array)
+- Use utility logger in all relevant error messages (consistency in logging)
+- Add `derive.council.proposal(<hash>)` for retrieval of a single (expanded) proposal
+- Correctly and transparently format type generation types (allowing for nested variants)
+
+
 ## 2.4.1 Oct 26, 2020
 
 Upgrade priority: Low. No breaking changes, however it does move `api-contract` forward with additional features.

README.md

@@ -28,19 +28,3 @@ The API is split up into a number of internal packages -
 Type definitions for interfaces as exposed by Polkadot & Substrate clients -
 
 - [@polkadot/types](packages/types/) Codecs for all Polkadot and Substrate primitives
-
-## development
-
-Contributions are welcome!
-
-To start off, this repo (along with others in the [@polkadot](https://github.com/polkadot-js/) family) uses yarn workspaces to organise the code. As such, after cloning, its dependencies _should_ be installed via `yarn`, not via npm; the latter will result in broken dependencies.
-
-To get started -
-
-1. Clone the repo locally, via `git clone https://github.com/polkadot-js/api <optional local path>`
-2. Ensure that you have a recent version of Node.js, for development purposes [Node 10](https://nodejs.org/en/) is recommended.
-3. Ensure that you have a recent version of Yarn, for development purposes [Yarn >=1.10.1](https://yarnpkg.com/docs/install) is required.
-4. Install the dependencies by running `yarn`
-5. Build the everything via `yarn run build`
-6. You can also launch the API Docs, via `yarn vuepress dev docs`
-7. Access the docs via [http://localhost:8080](http://localhost:8080)

babel.config.js

@@ -1,4 +1,4 @@
 // Copyright 2017-2020 @polkadot/api authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-module.exports = require('@polkadot/dev/config/babel');
+module.exports = require('@polkadot/dev/config/babel-config-cjs.cjs');

copy-to-apps.sh

@@ -1,25 +0,0 @@
-#!/usr/bin/env bash
-# Copyright 2017-2020 @polkadot/api authors & contributors
-# SPDX-License-Identifier: Apache-2.0
-
-function copy_folder () {
-  SRC="packages/$1/build"
-  DST="../apps/node_modules/@polkadot/$1"
-
-  echo "** Copying $SRC to $DST"
-
-  rm -rf $DST
-  cp -r $SRC $DST
-}
-
-yarn polkadot-dev-build-ts
-
-copy_folder "api"
-copy_folder "api-contract"
-copy_folder "api-derive"
-copy_folder "metadata"
-copy_folder "rpc-core"
-copy_folder "rpc-provider"
-copy_folder "types"
-copy_folder "types-known"
-copy_folder "typegen"

copy-to-test.sh

@@ -1,25 +0,0 @@
-#!/usr/bin/env bash
-# Copyright 2017-2020 @polkadot/api authors & contributors
-# SPDX-License-Identifier: Apache-2.0
-
-function copy_folder () {
-  SRC="packages/$1/build"
-  DST="../test/js-test/node_modules/@polkadot/$1"
-
-  echo "** Copying $SRC to $DST"
-
-  rm -rf $DST
-  cp -r $SRC $DST
-}
-
-yarn polkadot-dev-build-ts
-
-copy_folder "api"
-copy_folder "api-contract"
-copy_folder "api-derive"
-copy_folder "metadata"
-copy_folder "rpc-core"
-copy_folder "rpc-provider"
-copy_folder "types"
-copy_folder "types-known"
-copy_folder "typegen"

docker-compose.yml

@@ -1,102 +0,0 @@
-# Docker compose file to run Polkadot-JS API e2e test files on supported versions of Polkadot and Substrate
-# 
-# Setup:
-# Builds 5 containers with different supported versions of Substrate and Polkadot.
-# Runs Polkadot-JS API Tests 
-#
-# Before you can run this script, you need to install Docker and 'Docker Compose' on your machine.
-# Please follow the steps described here (including the prerequisites): https://docs.docker.com/compose/install/
-#
-# Usage:
-# 1. BUILD: Run `docker-compose pull && docker-compose up -d` to pull the latest docker imaged and run docker-compose in detached mode. This will run the substrate and polkadot containers in the background.
-# 2. INFO: Run `docker ps` to get a list of Docker containers running in the background including their mapped ports on localhost
-# 3. TEST: Run `docker-compose logs -f js-api-tests` to run the API tests and print the logs
-# 4. QUIT: Run `docker-compose down` to stop and remove all running containers.
-#
-# Provided Endpoints for localhost:
-#   - Substrate Master: ws://127.0.0.1:9945/
-#   - Substrate 1.0: ws://127.0.0.1:9946/
-#   - Substrate 2.0: ws://127.0.0.1:9947/
-#   - Polkadot Master: ws://127.0.0.1:9948/
-#   - Polkadot Alexander: ws://127.0.0.1:9949/
-# 
-# Find more Docker images of Substrate https://hub.docker.com/r/parity/substrate/tags
-# Find more Docker images of Polkadot https://hub.docker.com/r/parity/polkadot/tags
-
-
-version: "3.7"
-services:
-  substrate-master:
-    image: parity/substrate:latest
-    ports:
-      - "9945:9944"
-      - "9935:9933"
-    networks:
-      - internet
-    command:
-      - "--dev"
-      - "--ws-external"
-      - "--rpc-external"
-    
-  substrate-1.0:
-    image: parity/substrate:v1.0.0
-    ports:
-      - "9946:9944"
-      - "9936:9933"
-    networks:
-      - internet
-    command:
-      - "--dev"
-      - "--ws-external"
-      - "--rpc-external"
-
-  substrate-2.0:
-    image: parity/substrate:2.0.0-b65c315a1
-    ports:
-      - "9947:9944"
-      - "9937:9933"
-    networks:
-      - internet
-    command:
-      - "--dev"
-      - "--ws-external"
-      - "--rpc-external"
-  
-  polkadot-master:
-    image: parity/polkadot:latest
-    ports:
-      - "9948:9944"
-      - "9938:9933"
-    networks:
-      - internet
-    command:
-      - "--dev"
-      - "--ws-external"
-      - "--rpc-external"
-
-  polkadot-alexander:
-      image: parity/polkadot:v0.4.4
-      ports:
-        - "9949:9944"
-        - "9939:9933"
-      networks:
-        - internet
-      command:
-        - "--dev"
-        - "--ws-external"
-        - "--rpc-external"
-
-  # This is the container running the API tests
-  js-api-tests:
-    image: node:11
-    volumes: 
-      - ./:/polkadot-js/api
-    working_dir: /polkadot-js/api
-    network_mode: host
-    tty: true
-    environment: 
-      - TERM=xterm-256color`
-    command: bash -c "NODE_ENV=abc /usr/local/bin/yarn && /usr/local/bin/yarn test:all"
-
-networks:
-  internet:

jest.config.js

@@ -1,29 +1,30 @@
 // Copyright 2017-2020 @polkadot/api authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-const config = require('@polkadot/dev/config/jest');
+const config = require('@polkadot/dev/config/jest.cjs');
 
 module.exports = Object.assign({}, config, {
   moduleNameMapper: {
-    '@polkadot/api-contract(.*)$': '<rootDir>/packages/api-contract/src/$1',
+    '@polkadot/api-(contract|derive)(.*)$': '<rootDir>/packages/api-$1/src/$2',
-    '@polkadot/api-derive(.*)$': '<rootDir>/packages/api-derive/src/$1',
     // eslint-disable-next-line sort-keys
     '@polkadot/api(.*)$': '<rootDir>/packages/api/src/$1',
     '@polkadot/metadata(.*)$': '<rootDir>/packages/metadata/src/$1',
     '@polkadot/rpc-(core|provider)(.*)$': '<rootDir>/packages/rpc-$1/src/$2',
+    '@polkadot/typegen(.*)$': '<rootDir>/packages/typegen/src/$1',
     '@polkadot/types-known(.*)$': '<rootDir>/packages/types-known/src/$1',
     // eslint-disable-next-line sort-keys
     '@polkadot/types(.*)$': '<rootDir>/packages/types/src/$1'
   },
   modulePathIgnorePatterns: [
     '<rootDir>/packages/api/build',
-    '<rootDir>/packages/api-derive/build',
     '<rootDir>/packages/api-contract/build',
+    '<rootDir>/packages/api-derive/build',
     '<rootDir>/packages/metadata/build',
     '<rootDir>/packages/rpc-core/build',
     '<rootDir>/packages/rpc-provider/build',
+    '<rootDir>/packages/typegen/build',
     '<rootDir>/packages/types/build',
     '<rootDir>/packages/types-known/build'
   ],
-  resolver: './jest.resolver.js'
+  resolver: '@polkadot/dev/config/jest-resolver.cjs'
 });

jest.resolver.js

@@ -1,12 +0,0 @@
-// Copyright 2017-2020 @polkadot/api authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-const path = require('path');
-
-module.exports = function resolver (file, config) {
-  if (file.includes('package.json')) {
-    return path.join(config.basedir.replace('/src', '/'), file);
-  }
-
-  return config.defaultResolver(file, config);
-};

package.json

@@ -7,8 +7,7 @@
     "packages/*"
   ],
   "resolutions": {
-    "babel-core": "^7.0.0-bridge.0",
+    "typescript": "^4.1.2"
-    "typescript": "^4.0.3"
   },
   "scripts": {
     "build": "yarn build:interfaces && polkadot-dev-build-ts && (cd packages/typegen && copyfiles scripts/* build)",
@@ -24,14 +23,14 @@
     "test:watch": "polkadot-dev-run-test --watch"
   },
   "devDependencies": {
-    "@babel/core": "^7.12.3",
+    "@babel/core": "^7.12.8",
     "@babel/register": "^7.12.1",
-    "@babel/runtime": "^7.12.1",
+    "@babel/runtime": "^7.12.5",
-    "@polkadot/dev": "^0.59.6",
+    "@polkadot/dev": "^0.60.5",
-    "@polkadot/ts": "^0.3.51",
+    "@polkadot/ts": "^0.3.55",
     "@polkadot/typegen": "workspace:packages/typegen",
     "@types/jest": "^26.0.15",
     "copyfiles": "^2.4.0"
   },
-  "version": "2.4.1"
+  "version": "2.9.1"
 }

packages/api-contract/package.json

@@ -1,37 +1,26 @@
 {
   "name": "@polkadot/api-contract",
-  "version": "2.4.1",
+  "version": "2.9.1",
   "description": "Interfaces for interacting with contracts and contract ABIs",
   "main": "index.js",
+  "sideEffects": false,
   "keywords": [
     "Polkadot",
     "ABI"
   ],
   "author": "Jaco Greeff <jacogr@gmail.com>",
-  "maintainers": [
+  "maintainers": [],
-    "Jaco Greeff <jacogr@gmail.com>"
-  ],
   "contributors": [],
   "license": "Apache-2.0",
-  "publishConfig": {
+  "repository": "github:polkadot-js/api",
-    "access": "public",
+  "bugs": "https://github.com/polkadot-js/api/issues",
-    "registry": "https://registry.npmjs.org"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/polkadot-js/api.git"
-  },
-  "bugs": {
-    "url": "https://github.com/polkadot-js/api/issues"
-  },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api-contract#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.1",
+    "@babel/runtime": "^7.12.5",
-    "@polkadot/api": "^2.4.1",
+    "@polkadot/api": "2.9.1",
-    "@polkadot/rpc-core": "^2.4.1",
+    "@polkadot/types": "2.9.1",
-    "@polkadot/types": "^2.4.1",
+    "@polkadot/util": "^4.2.1",
-    "@polkadot/util": "^3.6.1",
+    "bn.js": "^4.11.9",
-    "bn.js": "^5.1.3",
     "rxjs": "^6.6.3"
   }
 }

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

@@ -1,11 +1,9 @@
 // Copyright 2017-2020 @polkadot/api-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import Abi from './Abi';
+import { Abi } from '.';
 
-import * as testContracts from '../test/contracts';
+import abis from '../test/contracts';
-
-const abis: Record<string, any> = { ...testContracts };
 
 interface JSONAbi {
   spec: {

packages/api-contract/src/Abi.ts

@@ -5,9 +5,14 @@ import { AnyJson, Codec, CodecArg } from '@polkadot/types/types';
 import { ChainProperties, ContractConstructorSpec, ContractEventSpec, ContractMessageSpec, ContractMessageParamSpec, ContractProject } from '@polkadot/types/interfaces';
 import { AbiConstructor, AbiEvent, AbiMessage, AbiParam, DecodedEvent, DecodedMessage } from './types';
 
-import { assert, compactAddLength, compactStripLength, isNumber, isObject, isString, stringCamelCase, u8aConcat, u8aToHex } from '@polkadot/util';
+import { Bytes } from '@polkadot/types';
+import { assert, assertReturn, compactAddLength, compactStripLength, isNumber, isObject, isString, logger, stringCamelCase, u8aConcat, u8aToHex } from '@polkadot/util';
 
-import MetaRegistry from './MetaRegistry';
+import { MetaRegistry } from './MetaRegistry';
+
+const EMPTY_U8A = new Uint8Array();
+
+const l = logger('Abi');
 
 function findMessage <T extends AbiMessage> (list: T[], messageOrId: T | string | number): T {
   const message = isNumber(messageOrId)
@@ -16,12 +21,10 @@ function findMessage <T extends AbiMessage> (list: T[], messageOrId: T | string
       ? list.find(({ identifier }) => [identifier, stringCamelCase(identifier)].includes(messageOrId.toString()))
       : messageOrId;
 
-  assert(message, `Attempted to call an invalid contract interface, ${JSON.stringify(messageOrId)}`);
+  return assertReturn(message, `Attempted to call an invalid contract interface, ${JSON.stringify(messageOrId)}`);
-
-  return message;
 }
 
-export default class Abi {
+export class Abi {
   readonly #events: AbiEvent[];
 
   public readonly constructors: AbiConstructor[];
@@ -74,7 +77,7 @@ export default class Abi {
   /**
    * Warning: Unstable API, bound to change
    */
-  public decodeEvent (data: Uint8Array): DecodedEvent {
+  public decodeEvent (data: Bytes | Uint8Array): DecodedEvent {
     const index = data[0];
     const event = this.#events[index];
 
@@ -111,11 +114,11 @@ export default class Abi {
         assert(isObject(arg.type), 'Invalid type definition found');
 
         return {
-          name: stringCamelCase(arg.name.toString()),
+          name: stringCamelCase(arg.name),
           type: this.registry.getMetaTypeDef(arg.type)
         };
       } catch (error) {
-        console.error(`Error expanding argument ${index} in ${JSON.stringify(spec)}`);
+        l.error(`Error expanding argument ${index} in ${JSON.stringify(spec)}`);
 
         throw error;
       }
@@ -151,8 +154,8 @@ export default class Abi {
       identifier: spec.name.toString(),
       index,
       selector: spec.selector,
-      toU8a: (params: CodecArg[]) =>
+      toU8a: (params: CodecArg[], additional?: Uint8Array) =>
-        this.#encodeArgs(spec, args, params)
+        this.#encodeArgs(spec, args, params, additional)
     };
 
     return message;
@@ -182,13 +185,14 @@ export default class Abi {
     return message.fromU8a(trimmed.subarray(4));
   }
 
-  #encodeArgs = ({ name, selector }: ContractMessageSpec | ContractConstructorSpec, args: AbiParam[], data: CodecArg[]): Uint8Array => {
+  #encodeArgs = ({ name, selector }: ContractMessageSpec | ContractConstructorSpec, args: AbiParam[], data: CodecArg[], additional = EMPTY_U8A): Uint8Array => {
     assert(data.length === args.length, `Expected ${args.length} arguments to contract message '${name.toString()}', found ${data.length}`);
 
     return compactAddLength(
       u8aConcat(
         this.registry.createType('ContractSelector', selector).toU8a(),
-        ...args.map(({ type }, index) => this.registry.createType(type.type as 'Text', data[index]).toU8a())
+        ...args.map(({ type }, index) => this.registry.createType(type.type as 'Text', data[index]).toU8a()),
+        additional
       )
     );
   }

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

@@ -4,11 +4,9 @@
 import fs from 'fs';
 import path from 'path';
 
-import Abi from './Abi';
+import { Abi } from '.';
 
-import * as testContracts from '../test/contracts';
+import abis from '../test/contracts';
-
-const abis: Record<string, any> = { ...testContracts };
 
 describe('MetaRegistry', (): void => {
   Object.keys(abis).forEach((abiName) => {
@@ -33,6 +31,6 @@ describe('MetaRegistry', (): void => {
   });
 
   it('stores base project as JSON', (): void => {
-    expect(new Abi(abis.dns).json).toEqual(abis.dns);
+    expect(new Abi(abis.ink_dns).json).toEqual(abis.ink_dns);
   });
 });

packages/api-contract/src/MetaRegistry.ts

@@ -5,7 +5,7 @@ import { ContractDisplayName, ChainProperties, SiField, SiLookupTypeId, SiType,
 import { InterfaceTypes, TypeDef, TypeDefInfo } from '@polkadot/types/types';
 
 import { assert, isUndefined } from '@polkadot/util';
-import { TypeRegistry, withTypeString } from '@polkadot/types';
+import { TypeRegistry, withTypeString } from '@polkadot/types/create';
 
 interface PartialTypeSpec {
   readonly type: SiLookupTypeId;
@@ -22,7 +22,9 @@ const PRIMITIVE_ALIAS: Record<string, keyof InterfaceTypes> = {
   Str: 'Text'
 };
 
-export default class MetaRegistry extends TypeRegistry {
+const PRIMITIVE_ALWAYS = ['AccountId', 'AccountIndex', 'Address', 'Balance'];
+
+export class MetaRegistry extends TypeRegistry {
   public readonly metaTypeDefs: TypeDef[] = [];
 
   #siTypes: SiType[] = [];
@@ -56,8 +58,8 @@ export default class MetaRegistry extends TypeRegistry {
         typeDef = {
           ...typeDef,
           displayName,
-          type: ['Balance'].includes(displayName)
+          type: PRIMITIVE_ALWAYS.includes(displayName)
-            ? 'Balance'
+            ? displayName
             : typeDef.type
         };
       }
@@ -84,10 +86,10 @@ export default class MetaRegistry extends TypeRegistry {
 
   #extract = (type: SiType, id: SiLookupTypeId): TypeDef => {
     const path = [...type.path];
+    const pathFinal = path.length ? path[path.length - 1].toString() : '';
     let typeDef: Omit<TypeDef, 'type'>;
 
-    // TODO solang?
+    if (type.path.join('::').startsWith('ink_env::types::') || PRIMITIVE_ALWAYS.includes(pathFinal)) {
-    if (type.path.join('::').startsWith('ink_env::types::')) {
       typeDef = this.#extractPrimitivePath(type);
     } else if (type.def.isPrimitive) {
       typeDef = this.#extractPrimitive(type);
@@ -117,7 +119,7 @@ export default class MetaRegistry extends TypeRegistry {
         : {}
       ),
       ...(type.params.length > 0
-        ? { params: type.params.map((type) => this.getMetaTypeDef({ type })) }
+        ? { sub: type.params.map((type) => this.getMetaTypeDef({ type })) }
         : {}
       ),
       ...typeDef

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

@@ -4,12 +4,12 @@
 import { ApiTypes, DecorateMethod } from '@polkadot/api/types';
 import { AnyJson, Registry } from '@polkadot/types/types';
 
-import ApiBase from '@polkadot/api/base';
+import { ApiBase } from '@polkadot/api/base';
 import { assert } from '@polkadot/util';
 
-import Abi from '../Abi';
+import { Abi } from '../Abi';
 
-export default abstract class Base<ApiType extends ApiTypes> {
+export abstract class Base<ApiType extends ApiTypes> {
   public readonly abi: Abi;
 
   public readonly api: ApiBase<ApiType>;

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

@@ -5,18 +5,44 @@ import { ApiTypes, DecorateMethod } from '@polkadot/api/types';
 import { SubmittableExtrinsic } from '@polkadot/api/submittable/types';
 import { AccountId, EventRecord, Hash } from '@polkadot/types/interfaces';
 import { AnyJson, CodecArg, ISubmittableResult } from '@polkadot/types/types';
-import { AbiConstructor } from '../types';
+import { AbiConstructor, BlueprintOptions } from '../types';
-import { MapConstructorExec } from './types';
+import { BlueprintDeploy, ContractGeneric, MapConstructorExec } from './types';
 
 import BN from 'bn.js';
 import { SubmittableResult } from '@polkadot/api';
-import ApiBase from '@polkadot/api/base';
+import { ApiBase } from '@polkadot/api/base';
-import { isUndefined, stringCamelCase } from '@polkadot/util';
+import { Bytes } from '@polkadot/types';
+import { isUndefined, stringCamelCase, compactAddLength, u8aToU8a } from '@polkadot/util';
+import { randomAsU8a } from '@polkadot/util-crypto';
 
-import Abi from '../Abi';
+import { Abi } from '../Abi';
-import { applyOnEvent } from '../util';
+import { applyOnEvent, extractOptions, isOptions } from '../util';
-import Base from './Base';
+import { Base } from './Base';
-import Contract from './Contract';
+import { Contract } from './Contract';
+
+const EMPTY_SALT = new Uint8Array();
+
+function createTx <ApiType extends ApiTypes> (fn: (options: BlueprintOptions, params: CodecArg[]) => SubmittableExtrinsic<ApiType, BlueprintSubmittableResult<ApiType>>): BlueprintDeploy<ApiType> {
+  return (options: BigInt | string | number | BN | BlueprintOptions, ...params: CodecArg[]): SubmittableExtrinsic<ApiType, BlueprintSubmittableResult<ApiType>> =>
+    isOptions(options)
+      ? fn(options, params)
+      : fn(...extractOptions(options, params));
+}
+
+function createWithId <T> (fn: (constructorOrId: AbiConstructor | string | number, options: BlueprintOptions, params: CodecArg[]) => T): ContractGeneric<BlueprintOptions, T> {
+  return (constructorOrId: AbiConstructor | string | number, options: BigInt | string | number | BN | BlueprintOptions, ...params: CodecArg[]): T =>
+    isOptions(options)
+      ? fn(constructorOrId, options, params)
+      : fn(constructorOrId, ...extractOptions(options, params));
+}
+
+function encodeSalt (salt: Uint8Array | string | null = randomAsU8a()) {
+  return salt instanceof Bytes
+    ? salt
+    : salt && salt.length
+      ? compactAddLength(u8aToU8a(salt))
+      : EMPTY_SALT;
+}
 
 export class BlueprintSubmittableResult<ApiType extends ApiTypes> extends SubmittableResult {
   public readonly contract?: Contract<ApiType>;
@@ -28,22 +54,31 @@ export class BlueprintSubmittableResult<ApiType extends ApiTypes> extends Submit
   }
 }
 
-export default class Blueprint<ApiType extends ApiTypes> extends Base<ApiType> {
+export class Blueprint<ApiType extends ApiTypes> extends Base<ApiType> {
+  /**
+   * @description The on-chain code hash for this blueprint
+   */
   public readonly codeHash: Hash;
 
+  /**
+   * @deprecated
+   * @description Deprecated. Use `.tx.<constructorName>`. Creates a contract in a non-deterministic way.
+   */
+  public readonly createContract: ContractGeneric<BlueprintOptions, SubmittableExtrinsic<ApiType, BlueprintSubmittableResult<ApiType>>>;
+
   readonly #tx: MapConstructorExec<ApiType> = {};
 
   constructor (api: ApiBase<ApiType>, abi: AnyJson | Abi, codeHash: string | Hash | Uint8Array, decorateMethod: DecorateMethod<ApiType>) {
     super(api, abi, decorateMethod);
 
     this.codeHash = this.registry.createType('Hash', codeHash);
+    this.createContract = createWithId(this.#deploy);
 
     this.abi.constructors.forEach((c): void => {
       const messageName = stringCamelCase(c.identifier);
 
       if (isUndefined(this.#tx[messageName])) {
-        this.#tx[messageName] = (endowment: BigInt | string | number | BN, gasLimit: BigInt | string | number | BN, ...params: CodecArg[]) =>
+        this.#tx[messageName] = createTx((o, p) => this.#deploy(c, o, p));
-          this.#deploy(c, endowment, gasLimit, params);
       }
     });
   }
@@ -52,17 +87,20 @@ export default class Blueprint<ApiType extends ApiTypes> extends Base<ApiType> {
     return this.#tx;
   }
 
-  #deploy = (constructorOrId: AbiConstructor | string| number, endowment: BigInt | string | number | BN, gasLimit: BigInt | string | number | BN, params: CodecArg[]): SubmittableExtrinsic<ApiType, BlueprintSubmittableResult<ApiType>> => {
+  #deploy = (constructorOrId: AbiConstructor | string| number, { gasLimit = 0, salt, value = 0 }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, BlueprintSubmittableResult<ApiType>> => {
-    return this.api.tx.contracts
+    const encodedSalt = encodeSalt(salt);
-      .instantiate(endowment, gasLimit, this.codeHash, this.abi.findConstructor(constructorOrId).toU8a(params))
+    const withSalt = this.api.tx.contracts.instantiate.meta.args.length === 5;
-      .withResultTransform((result: ISubmittableResult) =>
+    const encoded = this.abi.findConstructor(constructorOrId).toU8a(params, withSalt ? EMPTY_SALT : encodedSalt);
-        new BlueprintSubmittableResult(result, applyOnEvent(result, 'Instantiated', (record: EventRecord) =>
+    const tx = withSalt
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore new style with salt included
+      ? this.api.tx.contracts.instantiate(value, gasLimit, this.codeHash, encoded, encodedSalt)
+      : this.api.tx.contracts.instantiate(value, gasLimit, this.codeHash, encoded);
+
+    return tx.withResultTransform((result: ISubmittableResult) =>
+      new BlueprintSubmittableResult(result, applyOnEvent(result, 'Instantiated', ([record]: EventRecord[]) =>
         new Contract<ApiType>(this.api, this.abi, record.event.data[1] as AccountId, this._decorateMethod)
       ))
     );
   }
-
-  public createContract (constructorOrId: AbiConstructor | string| number, endowment: BigInt | string | number | BN, gasLimit: BigInt | string | number | BN, ...params: CodecArg[]): SubmittableExtrinsic<ApiType, BlueprintSubmittableResult<ApiType>> {
-    return this.#deploy(constructorOrId, endowment, gasLimit, params);
-  }
 }

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

@@ -0,0 +1,27 @@
+// Copyright 2017-2020 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import fs from 'fs';
+import path from 'path';
+import { decorateMethod } from '@polkadot/api/promise';
+
+import contractFlipper from '../../test/contracts/ink/flipper.contract.json';
+import abiFlipper from '../../test/contracts/ink/flipper.json';
+import { mockApi } from './mock';
+import { Code } from './Code';
+
+const wasmFlipper = fs.readFileSync(path.join(__dirname, '../../test/contracts/ink/flipper.wasm'));
+
+describe('Code', (): void => {
+  it('can construct with an individual ABI/WASM combo', (): void => {
+    expect(
+      () => new Code(mockApi, abiFlipper, wasmFlipper, decorateMethod)
+    ).not.toThrow();
+  });
+
+  it('can construct with an .contract ABI', (): void => {
+    expect(
+      () => new Code(mockApi, contractFlipper, null, decorateMethod)
+    ).not.toThrow();
+  });
+});

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

@@ -7,13 +7,13 @@ import { EventRecord, Hash } from '@polkadot/types/interfaces';
 import { AnyJson, ISubmittableResult } from '@polkadot/types/types';
 
 import { SubmittableResult } from '@polkadot/api';
-import ApiBase from '@polkadot/api/base';
+import { ApiBase } from '@polkadot/api/base';
-import { compactAddLength, u8aToU8a } from '@polkadot/util';
+import { assert, compactAddLength, isWasm, u8aToU8a } from '@polkadot/util';
 
-import Abi from '../Abi';
+import { Abi } from '../Abi';
 import { applyOnEvent } from '../util';
-import Base from './Base';
+import { Base } from './Base';
-import Blueprint from './Blueprint';
+import { Blueprint } from './Blueprint';
 
 export class CodeSubmittableResult<ApiType extends ApiTypes> extends SubmittableResult {
   public readonly blueprint?: Blueprint<ApiType>;
@@ -25,20 +25,27 @@ export class CodeSubmittableResult<ApiType extends ApiTypes> extends Submittable
   }
 }
 
-export default class Code<ApiType extends ApiTypes> extends Base<ApiType> {
+export class Code<ApiType extends ApiTypes> extends Base<ApiType> {
   public readonly code: Uint8Array;
 
-  constructor (api: ApiBase<ApiType>, abi: AnyJson | Abi, wasm: Uint8Array | string | Buffer, decorateMethod: DecorateMethod<ApiType>) {
+  constructor (api: ApiBase<ApiType>, abi: AnyJson | Abi, wasm: Uint8Array | string | Buffer | null | undefined, decorateMethod: DecorateMethod<ApiType>) {
     super(api, abi, decorateMethod);
 
-    this.code = u8aToU8a(wasm);
+    this.code = isWasm(this.abi.project.source.wasm)
+      ? this.abi.project.source.wasm
+      : u8aToU8a(wasm);
+
+    assert(isWasm(this.code), 'No WASM code provided');
   }
 
+  /**
+   * @description Deploy the code bundle, creating a Blueprint.
+   */
   public createBlueprint (): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> {
     return this.api.tx.contracts
       .putCode(compactAddLength(this.code))
       .withResultTransform((result: ISubmittableResult) =>
-        new CodeSubmittableResult(result, applyOnEvent(result, 'CodeStored', (record: EventRecord) =>
+        new CodeSubmittableResult(result, applyOnEvent(result, 'CodeStored', ([record]: EventRecord[]) =>
           new Blueprint<ApiType>(this.api, this.abi, record.event.data[0] as Hash, this._decorateMethod)
         ))
       );

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

@@ -3,45 +3,123 @@
 
 import { ApiTypes, DecorateMethod } from '@polkadot/api/types';
 import { SubmittableExtrinsic } from '@polkadot/api/submittable/types';
-import { AccountId, ContractExecResult } from '@polkadot/types/interfaces';
+import { AccountId, ContractExecResult, EventRecord } from '@polkadot/types/interfaces';
-import { AnyJson, CodecArg } from '@polkadot/types/types';
+import { AnyJson, CodecArg, ISubmittableResult, Registry } from '@polkadot/types/types';
-import { AbiMessage, ContractCallOutcome } from '../types';
+import { AbiMessage, ContractCallOutcome, ContractOptions, DecodedEvent } from '../types';
-import { ContractRead, MapMessageExec, MapMessageRead } from './types';
+import { ContractCallResult, ContractCallSend, ContractGeneric, ContractQuery, ContractTx, MapMessageQuery, MapMessageTx } from './types';
 
 import BN from 'bn.js';
 import { map } from 'rxjs/operators';
-import ApiBase from '@polkadot/api/base';
+import { SubmittableResult } from '@polkadot/api';
-import { assert, bnToBn, isFunction, isUndefined, stringCamelCase } from '@polkadot/util';
+import { ApiBase } from '@polkadot/api/base';
+import { Bytes } from '@polkadot/types';
+import { assert, bnToBn, isFunction, isUndefined, logger, stringCamelCase } from '@polkadot/util';
 
-import Abi from '../Abi';
+import { Abi } from '../Abi';
-import { formatData } from '../util';
+import { applyOnEvent, extractOptions, formatData, isOptions } from '../util';
-import Base from './Base';
+import { Base } from './Base';
 
+// As per Rust, 5 * GAS_PER_SEC
+const MAX_CALL_GAS = new BN(5_000_000_000_000).subn(1);
 const ERROR_NO_CALL = 'Your node does not expose the contracts.call RPC. This is most probably due to a runtime configuration.';
+const l = logger('Contract');
 
-export default class Contract<ApiType extends ApiTypes> extends Base<ApiType> {
+function createQuery <ApiType extends ApiTypes> (fn: (origin: string | AccountId | Uint8Array, options: ContractOptions, params: CodecArg[]) => ContractCallResult<ApiType, ContractCallOutcome>): ContractQuery<ApiType> {
+  return (origin: string | AccountId | Uint8Array, options: BigInt | string | number | BN | ContractOptions, ...params: CodecArg[]): ContractCallResult<ApiType, ContractCallOutcome> =>
+    isOptions(options)
+      ? fn(origin, options, params)
+      : fn(origin, ...extractOptions(options, params));
+}
+
+function createTx <ApiType extends ApiTypes> (fn: (options: ContractOptions, params: CodecArg[]) => SubmittableExtrinsic<ApiType>): ContractTx<ApiType> {
+  return (options: BigInt | string | number | BN | ContractOptions, ...params: CodecArg[]): SubmittableExtrinsic<ApiType> =>
+    isOptions(options)
+      ? fn(options, params)
+      : fn(...extractOptions(options, params));
+}
+
+function createWithId <T> (fn: (messageOrId: AbiMessage | string | number, options: ContractOptions, params: CodecArg[]) => T): ContractGeneric<ContractOptions, T> {
+  return (messageOrId: AbiMessage | string | number, options: BigInt | string | number | BN | ContractOptions, ...params: CodecArg[]): T =>
+    isOptions(options)
+      ? fn(messageOrId, options, params)
+      : fn(messageOrId, ...extractOptions(options, params));
+}
+
+export class ContractSubmittableResult extends SubmittableResult {
+  public readonly contractEvents?: DecodedEvent[];
+
+  constructor (result: ISubmittableResult, contractEvents?: DecodedEvent[]) {
+    super(result);
+
+    this.contractEvents = contractEvents;
+  }
+}
+
+// map from a JSON result to current-style ContractExecResult
+function mapExecResult (registry: Registry, json: Record<string, AnyJson>): ContractExecResult {
+  if (!Object.keys(json).some((key) => ['error', 'success'].includes(key))) {
+    return registry.createType('ContractExecResult', json);
+  }
+
+  const from = registry.createType('ContractExecResultTo260', json);
+
+  if (from.isSuccess) {
+    const s = from.asSuccess;
+
+    return registry.createType('ContractExecResult', {
+      gasConsumed: s.gasConsumed,
+      result: {
+        ok: {
+          data: s.data,
+          flags: s.flags
+        }
+      }
+    });
+  }
+
+  // in the old format error has no additional information,
+  // map it as-is with an "unknown" error
+  return registry.createType('ContractExecResult', { result: { err: { other: 'unknown' } } });
+}
+
+export class Contract<ApiType extends ApiTypes> extends Base<ApiType> {
+  /**
+   * @description The on-chain address for this contract
+   */
   public readonly address: AccountId;
 
-  readonly #tx: MapMessageExec<ApiType> = {};
+  /**
+   * @deprecated
+   * @description Deprecated. Use `.tx.<messageName>` to send a transaction.
+   */
+  public readonly exec: ContractGeneric<ContractOptions, SubmittableExtrinsic<ApiType>>;
 
-  readonly #query: MapMessageRead<ApiType> = {};
+  /**
+   * @deprecated
+   * @description Deprecated. Use `.tx.<messageName>` to send a transaction.
+   */
+  public readonly read: ContractGeneric<ContractOptions, ContractCallSend<ApiType>>;
+
+  readonly #query: MapMessageQuery<ApiType> = {};
+
+  readonly #tx: MapMessageTx<ApiType> = {};
 
   constructor (api: ApiBase<ApiType>, abi: AnyJson | Abi, address: string | AccountId, decorateMethod: DecorateMethod<ApiType>) {
     super(api, abi, decorateMethod);
 
     this.address = this.registry.createType('AccountId', address);
+    this.exec = createWithId(this.#exec);
+    this.read = createWithId(this.#read);
 
     this.abi.messages.forEach((m): void => {
       const messageName = stringCamelCase(m.identifier);
 
       if (isUndefined(this.#tx[messageName])) {
-        this.#tx[messageName] = (value: BigInt | BN | string | number, gasLimit: BigInt | BN | string | number, ...params: CodecArg[]) =>
+        this.#tx[messageName] = createTx((o, p) => this.#exec(m, o, p));
-          this.#exec(m, value, gasLimit, params);
       }
 
       if (isUndefined(this.#query[messageName])) {
-        this.#query[messageName] = (origin: string | AccountId | Uint8Array, value: BigInt | BN | string | number, gasLimit: BigInt | BN | string | number, ...params: CodecArg[]) =>
+        this.#query[messageName] = createQuery((f, o, p) => this.#read(m, o, p).send(f));
-          this.#read(m, value, gasLimit, params).send(origin);
       }
     });
   }
@@ -50,29 +128,47 @@ export default class Contract<ApiType extends ApiTypes> extends Base<ApiType> {
     return isFunction(this.api.rx.rpc.contracts?.call);
   }
 
-  public get query (): MapMessageRead<ApiType> {
+  public get query (): MapMessageQuery<ApiType> {
     assert(this.hasRpcContractsCall, ERROR_NO_CALL);
 
     return this.#query;
   }
 
-  public get tx (): MapMessageExec<ApiType> {
+  public get tx (): MapMessageTx<ApiType> {
     return this.#tx;
   }
 
-  #getGas = (_gasLimit: BigInt | BN | string | number): BN => {
+  #getGas = (_gasLimit: BigInt | BN | string | number, isCall = false): BN => {
     const gasLimit = bnToBn(_gasLimit);
 
     return gasLimit.lten(0)
-      ? this.api.consts.system.maximumBlockWeight.muln(64).divn(100)
+      ? isCall
+        ? MAX_CALL_GAS
+        : this.api.consts.system.maximumBlockWeight.muln(64).divn(100)
       : gasLimit;
   }
 
-  #exec = (messageOrId: AbiMessage | string | number, value: BigInt | BN | string | number, gasLimit: BigInt | BN | string | number, params: CodecArg[]): SubmittableExtrinsic<ApiType> => {
+  #exec = (messageOrId: AbiMessage | string | number, { gasLimit = 0, value = 0 }: ContractOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType> => {
-    return this.api.tx.contracts.call(this.address, value, this.#getGas(gasLimit), this.abi.findMessage(messageOrId).toU8a(params));
+    return this.api.tx.contracts
+      .call(this.address, value, this.#getGas(gasLimit), this.abi.findMessage(messageOrId).toU8a(params))
+      .withResultTransform((result: ISubmittableResult) =>
+        new ContractSubmittableResult(result, applyOnEvent(result, 'ContractExecution', (records: EventRecord[]) =>
+          records
+            .map(({ event: { data: [, data] } }): DecodedEvent | null => {
+              try {
+                return this.abi.decodeEvent(data as Bytes);
+              } catch (error) {
+                l.error(`Unable to decode contract event: ${(error as Error).message}`);
+
+                return null;
+              }
+            })
+            .filter((decoded): decoded is DecodedEvent => !!decoded)
+        ))
+      );
   }
 
-  #read = (messageOrId: AbiMessage | string | number, value: BigInt | BN | string | number, gasLimit: BigInt | BN | string | number, params: CodecArg[]): ContractRead<ApiType> => {
+  #read = (messageOrId: AbiMessage | string | number, { gasLimit = 0, value = 0 }: ContractOptions, params: CodecArg[]): ContractCallSend<ApiType> => {
     assert(this.hasRpcContractsCall, ERROR_NO_CALL);
 
     const message = this.abi.findMessage(messageOrId);
@@ -80,29 +176,25 @@ export default class Contract<ApiType extends ApiTypes> extends Base<ApiType> {
     return {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       send: this._decorateMethod((origin: string | AccountId | Uint8Array) =>
-        this.api.rx.rpc.contracts.call({
+        this.api.rx.rpc.contracts.call.json({
           dest: this.address,
-          gasLimit: this.#getGas(gasLimit),
+          gasLimit: this.#getGas(gasLimit, true),
           inputData: message.toU8a(params),
           origin,
           value
-        }).pipe(
+        }).pipe(map((json): ContractCallOutcome => {
-          map((result: ContractExecResult): ContractCallOutcome => ({
+          const { debugMessage, gasConsumed, result } = mapExecResult(this.registry, json.toJSON());
-            output: result.isSuccess && message.returnType
+
-              ? formatData(this.registry, result.asSuccess.data, message.returnType)
+          return {
+            debugMessage,
+            gasConsumed,
+            output: result.isOk && message.returnType
+              ? formatData(this.registry, result.asOk.data, message.returnType)
               : null,
             result
+          };
         }))
       )
-      )
     };
   }
-
-  public exec (messageOrId: AbiMessage | string | number, value: BigInt | BN | string | number, gasLimit: BigInt | BN | string | number, ...params: CodecArg[]): SubmittableExtrinsic<ApiType> {
-    return this.#exec(messageOrId, value, gasLimit, params);
-  }
-
-  public read (messageOrId: AbiMessage | string | number, value: BigInt | BN | string | number, gasLimit: BigInt | BN | string | number, ...params: CodecArg[]): ContractRead<ApiType> {
-    return this.#read(messageOrId, value, gasLimit, params);
-  }
 }

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

@@ -1,6 +1,6 @@
 // Copyright 2017-2020 @polkadot/api authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export { default as Blueprint, BlueprintSubmittableResult } from './Blueprint';
+export { Blueprint, BlueprintSubmittableResult } from './Blueprint';
-export { default as Code, CodeSubmittableResult } from './Code';
+export { Code, CodeSubmittableResult } from './Code';
-export { default as Contract } from './Contract';
+export { Contract } from './Contract';

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

@@ -0,0 +1,20 @@
+// Copyright 2017-2020 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ApiBase } from '@polkadot/api/base';
+import { TypeRegistry } from '@polkadot/types';
+
+const registry = new TypeRegistry();
+
+export const mockApi = {
+  registry,
+  rx: {
+    tx: {
+      contracts: {
+        putCode: (): never => {
+          throw new Error('mock');
+        }
+      }
+    }
+  }
+} as unknown as ApiBase<'promise'>;

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

@@ -5,27 +5,47 @@ import { ApiTypes, ObsInnerType } from '@polkadot/api/types';
 import { SubmittableExtrinsic } from '@polkadot/api/submittable/types';
 import { AccountId } from '@polkadot/types/interfaces';
 import { CodecArg } from '@polkadot/types/types';
-import { ContractCallOutcome } from '../types';
+import { AbiMessage, BlueprintOptions, ContractCallOutcome, ContractOptions } from '../types';
 
 import BN from 'bn.js';
 import { Observable } from 'rxjs';
 
-type ContractCallResult<ApiType extends ApiTypes, T> = ApiType extends 'rxjs'
+export interface BlueprintDeploy<ApiType extends ApiTypes> {
+  (options: BlueprintOptions, ...params: CodecArg[]): SubmittableExtrinsic<ApiType>;
+  (value: BigInt | string | number | BN, gasLimit: BigInt | string | number | BN, ...params: CodecArg[]): SubmittableExtrinsic<ApiType>;
+}
+
+export interface ContractQuery<ApiType extends ApiTypes> {
+  (origin: AccountId | string | Uint8Array, options: ContractOptions, ...params: CodecArg[]): ContractCallResult<ApiType, ContractCallOutcome>;
+  (origin: AccountId | string | Uint8Array, value: BigInt | BN | string | number, gasLimit: BigInt | BN | string | number, ...params: CodecArg[]): ContractCallResult<ApiType, ContractCallOutcome>;
+}
+
+export interface ContractTx<ApiType extends ApiTypes> {
+  (options: ContractOptions, ...params: CodecArg[]): SubmittableExtrinsic<ApiType>;
+  (value: BigInt | BN | string | number, gasLimit: BigInt | BN | string | number, ...params: CodecArg[]): SubmittableExtrinsic<ApiType>;
+}
+
+export interface ContractGeneric<O, T> {
+  (messageOrId: AbiMessage | string | number, options: O, ...params: CodecArg[]): T;
+  (messageOrId: AbiMessage | string | number, value: BigInt | BN | string | number, gasLimit: BigInt | BN | string | number, ...params: CodecArg[]): T;
+}
+
+export type ContractCallResult<ApiType extends ApiTypes, T> = ApiType extends 'rxjs'
   ? Observable<Observable<T>>
   : Promise<ObsInnerType<Observable<T>>>;
 
-export interface ContractRead<ApiType extends ApiTypes> {
+export interface ContractCallSend<ApiType extends ApiTypes> {
   send (account: string | AccountId | Uint8Array): ContractCallResult<ApiType, ContractCallOutcome>;
 }
 
 export interface MapConstructorExec<ApiType extends ApiTypes> {
-  [message: string]: (endowment: BigInt | string | number | BN, gasLimit: BigInt | string | number | BN, ...params: CodecArg[]) => SubmittableExtrinsic<ApiType>;
+  [message: string]: BlueprintDeploy<ApiType>;
 }
 
-export interface MapMessageExec<ApiType extends ApiTypes> {
+export interface MapMessageTx<ApiType extends ApiTypes> {
-  [message: string]: (value: BigInt | BN | string | number, gasLimit: BigInt | BN | string | number, ...params: CodecArg[]) => SubmittableExtrinsic<ApiType>;
+  [message: string]: ContractTx<ApiType>;
 }
 
-export interface MapMessageRead<ApiType extends ApiTypes> {
+export interface MapMessageQuery<ApiType extends ApiTypes> {
-  [message: string]: (origin: AccountId | string | Uint8Array, value: BigInt | BN | string | number, gasLimit: BigInt | BN | string | number, ...params: CodecArg[]) => ContractCallResult<ApiType, ContractCallOutcome>;
+  [message: string]: ContractQuery<ApiType>;
 }

packages/api-contract/src/checkTypes.manual.ts

@@ -0,0 +1,51 @@
+// Copyright 2017-2020 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Simple non-runnable checks to test type definitions in the editor itself
+
+import { ApiPromise } from '@polkadot/api';
+import { TestKeyringMap, createTestPairs } from '@polkadot/keyring/testingPairs';
+
+import abiIncrementer from '../test/contracts/ink/incrementer.json';
+import { BlueprintPromise, ContractPromise } from '.';
+
+async function checkBlueprint (api: ApiPromise, pairs: TestKeyringMap): Promise<void> {
+  const blueprint = new BlueprintPromise(api, abiIncrementer, '0x1234');
+
+  // new style
+  await blueprint.tx.new({ gasLimit: 456, salt: '0x1234', value: 123 }, 42).signAndSend(pairs.bob);
+  await blueprint.tx.new({ gasLimit: 456, value: 123 }, 42).signAndSend(pairs.bob);
+
+  // old style
+  await blueprint.tx.new(123, 456, 42).signAndSend(pairs.bob);
+}
+
+async function checkContract (api: ApiPromise, pairs: TestKeyringMap): Promise<void> {
+  const contract = new ContractPromise(api, abiIncrementer, '0x1234');
+
+  // queries
+  await contract.query.get(pairs.alice.address, {});
+  await contract.query.get(pairs.alice.address, 0, 0);
+
+  // execute
+  await contract.tx.inc({ gasLimit: 1234 }, 123).signAndSend(pairs.eve);
+  await contract.tx.inc(123, 456, 69).signAndSend(pairs.eve);
+
+  // deprecated
+  await contract.read('get', {}).send(pairs.eve.address);
+  await contract.exec('inc', {}, 123).signAndSend(pairs.dave);
+}
+
+async function main (): Promise<void> {
+  const api = await ApiPromise.create();
+  const pairs = createTestPairs();
+
+  // eslint-disable-next-line @typescript-eslint/no-floating-promises
+  Promise.all([
+    checkBlueprint(api, pairs),
+    checkContract(api, pairs)
+  ]);
+}
+
+// eslint-disable-next-line @typescript-eslint/unbound-method
+main().catch(console.error);

packages/api-contract/src/index.ts

@@ -1,7 +1,7 @@
 // Copyright 2017-2020 @polkadot/api-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export { default as Abi } from './Abi';
+export { Abi } from './Abi';
 
 export { Blueprint as BlueprintRx, Code as CodeRx, Contract as ContractRx } from './rx';
 export { Blueprint as BlueprintPromise, Code as CodePromise, Contract as ContractPromise } from './promise';

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

@@ -7,10 +7,10 @@ import { AnyJson } from '@polkadot/types/types';
 import { ApiPromise } from '@polkadot/api';
 import { decorateMethod } from '@polkadot/api/promise';
 
-import Abi from '../Abi';
+import { Abi } from '../Abi';
-import BaseBlueprint from '../base/Blueprint';
+import { Blueprint as BaseBlueprint } from '../base';
 
-export default class Blueprint extends BaseBlueprint<'promise'> {
+export class Blueprint extends BaseBlueprint<'promise'> {
   constructor (api: ApiPromise, abi: AnyJson | Abi, codeHash: string | Hash) {
     super(api, abi, codeHash, decorateMethod);
   }

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

@@ -5,11 +5,11 @@ import { ApiPromise } from '@polkadot/api';
 import { decorateMethod } from '@polkadot/api/promise';
 import { AnyJson } from '@polkadot/types/types';
 
-import Abi from '../Abi';
+import { Abi } from '../Abi';
-import BaseCode from '../base/Code';
+import { Code as BaseCode } from '../base';
 
-export default class Code extends BaseCode<'promise'> {
+export class Code extends BaseCode<'promise'> {
-  constructor (api: ApiPromise, abi: AnyJson | Abi, wasm: Uint8Array | string | Buffer) {
+  constructor (api: ApiPromise, abi: AnyJson | Abi, wasm: Uint8Array | string | Buffer | null | undefined) {
     super(api, abi, wasm, decorateMethod);
   }
 }

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

@@ -7,10 +7,10 @@ import { AnyJson } from '@polkadot/types/types';
 import { ApiPromise } from '@polkadot/api';
 import { decorateMethod } from '@polkadot/api/promise';
 
-import Abi from '../Abi';
+import { Abi } from '../Abi';
-import BaseContract from '../base/Contract';
+import { Contract as BaseContract } from '../base';
 
-export default class Contract extends BaseContract<'promise'> {
+export class Contract extends BaseContract<'promise'> {
   constructor (api: ApiPromise, abi: AnyJson | Abi, address: string | AccountId) {
     super(api, abi, address, decorateMethod);
   }

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

@@ -1,6 +1,6 @@
 // Copyright 2017-2020 @polkadot/api-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export { default as Blueprint } from './Blueprint';
+export { Blueprint } from './Blueprint';
-export { default as Code } from './Code';
+export { Code } from './Code';
-export { default as Contract } from './Contract';
+export { Contract } from './Contract';

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

@@ -7,10 +7,10 @@ import { AnyJson } from '@polkadot/types/types';
 import { ApiRx } from '@polkadot/api';
 import { decorateMethod } from '@polkadot/api/rx';
 
-import Abi from '../Abi';
+import { Abi } from '../Abi';
-import BaseBlueprint from '../base/Blueprint';
+import { Blueprint as BaseBlueprint } from '../base';
 
-export default class Blueprint extends BaseBlueprint<'rxjs'> {
+export class Blueprint extends BaseBlueprint<'rxjs'> {
   constructor (api: ApiRx, abi: AnyJson | Abi, codeHash: string | Hash) {
     super(api, abi, codeHash, decorateMethod);
   }

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

@@ -6,11 +6,11 @@ import { AnyJson } from '@polkadot/types/types';
 import { ApiRx } from '@polkadot/api';
 import { decorateMethod } from '@polkadot/api/rx';
 
-import Abi from '../Abi';
+import { Abi } from '../Abi';
-import BaseCode from '../base/Code';
+import { Code as BaseCode } from '../base';
 
-export default class Code extends BaseCode<'rxjs'> {
+export class Code extends BaseCode<'rxjs'> {
-  constructor (api: ApiRx, abi: AnyJson | Abi, wasm: Uint8Array | string | Buffer) {
+  constructor (api: ApiRx, abi: AnyJson | Abi, wasm: Uint8Array | string | Buffer | null | undefined) {
     super(api, abi, wasm, decorateMethod);
   }
 }

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

@@ -7,10 +7,10 @@ import { AnyJson } from '@polkadot/types/types';
 import { ApiRx } from '@polkadot/api';
 import { decorateMethod } from '@polkadot/api/rx';
 
-import Abi from '../Abi';
+import { Abi } from '../Abi';
-import BaseContract from '../base/Contract';
+import { Contract as BaseContract } from '../base';
 
-export default class Contract extends BaseContract<'rxjs'> {
+export class Contract extends BaseContract<'rxjs'> {
   constructor (api: ApiRx, abi: AnyJson | Abi, address: string | AccountId) {
     super(api, abi, address, decorateMethod);
   }

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

@@ -1,6 +1,6 @@
 // Copyright 2017-2020 @polkadot/api-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export { default as Blueprint } from './Blueprint';
+export { Blueprint } from './Blueprint';
-export { default as Code } from './Code';
+export { Code } from './Code';
-export { default as Contract } from './Contract';
+export { Contract } from './Contract';

packages/api-contract/src/types.ts

@@ -2,11 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ApiTypes } from '@polkadot/api/types';
-import { ContractExecResult, ContractSelector } from '@polkadot/types/interfaces';
+import { ContractExecResultResult, ContractSelector } from '@polkadot/types/interfaces';
 import { Codec, CodecArg, TypeDef } from '@polkadot/types/types';
 
-import ApiBase from '@polkadot/api/base';
+import BN from 'bn.js';
-import Abi from './Abi';
+import { ApiBase } from '@polkadot/api/base';
+import { Text, u64 } from '@polkadot/types';
+
+import { Abi } from '.';
 
 export interface ContractBase<ApiType extends ApiTypes> {
   readonly abi: Abi;
@@ -40,7 +43,7 @@ export interface AbiMessage {
   isPayable?: boolean;
   returnType?: TypeDef | null;
   selector: ContractSelector;
-  toU8a: (params: CodecArg[]) => Uint8Array;
+  toU8a: (params: CodecArg[], additional?: Uint8Array) => Uint8Array;
 }
 
 export type AbiConstructor = AbiMessage;
@@ -51,8 +54,10 @@ export interface InterfaceContractCalls {
 }
 
 export interface ContractCallOutcome {
+  debugMessage: Text;
+  gasConsumed: u64;
   output: Codec | null;
-  result: ContractExecResult;
+  result: ContractExecResultResult;
 }
 
 export interface DecodedEvent {
@@ -64,3 +69,14 @@ export interface DecodedMessage {
   args: Codec[];
   message: AbiMessage;
 }
+
+export interface BlueprintOptions {
+  gasLimit?: BigInt | string | number | BN;
+  salt?: Uint8Array | string | null;
+  value?: BigInt | string | number | BN;
+}
+
+export interface ContractOptions {
+  gasLimit?: BigInt | BN | string | number;
+  value?: BigInt | BN | string | number;
+}

packages/api-contract/src/util.ts

@@ -1,24 +1,42 @@
-// Copyright 2017-2020 @polkadot/rpc-core authors & contributors
+// Copyright 2017-2020 @polkadot/rpc-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import { SubmittableResult } from '@polkadot/api';
 import { EventRecord } from '@polkadot/types/interfaces';
-import { Codec, Registry, TypeDef } from '@polkadot/types/types';
+import { Codec, CodecArg, Registry, TypeDef } from '@polkadot/types/types';
+import { BlueprintOptions, ContractOptions } from './types';
 
-import { Raw, createTypeUnsafe } from '@polkadot/types';
+import BN from 'bn.js';
+import { Raw } from '@polkadot/types';
+import { createTypeUnsafe } from '@polkadot/types/create';
+import { isBn, isBigInt, isNumber, isString } from '@polkadot/util';
+
+type ContractEvents = 'CodeStored' | 'ContractExecution' | 'Instantiated';
+
+type TOptions = BlueprintOptions | ContractOptions;
 
 export function formatData (registry: Registry, data: Raw, { type }: TypeDef): Codec {
   return createTypeUnsafe(registry, type, [data], true);
 }
 
-export function applyOnEvent <T> (result: SubmittableResult, type: 'CodeStored' | 'Instantiated', fn: (record: EventRecord) => T): T | undefined {
+export function applyOnEvent <T> (result: SubmittableResult, type: ContractEvents, fn: (records: EventRecord[]) => T): T | undefined {
   if (result.isInBlock || result.isFinalized) {
-    const record = result.findRecord('contracts', type);
+    const records = result.filterRecords('contracts', type);
 
-    if (record) {
+    if (records.length) {
-      return fn(record);
+      return fn(records);
     }
   }
 
   return undefined;
 }
+
+export function isOptions <T> (options: BigInt | string | number | BN | T): options is T {
+  return !(isBn(options) || isBigInt(options) || isNumber(options) || isString(options));
+}
+
+export function extractOptions <T extends TOptions> (value: BigInt | string | number | BN, params: CodecArg[]): [T, CodecArg[]] {
+  const gasLimit = params.shift() as BN;
+
+  return [{ gasLimit, value } as T, params];
+}

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

@@ -29,15 +29,6 @@
   {
     "displayName": "Entry",
     "namespace": "ink_storage::collections::stash",
-    "params": [
-      {
-        "displayName": "Hash",
-        "namespace": "ink_env::types",
-        "info": 6,
-        "type": "Hash"
-      }
-    ],
-    "info": 3,
     "sub": [
       {
         "displayName": "VacantEntry",
@@ -66,6 +57,7 @@
         "name": "Occupied"
       }
     ],
+    "info": 3,
     "type": "{\"_enum\":{\"Vacant\":\"VacantEntry\",\"Occupied\":\"Hash\"}}"
   },
   {
@@ -108,15 +100,6 @@
   {
     "displayName": "ValueEntry",
     "namespace": "ink_storage::collections::hashmap",
-    "params": [
-      {
-        "displayName": "AccountId",
-        "namespace": "ink_env::types",
-        "info": 6,
-        "type": "AccountId"
-      }
-    ],
-    "info": 9,
     "sub": [
       {
         "displayName": "AccountId",
@@ -131,6 +114,7 @@
         "name": "key_index"
       }
     ],
+    "info": 9,
     "type": "{\"value\":\"AccountId\",\"key_index\":\"u32\"}"
   },
   {
@@ -141,38 +125,6 @@
   },
   {
     "displayName": "Result",
-    "params": [
-      {
-        "info": 10,
-        "sub": [],
-        "type": "()"
-      },
-      {
-        "displayName": "Error",
-        "namespace": "dns::dns",
-        "info": 3,
-        "sub": [
-          {
-            "ext": {
-              "discriminant": 0
-            },
-            "info": 6,
-            "name": "NameAlreadyExists",
-            "type": "Null"
-          },
-          {
-            "ext": {
-              "discriminant": 1
-            },
-            "info": 6,
-            "name": "CallerIsNotOwner",
-            "type": "Null"
-          }
-        ],
-        "type": "{ _enum: [\"NameAlreadyExists\", \"CallerIsNotOwner\"] }"
-      }
-    ],
-    "info": 7,
     "sub": [
       {
         "name": "Ok",
@@ -203,9 +155,10 @@
             "type": "Null"
           }
         ],
-        "type": "{ _enum: [\"NameAlreadyExists\", \"CallerIsNotOwner\"] }"
+        "type": "{\"_enum\":[\"NameAlreadyExists\",\"CallerIsNotOwner\"]}"
       }
     ],
+    "info": 7,
     "type": "Result<(), Error>"
   },
   {
@@ -235,25 +188,17 @@
         "type": "Null"
       }
     ],
-    "type": "{ _enum: [\"NameAlreadyExists\", \"CallerIsNotOwner\"] }"
+    "type": "{\"_enum\":[\"NameAlreadyExists\",\"CallerIsNotOwner\"]}"
   },
   {
     "displayName": "Option",
-    "params": [
-      {
-        "displayName": "AccountId",
-        "namespace": "ink_env::types",
-        "info": 6,
-        "type": "AccountId"
-      }
-    ],
-    "info": 5,
     "sub": {
       "displayName": "AccountId",
       "namespace": "ink_env::types",
       "info": 6,
       "type": "AccountId"
     },
+    "info": 5,
     "type": "Option<AccountId>"
   }
 ]

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

@@ -33,15 +33,6 @@
   {
     "displayName": "Entry",
     "namespace": "ink_storage::collections::stash",
-    "params": [
-      {
-        "displayName": "AccountId",
-        "namespace": "ink_env::types",
-        "info": 6,
-        "type": "AccountId"
-      }
-    ],
-    "info": 3,
     "sub": [
       {
         "displayName": "VacantEntry",
@@ -70,6 +61,7 @@
         "name": "Occupied"
       }
     ],
+    "info": 3,
     "type": "{\"_enum\":{\"Vacant\":\"VacantEntry\",\"Occupied\":\"AccountId\"}}"
   },
   {
@@ -112,13 +104,6 @@
   {
     "displayName": "ValueEntry",
     "namespace": "ink_storage::collections::hashmap",
-    "params": [
-      {
-        "info": 6,
-        "type": "u128"
-      }
-    ],
-    "info": 9,
     "sub": [
       {
         "info": 6,
@@ -131,32 +116,12 @@
         "name": "key_index"
       }
     ],
+    "info": 9,
     "type": "{\"value\":\"u128\",\"key_index\":\"u32\"}"
   },
   {
     "displayName": "Entry",
     "namespace": "ink_storage::collections::stash",
-    "params": [
-      {
-        "info": 10,
-        "sub": [
-          {
-            "displayName": "AccountId",
-            "namespace": "ink_env::types",
-            "info": 6,
-            "type": "AccountId"
-          },
-          {
-            "displayName": "AccountId",
-            "namespace": "ink_env::types",
-            "info": 6,
-            "type": "AccountId"
-          }
-        ],
-        "type": "(AccountId, AccountId)"
-      }
-    ],
-    "info": 3,
     "sub": [
       {
         "displayName": "VacantEntry",
@@ -197,6 +162,7 @@
         "name": "Occupied"
       }
     ],
+    "info": 3,
     "type": "{\"_enum\":{\"Vacant\":\"VacantEntry\",\"Occupied\":\"(AccountId, AccountId)\"}}"
   },
   {
@@ -223,21 +189,13 @@
   },
   {
     "displayName": "Option",
-    "params": [
-      {
-        "displayName": "AccountId",
-        "namespace": "ink_env::types",
-        "info": 6,
-        "type": "AccountId"
-      }
-    ],
-    "info": 5,
     "sub": {
       "displayName": "AccountId",
       "namespace": "ink_env::types",
       "info": 6,
       "type": "AccountId"
     },
+    "info": 5,
     "type": "Option<AccountId>"
   }
 ]

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

@@ -29,13 +29,6 @@
   {
     "displayName": "Entry",
     "namespace": "ink_storage::collections::stash",
-    "params": [
-      {
-        "info": 6,
-        "type": "u32"
-      }
-    ],
-    "info": 3,
     "sub": [
       {
         "displayName": "VacantEntry",
@@ -62,6 +55,7 @@
         "name": "Occupied"
       }
     ],
+    "info": 3,
     "type": "{\"_enum\":{\"Vacant\":\"VacantEntry\",\"Occupied\":\"u32\"}}"
   },
   {
@@ -85,15 +79,6 @@
   {
     "displayName": "ValueEntry",
     "namespace": "ink_storage::collections::hashmap",
-    "params": [
-      {
-        "displayName": "AccountId",
-        "namespace": "ink_env::types",
-        "info": 6,
-        "type": "AccountId"
-      }
-    ],
-    "info": 9,
     "sub": [
       {
         "displayName": "AccountId",
@@ -108,6 +93,7 @@
         "name": "key_index"
       }
     ],
+    "info": 9,
     "type": "{\"value\":\"AccountId\",\"key_index\":\"u32\"}"
   },
   {
@@ -132,15 +118,6 @@
   {
     "displayName": "Entry",
     "namespace": "ink_storage::collections::stash",
-    "params": [
-      {
-        "displayName": "AccountId",
-        "namespace": "ink_env::types",
-        "info": 6,
-        "type": "AccountId"
-      }
-    ],
-    "info": 3,
     "sub": [
       {
         "displayName": "VacantEntry",
@@ -169,18 +146,12 @@
         "name": "Occupied"
       }
     ],
+    "info": 3,
     "type": "{\"_enum\":{\"Vacant\":\"VacantEntry\",\"Occupied\":\"AccountId\"}}"
   },
   {
     "displayName": "ValueEntry",
     "namespace": "ink_storage::collections::hashmap",
-    "params": [
-      {
-        "info": 6,
-        "type": "u32"
-      }
-    ],
-    "info": 9,
     "sub": [
       {
         "info": 6,
@@ -193,32 +164,12 @@
         "name": "key_index"
       }
     ],
+    "info": 9,
     "type": "{\"value\":\"u32\",\"key_index\":\"u32\"}"
   },
   {
     "displayName": "Entry",
     "namespace": "ink_storage::collections::stash",
-    "params": [
-      {
-        "info": 10,
-        "sub": [
-          {
-            "displayName": "AccountId",
-            "namespace": "ink_env::types",
-            "info": 6,
-            "type": "AccountId"
-          },
-          {
-            "displayName": "AccountId",
-            "namespace": "ink_env::types",
-            "info": 6,
-            "type": "AccountId"
-          }
-        ],
-        "type": "(AccountId, AccountId)"
-      }
-    ],
-    "info": 3,
     "sub": [
       {
         "displayName": "VacantEntry",
@@ -259,6 +210,7 @@
         "name": "Occupied"
       }
     ],
+    "info": 3,
     "type": "{\"_enum\":{\"Vacant\":\"VacantEntry\",\"Occupied\":\"(AccountId, AccountId)\"}}"
   },
   {
@@ -282,13 +234,6 @@
   {
     "displayName": "ValueEntry",
     "namespace": "ink_storage::collections::hashmap",
-    "params": [
-      {
-        "info": 6,
-        "type": "bool"
-      }
-    ],
-    "info": 9,
     "sub": [
       {
         "info": 6,
@@ -301,6 +246,7 @@
         "name": "key_index"
       }
     ],
+    "info": 9,
     "type": "{\"value\":\"bool\",\"key_index\":\"u32\"}"
   },
   {
@@ -309,105 +255,17 @@
   },
   {
     "displayName": "Option",
-    "params": [
-      {
-        "displayName": "AccountId",
-        "namespace": "ink_env::types",
-        "info": 6,
-        "type": "AccountId"
-      }
-    ],
-    "info": 5,
     "sub": {
       "displayName": "AccountId",
       "namespace": "ink_env::types",
       "info": 6,
       "type": "AccountId"
     },
+    "info": 5,
     "type": "Option<AccountId>"
   },
   {
     "displayName": "Result",
-    "params": [
-      {
-        "info": 10,
-        "sub": [],
-        "type": "()"
-      },
-      {
-        "displayName": "Error",
-        "namespace": "erc721::erc721",
-        "info": 3,
-        "sub": [
-          {
-            "ext": {
-              "discriminant": 0
-            },
-            "info": 6,
-            "name": "NotOwner",
-            "type": "Null"
-          },
-          {
-            "ext": {
-              "discriminant": 1
-            },
-            "info": 6,
-            "name": "NotApproved",
-            "type": "Null"
-          },
-          {
-            "ext": {
-              "discriminant": 2
-            },
-            "info": 6,
-            "name": "TokenExists",
-            "type": "Null"
-          },
-          {
-            "ext": {
-              "discriminant": 3
-            },
-            "info": 6,
-            "name": "TokenNotFound",
-            "type": "Null"
-          },
-          {
-            "ext": {
-              "discriminant": 4
-            },
-            "info": 6,
-            "name": "CannotInsert",
-            "type": "Null"
-          },
-          {
-            "ext": {
-              "discriminant": 5
-            },
-            "info": 6,
-            "name": "CannotRemove",
-            "type": "Null"
-          },
-          {
-            "ext": {
-              "discriminant": 6
-            },
-            "info": 6,
-            "name": "CannotFetchValue",
-            "type": "Null"
-          },
-          {
-            "ext": {
-              "discriminant": 7
-            },
-            "info": 6,
-            "name": "NotAllowed",
-            "type": "Null"
-          }
-        ],
-        "type": "{ _enum: [\"NotOwner\", \"NotApproved\", \"TokenExists\", \"TokenNotFound\", \"CannotInsert\", \"CannotRemove\", \"CannotFetchValue\", \"NotAllowed\"] }"
-      }
-    ],
-    "info": 7,
     "sub": [
       {
         "name": "Ok",
@@ -486,9 +344,10 @@
             "type": "Null"
           }
         ],
-        "type": "{ _enum: [\"NotOwner\", \"NotApproved\", \"TokenExists\", \"TokenNotFound\", \"CannotInsert\", \"CannotRemove\", \"CannotFetchValue\", \"NotAllowed\"] }"
+        "type": "{\"_enum\":[\"NotOwner\",\"NotApproved\",\"TokenExists\",\"TokenNotFound\",\"CannotInsert\",\"CannotRemove\",\"CannotFetchValue\",\"NotAllowed\"]}"
       }
     ],
+    "info": 7,
     "type": "Result<(), Error>"
   },
   {
@@ -566,6 +425,6 @@
         "type": "Null"
       }
     ],
-    "type": "{ _enum: [\"NotOwner\", \"NotApproved\", \"TokenExists\", \"TokenNotFound\", \"CannotInsert\", \"CannotRemove\", \"CannotFetchValue\", \"NotAllowed\"] }"
+    "type": "{\"_enum\":[\"NotOwner\",\"NotApproved\",\"TokenExists\",\"TokenNotFound\",\"CannotInsert\",\"CannotRemove\",\"CannotFetchValue\",\"NotAllowed\"]}"
   }
 ]

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

@@ -29,25 +29,6 @@
   {
     "displayName": "Entry",
     "namespace": "ink_storage::collections::stash",
-    "params": [
-      {
-        "info": 10,
-        "sub": [
-          {
-            "info": 6,
-            "type": "u32"
-          },
-          {
-            "displayName": "AccountId",
-            "namespace": "ink_env::types",
-            "info": 6,
-            "type": "AccountId"
-          }
-        ],
-        "type": "(u32, AccountId)"
-      }
-    ],
-    "info": 3,
     "sub": [
       {
         "displayName": "VacantEntry",
@@ -86,6 +67,7 @@
         "name": "Occupied"
       }
     ],
+    "info": 3,
     "type": "{\"_enum\":{\"Vacant\":\"VacantEntry\",\"Occupied\":\"(u32, AccountId)\"}}"
   },
   {
@@ -144,14 +126,6 @@
   {
     "displayName": "ValueEntry",
     "namespace": "ink_storage::collections::hashmap",
-    "params": [
-      {
-        "info": 10,
-        "sub": [],
-        "type": "()"
-      }
-    ],
-    "info": 9,
     "sub": [
       {
         "info": 10,
@@ -165,6 +139,7 @@
         "name": "key_index"
       }
     ],
+    "info": 9,
     "type": "{\"value\":\"()\",\"key_index\":\"u32\"}"
   },
   {
@@ -175,13 +150,6 @@
   {
     "displayName": "Entry",
     "namespace": "ink_storage::collections::stash",
-    "params": [
-      {
-        "info": 6,
-        "type": "u32"
-      }
-    ],
-    "info": 3,
     "sub": [
       {
         "displayName": "VacantEntry",
@@ -208,18 +176,12 @@
         "name": "Occupied"
       }
     ],
+    "info": 3,
     "type": "{\"_enum\":{\"Vacant\":\"VacantEntry\",\"Occupied\":\"u32\"}}"
   },
   {
     "displayName": "ValueEntry",
     "namespace": "ink_storage::collections::hashmap",
-    "params": [
-      {
-        "info": 6,
-        "type": "u32"
-      }
-    ],
-    "info": 9,
     "sub": [
       {
         "info": 6,
@@ -232,58 +194,12 @@
         "name": "key_index"
       }
     ],
+    "info": 9,
     "type": "{\"value\":\"u32\",\"key_index\":\"u32\"}"
   },
   {
     "displayName": "Entry",
     "namespace": "ink_storage::collections::stash",
-    "params": [
-      {
-        "displayName": "Transaction",
-        "namespace": "multisig_plain::multisig_plain",
-        "info": 9,
-        "sub": [
-          {
-            "displayName": "AccountId",
-            "namespace": "ink_env::types",
-            "info": 6,
-            "type": "AccountId",
-            "name": "callee"
-          },
-          {
-            "info": 12,
-            "length": 4,
-            "sub": {
-              "info": 6,
-              "type": "u8"
-            },
-            "type": "[u8;4]",
-            "name": "selector"
-          },
-          {
-            "info": 11,
-            "sub": {
-              "info": 6,
-              "type": "u8"
-            },
-            "type": "Vec<u8>",
-            "name": "input"
-          },
-          {
-            "info": 6,
-            "type": "u128",
-            "name": "transferred_value"
-          },
-          {
-            "info": 6,
-            "type": "u64",
-            "name": "gas_limit"
-          }
-        ],
-        "type": "{\"callee\":\"AccountId\",\"selector\":\"[u8;4]\",\"input\":\"Vec<u8>\",\"transferred_value\":\"u128\",\"gas_limit\":\"u64\"}"
-      }
-    ],
-    "info": 3,
     "sub": [
       {
         "displayName": "VacantEntry",
@@ -350,6 +266,7 @@
         "name": "Occupied"
       }
     ],
+    "info": 3,
     "type": "{\"_enum\":{\"Vacant\":\"VacantEntry\",\"Occupied\":\"Transaction\"}}"
   },
   {
@@ -424,15 +341,6 @@
   {
     "displayName": "Entry",
     "namespace": "ink_storage::collections::stash",
-    "params": [
-      {
-        "displayName": "AccountId",
-        "namespace": "ink_env::types",
-        "info": 6,
-        "type": "AccountId"
-      }
-    ],
-    "info": 3,
     "sub": [
       {
         "displayName": "VacantEntry",
@@ -461,6 +369,7 @@
         "name": "Occupied"
       }
     ],
+    "info": 3,
     "type": "{\"_enum\":{\"Vacant\":\"VacantEntry\",\"Occupied\":\"AccountId\"}}"
   },
   {
@@ -523,19 +432,6 @@
   },
   {
     "displayName": "Result",
-    "params": [
-      {
-        "info": 10,
-        "sub": [],
-        "type": "()"
-      },
-      {
-        "info": 10,
-        "sub": [],
-        "type": "()"
-      }
-    ],
-    "info": 7,
     "sub": [
       {
         "name": "Ok",
@@ -550,26 +446,11 @@
         "type": "()"
       }
     ],
+    "info": 7,
     "type": "Result<(), ()>"
   },
   {
     "displayName": "Result",
-    "params": [
-      {
-        "info": 11,
-        "sub": {
-          "info": 6,
-          "type": "u8"
-        },
-        "type": "Vec<u8>"
-      },
-      {
-        "info": 10,
-        "sub": [],
-        "type": "()"
-      }
-    ],
-    "info": 7,
     "sub": [
       {
         "name": "Ok",
@@ -587,64 +468,24 @@
         "type": "()"
       }
     ],
+    "info": 7,
     "type": "Result<Vec<u8>, ()>"
   },
   {
     "displayName": "Result",
-    "params": [
-      {
-        "displayName": "Option",
-        "params": [
-          {
-            "info": 11,
-            "sub": {
-              "info": 6,
-              "type": "u8"
-            },
-            "type": "Vec<u8>"
-          }
-        ],
-        "info": 5,
-        "sub": {
-          "info": 11,
-          "sub": {
-            "info": 6,
-            "type": "u8"
-          },
-          "type": "Vec<u8>"
-        },
-        "type": "Option<Vec<u8>>"
-      },
-      {
-        "info": 10,
-        "sub": [],
-        "type": "()"
-      }
-    ],
-    "info": 7,
     "sub": [
       {
         "name": "Ok",
         "displayName": "Option",
-        "params": [
+        "sub": {
-          {
           "info": 11,
           "sub": {
             "info": 6,
             "type": "u8"
           },
           "type": "Vec<u8>"
-          }
+        },
-        ],
         "info": 5,
-        "sub": {
-          "info": 11,
-          "sub": {
-            "info": 6,
-            "type": "u8"
-          },
-          "type": "Vec<u8>"
-        },
         "type": "Option<Vec<u8>>"
       },
       {
@@ -654,29 +495,20 @@
         "type": "()"
       }
     ],
+    "info": 7,
     "type": "Result<Option<Vec<u8>>, ()>"
   },
   {
     "displayName": "Option",
-    "params": [
+    "sub": {
-      {
       "info": 11,
       "sub": {
         "info": 6,
         "type": "u8"
       },
       "type": "Vec<u8>"
-      }
+    },
-    ],
     "info": 5,
-    "sub": {
-      "info": 11,
-      "sub": {
-        "info": 6,
-        "type": "u8"
-      },
-      "type": "Vec<u8>"
-    },
     "type": "Option<Vec<u8>>"
   }
 ]

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

@@ -0,0 +1,28 @@
+[
+  {
+    "info": 6,
+    "type": "u256"
+  },
+  {
+    "info": 6,
+    "type": "u8"
+  },
+  {
+    "info": 12,
+    "length": 32,
+    "sub": {
+      "info": 6,
+      "type": "u8"
+    },
+    "type": "[u8;32]"
+  },
+  {
+    "displayName": "AccountId",
+    "info": 6,
+    "type": "AccountId"
+  },
+  {
+    "info": 6,
+    "type": "Text"
+  }
+]

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

@@ -0,0 +1,422 @@
+[
+  {
+    "info": 6,
+    "type": "i32"
+  },
+  {
+    "info": 6,
+    "type": "u32"
+  },
+  {
+    "info": 6,
+    "type": "u8"
+  },
+  {
+    "displayName": "Variant",
+    "namespace": "enum_example::enum_example",
+    "info": 3,
+    "sub": [
+      {
+        "info": 10,
+        "sub": [],
+        "name": "None",
+        "type": "()"
+      },
+      {
+        "displayName": "Weekday",
+        "namespace": "enum_example::enum_example",
+        "info": 3,
+        "sub": [
+          {
+            "ext": {
+              "discriminant": 0
+            },
+            "info": 6,
+            "name": "Monday",
+            "type": "Null"
+          },
+          {
+            "ext": {
+              "discriminant": 1
+            },
+            "info": 6,
+            "name": "Tuesday",
+            "type": "Null"
+          },
+          {
+            "ext": {
+              "discriminant": 2
+            },
+            "info": 6,
+            "name": "Wednesday",
+            "type": "Null"
+          },
+          {
+            "ext": {
+              "discriminant": 3
+            },
+            "info": 6,
+            "name": "Thursday",
+            "type": "Null"
+          },
+          {
+            "ext": {
+              "discriminant": 4
+            },
+            "info": 6,
+            "name": "Friday",
+            "type": "Null"
+          },
+          {
+            "ext": {
+              "discriminant": 5
+            },
+            "info": 6,
+            "name": "Saturday",
+            "type": "Null"
+          },
+          {
+            "ext": {
+              "discriminant": 6
+            },
+            "info": 6,
+            "name": "Sunday",
+            "type": "Null"
+          }
+        ],
+        "type": "{\"_enum\":[\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\",\"Sunday\"]}",
+        "name": "Weekday"
+      },
+      {
+        "displayName": "TupleMaybeSigned",
+        "namespace": "enum_example::enum_example",
+        "info": 3,
+        "sub": [
+          {
+            "info": 6,
+            "type": "i32",
+            "name": "Signed"
+          },
+          {
+            "info": 6,
+            "type": "u32",
+            "name": "Unsigned"
+          }
+        ],
+        "type": "{\"_enum\":{\"Signed\":\"i32\",\"Unsigned\":\"u32\"}}",
+        "name": "TupleMaybeSigned"
+      },
+      {
+        "displayName": "NamedMaybeSigned",
+        "namespace": "enum_example::enum_example",
+        "info": 3,
+        "sub": [
+          {
+            "info": 9,
+            "sub": [
+              {
+                "info": 6,
+                "type": "i32",
+                "name": "value"
+              }
+            ],
+            "name": "Signed",
+            "type": "{\"value\":\"i32\"}"
+          },
+          {
+            "info": 9,
+            "sub": [
+              {
+                "info": 6,
+                "type": "u32",
+                "name": "value"
+              }
+            ],
+            "name": "Unsigned",
+            "type": "{\"value\":\"u32\"}"
+          }
+        ],
+        "type": "{\"_enum\":{\"Signed\":\"{\\\"value\\\":\\\"i32\\\"}\",\"Unsigned\":\"{\\\"value\\\":\\\"u32\\\"}\"}}",
+        "name": "NamedMaybeSigned"
+      },
+      {
+        "displayName": "Color",
+        "namespace": "enum_example::enum_example",
+        "info": 3,
+        "sub": [
+          {
+            "info": 10,
+            "sub": [],
+            "name": "Red",
+            "type": "()"
+          },
+          {
+            "info": 10,
+            "sub": [],
+            "name": "Blue",
+            "type": "()"
+          },
+          {
+            "info": 10,
+            "sub": [],
+            "name": "Green",
+            "type": "()"
+          },
+          {
+            "info": 10,
+            "sub": [],
+            "name": "Yellow",
+            "type": "()"
+          },
+          {
+            "info": 9,
+            "sub": [
+              {
+                "info": 6,
+                "type": "u8",
+                "name": "r"
+              },
+              {
+                "info": 6,
+                "type": "u8",
+                "name": "g"
+              },
+              {
+                "info": 6,
+                "type": "u8",
+                "name": "b"
+              }
+            ],
+            "name": "Rgb",
+            "type": "{\"r\":\"u8\",\"g\":\"u8\",\"b\":\"u8\"}"
+          },
+          {
+            "info": 9,
+            "sub": [
+              {
+                "info": 6,
+                "type": "u8",
+                "name": "r"
+              },
+              {
+                "info": 6,
+                "type": "u8",
+                "name": "g"
+              },
+              {
+                "info": 6,
+                "type": "u8",
+                "name": "b"
+              },
+              {
+                "info": 6,
+                "type": "u8",
+                "name": "a"
+              }
+            ],
+            "name": "Rgba",
+            "type": "{\"r\":\"u8\",\"g\":\"u8\",\"b\":\"u8\",\"a\":\"u8\"}"
+          }
+        ],
+        "type": "{\"_enum\":{\"Red\":\"()\",\"Blue\":\"()\",\"Green\":\"()\",\"Yellow\":\"()\",\"Rgb\":\"{\\\"r\\\":\\\"u8\\\",\\\"g\\\":\\\"u8\\\",\\\"b\\\":\\\"u8\\\"}\",\"Rgba\":\"{\\\"r\\\":\\\"u8\\\",\\\"g\\\":\\\"u8\\\",\\\"b\\\":\\\"u8\\\",\\\"a\\\":\\\"u8\\\"}\"}}",
+        "name": "Color"
+      }
+    ],
+    "type": "{\"_enum\":{\"None\":\"()\",\"Weekday\":\"Weekday\",\"TupleMaybeSigned\":\"TupleMaybeSigned\",\"NamedMaybeSigned\":\"NamedMaybeSigned\",\"Color\":\"Color\"}}"
+  },
+  {
+    "displayName": "Weekday",
+    "namespace": "enum_example::enum_example",
+    "info": 3,
+    "sub": [
+      {
+        "ext": {
+          "discriminant": 0
+        },
+        "info": 6,
+        "name": "Monday",
+        "type": "Null"
+      },
+      {
+        "ext": {
+          "discriminant": 1
+        },
+        "info": 6,
+        "name": "Tuesday",
+        "type": "Null"
+      },
+      {
+        "ext": {
+          "discriminant": 2
+        },
+        "info": 6,
+        "name": "Wednesday",
+        "type": "Null"
+      },
+      {
+        "ext": {
+          "discriminant": 3
+        },
+        "info": 6,
+        "name": "Thursday",
+        "type": "Null"
+      },
+      {
+        "ext": {
+          "discriminant": 4
+        },
+        "info": 6,
+        "name": "Friday",
+        "type": "Null"
+      },
+      {
+        "ext": {
+          "discriminant": 5
+        },
+        "info": 6,
+        "name": "Saturday",
+        "type": "Null"
+      },
+      {
+        "ext": {
+          "discriminant": 6
+        },
+        "info": 6,
+        "name": "Sunday",
+        "type": "Null"
+      }
+    ],
+    "type": "{\"_enum\":[\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\",\"Sunday\"]}"
+  },
+  {
+    "displayName": "TupleMaybeSigned",
+    "namespace": "enum_example::enum_example",
+    "info": 3,
+    "sub": [
+      {
+        "info": 6,
+        "type": "i32",
+        "name": "Signed"
+      },
+      {
+        "info": 6,
+        "type": "u32",
+        "name": "Unsigned"
+      }
+    ],
+    "type": "{\"_enum\":{\"Signed\":\"i32\",\"Unsigned\":\"u32\"}}"
+  },
+  {
+    "displayName": "NamedMaybeSigned",
+    "namespace": "enum_example::enum_example",
+    "info": 3,
+    "sub": [
+      {
+        "info": 9,
+        "sub": [
+          {
+            "info": 6,
+            "type": "i32",
+            "name": "value"
+          }
+        ],
+        "name": "Signed",
+        "type": "{\"value\":\"i32\"}"
+      },
+      {
+        "info": 9,
+        "sub": [
+          {
+            "info": 6,
+            "type": "u32",
+            "name": "value"
+          }
+        ],
+        "name": "Unsigned",
+        "type": "{\"value\":\"u32\"}"
+      }
+    ],
+    "type": "{\"_enum\":{\"Signed\":\"{\\\"value\\\":\\\"i32\\\"}\",\"Unsigned\":\"{\\\"value\\\":\\\"u32\\\"}\"}}"
+  },
+  {
+    "displayName": "Color",
+    "namespace": "enum_example::enum_example",
+    "info": 3,
+    "sub": [
+      {
+        "info": 10,
+        "sub": [],
+        "name": "Red",
+        "type": "()"
+      },
+      {
+        "info": 10,
+        "sub": [],
+        "name": "Blue",
+        "type": "()"
+      },
+      {
+        "info": 10,
+        "sub": [],
+        "name": "Green",
+        "type": "()"
+      },
+      {
+        "info": 10,
+        "sub": [],
+        "name": "Yellow",
+        "type": "()"
+      },
+      {
+        "info": 9,
+        "sub": [
+          {
+            "info": 6,
+            "type": "u8",
+            "name": "r"
+          },
+          {
+            "info": 6,
+            "type": "u8",
+            "name": "g"
+          },
+          {
+            "info": 6,
+            "type": "u8",
+            "name": "b"
+          }
+        ],
+        "name": "Rgb",
+        "type": "{\"r\":\"u8\",\"g\":\"u8\",\"b\":\"u8\"}"
+      },
+      {
+        "info": 9,
+        "sub": [
+          {
+            "info": 6,
+            "type": "u8",
+            "name": "r"
+          },
+          {
+            "info": 6,
+            "type": "u8",
+            "name": "g"
+          },
+          {
+            "info": 6,
+            "type": "u8",
+            "name": "b"
+          },
+          {
+            "info": 6,
+            "type": "u8",
+            "name": "a"
+          }
+        ],
+        "name": "Rgba",
+        "type": "{\"r\":\"u8\",\"g\":\"u8\",\"b\":\"u8\",\"a\":\"u8\"}"
+      }
+    ],
+    "type": "{\"_enum\":{\"Red\":\"()\",\"Blue\":\"()\",\"Green\":\"()\",\"Yellow\":\"()\",\"Rgb\":\"{\\\"r\\\":\\\"u8\\\",\\\"g\\\":\\\"u8\\\",\\\"b\\\":\\\"u8\\\"}\",\"Rgba\":\"{\\\"r\\\":\\\"u8\\\",\\\"g\\\":\\\"u8\\\",\\\"b\\\":\\\"u8\\\",\\\"a\\\":\\\"u8\\\"}\"}}"
+  }
+]

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

@@ -33,15 +33,6 @@
   {
     "displayName": "Entry",
     "namespace": "ink_storage::collections::stash",
-    "params": [
-      {
-        "displayName": "AccountId",
-        "namespace": "ink_env::types",
-        "info": 6,
-        "type": "AccountId"
-      }
-    ],
-    "info": 3,
     "sub": [
       {
         "displayName": "VacantEntry",
@@ -70,6 +61,7 @@
         "name": "Occupied"
       }
     ],
+    "info": 3,
     "type": "{\"_enum\":{\"Vacant\":\"VacantEntry\",\"Occupied\":\"AccountId\"}}"
   },
   {
@@ -112,13 +104,6 @@
   {
     "displayName": "ValueEntry",
     "namespace": "ink_storage::collections::hashmap",
-    "params": [
-      {
-        "info": 6,
-        "type": "u128"
-      }
-    ],
-    "info": 9,
     "sub": [
       {
         "info": 6,
@@ -131,32 +116,12 @@
         "name": "key_index"
       }
     ],
+    "info": 9,
     "type": "{\"value\":\"u128\",\"key_index\":\"u32\"}"
   },
   {
     "displayName": "Entry",
     "namespace": "ink_storage::collections::stash",
-    "params": [
-      {
-        "info": 10,
-        "sub": [
-          {
-            "displayName": "AccountId",
-            "namespace": "ink_env::types",
-            "info": 6,
-            "type": "AccountId"
-          },
-          {
-            "displayName": "AccountId",
-            "namespace": "ink_env::types",
-            "info": 6,
-            "type": "AccountId"
-          }
-        ],
-        "type": "(AccountId, AccountId)"
-      }
-    ],
-    "info": 3,
     "sub": [
       {
         "displayName": "VacantEntry",
@@ -197,6 +162,7 @@
         "name": "Occupied"
       }
     ],
+    "info": 3,
     "type": "{\"_enum\":{\"Vacant\":\"VacantEntry\",\"Occupied\":\"(AccountId, AccountId)\"}}"
   },
   {
@@ -227,21 +193,13 @@
   },
   {
     "displayName": "Option",
-    "params": [
-      {
-        "displayName": "AccountId",
-        "namespace": "ink_env::types",
-        "info": 6,
-        "type": "AccountId"
-      }
-    ],
-    "info": 5,
     "sub": {
       "displayName": "AccountId",
       "namespace": "ink_env::types",
       "info": 6,
       "type": "AccountId"
     },
+    "info": 5,
     "type": "Option<AccountId>"
   }
 ]

packages/api-contract/test/contracts/index.ts

@@ -1,6 +1,21 @@
 // Copyright 2017-2020 @polkadot/api-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export * from './ink';
+import * as ink from './ink';
-export * from './solang';
+import * as solang from './solang';
-export * from './user';
+import * as user from './user';
+
+const all: Record<string, any> = {};
+
+function addExport (type: string, abis: Record<string, any>): void {
+  Object.keys(abis).forEach((key): void => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    all[`${type}_${key}`] = abis[key];
+  });
+}
+
+addExport('ink', ink);
+addExport('solang', solang);
+addExport('user', user);
+
+export default all;

packages/api-contract/test/contracts/ink/flipper.contract.json

@@ -0,0 +1,107 @@
+{
+  "metadataVersion": "0.1.0",
+  "source": {
+    "hash": "0x98086d5ccadd437459b812682380250f51a3034272cd1108e499acc0cafe9f42",
+    "language": "ink! 3.0.0-rc2",
+    "compiler": "rustc 1.49.0-nightly",
+    "wasm": "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"
+  },
+  "contract": {
+    "name": "flipper",
+    "version": "3.0.0-rc2",
+    "authors": [
+      "Parity Technologies <admin@parity.io>"
+    ]
+  },
+  "spec": {
+    "constructors": [
+      {
+        "args": [
+          {
+            "name": "init_value",
+            "type": {
+              "displayName": [
+                "bool"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          " Creates a new flipper smart contract initialized with the given value."
+        ],
+        "name": [
+          "new"
+        ],
+        "selector": "0xd183512b"
+      },
+      {
+        "args": [],
+        "docs": [
+          " Creates a new flipper smart contract initialized to `false`."
+        ],
+        "name": [
+          "default"
+        ],
+        "selector": "0x6a3712e2"
+      }
+    ],
+    "docs": [],
+    "events": [],
+    "messages": [
+      {
+        "args": [],
+        "docs": [
+          " Flips the current value of the Flipper's bool."
+        ],
+        "mutates": true,
+        "name": [
+          "flip"
+        ],
+        "payable": false,
+        "returnType": null,
+        "selector": "0xc096a5f3"
+      },
+      {
+        "args": [],
+        "docs": [
+          " Returns the current value of the Flipper's bool."
+        ],
+        "mutates": false,
+        "name": [
+          "get"
+        ],
+        "payable": false,
+        "returnType": {
+          "displayName": [
+            "bool"
+          ],
+          "type": 1
+        },
+        "selector": "0x1e5ca456"
+      }
+    ]
+  },
+  "storage": {
+    "struct": {
+      "fields": [
+        {
+          "layout": {
+            "cell": {
+              "key": "0x0000000000000000000000000000000000000000000000000000000000000000",
+              "ty": 1
+            }
+          },
+          "name": "value"
+        }
+      ]
+    }
+  },
+  "types": [
+    {
+      "def": {
+        "primitive": "bool"
+      }
+    }
+  ]
+}

packages/api-contract/test/contracts/user/assetTransfer.json

@@ -0,0 +1,299 @@
+{
+  "contract": {
+    "authors": [
+      "unknown"
+    ],
+    "name": "AssetTransfer",
+    "version": "0.0.1"
+  },
+  "metadataVersion": "0.1.0",
+  "source": {
+    "compiler": "solang 0.1.4",
+    "hash": "0x7d163f445bec3d33e90d0f60bda40acd42f2760dbc1b731616af70a6001e05c7",
+    "language": "Solidity 0.1.4"
+  },
+  "spec": {
+    "constructors": [
+      {
+        "args": [],
+        "docs": [
+          ""
+        ],
+        "name": "new",
+        "selector": "0x861731d5"
+      }
+    ],
+    "events": [
+      {
+        "args": [
+          {
+            "indexed": false,
+            "name": "_newUser",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 4
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "name": "successfulRegistration"
+      },
+      {
+        "args": [
+          {
+            "indexed": false,
+            "name": "sender",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 4
+            }
+          },
+          {
+            "indexed": false,
+            "name": "_hexAsset",
+            "type": {
+              "display_name": [
+                "String"
+              ],
+              "type": 5
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "name": "addedAsset"
+      },
+      {
+        "args": [
+          {
+            "indexed": false,
+            "name": "sender",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 4
+            }
+          },
+          {
+            "indexed": false,
+            "name": "receiver",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 4
+            }
+          },
+          {
+            "indexed": false,
+            "name": "hexOfAsset",
+            "type": {
+              "display_name": [
+                "String"
+              ],
+              "type": 5
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "name": "assetSent"
+      }
+    ],
+    "messages": [
+      {
+        "args": [
+          {
+            "name": "_user",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 4
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": false,
+        "name": "viewBalance",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "u256"
+          ],
+          "type": 1
+        },
+        "selector": "0xc1a13d1a"
+      },
+      {
+        "args": [
+          {
+            "name": "_assetHex",
+            "type": {
+              "display_name": [
+                "String"
+              ],
+              "type": 5
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": false,
+        "name": "findOwner",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "AccountId"
+          ],
+          "type": 4
+        },
+        "selector": "0x63560a8e"
+      },
+      {
+        "args": [
+          {
+            "name": "_hexAsset",
+            "type": {
+              "display_name": [
+                "String"
+              ],
+              "type": 5
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": true,
+        "name": "addAsset",
+        "payable": false,
+        "return_type": null,
+        "selector": "0xa7c6b52e"
+      },
+      {
+        "args": [],
+        "docs": [
+          ""
+        ],
+        "mutates": true,
+        "name": "receiveAsset",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "String"
+          ],
+          "type": 5
+        },
+        "selector": "0xb2f3b5bc"
+      },
+      {
+        "args": [
+          {
+            "name": "_assetHex",
+            "type": {
+              "display_name": [
+                "String"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "_receiver",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 4
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": true,
+        "name": "sendAsset",
+        "payable": false,
+        "return_type": null,
+        "selector": "0xd6e5288f"
+      },
+      {
+        "args": [
+          {
+            "name": "_newUser",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 4
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": true,
+        "name": "register",
+        "payable": false,
+        "return_type": null,
+        "selector": "0x4420e486"
+      }
+    ]
+  },
+  "storage": {
+    "struct": {
+      "fields": []
+    }
+  },
+  "types": [
+    {
+      "def": {
+        "primitive": "u256"
+      }
+    },
+    {
+      "def": {
+        "primitive": "u8"
+      }
+    },
+    {
+      "def": {
+        "array": {
+          "len": 32,
+          "type": 2
+        }
+      }
+    },
+    {
+      "def": {
+        "composite": {
+          "fields": [
+            {
+              "type": 3
+            }
+          ]
+        }
+      },
+      "path": [
+        "AccountId"
+      ]
+    },
+    {
+      "def": {
+        "primitive": "str"
+      }
+    }
+  ]
+}

packages/api-contract/test/contracts/user/enumExample.json

@@ -0,0 +1,528 @@
+{
+  "metadataVersion": "0.1.0",
+  "source": {
+    "hash": "0x1a37c380fe02fe3b670480dff1393b0401788955315d092e39fcc06047f1413c",
+    "language": "ink! 3.0.0-rc2",
+    "compiler": "rustc 1.49.0-nightly"
+  },
+  "contract": {
+    "name": "enum_example",
+    "version": "0.1.0",
+    "authors": [
+      "[your_name] <[your_email]>"
+    ]
+  },
+  "spec": {
+    "constructors": [
+      {
+        "args": [],
+        "docs": [],
+        "name": [
+          "new"
+        ],
+        "selector": "0xd183512b"
+      }
+    ],
+    "docs": [],
+    "events": [],
+    "messages": [
+      {
+        "args": [
+          {
+            "name": "variant",
+            "type": {
+              "displayName": [
+                "Variant"
+              ],
+              "type": 4
+            }
+          }
+        ],
+        "docs": [],
+        "mutates": true,
+        "name": [
+          "set_variant"
+        ],
+        "payable": false,
+        "returnType": null,
+        "selector": "0x4fa6b9cf"
+      },
+      {
+        "args": [],
+        "docs": [],
+        "mutates": false,
+        "name": [
+          "get_variant"
+        ],
+        "payable": false,
+        "returnType": {
+          "displayName": [
+            "Variant"
+          ],
+          "type": 4
+        },
+        "selector": "0x1d5962d1"
+      }
+    ]
+  },
+  "storage": {
+    "struct": {
+      "fields": [
+        {
+          "layout": {
+            "enum": {
+              "dispatchKey": "0x0000000000000000000000000000000000000000000000000000000000000000",
+              "variants": {
+                "0": {
+                  "fields": []
+                },
+                "1": {
+                  "fields": [
+                    {
+                      "layout": {
+                        "enum": {
+                          "dispatchKey": "0x0100000000000000000000000000000000000000000000000000000000000000",
+                          "variants": {
+                            "0": {
+                              "fields": []
+                            },
+                            "1": {
+                              "fields": []
+                            },
+                            "2": {
+                              "fields": []
+                            },
+                            "3": {
+                              "fields": []
+                            },
+                            "4": {
+                              "fields": []
+                            },
+                            "5": {
+                              "fields": []
+                            },
+                            "6": {
+                              "fields": []
+                            }
+                          }
+                        }
+                      },
+                      "name": null
+                    }
+                  ]
+                },
+                "2": {
+                  "fields": [
+                    {
+                      "layout": {
+                        "enum": {
+                          "dispatchKey": "0x0100000000000000000000000000000000000000000000000000000000000000",
+                          "variants": {
+                            "0": {
+                              "fields": [
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0200000000000000000000000000000000000000000000000000000000000000",
+                                      "ty": 1
+                                    }
+                                  },
+                                  "name": null
+                                }
+                              ]
+                            },
+                            "1": {
+                              "fields": [
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0200000000000000000000000000000000000000000000000000000000000000",
+                                      "ty": 2
+                                    }
+                                  },
+                                  "name": null
+                                }
+                              ]
+                            }
+                          }
+                        }
+                      },
+                      "name": null
+                    }
+                  ]
+                },
+                "3": {
+                  "fields": [
+                    {
+                      "layout": {
+                        "enum": {
+                          "dispatchKey": "0x0100000000000000000000000000000000000000000000000000000000000000",
+                          "variants": {
+                            "0": {
+                              "fields": [
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0200000000000000000000000000000000000000000000000000000000000000",
+                                      "ty": 1
+                                    }
+                                  },
+                                  "name": "value"
+                                }
+                              ]
+                            },
+                            "1": {
+                              "fields": [
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0200000000000000000000000000000000000000000000000000000000000000",
+                                      "ty": 2
+                                    }
+                                  },
+                                  "name": "value"
+                                }
+                              ]
+                            }
+                          }
+                        }
+                      },
+                      "name": null
+                    }
+                  ]
+                },
+                "4": {
+                  "fields": [
+                    {
+                      "layout": {
+                        "enum": {
+                          "dispatchKey": "0x0100000000000000000000000000000000000000000000000000000000000000",
+                          "variants": {
+                            "0": {
+                              "fields": []
+                            },
+                            "1": {
+                              "fields": []
+                            },
+                            "2": {
+                              "fields": []
+                            },
+                            "3": {
+                              "fields": []
+                            },
+                            "4": {
+                              "fields": [
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0200000000000000000000000000000000000000000000000000000000000000",
+                                      "ty": 3
+                                    }
+                                  },
+                                  "name": "r"
+                                },
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0300000000000000000000000000000000000000000000000000000000000000",
+                                      "ty": 3
+                                    }
+                                  },
+                                  "name": "g"
+                                },
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0400000000000000000000000000000000000000000000000000000000000000",
+                                      "ty": 3
+                                    }
+                                  },
+                                  "name": "b"
+                                }
+                              ]
+                            },
+                            "5": {
+                              "fields": [
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0200000000000000000000000000000000000000000000000000000000000000",
+                                      "ty": 3
+                                    }
+                                  },
+                                  "name": "r"
+                                },
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0300000000000000000000000000000000000000000000000000000000000000",
+                                      "ty": 3
+                                    }
+                                  },
+                                  "name": "g"
+                                },
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0400000000000000000000000000000000000000000000000000000000000000",
+                                      "ty": 3
+                                    }
+                                  },
+                                  "name": "b"
+                                },
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0500000000000000000000000000000000000000000000000000000000000000",
+                                      "ty": 3
+                                    }
+                                  },
+                                  "name": "a"
+                                }
+                              ]
+                            }
+                          }
+                        }
+                      },
+                      "name": null
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "name": "last"
+        }
+      ]
+    }
+  },
+  "types": [
+    {
+      "def": {
+        "primitive": "i32"
+      }
+    },
+    {
+      "def": {
+        "primitive": "u32"
+      }
+    },
+    {
+      "def": {
+        "primitive": "u8"
+      }
+    },
+    {
+      "def": {
+        "variant": {
+          "variants": [
+            {
+              "name": "None"
+            },
+            {
+              "fields": [
+                {
+                  "type": 5
+                }
+              ],
+              "name": "Weekday"
+            },
+            {
+              "fields": [
+                {
+                  "type": 6
+                }
+              ],
+              "name": "TupleMaybeSigned"
+            },
+            {
+              "fields": [
+                {
+                  "type": 7
+                }
+              ],
+              "name": "NamedMaybeSigned"
+            },
+            {
+              "fields": [
+                {
+                  "type": 8
+                }
+              ],
+              "name": "Color"
+            }
+          ]
+        }
+      },
+      "path": [
+        "enum_example",
+        "enum_example",
+        "Variant"
+      ]
+    },
+    {
+      "def": {
+        "variant": {
+          "variants": [
+            {
+              "discriminant": 0,
+              "name": "Monday"
+            },
+            {
+              "discriminant": 1,
+              "name": "Tuesday"
+            },
+            {
+              "discriminant": 2,
+              "name": "Wednesday"
+            },
+            {
+              "discriminant": 3,
+              "name": "Thursday"
+            },
+            {
+              "discriminant": 4,
+              "name": "Friday"
+            },
+            {
+              "discriminant": 5,
+              "name": "Saturday"
+            },
+            {
+              "discriminant": 6,
+              "name": "Sunday"
+            }
+          ]
+        }
+      },
+      "path": [
+        "enum_example",
+        "enum_example",
+        "Weekday"
+      ]
+    },
+    {
+      "def": {
+        "variant": {
+          "variants": [
+            {
+              "fields": [
+                {
+                  "type": 1
+                }
+              ],
+              "name": "Signed"
+            },
+            {
+              "fields": [
+                {
+                  "type": 2
+                }
+              ],
+              "name": "Unsigned"
+            }
+          ]
+        }
+      },
+      "path": [
+        "enum_example",
+        "enum_example",
+        "TupleMaybeSigned"
+      ]
+    },
+    {
+      "def": {
+        "variant": {
+          "variants": [
+            {
+              "fields": [
+                {
+                  "name": "value",
+                  "type": 1
+                }
+              ],
+              "name": "Signed"
+            },
+            {
+              "fields": [
+                {
+                  "name": "value",
+                  "type": 2
+                }
+              ],
+              "name": "Unsigned"
+            }
+          ]
+        }
+      },
+      "path": [
+        "enum_example",
+        "enum_example",
+        "NamedMaybeSigned"
+      ]
+    },
+    {
+      "def": {
+        "variant": {
+          "variants": [
+            {
+              "name": "Red"
+            },
+            {
+              "name": "Blue"
+            },
+            {
+              "name": "Green"
+            },
+            {
+              "name": "Yellow"
+            },
+            {
+              "fields": [
+                {
+                  "name": "r",
+                  "type": 3
+                },
+                {
+                  "name": "g",
+                  "type": 3
+                },
+                {
+                  "name": "b",
+                  "type": 3
+                }
+              ],
+              "name": "Rgb"
+            },
+            {
+              "fields": [
+                {
+                  "name": "r",
+                  "type": 3
+                },
+                {
+                  "name": "g",
+                  "type": 3
+                },
+                {
+                  "name": "b",
+                  "type": 3
+                },
+                {
+                  "name": "a",
+                  "type": 3
+                }
+              ],
+              "name": "Rgba"
+            }
+          ]
+        }
+      },
+      "path": [
+        "enum_example",
+        "enum_example",
+        "Color"
+      ]
+    }
+  ]
+}

packages/api-contract/test/contracts/user/index.ts

@@ -1,4 +1,6 @@
 // Copyright 2017-2020 @polkadot/api-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+export { default as assetTransfer } from './assetTransfer.json';
+export { default as enumExample } from './enumExample.json';
 export { default as withString } from './withString.json';

packages/api-derive/package.json

@@ -1,44 +1,34 @@
 {
   "name": "@polkadot/api-derive",
-  "version": "2.4.1",
+  "version": "2.9.1",
   "description": "Common functions used across Polkadot, derived from RPC calls and storage queries.",
   "main": "index.js",
+  "sideEffects": false,
   "keywords": [
     "Polkadot",
     "Promise",
     "RxJs"
   ],
   "author": "Jaco Greeff <jacogr@gmail.com>",
-  "maintainers": [
+  "maintainers": [],
-    "Jaco Greeff <jacogr@gmail.com>"
-  ],
   "contributors": [],
   "license": "Apache-2.0",
-  "publishConfig": {
+  "repository": "github:polkadot-js/api",
-    "access": "public",
+  "bugs": "https://github.com/polkadot-js/api/issues",
-    "registry": "https://registry.npmjs.org"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/polkadot-js/api.git"
-  },
-  "bugs": {
-    "url": "https://github.com/polkadot-js/api/issues"
-  },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api-derive#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.1",
+    "@babel/runtime": "^7.12.5",
-    "@polkadot/api": "^2.4.1",
+    "@polkadot/api": "2.9.1",
-    "@polkadot/rpc-core": "^2.4.1",
+    "@polkadot/rpc-core": "2.9.1",
-    "@polkadot/rpc-provider": "^2.4.1",
+    "@polkadot/types": "2.9.1",
-    "@polkadot/types": "^2.4.1",
+    "@polkadot/util": "^4.2.1",
-    "@polkadot/util": "^3.6.1",
+    "@polkadot/util-crypto": "^4.2.1",
-    "@polkadot/util-crypto": "^3.6.1",
+    "bn.js": "^4.11.9",
-    "bn.js": "^5.1.3",
     "memoizee": "^0.4.14",
     "rxjs": "^6.6.3"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^3.6.1"
+    "@polkadot/keyring": "^4.2.1",
+    "@polkadot/rpc-provider": "2.9.1"
   }
 }

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

@@ -6,7 +6,7 @@ import { AccountId, AccountIndex, Address } from '@polkadot/types/interfaces';
 import { Observable, of } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { isU8a, assert } from '@polkadot/util';
+import { isU8a, assertReturn } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';
 
 import { memo } from '../util';
@@ -16,18 +16,14 @@ function retrieve (api: ApiInterfaceRx, address: Address | AccountId | AccountIn
     ? address
     : decodeAddress((address || '').toString());
 
-  if (decoded.length === 32) {
+  if (decoded.length > 8) {
     return of(api.registry.createType('AccountId', decoded));
   }
 
   const accountIndex = api.registry.createType('AccountIndex', decoded);
 
   return api.derive.accounts.indexToId(accountIndex.toString()).pipe(
-    map((accountId) => {
+    map((accountId) => assertReturn(accountId, 'Unable to retrieve accountId'))
-      assert(accountId, 'Unable to retrieve accountId');
-
-      return accountId;
-    })
   );
 }
 

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

@@ -20,9 +20,17 @@ type FlagsIntermediate = [
   AccountId | undefined
 ];
 
-function isIncludedFn (accountId: AccountId | Address | string): (_: AccountId | Address |string) => boolean {
+function parseFlags (address: AccountId | Address | string | null | undefined, [electionsMembers, councilMembers, technicalCommitteeMembers, societyMembers, sudoKey]: FlagsIntermediate): DeriveAccountFlags {
-  return function (id: AccountId | Address | string): boolean {
+  const isIncluded = (id: AccountId | Address | string) =>
-    return id.toString() === accountId.toString();
+    address
+      ? id.toString() === address.toString()
+      : false;
+
+  return {
+    isCouncil: (electionsMembers?.map(([id]: ITuple<[AccountId, Balance]>) => id) || councilMembers || []).some(isIncluded),
+    isSociety: (societyMembers || []).some(isIncluded),
+    isSudo: sudoKey?.toString() === address?.toString(),
+    isTechCommittee: (technicalCommitteeMembers || []).some(isIncluded)
   };
 }
 
@@ -34,8 +42,7 @@ export function flags (instanceId: string, api: ApiInterfaceRx): (address?: Acco
   return memo(instanceId, (address?: AccountId | Address | string | null): Observable<DeriveAccountFlags> => {
     const councilSection = api.query.electionsPhragmen ? 'electionsPhragmen' : 'elections';
 
-    return (
+    return combineLatest<FlagsIntermediate>([
-      combineLatest([
       address && api.query[councilSection]?.members
         ? api.query[councilSection].members()
         : of(undefined),
@@ -51,18 +58,8 @@ export function flags (instanceId: string, api: ApiInterfaceRx): (address?: Acco
       address && api.query.sudo?.key
         ? api.query.sudo.key()
         : of(undefined)
-      ]) as Observable<FlagsIntermediate>
+    ]).pipe(
-    ).pipe(
+      map((result) => parseFlags(address, result))
-      map(([electionsMembers, councilMembers, technicalCommitteeMembers, societyMembers, sudoKey]): DeriveAccountFlags => {
-        const isIncluded = address ? isIncludedFn(address) : (): boolean => false;
-
-        return {
-          isCouncil: (electionsMembers?.map(([id]: ITuple<[AccountId, Balance]>) => id) || councilMembers || []).some(isIncluded),
-          isSociety: (societyMembers || []).some(isIncluded),
-          isSudo: sudoKey?.toString() === address?.toString(),
-          isTechCommittee: (technicalCommitteeMembers || []).some(isIncluded)
-        };
-      })
     );
   });
 }

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

@@ -12,14 +12,14 @@ import { decodeAddress } from '@polkadot/util-crypto';
 
 import { memo } from '../util';
 
-function retrieve (api: ApiInterfaceRx, address: Address | AccountId | AccountIndex | string | null | undefined): Observable<AccountIdAndIndex> {
+function retrieve (api: ApiInterfaceRx, address: Address | AccountId | AccountIndex | Uint8Array | 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) {
+    if (decoded.length > 8) {
       const accountId = api.registry.createType('AccountId', decoded);
 
       return api.derive.accounts.idToIndex(accountId).pipe(
@@ -39,7 +39,7 @@ function retrieve (api: ApiInterfaceRx, address: Address | AccountId | AccountIn
 
 /**
  * @name idAndIndex
- * @param {(Address | AccountId | AccountIndex | string | null)} address - An accounts address in various formats.
+ * @param {(Address | AccountId | AccountIndex | Uint8Array | string | null)} address - An accounts address in various formats.
  * @description  An array containing the [[AccountId]] and [[AccountIndex]] as optional values.
  * @example
  * <BR>
@@ -50,7 +50,7 @@ function retrieve (api: ApiInterfaceRx, address: Address | AccountId | AccountIn
  * });
  * ```
  */
-export function idAndIndex (instanceId: string, api: ApiInterfaceRx): (address?: Address | AccountId | AccountIndex | string | null) => Observable<AccountIdAndIndex> {
+export function idAndIndex (instanceId: string, api: ApiInterfaceRx): (address?: Address | AccountId | AccountIndex | Uint8Array | string | null) => Observable<AccountIdAndIndex> {
-  return memo(instanceId, (address?: Address | AccountId | AccountIndex | string | null): Observable<AccountIdAndIndex> =>
+  return memo(instanceId, (address?: Address | AccountId | AccountIndex | Uint8Array | string | null): Observable<AccountIdAndIndex> =>
     retrieve(api, address));
 }

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

@@ -0,0 +1,126 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { AccountId, IdentityInfoAdditional, Registration } from '@polkadot/types/interfaces';
+import { ITuple } from '@polkadot/types/types';
+import { DeriveAccountRegistration, DeriveHasIdentity } from '../types';
+
+import { Observable, combineLatest, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { Data, Option } from '@polkadot/types';
+import { u8aToString } from '@polkadot/util';
+
+import { memo } from '../util';
+
+const UNDEF_HEX = { toHex: () => undefined };
+
+function dataAsString (data: Data): string | undefined {
+  return data.isRaw
+    ? u8aToString(data.asRaw.toU8a(true))
+    : data.isNone
+      ? undefined
+      : data.toHex();
+}
+
+function extractOther (additional: IdentityInfoAdditional[]): Record<string, string> {
+  return additional.reduce((other: Record<string, string>, [_key, _value]): Record<string, string> => {
+    const key = dataAsString(_key);
+    const value = dataAsString(_value);
+
+    if (key && value) {
+      other[key] = value;
+    }
+
+    return other;
+  }, {});
+}
+
+function extractIdentity (identityOfOpt?: Option<Registration>, superOf?: [AccountId, Data]): DeriveAccountRegistration {
+  if (!identityOfOpt?.isSome) {
+    return { judgements: [] };
+  }
+
+  const { info, judgements } = identityOfOpt.unwrap();
+  const topDisplay = dataAsString(info.display);
+
+  return {
+    display: (superOf && dataAsString(superOf[1])) || topDisplay,
+    displayParent: superOf && topDisplay,
+    email: dataAsString(info.email),
+    image: dataAsString(info.image),
+    judgements,
+    legal: dataAsString(info.legal),
+    other: extractOther(info.additional),
+    parent: superOf && superOf[0],
+    pgp: info.pgpFingerprint.unwrapOr(UNDEF_HEX).toHex(),
+    riot: dataAsString(info.riot),
+    twitter: dataAsString(info.twitter),
+    web: dataAsString(info.web)
+  };
+}
+
+function getParent (api: ApiInterfaceRx, identityOfOpt: Option<Registration> | undefined, superOfOpt: Option<ITuple<[AccountId, Data]>> | undefined): Observable<[Option<Registration> | undefined, [AccountId, Data] | undefined]> {
+  if (identityOfOpt?.isSome) {
+    // this identity has something set
+    return of([identityOfOpt, undefined]);
+  } else if (superOfOpt?.isSome) {
+    const superOf = superOfOpt.unwrap();
+
+    // we have a super
+    return combineLatest([
+      api.query.identity.identityOf<Option<Registration>>(superOf[0]),
+      of(superOf)
+    ]);
+  }
+
+  // nothing of value returned
+  return of([undefined, undefined]);
+}
+
+export function _identityBase (instanceId: string, api: ApiInterfaceRx): (accountId?: AccountId | Uint8Array | string) => Observable<[Option<Registration> | undefined, Option<ITuple<[AccountId, Data]>> | undefined]> {
+  return memo(instanceId, (accountId?: AccountId | Uint8Array | string): Observable<[Option<Registration> | undefined, Option<ITuple<[AccountId, Data]>> | undefined]> =>
+    accountId && api.query.identity?.identityOf
+      ? api.queryMulti<[Option<Registration>, Option<ITuple<[AccountId, Data]>>]>([
+        [api.query.identity.identityOf, accountId],
+        [api.query.identity.superOf, accountId]
+      ])
+      : of([undefined, undefined])
+  );
+}
+
+/**
+ * @name identity
+ * @description Returns identity info for an account
+ */
+export function identity (instanceId: string, api: ApiInterfaceRx): (accountId?: AccountId | Uint8Array | string) => Observable<DeriveAccountRegistration> {
+  return memo(instanceId, (accountId?: AccountId | Uint8Array | string): Observable<DeriveAccountRegistration> =>
+    api.derive.accounts._identityBase(accountId).pipe(
+      switchMap(([identityOfOpt, superOfOpt]) => getParent(api, identityOfOpt, superOfOpt)),
+      map(([identityOfOpt, superOf]) => extractIdentity(identityOfOpt, superOf))
+    )
+  );
+}
+
+export function hasIdentity (instanceId: string, api: ApiInterfaceRx): (accountId: AccountId | Uint8Array | string) => Observable<DeriveHasIdentity> {
+  return memo(instanceId, (accountId: AccountId | Uint8Array | string): Observable<DeriveHasIdentity> =>
+    api.derive.accounts._identityBase(accountId).pipe(
+      map(([identityOfOpt, superOfOpt]: [Option<Registration> | undefined, Option<ITuple<[AccountId, Data]>> | undefined]): DeriveHasIdentity => {
+        const parentId = superOfOpt && superOfOpt.isSome
+          ? superOfOpt.unwrap()[0].toString()
+          : null;
+        const hasIdentity = !!parentId || !!(identityOfOpt && identityOfOpt.isSome);
+
+        return { hasIdentity, parentId };
+      })
+    )
+  );
+}
+
+export function hasIdentityMulti (instanceId: string, api: ApiInterfaceRx): (accountIds: (AccountId | Uint8Array | string)[]) => Observable<DeriveHasIdentity[]> {
+  return memo(instanceId, (accountIds: (AccountId | Uint8Array | string)[]): Observable<DeriveHasIdentity[]> =>
+    combineLatest(
+      accountIds.map((accountId) => api.derive.accounts.hasIdentity(accountId))
+    )
+  );
+}

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

@@ -5,6 +5,7 @@ export * from './accountId';
 export * from './flags';
 export * from './idAndIndex';
 export * from './idToIndex';
+export * from './identity';
 export * from './indexToId';
 export * from './indexes';
 export * from './info';

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

@@ -2,25 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { AccountId, AccountIndex, Address, Balance, Registration } from '@polkadot/types/interfaces';
+import { AccountId, AccountIndex, Address, Balance } from '@polkadot/types/interfaces';
 import { ITuple } from '@polkadot/types/types';
 import { DeriveAccountInfo, DeriveAccountRegistration } from '../types';
 
 import { Observable, combineLatest, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
-import { Bytes, Data, Option, u32 } from '@polkadot/types';
+import { Bytes, Option, u32 } from '@polkadot/types';
 import { u8aToString } from '@polkadot/util';
 
 import { memo } from '../util';
 
-function dataAsString (data: Data): string | undefined {
-  return data.isRaw
-    ? u8aToString(data.asRaw.toU8a(true))
-    : data.isNone
-      ? undefined
-      : data.toHex();
-}
-
 function retrieveNick (api: ApiInterfaceRx, accountId?: AccountId): Observable<string | undefined> {
   return ((
     accountId && api.query.nicks?.nameOf
@@ -35,90 +27,17 @@ function retrieveNick (api: ApiInterfaceRx, accountId?: AccountId): Observable<s
   );
 }
 
-function extractIdentity (identityOfOpt?: Option<Registration>, superOf?: [AccountId, Data]): DeriveAccountRegistration {
-  if (!identityOfOpt?.isSome) {
-    return { judgements: [] };
-  }
-
-  const { info, judgements } = identityOfOpt.unwrap();
-  const topDisplay = dataAsString(info.display);
-
-  return {
-    display: superOf
-      ? dataAsString(superOf[1]) || topDisplay
-      : topDisplay,
-    displayParent: superOf
-      ? topDisplay
-      : undefined,
-    email: dataAsString(info.email),
-    image: dataAsString(info.image),
-    judgements,
-    legal: dataAsString(info.legal),
-    other: info.additional.reduce((other: Record<string, string>, [_key, _value]): Record<string, string> => {
-      const key = dataAsString(_key);
-      const value = dataAsString(_value);
-
-      if (key && value) {
-        other[key] = value;
-      }
-
-      return other;
-    }, {}),
-    parent: superOf
-      ? superOf[0]
-      : undefined,
-    pgp: info.pgpFingerprint.isSome
-      ? info.pgpFingerprint.unwrap().toHex()
-      : undefined,
-    riot: dataAsString(info.riot),
-    twitter: dataAsString(info.twitter),
-    web: dataAsString(info.web)
-  };
-}
-
-function retrieveIdentity (api: ApiInterfaceRx, accountId?: AccountId): Observable<DeriveAccountRegistration> {
-  return ((
-    accountId && api.query.identity?.identityOf
-      ? api.queryMulti([
-        [api.query.identity.identityOf, accountId],
-        [api.query.identity.superOf, accountId]
-      ])
-      : of([undefined, undefined])
-  ) as Observable<[Option<Registration> | undefined, Option<ITuple<[AccountId, Data]>> | undefined]>).pipe(
-    switchMap(([identityOfOpt, superOfOpt]): Observable<[Option<Registration> | undefined, [AccountId, Data] | undefined]> => {
-      if (identityOfOpt?.isSome) {
-        // this identity has something set
-        return of([identityOfOpt, undefined]);
-      } else if (superOfOpt?.isSome) {
-        const superOf = superOfOpt.unwrap();
-
-        // we have a super
-        return combineLatest([
-          api.query.identity.identityOf<Option<Registration>>(superOf[0]),
-          of(superOf)
-        ]);
-      }
-
-      // nothing of value returned
-      return of([undefined, undefined]);
-    }),
-    map(([identityOfOpt, superOf]): DeriveAccountRegistration =>
-      extractIdentity(identityOfOpt, superOf)
-    )
-  );
-}
-
 /**
  * @name info
  * @description Returns aux. info with regards to an account, current that includes the accountId, accountIndex and nickname
  */
-export function info (instanceId: string, api: ApiInterfaceRx): (address?: AccountIndex | AccountId | Address | string | null) => Observable<DeriveAccountInfo> {
+export function info (instanceId: string, api: ApiInterfaceRx): (address?: AccountIndex | AccountId | Address | Uint8Array | string | null) => Observable<DeriveAccountInfo> {
-  return memo(instanceId, (address?: AccountIndex | AccountId | Address | string | null): Observable<DeriveAccountInfo> =>
+  return memo(instanceId, (address?: AccountIndex | AccountId | Address | Uint8Array | string | null): Observable<DeriveAccountInfo> =>
     api.derive.accounts.idAndIndex(address).pipe(
       switchMap(([accountId, accountIndex]): Observable<[Partial<DeriveAccountInfo>, DeriveAccountRegistration, string?]> =>
         combineLatest([
           of({ accountId, accountIndex }),
-          retrieveIdentity(api, accountId),
+          api.derive.accounts.identity(accountId),
           retrieveNick(api, accountId)
         ])
       ),

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

@@ -35,3 +35,8 @@ export interface DeriveAccountInfo {
   identity: DeriveAccountRegistration;
   nickname?: string;
 }
+
+export interface DeriveHasIdentity {
+  hasIdentity: boolean;
+  parentId: string | null;
+}

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

@@ -16,9 +16,16 @@ import { memo } from '../util';
 type ResultBalance = [VestingInfo | null, (BalanceLock | BalanceLockTo212)[]];
 type Result = [DeriveBalancesAccount, BlockNumber, ResultBalance];
 
+interface AllLocked {
+  allLocked: boolean,
+  lockedBalance: Balance,
+  lockedBreakdown: (BalanceLock | BalanceLockTo212)[],
+  vestingLocked: Balance
+}
+
 const VESTING_ID = '0x76657374696e6720';
 
-function calcBalances (api: ApiInterfaceRx, [{ accountId, accountNonce, freeBalance, frozenFee, frozenMisc, reservedBalance, votingBalance }, bestNumber, [vesting, locks]]: Result): DeriveBalancesAll {
+function calcLocked (api: ApiInterfaceRx, bestNumber: BlockNumber, locks: (BalanceLock | BalanceLockTo212)[]): AllLocked {
   let lockedBalance = api.registry.createType('Balance');
   let lockedBreakdown: (BalanceLock | BalanceLockTo212)[] = [];
   let vestingLocked = api.registry.createType('Balance');
@@ -27,18 +34,22 @@ function calcBalances (api: ApiInterfaceRx, [{ accountId, accountNonce, freeBala
   if (Array.isArray(locks)) {
     // only get the locks that are valid until passed the current block
     lockedBreakdown = (locks as BalanceLockTo212[]).filter(({ until }): boolean => !until || (bestNumber && until.gt(bestNumber)));
-
-    const notAll = lockedBreakdown.filter(({ amount }) => !amount.isMax());
-
     allLocked = lockedBreakdown.some(({ amount }) => amount.isMax());
     vestingLocked = api.registry.createType('Balance', lockedBreakdown.filter(({ id }) => id.eq(VESTING_ID)).reduce((result: BN, { amount }) => result.iadd(amount), new BN(0)));
 
     // get the maximum of the locks according to https://github.com/paritytech/substrate/blob/master/srml/balances/src/lib.rs#L699
+    const notAll = lockedBreakdown.filter(({ amount }) => !amount.isMax());
+
     if (notAll.length) {
       lockedBalance = api.registry.createType('Balance', bnMax(...notAll.map(({ amount }): Balance => amount)));
     }
   }
 
+  return { allLocked, lockedBalance, lockedBreakdown, vestingLocked };
+}
+
+function calcBalances (api: ApiInterfaceRx, [{ accountId, accountNonce, freeBalance, frozenFee, frozenMisc, reservedBalance, votingBalance }, bestNumber, [vesting, locks]]: Result): DeriveBalancesAll {
+  const { allLocked, lockedBalance, lockedBreakdown, vestingLocked } = calcLocked(api, bestNumber, locks);
   // Calculate the vesting balances,
   //  - offset = balance locked at startingBlock
   //  - perBlock is the unlock amount

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

@@ -17,12 +17,12 @@ import { memo } from '../util';
  * <BR>
  *
  * ```javascript
- * const { author, number } = await api.derive.chain.getHeader('0x123...456');
+ * const { author, block } = await api.derive.chain.getBlock('0x123...456');
  *
- * console.log(`block #${number} was authored by ${author}`);
+ * console.log(`block #${block.header.number} was authored by ${author}`);
  * ```
  */
-export function getHeader (instanceId: string, api: ApiInterfaceRx): (hash: Uint8Array | string) => Observable<SignedBlockExtended | undefined> {
+export function getBlock (instanceId: string, api: ApiInterfaceRx): (hash: Uint8Array | string) => Observable<SignedBlockExtended | undefined> {
   return memo(instanceId, (hash: Uint8Array | string): Observable<SignedBlockExtended | undefined> =>
     combineLatest([
       api.rpc.chain.getBlock(hash),
@@ -35,7 +35,7 @@ export function getHeader (instanceId: string, api: ApiInterfaceRx): (hash: Uint
       ),
       catchError((): Observable<undefined> =>
         // where rpc.chain.getHeader throws, we will land here - it can happen that
-        // we supplied an invalid hash. (Due to defaults, storeage will have an
+        // we supplied an invalid hash. (Due to defaults, storage will have an
         // empty value, so only the RPC is affected). So return undefined
         of()
       )

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

@@ -5,5 +5,6 @@ export * from './bestNumber';
 export * from './bestNumberFinalized';
 export * from './bestNumberLag';
 export * from './getHeader';
+export * from './getBlock';
 export * from './subscribeNewBlocks';
 export * from './subscribeNewHeads';

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

@@ -6,20 +6,20 @@ import { Hash, Proposal, Votes } from '@polkadot/types/interfaces';
 import { DeriveCollectiveProposal } from '../types';
 
 import { Observable, combineLatest, of } from 'rxjs';
-import { map, switchMap } from 'rxjs/operators';
+import { catchError, map, switchMap } from 'rxjs/operators';
 import { Option } from '@polkadot/types';
 import { isFunction } from '@polkadot/util';
 
 import { memo } from '../util';
 
-type Result = [Hash[], Option<Proposal>[], Option<Votes>[]];
+type Result = [(Hash | Uint8Array | string)[], (Option<Proposal> | null)[], Option<Votes>[]];
 
-function parse ([hashes, proposals, votes]: Result): DeriveCollectiveProposal[] {
+function parse (api: ApiInterfaceRx, [hashes, proposals, votes]: Result): DeriveCollectiveProposal[] {
   return proposals
     .map((proposalOpt, index): DeriveCollectiveProposal | null =>
-      proposalOpt.isSome
+      proposalOpt && proposalOpt.isSome
         ? {
-          hash: hashes[index],
+          hash: api.registry.createType('Hash', hashes[index]),
           proposal: proposalOpt.unwrap(),
           votes: votes[index].unwrapOr(null)
         }
@@ -28,21 +28,46 @@ function parse ([hashes, proposals, votes]: Result): DeriveCollectiveProposal[]
     .filter((proposal): proposal is DeriveCollectiveProposal => !!proposal);
 }
 
-export function proposals (instanceId: string, api: ApiInterfaceRx, section: 'council' | 'technicalCommittee'): () => Observable<DeriveCollectiveProposal[]> {
+function _proposalsFrom (instanceId: string, api: ApiInterfaceRx, section: 'council' | 'technicalCommittee' = 'council'): (hashes: (Hash | Uint8Array | string)[]) => Observable<DeriveCollectiveProposal[]> {
+  return memo(instanceId, (hashes: (Hash | Uint8Array | string)[]): Observable<DeriveCollectiveProposal[]> =>
+    (isFunction(api.query[section]?.proposals) && hashes.length
+      ? combineLatest<Result>([
+        of(hashes),
+        combineLatest(hashes.map((hash) =>
+          // this should simply be api.query[section].proposalOf.multi<Option<Proposal>>(hashes),
+          // however we have had cases on Edgeware where the indices have moved around after an
+          // upgrade, which results in invalid on-chain data
+          api.query[section].proposalOf(hash).pipe(catchError(() => of(null)))
+        )),
+        api.query[section].voting.multi<Option<Votes>>(hashes)
+      ])
+      : of([[], [], []] as Result)
+    ).pipe(
+      map((result) => parse(api, result))
+    )
+  );
+}
+
+export function proposals (instanceId: string, api: ApiInterfaceRx, section: 'council' | 'technicalCommittee' = 'council'): () => Observable<DeriveCollectiveProposal[]> {
+  const proposalsFrom = _proposalsFrom(instanceId, api, section);
+
   return memo(instanceId, (): Observable<DeriveCollectiveProposal[]> =>
     isFunction(api.query[section]?.proposals)
       ? api.query[section].proposals().pipe(
-        switchMap((hashes: Hash[]): Observable<Result> =>
+        switchMap(proposalsFrom)
-          hashes.length
-            ? combineLatest([
-              of(hashes),
-              api.query[section].proposalOf.multi<Option<Proposal>>(hashes),
-              api.query[section].voting.multi<Option<Votes>>(hashes)
-            ])
-            : of([[], [], []])
-        ),
-        map(parse)
       )
       : of([] as DeriveCollectiveProposal[])
   );
 }
+
+export function proposal (instanceId: string, api: ApiInterfaceRx, section: 'council' | 'technicalCommittee' = 'council'): (hash: Hash | Uint8Array | string) => Observable<DeriveCollectiveProposal | null> {
+  const proposalsFrom = _proposalsFrom(instanceId, api, section);
+
+  return memo(instanceId, (hash: Hash | Uint8Array | string): Observable<DeriveCollectiveProposal | null> =>
+    isFunction(api.query[section]?.proposals)
+      ? proposalsFrom([hash]).pipe(
+        map(([proposal]) => proposal)
+      )
+      : of(null)
+  );
+}

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

@@ -2,12 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { DeriveCollectiveProposals } from '../types';
+import { Hash } from '@polkadot/types/interfaces';
+import { DeriveCollectiveProposal } from '../types';
 
 import { Observable } from 'rxjs';
-import { proposals as collectiveProposals } from '../collective';
+import { proposal as collectiveProposal, proposals as collectiveProposals } from '../collective';
 import { memo } from '../util';
 
-export function proposals (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveCollectiveProposals> {
+export function proposal (instanceId: string, api: ApiInterfaceRx): (hash: Hash | Uint8Array | string) => Observable<DeriveCollectiveProposal | null> {
-  return memo(instanceId, collectiveProposals(instanceId, api, 'council'));
+  return memo(instanceId, collectiveProposal(instanceId, api));
+}
+
+export function proposals (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveCollectiveProposal[]> {
+  return memo(instanceId, collectiveProposals(instanceId, api));
 }

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2020 @polkadot/api-derive authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { AccountId, ReferendumInfo, ReferendumInfoTo239, VotingDelegating, VotingDirect, VotingDirectVote } from '@polkadot/types/interfaces';
+import { AccountId, ReferendumInfo, ReferendumInfoFinished, ReferendumInfoTo239, Vote, VotingDelegating, VotingDirect, VotingDirectVote } from '@polkadot/types/interfaces';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { DeriveDemocracyLock } from '../types';
 
@@ -9,27 +9,26 @@ import BN from 'bn.js';
 import { Observable, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
 import { Option } from '@polkadot/types';
-import { isUndefined } from '@polkadot/util';
+import { BN_ZERO, isUndefined } from '@polkadot/util';
 
 import { memo } from '../util';
 
 const LOCKUPS = [0, 1, 2, 4, 8, 16, 32];
-const ZERO = new BN(0);
+
+function parseEnd (api: ApiInterfaceRx, vote: Vote, { approved, end }: ReferendumInfoFinished): [BN, BN] {
+  return [
+    end,
+    (approved.isTrue && vote.isAye) || (approved.isFalse && vote.isNay)
+      ? end.add(api.consts.democracy.enactmentPeriod.muln(LOCKUPS[vote.conviction.index]))
+      : BN_ZERO
+  ];
+}
 
 function parseLock (api: ApiInterfaceRx, [referendumId, accountVote]: VotingDirectVote, referendum: ReferendumInfo): DeriveDemocracyLock {
   const { balance, vote } = accountVote.asStandard;
-  let unlockAt = ZERO;
+  const [referendumEnd, unlockAt] = referendum.isFinished
-  let referendumEnd = ZERO;
+    ? parseEnd(api, vote, referendum.asFinished)
-
+    : [BN_ZERO, BN_ZERO];
-  if (referendum.isFinished) {
-    const { approved, end } = referendum.asFinished;
-
-    referendumEnd = end;
-
-    if ((approved.isTrue && vote.isAye) || (approved.isFalse && vote.isNay)) {
-      unlockAt = end.add(api.consts.democracy.enactmentPeriod.muln(LOCKUPS[vote.conviction.index]));
-    }
-  }
 
   return { balance, isDelegated: false, isFinished: referendum.isFinished, referendumEnd, referendumId, unlockAt, vote };
 }

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

@@ -40,11 +40,8 @@ function votesPrev (api: ApiInterfaceRx, referendumId: BN): Observable<DeriveRef
   );
 }
 
-function votesCurr (api: ApiInterfaceRx, referendumId: BN): Observable<DeriveReferendumVote[]> {
+function extractVotes (mapped: [AccountId, Voting][], referendumId: BN): DeriveReferendumVote[] {
-  return api.query.democracy.votingOf.entries<Voting>().pipe(
+  return mapped
-    map((allVoting): DeriveReferendumVote[] => {
-      const mapped = allVoting.map(([key, voting]): [AccountId, Voting] => [key.args[0] as AccountId, voting]);
-      const votes = mapped
     .filter(([, voting]) => voting.isDirect)
     .map(([accountId, voting]): [AccountId, VotingDirectVote[]] => [
       accountId,
@@ -65,6 +62,13 @@ function votesCurr (api: ApiInterfaceRx, referendumId: BN): Observable<DeriveRef
         return result;
       }, result), []
     );
+}
+
+function votesCurr (api: ApiInterfaceRx, referendumId: BN): Observable<DeriveReferendumVote[]> {
+  return api.query.democracy.votingOf.entries<Voting>().pipe(
+    map((allVoting): DeriveReferendumVote[] => {
+      const mapped = allVoting.map(([key, voting]): [AccountId, Voting] => [key.args[0] as AccountId, voting]);
+      const votes = extractVotes(mapped, referendumId);
       const delegations = mapped
         .filter(([, voting]) => voting.isDelegating)
         .map(([accountId, voting]): [AccountId, VotingDelegating] => [accountId, voting.asDelegating]);

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

@@ -58,18 +58,22 @@ export function compareRationals (n1: BN, d1: BN, n2: BN, d2: BN): boolean {
   }
 }
 
-export function calcPassing (threshold: VoteThreshold, sqrtElectorate: BN, { votedAye, votedNay, votedTotal }: ApproxState): boolean {
+function calcPassingOther (threshold: VoteThreshold, sqrtElectorate: BN, { votedAye, votedNay, votedTotal }: ApproxState): boolean {
   const sqrtVoters = bnSqrt(votedTotal);
 
   return sqrtVoters.isZero()
     ? false
-    : threshold.isSimplemajority
-      ? votedAye.gt(votedNay)
     : threshold.isSupermajorityapproval
       ? compareRationals(votedNay, sqrtVoters, votedAye, sqrtElectorate)
       : compareRationals(votedNay, sqrtElectorate, votedAye, sqrtVoters);
 }
 
+export function calcPassing (threshold: VoteThreshold, sqrtElectorate: BN, state: ApproxState): boolean {
+  return threshold.isSimplemajority
+    ? state.votedAye.gt(state.votedNay)
+    : calcPassingOther(threshold, sqrtElectorate, state);
+}
+
 function calcVotesPrev (votesFor: DeriveReferendumVote[]): DeriveReferendumVoteState {
   return votesFor.reduce((state: DeriveReferendumVoteState, derived): DeriveReferendumVoteState => {
     const { balance, vote } = derived;
@@ -92,16 +96,7 @@ function calcVotesPrev (votesFor: DeriveReferendumVote[]): DeriveReferendumVoteS
     state.votedTotal.iadd(counted);
 
     return state;
-  }, {
+  }, { allAye: [], allNay: [], voteCount: 0, voteCountAye: 0, voteCountNay: 0, votedAye: new BN(0), votedNay: new BN(0), votedTotal: new BN(0) });
-    allAye: [],
-    allNay: [],
-    voteCount: 0,
-    voteCountAye: 0,
-    voteCountNay: 0,
-    votedAye: new BN(0),
-    votedNay: new BN(0),
-    votedTotal: new BN(0)
-  });
 }
 
 function calcVotesCurrent (tally: Tally, votes: DeriveReferendumVote[]): DeriveReferendumVoteState {

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

@@ -6,9 +6,9 @@
 /* eslint-disable @typescript-eslint/restrict-template-expressions */
 
 import { Observable, from } from 'rxjs';
-import ApiRx from '@polkadot/api/rx/Api';
+import { ApiRx } from '@polkadot/api/rx';
-import MockProvider from '@polkadot/rpc-provider/mock';
+import { MockProvider } from '@polkadot/rpc-provider/mock';
-import { TypeRegistry } from '@polkadot/types';
+import { TypeRegistry } from '@polkadot/types/create';
 
 import { ExactDerive } from '.';
 

packages/api-derive/src/index.ts

@@ -92,7 +92,7 @@ function injectFunctions<AllSections> (instanceId: string, api: ApiInterfaceRx,
 // FIXME The return type of this function should be {...ExactDerive, ...DeriveCustom}
 // For now we just drop the custom derive typings
 /** @internal */
-export default function decorateDerive (instanceId: string, api: ApiInterfaceRx, custom: DeriveCustom = {}): ExactDerive {
+export function decorateDerive (instanceId: string, api: ApiInterfaceRx, custom: DeriveCustom = {}): ExactDerive {
   return {
     ...injectFunctions(instanceId, api, derive),
     ...injectFunctions(instanceId, api, custom)

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

@@ -10,6 +10,7 @@ import { map } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 
 import { memo } from '../util';
+import { didUpdateToBool } from './util';
 
 type Result = [
   Active,
@@ -23,7 +24,7 @@ type Result = [
 ];
 
 function parseActive (id: ParaId, active: Active): DeriveParachainActive | null {
-  const found = active.find(([paraId]): boolean => paraId === id);
+  const found = active.find(([paraId]) => paraId === id);
 
   if (found && found[1].isSome) {
     const [collatorId, retriable] = found[1].unwrap();
@@ -48,9 +49,8 @@ function parseActive (id: ParaId, active: Active): DeriveParachainActive | null
 }
 
 function parseCollators (id: ParaId, collatorQueue: SelectedThreads | RetryQueue): (CollatorId | null)[] {
-  return collatorQueue
+  return collatorQueue.map((queue): CollatorId | null => {
-    .map((queue): CollatorId | null => {
+    const found = queue.find(([paraId]) => paraId === id);
-      const found = queue.find(([paraId]): boolean => paraId === id);
 
     return found ? found[1] : null;
   });
@@ -63,9 +63,7 @@ function parse (id: ParaId, [active, retryQueue, selectedThreads, didUpdate, inf
 
   return {
     active: parseActive(id, active),
-    didUpdate: didUpdate.isSome
+    didUpdate: didUpdateToBool(didUpdate, id),
-      ? !!didUpdate.unwrap().some((paraId): boolean => paraId.eq(id))
-      : false,
     heads,
     id,
     info: { id, ...info.unwrap() } as DeriveParachainInfo,

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

@@ -10,6 +10,7 @@ import { map, switchMap } from 'rxjs/operators';
 import { ApiInterfaceRx } from '@polkadot/api/types';
 
 import { memo } from '../util';
+import { didUpdateToBool } from './util';
 
 type Result = [
   ParaId[],
@@ -20,17 +21,13 @@ type Result = [
 ];
 
 function parse ([ids, didUpdate, infos, pendingSwaps, relayDispatchQueueSizes]: Result): DeriveParachain[] {
-  return ids.map((id, index): DeriveParachain => {
+  return ids.map((id, index): DeriveParachain => ({
-    return {
+    didUpdate: didUpdateToBool(didUpdate, id),
-      didUpdate: didUpdate.isSome
-        ? !!didUpdate.unwrap().some((paraId): boolean => paraId.eq(id))
-        : false,
     id,
     info: { id, ...infos[index].unwrapOr(null) } as DeriveParachainInfo,
     pendingSwapId: pendingSwaps[index].unwrapOr(null),
     relayDispatchQueueSize: relayDispatchQueueSizes[index][0].toNumber()
-    };
+  }));
-  });
 }
 
 export function overview (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveParachain[]> {
@@ -46,9 +43,7 @@ export function overview (instanceId: string, api: ApiInterfaceRx): () => Observ
             api.query.parachains.relayDispatchQueueSize.multi<RelayDispatchQueueSize>(paraIds)
           ])
         ),
-        map((result: Result): DeriveParachain[] =>
+        map(parse)
-          parse(result)
-        )
       )
       : of([] as DeriveParachain[])
   );

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

@@ -0,0 +1,11 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ParaId } from '@polkadot/types/interfaces';
+import { DidUpdate } from './types';
+
+export function didUpdateToBool (didUpdate: DidUpdate, id: ParaId): boolean {
+  return didUpdate.isSome
+    ? didUpdate.unwrap().some((paraId) => paraId.eq(id))
+    : false;
+}

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
+import { AccountId } from '@polkadot/types/interfaces';
 import { DeriveStakingElected } from '../types';
 
 import { Observable } from 'rxjs';
@@ -9,14 +10,19 @@ import { map, switchMap } from 'rxjs/operators';
 
 import { memo } from '../util';
 
+function combineAccounts (nextElected: AccountId[], validators: AccountId[]): AccountId[] {
+  return [...nextElected].concat(...validators.filter((v) => !nextElected.find((n) => n.eq(v))));
+}
+
 export function electedInfo (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveStakingElected> {
   return memo(instanceId, (): Observable<DeriveStakingElected> =>
     api.derive.staking.validators().pipe(
-      switchMap(({ nextElected }): Observable<DeriveStakingElected> =>
+      switchMap(({ nextElected, validators }): Observable<DeriveStakingElected> =>
-        api.derive.staking.queryMulti(nextElected).pipe(
+        api.derive.staking.queryMulti(combineAccounts(nextElected, validators)).pipe(
           map((info): DeriveStakingElected => ({
             info,
-            nextElected
+            nextElected,
+            validators
           }))
         )
       )

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

@@ -10,6 +10,7 @@ import { map, switchMap } from 'rxjs/operators';
 import { BN_ZERO } from '@polkadot/util';
 
 import { deriveCache, memo } from '../util';
+import { filterEras } from './util';
 
 const CACHE_KEY = 'eraPoints';
 
@@ -42,7 +43,7 @@ export function _erasPoints (instanceId: string, api: ApiInterfaceRx): (eras: Er
       : eras
         .map((era) => deriveCache.get<DeriveEraPoints>(`${CACHE_KEY}-${era.toString()}`))
         .filter((value): value is DeriveEraPoints => !!value);
-    const remaining = eras.filter((era) => !cached.some((cached) => era.eq(cached.era)));
+    const remaining = filterEras(eras, cached);
 
     return !remaining.length
       ? of(cached)

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

@@ -10,6 +10,7 @@ import { map, switchMap } from 'rxjs/operators';
 import { Option } from '@polkadot/types';
 
 import { deriveCache, memo } from '../util';
+import { filterEras } from './util';
 
 const CACHE_KEY = 'eraRewards';
 
@@ -31,7 +32,7 @@ export function _erasRewards (instanceId: string, api: ApiInterfaceRx): (eras: E
       : eras
         .map((era) => deriveCache.get<DeriveEraRewards>(`${CACHE_KEY}-${era.toString()}`))
         .filter((value): value is DeriveEraRewards => !!value);
-    const remaining = eras.filter((era) => !cached.some((cached) => era.eq(cached.era)));
+    const remaining = filterEras(eras, cached);
 
     if (!remaining.length) {
       return of(cached);

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

@@ -12,6 +12,7 @@ import { Option } from '@polkadot/types';
 import { isFunction } from '@polkadot/util';
 
 import { memo } from '../util';
+import { DeriveStakingQuery } from './types';
 
 type ErasResult = [{ unwrapOr: (value: BN) => BN }, DeriveEraPoints[], DeriveEraPrefs[], DeriveEraRewards[]];
 
@@ -99,35 +100,7 @@ function filterEras (eras: EraIndex[], stakingLedger: StakingLedger): EraIndex[]
   return eras.filter((era) => filterEra(era, stakingLedger));
 }
 
-function filterRewards (api: ApiInterfaceRx, eras: EraIndex[], migrateEra: BN, rewards: DeriveStakerReward[], stakingLedger: StakingLedger, withActive: boolean): Observable<DeriveStakerReward[]> {
+function removeClaimed (validators: string[], queryValidators: DeriveStakingQuery[], reward: DeriveStakerReward): void {
-  if (withActive) {
-    return of(rewards);
-  }
-
-  const validators = uniqValidators(rewards);
-
-  return (
-    isFunction(api.tx.staking.payoutStakers)
-      ? api.derive.staking.queryMulti(validators)
-      : of([])
-  ).pipe(
-    map((queryValidators): DeriveStakerReward[] => {
-      const filter = withActive
-        ? eras
-        : filterEras(eras, stakingLedger);
-
-      return rewards
-        .filter(({ isEmpty }) => !isEmpty)
-        .filter((reward): boolean => {
-          if (!filter.some((filter) => reward.era.eq(filter))) {
-            return false;
-          } else if (reward.era.lt(migrateEra)) {
-            // we filter again here, the actual ledger may have changed, e.g. something has been claimed
-            return filterEra(reward.era, stakingLedger);
-          }
-
-          reward.isStakerPayout = true;
-
   const rm: string[] = [];
 
   Object.keys(reward.validators).forEach((validatorId): void => {
@@ -145,15 +118,40 @@ function filterRewards (api: ApiInterfaceRx, eras: EraIndex[], migrateEra: BN, r
   rm.forEach((validatorId): void => {
     delete reward.validators[validatorId];
   });
+}
+
+function filterRewards (api: ApiInterfaceRx, eras: EraIndex[], { migrateEra, rewards, stakingLedger }: { migrateEra: BN, rewards: DeriveStakerReward[]; stakingLedger: StakingLedger }): Observable<DeriveStakerReward[]> {
+  const validators = uniqValidators(rewards);
+  const filter = filterEras(eras, stakingLedger);
+
+  return (
+    isFunction(api.tx.staking.payoutStakers)
+      ? api.derive.staking.queryMulti(validators)
+      : of([])
+  ).pipe(
+    map((queryValidators): DeriveStakerReward[] =>
+      rewards
+        .filter(({ isEmpty }) => !isEmpty)
+        .filter((reward): boolean => {
+          if (!filter.some((filter) => reward.era.eq(filter))) {
+            return false;
+          } else if (reward.era.lt(migrateEra)) {
+            // we filter again here, the actual ledger may have changed, e.g. something has been claimed
+            return filterEra(reward.era, stakingLedger);
+          }
+
+          reward.isStakerPayout = true;
+
+          removeClaimed(validators, queryValidators, reward);
 
           return true;
         })
         .filter(({ validators }) => Object.keys(validators).length !== 0)
         .map((reward) => ({
           ...reward,
-          nominators: reward.nominating.filter(({ validatorId }) => !!reward.validators[validatorId])
+          nominators: reward.nominating.filter((n) => !!reward.validators[n.validatorId])
-        }));
+        }))
-    })
+    )
   );
 }
 
@@ -178,13 +176,15 @@ export function _stakerRewards (instanceId: string, api: ApiInterfaceRx): (accou
       api.derive.staking._stakerRewardsEras(eras, withActive)
     ]).pipe(
       switchMap(([{ stakingLedger, stashId }, exposures, erasResult]): Observable<DeriveStakerReward[]> => {
-        const migrateEra: BN = erasResult[0].unwrapOr(ZERO);
-
         if (!stashId || !stakingLedger) {
           return of([]);
         }
 
-        return filterRewards(api, eras, migrateEra, parseRewards(api, stashId, erasResult, exposures), stakingLedger, withActive);
+        const rewards = parseRewards(api, stashId, erasResult, exposures);
+
+        return withActive
+          ? of(rewards)
+          : filterRewards(api, eras, { migrateEra: erasResult[0].unwrapOr(ZERO), rewards, stakingLedger });
       })
     )
   );

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

@@ -120,8 +120,9 @@ export interface DeriveStakingQuery extends DeriveStakingStash {
 }
 
 export interface DeriveStakingElected {
-  nextElected: AccountId[];
   info: DeriveStakingQuery[];
+  nextElected: AccountId[];
+  validators: AccountId[];
 }
 
 export interface DeriveStakingWaiting {

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

@@ -0,0 +1,8 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EraIndex } from '@polkadot/types/interfaces';
+
+export function filterEras <T extends { era: EraIndex }> (eras: EraIndex[], list: T[]): EraIndex[] {
+  return eras.filter((era) => !list.some((entry) => era.eq(entry.era)));
+}

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

@@ -30,7 +30,6 @@ export function validators (instanceId: string, api: ApiInterfaceRx): () => Obse
   return memo(instanceId, (): Observable<DeriveStakingValidators> =>
     // Sadly the node-template is (for some obscure reason) not comprehensive, so while the derive works
     // in all actual real-world deployed chains, it does create some confusion for limited template chains
-    // NOTE: Not doing multi queries here, since we have validators as a single in the derived newHead
     combineLatest([
       api.query.session
         ? api.query.session.validators()

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

@@ -2,12 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { DeriveCollectiveProposals } from '../types';
+import { DeriveCollectiveProposal } from '../types';
 
 import { Observable } from 'rxjs';
 import { proposals as collectiveProposals } from '../collective';
 import { memo } from '../util';
 
-export function proposals (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveCollectiveProposals> {
+export function proposals (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveCollectiveProposal[]> {
   return memo(instanceId, collectiveProposals(instanceId, api, 'technicalCommittee'));
 }

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

@@ -3,7 +3,7 @@
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
 import { ProposalIndex, TreasuryProposal } from '@polkadot/types/interfaces';
-import { DeriveCollectiveProposals, DeriveTreasuryProposal, DeriveTreasuryProposals } from '../types';
+import { DeriveCollectiveProposal, DeriveTreasuryProposal, DeriveTreasuryProposals } from '../types';
 
 import { Observable, combineLatest, of } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
@@ -15,7 +15,7 @@ interface Result {
   allIds: ProposalIndex[];
   allProposals: Option<TreasuryProposal>[];
   approvalIds: ProposalIndex[];
-  councilProposals: DeriveCollectiveProposals;
+  councilProposals: DeriveCollectiveProposal[];
   proposalCount: ProposalIndex;
 }
 
@@ -51,9 +51,7 @@ function retrieveProposals (api: ApiInterfaceRx, proposalCount: ProposalIndex, a
   const count = proposalCount.toNumber();
 
   for (let index = 0; index < count; index++) {
-    const isApproval = approvalIds.some((id): boolean => id.eqn(index));
+    if (!approvalIds.some((id) => id.eqn(index))) {
-
-    if (!isApproval) {
       proposalIds.push(api.registry.createType('ProposalIndex', index));
     }
   }
@@ -64,7 +62,7 @@ function retrieveProposals (api: ApiInterfaceRx, proposalCount: ProposalIndex, a
     api.query.treasury.proposals.multi<Option<TreasuryProposal>>(allIds),
     api.derive.council.proposals()
   ]).pipe(
-    map(([allProposals, councilProposals]: [Option<TreasuryProposal>[], DeriveCollectiveProposals]): DeriveTreasuryProposals =>
+    map(([allProposals, councilProposals]: [Option<TreasuryProposal>[], DeriveCollectiveProposal[]]): DeriveTreasuryProposals =>
       parseResult(api, { allIds, allProposals, approvalIds, councilProposals, proposalCount })
     )
   );

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

@@ -17,7 +17,7 @@ const _Header = Struct.with(runtimeTypes.types.Header as any) as Constructor<Hea
  * @description
  * A [[Block]] header with an additional `author` field that indicates the block author
  */
-export default class HeaderExtended extends _Header {
+export class HeaderExtended extends _Header {
   readonly #author?: AccountId;
 
   constructor (registry: Registry, header?: Header, sessionValidators?: AccountId[]) {
@@ -36,9 +36,9 @@ export default class HeaderExtended extends _Header {
   /**
    * @description Creates a human-friendly JSON representation
    */
-  public toHuman (isExtended?: boolean): AnyJson {
+  public toHuman (isExtended?: boolean): Record<string, AnyJson> {
     return {
-      ...super.toHuman(isExtended) as { [index: string]: AnyJson },
+      ...super.toHuman(isExtended),
       author: this.author
         ? this.author.toHuman()
         : undefined
@@ -48,9 +48,9 @@ export default class HeaderExtended extends _Header {
   /**
    * @description Creates the JSON representation
    */
-  public toJSON (): AnyJson {
+  public toJSON (): Record<string, AnyJson> {
     return {
-      ...super.toJSON() as { [index: string]: AnyJson },
+      ...super.toJSON(),
       author: this.author
         ? this.author.toJSON()
         : undefined

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

@@ -17,7 +17,7 @@ const _SignedBlock = Struct.with(runtimeTypes.types.SignedBlock as any) as Const
  * @description
  * A [[Block]] header with an additional `author` field that indicates the block author
  */
-export default class BlockExtended extends _SignedBlock {
+export class SignedBlockExtended extends _SignedBlock {
   readonly #author?: AccountId;
 
   constructor (registry: Registry, block?: SignedBlock, sessionValidators?: AccountId[]) {
@@ -36,9 +36,9 @@ export default class BlockExtended extends _SignedBlock {
   /**
    * @description Creates a human-friendly JSON representation
    */
-  public toHuman (isExtended?: boolean): AnyJson {
+  public toHuman (isExtended?: boolean): Record<string, AnyJson> {
     return {
-      ...super.toHuman(isExtended) as { [index: string]: AnyJson },
+      ...super.toHuman(isExtended),
       author: this.author
         ? this.author.toHuman()
         : undefined
@@ -48,9 +48,9 @@ export default class BlockExtended extends _SignedBlock {
   /**
    * @description Creates the JSON representation
    */
-  public toJSON (): AnyJson {
+  public toJSON (): Record<string, AnyJson> {
     return {
-      ...super.toJSON() as { [index: string]: AnyJson },
+      ...super.toJSON(),
       author: this.author
         ? this.author.toJSON()
         : undefined

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

@@ -1,5 +1,5 @@
 // Copyright 2017-2020 @polkadot/api-derive authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export { default as HeaderExtended } from './HeaderExtended';
+export { HeaderExtended } from './HeaderExtended';
-export { default as SignedBlockExtended } from './SignedBlockExtended';
+export { SignedBlockExtended } from './SignedBlockExtended';

packages/api-derive/src/types.ts

@@ -60,8 +60,6 @@ export interface DeriveCollectiveProposal {
   votes: Votes | null;
 }
 
-export type DeriveCollectiveProposals = DeriveCollectiveProposal[];
-
 export interface DeriveFees {
   creationFee: Balance;
   existentialDeposit: Balance;

packages/api-derive/src/util/approvalFlagToBools.spec.ts

@@ -3,7 +3,7 @@
 
 import { ApprovalFlag } from '@polkadot/types/interfaces';
 
-import { TypeRegistry } from '@polkadot/types';
+import { TypeRegistry } from '@polkadot/types/create';
 
 import { approvalFlagsToBools } from './approvalFlagsToBools';
 

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

@@ -1,11 +1,9 @@
 // Copyright 2017-2020 @polkadot/api-derive authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { drr } from '@polkadot/rpc-core/rxjs';
+export { drr } from '@polkadot/rpc-core/util';
 
 export * from './approvalFlagsToBools';
 export * from './cache';
 export * from './cacheImpl';
 export * from './memo';
-
-export { drr };

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

@@ -3,8 +3,7 @@
 
 import createMemo from 'memoizee';
 import { Observable, Observer, TeardownLogic } from 'rxjs';
-import { drr } from '@polkadot/rpc-core/rxjs';
+import { drr, normalizer } from '@polkadot/rpc-core/util';
-import normalizer from '@polkadot/rpc-core/normalizer';
 
 type ObsFn <T> = (...params: any[]) => Observable<T>;
 

packages/api/package.json

@@ -1,46 +1,33 @@
 {
   "name": "@polkadot/api",
-  "version": "2.4.1",
+  "version": "2.9.1",
   "description": "Promise and RxJS wrappers around the Polkadot JS RPC",
   "main": "index.js",
+  "sideEffects": false,
   "keywords": [
     "Polkadot",
     "RxJs"
   ],
   "author": "Jaco Greeff <jacogr@gmail.com>",
-  "maintainers": [
+  "maintainers": [],
-    "Jaco Greeff <jacogr@gmail.com>"
-  ],
   "contributors": [],
   "license": "Apache-2.0",
-  "publishConfig": {
+  "repository": "github:polkadot-js/api",
-    "access": "public",
+  "bugs": "https://github.com/polkadot-js/api/issues",
-    "registry": "https://registry.npmjs.org"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/polkadot-js/api.git"
-  },
-  "bugs": {
-    "url": "https://github.com/polkadot-js/api/issues"
-  },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.1",
+    "@babel/runtime": "^7.12.5",
-    "@polkadot/api-derive": "^2.4.1",
+    "@polkadot/api-derive": "2.9.1",
-    "@polkadot/keyring": "^3.6.1",
+    "@polkadot/keyring": "^4.2.1",
-    "@polkadot/metadata": "^2.4.1",
+    "@polkadot/metadata": "2.9.1",
-    "@polkadot/rpc-core": "^2.4.1",
+    "@polkadot/rpc-core": "2.9.1",
-    "@polkadot/rpc-provider": "^2.4.1",
+    "@polkadot/rpc-provider": "2.9.1",
-    "@polkadot/types": "^2.4.1",
+    "@polkadot/types": "2.9.1",
-    "@polkadot/types-known": "^2.4.1",
+    "@polkadot/types-known": "2.9.1",
-    "@polkadot/util": "^3.6.1",
+    "@polkadot/util": "^4.2.1",
-    "@polkadot/util-crypto": "^3.6.1",
+    "@polkadot/util-crypto": "^4.2.1",
-    "bn.js": "^5.1.3",
+    "bn.js": "^4.11.9",
     "eventemitter3": "^4.0.7",
     "rxjs": "^6.6.3"
-  },
-  "devDependencies": {
-    "@polkadot/keyring": "^3.6.1"
   }
 }

packages/api/src/augment/consts.ts

@@ -1,14 +1,13 @@
 // Auto-generated via `yarn polkadot-types-from-chain`, do not edit
 /* eslint-disable */
 
-import { Codec } from '@polkadot/types/types';
+import type { Vec, u16, u32, u64 } from '@polkadot/types';
-import { Vec } from '@polkadot/types/codec';
+import type { Codec } from '@polkadot/types/types';
-import { u16, u32, u64 } from '@polkadot/types/primitive';
+import type { Balance, BalanceOf, BlockNumber, LockIdentifier, ModuleId, Moment, Perbill, Percent, Permill, RuntimeDbWeight, Weight } from '@polkadot/types/interfaces/runtime';
-import { Balance, BalanceOf, BlockNumber, LockIdentifier, ModuleId, Moment, Perbill, Percent, Permill, RuntimeDbWeight, Weight } from '@polkadot/types/interfaces/runtime';
+import type { SessionIndex } from '@polkadot/types/interfaces/session';
-import { SessionIndex } from '@polkadot/types/interfaces/session';
+import type { EraIndex } from '@polkadot/types/interfaces/staking';
-import { EraIndex } from '@polkadot/types/interfaces/staking';
+import type { WeightToFeeCoefficient } from '@polkadot/types/interfaces/support';
-import { WeightToFeeCoefficient } from '@polkadot/types/interfaces/support';
+import type { ApiTypes } from '@polkadot/api/types';
-import { ApiTypes } from '@polkadot/api/types';
 
 declare module '@polkadot/api/types/consts' {
   export interface AugmentedConsts<ApiType> {
@@ -134,17 +133,6 @@ declare module '@polkadot/api/types/consts' {
       termDuration: BlockNumber & AugmentedConst<ApiType>;
       votingBond: BalanceOf & AugmentedConst<ApiType>;
     };
-    finalityTracker: {
-      [key: string]: Codec;
-      /**
-       * The delay after which point things become suspicious. Default is 1000.
-       **/
-      reportLatency: BlockNumber & AugmentedConst<ApiType>;
-      /**
-       * The number of recent samples to keep from this chain. Default is 101.
-       **/
-      windowSize: BlockNumber & AugmentedConst<ApiType>;
-    };
     identity: {
       [key: string]: Codec;
       /**

packages/api/src/augment/query.ts

@@ -1,34 +1,33 @@
 // Auto-generated via `yarn polkadot-types-from-chain`, do not edit
 /* eslint-disable */
 
-import { AnyNumber, ITuple, Observable } from '@polkadot/types/types';
+import type { Bytes, Data, Option, U8aFixed, Vec, bool, u32, u64 } from '@polkadot/types';
-import { Option, U8aFixed, Vec } from '@polkadot/types/codec';
+import type { AnyNumber, ITuple, Observable } from '@polkadot/types/types';
-import { Bytes, Data, bool, u32, u64 } from '@polkadot/types/primitive';
+import type { UncleEntryItem } from '@polkadot/types/interfaces/authorship';
-import { UncleEntryItem } from '@polkadot/types/interfaces/authorship';
+import type { BabeAuthorityWeight, MaybeRandomness, NextConfigDescriptor, Randomness } from '@polkadot/types/interfaces/babe';
-import { BabeAuthorityWeight, MaybeRandomness, NextConfigDescriptor, Randomness } from '@polkadot/types/interfaces/babe';
+import type { AccountData, BalanceLock } from '@polkadot/types/interfaces/balances';
-import { AccountData, BalanceLock } from '@polkadot/types/interfaces/balances';
+import type { ProposalIndex, Votes } from '@polkadot/types/interfaces/collective';
-import { ProposalIndex, Votes } from '@polkadot/types/interfaces/collective';
+import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
-import { AuthorityId } from '@polkadot/types/interfaces/consensus';
+import type { CodeHash, ContractInfo, PrefabWasmModule, Schedule } from '@polkadot/types/interfaces/contracts';
-import { CodeHash, ContractInfo, PrefabWasmModule, Schedule } from '@polkadot/types/interfaces/contracts';
+import type { PreimageStatus, PropIndex, Proposal, ReferendumIndex, ReferendumInfo, Voting } from '@polkadot/types/interfaces/democracy';
-import { PreimageStatus, PropIndex, Proposal, ReferendumIndex, ReferendumInfo, Voting } from '@polkadot/types/interfaces/democracy';
+import type { VoteThreshold } from '@polkadot/types/interfaces/elections';
-import { VoteThreshold } from '@polkadot/types/interfaces/elections';
+import type { SetId, StoredPendingChange, StoredState } from '@polkadot/types/interfaces/grandpa';
-import { SetId, StoredPendingChange, StoredState } from '@polkadot/types/interfaces/grandpa';
+import type { RegistrarInfo, Registration } from '@polkadot/types/interfaces/identity';
-import { RegistrarInfo, Registration } from '@polkadot/types/interfaces/identity';
+import type { AuthIndex } from '@polkadot/types/interfaces/imOnline';
-import { AuthIndex } from '@polkadot/types/interfaces/imOnline';
+import type { DeferredOffenceOf, Kind, OffenceDetails, OpaqueTimeSlot, ReportIdOf } from '@polkadot/types/interfaces/offences';
-import { DeferredOffenceOf, Kind, OffenceDetails, OpaqueTimeSlot, ReportIdOf } from '@polkadot/types/interfaces/offences';
+import type { ProxyAnnouncement, ProxyDefinition } from '@polkadot/types/interfaces/proxy';
-import { ProxyAnnouncement, ProxyDefinition } from '@polkadot/types/interfaces/proxy';
+import type { ActiveRecovery, RecoveryConfig } from '@polkadot/types/interfaces/recovery';
-import { ActiveRecovery, RecoveryConfig } from '@polkadot/types/interfaces/recovery';
+import type { AccountId, AccountIndex, Balance, BalanceOf, BlockNumber, ExtrinsicsWeight, Hash, KeyTypeId, Moment, OpaqueCall, Perbill, Releases, ValidatorId } from '@polkadot/types/interfaces/runtime';
-import { AccountId, AccountIndex, Balance, BalanceOf, BlockNumber, ExtrinsicsWeight, Hash, KeyTypeId, Moment, OpaqueCall, Perbill, Releases, ValidatorId } from '@polkadot/types/interfaces/runtime';
+import type { Scheduled, TaskAddress } from '@polkadot/types/interfaces/scheduler';
-import { Scheduled, TaskAddress } from '@polkadot/types/interfaces/scheduler';
+import type { Keys, SessionIndex } from '@polkadot/types/interfaces/session';
-import { Keys, SessionIndex } from '@polkadot/types/interfaces/session';
+import type { Bid, BidKind, SocietyVote, StrikeCount, VouchingStatus } from '@polkadot/types/interfaces/society';
-import { Bid, BidKind, SocietyVote, StrikeCount, VouchingStatus } from '@polkadot/types/interfaces/society';
+import type { ActiveEraInfo, ElectionResult, ElectionScore, ElectionStatus, EraIndex, EraRewardPoints, Exposure, Forcing, Nominations, RewardDestination, SlashingSpans, SpanIndex, SpanRecord, StakingLedger, UnappliedSlash, ValidatorPrefs } from '@polkadot/types/interfaces/staking';
-import { ActiveEraInfo, ElectionResult, ElectionScore, ElectionStatus, EraIndex, EraRewardPoints, Exposure, Forcing, Nominations, RewardDestination, SlashingSpans, SpanIndex, SpanRecord, StakingLedger, UnappliedSlash, ValidatorPrefs } from '@polkadot/types/interfaces/staking';
+import type { AccountInfo, DigestOf, EventIndex, EventRecord, LastRuntimeUpgradeInfo, Phase } from '@polkadot/types/interfaces/system';
-import { AccountInfo, DigestOf, EventIndex, EventRecord, LastRuntimeUpgradeInfo, Phase } from '@polkadot/types/interfaces/system';
+import type { Bounty, BountyIndex, OpenTip, TreasuryProposal } from '@polkadot/types/interfaces/treasury';
-import { Bounty, BountyIndex, OpenTip, TreasuryProposal } from '@polkadot/types/interfaces/treasury';
+import type { Multiplier } from '@polkadot/types/interfaces/txpayment';
-import { Multiplier } from '@polkadot/types/interfaces/txpayment';
+import type { Multisig } from '@polkadot/types/interfaces/utility';
-import { Multisig } from '@polkadot/types/interfaces/utility';
+import type { VestingInfo } from '@polkadot/types/interfaces/vesting';
-import { VestingInfo } from '@polkadot/types/interfaces/vesting';
+import type { ApiTypes } from '@polkadot/api/types';
-import { ApiTypes } from '@polkadot/api/types';
 
 declare module '@polkadot/api/types/storage' {
   export interface AugmentedQueries<ApiType> {
@@ -53,6 +52,12 @@ declare module '@polkadot/api/types/storage' {
        * Current epoch authorities.
        **/
       authorities: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AuthorityId, BabeAuthorityWeight]>>>> & QueryableStorageEntry<ApiType>;
+      /**
+       * Temporary value (cleared at block finalization) that includes the VRF output generated
+       * at this block. This field should always be populated during block processing unless
+       * secondary plain slots are enabled (which don't contain a VRF output).
+       **/
+      authorVrfRandomness: AugmentedQuery<ApiType, () => Observable<MaybeRandomness>> & QueryableStorageEntry<ApiType>;
       /**
        * Current slot number.
        **/

packages/api/src/augment/rpc.ts

@@ -1,25 +1,24 @@
 // Auto-generated via `yarn polkadot-types-from-chain`, do not edit
 /* eslint-disable */
 
-import { AnyNumber, Codec, IExtrinsic, Observable } from '@polkadot/types/types';
+import type { Metadata } from '@polkadot/metadata';
-import { HashMap, Option, Vec } from '@polkadot/types/codec';
+import type { Bytes, HashMap, Json, Null, Option, StorageKey, Text, Vec, bool, u32, u64 } from '@polkadot/types';
-import { Bytes, Null, StorageKey, Text, bool, u32, u64 } from '@polkadot/types/primitive';
+import type { AnyNumber, Codec, IExtrinsic, Observable } from '@polkadot/types/types';
-import { Metadata } from '@polkadot/types';
+import type { ExtrinsicOrHash, ExtrinsicStatus } from '@polkadot/types/interfaces/author';
-import { ExtrinsicOrHash, ExtrinsicStatus } from '@polkadot/types/interfaces/author';
+import type { EpochAuthorship } from '@polkadot/types/interfaces/babe';
-import { EpochAuthorship } from '@polkadot/types/interfaces/babe';
+import type { BlockHash } from '@polkadot/types/interfaces/chain';
-import { BlockHash } from '@polkadot/types/interfaces/chain';
+import type { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate';
-import { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate';
+import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
-import { AuthorityId } from '@polkadot/types/interfaces/consensus';
+import type { ContractCallRequest, ContractExecResult } from '@polkadot/types/interfaces/contracts';
-import { ContractCallRequest, ContractExecResult } from '@polkadot/types/interfaces/contracts';
+import type { CreatedBlock } from '@polkadot/types/interfaces/engine';
-import { CreatedBlock } from '@polkadot/types/interfaces/engine';
+import type { Extrinsic } from '@polkadot/types/interfaces/extrinsics';
-import { Extrinsic } from '@polkadot/types/interfaces/extrinsics';
+import type { EncodedFinalityProofs, JustificationNotification, ReportedRoundStates } from '@polkadot/types/interfaces/grandpa';
-import { EncodedFinalityProofs, JustificationNotification, ReportedRoundStates } from '@polkadot/types/interfaces/grandpa';
+import type { StorageKind } from '@polkadot/types/interfaces/offchain';
-import { StorageKind } from '@polkadot/types/interfaces/offchain';
+import type { RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
-import { RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
+import type { RpcMethods } from '@polkadot/types/interfaces/rpc';
-import { RpcMethods } from '@polkadot/types/interfaces/rpc';
+import type { AccountId, BlockNumber, H256, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime';
-import { AccountId, BlockNumber, H256, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime';
+import type { ReadProof, RuntimeVersion } from '@polkadot/types/interfaces/state';
-import { ReadProof, RuntimeVersion } from '@polkadot/types/interfaces/state';
+import type { ApplyExtrinsicResult, ChainProperties, ChainType, Health, NetworkState, NodeRole, PeerInfo, SyncState } from '@polkadot/types/interfaces/system';
-import { ApplyExtrinsicResult, ChainProperties, ChainType, Health, NetworkState, NodeRole, PeerInfo } from '@polkadot/types/interfaces/system';
 
 declare module '@polkadot/rpc-core/types.jsonrpc' {
   export interface RpcInterface {
@@ -245,6 +244,12 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
        **/
       subscribeStorage: AugmentedRpc<<T = Codec[]>(keys?: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[]) => Observable<T>>;
     };
+    syncstate: {
+      /**
+       * Returns the json-serialized chainspec running the node, with a sync state.
+       **/
+      genSyncSpec: AugmentedRpc<(raw: bool | boolean | Uint8Array) => Observable<Json>>;
+    };
     system: {
       /**
        * Retrieves the next accountIndex as available on the node
@@ -302,6 +307,10 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
        * Remove a reserved peer
        **/
       removeReservedPeer: AugmentedRpc<(peerId: Text | string) => Observable<Text>>;
+      /**
+       * Returns the state of the syncing of the node
+       **/
+      syncState: AugmentedRpc<() => Observable<SyncState>>;
       /**
        * Retrieves the version of the node
        **/