[CI Skip] release/stable 4.16.1

skip-checks: true
4.16 (#3701 )
2021-06-26 08:48:42 +00:00 · 2021-06-26 10:37:06 +02:00 · 2021-06-26 10:10:46 +02:00 · 2021-06-26 05:54:47 +00:00 · 2021-06-26 08:43:58 +03:00 · 2021-06-25 15:14:24 +00:00
312 changed files with 27075 additions and 6386 deletions
@@ -1,4 +1,4 @@
-27
+31
 1.4.2
 1.6.2
 1.11.2
@@ -19,3 +19,7 @@
 3.10.2
 4.0.2
 4.0.3
+4.6.2
+4.7.2
+4.9.2
+4.11.2
@@ -0,0 +1,23 @@
+name: 'Lock Threads'
+
+on:
+  schedule:
+    - cron: '30 1/2 * * *'
+
+jobs:
+  lock:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/lock-threads@v2
+        with:
+          github-token: ${{ secrets.GH_PAT_BOT }}
+          issue-lock-inactive-days: '7'
+          issue-lock-comment: >
+            This thread has been automatically locked since there has not been
+            any recent activity after it was closed. Please open a new issue
+            if you think you have a related problem or query.
+          pr-lock-inactive-days: '2'
+          pr-lock-comment: >
+            This pull request has been automatically locked since there
+            has not been any recent activity after it was closed.
+            Please open a new issue for related bugs.
@@ -6,11 +6,11 @@ on:

 jobs:
  master:
+    if: "! startsWith(github.event.head_commit.message, '[CI Skip]')"
    strategy:
      matrix:
        step: ['build:release']
    name: ${{ matrix.step }}
-    if: "! startsWith(github.event.head_commit.message, '[CI Skip]') && github.repository == 'polkadot-js/api'"
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
@@ -25,10 +25,3 @@ jobs:
      run: |
        yarn install --immutable | grep -v 'YN0013'
        yarn ${{ matrix.step }}
-
-  dummy:
-    runs-on: ubuntu-latest
-    steps:
-    - name: dummy
-      run: |
-        echo "Dummy skip step"
@@ -0,0 +1,18 @@
+name: Semgrep
+on:
+  pull_request: {}
+  push:
+    branches:
+      - master
+
+jobs:
+  check:
+    if: "! startsWith(github.event.head_commit.message, '[CI Skip]') && (!github.event.pull_request || github.event.pull_request.head.repo.full_name == github.repository)"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: returntocorp/semgrep-action@v1
+        with:
+          auditOn: push
+          publishToken: ${{ secrets.SEMGREP_APP_TOKEN }}
+          publishDeployment: 1395
@@ -0,0 +1,17 @@
+name: 'Close stale issues and PRs'
+on:
+  schedule:
+    - cron: '30 2/2 * * *'
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v3
+        with:
+          repo-token: ${{ secrets.GH_PAT_BOT }}
+          stale-issue-message: 'This issue has been open for 21 days with no activity and is not labelled as an enhancement. It will be closed in 7 days.'
+          stale-issue-label: 'stale'
+          exempt-issue-labels: '-size-l,-size-m,-size-s,-size-xl,-size-xs,[bug]'
+          days-before-stale: 21
+          days-before-close: 7
@@ -1 +1 @@
-12
+14
@@ -0,0 +1,3 @@
+build
+coverage
+packages
@@ -0,0 +1,4 @@
+// Copyright 2017-2021 @polkadot/api authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+module.exports = require('@polkadot/dev/config/prettier.cjs');
@@ -10,4 +10,4 @@ plugins:
  - path: .yarn/plugins/@yarnpkg/plugin-version.cjs
    spec: "@yarnpkg/plugin-version"

-yarnPath: .yarn/releases/yarn-2.4.1.cjs
+yarnPath: .yarn/releases/yarn-3.0.0-rc.2.cjs
@@ -1,5 +1,258 @@
 # CHANGELOG

+## 4.16.1 Jun 26, 2021
+
+Upgrade priority: Low. Recommended for full from-genesis queries on Kusama.
+
+Contributed:
+
+- Adjust types for uniques (Thanks to https://github.com/Yuripetusko)
+
+Changes:
+
+- Add Kusama, Polkadot & Westend 9050 upgrade blocks
+- Add Kusama & Westend 9070 upgrade blocks
+- Adjust API decoration to lazy-create event and storage types
+- Use TS `override` as applicable (with `--noImplicitOverrides` option)
+- Add missing historic `Heartbeat: HeartbeatTo244` mapping to Kusama
+- Remove duplication from contracts registry
+- Add explicit check for scale-info 0.7+ (contracts index lookups)
+- Align static metadata with latest Substrate
+
+
+## 4.15.1 Jun 19, 2021
+
+Upgrade priority: Medium. Recommended for all chains where Xcm is used (addition of new `XcmOrigin`)
+
+Contributed:
+
+- Added `ChargeAssetTxPayment` extension (Thanks to https://github.com/apopiak)
+
+Changes:
+
+- Allow for type decoding of nested fixed vectors, tuples and structs
+- Added `childstate_getKeysPaged` RPC
+- Add `XcmOrigin` mapping for `OriginCaller` generation
+- Align static metadata with latest Substrate
+- Adjust error message for contracts V3 (extrinsic from runtime)
+- Correct module optionality in `api.derive.balances.account`
+- Add alias for `GenericAddress` -> `GenericMultiAddress`
+- Adjust metadata doc generation (keep spaces between subsequent lines)
+
+
+## 4.14.1 Jun 14, 2021
+
+Upgrade priority: Low. Internal adjustment only, no major external usage changes.
+
+Contributed:
+
+- Adjust types for uniques (Thanks to https://github.com/hamidra)
+- Add `ValidationCodeHash` type (Thanks to https://github.com/andresilva)
+- Extend `OriginCaller` type creation (Thanks to https://github.com/xlc)
+
+Changes:
+
+- Do strict length checking on `[u8; <length>]` type inputs
+- Adjust keys/entries retrieval batch sizes
+- Add upgrade block for Kusama 9040
+- Use `BN` imports from `@polkadot/util`
+
+
+## 4.13.1 Jun 6, 2021
+
+Upgrade priority: Medium. Required for users connecting to Statemine and future Kusama upgrades.
+
+Changes:
+
+- Overrides for `westmint` spec (same as `statemint`)
+- Adjust `tx.session.setKeys` TS augmentation to allow `string` & `Uint8Array` keys
+- Add & adjust types for latest Cumulus code
+- Added 9031-9033 upgrade block for Westend
+- Update static metadata to latest Substrate
+- Optimize map retrieval with split page sizes for keys & values
+- Sanitizing `BN` imports to `type`-only as required
+
+
+## 4.12.1 May 30, 2021
+
+Upgrade priority: Low. Internal adjustment only, no major external usage changes.
+
+Changelog:
+
+- Update `FundInfo` type with Polkadot (Thanks to https://github.com/arjanz)
+
+Changes:
+
+- Allow storage queries with default keys values
+- Align identity `Data` to limit to 32 bytes in the `Raw` enum (as per Substrate)
+- Align static (test & docs-only) metadata with latest Substrate master
+- Added 9030 upgrade blocks for Kusama & Westend
+- Cleanup of Eth pallet RPC definitions
+- Cleanup README for `@polkadot/rpc-core` (recommended for internal-usage only)
+- Cleanup internal tests (no dangling handles, cater for Jest 27)
+
+
+## 4.11.2 May 24, 2021
+
+Upgrade priority: Low. Recommended where users are having TS mismatches with type definitions created on older versions.
+
+Changes:
+
+- Add backwards-compatible TS-only `AugmentedQueryDoubleMap` type (unused now in type generation)
+
+
+## 4.11.1 May 23, 2021
+
+Upgrade priority: Low. Recommended for users using staking entries on Polkadot and users of Substrate master.
+
+Changes:
+
+- Fix metadata v13 storage decoding on `NMap`
+- Add augmentation & keys/entries for NMap types
+- Return additional error information from internal u8a decoding failures
+- Adjust Westend types for 16 nominators-only
+- Add support for `DisallowSigned` (as per shell runtime) extension
+- Display small hex-slice with u8a decoding failures
+- Add `state_getChildReadProof` RPC
+- Cleanup Rococo known types (only as used)
+- Under Node.js allow for WS receiving up to 16MB messages
+- Update entries/keys for max of 256 items per call
+
+
+## 4.10.1 May 17, 2021
+
+Upgrade priority: Medium. Recommended for uses of Polkadot/Kusama 9010 runtimes.
+
+- **Breaking change** Support for the contracts V2 compatibility has been dropped in `@polkadot/api-contract`
+
+Contributed:
+
+- Expose RPC definitions via `.meta` (Thanks to https://github.com/jiqiang90)
+- Adjust staking derives for chain-specific optional fields (https://github.com/WoeOm)
+- Update base Centrifuge types (Thanks to https://github.com/branan)
+
+Changes:
+
+- Allow for `Bounded*` type usage (as per latest Substrate)
+- Adjust internal TS definitions for providers
+- Fix `ContractRx` query result definitions (no extra Observable)
+- Handle contract call RPC result directly as `Raw` (returned as hex)
+- Use `BN_*` constants as non-specified defaults in contract interfaces
+- Remove all type overrides for node/node-template (API tracks latest)
+- Contracts ABI now supports metadata version where indexes are 0-based
+- Remove support for the old-style V2 contracts from `@polkadot/api-contract`
+- Adjust historic decoration, return as-at registry via `getHeader`, `getMetadata` & `getRuntimeVersion`
+- Adjust `VecFixed` to allow for the handling of hex inputs
+- Adjust `Compact<*>` to allow for wrapped `toBigInt()` conversions
+- Fix `isPedantic` decoding to correctly handle `Text`
+- Cater for new `phragmenElection` module naming
+- Add Kusama & Westend 9010 upgrade blocks
+- Adjust `CompactSolution` for 24 nominators
+- Bump static metadata to latest Substrate
+
+
+## 4.9.1 May 6, 2021
+
+Upgrade priority: Medium. Required for the next v0.9.0 Polkadot/Kusama chain upgrades where parachains are used.
+
+- **Breaking change** The previously deprecated contracts interfaces, has been removed. Update to `<myContract>.query.*`, `<myContract>.tx.*` and `<myCode>.tx.*` interfaces as per the previous code usage hints.
+- **Important** By default the `isPedantic` mode is now switched on for storage queries. This means that the API will fail on any types where the input/output decoding doesn't match 100%
+
+Changes:
+
+- Re-add isPedantic check on storage decoding
+- `ConsensusEngineId` now implements `[u8;4]` (mapping closer to Rust source)
+- Additional Xcm types
+- Adjust parachain types
+- Remove error logging on createType (details passed in error)
+- Adjust `ContractInfo` type as per latest Substrate
+- Adjust `DigestItem` type as per latest Substrate
+- Adjust re-encoding of `BitVec` based on decoded length
+- Added `contracts_instantiate`, `state_traceBlock` & `system_reservedPeers` RPCs
+- Prepare for auto-capability detection with historic `.at` queries
+- Add known upgrade block for Westend 900 & 9000
+- Remove all deprecated interfaces inside `@polkadot/api-contracts`
+- Initial support for NMap storage keys
+- Support metadata v13 from Substrate (upcoming upgrade)
+- Optimize historic metadata retrieval from rpc core
+
+
+## 4.8.1 May 2, 2021
+
+Upgrade priority: Low. Recommended when using or developing for parachains.
+
+Changes:
+
+- De-alias xcm `Outcome` (used in multiple pallettes)
+- Adjust xcm types as per latest, e.g. `XcmError`
+- Fix generate of well-known storage keys (e.g. `:code`)
+- Optimize metadata unknown type validation
+- Allow metadata creation for `Map` or `Record`
+- Expose additional camelCase `method` on `AbiMessage` (maps to decorated name)
+- Added explicit double-byte ss58 `AccountId` encoding test
+- Add known upgrade block for Polkadot v30
+- Cleanup WebSocket handlers when close event has been received
+- Update to latest Substrate metadata
+
+
+## 4.7.2 Apr 26, 2021
+
+Upgrade priority: Low. Recommended for users of 4.7.1 using nvm
+
+Changes:
+
+- Update `EthBlock`/`EthHeader` types (as per Rust origin)
+- Updated Xcm `OriginKind` enum
+- Add derives for `membership`
+- Cleanups on encodedLength calculations
+- Update `.nvmrc` to reflect engines changes
+
+
+## 4.7.1 Apr 25, 2021
+
+Upgrade priority: Low. Recommended for users following Substrate master.
+
+Changes:
+
+- Adjust Struct decoding with better error messages on invalid input objects
+- Add support for new `BoundedVec` type
+- Expand `Data` type (as used in identity), with all is/as getters
+- Updated `Xcm` types (with Plularity)
+- Adjust `DispatchError` type as per current Substrate master
+- Adjusted Statemint `Proxy` type
+- Remove metadata generation dependency on well-known.json (dedupe)
+- Adjust WebSocket reconnection delay from 1s to 2.5s
+- Revert Beefy keys addition for Westend
+- Add explicit `engines` config to `package.json`
+- Support for `None` in `RewardDestination`
+- Align with latest substrate metadata
+
+
+## 4.6.2 Apr 19, 2021
+
+Upgrade priority: Low. Recommended for users of Kusama/Polkadot.
+
+Changes:
+
+- Correct Kusama/Polkadot runtime 30 session key definitions
+
+
+## 4.6.1 Apr 19, 2021
+
+Upgrade priority: Low. Recommended if used in a Node.js 15.x environment.
+
+Changes:
+
+- Assert keypair validity in signing operations
+- Expose `internalError` on submittable results (e.g. event decoding errors)
+- Simplify session derives for old/new
+- Add Statemint to known types
+- Add support for `rpc.beefy.subscribeJustifications`
+- Update Xcm types
+- Explicitly handle `isReadyOrError` with `Api.create`
+- Add Kusama upgrade block for 2030
+
+
 ## 4.5.1 Apr 12, 2021

 Upgrade priority: Low. Recommended with usage with the Rococo testnet.
@@ -9,7 +262,7 @@ Changes:
 - Update parachain types as per latest Polkadot
 - Cater for `Keys` with `BEEFY` session keys
 - Update `Keys` injection to allow for on-chain type detection
- Update `Westend` known upgrade points for runtime 50
+- Add `Westend` known upgrade block for runtime 50
 - Align types with latest Substrate master
 - Adjust keepalive `system_health` timer

@@ -21,7 +21,7 @@ The API is split up into a number of internal packages -

 - [@polkadot/api](packages/api/) The API library, providing both Promise and RxJS Observable-based interfaces. This is the main user-facing entry point.
 - [@polkadot/api-derive](packages/api-derive/) Derived results that are injected into the API, allowing for combinations of various query results (only used internally and exposed on the Api instances via `api.derive.*`)
- [@polkadot/api-metadata](packages/api-metadata/) Base extrinsic, storage and constant injectors for injection
+- [@polkadot/metadata](packages/metadata/) Base extrinsic, storage and constant injectors for injection
 - [@polkadot/rpc-core](packages/rpc-core/) Wrapper around all [JSON-RPC methods](https://polkadot.js.org/docs/substrate/rpc) exposed by a Polkadot network client
 - [@polkadot/rpc-provider](packages/rpc-provider/) Providers for connecting to nodes, including WebSockets and Http

@@ -27,5 +27,6 @@ module.exports = {
    '<rootDir>/packages/types/build',
    '<rootDir>/packages/types-known/build'
  ],
+  testTimeout: 10000,
  transformIgnorePatterns: ['/node_modules/(?!@polkadot|@babel/runtime/helpers/esm/)']
 };
@@ -8,7 +8,7 @@
    "packages/*"
  ],
  "resolutions": {
-    "typescript": "^4.2.4"
+    "typescript": "^4.3.4"
  },
  "scripts": {
    "build": "yarn build:interfaces && polkadot-dev-build-ts",
@@ -20,19 +20,19 @@
    "lint": "polkadot-dev-run-lint",
    "clean": "polkadot-dev-clean-build",
    "postinstall": "polkadot-dev-yarn-only",
-    "test": "polkadot-dev-run-test --coverage --runInBand --testPathIgnorePatterns e2e",
-    "test:one": "polkadot-dev-run-test",
+    "test": "polkadot-dev-run-test --coverage --forceExit --runInBand --testPathIgnorePatterns e2e",
+    "test:one": "polkadot-dev-run-test --detectOpenHandles --forceExit",
    "test:watch": "polkadot-dev-run-test --watch"
  },
  "devDependencies": {
-    "@babel/core": "^7.13.15",
-    "@babel/register": "^7.13.14",
-    "@babel/runtime": "^7.13.10",
-    "@polkadot/dev": "^0.62.7",
-    "@polkadot/ts": "^0.3.62",
+    "@babel/core": "^7.14.6",
+    "@babel/register": "^7.14.5",
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/dev": "^0.62.43",
+    "@polkadot/ts": "^0.4.1",
    "@polkadot/typegen": "workspace:packages/typegen",
-    "@types/jest": "^26.0.22",
+    "@types/jest": "^26.0.23",
    "copyfiles": "^2.4.1"
  },
-  "version": "4.5.1"
+  "version": "4.16.1"
 }
@@ -1,6 +1,6 @@
 {
  "name": "@polkadot/api-contract",
-  "version": "4.5.1",
+  "version": "4.16.1",
  "type": "module",
  "description": "Interfaces for interacting with contracts and contract ABIs",
  "main": "index.js",
@@ -8,6 +8,9 @@
    "./detectPackage.js",
    "./detectPackage.cjs"
  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
  "author": "Jaco Greeff <jacogr@gmail.com>",
  "maintainers": [],
  "contributors": [],
@@ -16,11 +19,10 @@
  "bugs": "https://github.com/polkadot-js/api/issues",
  "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api-contract#readme",
  "dependencies": {
-    "@babel/runtime": "^7.13.10",
-    "@polkadot/api": "4.5.1",
-    "@polkadot/types": "4.5.1",
-    "@polkadot/util": "^6.1.1",
-    "@polkadot/x-rxjs": "^6.1.1",
-    "bn.js": "^4.11.9"
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/api": "4.16.1",
+    "@polkadot/types": "4.16.1",
+    "@polkadot/util": "^6.10.1",
+    "@polkadot/x-rxjs": "^6.10.1"
  }
 }
@@ -6,12 +6,10 @@ import type { ChainProperties, ContractConstructorSpec, ContractEventSpec, Contr
 import type { AnyJson, Codec, CodecArg } from '@polkadot/types/types';
 import type { AbiConstructor, AbiEvent, AbiMessage, AbiParam, DecodedEvent, DecodedMessage } from './types';

-import { assert, assertReturn, compactAddLength, compactStripLength, isNumber, isObject, isString, logger, stringCamelCase, u8aConcat, u8aToHex } from '@polkadot/util';
+import { assert, assertReturn, compactAddLength, compactStripLength, isNumber, isObject, isString, logger, stringCamelCase, stringify, u8aConcat, u8aToHex } from '@polkadot/util';

 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 {
@@ -21,7 +19,7 @@ function findMessage <T extends AbiMessage> (list: T[], messageOrId: T | string
      ? list.find(({ identifier }) => [identifier, stringCamelCase(identifier)].includes(messageOrId.toString()))
      : messageOrId;

-  return assertReturn(message, `Attempted to call an invalid contract interface, ${JSON.stringify(messageOrId)}`);
+  return assertReturn(message, () => `Attempted to call an invalid contract interface, ${stringify(messageOrId)}`);
 }

 export class Abi {
@@ -45,13 +43,13 @@ export class Abi {
    assert(isObject(json) && !Array.isArray(json) && json.metadataVersion && isObject(json.spec) && !Array.isArray(json.spec) && Array.isArray(json.spec.constructors) && Array.isArray(json.spec.messages), 'Invalid JSON ABI structure supplied, expected a recent metadata version');

    this.json = json;
-    this.registry = new MetaRegistry(chainProperties);
+    this.registry = new MetaRegistry(json.metadataVersion as string, chainProperties);
    this.project = this.registry.createType('ContractProject', json);

    this.registry.setMetaTypes(this.project.types);

    this.project.types.forEach((_, index) =>
-      this.registry.getMetaTypeDef({ type: this.registry.createType('SiLookupTypeId', index + 1) })
+      this.registry.getMetaTypeDef({ type: this.registry.createType('SiLookupTypeId', index + this.registry.typeOffset) })
    );
    this.constructors = this.project.spec.constructors.map((spec: ContractConstructorSpec, index) =>
      this.#createMessage(spec, index, {
@@ -81,7 +79,7 @@ export class Abi {
    const index = data[0];
    const event = this.#events[index];

-    assert(event, `Unable to find event with index ${index}`);
+    assert(event, () => `Unable to find event with index ${index}`);

    return event.fromU8a(data.subarray(1));
  }
@@ -118,7 +116,7 @@ export class Abi {
          type: this.registry.getMetaTypeDef(arg.type)
        };
      } catch (error) {
-        l.error(`Error expanding argument ${index} in ${JSON.stringify(spec)}`);
+        l.error(`Error expanding argument ${index} in ${stringify(spec)}`);

        throw error;
      }
@@ -129,7 +127,7 @@ export class Abi {
    const args = this.#createArgs(spec.args, spec);
    const event = {
      args,
-      docs: spec.docs.map((doc) => doc.toString()),
+      docs: spec.docs.map((d) => d.toString()),
      fromU8a: (data: Uint8Array): DecodedEvent => ({
        args: this.#decodeArgs(args, data),
        event
@@ -143,19 +141,21 @@ export class Abi {

  #createMessage = (spec: ContractMessageSpec | ContractConstructorSpec, index: number, add: Partial<AbiMessage> = {}): AbiMessage => {
    const args = this.#createArgs(spec.args, spec);
+    const identifier = spec.name.toString();
    const message = {
      ...add,
      args,
-      docs: spec.docs.map((doc) => doc.toString()),
+      docs: spec.docs.map((d) => d.toString()),
      fromU8a: (data: Uint8Array): DecodedMessage => ({
        args: this.#decodeArgs(args, data),
        message
      }),
-      identifier: spec.name.toString(),
+      identifier,
      index,
+      method: stringCamelCase(identifier),
      selector: spec.selector,
-      toU8a: (params: CodecArg[], additional?: Uint8Array) =>
-        this.#encodeArgs(spec, args, params, additional)
+      toU8a: (params: CodecArg[]) =>
+        this.#encodeArgs(spec, args, params)
    };

    return message;
@@ -185,14 +185,13 @@ export class Abi {
    return message.fromU8a(trimmed.subarray(4));
  }

-  #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}`);
+  #encodeArgs = ({ name, selector }: ContractMessageSpec | ContractConstructorSpec, args: AbiParam[], data: CodecArg[]): 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()),
-        additional
+        ...args.map(({ type }, index) => this.registry.createType(type.type as 'Text', data[index]).toU8a())
      )
    );
  }
@@ -14,8 +14,8 @@ interface PartialTypeSpec {
 }

 // convert the offset into project-specific, index-1
-export function getRegistryOffset (id: SiLookupTypeId): number {
-  return id.toNumber() - 1;
+export function getRegistryOffset (id: SiLookupTypeId, typeOffset: number): number {
+  return id.toNumber() - typeOffset;
 }

 const PRIMITIVE_ALIAS: Record<string, keyof InterfaceTypes> = {
@@ -28,11 +28,18 @@ const PRIMITIVE_ALWAYS = ['AccountId', 'AccountIndex', 'Address', 'Balance'];
 export class MetaRegistry extends TypeRegistry {
  public readonly metaTypeDefs: TypeDef[] = [];

+  public readonly typeOffset;
+
  #siTypes: SiType[] = [];

-  constructor (chainProperties?: ChainProperties) {
+  constructor (metadataVersion: string, chainProperties?: ChainProperties) {
    super();

+    const [major, minor] = metadataVersion.split('.').map((n) => parseInt(n, 10));
+
+    // type indexes are 1-based pre 0.7 and 0-based post
+    this.typeOffset = (major === 0 && minor < 7) ? 1 : 0;
+
    if (chainProperties) {
      this.setChainProperties(chainProperties);
    }
@@ -43,7 +50,7 @@ export class MetaRegistry extends TypeRegistry {
  }

  public getMetaTypeDef (typeSpec: PartialTypeSpec): TypeDef {
-    const offset = getRegistryOffset(typeSpec.type);
+    const offset = getRegistryOffset(typeSpec.type, this.typeOffset);
    let typeDef = this.metaTypeDefs[offset];

    if (!typeDef) {
@@ -78,19 +85,22 @@ export class MetaRegistry extends TypeRegistry {
  }

  #getMetaType = (id: SiLookupTypeId): SiType => {
-    const type = this.#siTypes[getRegistryOffset(id)];
+    const type = this.#siTypes[getRegistryOffset(id, this.typeOffset)];

-    assert(!isUndefined(type), `getMetaType:: Unable to find ${id.toNumber()} in type values`);
+    assert(!isUndefined(type), () => `getMetaType:: Unable to find ${id.toNumber()} in type values`);

    return this.createType('SiType', type);
  }

  #extract = (type: SiType, id: SiLookupTypeId): TypeDef => {
    const path = [...type.path];
-    const pathFinal = path.length ? path[path.length - 1].toString() : '';
+    const isPrimitivePath = !!path.length && (
+      (path.length > 2 && path[0].eq('ink_env') && path[1].eq('types')) ||
+      PRIMITIVE_ALWAYS.includes(path[path.length - 1].toString())
+    );
    let typeDef: Omit<TypeDef, 'type'>;

-    if (type.path.join('::').startsWith('ink_env::types::') || PRIMITIVE_ALWAYS.includes(pathFinal)) {
+    if (isPrimitivePath) {
      typeDef = this.#extractPrimitivePath(type);
    } else if (type.def.isPrimitive) {
      typeDef = this.#extractPrimitive(type);
@@ -116,7 +126,7 @@ export class MetaRegistry extends TypeRegistry {
        : {}
      ),
      ...(path.length > 1
-        ? { namespace: path.map((segment) => segment.toString()).join('::') }
+        ? { namespace: path.map((s) => s.toString()).join('::') }
        : {}
      ),
      ...(type.params.length > 0
@@ -128,7 +138,7 @@ export class MetaRegistry extends TypeRegistry {
  }

  #extractArray = ({ len: length, type }: SiTypeDefArray): Omit<TypeDef, 'type'> => {
-    assert(!length || length.toNumber() <= 256, 'MetaRegistry: Only support for [Type; <length>], where length > 256');
+    assert(!length || length.toNumber() <= 256, 'MetaRegistry: Only support for [Type; <length>], where length <= 256');

    return {
      info: TypeDefInfo.VecFixed,
@@ -144,27 +154,25 @@ export class MetaRegistry extends TypeRegistry {
    ]),
    [true, true]);

-    let info;
+    assert(isTuple || isStruct, 'Invalid fields type detected, expected either Tuple or Struct');

-    // check for tuple first (no fields may be available)
-    if (isTuple) {
-      info = TypeDefInfo.Tuple;
-    } else if (isStruct) {
-      info = TypeDefInfo.Struct;
-    } else {
-      throw new Error('Invalid fields type detected, expected either Tuple or Struct');
-    }
-
-    const sub = fields.map(({ name, type }) => {
-      return {
-        ...this.getMetaTypeDef({ type }),
-        ...(name.isSome ? { name: name.unwrap().toString() } : {})
-      };
-    });
+    const sub = fields.map(({ name, type }) => ({
+      ...this.getMetaTypeDef({ type }),
+      ...(name.isSome
+        ? { name: name.unwrap().toString() }
+        : {}
+      )
+    }));

    return isTuple && sub.length === 1
      ? sub[0]
-      : { info, sub };
+      : {
+        // check for tuple first (no fields may be available)
+        info: isTuple
+          ? TypeDefInfo.Tuple
+          : TypeDefInfo.Struct,
+        sub
+      };
  }

  #extractPrimitive = (type: SiType): TypeDef => {
@@ -184,7 +192,7 @@ export class MetaRegistry extends TypeRegistry {
  }

  #extractSequence = ({ type }: SiTypeDefSequence, id: SiLookupTypeId): Omit<TypeDef, 'type'> => {
-    assert(!!type, `ContractRegistry: Invalid sequence type found at id ${id.toString()}`);
+    assert(!!type, () => `ContractRegistry: Invalid sequence type found at id ${id.toString()}`);

    return {
      info: TypeDefInfo.Vec,
@@ -205,32 +213,28 @@ export class MetaRegistry extends TypeRegistry {
    const { params, path } = this.#getMetaType(id);
    const specialVariant = path[0].toString();

-    if (specialVariant === 'Option') {
-      return {
+    return specialVariant === 'Option'
+      ? {
        info: TypeDefInfo.Option,
        sub: this.getMetaTypeDef({ type: params[0] })
-      };
-    } else if (specialVariant === 'Result') {
-      return {
-        info: TypeDefInfo.Result,
-        sub: params.map((type, index) => ({
-          name: ['Ok', 'Error'][index],
-          ...this.getMetaTypeDef({ type })
-        }))
-      };
-    }
-
-    return {
-      info: TypeDefInfo.Enum,
-      sub: this.#extractVariantSub(variants)
-    };
+      }
+      : specialVariant === 'Result'
+        ? {
+          info: TypeDefInfo.Result,
+          sub: params.map((type, index) => ({
+            name: ['Ok', 'Error'][index],
+            ...this.getMetaTypeDef({ type })
+          }))
+        }
+        : {
+          info: TypeDefInfo.Enum,
+          sub: this.#extractVariantSub(variants)
+        };
  }

  #extractVariantSub = (variants: SiVariant[]): TypeDef[] => {
-    const isAllUnitVariants = variants.every(({ fields }) => fields.length === 0);
-
-    if (isAllUnitVariants) {
-      return variants.map(({ discriminant, name }) => ({
+    return variants.every(({ fields }) => fields.length === 0)
+      ? variants.map(({ discriminant, name }) => ({
        ...(
          discriminant.isSome
            ? { ext: { discriminant: discriminant.unwrap().toNumber() } }
@@ -239,14 +243,10 @@ export class MetaRegistry extends TypeRegistry {
        info: TypeDefInfo.Plain,
        name: name.toString(),
        type: 'Null'
-      }));
-    }
-
-    return variants.map(({ fields, name }) =>
-      withTypeString({
+      }))
+      : variants.map(({ fields, name }) => withTypeString({
        ...this.#extractFields(fields),
        name: name.toString()
-      })
-    );
+      }));
  }
 }
@@ -5,7 +5,7 @@ import type { ApiTypes, DecorateMethod } from '@polkadot/api/types';
 import type { AnyJson, Registry } from '@polkadot/types/types';

 import { ApiBase } from '@polkadot/api/base';
-import { assert } from '@polkadot/util';
+import { assert, isFunction } from '@polkadot/util';

 import { Abi } from '../Abi';

@@ -26,6 +26,7 @@ export abstract class Base<ApiType extends ApiTypes> {
    this.registry = this.abi.registry;
    this._decorateMethod = decorateMethod;

-    assert(api.rx.tx.contracts?.instantiate, 'You need to connect to a node with the contracts module, the metadata does not enable api.tx.contracts on this instance');
+    assert(!!(api && api.isConnected && api.tx && api.tx.contracts && Object.keys(api.tx.contracts).length), 'Your API has not been initialized correctly and it not decorated with the runtime interfaces for contracts as retrieved from the on-chain runtime');
+    assert(isFunction(api.tx.contracts.instantiateWithCode), 'You need to connect to a chain with a runtime with a V3 contracts module. The runtime does not expose api.tx.contracts.instantiateWithCode');
  }
 }
@@ -6,17 +6,17 @@ import type { ApiTypes, DecorateMethod } from '@polkadot/api/types';
 import type { AccountId, EventRecord, Hash } from '@polkadot/types/interfaces';
 import type { AnyJson, CodecArg, ISubmittableResult } from '@polkadot/types/types';
 import type { AbiConstructor, BlueprintOptions } from '../types';
-import type { ContractGeneric, MapConstructorExec } from './types';
+import type { MapConstructorExec } from './types';

 import { SubmittableResult } from '@polkadot/api';
 import { ApiBase } from '@polkadot/api/base';
-import { isUndefined, stringCamelCase } from '@polkadot/util';
+import { BN_ZERO, isUndefined } from '@polkadot/util';

 import { Abi } from '../Abi';
 import { applyOnEvent } from '../util';
 import { Base } from './Base';
 import { Contract } from './Contract';
-import { createBluePrintTx, createBluePrintWithId, EMPTY_SALT, encodeSalt } from './util';
+import { createBluePrintTx, encodeSalt } from './util';

 export class BlueprintSubmittableResult<ApiType extends ApiTypes> extends SubmittableResult {
  public readonly contract?: Contract<ApiType>;
@@ -34,25 +34,16 @@ export class Blueprint<ApiType extends ApiTypes> extends Base<ApiType> {
   */
  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 = createBluePrintWithId(this.#deploy);

    this.abi.constructors.forEach((c): void => {
-      const messageName = stringCamelCase(c.identifier);
-
-      if (isUndefined(this.#tx[messageName])) {
-        this.#tx[messageName] = createBluePrintTx((o, p) => this.#deploy(c, o, p));
+      if (isUndefined(this.#tx[c.method])) {
+        this.#tx[c.method] = createBluePrintTx((o, p) => this.#deploy(c, o, p));
      }
    });
  }
@@ -61,20 +52,19 @@ export class Blueprint<ApiType extends ApiTypes> extends Base<ApiType> {
    return this.#tx;
  }

-  #deploy = (constructorOrId: AbiConstructor | string | number, { gasLimit = 0, salt, value = 0 }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, BlueprintSubmittableResult<ApiType>> => {
-    const encodedSalt = encodeSalt(salt);
-    const withSalt = this.api.tx.contracts.instantiate.meta.args.length === 5;
-    const encoded = this.abi.findConstructor(constructorOrId).toU8a(params, withSalt ? EMPTY_SALT : encodedSalt);
-    const tx = withSalt
-      ? this.api.tx.contracts.instantiate(value, gasLimit, this.codeHash, encoded, encodedSalt)
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore old style with salt included
-      : 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)
-      ))
-    );
+  #deploy = (constructorOrId: AbiConstructor | string | number, { gasLimit = BN_ZERO, salt, value = BN_ZERO }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, BlueprintSubmittableResult<ApiType>> => {
+    return this.api.tx.contracts
+      .instantiate(
+        value,
+        gasLimit,
+        this.codeHash,
+        this.abi.findConstructor(constructorOrId).toU8a(params),
+        encodeSalt(salt)
+      )
+      .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)
+        ))
+      );
  }
 }
@@ -10,17 +10,14 @@ import type { MapConstructorExec } from './types';

 import { SubmittableResult } from '@polkadot/api';
 import { ApiBase } from '@polkadot/api/base';
-import { assert, compactAddLength, isFunction, isUndefined, isWasm, logger, stringCamelCase, u8aToU8a } from '@polkadot/util';
-import { blake2AsU8a } from '@polkadot/util-crypto';
+import { assert, BN_ZERO, compactAddLength, isUndefined, isWasm, u8aToU8a } from '@polkadot/util';

 import { Abi } from '../Abi';
 import { applyOnEvent } from '../util';
 import { Base } from './Base';
 import { Blueprint } from './Blueprint';
 import { Contract } from './Contract';
-import { createBluePrintTx, EMPTY_SALT, encodeSalt } from './util';
-
-const l = logger('Code');
+import { createBluePrintTx, encodeSalt } from './util';

 export class CodeSubmittableResult<ApiType extends ApiTypes> extends SubmittableResult {
  public readonly blueprint?: Blueprint<ApiType>;
@@ -49,10 +46,8 @@ export class Code<ApiType extends ApiTypes> extends Base<ApiType> {
    assert(isWasm(this.code), 'No WASM code provided');

    this.abi.constructors.forEach((c): void => {
-      const messageName = stringCamelCase(c.identifier);
-
-      if (isUndefined(this.#tx[messageName])) {
-        this.#tx[messageName] = createBluePrintTx((o, p) => this.#instantiate(c, o, p));
+      if (isUndefined(this.#tx[c.method])) {
+        this.#tx[c.method] = createBluePrintTx((o, p) => this.#instantiate(c, o, p));
      }
    });
  }
@@ -61,55 +56,25 @@ export class Code<ApiType extends ApiTypes> extends Base<ApiType> {
    return this.#tx;
  }

-  /**
-   * @description Deploy the code bundle and the contract, creating a Blueprint.
-   * @deprecated Use the `code.tx.<constructor>(...) format to put code and deploy
-   */
-  public createContract (constructorOrId: AbiConstructor | string | number, options: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> {
-    l.warn('.createContract is deprecated, use code.tx.<constructorName>(...) instead (where code refers to this instance)');
-
-    return this.#instantiate(constructorOrId, options, params);
-  }
-
-  #instantiate = (constructorOrId: AbiConstructor | string | number, options: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> => {
-    return isFunction(this.api.tx.contracts.instantiateWithCode)
-      ? this.#instantiateCurrent(constructorOrId, options, params)
-      : this.#instantiatePrev(constructorOrId, options, params);
-  }
-
-  #instantiateCurrent = (constructorOrId: AbiConstructor | string | number, { gasLimit = 0, salt, value = 0 }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> => {
+  #instantiate = (constructorOrId: AbiConstructor | string | number, { gasLimit = BN_ZERO, salt, value = BN_ZERO }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> => {
    return this.api.tx.contracts
-      .instantiateWithCode(value, gasLimit, compactAddLength(this.code), this.abi.findConstructor(constructorOrId).toU8a(params), encodeSalt(salt))
-      .withResultTransform(this.#transformEvents);
-  }
-
-  #instantiatePrev = (constructorOrId: AbiConstructor | string | number, { gasLimit = 0, salt, value = 0 }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> => {
-    assert(isFunction(this.api.tx.utility?.batch), 'Your chain does not include the utility pallet, for contracts v2 deployment, this is required');
-
-    const encodedSalt = encodeSalt(salt);
-    const withSalt = this.api.tx.contracts.instantiate.meta.args.length === 5;
-    const encoded = this.abi.findConstructor(constructorOrId).toU8a(params, withSalt ? EMPTY_SALT : encodedSalt);
-    const codeHash = blake2AsU8a(this.code);
-
-    return this.api.tx.utility.batch([
-      this.api.tx.contracts.putCode(compactAddLength(this.code)),
-      withSalt
-        ? this.api.tx.contracts.instantiate(value, gasLimit, codeHash, encoded, encodedSalt)
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore old style with salt included in the params itself
-        : this.api.tx.contracts.instantiate(value, gasLimit, codeHash, encoded)
-    ]).withResultTransform(this.#transformEvents);
-  }
-
-  #transformEvents = (result: ISubmittableResult): CodeSubmittableResult<ApiType> => {
-    return new CodeSubmittableResult(result, ...(applyOnEvent(result, ['CodeStored', 'Instantiated'], (records: EventRecord[]) =>
-      records.reduce(([blueprint, contract], { event }): [Blueprint<ApiType>?, Contract<ApiType>?] =>
-        this.api.events.contracts.Instantiated.is(event)
-          ? [blueprint, new Contract<ApiType>(this.api, this.abi, event.data[1], this._decorateMethod)]
-          : this.api.events.contracts.CodeStored.is(event)
-            ? [new Blueprint<ApiType>(this.api, this.abi, event.data[0], this._decorateMethod), contract]
-            : [blueprint, contract],
-      [] as [Blueprint<ApiType>?, Contract<ApiType>?])
-    ) || []));
+      .instantiateWithCode(
+        value,
+        gasLimit,
+        compactAddLength(this.code),
+        this.abi.findConstructor(constructorOrId).toU8a(params),
+        encodeSalt(salt)
+      )
+      .withResultTransform((result: ISubmittableResult) =>
+        new CodeSubmittableResult(result, ...(applyOnEvent(result, ['CodeStored', 'Instantiated'], (records: EventRecord[]) =>
+          records.reduce<[Blueprint<ApiType>?, Contract<ApiType>?]>(([blueprint, contract], { event }) =>
+            this.api.events.contracts.Instantiated.is(event)
+              ? [blueprint, new Contract<ApiType>(this.api, this.abi, event.data[1], this._decorateMethod)]
+              : this.api.events.contracts.CodeStored.is(event)
+                ? [new Blueprint<ApiType>(this.api, this.abi, event.data[0], this._decorateMethod), contract]
+                : [blueprint, contract],
+          [])
+        ) || []))
+      );
  }
 }
@@ -4,24 +4,23 @@
 import type { SubmittableExtrinsic } from '@polkadot/api/submittable/types';
 import type { ApiTypes, DecorateMethod } from '@polkadot/api/types';
 import type { Bytes } from '@polkadot/types';
-import type { AccountId, ContractExecResult, EventRecord, Weight } from '@polkadot/types/interfaces';
-import type { AnyJson, CodecArg, ISubmittableResult, Registry } from '@polkadot/types/types';
+import type { AccountId, EventRecord, Weight } from '@polkadot/types/interfaces';
+import type { AnyJson, CodecArg, ISubmittableResult } from '@polkadot/types/types';
 import type { AbiMessage, ContractCallOutcome, ContractOptions, DecodedEvent } from '../types';
-import type { ContractCallResult, ContractCallSend, ContractGeneric, ContractQuery, ContractTx, MapMessageQuery, MapMessageTx } from './types';
-
-import BN from 'bn.js';
+import type { ContractCallResult, ContractCallSend, ContractQuery, ContractTx, MapMessageQuery, MapMessageTx } from './types';

 import { SubmittableResult } from '@polkadot/api';
 import { ApiBase } from '@polkadot/api/base';
-import { assert, bnToBn, isFunction, isUndefined, logger, stringCamelCase } from '@polkadot/util';
+import { createTypeUnsafe } from '@polkadot/types';
+import { assert, BN, BN_HUNDRED, BN_ONE, BN_ZERO, bnToBn, isFunction, isUndefined, logger } from '@polkadot/util';
 import { map } from '@polkadot/x-rxjs/operators';

 import { Abi } from '../Abi';
-import { applyOnEvent, extractOptions, formatData, isOptions } from '../util';
+import { applyOnEvent, extractOptions, isOptions } from '../util';
 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 MAX_CALL_GAS = new BN(5_000_000_000_000).isub(BN_ONE);
 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');
@@ -40,16 +39,6 @@ function createTx <ApiType extends ApiTypes> (fn: (options: ContractOptions, par
      : fn(...extractOptions(options, params));
 }

-function createWithId <T> (fn: (messageOrId: AbiMessage | string | number, options: ContractOptions, params: CodecArg[]) => T, warn?: string): ContractGeneric<ContractOptions, T> {
-  return (messageOrId: AbiMessage | string | number, options: BigInt | string | number | BN | ContractOptions, ...params: CodecArg[]): T => {
-    warn && l.warn(warn);
-
-    return isOptions(options)
-      ? fn(messageOrId, options, params)
-      : fn(messageOrId, ...extractOptions(options, params));
-  };
-}
-
 export class ContractSubmittableResult extends SubmittableResult {
  public readonly contractEvents?: DecodedEvent[];

@@ -60,51 +49,12 @@ export class ContractSubmittableResult extends SubmittableResult {
  }
 }

-// 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;

-  /**
-   * @deprecated
-   * @description Deprecated. Use `.tx.<messageName>` to send a transaction.
-   */
-  public readonly exec: ContractGeneric<ContractOptions, SubmittableExtrinsic<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> = {};
@@ -113,18 +63,14 @@ export class Contract<ApiType extends ApiTypes> extends Base<ApiType> {
    super(api, abi, decorateMethod);

    this.address = this.registry.createType('AccountId', address);
-    this.exec = createWithId(this.#exec, '.exec is deprecated, use contract.tx.<messageName>(...) instead (where contract refers to this instance)');
-    this.read = createWithId(this.#read, '.read is deprecated, use contract.query.<messageName>(...) instead (where contract refers to this instance)');

    this.abi.messages.forEach((m): void => {
-      const messageName = stringCamelCase(m.identifier);
-
-      if (isUndefined(this.#tx[messageName])) {
-        this.#tx[messageName] = createTx((o, p) => this.#exec(m, o, p));
+      if (isUndefined(this.#tx[m.method])) {
+        this.#tx[m.method] = createTx((o, p) => this.#exec(m, o, p));
      }

-      if (isUndefined(this.#query[messageName])) {
-        this.#query[messageName] = createQuery((f, o, p) => this.#read(m, o, p).send(f));
+      if (isUndefined(this.#query[m.method])) {
+        this.#query[m.method] = createQuery((f, o, p) => this.#read(m, o, p).send(f));
      }
    });
  }
@@ -146,19 +92,24 @@ export class Contract<ApiType extends ApiTypes> extends Base<ApiType> {
  #getGas = (_gasLimit: BigInt | BN | string | number, isCall = false): BN => {
    const gasLimit = bnToBn(_gasLimit);

-    return gasLimit.lten(0)
+    return gasLimit.lte(BN_ZERO)
      ? isCall
        ? MAX_CALL_GAS
        : (this.api.consts.system.blockWeights
          ? this.api.consts.system.blockWeights.maxBlock
          : this.api.consts.system.maximumBlockWeight as Weight
-        ).muln(64).divn(100)
+        ).muln(64).div(BN_HUNDRED)
      : gasLimit;
  }

-  #exec = (messageOrId: AbiMessage | string | number, { gasLimit = 0, value = 0 }: ContractOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType> => {
+  #exec = (messageOrId: AbiMessage | string | number, { gasLimit = BN_ZERO, value = BN_ZERO }: ContractOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType> => {
    return this.api.tx.contracts
-      .call(this.address, value, this.#getGas(gasLimit), this.abi.findMessage(messageOrId).toU8a(params))
+      .call(
+        this.address,
+        value,
+        this.#getGas(gasLimit),
+        this.abi.findMessage(messageOrId).toU8a(params)
+      )
      .withResultTransform((result: ISubmittableResult) =>
        // ContractEmitted is the current generation, ContractExecution is the previous generation
        new ContractSubmittableResult(result, applyOnEvent(result, ['ContractEmitted', 'ContractExecution'], (records: EventRecord[]) =>
@@ -177,7 +128,7 @@ export class Contract<ApiType extends ApiTypes> extends Base<ApiType> {
      );
  }

-  #read = (messageOrId: AbiMessage | string | number, { gasLimit = 0, value = 0 }: ContractOptions, params: CodecArg[]): ContractCallSend<ApiType> => {
+  #read = (messageOrId: AbiMessage | string | number, { gasLimit = BN_ZERO, value = BN_ZERO }: ContractOptions, params: CodecArg[]): ContractCallSend<ApiType> => {
    assert(this.hasRpcContractsCall, ERROR_NO_CALL);

    const message = this.abi.findMessage(messageOrId);
@@ -185,24 +136,24 @@ export 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.json({
-          dest: this.address,
-          gasLimit: this.#getGas(gasLimit, true),
-          inputData: message.toU8a(params),
-          origin,
-          value
-        }).pipe(map((json): ContractCallOutcome => {
-          const { debugMessage, gasConsumed, result } = mapExecResult(this.registry, json.toJSON());
-
-          return {
-            debugMessage,
-            gasConsumed,
-            output: result.isOk && message.returnType
-              ? formatData(this.registry, result.asOk.data, message.returnType)
-              : null,
-            result
-          };
-        }))
+        this.api.rx.rpc.contracts
+          .call({
+            dest: this.address,
+            gasLimit: this.#getGas(gasLimit, true),
+            inputData: message.toU8a(params),
+            origin,
+            value
+          })
+          .pipe(
+            map(({ debugMessage, gasConsumed, result }): ContractCallOutcome => ({
+              debugMessage,
+              gasConsumed,
+              output: result.isOk && message.returnType
+                ? createTypeUnsafe(this.registry, message.returnType.type, [result.asOk.data.toU8a(true)], { isPedantic: true })
+                : null,
+              result
+            }))
+          )
      )
    };
  }
@@ -7,16 +7,12 @@ import { TypeRegistry } from '@polkadot/types';
 const registry = new TypeRegistry();

 export const mockApi = {
+  isConnected: true,
  registry,
-  rx: {
-    tx: {
-      contracts: {
-        instantiate: (): never => {
-          throw new Error('mock');
-        },
-        putCode: (): never => {
-          throw new Error('mock');
-        }
+  tx: {
+    contracts: {
+      instantiateWithCode: (): never => {
+        throw new Error('mock');
      }
    }
  }
@@ -1,11 +1,11 @@
 // Copyright 2017-2021 @polkadot/api-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import type BN from 'bn.js';
 import type { SubmittableExtrinsic } from '@polkadot/api/submittable/types';
 import type { ApiTypes, ObsInnerType } from '@polkadot/api/types';
 import type { AccountId } from '@polkadot/types/interfaces';
 import type { CodecArg } from '@polkadot/types/types';
+import type { BN } from '@polkadot/util';
 import type { Observable } from '@polkadot/x-rxjs';
 import type { AbiMessage, BlueprintOptions, ContractCallOutcome, ContractOptions } from '../types';

@@ -30,7 +30,7 @@ export interface ContractGeneric<O, T> {
 }

 export type ContractCallResult<ApiType extends ApiTypes, T> = ApiType extends 'rxjs'
-  ? Observable<Observable<T>>
+  ? Observable<T>
  : Promise<ObsInnerType<Observable<T>>>;

 export interface ContractCallSend<ApiType extends ApiTypes> {
@@ -5,11 +5,10 @@ import type { SubmittableResult } from '@polkadot/api';
 import type { SubmittableExtrinsic } from '@polkadot/api/submittable/types';
 import type { ApiTypes } from '@polkadot/api/types';
 import type { CodecArg } from '@polkadot/types/types';
+import type { BN } from '@polkadot/util';
 import type { AbiConstructor, BlueprintOptions } from '../types';
 import type { BlueprintDeploy, ContractGeneric } from './types';

-import BN from 'bn.js';
-
 import { Bytes } from '@polkadot/types';
 import { compactAddLength, u8aToU8a } from '@polkadot/util';
 import { randomAsU8a } from '@polkadot/util-crypto';
@@ -30,10 +30,6 @@ async function checkContract (api: ApiPromise, pairs: TestKeyringMap): Promise<v
  // 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> {
@@ -3,4 +3,4 @@

 // Auto-generated by @polkadot/dev, do not edit

-export const packageInfo = { name: '@polkadot/api-contract', version: '4.5.1' };
+export const packageInfo = { name: '@polkadot/api-contract', version: '4.16.1' };
@@ -1,12 +1,12 @@
 // Copyright 2017-2021 @polkadot/api-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import type BN from 'bn.js';
 import type { ApiBase } from '@polkadot/api/base';
 import type { ApiTypes } from '@polkadot/api/types';
 import type { Text, u64 } from '@polkadot/types';
 import type { ContractExecResultResult, ContractSelector } from '@polkadot/types/interfaces';
 import type { Codec, CodecArg, TypeDef } from '@polkadot/types/types';
+import type { BN } from '@polkadot/util';
 import type { Abi } from '.';

 export interface ContractBase<ApiType extends ApiTypes> {
@@ -39,9 +39,10 @@ export interface AbiMessage {
  isConstructor?: boolean;
  isMutating?: boolean;
  isPayable?: boolean;
+  method: string;
  returnType?: TypeDef | null;
  selector: ContractSelector;
-  toU8a: (params: CodecArg[], additional?: Uint8Array) => Uint8Array;
+  toU8a: (params: CodecArg[]) => Uint8Array;
 }

 export type AbiConstructor = AbiMessage;
@@ -2,24 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0

 import type { SubmittableResult } from '@polkadot/api';
-import type { Raw } from '@polkadot/types';
 import type { EventRecord } from '@polkadot/types/interfaces';
-import type { Codec, CodecArg, Registry, TypeDef } from '@polkadot/types/types';
+import type { CodecArg } from '@polkadot/types/types';
+import type { BN } from '@polkadot/util';
 import type { BlueprintOptions, ContractOptions } from './types';

-import BN from 'bn.js';
-
-import { createTypeUnsafe } from '@polkadot/types/create';
 import { isBigInt, isBn, isNumber, isString } from '@polkadot/util';

 type ContractEvents = 'CodeStored' | 'ContractEmitted' | 'ContractExecution' | 'Instantiated';

 type TOptions = BlueprintOptions | ContractOptions;

-export function formatData (registry: Registry, data: Raw, { type }: TypeDef): Codec {
-  return createTypeUnsafe(registry, type, [data], { isPedantic: true });
-}
-
 export function applyOnEvent <T> (result: SubmittableResult, types: ContractEvents[], fn: (records: EventRecord[]) => T): T | undefined {
  if (result.isInBlock || result.isFinalized) {
    const records = result.filterRecords('contracts', types);
@@ -1,6 +1,6 @@
 {
  "name": "@polkadot/api-derive",
-  "version": "4.5.1",
+  "version": "4.16.1",
  "type": "module",
  "description": "Common functions used across Polkadot, derived from RPC calls and storage queries.",
  "main": "index.js",
@@ -8,6 +8,9 @@
    "./detectPackage.js",
    "./detectPackage.cjs"
  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
  "author": "Jaco Greeff <jacogr@gmail.com>",
  "maintainers": [],
  "contributors": [],
@@ -16,17 +19,16 @@
  "bugs": "https://github.com/polkadot-js/api/issues",
  "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api-derive#readme",
  "dependencies": {
-    "@babel/runtime": "^7.13.10",
-    "@polkadot/api": "4.5.1",
-    "@polkadot/rpc-core": "4.5.1",
-    "@polkadot/types": "4.5.1",
-    "@polkadot/util": "^6.1.1",
-    "@polkadot/util-crypto": "^6.1.1",
-    "@polkadot/x-rxjs": "^6.1.1",
-    "bn.js": "^4.11.9"
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/api": "4.16.1",
+    "@polkadot/rpc-core": "4.16.1",
+    "@polkadot/types": "4.16.1",
+    "@polkadot/util": "^6.10.1",
+    "@polkadot/util-crypto": "^6.10.1",
+    "@polkadot/x-rxjs": "^6.10.1"
  },
  "devDependencies": {
-    "@polkadot/keyring": "^6.1.1",
-    "@polkadot/rpc-provider": "4.5.1"
+    "@polkadot/keyring": "^6.10.1",
+    "@polkadot/rpc-provider": "4.16.1"
  }
 }
@@ -41,7 +41,11 @@ function parseFlags (address: AccountId | Address | string | null | undefined, [
 */
 export function flags (instanceId: string, api: ApiInterfaceRx): (address?: AccountId | Address | string | null) => Observable<DeriveAccountFlags> {
  return memo(instanceId, (address?: AccountId | Address | string | null): Observable<DeriveAccountFlags> => {
-    const councilSection = api.query.electionsPhragmen ? 'electionsPhragmen' : 'elections';
+    const councilSection = api.query.phragmenElection
+      ? 'phragmenElection'
+      : api.query.electionsPhragmen
+        ? 'electionsPhragmen'
+        : 'elections';

    return combineLatest<FlagsIntermediate>([
      address && api.query[councilSection]?.members
@@ -23,13 +23,19 @@ type DeriveCustomAccount = ApiInterfaceRx['derive'] & {
  }
 }

+function zeroBalance (api: ApiInterfaceRx) {
+  return api.registry.createType('Balance');
+}
+
 function getBalance (api: ApiInterfaceRx, [freeBalance, reservedBalance, frozenFee, frozenMisc]: BalanceResult): DeriveBalancesAccountData {
+  const votingBalance = api.registry.createType('Balance', freeBalance.toBn());
+
  return {
    freeBalance,
    frozenFee,
    frozenMisc,
    reservedBalance,
-    votingBalance: api.registry.createType('Balance', freeBalance.toBn())
+    votingBalance
  };
 }

@@ -55,7 +61,16 @@ function queryBalancesFree (api: ApiInterfaceRx, accountId: AccountId): Observab
  ]).pipe(
    map(([freeBalance, reservedBalance, accountNonce]): Result => [
      accountNonce,
-      [[freeBalance, reservedBalance, api.registry.createType('Balance'), api.registry.createType('Balance')]]
+      [[freeBalance, reservedBalance, zeroBalance(api), zeroBalance(api)]]
+    ])
+  );
+}
+
+function querySystemNonce (api: ApiInterfaceRx, accountId: AccountId): Observable<Result> {
+  return api.query.system.accountNonce<Index>(accountId).pipe(
+    map((accountNonce): Result => [
+      accountNonce,
+      [[zeroBalance(api), zeroBalance(api), zeroBalance(api), zeroBalance(api)]]
    ])
  );
 }
@@ -71,6 +86,7 @@ function queryBalancesAccount (api: ApiInterfaceRx, accountId: AccountId, module
  const extract = (data: AccountData[]) =>
    data.map(({ feeFrozen, free, miscFrozen, reserved }): BalanceResult => [free, reserved, feeFrozen, miscFrozen]);

+  // NOTE this is for the first case where we do have instances specified
  return isFunction(api.query.system.account)
    ? api.queryMulti<[AccountInfo, ...(AccountData[])]>([[api.query.system.account, accountId], ...balances]).pipe(
      map(([{ nonce }, ...balances]): Result => [nonce, extract(balances)])
@@ -80,16 +96,27 @@ function queryBalancesAccount (api: ApiInterfaceRx, accountId: AccountId, module
    );
 }

-function queryCurrent (api: ApiInterfaceRx, accountId: AccountId): Observable<Result> {
+function querySystemAccount (api: ApiInterfaceRx, accountId: AccountId): Observable<Result> {
  // AccountInfo is current, support old, eg. Edgeware
  return api.query.system.account<AccountInfo | ITuple<[Index, AccountData]>>(accountId).pipe(
    map((infoOrTuple): Result => {
-      const { feeFrozen, free, miscFrozen, reserved } = (infoOrTuple as AccountInfo).nonce
+      const data = (infoOrTuple as AccountInfo).nonce
        ? (infoOrTuple as AccountInfo).data
        : (infoOrTuple as [Index, AccountData])[1];

+      const nonce = (infoOrTuple as AccountInfo).nonce || (infoOrTuple as [Index, AccountData])[0];
+
+      if (!data || data.isEmpty) {
+        return [
+          nonce,
+          [[zeroBalance(api), zeroBalance(api), zeroBalance(api), zeroBalance(api)]]
+        ];
+      }
+
+      const { feeFrozen, free, miscFrozen, reserved } = data;
+
      return [
-        (infoOrTuple as AccountInfo).nonce || (infoOrTuple as [Index, AccountData])[0],
+        nonce,
        [[free, reserved, feeFrozen, miscFrozen]]
      ];
    })
@@ -113,6 +140,10 @@ function queryCurrent (api: ApiInterfaceRx, accountId: AccountId): Observable<Re
 */
 export function account (instanceId: string, api: ApiInterfaceRx): (address: AccountIndex | AccountId | Address | string) => Observable<DeriveBalancesAccount> {
  const balanceInstances = api.registry.getModuleInstances(api.runtimeVersion.specName.toString(), 'balances');
+  const empty: Result = [
+    api.registry.createType('Index'),
+    [[zeroBalance(api), zeroBalance(api), zeroBalance(api), zeroBalance(api)]]
+  ];

  return memo(instanceId, (address: AccountIndex | AccountId | Address | string): Observable<DeriveBalancesAccount> =>
    api.derive.accounts.accountId(address).pipe(
@@ -122,19 +153,17 @@ export function account (instanceId: string, api: ApiInterfaceRx): (address: Acc
            of(accountId),
            balanceInstances
              ? queryBalancesAccount(api, accountId, balanceInstances)
-              : isFunction(api.query.system.account)
-                ? queryCurrent(api, accountId)
-                : isFunction(api.query.balances.account)
+              : isFunction(api.query.system?.account)
+                ? querySystemAccount(api, accountId)
+                : isFunction(api.query.balances?.account)
                  ? queryBalancesAccount(api, accountId)
-                  : queryBalancesFree(api, accountId)
-          ])
-          : of([
-            api.registry.createType('AccountId'),
-            [
-              api.registry.createType('Index'),
-              [[api.registry.createType('Balance'), api.registry.createType('Balance'), api.registry.createType('Balance'), api.registry.createType('Balance')]]
-            ]
+                  : isFunction(api.query.balances?.freeBalance)
+                    ? queryBalancesFree(api, accountId)
+                    : isFunction(api.query.system?.accountNonce)
+                      ? querySystemNonce(api, accountId)
+                      : of(empty)
          ])
+          : of([api.registry.createType('AccountId'), empty])
        )
      ),
      map((result): DeriveBalancesAccount => calcBalances(api, result))
@@ -7,9 +7,7 @@ import type { AccountId, AccountIndex, Address, Balance, BalanceLock, BalanceLoc
 import type { Observable } from '@polkadot/x-rxjs';
 import type { DeriveBalancesAccount, DeriveBalancesAccountData, DeriveBalancesAll, DeriveBalancesAllAccountData } from '../types';

-import BN from 'bn.js';
-
-import { bnMax, isFunction } from '@polkadot/util';
+import { BN, bnMax, isFunction } from '@polkadot/util';
 import { combineLatest, of } from '@polkadot/x-rxjs';
 import { map, switchMap } from '@polkadot/x-rxjs/operators';

@@ -44,11 +42,11 @@ function calcLocked (api: ApiInterfaceRx, bestNumber: BlockNumber, locks: (Balan
  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)));
-    allLocked = lockedBreakdown.some(({ amount }) => amount.isMax());
+    allLocked = lockedBreakdown.some(({ amount }) => 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());
+    const notAll = lockedBreakdown.filter(({ amount }) => amount && !amount.isMax());

    if (notAll.length) {
      lockedBalance = api.registry.createType('Balance', bnMax(...notAll.map(({ amount }): Balance => amount)));
@@ -13,6 +13,8 @@ import { catchError, map, switchMap } from '@polkadot/x-rxjs/operators';

 import { memo } from '../util';

+type Collective = 'council' | 'membership' | 'technicalCommittee';
+
 type Result = [(Hash | Uint8Array | string)[], (Option<Proposal> | null)[], Option<Votes>[]];

 function parse (api: ApiInterfaceRx, [hashes, proposals, votes]: Result): DeriveCollectiveProposal[] {
@@ -29,7 +31,7 @@ function parse (api: ApiInterfaceRx, [hashes, proposals, votes]: Result): Derive
    .filter((proposal): proposal is DeriveCollectiveProposal => !!proposal);
 }

-function _proposalsFrom (instanceId: string, api: ApiInterfaceRx, section: 'council' | 'technicalCommittee' = 'council'): (hashes: (Hash | Uint8Array | string)[]) => Observable<DeriveCollectiveProposal[]> {
+function _proposalsFrom (instanceId: string, api: ApiInterfaceRx, section: Collective): (hashes: (Hash | Uint8Array | string)[]) => Observable<DeriveCollectiveProposal[]> {
  return memo(instanceId, (hashes: (Hash | Uint8Array | string)[]): Observable<DeriveCollectiveProposal[]> =>
    (isFunction(api.query[section]?.proposals) && hashes.length
      ? combineLatest<Result>([
@@ -49,19 +51,19 @@ function _proposalsFrom (instanceId: string, api: ApiInterfaceRx, section: 'coun
  );
 }

-export function proposals (instanceId: string, api: ApiInterfaceRx, section: 'council' | 'technicalCommittee' = 'council'): () => Observable<DeriveCollectiveProposal[]> {
+export function proposals (instanceId: string, api: ApiInterfaceRx, section: Collective): () => Observable<DeriveCollectiveProposal[]> {
  const proposalsFrom = _proposalsFrom(instanceId, api, section);

  return memo(instanceId, (): Observable<DeriveCollectiveProposal[]> =>
    isFunction(api.query[section]?.proposals)
-      ? api.query[section].proposals().pipe(
+      ? api.query[section as 'council'].proposals().pipe(
        switchMap(proposalsFrom)
      )
      : of([] as DeriveCollectiveProposal[])
  );
 }

-export function proposal (instanceId: string, api: ApiInterfaceRx, section: 'council' | 'technicalCommittee' = 'council'): (hash: Hash | Uint8Array | string) => Observable<DeriveCollectiveProposal | null> {
+export function proposal (instanceId: string, api: ApiInterfaceRx, section: Collective): (hash: Hash | Uint8Array | string) => Observable<DeriveCollectiveProposal | null> {
  const proposalsFrom = _proposalsFrom(instanceId, api, section);

  return memo(instanceId, (hash: Hash | Uint8Array | string): Observable<DeriveCollectiveProposal | null> =>
@@ -2,11 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0

 import type { ApiInterfaceRx } from '@polkadot/api/types';
+import type { BN } from '@polkadot/util';
 import type { Observable } from '@polkadot/x-rxjs';
 import type { DeriveContractFees } from '../types';

-import BN from 'bn.js';
-
 import { of } from '@polkadot/x-rxjs';
 import { map } from '@polkadot/x-rxjs/operators';

@@ -10,9 +10,9 @@ import { proposal as collectiveProposal, proposals as collectiveProposals } from
 import { memo } from '../util';

 export function proposal (instanceId: string, api: ApiInterfaceRx): (hash: Hash | Uint8Array | string) => Observable<DeriveCollectiveProposal | null> {
-  return memo(instanceId, collectiveProposal(instanceId, api));
+  return memo(instanceId, collectiveProposal(instanceId, api, 'council'));
 }

 export function proposals (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveCollectiveProposal[]> {
-  return memo(instanceId, collectiveProposals(instanceId, api));
+  return memo(instanceId, collectiveProposals(instanceId, api, 'council'));
 }
@@ -21,7 +21,7 @@ function isVoter (value: VoteEntry): value is Voter {
 }

 function retrieveStakeOf (api: ApiInterfaceRx): Observable<[AccountId, Balance][]> {
-  return (api.query.electionsPhragmen || api.query.elections).stakeOf.entries<Balance, [AccountId]>().pipe(
+  return (api.query.phragmenElection || api.query.electionsPhragmen || api.query.elections).stakeOf.entries<Balance, [AccountId]>().pipe(
    map((entries) =>
      entries.map(([{ args: [accountId] }, stake]) => [accountId, stake])
    )
@@ -29,7 +29,7 @@ function retrieveStakeOf (api: ApiInterfaceRx): Observable<[AccountId, Balance][
 }

 function retrieveVoteOf (api: ApiInterfaceRx): Observable<[AccountId, AccountId[]][]> {
-  return (api.query.electionsPhragmen || api.query.elections).votesOf.entries<Vec<AccountId>, [AccountId]>().pipe(
+  return (api.query.phragmenElection || api.query.electionsPhragmen || api.query.elections).votesOf.entries<Vec<AccountId>, [AccountId]>().pipe(
    map((entries) =>
      entries.map(([{ args: [accountId] }, votes]) => [accountId, votes])
    )
@@ -61,7 +61,7 @@ function retrievePrev (api: ApiInterfaceRx): Observable<DeriveCouncilVotes> {
 }

 function retrieveCurrent (api: ApiInterfaceRx): Observable<DeriveCouncilVotes> {
-  const elections = (api.query.electionsPhragmen || api.query.elections);
+  const elections = (api.query.phragmenElection || api.query.electionsPhragmen || api.query.elections);

  return elections.voting.entries<VoteEntry, [AccountId]>().pipe(
    map((entries): DeriveCouncilVotes =>
@@ -77,7 +77,7 @@ function retrieveCurrent (api: ApiInterfaceRx): Observable<DeriveCouncilVotes> {

 export function votes (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveCouncilVotes> {
  return memo(instanceId, (): Observable<DeriveCouncilVotes> =>
-    (api.query.electionsPhragmen || api.query.elections).stakeOf
+    (api.query.phragmenElection || api.query.electionsPhragmen || api.query.elections).stakeOf
      ? retrievePrev(api)
      : retrieveCurrent(api)
  );
@@ -4,11 +4,10 @@
 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { Option } from '@polkadot/types';
 import type { AccountId, ReferendumInfo, ReferendumInfoFinished, ReferendumInfoTo239, Vote, VotingDelegating, VotingDirect, VotingDirectVote } from '@polkadot/types/interfaces';
+import type { BN } from '@polkadot/util';
 import type { Observable } from '@polkadot/x-rxjs';
 import type { DeriveDemocracyLock } from '../types';

-import BN from 'bn.js';
-
 import { BN_ZERO, isUndefined } from '@polkadot/util';
 import { of } from '@polkadot/x-rxjs';
 import { map, switchMap } from '@polkadot/x-rxjs/operators';
@@ -3,10 +3,9 @@

 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { ReferendumIndex } from '@polkadot/types/interfaces';
+import type { BN } from '@polkadot/util';
 import type { Observable } from '@polkadot/x-rxjs';

-import BN from 'bn.js';
-
 import { of } from '@polkadot/x-rxjs';
 import { map } from '@polkadot/x-rxjs/operators';

@@ -4,11 +4,10 @@
 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { Option, Vec } from '@polkadot/types';
 import type { AccountId, ReferendumInfo, ReferendumInfoTo239, Vote, Voting, VotingDelegating, VotingDirectVote } from '@polkadot/types/interfaces';
+import type { BN } from '@polkadot/util';
 import type { Observable } from '@polkadot/x-rxjs';
 import type { DeriveBalancesAccount, DeriveReferendum, DeriveReferendumVote, DeriveReferendumVotes } from '../types';

-import BN from 'bn.js';
-
 import { isFunction } from '@polkadot/util';
 import { combineLatest, of } from '@polkadot/x-rxjs';
 import { map, switchMap } from '@polkadot/x-rxjs/operators';
@@ -2,10 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0

 import type { ApiInterfaceRx } from '@polkadot/api/types';
+import type { BN } from '@polkadot/util';
 import type { Observable } from '@polkadot/x-rxjs';

-import BN from 'bn.js';
-
 import { bnSqrt } from '@polkadot/util';
 import { map } from '@polkadot/x-rxjs/operators';

@@ -1,9 +1,9 @@
 // Copyright 2017-2021 @polkadot/api-derive authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import type BN from 'bn.js';
 import type { Vec } from '@polkadot/types';
 import type { AccountId, Balance, BlockNumber, Hash, PropIndex, Proposal, ReferendumIndex, ReferendumInfoTo239, ReferendumStatus, Vote, VoteThreshold } from '@polkadot/types/interfaces';
+import type { BN } from '@polkadot/util';

 export interface DeriveDemocracyLock {
  balance: Balance;
@@ -7,9 +7,7 @@ import type { AccountId, Balance, BlockNumber, PreimageStatus, Proposal, Referen
 import type { ITuple } from '@polkadot/types/types';
 import type { DeriveProposalImage, DeriveReferendum, DeriveReferendumVote, DeriveReferendumVotes, DeriveReferendumVoteState } from '../types';

-import BN from 'bn.js';
-
-import { bnSqrt } from '@polkadot/util';
+import { BN, bnSqrt } from '@polkadot/util';

 type PreimageInfo = [Bytes, AccountId, Balance, BlockNumber];
 type OldPreimage = ITuple<PreimageInfo>;
@@ -42,7 +42,11 @@ function sortAccounts ([, balanceA]: [AccountId, Balance], [, balanceB]: [Accoun
 }

 function queryElections (api: ApiInterfaceRx): Observable<DeriveElectionsInfo> {
-  const section = api.query.electionsPhragmen ? 'electionsPhragmen' : 'elections';
+  const section = api.query.phragmenElection
+    ? 'phragmenElection'
+    : api.query.electionsPhragmen
+      ? 'electionsPhragmen'
+      : 'elections';

  return api.queryMulti<[Vec<AccountId>, Vec<Candidate>, Vec<Member>, Vec<Member>]>([
    api.query.council.members,
@@ -39,6 +39,10 @@ describe('derive', (): void => {
      api.isReady.subscribe(() => done());
    });

+    afterAll(async () => {
+      await api.disconnect();
+    });
+
    testFunction(api)('accounts', 'idAndIndex', []);
    testFunction(api)('accounts', 'idToIndex', []);
    testFunction(api)('accounts', 'indexes', []);
@@ -80,7 +84,11 @@ describe('derive', (): void => {
    });

    beforeAll((done): void => {
-      api.isReady.subscribe((): void => done());
+      api.isReady.subscribe(() => done());
+    });
+
+    afterAll(async () => {
+      await api.disconnect();
    });

    // override
@@ -16,6 +16,7 @@ import * as council from './council';
 import * as democracy from './democracy';
 import * as elections from './elections';
 import * as imOnline from './imOnline';
+import * as membership from './membership';
 import * as parachains from './parachains';
 import * as session from './session';
 import * as society from './society';
@@ -27,7 +28,7 @@ import * as tx from './tx';
 export { packageInfo } from './packageInfo';
 export * from './type';

-export const derive = { accounts, balances, bounties, chain, contracts, council, democracy, elections, imOnline, parachains, session, society, staking, technicalCommittee, treasury, tx };
+export const derive = { accounts, balances, bounties, chain, contracts, council, democracy, elections, imOnline, membership, parachains, session, society, staking, technicalCommittee, treasury, tx };

 type DeriveSection<Section> = {
  [Method in keyof Section]: Section[Method] extends AnyFunction
@@ -47,8 +48,9 @@ const deriveAvail: Record<string, string[]> = {
  contracts: ['contracts'],
  council: ['council'],
  democracy: ['democracy'],
-  elections: ['electionsPhragmen', 'elections'],
+  elections: ['phragmenElection', 'electionsPhragmen', 'elections'],
  imOnline: ['imOnline'],
+  membership: ['membership'],
  parachains: ['parachains', 'registrar'],
  session: ['session'],
  society: ['society'],
@@ -0,0 +1,4 @@
+// Copyright 2017-2021 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './proposals';
@@ -0,0 +1,13 @@
+// Copyright 2017-2021 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ApiInterfaceRx } from '@polkadot/api/types';
+import type { Observable } from '@polkadot/x-rxjs';
+import type { DeriveCollectiveProposal } from '../types';
+
+import { proposals as collectiveProposals } from '../collective';
+import { memo } from '../util';
+
+export function proposals (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveCollectiveProposal[]> {
+  return memo(instanceId, collectiveProposals(instanceId, api, 'membership'));
+}
@@ -3,4 +3,4 @@

 // Auto-generated by @polkadot/dev, do not edit

-export const packageInfo = { name: '@polkadot/api-derive', version: '4.5.1' };
+export const packageInfo = { name: '@polkadot/api-derive', version: '4.16.1' };
@@ -2,71 +2,31 @@
 // SPDX-License-Identifier: Apache-2.0

 import type { ApiInterfaceRx } from '@polkadot/api/types';
-import type { u64 } from '@polkadot/types';
-import type { SessionIndex } from '@polkadot/types/interfaces';
 import type { Observable } from '@polkadot/x-rxjs';
-import type { DeriveSessionIndexes, DeriveSessionInfo } from '../types';
+import type { DeriveSessionInfo } from '../types';

 import { map } from '@polkadot/x-rxjs/operators';

 import { memo } from '../util';

-type ResultType = [boolean, u64, SessionIndex];
-type Result = [ResultType, DeriveSessionIndexes];
-
-function createDerive (api: ApiInterfaceRx, [[hasBabe, epochDuration, sessionsPerEra], { activeEra, activeEraStart, currentEra, currentIndex, validatorCount }]: Result): DeriveSessionInfo {
-  return {
-    activeEra,
-    activeEraStart,
-    currentEra,
-    currentIndex,
-    eraLength: api.registry.createType('BlockNumber', sessionsPerEra.mul(epochDuration)),
-    isEpoch: hasBabe,
-    sessionLength: epochDuration,
-    sessionsPerEra,
-    validatorCount
-  };
-}
-
-function queryAura (api: ApiInterfaceRx): Observable<DeriveSessionInfo> {
-  return api.derive.session.indexes().pipe(
-    map((indexes): DeriveSessionInfo =>
-      createDerive(api, [
-        [
-          false,
-          api.registry.createType('u64', 1),
-          // we may have aura without staking (permissioned)
-          api.consts.staking?.sessionsPerEra || api.registry.createType('SessionIndex', 1)
-        ],
-        indexes
-      ])
-    )
-  );
-}
-
-function queryBabe (api: ApiInterfaceRx): Observable<DeriveSessionInfo> {
-  return api.derive.session.indexes().pipe(
-    map((indexes) =>
-      createDerive(api, [
-        [
-          true,
-          api.consts.babe.epochDuration,
-          // we may have babe without staking (permissioned)
-          api.consts.staking?.sessionsPerEra || api.registry.createType('SessionIndex', 1)
-        ],
-        indexes
-      ])
-    )
-  );
-}
-
 /**
 * @description Retrieves all the session and era query and calculates specific values on it as the length of the session and eras
 */
 export function info (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveSessionInfo> {
  return memo(instanceId, (): Observable<DeriveSessionInfo> =>
-    api.consts.babe
-      ? queryBabe(api)
-      : queryAura(api)
+    api.derive.session.indexes().pipe(
+      map((indexes) => {
+        const sessionLength = api.consts?.babe?.epochDuration || api.registry.createType('u64', 1);
+        const sessionsPerEra = api.consts?.staking?.sessionsPerEra || api.registry.createType('SessionIndex', 1);
+
+        return {
+          ...indexes,
+          eraLength: api.registry.createType('BlockNumber', sessionsPerEra.mul(sessionLength)),
+          isEpoch: !!api.query.babe,
+          sessionLength,
+          sessionsPerEra
+        };
+      })
+    )
  );
 }
@@ -44,7 +44,7 @@ function queryBabe (api: ApiInterfaceRx): Observable<[DeriveSessionInfo, ResultS
      combineLatest([
        of(info),
        // we may have no staking, but have babe (permissioned)
-        api.query.staking
+        api.query.staking?.erasStartSessionIndex
          ? api.queryMulti<ResultSlots>([
            api.query.babe.currentSlot,
            api.query.babe.epochIndex,
@@ -69,7 +69,7 @@ function queryBabe (api: ApiInterfaceRx): Observable<[DeriveSessionInfo, ResultS
 */
 export function progress (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveSessionProgress> {
  return memo(instanceId, (): Observable<DeriveSessionProgress> =>
-    api.consts.babe
+    api.query.babe
      ? queryBabe(api).pipe(
        map(([info, slots]: [DeriveSessionInfo, ResultSlotsFlat]): DeriveSessionProgress =>
          createDerive(api, info, slots)
@@ -5,9 +5,7 @@ import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { Balance, StakingLedger, UnlockChunk } from '@polkadot/types/interfaces';
 import type { DeriveSessionInfo, DeriveStakingAccount, DeriveStakingKeys, DeriveStakingQuery, DeriveUnlocking } from '../types';

-import BN from 'bn.js';
-
-import { BN_ZERO } from '@polkadot/util';
+import { BN, BN_ZERO } from '@polkadot/util';
 import { combineLatest, Observable } from '@polkadot/x-rxjs';
 import { map, switchMap } from '@polkadot/x-rxjs/operators';

@@ -4,10 +4,10 @@
 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { Option, u32 } from '@polkadot/types';
 import type { ActiveEraInfo, EraIndex } from '@polkadot/types/interfaces';
+import type { BN } from '@polkadot/util';
 import type { Observable } from '@polkadot/x-rxjs';

-import BN from 'bn.js';
-
+import { BN_ONE, BN_ZERO } from '@polkadot/util';
 import { map } from '@polkadot/x-rxjs/operators';

 import { memo } from '../util';
@@ -24,12 +24,12 @@ export function erasHistoric (instanceId: string, api: ApiInterfaceRx): (withAct
        const activeEra: BN = activeEraOpt.unwrapOrDefault().index;
        let lastEra = activeEra;

-        while (lastEra.gten(0) && (result.length < max)) {
+        while (lastEra.gte(BN_ZERO) && (result.length < max)) {
          if ((lastEra !== activeEra) || (withActive === true)) {
            result.push(api.registry.createType('EraIndex', lastEra));
          }

-          lastEra = lastEra.subn(1);
+          lastEra = lastEra.sub(BN_ONE);
        }

        // go from oldest to newest
@@ -3,12 +3,11 @@

 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { AccountId, EraIndex, StakingLedger } from '@polkadot/types/interfaces';
+import type { BN } from '@polkadot/util';
 import type { Observable } from '@polkadot/x-rxjs';
 import type { DeriveEraPoints, DeriveEraPrefs, DeriveEraRewards, DeriveEraValPrefs, DeriveStakerExposure, DeriveStakerReward, DeriveStakerRewardValidator } from '../types';
 import type { DeriveStakingQuery } from './types';

-import BN from 'bn.js';
-
 import { BN_BILLION, BN_ZERO } from '@polkadot/util';
 import { combineLatest, of } from '@polkadot/x-rxjs';
 import { map, switchMap } from '@polkadot/x-rxjs/operators';
@@ -28,7 +27,7 @@ function parseRewards (api: ApiInterfaceRx, stashId: AccountId, [erasPoints, era
    Object.entries(eraValidators).forEach(([validatorId, exposure]): void => {
      const valPoints = allValPoints[validatorId] || BN_ZERO;
      const valComm = allValPrefs[validatorId]?.commission.unwrap() || BN_ZERO;
-      const expTotal = exposure.total.unwrap();
+      const expTotal = exposure.total?.unwrap() || BN_ZERO;
      let avail = BN_ZERO;
      let value: BN | undefined;

@@ -121,8 +120,6 @@ function filterRewards (eras: EraIndex[], valInfo: [string, DeriveStakingQuery][
        return false;
      }

-      reward.isStakerPayout = true;
-
      removeClaimed(validators, queryValidators, reward);

      return true;
@@ -165,17 +162,21 @@ export function _stakerRewards (instanceId: string, api: ApiInterfaceRx): (accou
        const [allValidators, stashValidators] = allUniqValidators(allRewards);

        return api.derive.staking.queryMulti(allValidators, { withLedger: true }).pipe(
-          map((queriedVals): DeriveStakerReward[][] => {
-            return queries.map(({ stakingLedger }, index): DeriveStakerReward[] => {
-              const rewards = allRewards[index];
-              const ownValidators = stashValidators[index].map((validatorId): [string, DeriveStakingQuery] => [
-                validatorId,
-                queriedVals.find((q) => q.accountId.eq(validatorId)) as DeriveStakingQuery
-              ]);
-
-              return filterRewards(eras, ownValidators, { rewards, stakingLedger });
-            });
-          })
+          map((queriedVals): DeriveStakerReward[][] =>
+            queries.map(({ stakingLedger }, index): DeriveStakerReward[] =>
+              filterRewards(
+                eras,
+                stashValidators[index].map((validatorId): [string, DeriveStakingQuery] => [
+                  validatorId,
+                  queriedVals.find((q) => q.accountId.eq(validatorId)) as DeriveStakingQuery
+                ]),
+                {
+                  rewards: allRewards[index],
+                  stakingLedger
+                }
+              )
+            )
+          )
        );
      })
    )
@@ -1,8 +1,8 @@
 // Copyright 2017-2021 @polkadot/api-derive authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import type BN from 'bn.js';
 import type { AccountId, Balance, EraIndex, Exposure, RewardDestination, RewardPoint, StakingLedger, ValidatorPrefs } from '@polkadot/types/interfaces';
+import type { BN } from '@polkadot/util';
 import type { DeriveSessionIndexes } from '../session/types';

 export type DeriveEraValPoints = Record<string, RewardPoint>;
@@ -81,7 +81,6 @@ export interface DeriveStakerRewardValidator {
 export interface DeriveStakerReward {
  era: EraIndex;
  eraReward: Balance;
-  isStakerPayout?: boolean;
  isEmpty: boolean;
  isValidator: boolean;
  nominating: DeriveEraExposureNominating[];
@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/api-derive authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import BN from 'bn.js';
+import { BN } from '@polkadot/util';

 export const FALLBACK_MAX_HASH_COUNT = 250;

@@ -1,9 +1,9 @@
 // Copyright 2017-2021 @polkadot/api-derive authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import type BN from 'bn.js';
 import type { u32 } from '@polkadot/types';
 import type { AccountId, Balance, BalanceLock, BalanceLockTo212, BalanceOf, Bid, BidKind, BlockNumber, Bounty, BountyIndex, Hash, Index, Proposal, ProposalIndex, SetIndex, SocietyVote, StrikeCount, TreasuryProposal, Votes, VouchingStatus } from '@polkadot/types/interfaces';
+import type { BN } from '@polkadot/util';

 export * from './accounts/types';
 export * from './council/types';
@@ -1,6 +1,6 @@
 {
  "name": "@polkadot/api",
-  "version": "4.5.1",
+  "version": "4.16.1",
  "type": "module",
  "description": "Promise and RxJS wrappers around the Polkadot JS RPC",
  "main": "index.js",
@@ -8,6 +8,9 @@
    "./detectPackage.js",
    "./detectPackage.cjs"
  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
  "author": "Jaco Greeff <jacogr@gmail.com>",
  "maintainers": [],
  "contributors": [],
@@ -16,18 +19,17 @@
  "bugs": "https://github.com/polkadot-js/api/issues",
  "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api#readme",
  "dependencies": {
-    "@babel/runtime": "^7.13.10",
-    "@polkadot/api-derive": "4.5.1",
-    "@polkadot/keyring": "^6.1.1",
-    "@polkadot/metadata": "4.5.1",
-    "@polkadot/rpc-core": "4.5.1",
-    "@polkadot/rpc-provider": "4.5.1",
-    "@polkadot/types": "4.5.1",
-    "@polkadot/types-known": "4.5.1",
-    "@polkadot/util": "^6.1.1",
-    "@polkadot/util-crypto": "^6.1.1",
-    "@polkadot/x-rxjs": "^6.1.1",
-    "bn.js": "^4.11.9",
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/api-derive": "4.16.1",
+    "@polkadot/keyring": "^6.10.1",
+    "@polkadot/metadata": "4.16.1",
+    "@polkadot/rpc-core": "4.16.1",
+    "@polkadot/rpc-provider": "4.16.1",
+    "@polkadot/types": "4.16.1",
+    "@polkadot/types-known": "4.16.1",
+    "@polkadot/util": "^6.10.1",
+    "@polkadot/util-crypto": "^6.10.1",
+    "@polkadot/x-rxjs": "^6.10.1",
    "eventemitter3": "^4.0.7"
  }
 }
@@ -1,8 +1,9 @@
 // Auto-generated via `yarn polkadot-types-from-chain`, do not edit
 /* eslint-disable */

-import type { Vec, u16, u32, u64, u8 } from '@polkadot/types';
+import type { Vec, u16, u32, u64 } from '@polkadot/types';
 import type { Codec } from '@polkadot/types/types';
+import type { Schedule } from '@polkadot/types/interfaces/contracts';
 import type { Balance, BalanceOf, BlockNumber, LockIdentifier, Moment, PalletId, Perbill, Percent, Permill, RuntimeDbWeight, Weight } from '@polkadot/types/interfaces/runtime';
 import type { SessionIndex } from '@polkadot/types/interfaces/session';
 import type { EraIndex } from '@polkadot/types/interfaces/staking';
@@ -14,7 +15,6 @@ import type { ApiTypes } from '@polkadot/api/types';
 declare module '@polkadot/api/types/consts' {
  export interface AugmentedConsts<ApiType> {
    babe: {
-      [key: string]: Codec;
      /**
       * The amount of time, in slots, that each epoch should last.
       * NOTE: Currently it is not possible to change the epoch duration after
@@ -29,16 +29,22 @@ declare module '@polkadot/api/types/consts' {
       * the probability of a slot being empty).
       **/
      expectedBlockTime: Moment & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    balances: {
-      [key: string]: Codec;
      /**
       * The minimum amount required to keep an account open.
       **/
      existentialDeposit: Balance & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    bounties: {
-      [key: string]: Codec;
      /**
       * Percentage of the curator fee that will be reserved upfront as deposit for bounty curator.
       **/
@@ -67,9 +73,12 @@ declare module '@polkadot/api/types/consts' {
       * Maximum acceptable reason length.
       **/
      maximumReasonLength: u32 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    contracts: {
-      [key: string]: Codec;
      /**
       * The maximum number of tries that can be queued for deletion.
       **/
@@ -104,20 +113,6 @@ declare module '@polkadot/api/types/consts' {
       * It works the same as [`Self::DepositPerStorageByte`] but for storage items.
       **/
      depositPerStorageItem: BalanceOf & AugmentedConst<ApiType>;
-      /**
-       * The maximum length of a contract code in bytes. This limit applies to the instrumented
-       * version of the code. Therefore `instantiate_with_code` can fail even when supplying
-       * a wasm binary below this maximum size.
-       **/
-      maxCodeSize: u32 & AugmentedConst<ApiType>;
-      /**
-       * The maximum nesting level of a call/instantiate stack.
-       **/
-      maxDepth: u32 & AugmentedConst<ApiType>;
-      /**
-       * The maximum size of a storage value and event payload in bytes.
-       **/
-      maxValueSize: u32 & AugmentedConst<ApiType>;
      /**
       * The fraction of the deposit that should be used as rent per block.
       * 
@@ -126,6 +121,10 @@ declare module '@polkadot/api/types/consts' {
       * This determines how high this rent payment is per block as a fraction of the deposit.
       **/
      rentFraction: Perbill & AugmentedConst<ApiType>;
+      /**
+       * Cost schedule and limits.
+       **/
+      schedule: Schedule & AugmentedConst<ApiType>;
      /**
       * Number of block delay an extrinsic claim surcharge has.
       * 
@@ -142,9 +141,12 @@ declare module '@polkadot/api/types/consts' {
       * The minimum amount required to generate a tombstone.
       **/
      tombstoneDeposit: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    democracy: {
-      [key: string]: Codec;
      /**
       * Period in blocks where an external proposal may not be re-submitted after being vetoed.
       **/
@@ -158,7 +160,7 @@ declare module '@polkadot/api/types/consts' {
       **/
      enactmentPeriod: BlockNumber & AugmentedConst<ApiType>;
      /**
-       * Minimum voting period allowed for an emergency referendum.
+       * Minimum voting period allowed for a fast-track referendum.
       **/
      fastTrackVotingPeriod: BlockNumber & AugmentedConst<ApiType>;
      /**
@@ -167,6 +169,9 @@ declare module '@polkadot/api/types/consts' {
      launchPeriod: BlockNumber & AugmentedConst<ApiType>;
      /**
       * The maximum number of votes for an account.
+       * 
+       * Also used to compute weight, an overly big value can
+       * lead to extrinsic with very big weight: see `delegate` for instance.
       **/
      maxVotes: u32 & AugmentedConst<ApiType>;
      /**
@@ -181,9 +186,19 @@ declare module '@polkadot/api/types/consts' {
       * How often (in blocks) to check for new votes.
       **/
      votingPeriod: BlockNumber & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    electionProviderMultiPhase: {
-      [key: string]: Codec;
+      /**
+       * The repeat threshold of the offchain worker.
+       * 
+       * For example, if it is 5, that means that at least 5 blocks will elapse between attempts
+       * to submit the worker's solution.
+       **/
+      offchainRepeat: BlockNumber & AugmentedConst<ApiType>;
      /**
       * Duration of the signed phase.
       **/
@@ -197,19 +212,51 @@ declare module '@polkadot/api/types/consts' {
       * Duration of the unsigned phase.
       **/
      unsignedPhase: BlockNumber & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    elections: {
-      [key: string]: Codec;
+      /**
+       * How much should be locked up in order to submit one's candidacy.
+       **/
      candidacyBond: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Number of members to elect.
+       **/
      desiredMembers: u32 & AugmentedConst<ApiType>;
+      /**
+       * Number of runners_up to keep.
+       **/
      desiredRunnersUp: u32 & AugmentedConst<ApiType>;
+      /**
+       * Identifier for the elections-phragmen pallet's lock
+       **/
      palletId: LockIdentifier & AugmentedConst<ApiType>;
+      /**
+       * How long each seat is kept. This defines the next block number at which an election
+       * round will happen. If set to zero, no elections are ever triggered and the module will
+       * be in passive mode.
+       **/
      termDuration: BlockNumber & AugmentedConst<ApiType>;
+      /**
+       * Base deposit associated with voting.
+       * 
+       * This should be sensibly high to economically ensure the pallet cannot be attacked by
+       * creating a gigantic number of votes.
+       **/
      votingBondBase: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * The amount of bond that need to be locked for each vote (32 bytes).
+       **/
      votingBondFactor: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    gilt: {
-      [key: string]: Codec;
      /**
       * Portion of the queue which is free from ordering and just a FIFO.
       * 
@@ -253,11 +300,14 @@ declare module '@polkadot/api/types/consts' {
       * this value multiplied by `Period`.
       **/
      queueCount: u32 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    identity: {
-      [key: string]: Codec;
      /**
-       * The amount held on deposit for a registered identity.
+       * The amount held on deposit for a registered identity
       **/
      basicDeposit: BalanceOf & AugmentedConst<ApiType>;
      /**
@@ -284,37 +334,61 @@ declare module '@polkadot/api/types/consts' {
       * another trie item whose value is the size of an account ID plus 32 bytes.
       **/
      subAccountDeposit: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    indices: {
-      [key: string]: Codec;
      /**
       * The deposit needed for reserving an index.
       **/
      deposit: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    lottery: {
-      [key: string]: Codec;
+      /**
+       * The max number of calls available in a single lottery.
+       **/
      maxCalls: u32 & AugmentedConst<ApiType>;
+      /**
+       * The Lottery's pallet id
+       **/
      palletId: PalletId & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    multisig: {
-      [key: string]: Codec;
      /**
       * The base amount of currency needed to reserve for creating a multisig execution or to store
       * a dispatch call for later.
+       * 
+       * This is held for an additional storage item whose value size is
+       * `4 + sizeof((BlockNumber, Balance, AccountId))` bytes and whose key size is
+       * `32 + sizeof(AccountId)` bytes.
       **/
      depositBase: BalanceOf & AugmentedConst<ApiType>;
      /**
       * The amount of currency needed per unit threshold when creating a multisig execution.
+       * 
+       * This is held for adding 32 bytes more into a pre-existing storage value.
       **/
      depositFactor: BalanceOf & AugmentedConst<ApiType>;
      /**
-       * The maximum amount of signatories allowed for a given multisig.
+       * The maximum amount of signatories allowed in the multisig.
       **/
      maxSignatories: u16 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    proxy: {
-      [key: string]: Codec;
      /**
       * The base amount of currency needed to reserve for creating an announcement.
       * 
@@ -335,7 +409,7 @@ declare module '@polkadot/api/types/consts' {
      /**
       * The maximum amount of proxies allowed for a single account.
       **/
-      maxProxies: u16 & AugmentedConst<ApiType>;
+      maxProxies: u32 & AugmentedConst<ApiType>;
      /**
       * The base amount of currency needed to reserve for creating a proxy.
       * 
@@ -351,15 +425,23 @@ declare module '@polkadot/api/types/consts' {
       * `32 + proxy_type.encode().len()` bytes of data.
       **/
      proxyDepositFactor: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    recovery: {
-      [key: string]: Codec;
      /**
       * The base amount of currency needed to reserve for creating a recovery configuration.
+       * 
+       * This is held for an additional storage item whose value size is
+       * `2 + sizeof(BlockNumber, Balance)` bytes.
       **/
      configDepositBase: BalanceOf & AugmentedConst<ApiType>;
      /**
       * The amount of currency needed per additional user when creating a recovery configuration.
+       * 
+       * This is held for adding `sizeof(AccountId)` bytes more into a pre-existing storage value.
       **/
      friendDepositFactor: BalanceOf & AugmentedConst<ApiType>;
      /**
@@ -368,11 +450,20 @@ declare module '@polkadot/api/types/consts' {
      maxFriends: u16 & AugmentedConst<ApiType>;
      /**
       * The base amount of currency needed to reserve for starting a recovery.
+       * 
+       * This is primarily held for deterring malicious recovery attempts, and should
+       * have a value large enough that a bad actor would choose not to place this
+       * deposit. It also acts to fund additional storage item whose value size is
+       * `sizeof(BlockNumber, Balance + T * AccountId)` bytes. Where T is a configurable
+       * threshold.
       **/
      recoveryDeposit: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    society: {
-      [key: string]: Codec;
      /**
       * The minimum amount of a deposit required for a bid to be made.
       **/
@@ -407,16 +498,16 @@ declare module '@polkadot/api/types/consts' {
       * doesn't vote or someone votes in the wrong way.
       **/
      wrongSideDeduction: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    staking: {
-      [key: string]: Codec;
      /**
       * Number of eras that staked funds must remain bonded for.
       **/
      bondingDuration: EraIndex & AugmentedConst<ApiType>;
-      /**
-       * Maximum number of nominations per nominator.
-       **/
      maxNominations: u32 & AugmentedConst<ApiType>;
      /**
       * The maximum number of nominators rewarded for each validator.
@@ -432,14 +523,16 @@ declare module '@polkadot/api/types/consts' {
      /**
       * Number of eras that slashes are deferred by, after computation.
       * 
-       * This should be less than the bonding duration.
-       * Set to 0 if slashes should be applied immediately, without opportunity for
-       * intervention.
+       * This should be less than the bonding duration. Set to 0 if slashes
+       * should be applied immediately, without opportunity for intervention.
       **/
      slashDeferDuration: EraIndex & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    system: {
-      [key: string]: Codec;
      /**
       * Maximum number of block number to block hash mappings to keep (oldest pruned first).
       **/
@@ -463,14 +556,17 @@ declare module '@polkadot/api/types/consts' {
       * that the runtime should know about the prefix in order to make use of it as
       * an identifier of the chain.
       **/
-      ss58Prefix: u8 & AugmentedConst<ApiType>;
+      ss58Prefix: u16 & AugmentedConst<ApiType>;
      /**
       * Get the chain's current version.
       **/
      version: RuntimeVersion & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    timestamp: {
-      [key: string]: Codec;
      /**
       * The minimum period between blocks. Beware that this is different to the *expected* period
       * that the block production apparatus provides. Your chosen consensus system will generally
@@ -478,9 +574,12 @@ declare module '@polkadot/api/types/consts' {
       * period on default settings.
       **/
      minimumPeriod: Moment & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    tips: {
-      [key: string]: Codec;
      /**
       * The amount held on deposit per byte within the tip report reason.
       **/
@@ -501,9 +600,12 @@ declare module '@polkadot/api/types/consts' {
       * The amount held on deposit for placing a tip report.
       **/
      tipReportDepositBase: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    transactionPayment: {
-      [key: string]: Codec;
      /**
       * The fee to be paid for making a transaction; the per-byte portion.
       **/
@@ -512,9 +614,12 @@ declare module '@polkadot/api/types/consts' {
       * The polynomial that is applied in order to derive fee from weight.
       **/
      weightToFee: Vec<WeightToFeeCoefficient> & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    treasury: {
-      [key: string]: Codec;
      /**
       * Percentage of spare funds (if any) that are burnt per spend period.
       **/
@@ -536,13 +641,20 @@ declare module '@polkadot/api/types/consts' {
       * Period between successive spends.
       **/
      spendPeriod: BlockNumber & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
    vesting: {
-      [key: string]: Codec;
      /**
       * The minimum amount transferred to call `vested_transfer`.
       **/
      minVestedTransfer: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
    };
  }

@@ -6,7 +6,6 @@ import type { ApiTypes } from '@polkadot/api/types';
 declare module '@polkadot/api/types/errors' {
  export interface AugmentedErrors<ApiType> {
    assets: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Invalid metadata given.
       **/
@@ -43,10 +42,6 @@ declare module '@polkadot/api/types/errors' {
       * No provider reference exists to allow a non-zero balance of a non-self-sufficient asset.
       **/
      NoProvider: AugmentedError<ApiType>;
-      /**
-       * A mint operation lead to an overflow.
-       **/
-      Overflow: AugmentedError<ApiType>;
      /**
       * No approval exists that would allow the transfer.
       **/
@@ -59,9 +54,12 @@ declare module '@polkadot/api/types/errors' {
       * The source account would not survive the transfer and it needs to stay alive.
       **/
      WouldDie: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    authorship: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * The uncle is genesis.
       **/
@@ -90,9 +88,12 @@ declare module '@polkadot/api/types/errors' {
       * Uncles already set in the block.
       **/
      UnclesAlreadySet: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    babe: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * A given equivocation report is valid but already previously reported.
       **/
@@ -105,9 +106,12 @@ declare module '@polkadot/api/types/errors' {
       * A key ownership proof provided as part of an equivocation report is invalid.
       **/
      InvalidKeyOwnershipProof: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    balances: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Beneficiary account must pre-exist
       **/
@@ -133,16 +137,19 @@ declare module '@polkadot/api/types/errors' {
       **/
      LiquidityRestrictions: AugmentedError<ApiType>;
      /**
-       * Got an overflow after adding
+       * Number of named reserves exceed MaxReserves
       **/
-      Overflow: AugmentedError<ApiType>;
+      TooManyReserves: AugmentedError<ApiType>;
      /**
       * Vesting balance too high to send value
       **/
      VestingBalance: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    bounties: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Proposer's balance is too low.
       **/
@@ -180,9 +187,12 @@ declare module '@polkadot/api/types/errors' {
       * The bounty status is unexpected.
       **/
      UnexpectedStatus: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    contracts: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Performing the requested transfer would have brought the contract below
       * the subsistence threshold. No transfer is allowed to do this in order to allow
@@ -199,6 +209,13 @@ declare module '@polkadot/api/types/errors' {
       * current schedule.
       **/
      CodeTooLarge: AugmentedError<ApiType>;
+      /**
+       * A tombstone exist at the specified address.
+       * 
+       * Tombstone cannot be called. Anyone can use `seal_restore_to` in order to revive
+       * the contract, though.
+       **/
+      ContractIsTombstone: AugmentedError<ApiType>;
      /**
       * A contract could not be evicted because it has enough balance to pay rent.
       * 
@@ -206,10 +223,18 @@ declare module '@polkadot/api/types/errors' {
       * contract has enough balance to pay for its rent.
       **/
      ContractNotEvictable: AugmentedError<ApiType>;
+      /**
+       * No contract was found at the specified address.
+       **/
+      ContractNotFound: AugmentedError<ApiType>;
      /**
       * Contract trapped during execution.
       **/
      ContractTrapped: AugmentedError<ApiType>;
+      /**
+       * The debug message specified to `seal_debug_message` does contain invalid UTF-8.
+       **/
+      DebugMessageInvalidUTF8: AugmentedError<ApiType>;
      /**
       * Input passed to a contract API function failed to decode as expected type.
       **/
@@ -231,9 +256,9 @@ declare module '@polkadot/api/types/errors' {
       **/
      DuplicateTopics: AugmentedError<ApiType>;
      /**
-       * `seal_input` was called twice from the same contract execution context.
+       * `seal_call` forwarded this contracts input. It therefore is no longer available.
       **/
-      InputAlreadyRead: AugmentedError<ApiType>;
+      InputForwarded: AugmentedError<ApiType>;
      /**
       * An origin TrieId written in the current block.
       **/
@@ -274,11 +299,6 @@ declare module '@polkadot/api/types/errors' {
       * is rejected.
       **/
      NoChainExtension: AugmentedError<ApiType>;
-      /**
-       * The contract that was called is either no contract at all (a plain account)
-       * or is a tombstone.
-       **/
-      NotCallable: AugmentedError<ApiType>;
      /**
       * A buffer outside of sandbox memory was passed to a contract API function.
       **/
@@ -296,11 +316,18 @@ declare module '@polkadot/api/types/errors' {
       **/
      RandomSubjectTooLong: AugmentedError<ApiType>;
      /**
-       * The action performed is not allowed while the contract performing it is already
-       * on the call stack. Those actions are contract self destruction and restoration
-       * of a tombstone.
+       * A call tried to invoke a contract that is flagged as non-reentrant.
       **/
      ReentranceDenied: AugmentedError<ApiType>;
+      /**
+       * The called contract does not have enough balance to pay for its storage.
+       * 
+       * The contract ran out of balance and is therefore eligible for eviction into a
+       * tombstone. Anyone can evict the contract by submitting a `claim_surcharge`
+       * extrinsic. Alternatively, a plain balance transfer can be used in order to
+       * increase the contracts funds so that it can be called again.
+       **/
+      RentNotPaid: AugmentedError<ApiType>;
      /**
       * A storage modification exhausted the 32bit type that holds the storage size.
       * 
@@ -308,6 +335,17 @@ declare module '@polkadot/api/types/errors' {
       * when number of storage items is too large.
       **/
      StorageExhausted: AugmentedError<ApiType>;
+      /**
+       * A contract self destructed in its constructor.
+       * 
+       * This can be triggered by a call to `seal_terminate` or `seal_restore_to`.
+       **/
+      TerminatedInConstructor: AugmentedError<ApiType>;
+      /**
+       * Termination of a contract is not allowed while the contract is already
+       * on the call stack. Can be triggered by `seal_terminate` or `seal_restore_to.
+       **/
+      TerminatedWhileReentrant: AugmentedError<ApiType>;
      /**
       * The amount of topics passed to `seal_deposit_events` exceeds the limit.
       **/
@@ -322,9 +360,12 @@ declare module '@polkadot/api/types/errors' {
       * The size defined in `T::MaxValueSize` was exceeded.
       **/
      ValueTooLarge: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    council: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Members are already initialized!
       **/
@@ -365,9 +406,12 @@ declare module '@polkadot/api/types/errors' {
       * The given weight bound for the proposal was too low.
       **/
      WrongProposalWeight: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    democracy: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Cannot cancel the same proposal twice
       **/
@@ -460,10 +504,6 @@ declare module '@polkadot/api/types/errors' {
       * The given account did not vote on the referendum.
       **/
      NotVoter: AugmentedError<ApiType>;
-      /**
-       * An unexpected integer overflow occurred.
-       **/
-      Overflow: AugmentedError<ApiType>;
      /**
       * Invalid preimage
       **/
@@ -492,10 +532,6 @@ declare module '@polkadot/api/types/errors' {
       * Maximum number of proposals reached.
       **/
      TooManyProposals: AugmentedError<ApiType>;
-      /**
-       * An unexpected integer underflow occurred.
-       **/
-      Underflow: AugmentedError<ApiType>;
      /**
       * Value too low
       **/
@@ -509,9 +545,20 @@ declare module '@polkadot/api/types/errors' {
       * Invalid upper bound.
       **/
      WrongUpperBound: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    electionProviderMultiPhase: {
-      [key: string]: AugmentedError<ApiType>;
+      /**
+       * The call is not allowed at this point.
+       **/
+      CallNotAllowed: AugmentedError<ApiType>;
+      /**
+       * OCW submitted solution for wrong round
+       **/
+      OcwCallWrongEra: AugmentedError<ApiType>;
      /**
       * Submission was too early.
       **/
@@ -524,9 +571,12 @@ declare module '@polkadot/api/types/errors' {
       * Wrong number of winners presented.
       **/
      PreDispatchWrongWinnerCount: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    elections: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Duplicated candidate submission.
       **/
@@ -595,9 +645,12 @@ declare module '@polkadot/api/types/errors' {
       * Cannot vote when no candidates or members exist.
       **/
      UnableToVote: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    gilt: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * The amount of the bid is less than the minimum allowed.
       **/
@@ -631,9 +684,12 @@ declare module '@polkadot/api/types/errors' {
       * Gilt index is unknown.
       **/
      Unknown: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    grandpa: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Attempt to signal GRANDPA change with one already pending.
       **/
@@ -664,9 +720,12 @@ declare module '@polkadot/api/types/errors' {
       * Cannot signal forced change so soon after last.
       **/
      TooSoon: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    identity: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Account ID is already named.
       **/
@@ -731,9 +790,12 @@ declare module '@polkadot/api/types/errors' {
       * Too many subs-accounts.
       **/
      TooManySubAccounts: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    imOnline: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Duplicated heartbeat.
       **/
@@ -742,9 +804,12 @@ declare module '@polkadot/api/types/errors' {
       * Non existent public key.
       **/
      InvalidKey: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    indices: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * The index was not available.
       **/
@@ -765,9 +830,12 @@ declare module '@polkadot/api/types/errors' {
       * The index is permanent and may not be freed/changed.
       **/
      Permanent: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    lottery: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * A lottery has already ended.
       **/
@@ -792,17 +860,16 @@ declare module '@polkadot/api/types/errors' {
       * A lottery has not been configured.
       **/
      NotConfigured: AugmentedError<ApiType>;
-      /**
-       * An overflow has occurred.
-       **/
-      Overflow: AugmentedError<ApiType>;
      /**
       * Too many calls for a single lottery.
       **/
      TooManyCalls: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    multisig: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Call is already approved by this signatory.
       **/
@@ -859,9 +926,12 @@ declare module '@polkadot/api/types/errors' {
       * A different timepoint was given to the multisig operation that is underway.
       **/
      WrongTimepoint: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    proxy: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Account is already a proxy.
       **/
@@ -894,9 +964,12 @@ declare module '@polkadot/api/types/errors' {
       * A call which is incompatible with the proxy type's filter was attempted.
       **/
      Unproxyable: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    recovery: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * This account is already set up for recovery
       **/
@@ -949,10 +1022,6 @@ declare module '@polkadot/api/types/errors' {
       * A recovery process has not started for this rescuer
       **/
      NotStarted: AugmentedError<ApiType>;
-      /**
-       * There was an overflow in a calculation
-       **/
-      Overflow: AugmentedError<ApiType>;
      /**
       * There are still active recovery attempts that need to be closed
       **/
@@ -965,9 +1034,12 @@ declare module '@polkadot/api/types/errors' {
       * Threshold must be greater than zero
       **/
      ZeroThreshold: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    scheduler: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Failed to schedule a call
       **/
@@ -984,9 +1056,12 @@ declare module '@polkadot/api/types/errors' {
       * Given target block number is in the past.
       **/
      TargetBlockNumberInPast: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    session: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Registered duplicate key.
       **/
@@ -1007,9 +1082,12 @@ declare module '@polkadot/api/types/errors' {
       * No keys are associated with this account.
       **/
      NoKeys: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    society: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * User has already made a bid.
       **/
@@ -1082,9 +1160,12 @@ declare module '@polkadot/api/types/errors' {
       * User is suspended.
       **/
      Suspended: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    staking: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Stash is already bonded.
       **/
@@ -1105,6 +1186,10 @@ declare module '@polkadot/api/types/errors' {
       * A nomination target was supplied that was blocked or otherwise not a validator.
       **/
      BadTarget: AugmentedError<ApiType>;
+      /**
+       * The user has enough bond and thus cannot be chilled forcefully by an external person.
+       **/
+      CannotChillOther: AugmentedError<ApiType>;
      /**
       * Duplicate index.
       **/
@@ -1126,9 +1211,9 @@ declare module '@polkadot/api/types/errors' {
       **/
      IncorrectSlashingSpans: AugmentedError<ApiType>;
      /**
-       * Can not bond with value less than minimum balance.
+       * Can not bond with value less than minimum required.
       **/
-      InsufficientValue: AugmentedError<ApiType>;
+      InsufficientBond: AugmentedError<ApiType>;
      /**
       * Invalid era to reward.
       **/
@@ -1161,20 +1246,36 @@ declare module '@polkadot/api/types/errors' {
       * Can not rebond without unlocking chunks.
       **/
      NoUnlockChunk: AugmentedError<ApiType>;
+      /**
+       * There are too many nominators in the system. Governance needs to adjust the staking settings
+       * to keep things safe for the runtime.
+       **/
+      TooManyNominators: AugmentedError<ApiType>;
      /**
       * Too many nomination targets supplied.
       **/
      TooManyTargets: AugmentedError<ApiType>;
+      /**
+       * There are too many validators in the system. Governance needs to adjust the staking settings
+       * to keep things safe for the runtime.
+       **/
+      TooManyValidators: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    sudo: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Sender must be the Sudo account
       **/
      RequireSudo: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    system: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Failed to extract the runtime version from the new runtime.
       * 
@@ -1199,9 +1300,12 @@ declare module '@polkadot/api/types/errors' {
       * and the new runtime.
       **/
      SpecVersionNeedsToIncrease: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    technicalCommittee: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Members are already initialized!
       **/
@@ -1242,9 +1346,12 @@ declare module '@polkadot/api/types/errors' {
       * The given weight bound for the proposal was too low.
       **/
      WrongProposalWeight: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    technicalMembership: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Already a member.
       **/
@@ -1253,9 +1360,12 @@ declare module '@polkadot/api/types/errors' {
       * Not a member.
       **/
      NotMember: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    tips: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * The tip was already found/started.
       **/
@@ -1280,9 +1390,70 @@ declare module '@polkadot/api/types/errors' {
       * The tip hash is unknown.
       **/
      UnknownTip: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    transactionStorage: {
+      /**
+       * Attempted to call `store` outside of block execution.
+       **/
+      BadContext: AugmentedError<ApiType>;
+      /**
+       * Double proof check in the block.
+       **/
+      DoubleCheck: AugmentedError<ApiType>;
+      /**
+       * Attempting to store empty transaction
+       **/
+      EmptyTransaction: AugmentedError<ApiType>;
+      /**
+       * Insufficient account balance.
+       **/
+      InsufficientFunds: AugmentedError<ApiType>;
+      /**
+       * Proof failed verification.
+       **/
+      InvalidProof: AugmentedError<ApiType>;
+      /**
+       * Missing storage proof.
+       **/
+      MissingProof: AugmentedError<ApiType>;
+      /**
+       * Unable to verify proof becasue state data is missing.
+       **/
+      MissingStateData: AugmentedError<ApiType>;
+      /**
+       * Invalid configuration.
+       **/
+      NotConfigured: AugmentedError<ApiType>;
+      /**
+       * Storage proof was not checked in the block.
+       **/
+      ProofNotChecked: AugmentedError<ApiType>;
+      /**
+       * Renewed extrinsic is not found.
+       **/
+      RenewedNotFound: AugmentedError<ApiType>;
+      /**
+       * Too many transactions in the block.
+       **/
+      TooManyTransactions: AugmentedError<ApiType>;
+      /**
+       * Transaction is too large.
+       **/
+      TransactionTooLarge: AugmentedError<ApiType>;
+      /**
+       * Proof was not expected in this block.
+       **/
+      UnexpectedProof: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    treasury: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Proposer's balance is too low.
       **/
@@ -1291,9 +1462,62 @@ declare module '@polkadot/api/types/errors' {
       * No proposal or bounty at that index.
       **/
      InvalidIndex: AugmentedError<ApiType>;
+      /**
+       * Too many approvals in the queue.
+       **/
+      TooManyApprovals: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    uniques: {
+      /**
+       * The asset instance ID has already been used for an asset.
+       **/
+      AlreadyExists: AugmentedError<ApiType>;
+      /**
+       * Invalid witness data given.
+       **/
+      BadWitness: AugmentedError<ApiType>;
+      /**
+       * The asset instance or class is frozen.
+       **/
+      Frozen: AugmentedError<ApiType>;
+      /**
+       * The asset ID is already taken.
+       **/
+      InUse: AugmentedError<ApiType>;
+      /**
+       * There is no delegate approved.
+       **/
+      NoDelegate: AugmentedError<ApiType>;
+      /**
+       * The signing account has no permission to do the operation.
+       **/
+      NoPermission: AugmentedError<ApiType>;
+      /**
+       * No approval exists that would allow the transfer.
+       **/
+      Unapproved: AugmentedError<ApiType>;
+      /**
+       * The given asset ID is unknown.
+       **/
+      Unknown: AugmentedError<ApiType>;
+      /**
+       * The delegate turned out to be different to what was expected.
+       **/
+      WrongDelegate: AugmentedError<ApiType>;
+      /**
+       * The owner turned out to be different to what was expected.
+       **/
+      WrongOwner: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
    vesting: {
-      [key: string]: AugmentedError<ApiType>;
      /**
       * Amount being transferred is too low to create a vesting schedule.
       **/
@@ -1306,6 +1530,10 @@ declare module '@polkadot/api/types/errors' {
       * The account given is not vesting.
       **/
      NotVesting: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
    };
  }

@@ -21,13 +21,13 @@ import type { IdentificationTuple, SessionIndex } from '@polkadot/types/interfac
 import type { ElectionCompute, EraIndex } from '@polkadot/types/interfaces/staking';
 import type { DispatchError, DispatchInfo, DispatchResult } from '@polkadot/types/interfaces/system';
 import type { BountyIndex } from '@polkadot/types/interfaces/treasury';
+import type { ClassId, InstanceId } from '@polkadot/types/interfaces/uniques';
 import type { Timepoint } from '@polkadot/types/interfaces/utility';
 import type { ApiTypes } from '@polkadot/api/types';

 declare module '@polkadot/api/types/events' {
  export interface AugmentedEvents<ApiType> {
    assets: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * An approval for account `delegate` was cancelled by `owner`.
       * \[id, owner, delegate\]
@@ -105,9 +105,12 @@ declare module '@polkadot/api/types/events' {
       * \[id, owner, delegate, destination\]
       **/
      TransferredApproved: AugmentedEvent<ApiType, [AssetId, AccountId, AccountId, AccountId, TAssetBalance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    balances: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A balance was set by root. \[who, free, reserved\]
       **/
@@ -143,9 +146,12 @@ declare module '@polkadot/api/types/events' {
       * Some balance was unreserved (moved from reserved to free). \[who, value\]
       **/
      Unreserved: AugmentedEvent<ApiType, [AccountId, Balance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    bounties: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A bounty is awarded to a beneficiary. \[index, beneficiary\]
       **/
@@ -174,9 +180,12 @@ declare module '@polkadot/api/types/events' {
       * A bounty proposal was rejected; funds were slashed. \[index, bond\]
       **/
      BountyRejected: AugmentedEvent<ApiType, [BountyIndex, Balance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    contracts: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A code with the specified hash was removed.
       * \[code_hash\]
@@ -243,9 +252,12 @@ declare module '@polkadot/api/types/events' {
       * this event is by calling `seal_terminate`.
       **/
      Terminated: AugmentedEvent<ApiType, [AccountId, AccountId]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    council: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A motion was approved by the required threshold.
       * \[proposal_hash\]
@@ -283,9 +295,12 @@ declare module '@polkadot/api/types/events' {
       * \[account, proposal_hash, voted, yes, no\]
       **/
      Voted: AugmentedEvent<ApiType, [AccountId, Hash, bool, MemberCount, MemberCount]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    democracy: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A proposal \[hash\] has been blacklisted permanently.
       **/
@@ -362,9 +377,12 @@ declare module '@polkadot/api/types/events' {
       * An external proposal has been vetoed. \[who, proposal_hash, until\]
       **/
      Vetoed: AugmentedEvent<ApiType, [AccountId, Hash, BlockNumber]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    electionProviderMultiPhase: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * The election has been finalized, with `Some` of the given computation, or else if the
       * election failed, `None`.
@@ -393,9 +411,12 @@ declare module '@polkadot/api/types/events' {
       * The unsigned phase of the given round has started.
       **/
      UnsignedPhaseStarted: AugmentedEvent<ApiType, [u32]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    elections: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A \[candidate\] was slashed by \[amount\] due to failing to obtain a seat as member or
       * runner-up.
@@ -418,10 +439,11 @@ declare module '@polkadot/api/types/events' {
       **/
      MemberKicked: AugmentedEvent<ApiType, [AccountId]>;
      /**
-       * A new term with \[new_members\]. This indicates that enough candidates existed to run the
-       * election, not that enough have has been elected. The inner value must be examined for
-       * this purpose. A `NewTerm(\[\])` indicates that some candidates got their bond slashed and
-       * none were elected, whilst `EmptyTerm` means that no candidates existed to begin with.
+       * A new term with \[new_members\]. This indicates that enough candidates existed to run
+       * the election, not that enough have has been elected. The inner value must be examined
+       * for this purpose. A `NewTerm(\[\])` indicates that some candidates got their bond
+       * slashed and none were elected, whilst `EmptyTerm` means that no candidates existed to
+       * begin with.
       **/
      NewTerm: AugmentedEvent<ApiType, [Vec<ITuple<[AccountId, Balance]>>]>;
      /**
@@ -432,9 +454,12 @@ declare module '@polkadot/api/types/events' {
       * A \[seat holder\] was slashed by \[amount\] by being forcefully removed from the set.
       **/
      SeatHolderSlashed: AugmentedEvent<ApiType, [AccountId, Balance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    gilt: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A bid was successfully placed.
       * \[ who, amount, duration \]
@@ -455,9 +480,12 @@ declare module '@polkadot/api/types/events' {
       * \[ index, who, original_amount, additional_amount \]
       **/
      GiltThawed: AugmentedEvent<ApiType, [ActiveIndex, AccountId, BalanceOf, BalanceOf]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    grandpa: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * New authority set has been applied. \[authority_set\]
       **/
@@ -470,9 +498,12 @@ declare module '@polkadot/api/types/events' {
       * Current authority set has been resumed.
       **/
      Resumed: AugmentedEvent<ApiType, []>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    identity: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A name was cleared, and the given balance returned. \[who, deposit\]
       **/
@@ -515,9 +546,12 @@ declare module '@polkadot/api/types/events' {
       * main identity account to the sub-identity account. \[sub, main, deposit\]
       **/
      SubIdentityRevoked: AugmentedEvent<ApiType, [AccountId, AccountId, Balance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    imOnline: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * At the end of the session, no offence was committed.
       **/
@@ -530,9 +564,12 @@ declare module '@polkadot/api/types/events' {
       * At the end of the session, at least one validator was found to be \[offline\].
       **/
      SomeOffline: AugmentedEvent<ApiType, [Vec<IdentificationTuple>]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    indices: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A account index was assigned. \[index, who\]
       **/
@@ -545,9 +582,12 @@ declare module '@polkadot/api/types/events' {
       * A account index has been frozen to its current account ID. \[index, who\]
       **/
      IndexFrozen: AugmentedEvent<ApiType, [AccountIndex, AccountId]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    lottery: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A new set of calls have been set!
       **/
@@ -564,9 +604,12 @@ declare module '@polkadot/api/types/events' {
       * A winner has been chosen!
       **/
      Winner: AugmentedEvent<ApiType, [AccountId, Balance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    multisig: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A multisig operation has been approved by someone.
       * \[approving, timepoint, multisig, call_hash\]
@@ -584,19 +627,24 @@ declare module '@polkadot/api/types/events' {
       * A new multisig operation has begun. \[approving, multisig, call_hash\]
       **/
      NewMultisig: AugmentedEvent<ApiType, [AccountId, AccountId, CallHash]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    offences: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * There is an offence reported of the given `kind` happened at the `session_index` and
-       * (kind-specific) time slot. This event is not deposited for duplicate slashes. last
-       * element indicates of the offence was applied (true) or queued (false)
-       * \[kind, timeslot, applied\].
+       * (kind-specific) time slot. This event is not deposited for duplicate slashes.
+       * \[kind, timeslot\].
       **/
-      Offence: AugmentedEvent<ApiType, [Kind, OpaqueTimeSlot, bool]>;
+      Offence: AugmentedEvent<ApiType, [Kind, OpaqueTimeSlot]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    proxy: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * An announcement was placed to make a call in the future. \[real, proxy, call_hash\]
       **/
@@ -610,9 +658,12 @@ declare module '@polkadot/api/types/events' {
       * A proxy was executed correctly, with the given \[result\].
       **/
      ProxyExecuted: AugmentedEvent<ApiType, [DispatchResult]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    recovery: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * Lost account has been successfully recovered by rescuer account.
       * \[lost, rescuer\]
@@ -641,9 +692,12 @@ declare module '@polkadot/api/types/events' {
       * \[lost, rescuer, sender\]
       **/
      RecoveryVouched: AugmentedEvent<ApiType, [AccountId, AccountId, AccountId]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    scheduler: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * Canceled some task. \[when, index\]
       **/
@@ -656,17 +710,23 @@ declare module '@polkadot/api/types/events' {
       * Scheduled some task. \[when, index\]
       **/
      Scheduled: AugmentedEvent<ApiType, [BlockNumber, u32]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    session: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * New session has happened. Note that the argument is the \[session_index\], not the block
       * number as the type might suggest.
       **/
      NewSession: AugmentedEvent<ApiType, [SessionIndex]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    society: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A \[candidate\] was dropped (due to an excess of bids in the system).
       **/
@@ -734,9 +794,12 @@ declare module '@polkadot/api/types/events' {
       * their offer is the second. The vouching party is the third. \[candidate_id, offer, vouching\]
       **/
      Vouch: AugmentedEvent<ApiType, [AccountId, Balance, AccountId]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    staking: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * An account has bonded this amount. \[stash, amount\]
       * 
@@ -772,6 +835,10 @@ declare module '@polkadot/api/types/events' {
       * A new set of stakers was elected.
       **/
      StakingElection: AugmentedEvent<ApiType, []>;
+      /**
+       * The election failed. No new era is planned.
+       **/
+      StakingElectionFailed: AugmentedEvent<ApiType, []>;
      /**
       * An account has unbonded this amount. \[stash, amount\]
       **/
@@ -781,9 +848,12 @@ declare module '@polkadot/api/types/events' {
       * from the unlocking queue. \[stash, amount\]
       **/
      Withdrawn: AugmentedEvent<ApiType, [AccountId, Balance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    sudo: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * The \[sudoer\] just switched identity; the old key is supplied.
       **/
@@ -796,9 +866,12 @@ declare module '@polkadot/api/types/events' {
       * A sudo just took place. \[result\]
       **/
      SudoAsDone: AugmentedEvent<ApiType, [DispatchResult]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    system: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * `:code` was updated.
       **/
@@ -823,9 +896,12 @@ declare module '@polkadot/api/types/events' {
       * On on-chain remark happened. \[origin, remark_hash\]
       **/
      Remarked: AugmentedEvent<ApiType, [AccountId, Hash]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    technicalCommittee: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A motion was approved by the required threshold.
       * \[proposal_hash\]
@@ -863,9 +939,12 @@ declare module '@polkadot/api/types/events' {
       * \[account, proposal_hash, voted, yes, no\]
       **/
      Voted: AugmentedEvent<ApiType, [AccountId, Hash, bool, MemberCount, MemberCount]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    technicalMembership: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * Phantom member, never used.
       **/
@@ -890,9 +969,12 @@ declare module '@polkadot/api/types/events' {
       * Two members were swapped; see the transaction for who.
       **/
      MembersSwapped: AugmentedEvent<ApiType, []>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    tips: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * A new tip suggestion has been opened. \[tip_hash\]
       **/
@@ -913,9 +995,30 @@ declare module '@polkadot/api/types/events' {
       * A tip suggestion has been slashed. \[tip_hash, finder, deposit\]
       **/
      TipSlashed: AugmentedEvent<ApiType, [Hash, AccountId, Balance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    transactionStorage: {
+      /**
+       * Storage proof was successfully checked.
+       **/
+      ProofChecked: AugmentedEvent<ApiType, []>;
+      /**
+       * Renewed data under specified index.
+       **/
+      Renewed: AugmentedEvent<ApiType, [u32]>;
+      /**
+       * Stored data under specified index.
+       **/
+      Stored: AugmentedEvent<ApiType, [u32]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    treasury: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * Some funds have been allocated. \[proposal_index, award, beneficiary\]
       **/
@@ -945,9 +1048,114 @@ declare module '@polkadot/api/types/events' {
       * We have ended a spend period and will now allocate funds. \[budget_remaining\]
       **/
      Spending: AugmentedEvent<ApiType, [Balance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    uniques: {
+      /**
+       * An approval for a `delegate` account to transfer the `instance` of an asset `class` was
+       * cancelled by its `owner`.
+       * \[ class, instance, owner, delegate \]
+       **/
+      ApprovalCancelled: AugmentedEvent<ApiType, [ClassId, InstanceId, AccountId, AccountId]>;
+      /**
+       * An `instance` of an asset `class` has been approved by the `owner` for transfer by a
+       * `delegate`.
+       * \[ class, instance, owner, delegate \]
+       **/
+      ApprovedTransfer: AugmentedEvent<ApiType, [ClassId, InstanceId, AccountId, AccountId]>;
+      /**
+       * An asset `class` has had its attributes changed by the `Force` origin.
+       * \[ class \]
+       **/
+      AssetStatusChanged: AugmentedEvent<ApiType, [ClassId]>;
+      /**
+       * Attribute metadata has been cleared for an asset class or instance.
+       * \[ class, maybe_instance, key, maybe_value \]
+       **/
+      AttributeCleared: AugmentedEvent<ApiType, [ClassId, Option<InstanceId>, Bytes]>;
+      /**
+       * New attribute metadata has been set for an asset class or instance.
+       * \[ class, maybe_instance, key, value \]
+       **/
+      AttributeSet: AugmentedEvent<ApiType, [ClassId, Option<InstanceId>, Bytes, Bytes]>;
+      /**
+       * An asset `instance` was destroyed. \[ class, instance, owner \]
+       **/
+      Burned: AugmentedEvent<ApiType, [ClassId, InstanceId, AccountId]>;
+      /**
+       * Some asset `class` was frozen. \[ class \]
+       **/
+      ClassFrozen: AugmentedEvent<ApiType, [ClassId]>;
+      /**
+       * Metadata has been cleared for an asset class. \[ class \]
+       **/
+      ClassMetadataCleared: AugmentedEvent<ApiType, [ClassId]>;
+      /**
+       * New metadata has been set for an asset class. \[ class, data, is_frozen \]
+       **/
+      ClassMetadataSet: AugmentedEvent<ApiType, [ClassId, Bytes, bool]>;
+      /**
+       * Some asset `class` was thawed. \[ class \]
+       **/
+      ClassThawed: AugmentedEvent<ApiType, [ClassId]>;
+      /**
+       * An asset class was created. \[ class, creator, owner \]
+       **/
+      Created: AugmentedEvent<ApiType, [ClassId, AccountId, AccountId]>;
+      /**
+       * An asset `class` was destroyed. \[ class \]
+       **/
+      Destroyed: AugmentedEvent<ApiType, [ClassId]>;
+      /**
+       * An asset class was force-created. \[ class, owner \]
+       **/
+      ForceCreated: AugmentedEvent<ApiType, [ClassId, AccountId]>;
+      /**
+       * Some asset `instance` was frozen. \[ class, instance \]
+       **/
+      Frozen: AugmentedEvent<ApiType, [ClassId, InstanceId]>;
+      /**
+       * An asset `instace` was issued. \[ class, instance, owner \]
+       **/
+      Issued: AugmentedEvent<ApiType, [ClassId, InstanceId, AccountId]>;
+      /**
+       * Metadata has been cleared for an asset instance. \[ class, instance \]
+       **/
+      MetadataCleared: AugmentedEvent<ApiType, [ClassId, InstanceId]>;
+      /**
+       * New metadata has been set for an asset instance.
+       * \[ class, instance, data, is_frozen \]
+       **/
+      MetadataSet: AugmentedEvent<ApiType, [ClassId, InstanceId, Bytes, bool]>;
+      /**
+       * The owner changed \[ class, new_owner \]
+       **/
+      OwnerChanged: AugmentedEvent<ApiType, [ClassId, AccountId]>;
+      /**
+       * Metadata has been cleared for an asset instance. \[ class, successful_instances \]
+       **/
+      Redeposited: AugmentedEvent<ApiType, [ClassId, Vec<InstanceId>]>;
+      /**
+       * The management team changed \[ class, issuer, admin, freezer \]
+       **/
+      TeamChanged: AugmentedEvent<ApiType, [ClassId, AccountId, AccountId, AccountId]>;
+      /**
+       * Some asset `instance` was thawed. \[ class, instance \]
+       **/
+      Thawed: AugmentedEvent<ApiType, [ClassId, InstanceId]>;
+      /**
+       * An asset `instace` was transferred. \[ class, instance, from, to \]
+       **/
+      Transferred: AugmentedEvent<ApiType, [ClassId, InstanceId, AccountId, AccountId]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    utility: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * Batch of dispatches completed fully with no error.
       **/
@@ -957,9 +1165,12 @@ declare module '@polkadot/api/types/events' {
       * well as the error. \[index, error\]
       **/
      BatchInterrupted: AugmentedEvent<ApiType, [u32, DispatchError]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
    vesting: {
-      [key: string]: AugmentedEvent<ApiType>;
      /**
       * An \[account\] has become fully vested. No further vesting can happen.
       **/
@@ -970,6 +1181,10 @@ declare module '@polkadot/api/types/events' {
       * \[account, unvested\]
       **/
      VestingUpdated: AugmentedEvent<ApiType, [AccountId, Balance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
    };
  }

@@ -3,13 +3,13 @@

 import type { Bytes, Data, Option, U8aFixed, Vec, bool, u32, u64 } from '@polkadot/types';
 import type { AnyNumber, ITuple, Observable } from '@polkadot/types/types';
-import type { AssetApproval, AssetApprovalKey, AssetBalance, AssetDetails, AssetMetadata } from '@polkadot/types/interfaces/assets';
+import type { AssetApproval, AssetBalance, AssetDetails, AssetMetadata } from '@polkadot/types/interfaces/assets';
 import type { UncleEntryItem } from '@polkadot/types/interfaces/authorship';
 import type { BabeAuthorityWeight, BabeEpochConfiguration, MaybeRandomness, NextConfigDescriptor, Randomness } from '@polkadot/types/interfaces/babe';
-import type { AccountData, BalanceLock } from '@polkadot/types/interfaces/balances';
+import type { AccountData, BalanceLock, ReserveData } from '@polkadot/types/interfaces/balances';
 import type { ProposalIndex, Votes } from '@polkadot/types/interfaces/collective';
 import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
-import type { CodeHash, ContractInfo, DeletedContract, PrefabWasmModule, Schedule } from '@polkadot/types/interfaces/contracts';
+import type { CodeHash, ContractInfo, DeletedContract, PrefabWasmModule } from '@polkadot/types/interfaces/contracts';
 import type { PreimageStatus, PropIndex, Proposal, ReferendumIndex, ReferendumInfo, Voting } from '@polkadot/types/interfaces/democracy';
 import type { VoteThreshold } from '@polkadot/types/interfaces/elections';
 import type { ActiveGilt, ActiveGiltsTotal, ActiveIndex, GiltBid } from '@polkadot/types/interfaces/gilt';
@@ -17,17 +17,18 @@ import type { SetId, StoredPendingChange, StoredState } from '@polkadot/types/in
 import type { RegistrarInfo, Registration } from '@polkadot/types/interfaces/identity';
 import type { AuthIndex } from '@polkadot/types/interfaces/imOnline';
 import type { CallIndex, LotteryConfig } from '@polkadot/types/interfaces/lottery';
-import type { DeferredOffenceOf, Kind, OffenceDetails, OpaqueTimeSlot, ReportIdOf } from '@polkadot/types/interfaces/offences';
+import type { Kind, OffenceDetails, OpaqueTimeSlot, ReportIdOf } from '@polkadot/types/interfaces/offences';
 import type { ProxyAnnouncement, ProxyDefinition } from '@polkadot/types/interfaces/proxy';
 import type { ActiveRecovery, RecoveryConfig } from '@polkadot/types/interfaces/recovery';
-import type { AccountId, AccountIndex, AssetId, Balance, BalanceOf, BlockNumber, Hash, KeyTypeId, Moment, OpaqueCall, Perbill, Releases, Slot, ValidatorId } from '@polkadot/types/interfaces/runtime';
+import type { AccountId, AccountIndex, AssetId, Balance, BalanceOf, BlockNumber, Hash, KeyTypeId, Moment, OpaqueCall, Perbill, Releases, Slot, TransactionInfo, ValidatorId } from '@polkadot/types/interfaces/runtime';
 import type { Scheduled, TaskAddress } from '@polkadot/types/interfaces/scheduler';
 import type { Keys, SessionIndex } from '@polkadot/types/interfaces/session';
 import type { Bid, BidKind, SocietyVote, StrikeCount, VouchingStatus } from '@polkadot/types/interfaces/society';
-import type { ActiveEraInfo, ElectionPhase, EraIndex, EraRewardPoints, Exposure, Forcing, Nominations, ReadySolution, RewardDestination, RoundSnapshot, SeatHolder, SlashingSpans, SolutionOrSnapshotSize, SpanIndex, SpanRecord, StakingLedger, UnappliedSlash, ValidatorPrefs, Voter } from '@polkadot/types/interfaces/staking';
+import type { ActiveEraInfo, ElectionPhase, ElectionScore, EraIndex, EraRewardPoints, Exposure, Forcing, Nominations, ReadySolution, RewardDestination, RoundSnapshot, SeatHolder, SlashingSpans, SolutionOrSnapshotSize, SpanIndex, SpanRecord, StakingLedger, UnappliedSlash, ValidatorPrefs, Voter } from '@polkadot/types/interfaces/staking';
 import type { AccountInfo, ConsumedWeight, DigestOf, EventIndex, EventRecord, LastRuntimeUpgradeInfo, Phase } from '@polkadot/types/interfaces/system';
 import type { Bounty, BountyIndex, OpenTip, TreasuryProposal } from '@polkadot/types/interfaces/treasury';
 import type { Multiplier } from '@polkadot/types/interfaces/txpayment';
+import type { ClassDetails, ClassId, ClassMetadata, DepositBalanceOf, InstanceDetails, InstanceId, InstanceMetadata } from '@polkadot/types/interfaces/uniques';
 import type { Multisig } from '@polkadot/types/interfaces/utility';
 import type { VestingInfo } from '@polkadot/types/interfaces/vesting';
 import type { ApiTypes } from '@polkadot/api/types';
@@ -35,16 +36,16 @@ import type { ApiTypes } from '@polkadot/api/types';
 declare module '@polkadot/api/types/storage' {
  export interface AugmentedQueries<ApiType> {
    assets: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The number of units of assets held by any given account.
       **/
-      account: AugmentedQueryDoubleMap<ApiType, (key1: AssetId | AnyNumber | Uint8Array, key2: AccountId | string | Uint8Array) => Observable<AssetBalance>, [AssetId, AccountId]> & QueryableStorageEntry<ApiType, [AssetId, AccountId]>;
+      account: AugmentedQuery<ApiType, (arg1: AssetId | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<AssetBalance>, [AssetId, AccountId]> & QueryableStorageEntry<ApiType, [AssetId, AccountId]>;
      /**
       * Approved balance transfers. First balance is the amount approved for transfer. Second
       * is the amount of `T::Currency` reserved for storing this.
+       * First key is the asset ID, second key is the owner and third key is the delegate.
       **/
-      approvals: AugmentedQueryDoubleMap<ApiType, (key1: AssetId | AnyNumber | Uint8Array, key2: AssetApprovalKey | { owner?: any; delegate?: any } | string | Uint8Array) => Observable<Option<AssetApproval>>, [AssetId, AssetApprovalKey]> & QueryableStorageEntry<ApiType, [AssetId, AssetApprovalKey]>;
+      approvals: AugmentedQuery<ApiType, (arg1: AssetId | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array, arg3: AccountId | string | Uint8Array) => Observable<Option<AssetApproval>>, [AssetId, AccountId, AccountId]> & QueryableStorageEntry<ApiType, [AssetId, AccountId, AccountId]>;
      /**
       * Details of an asset.
       **/
@@ -53,9 +54,12 @@ declare module '@polkadot/api/types/storage' {
       * Metadata of an asset.
       **/
      metadata: AugmentedQuery<ApiType, (arg: AssetId | AnyNumber | Uint8Array) => Observable<AssetMetadata>, [AssetId]> & QueryableStorageEntry<ApiType, [AssetId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    authorship: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Author of current block.
       **/
@@ -68,9 +72,12 @@ declare module '@polkadot/api/types/storage' {
       * Uncles
       **/
      uncles: AugmentedQuery<ApiType, () => Observable<Vec<UncleEntryItem>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    babe: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Current epoch authorities.
       **/
@@ -165,9 +172,12 @@ declare module '@polkadot/api/types/storage' {
       * TWOX-NOTE: `SegmentIndex` is an increasing integer, so this is okay.
       **/
      underConstruction: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Randomness>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    balances: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The balance of an account.
       * 
@@ -179,6 +189,10 @@ declare module '@polkadot/api/types/storage' {
       * NOTE: Should only be accessed when setting, changing and freeing a lock.
       **/
      locks: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Vec<BalanceLock>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
+      /**
+       * Named reserves on some account balances.
+       **/
+      reserves: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Vec<ReserveData>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * Storage version of the pallet.
       * 
@@ -189,9 +203,12 @@ declare module '@polkadot/api/types/storage' {
       * The total units issued in the system.
       **/
      totalIssuance: AugmentedQuery<ApiType, () => Observable<Balance>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    bounties: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Bounties that have been made.
       **/
@@ -208,9 +225,12 @@ declare module '@polkadot/api/types/storage' {
       * The description of each bounty.
       **/
      bountyDescriptions: AugmentedQuery<ApiType, (arg: BountyIndex | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [BountyIndex]> & QueryableStorageEntry<ApiType, [BountyIndex]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    contracts: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The subtrie counter.
       **/
@@ -225,10 +245,6 @@ declare module '@polkadot/api/types/storage' {
       * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
       **/
      contractInfoOf: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<ContractInfo>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
-      /**
-       * Current cost schedule for contracts.
-       **/
-      currentSchedule: AugmentedQuery<ApiType, () => Observable<Schedule>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Evicted contracts that await child trie deletion.
       * 
@@ -240,9 +256,12 @@ declare module '@polkadot/api/types/storage' {
       * A mapping from an original code hash to the original code, untouched by instrumentation.
       **/
      pristineCode: AugmentedQuery<ApiType, (arg: CodeHash | string | Uint8Array) => Observable<Option<Bytes>>, [CodeHash]> & QueryableStorageEntry<ApiType, [CodeHash]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    council: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The current members of the collective. This is stored sorted (just by value).
       **/
@@ -267,9 +286,12 @@ declare module '@polkadot/api/types/storage' {
       * Votes on a given proposal, if it is ongoing.
       **/
      voting: AugmentedQuery<ApiType, (arg: Hash | string | Uint8Array) => Observable<Option<Votes>>, [Hash]> & QueryableStorageEntry<ApiType, [Hash]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    democracy: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * A record of who vetoed what. Maps proposal hash to a possible existent block number
       * (until when it may not be resubmitted) and who vetoed it.
@@ -345,9 +367,12 @@ declare module '@polkadot/api/types/storage' {
       * TWOX-NOTE: SAFE as `AccountId`s are crypto hashes anyway.
       **/
      votingOf: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Voting>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    electionProviderMultiPhase: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Current phase.
       **/
@@ -358,6 +383,13 @@ declare module '@polkadot/api/types/storage' {
       * Only exists when [`Snapshot`] is present.
       **/
      desiredTargets: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The minimum score that each 'untrusted' solution must attain in order to be considered
+       * feasible.
+       * 
+       * Can be set via `set_minimum_untrusted_score`.
+       **/
+      minimumUntrustedScore: AugmentedQuery<ApiType, () => Observable<Option<ElectionScore>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Current best solution, signed or unsigned, queued to be returned upon `elect`.
       **/
@@ -383,9 +415,12 @@ declare module '@polkadot/api/types/storage' {
       * Only exists when [`Snapshot`] is present.
       **/
      snapshotMetadata: AugmentedQuery<ApiType, () => Observable<Option<SolutionOrSnapshotSize>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    elections: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The present candidate list. A current member or runner-up can never enter this vector
       * and is always implicitly assumed to be a candidate.
@@ -418,9 +453,12 @@ declare module '@polkadot/api/types/storage' {
       * TWOX-NOTE: SAFE as `AccountId` is a crypto hash.
       **/
      voting: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Voter>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    gilt: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The currently active gilts, indexed according to the order of creation.
       **/
@@ -441,9 +479,12 @@ declare module '@polkadot/api/types/storage' {
       * whose duration is one `Period` would be storage `0`.
       **/
      queueTotals: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, BalanceOf]>>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    grandpa: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The number of changes (both in terms of keys and underlying economic responsibilities)
       * in the "set" of Grandpa validators from genesis.
@@ -472,9 +513,12 @@ declare module '@polkadot/api/types/storage' {
       * State of the current authority set.
       **/
      state: AugmentedQuery<ApiType, () => Observable<StoredState>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    identity: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Information that is pertinent to identify the entity behind an account.
       * 
@@ -501,14 +545,17 @@ declare module '@polkadot/api/types/storage' {
       * context. If the account is not some other account's sub-identity, then just `None`.
       **/
      superOf: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<ITuple<[AccountId, Data]>>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    imOnline: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * For each session index, we keep a mapping of `ValidatorId<T>` to the
       * number of blocks authored by the given authority.
       **/
-      authoredBlocks: AugmentedQueryDoubleMap<ApiType, (key1: SessionIndex | AnyNumber | Uint8Array, key2: ValidatorId | string | Uint8Array) => Observable<u32>, [SessionIndex, ValidatorId]> & QueryableStorageEntry<ApiType, [SessionIndex, ValidatorId]>;
+      authoredBlocks: AugmentedQuery<ApiType, (arg1: SessionIndex | AnyNumber | Uint8Array, arg2: ValidatorId | string | Uint8Array) => Observable<u32>, [SessionIndex, ValidatorId]> & QueryableStorageEntry<ApiType, [SessionIndex, ValidatorId]>;
      /**
       * The block number after which it's ok to send heartbeats in the current
       * session.
@@ -531,17 +578,23 @@ declare module '@polkadot/api/types/storage' {
       * For each session index, we keep a mapping of `AuthIndex` to
       * `offchain::OpaqueNetworkState`.
       **/
-      receivedHeartbeats: AugmentedQueryDoubleMap<ApiType, (key1: SessionIndex | AnyNumber | Uint8Array, key2: AuthIndex | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [SessionIndex, AuthIndex]> & QueryableStorageEntry<ApiType, [SessionIndex, AuthIndex]>;
+      receivedHeartbeats: AugmentedQuery<ApiType, (arg1: SessionIndex | AnyNumber | Uint8Array, arg2: AuthIndex | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [SessionIndex, AuthIndex]> & QueryableStorageEntry<ApiType, [SessionIndex, AuthIndex]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    indices: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The lookup from index to account.
       **/
      accounts: AugmentedQuery<ApiType, (arg: AccountIndex | AnyNumber | Uint8Array) => Observable<Option<ITuple<[AccountId, BalanceOf, bool]>>>, [AccountIndex]> & QueryableStorageEntry<ApiType, [AccountIndex]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    lottery: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The calls stored in this pallet to be used in an active lottery if configured
       * by `Config::ValidateCall`.
@@ -567,9 +620,12 @@ declare module '@polkadot/api/types/storage' {
       * Total number of tickets sold.
       **/
      ticketsCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    mmr: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Hashes of the nodes in the MMR.
       * 
@@ -585,26 +641,27 @@ declare module '@polkadot/api/types/storage' {
       * Latest MMR Root hash.
       **/
      rootHash: AugmentedQuery<ApiType, () => Observable<Hash>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    multisig: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      calls: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<ITuple<[OpaqueCall, AccountId, BalanceOf]>>>, [U8aFixed]> & QueryableStorageEntry<ApiType, [U8aFixed]>;
      /**
       * The set of open multisig operations.
       **/
-      multisigs: AugmentedQueryDoubleMap<ApiType, (key1: AccountId | string | Uint8Array, key2: U8aFixed | string | Uint8Array) => Observable<Option<Multisig>>, [AccountId, U8aFixed]> & QueryableStorageEntry<ApiType, [AccountId, U8aFixed]>;
+      multisigs: AugmentedQuery<ApiType, (arg1: AccountId | string | Uint8Array, arg2: U8aFixed | string | Uint8Array) => Observable<Option<Multisig>>, [AccountId, U8aFixed]> & QueryableStorageEntry<ApiType, [AccountId, U8aFixed]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    offences: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * A vector of reports of the same kind that happened at the same time slot.
       **/
-      concurrentReportsIndex: AugmentedQueryDoubleMap<ApiType, (key1: Kind | string | Uint8Array, key2: OpaqueTimeSlot | string | Uint8Array) => Observable<Vec<ReportIdOf>>, [Kind, OpaqueTimeSlot]> & QueryableStorageEntry<ApiType, [Kind, OpaqueTimeSlot]>;
-      /**
-       * Deferred reports that have been rejected by the offence handler and need to be submitted
-       * at a later time.
-       **/
-      deferredOffences: AugmentedQuery<ApiType, () => Observable<Vec<DeferredOffenceOf>>, []> & QueryableStorageEntry<ApiType, []>;
+      concurrentReportsIndex: AugmentedQuery<ApiType, (arg1: Kind | string | Uint8Array, arg2: OpaqueTimeSlot | string | Uint8Array) => Observable<Vec<ReportIdOf>>, [Kind, OpaqueTimeSlot]> & QueryableStorageEntry<ApiType, [Kind, OpaqueTimeSlot]>;
      /**
       * The primary structure that holds all offence records keyed by report identifiers.
       **/
@@ -618,9 +675,12 @@ declare module '@polkadot/api/types/storage' {
       * different types are not supported at the moment so we are doing the manual serialization.
       **/
      reportsByKindIndex: AugmentedQuery<ApiType, (arg: Kind | string | Uint8Array) => Observable<Bytes>, [Kind]> & QueryableStorageEntry<ApiType, [Kind]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    proxy: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The announcements made by the proxy (key).
       **/
@@ -630,25 +690,31 @@ declare module '@polkadot/api/types/storage' {
       * which are being delegated to, together with the amount held on deposit.
       **/
      proxies: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<ITuple<[Vec<ProxyDefinition>, BalanceOf]>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    randomnessCollectiveFlip: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Series of block headers from the last 81 blocks that acts as random seed material. This
       * is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of
       * the oldest hash.
       **/
      randomMaterial: AugmentedQuery<ApiType, () => Observable<Vec<Hash>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    recovery: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Active recovery attempts.
       * 
       * First account is the account to be recovered, and the second account
       * is the user trying to recover the account.
       **/
-      activeRecoveries: AugmentedQueryDoubleMap<ApiType, (key1: AccountId | string | Uint8Array, key2: AccountId | string | Uint8Array) => Observable<Option<ActiveRecovery>>, [AccountId, AccountId]> & QueryableStorageEntry<ApiType, [AccountId, AccountId]>;
+      activeRecoveries: AugmentedQuery<ApiType, (arg1: AccountId | string | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<Option<ActiveRecovery>>, [AccountId, AccountId]> & QueryableStorageEntry<ApiType, [AccountId, AccountId]>;
      /**
       * The list of allowed proxy accounts.
       * 
@@ -659,9 +725,12 @@ declare module '@polkadot/api/types/storage' {
       * The set of recoverable accounts and their recovery configuration.
       **/
      recoverable: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<RecoveryConfig>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    scheduler: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Items to be executed, indexed by the block number that they should be executed on.
       **/
@@ -676,9 +745,12 @@ declare module '@polkadot/api/types/storage' {
       * New networks start with last version.
       **/
      storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    session: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Current index of the session.
       **/
@@ -711,9 +783,12 @@ declare module '@polkadot/api/types/storage' {
       * The current set of validators.
       **/
      validators: AugmentedQuery<ApiType, () => Observable<Vec<ValidatorId>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    society: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The current bids, stored ordered by the value of the bid.
       **/
@@ -774,14 +849,17 @@ declare module '@polkadot/api/types/storage' {
      /**
       * Double map from Candidate -> Voter -> (Maybe) Vote.
       **/
-      votes: AugmentedQueryDoubleMap<ApiType, (key1: AccountId | string | Uint8Array, key2: AccountId | string | Uint8Array) => Observable<Option<SocietyVote>>, [AccountId, AccountId]> & QueryableStorageEntry<ApiType, [AccountId, AccountId]>;
+      votes: AugmentedQuery<ApiType, (arg1: AccountId | string | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<Option<SocietyVote>>, [AccountId, AccountId]> & QueryableStorageEntry<ApiType, [AccountId, AccountId]>;
      /**
       * Members currently vouching or banned from vouching again
       **/
      vouching: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<VouchingStatus>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    staking: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The active era information, it holds index and start.
       * 
@@ -805,6 +883,14 @@ declare module '@polkadot/api/types/storage' {
       * canceled by extraordinary circumstances (e.g. governance).
       **/
      canceledSlashPayout: AugmentedQuery<ApiType, () => Observable<BalanceOf>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * A tracker to keep count of the number of items in the `Nominators` map.
+       **/
+      counterForNominators: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * A tracker to keep count of the number of items in the `Validators` map.
+       **/
+      counterForValidators: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The current era index.
       * 
@@ -835,7 +921,7 @@ declare module '@polkadot/api/types/storage' {
       * Is it removed after `HISTORY_DEPTH` eras.
       * If stakers hasn't been set or has been removed then empty exposure is returned.
       **/
-      erasStakers: AugmentedQueryDoubleMap<ApiType, (key1: EraIndex | AnyNumber | Uint8Array, key2: AccountId | string | Uint8Array) => Observable<Exposure>, [EraIndex, AccountId]> & QueryableStorageEntry<ApiType, [EraIndex, AccountId]>;
+      erasStakers: AugmentedQuery<ApiType, (arg1: EraIndex | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<Exposure>, [EraIndex, AccountId]> & QueryableStorageEntry<ApiType, [EraIndex, AccountId]>;
      /**
       * Clipped Exposure of validator at era.
       * 
@@ -849,7 +935,7 @@ declare module '@polkadot/api/types/storage' {
       * Is it removed after `HISTORY_DEPTH` eras.
       * If stakers hasn't been set or has been removed then empty exposure is returned.
       **/
-      erasStakersClipped: AugmentedQueryDoubleMap<ApiType, (key1: EraIndex | AnyNumber | Uint8Array, key2: AccountId | string | Uint8Array) => Observable<Exposure>, [EraIndex, AccountId]> & QueryableStorageEntry<ApiType, [EraIndex, AccountId]>;
+      erasStakersClipped: AugmentedQuery<ApiType, (arg1: EraIndex | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<Exposure>, [EraIndex, AccountId]> & QueryableStorageEntry<ApiType, [EraIndex, AccountId]>;
      /**
       * The session index at which the era start for the last `HISTORY_DEPTH` eras.
       * 
@@ -869,7 +955,7 @@ declare module '@polkadot/api/types/storage' {
       * 
       * Is it removed after `HISTORY_DEPTH` eras.
       **/
-      erasValidatorPrefs: AugmentedQueryDoubleMap<ApiType, (key1: EraIndex | AnyNumber | Uint8Array, key2: AccountId | string | Uint8Array) => Observable<ValidatorPrefs>, [EraIndex, AccountId]> & QueryableStorageEntry<ApiType, [EraIndex, AccountId]>;
+      erasValidatorPrefs: AugmentedQuery<ApiType, (arg1: EraIndex | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<ValidatorPrefs>, [EraIndex, AccountId]> & QueryableStorageEntry<ApiType, [EraIndex, AccountId]>;
      /**
       * The total validator era payout for the last `HISTORY_DEPTH` eras.
       * 
@@ -900,18 +986,40 @@ declare module '@polkadot/api/types/storage' {
       * Map from all (unlocked) "controller" accounts to the info regarding the staking.
       **/
      ledger: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<StakingLedger>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
+      /**
+       * The maximum nominator count before we stop allowing new validators to join.
+       * 
+       * When this value is not set, no limits are enforced.
+       **/
+      maxNominatorsCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The maximum validator count before we stop allowing new validators to join.
+       * 
+       * When this value is not set, no limits are enforced.
+       **/
+      maxValidatorsCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Minimum number of staking participants before emergency conditions are imposed.
       **/
      minimumValidatorCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The minimum active bond to become and maintain the role of a nominator.
+       **/
+      minNominatorBond: AugmentedQuery<ApiType, () => Observable<BalanceOf>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The minimum active bond to become and maintain the role of a validator.
+       **/
+      minValidatorBond: AugmentedQuery<ApiType, () => Observable<BalanceOf>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The map from nominator stash key to the set of stash keys of all validators to nominate.
+       * 
+       * When updating this storage item, you must also update the `CounterForNominators`.
       **/
      nominators: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<Nominations>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * All slashing events on nominators, mapped by era to the highest slash value of the era.
       **/
-      nominatorSlashInEra: AugmentedQueryDoubleMap<ApiType, (key1: EraIndex | AnyNumber | Uint8Array, key2: AccountId | string | Uint8Array) => Observable<Option<BalanceOf>>, [EraIndex, AccountId]> & QueryableStorageEntry<ApiType, [EraIndex, AccountId]>;
+      nominatorSlashInEra: AugmentedQuery<ApiType, (arg1: EraIndex | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<Option<BalanceOf>>, [EraIndex, AccountId]> & QueryableStorageEntry<ApiType, [EraIndex, AccountId]>;
      /**
       * Where the reward payment should be made. Keyed by stash.
       **/
@@ -948,23 +1056,31 @@ declare module '@polkadot/api/types/storage' {
      validatorCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The map from (wannabe) validator stash key to the preferences of that validator.
+       * 
+       * When updating this storage item, you must also update the `CounterForValidators`.
       **/
      validators: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<ValidatorPrefs>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * All slashing events on validators, mapped by era to the highest slash proportion
       * and slash value of the era.
       **/
-      validatorSlashInEra: AugmentedQueryDoubleMap<ApiType, (key1: EraIndex | AnyNumber | Uint8Array, key2: AccountId | string | Uint8Array) => Observable<Option<ITuple<[Perbill, BalanceOf]>>>, [EraIndex, AccountId]> & QueryableStorageEntry<ApiType, [EraIndex, AccountId]>;
+      validatorSlashInEra: AugmentedQuery<ApiType, (arg1: EraIndex | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array) => Observable<Option<ITuple<[Perbill, BalanceOf]>>>, [EraIndex, AccountId]> & QueryableStorageEntry<ApiType, [EraIndex, AccountId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    sudo: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The `AccountId` of the sudo key.
       **/
      key: AugmentedQuery<ApiType, () => Observable<AccountId>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    system: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The full account information for a particular account ID.
       **/
@@ -1039,9 +1155,12 @@ declare module '@polkadot/api/types/storage' {
       * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
       **/
      upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    technicalCommittee: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The current members of the collective. This is stored sorted (just by value).
       **/
@@ -1066,9 +1185,12 @@ declare module '@polkadot/api/types/storage' {
       * Votes on a given proposal, if it is ongoing.
       **/
      voting: AugmentedQuery<ApiType, (arg: Hash | string | Uint8Array) => Observable<Option<Votes>>, [Hash]> & QueryableStorageEntry<ApiType, [Hash]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    technicalMembership: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * The current membership, stored as an ordered Vec.
       **/
@@ -1077,9 +1199,12 @@ declare module '@polkadot/api/types/storage' {
       * The current prime member, if one exists.
       **/
      prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    timestamp: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Did the timestamp get updated in this block?
       **/
@@ -1088,9 +1213,12 @@ declare module '@polkadot/api/types/storage' {
       * Current time for the current block.
       **/
      now: AugmentedQuery<ApiType, () => Observable<Moment>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    tips: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Simple preimage lookup from the reason's hash to the original data. Again, has an
       * insecure enumerable hash since the key is guaranteed to be the result of a secure hash.
@@ -1102,14 +1230,60 @@ declare module '@polkadot/api/types/storage' {
       * guaranteed to be a secure hash.
       **/
      tips: AugmentedQuery<ApiType, (arg: Hash | string | Uint8Array) => Observable<Option<OpenTip>>, [Hash]> & QueryableStorageEntry<ApiType, [Hash]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    transactionPayment: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<Multiplier>, []> & QueryableStorageEntry<ApiType, []>;
      storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    transactionStorage: {
+      blockTransactions: AugmentedQuery<ApiType, () => Observable<Vec<TransactionInfo>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Storage fee per byte.
+       **/
+      byteFee: AugmentedQuery<ApiType, () => Observable<Option<BalanceOf>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Count indexed chunks for each block.
+       **/
+      chunkCount: AugmentedQuery<ApiType, (arg: BlockNumber | AnyNumber | Uint8Array) => Observable<u32>, [BlockNumber]> & QueryableStorageEntry<ApiType, [BlockNumber]>;
+      /**
+       * Storage fee per transaction.
+       **/
+      entryFee: AugmentedQuery<ApiType, () => Observable<Option<BalanceOf>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Maximum number of indexed transactions in the block.
+       **/
+      maxBlockTransactions: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Maximum data set in a single transaction in bytes.
+       **/
+      maxTransactionSize: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Was the proof checked in this block?
+       **/
+      proofChecked: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Storage period for data in blocks. Should match `sp_storage_proof::DEFAULT_STORAGE_PERIOD`
+       * for block authoring.
+       **/
+      storagePeriod: AugmentedQuery<ApiType, () => Observable<BlockNumber>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Collection of transaction metadata by block number.
+       **/
+      transactions: AugmentedQuery<ApiType, (arg: BlockNumber | AnyNumber | Uint8Array) => Observable<Option<Vec<TransactionInfo>>>, [BlockNumber]> & QueryableStorageEntry<ApiType, [BlockNumber]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    treasury: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Proposal indices that have been approved but not yet awarded.
       **/
@@ -1122,13 +1296,51 @@ declare module '@polkadot/api/types/storage' {
       * Proposals that have been made.
       **/
      proposals: AugmentedQuery<ApiType, (arg: ProposalIndex | AnyNumber | Uint8Array) => Observable<Option<TreasuryProposal>>, [ProposalIndex]> & QueryableStorageEntry<ApiType, [ProposalIndex]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    uniques: {
+      /**
+       * The assets held by any given account; set out this way so that assets owned by a single
+       * account can be enumerated.
+       **/
+      account: AugmentedQuery<ApiType, (arg1: AccountId | string | Uint8Array, arg2: ClassId | AnyNumber | Uint8Array, arg3: InstanceId | AnyNumber | Uint8Array) => Observable<Option<ITuple<[]>>>, [AccountId, ClassId, InstanceId]> & QueryableStorageEntry<ApiType, [AccountId, ClassId, InstanceId]>;
+      /**
+       * The assets in existence and their ownership details.
+       **/
+      asset: AugmentedQuery<ApiType, (arg1: ClassId | AnyNumber | Uint8Array, arg2: InstanceId | AnyNumber | Uint8Array) => Observable<Option<InstanceDetails>>, [ClassId, InstanceId]> & QueryableStorageEntry<ApiType, [ClassId, InstanceId]>;
+      /**
+       * Metadata of an asset class.
+       **/
+      attribute: AugmentedQuery<ApiType, (arg1: ClassId | AnyNumber | Uint8Array, arg2: Option<InstanceId> | null | object | string | Uint8Array, arg3: Bytes | string | Uint8Array) => Observable<Option<ITuple<[Bytes, DepositBalanceOf]>>>, [ClassId, Option<InstanceId>, Bytes]> & QueryableStorageEntry<ApiType, [ClassId, Option<InstanceId>, Bytes]>;
+      /**
+       * Details of an asset class.
+       **/
+      class: AugmentedQuery<ApiType, (arg: ClassId | AnyNumber | Uint8Array) => Observable<Option<ClassDetails>>, [ClassId]> & QueryableStorageEntry<ApiType, [ClassId]>;
+      /**
+       * Metadata of an asset class.
+       **/
+      classMetadataOf: AugmentedQuery<ApiType, (arg: ClassId | AnyNumber | Uint8Array) => Observable<Option<ClassMetadata>>, [ClassId]> & QueryableStorageEntry<ApiType, [ClassId]>;
+      /**
+       * Metadata of an asset instance.
+       **/
+      instanceMetadataOf: AugmentedQuery<ApiType, (arg1: ClassId | AnyNumber | Uint8Array, arg2: InstanceId | AnyNumber | Uint8Array) => Observable<Option<InstanceMetadata>>, [ClassId, InstanceId]> & QueryableStorageEntry<ApiType, [ClassId, InstanceId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
    vesting: {
-      [key: string]: QueryableStorageEntry<ApiType>;
      /**
       * Information regarding the vesting of a given account.
       **/
      vesting: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<VestingInfo>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
    };
  }

@@ -6,10 +6,11 @@ import type { Bytes, HashMap, Json, Null, Option, StorageKey, Text, U256, U64, V
 import type { AnyNumber, Codec, IExtrinsic, Observable } from '@polkadot/types/types';
 import type { ExtrinsicOrHash, ExtrinsicStatus } from '@polkadot/types/interfaces/author';
 import type { EpochAuthorship } from '@polkadot/types/interfaces/babe';
+import type { BeefySignedCommitment } from '@polkadot/types/interfaces/beefy';
 import type { BlockHash } from '@polkadot/types/interfaces/chain';
 import type { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate';
 import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
-import type { ContractCallRequest, ContractExecResult } from '@polkadot/types/interfaces/contracts';
+import type { ContractCallRequest, ContractExecResult, ContractInstantiateResult, InstantiateRequest } from '@polkadot/types/interfaces/contracts';
 import type { CreatedBlock } from '@polkadot/types/interfaces/engine';
 import type { EthAccount, EthCallRequest, EthFilter, EthFilterChanges, EthLog, EthReceipt, EthRichBlock, EthSubKind, EthSubParams, EthSyncStatus, EthTransaction, EthTransactionRequest, EthWork } from '@polkadot/types/interfaces/eth';
 import type { Extrinsic } from '@polkadot/types/interfaces/extrinsics';
@@ -19,7 +20,7 @@ import type { StorageKind } from '@polkadot/types/interfaces/offchain';
 import type { FeeDetails, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
 import type { RpcMethods } from '@polkadot/types/interfaces/rpc';
 import type { AccountId, BlockNumber, H160, H256, H64, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime';
-import type { ReadProof, RuntimeVersion } from '@polkadot/types/interfaces/state';
+import type { ReadProof, RuntimeVersion, TraceBlockResponse } from '@polkadot/types/interfaces/state';
 import type { ApplyExtrinsicResult, ChainProperties, ChainType, Health, NetworkState, NodeRole, PeerInfo, SyncState } from '@polkadot/types/interfaces/system';

 declare module '@polkadot/rpc-core/types.jsonrpc' {
@@ -64,6 +65,12 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
       **/
      epochAuthorship: AugmentedRpc<() => Observable<HashMap<AuthorityId, EpochAuthorship>>>;
    };
+    beefy: {
+      /**
+       * Returns the block most recently finalized by BEEFY, alongside side its justification.
+       **/
+      subscribeJustifications: AugmentedRpc<() => Observable<BeefySignedCommitment>>;
+    };
    chain: {
      /**
       * Get header and body of a relay chain block
@@ -99,6 +106,10 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
       * Returns the keys with prefix from a child storage, leave empty to get all the keys
       **/
      getKeys: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, prefix: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
+      /**
+       * Returns the keys with prefix from a child storage with pagination support
+       **/
+      getKeysPaged: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, prefix: StorageKey | string | Uint8Array | any, count: u32 | AnyNumber | Uint8Array, startKey?: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
      /**
       * Returns a child storage entry at a specific block state
       **/
@@ -121,6 +132,10 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
       * Returns the value under a specified storage key in a contract
       **/
      getStorage: AugmentedRpc<(address: AccountId | string | Uint8Array, key: H256 | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Option<Bytes>>>;
+      /**
+       * Instantiate a new contract
+       **/
+      instantiate: AugmentedRpc<(request: InstantiateRequest | { origin?: any; endowment?: any; gasLimit?: any; code?: any; data?: any; salt?: any } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ContractInstantiateResult>>;
      /**
       * Returns the projected time a given contract will be able to sustain paying its rent
       **/
@@ -142,7 +157,7 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
       **/
      accounts: AugmentedRpc<() => Observable<Vec<H160>>>;
      /**
-       * Returns balance of the given account.
+       * Returns the blockNumber
       **/
      blockNumber: AugmentedRpc<() => Observable<U256>>;
      /**
@@ -371,6 +386,10 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
       * Retrieves the keys with prefix of a specific child storage
       **/
      getChildKeys: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
+      /**
+       * Returns proof of storage for child key entries at a specific block state.
+       **/
+      getChildReadProof: AugmentedRpc<(childStorageKey: PrefixedStorageKey | string | Uint8Array, keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: BlockHash | string | Uint8Array) => Observable<ReadProof>>;
      /**
       * Retrieves the child storage for a key
       **/
@@ -435,6 +454,10 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
       * Subscribes to storage changes for the provided keys
       **/
      subscribeStorage: AugmentedRpc<<T = Codec[]>(keys?: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[]) => Observable<T>>;
+      /**
+       * Provides a way to trace the re-execution of a single block
+       **/
+      traceBlock: AugmentedRpc<(block: Hash | string | Uint8Array, targets: Option<Text> | null | object | string | Uint8Array, storageKeys: Option<Text> | null | object | string | Uint8Array) => Observable<TraceBlockResponse>>;
    };
    syncstate: {
      /**
@@ -503,6 +526,10 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
       * Remove a reserved peer
       **/
      removeReservedPeer: AugmentedRpc<(peerId: Text | string) => Observable<Text>>;
+      /**
+       * Returns the list of reserved peers
+       **/
+      reservedPeers: AugmentedRpc<() => Observable<Vec<Text>>>;
      /**
       * Resets the log filter to Substrate defaults
       **/
@@ -10,8 +10,6 @@ import type { AnyFunction, AnyTuple, CallFunction, Codec, CodecArg as Arg, Defin
 import type { SubmittableExtrinsic } from '../submittable/types';
 import type { ApiInterfaceRx, ApiOptions, ApiTypes, DecoratedErrors, DecoratedEvents, DecoratedRpc, DecoratedRpcSection, DecorateMethod, PaginationOptions, QueryableConsts, QueryableModuleStorage, QueryableStorage, QueryableStorageEntry, QueryableStorageMulti, QueryableStorageMultiArg, SubmittableExtrinsicFunction, SubmittableExtrinsics, SubmittableModuleExtrinsics } from '../types';

-import BN from 'bn.js';
-
 import { decorateDerive, ExactDerive } from '@polkadot/api-derive';
 import { memo } from '@polkadot/api-derive/util';
 import { expandMetadata, Metadata } from '@polkadot/metadata';
@@ -20,7 +18,7 @@ import { WsProvider } from '@polkadot/rpc-provider';
 import { TypeRegistry } from '@polkadot/types/create';
 import { DEFAULT_VERSION as EXTRINSIC_DEFAULT_VERSION } from '@polkadot/types/extrinsic/constants';
 import { unwrapStorageType } from '@polkadot/types/primitive/StorageKey';
-import { arrayChunk, arrayFlatten, assert, compactStripLength, logger, u8aToHex } from '@polkadot/util';
+import { arrayChunk, arrayFlatten, assert, BN, compactStripLength, logger, u8aToHex } from '@polkadot/util';
 import { BehaviorSubject, combineLatest, Observable, of } from '@polkadot/x-rxjs';
 import { map, switchMap, tap, toArray } from '@polkadot/x-rxjs/operators';

@@ -39,7 +37,8 @@ interface MetaDecoration {
 }

 // the max amount of keys/values that we will retrieve at once
-const PAGE_SIZE = 384;
+const PAGE_SIZE_K = 1000; // limit aligned with the 1k on the node (trie lookups are heavy)
+const PAGE_SIZE_V = 250; // limited since the data may be very large (e.g. misfiring elections)

 const l = logger('api/init');

@@ -262,7 +261,8 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {

      return allKeys;
    }, []);
-    const unknown = exposed.filter((key) => !allKeys.includes(key));
+    const unknown = exposed.filter((k) => !allKeys.includes(k));
+    const deletion = allKnown.filter(([k]) => hasResults && !exposed.includes(k) && k !== 'rpc_methods');

    if (unknown.length) {
      l.warn(`RPC methods not decorated: ${unknown.join(', ')}`);
@@ -270,17 +270,10 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {

    // loop through all entries we have (populated in decorate) and filter as required
    // only remove when we have results and method missing, or with no results if optional
-    allKnown
-      .filter(([key]): boolean => hasResults
-        ? !exposed.includes(key) && key !== 'rpc_methods' // rpc_methods doesn't appear, v1
-        : key === 'rpc_methods' // we didn't find this one, remove
-      )
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      .forEach(([_, { method, section }]): void => {
-        delete (this._rpc as Record<string, Record<string, unknown>>)[section][method];
-        delete (this._rpcCore as unknown as Record<string, Record<string, unknown>>)[section][method];
-        delete (this._rx.rpc as Record<string, Record<string, unknown>>)[section][method];
-      });
+    deletion.forEach(([, { method, section }]): void => {
+      delete (this._rpc as Record<string, Record<string, unknown>>)[section][method];
+      delete (this._rx.rpc as Record<string, Record<string, unknown>>)[section][method];
+    });
  }

  protected _decorateRpc<ApiType extends ApiTypes> (rpc: RpcCore & RpcInterface, decorateMethod: DecorateMethod<ApiType>, input: Partial<DecoratedRpc<ApiType, RpcInterface>> = {}): DecoratedRpc<ApiType, RpcInterface> {
@@ -297,6 +290,8 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
            (section as Record<string, { json: unknown }>)[methodName].json = decorateMethod(method.json, { methodName }) as unknown;
            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
            (section as Record<string, { raw: unknown }>)[methodName].raw = decorateMethod(method.raw, { methodName }) as unknown;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            (section as Record<string, { meta: unknown }>)[methodName].meta = method.meta;
          }

          return section;
@@ -360,7 +355,7 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {

  private _decorateStorageEntry<ApiType extends ApiTypes> (creator: StorageEntry, decorateMethod: DecorateMethod<ApiType>): QueryableStorageEntry<ApiType> {
    // get the storage arguments, with DoubleMap as an array entry, otherwise spread
-    const getArgs = (...args: unknown[]): unknown[] => extractStorageArgs(creator, args);
+    const getArgs = (args: unknown[]): unknown[] => extractStorageArgs(creator, args);

    // Disable this where it occurs for each field we are decorating
    /* eslint-disable @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment */
@@ -369,51 +364,60 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {

    decorated.creator = creator;

-    decorated.at = decorateMethod((hash: Hash, arg1?: Arg, arg2?: Arg): Observable<Codec> =>
-      this._rpcCore.state.getStorage(getArgs(arg1, arg2), hash));
+    decorated.at = decorateMethod((hash: Hash, ...args: Arg[]): Observable<Codec> =>
+      this._rpcCore.state.getStorage(getArgs(args), hash));

-    decorated.hash = decorateMethod((arg1?: Arg, arg2?: Arg): Observable<Hash> =>
-      this._rpcCore.state.getStorageHash(getArgs(arg1, arg2)));
+    decorated.hash = decorateMethod((...args: Arg[]): Observable<Hash> =>
+      this._rpcCore.state.getStorageHash(getArgs(args)));

    decorated.is = <A extends AnyTuple> (key: IStorageKey<AnyTuple>): key is IStorageKey<A> =>
      key.section === creator.section && key.method === creator.method;

-    decorated.key = (arg1?: Arg, arg2?: Arg): string =>
-      u8aToHex(compactStripLength(creator(creator.meta.type.isDoubleMap ? [arg1, arg2] : arg1))[1]);
+    decorated.key = (...args: Arg[]): string =>
+      u8aToHex(compactStripLength(creator(
+        creator.meta.type.isPlain
+          ? undefined
+          : creator.meta.type.isMap
+            ? args[0]
+            : creator.meta.type.isDoubleMap
+              ? [args[0], args[1]]
+              : args
+      ))[1]);

-    decorated.keyPrefix = (key1?: Arg): string =>
-      u8aToHex(creator.keyPrefix(key1));
+    decorated.keyPrefix = (...keys: Arg[]): string =>
+      u8aToHex(creator.keyPrefix(...keys));

-    decorated.range = decorateMethod((range: [Hash, Hash?], arg1?: Arg, arg2?: Arg): Observable<[Hash, Codec][]> =>
-      this._decorateStorageRange(decorated, [arg1, arg2], range));
+    decorated.range = decorateMethod((range: [Hash, Hash?], ...args: Arg[]): Observable<[Hash, Codec][]> =>
+      this._decorateStorageRange(decorated, args, range));

-    decorated.size = decorateMethod((arg1?: Arg, arg2?: Arg): Observable<u64> =>
-      this._rpcCore.state.getStorageSize(getArgs(arg1, arg2)));
+    decorated.size = decorateMethod((...args: Arg[]): Observable<u64> =>
+      this._rpcCore.state.getStorageSize(getArgs(args)));

-    decorated.sizeAt = decorateMethod((hash: Hash | Uint8Array | string, arg1?: Arg, arg2?: Arg): Observable<u64> =>
-      this._rpcCore.state.getStorageSize(getArgs(arg1, arg2), hash));
+    decorated.sizeAt = decorateMethod((hash: Hash | Uint8Array | string, ...args: Arg[]): Observable<u64> =>
+      this._rpcCore.state.getStorageSize(getArgs(args), hash));

+    // FIXME NMap support
    // .keys() & .entries() only available on map types
    if (creator.iterKey && (creator.meta.type.isMap || creator.meta.type.isDoubleMap)) {
      decorated.entries = decorateMethod(
-        memo(this.#instanceId, (doubleMapArg?: Arg): Observable<[StorageKey, Codec][]> =>
-          this._retrieveMapEntries(creator, null, doubleMapArg)));
+        memo(this.#instanceId, (...args: Arg[]): Observable<[StorageKey, Codec][]> =>
+          this._retrieveMapEntries(creator, null, args)));

      decorated.entriesAt = decorateMethod(
-        memo(this.#instanceId, (hash: Hash | Uint8Array | string, doubleMapArg?: Arg): Observable<[StorageKey, Codec][]> =>
-          this._retrieveMapEntries(creator, hash, doubleMapArg)));
+        memo(this.#instanceId, (hash: Hash | Uint8Array | string, ...args: Arg[]): Observable<[StorageKey, Codec][]> =>
+          this._retrieveMapEntries(creator, hash, args)));

      decorated.entriesPaged = decorateMethod(
        memo(this.#instanceId, (opts: PaginationOptions): Observable<[StorageKey, Codec][]> =>
          this._retrieveMapEntriesPaged(creator, opts)));

      decorated.keys = decorateMethod(
-        memo(this.#instanceId, (doubleMapArg?: Arg): Observable<StorageKey[]> =>
-          this._retrieveMapKeys(creator, null, doubleMapArg)));
+        memo(this.#instanceId, (...args: Arg[]): Observable<StorageKey[]> =>
+          this._retrieveMapKeys(creator, null, args)));

      decorated.keysAt = decorateMethod(
-        memo(this.#instanceId, (hash: Hash | Uint8Array | string, doubleMapArg?: Arg): Observable<StorageKey[]> =>
-          this._retrieveMapKeys(creator, hash, doubleMapArg)));
+        memo(this.#instanceId, (hash: Hash | Uint8Array | string, ...args: Arg[]): Observable<StorageKey[]> =>
+          this._retrieveMapKeys(creator, hash, args)));

      decorated.keysPaged = decorateMethod(
        memo(this.#instanceId, (opts: PaginationOptions): Observable<StorageKey[]> =>
@@ -447,7 +451,7 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
    });
  }

-  private _decorateStorageRange<ApiType extends ApiTypes> (decorated: QueryableStorageEntry<ApiType>, args: [Arg?, Arg?], range: [Hash, Hash?]): Observable<[Hash, Codec][]> {
+  private _decorateStorageRange<ApiType extends ApiTypes> (decorated: QueryableStorageEntry<ApiType>, args: Arg[], range: [Hash, Hash?]): Observable<[Hash, Codec][]> {
    const outputType = unwrapStorageType(decorated.creator.meta.type, decorated.creator.meta.modifier.isOptional);

    return this._rpcCore.state
@@ -466,64 +470,60 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
      return of([]);
    }

+    const queryCall = this.hasSubscriptions
+      ? this._rpcCore.state.subscribeStorage
+      : this._rpcCore.state.queryStorageAt;
+
    return combineLatest(
-      arrayChunk(keys, PAGE_SIZE).map((keys) =>
-        (this.hasSubscriptions
-          ? this._rpcCore.state.subscribeStorage
-          : this._rpcCore.state.queryStorageAt
-        )(keys)
-      )
+      arrayChunk(keys, PAGE_SIZE_V).map((keys) => queryCall(keys))
    ).pipe(
-      map((valsArr): Codec[] => arrayFlatten(valsArr))
+      map(arrayFlatten)
    );
  }

-  private _retrieveMapKeys ({ iterKey, meta, method, section }: StorageEntry, at: Hash | Uint8Array | string | null, arg?: Arg): Observable<StorageKey[]> {
-    assert(iterKey && (meta.type.isMap || meta.type.isDoubleMap), 'keys can only be retrieved on maps, linked maps and double maps');
+  private _retrieveMapKeys ({ iterKey, meta, method, section }: StorageEntry, at: Hash | Uint8Array | string | null, args: Arg[]): Observable<StorageKey[]> {
+    assert(iterKey && (meta.type.isMap || meta.type.isDoubleMap || meta.type.isNMap), 'keys can only be retrieved on maps, linked maps and double maps');

-    const headKey = iterKey(arg).toHex();
+    const headKey = iterKey(...args).toHex();
    const startSubject = new BehaviorSubject<string>(headKey);
-    const query = at
-      ? (startKey: string) => this._rpcCore.state.getKeysPaged(headKey, PAGE_SIZE, startKey, at)
-      : (startKey: string) => this._rpcCore.state.getKeysPaged(headKey, PAGE_SIZE, startKey);
+    const queryCall = at
+      ? (startKey: string) => this._rpcCore.state.getKeysPaged(headKey, PAGE_SIZE_K, startKey, at)
+      : (startKey: string) => this._rpcCore.state.getKeysPaged(headKey, PAGE_SIZE_K, startKey);

    return startSubject.pipe(
-      switchMap((startKey) =>
-        query(startKey).pipe(
-          map((keys) => keys.map((key) => key.setMeta(meta, section, method)))
-        )
-      ),
+      switchMap(queryCall),
+      map((keys) => keys.map((key) => key.setMeta(meta, section, method))),
      tap((keys): void => {
        setTimeout((): void => {
-          keys.length === PAGE_SIZE
-            ? startSubject.next(keys[PAGE_SIZE - 1].toHex())
+          keys.length === PAGE_SIZE_K
+            ? startSubject.next(keys[PAGE_SIZE_K - 1].toHex())
            : startSubject.complete();
        }, 0);
      }),
      toArray(), // toArray since we want to startSubject to be completed
-      map((keysArr: StorageKey[][]) => arrayFlatten(keysArr))
+      map(arrayFlatten)
    );
  }

  private _retrieveMapKeysPaged ({ iterKey, meta, method, section }: StorageEntry, opts: PaginationOptions): Observable<StorageKey[]> {
-    assert(iterKey && (meta.type.isMap || meta.type.isDoubleMap), 'keys can only be retrieved on maps, linked maps and double maps');
+    assert(iterKey && (meta.type.isMap || meta.type.isDoubleMap || meta.type.isNMap), 'keys can only be retrieved on maps, linked maps and double maps');

-    const headKey = iterKey(opts.arg).toHex();
+    const headKey = iterKey(...opts.args).toHex();

    return this._rpcCore.state.getKeysPaged(headKey, opts.pageSize, opts.startKey || headKey).pipe(
      map((keys) => keys.map((key) => key.setMeta(meta, section, method)))
    );
  }

-  private _retrieveMapEntries (entry: StorageEntry, at: Hash | Uint8Array | string | null, arg?: Arg): Observable<[StorageKey, Codec][]> {
+  private _retrieveMapEntries (entry: StorageEntry, at: Hash | Uint8Array | string | null, args: Arg[]): Observable<[StorageKey, Codec][]> {
    const query = at
      ? (keyset: StorageKey[]) => this._rpcCore.state.queryStorageAt(keyset, at)
      : (keyset: StorageKey[]) => this._rpcCore.state.queryStorageAt(keyset);

-    return this._retrieveMapKeys(entry, at, arg).pipe(
+    return this._retrieveMapKeys(entry, at, args).pipe(
      switchMap((keys) =>
        keys.length
-          ? combineLatest(arrayChunk(keys, PAGE_SIZE).map(query)).pipe(
+          ? combineLatest(arrayChunk(keys, PAGE_SIZE_V).map(query)).pipe(
            map((valsArr) =>
              arrayFlatten(valsArr).map((value, index): [StorageKey, Codec] => [keys[index], value])
            )
@@ -82,13 +82,6 @@ export abstract class Getters<ApiType extends ApiTypes> extends Init<ApiType> {
    return assertResult(this._genesisHash);
  }

-  /**
-   * @description `true` when subscriptions are supported
-   */
-  public get hasSubscriptions (): boolean {
-    return this._rpcCore.provider.hasSubscriptions;
-  }
-
  /**
   * @description true is the underlying provider is connected
   */
@@ -1,19 +1,19 @@
 // Copyright 2017-2021 @polkadot/api authors & contributors
 // SPDX-License-Identifier: Apache-2.0

+import type { RpcInterfaceMethod } from '@polkadot/rpc-core/types';
 import type { Text } from '@polkadot/types';
 import type { ChainProperties, Hash, RuntimeVersion } from '@polkadot/types/interfaces';
 import type { Registry } from '@polkadot/types/types';
+import type { BN } from '@polkadot/util';
 import type { Observable, Subscription } from '@polkadot/x-rxjs';
 import type { ApiBase, ApiOptions, ApiTypes, DecorateMethod } from '../types';
 import type { VersionedRegistry } from './types';

-import BN from 'bn.js';
-
 import { Metadata } from '@polkadot/metadata';
 import { TypeRegistry } from '@polkadot/types/create';
 import { getSpecAlias, getSpecExtensions, getSpecHasher, getSpecRpc, getSpecTypes, getUpgradeVersion } from '@polkadot/types-known';
-import { assert, BN_ZERO, logger, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { assert, BN_ZERO, logger, stringify, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { cryptoWaitReady } from '@polkadot/util-crypto';
 import { of } from '@polkadot/x-rxjs';
 import { map, switchMap } from '@polkadot/x-rxjs/operators';
@@ -22,7 +22,6 @@ import { detectedCapabilities } from './capabilities';
 import { Decorate } from './Decorate';

 const KEEPALIVE_INTERVAL = 10000;
-const DEFAULT_BLOCKNUMBER = { unwrap: () => BN_ZERO };

 const l = logger('api/init');

@@ -31,7 +30,7 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {

  #registries: VersionedRegistry[] = [];

-  #updateSub?: Subscription;
+  #updateSub?: Subscription | null = null;

  constructor (options: ApiOptions, type: ApiTypes, decorateMethod: DecorateMethod<ApiType>) {
    super(options, type, decorateMethod);
@@ -58,7 +57,7 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {

    this._rx.signer = options.signer;

-    this._rpcCore.setRegistrySwap((hash: string | Uint8Array) => this.getBlockRegistry(hash));
+    this._rpcCore.setRegistrySwap((blockHash: Uint8Array) => this.getBlockRegistry(blockHash));

    if (this.hasSubscriptions) {
      this._rpcCore.provider.on('disconnected', this.#onProviderDisconnect);
@@ -102,10 +101,10 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
  /**
   * @description Sets up a registry based on the block hash defined
   */
-  public async getBlockRegistry (blockHash: string | Uint8Array): Promise<VersionedRegistry> {
-    // shortcut in the case where we have an immediate-same request
-    const lastBlockHash = u8aToU8a(blockHash);
-    const existingViaHash = this.#registries.find((r) => r.lastBlockHash && u8aEq(lastBlockHash, r.lastBlockHash));
+  public async getBlockRegistry (blockHash: Uint8Array): Promise<VersionedRegistry> {
+    const existingViaHash = this.#registries.find(({ lastBlockHash }) =>
+      lastBlockHash && u8aEq(lastBlockHash, blockHash)
+    );

    if (existingViaHash) {
      return existingViaHash;
@@ -116,39 +115,45 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {

    // We have to assume that on the RPC layer the calls used here does not call back into
    // the registry swap, so getHeader & getRuntimeVersion should not be historic
-    const header = this._genesisHash.eq(blockHash)
-      ? { number: DEFAULT_BLOCKNUMBER, parentHash: this._genesisHash }
-      : await this._rpcCore.chain.getHeader(blockHash).toPromise();
+    const header = this.registry.createType('HeaderPartial',
+      this._genesisHash.eq(blockHash)
+        ? { number: BN_ZERO, parentHash: this._genesisHash }
+        : await (this._rpcCore.chain.getHeader as RpcInterfaceMethod).json(blockHash).toPromise()
+    );

-    assert(header?.parentHash && !header.parentHash.isEmpty, 'Unable to retrieve header and parent from supplied hash');
+    assert(!header.parentHash.isEmpty, 'Unable to retrieve header and parent from supplied hash');

    // get the runtime version, either on-chain or via an known upgrade history
-    const [firstVersion, lastVersion] = getUpgradeVersion(this._genesisHash, header.number.unwrap());
-    const version = (firstVersion && (lastVersion || firstVersion.specVersion.eq(this._runtimeVersion.specVersion)))
-      ? { specName: this._runtimeVersion.specName, specVersion: firstVersion.specVersion }
-      : await this._rpcCore.state.getRuntimeVersion(header.parentHash).toPromise();
+    const [firstVersion, lastVersion] = getUpgradeVersion(this._genesisHash, header.number);
+    const version = this.registry.createType('RuntimeVersionPartial',
+      (firstVersion && (lastVersion || firstVersion.specVersion.eq(this._runtimeVersion.specVersion)))
+        ? { specName: this._runtimeVersion.specName, specVersion: firstVersion.specVersion }
+        : await (this._rpcCore.state.getRuntimeVersion as RpcInterfaceMethod).json(header.parentHash).toPromise()
+    );

    // check for pre-existing registries
-    const existingViaVersion = this.#registries.find((r) => r.specVersion.eq(version.specVersion));
+    const existingViaVersion = this.#registries.find(({ specVersion }) => specVersion.eq(version.specVersion));

    if (existingViaVersion) {
-      existingViaVersion.lastBlockHash = lastBlockHash;
+      existingViaVersion.lastBlockHash = blockHash;

      return existingViaVersion;
    }

    // nothing has been found, construct new
-    const metadata = await this._rpcCore.state.getMetadata(header.parentHash).toPromise();
+    const metadata = new Metadata(this.registry,
+      await (this._rpcCore.state.getMetadata as RpcInterfaceMethod).raw(header.parentHash).toPromise()
+    );
    const registry = this._initRegistry(new TypeRegistry(blockHash), this._runtimeChain as Text, version, metadata);

-    // For now, since this is new we ignore the capability lookups (this could be useful once proven)
-    // this._detectCapabilities(registry, blockHash);
-
    // add our new registry
-    const result = { isDefault: false, lastBlockHash, metadata, metadataConsts: null, registry, specVersion: version.specVersion };
+    const result = { isDefault: false, lastBlockHash: blockHash, metadata, metadataConsts: null, registry, specVersion: version.specVersion };

    this.#registries.push(result);

+    // TODO This could be useful for historic, disabled due to cross-looping, i.e. .at queries
+    // this._detectCapabilities(registry, blockHash);
+
    return result;
  }

@@ -156,10 +161,10 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
    // on re-connection to the same chain, we don't want to re-do everything from chain again
    if (this._isReady) {
      return true;
-    } else if (this.#updateSub) {
-      this.#updateSub.unsubscribe();
    }

+    this._unsubscribeUpdates();
+
    // only load from on-chain if we are not a clone (default path), alternatively
    // just use the values from the source instance provided
    [this._genesisHash, this._runtimeMetadata] = this._options.source?._isReady
@@ -190,17 +195,19 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
    return [source.genesisHash, source.runtimeMetadata];
  }

-  private _detectCapabilities (registry?: Registry, blockHash?: string | Uint8Array): void {
+  private _detectCapabilities (registry: Registry, blockHash?: string | Uint8Array): boolean {
    detectedCapabilities(this._rx, blockHash)
      .toPromise()
      .then((types): void => {
        if (Object.keys(types).length) {
-          (registry || this.registry).register(types as Record<string, string>);
+          registry.register(types as Record<string, string>);

-          l.debug(`Capabilities detected${blockHash ? ` (${u8aToHex(u8aToU8a(blockHash))})` : ''}: ${JSON.stringify(types)}`);
+          l.debug(() => `Capabilities detected${blockHash ? ` (${u8aToHex(u8aToU8a(blockHash))})` : ''}: ${stringify(types)}`);
        }
      })
-      .catch(l.error);
+      .catch(undefined);
+
+    return true;
  }

  // subscribe to metadata updates, inject the types on changes
@@ -235,9 +242,8 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
              // clear the registry types to ensure that we override correctly
              this._initRegistry(thisRegistry.registry.init(), this._runtimeChain as Text, version, metadata);
              this.injectMetadata(metadata, false, thisRegistry.registry);
-              this._detectCapabilities(thisRegistry.registry);

-              return true;
+              return this._detectCapabilities(thisRegistry.registry);
            })
          )
      )
@@ -280,7 +286,7 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
    }

    // get unique types & validate
-    metadata.getUniqTypes(false);
+    metadata.getUniqTypes(this._options.throwOnUnknown || false);

    return [genesisHash, metadata];
  }
@@ -293,15 +299,36 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {

    // inject metadata and adjust the types as detected
    this.injectMetadata(metadata, true);
-    this._detectCapabilities();

    // derive is last, since it uses the decorated rx
    this._rx.derive = this._decorateDeriveRx(this._rxDecorateMethod);
    this._derive = this._decorateDerive(this._decorateMethod);

+    // detect the on-chain capabilities
+    this._detectCapabilities(this.registry);
+
    return true;
  }

+  private _unsubscribeHealth (): void {
+    if (this.#healthTimer) {
+      clearInterval(this.#healthTimer);
+      this.#healthTimer = null;
+    }
+  }
+
+  private _unsubscribeUpdates (): void {
+    if (this.#updateSub) {
+      this.#updateSub.unsubscribe();
+      this.#updateSub = null;
+    }
+  }
+
+  protected _unsubscribe (): void {
+    this._unsubscribeHealth();
+    this._unsubscribeUpdates();
+  }
+
  #onProviderConnect = async (): Promise<void> => {
    this.emit('connected');
    this._isConnected.next(true);
@@ -321,13 +348,12 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
      }

      this.#healthTimer = setInterval((): void => {
-        this._rpcCore.system.health().toPromise().catch((error) => l.warn(`Health keepalive check failed: ${(error as Error).message}`));
+        this._rpcCore.system.health().toPromise().catch(() => undefined);
      }, KEEPALIVE_INTERVAL);
    } catch (_error) {
      const error = new Error(`FATAL: Unable to initialize the API: ${(_error as Error).message}`);

      l.error(error);
-      l.error(_error);

      this.emit('error', error);
    }
@@ -337,10 +363,7 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
    this.emit('disconnected');
    this._isConnected.next(false);

-    if (this.#healthTimer) {
-      clearInterval(this.#healthTimer);
-      this.#healthTimer = null;
-    }
+    this._unsubscribeHealth();
  };

  #onProviderError = (error: Error): void => {
@@ -2,18 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0

 import type { ApiInterfaceRx } from '@polkadot/api/types';
-import type { bool, Raw, u32 } from '@polkadot/types';
+import type { Raw, u32 } from '@polkadot/types';
 import type { Releases } from '@polkadot/types/interfaces';
 import type { InterfaceTypes } from '@polkadot/types/types';

 import { assert, compactFromU8a } from '@polkadot/util';
 import { combineLatest, Observable, of } from '@polkadot/x-rxjs';
-import { map, take } from '@polkadot/x-rxjs/operators';
+import { catchError, map, take } from '@polkadot/x-rxjs/operators';

 // the order and types needs to map with the all array setup below
-type ExtractedQ = [bool | null, bool | null, bool | null, Releases | null];
+type ExtractedQ = [Releases | null];

-type ExtractedR = [Raw | null];
+type ExtractedR = [Raw | null, Raw | null];

 type ExtractedC = [u32 | null, u32 | null];

@@ -38,23 +38,26 @@ interface AvailableMap<T> {

 interface Constants {
  accountIdLength: number;
+  refcount1Length: number;
+  refcount2Length: number;
+  refcount3Length: number;
 }

 const NumberMap = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten'];

-function mapCapabilities ({ accountIdLength }: Constants, [leasePeriodsPerSlot, slotRangeCount]: ExtractedC, [systemRefcount32, systemRefcountDual, systemRefcountTriple, stakingVersion]: ExtractedQ, [keys]: ExtractedR): Partial<DetectedTypes> {
+function mapCapabilities ({ accountIdLength, refcount1Length, refcount2Length, refcount3Length }: Constants, [leasePeriodsPerSlot, slotRangeCount]: ExtractedC, [stakingVersion]: ExtractedQ, [keys, accountInfo]: ExtractedR): Partial<DetectedTypes> {
  const types: Partial<DetectedTypes> = {};

  // AccountInfo
-  if (systemRefcountTriple && systemRefcountTriple.isTrue) {
-    types.AccountInfo = 'AccountInfoWithTripleRefCount';
-  } else if (systemRefcountDual && systemRefcountDual.isTrue) {
-    types.AccountInfo = 'AccountInfoWithDualRefCount';
-  } else {
-    types.AccountInfo = 'AccountInfoWithRefCount';
+  if (accountInfo) {
+    const length = accountInfo.length;

-    if (!systemRefcount32 || systemRefcount32.isFalse) {
-      types.RefCount = 'u8';
+    if (length === refcount1Length) {
+      types.AccountInfo = 'AccountInfoWithRefCount';
+    } else if (length === refcount2Length) {
+      types.AccountInfo = 'AccountInfoWithDualRefCount';
+    } else if (length === refcount3Length) {
+      types.AccountInfo = 'AccountInfoWithTripleRefCount';
    }
  }

@@ -75,7 +78,7 @@ function mapCapabilities ({ accountIdLength }: Constants, [leasePeriodsPerSlot,
      const numIds = tupleLength / accountIdLength;
      const numIdsRound = Math.floor(numIds);

-      assert(numIds >= 2 && numIds <= 11, `Detected ${numIds} in Keys, should be >= 2 and <= 11`);
+      assert(numIds >= 2 && numIds <= 11, () => `Detected ${numIds} in Keys, should be >= 2 and <= 11`);

      if (numIdsRound !== numIds) {
        // Beefy?
@@ -84,15 +87,15 @@ function mapCapabilities ({ accountIdLength }: Constants, [leasePeriodsPerSlot,
          // @ts-ignore
          types.Keys = `SessionKeys${numIdsRound - 1}B`;
        } else {
-          assert(false, `Expected integer number of keys, found ${numIds.toFixed(2)}`);
+          assert(false, () => `Expected integer number of keys, found ${numIds.toFixed(2)}`);
        }
      } else {
        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
        // @ts-ignore
        types.Keys = `SessionKeys${numIds - 1}`;
      }
-    } catch (error) {
-      console.error(error);
+    } catch {
+      // ignore
    }
  }

@@ -115,9 +118,12 @@ function mapCapabilities ({ accountIdLength }: Constants, [leasePeriodsPerSlot,

 function filterEntries <T> (original: T[]): AvailableMap<T> {
  const included = original.map((c) => !!c);
-  const filtered = original.filter((_, index) => included[index]);

-  return { filtered, included, original };
+  return {
+    filtered: original.filter((_, index) => included[index]),
+    included,
+    original
+  };
 }

 function extractResults <R, T = unknown> (results: unknown[], map: AvailableMap<T>): R {
@@ -134,18 +140,17 @@ function extractResults <R, T = unknown> (results: unknown[], map: AvailableMap<
 * @description Query the chain for the specific capabilities
 */
 export function detectedCapabilities (api: ApiInterfaceRx, blockHash?: Uint8Array | string | undefined): Observable<Partial<DetectedTypes>> {
+  const emptyAccountId = api.registry.createType('AccountId');
  const consts = filterEntries([
    api.consts.auctions?.leasePeriodsPerSlot,
    api.consts.auctions?.slotRangeCount
  ]);
  const queries = filterEntries([
-    api.query.system?.upgradedToU32RefCount,
-    api.query.system?.upgradedToDualRefCount,
-    api.query.system?.upgradedToTripleRefCount,
    api.query.staking?.storageVersion
  ]);
  const raws = filterEntries([
-    api.query.session?.queuedKeys
+    api.query.session?.queuedKeys.key(),
+    api.query.system?.account?.key(emptyAccountId)
  ]);

  return combineLatest([
@@ -162,20 +167,24 @@ export function detectedCapabilities (api: ApiInterfaceRx, blockHash?: Uint8Arra
      : of([]),
    raws.filtered.length
      ? blockHash
-        ? combineLatest(raws.filtered.map((k) => api.rpc.state.getStorage.raw(k.key(), blockHash)))
-        : combineLatest(raws.filtered.map((k) => api.rpc.state.getStorage.raw(k.key())))
+        ? combineLatest(raws.filtered.map((k) => api.rpc.state.getStorage.raw(k, blockHash)))
+        : combineLatest(raws.filtered.map((k) => api.rpc.state.getStorage.raw(k)))
      : of([])
  ]).pipe(
    map(([cResults, qResults, rResults]): Partial<DetectedTypes> =>
      mapCapabilities(
        {
-          accountIdLength: api.registry.createType('AccountId').encodedLength
+          accountIdLength: emptyAccountId.encodedLength,
+          refcount1Length: api.registry.createType('AccountInfoWithRefCount').encodedLength,
+          refcount2Length: api.registry.createType('AccountInfoWithDualRefCount').encodedLength,
+          refcount3Length: api.registry.createType('AccountInfoWithTripleRefCount').encodedLength
        },
        extractResults<ExtractedC>(cResults, consts),
        extractResults<ExtractedQ>(qResults, queries),
        extractResults<ExtractedR>(rResults, raws)
      )
    ),
-    take(1)
+    take(1),
+    catchError(() => of({}))
  );
 }
@@ -50,6 +50,8 @@ export abstract class ApiBase<ApiType extends ApiTypes> extends Getters<ApiType>
   * @description Disconnect from the underlying provider, halting all network traffic
   */
  public disconnect (): Promise<void> {
+    this._unsubscribe();
+
    return this._rpcCore.disconnect();
  }

@@ -1,10 +1,10 @@
 // Copyright 2017-2021 @polkadot/api authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import type BN from 'bn.js';
 import type { Metadata } from '@polkadot/metadata';
 import type { Constants } from '@polkadot/metadata/decorate/types';
 import type { Registry } from '@polkadot/types/types';
+import type { BN } from '@polkadot/util';

 export interface VersionedRegistry {
  isDefault: boolean;
@@ -129,6 +129,12 @@ async function queryExtra (api: ApiPromise, pairs: TestKeyringMap): Promise<void
  await api.query.system.account.entries(); // should not take a param
  await api.query.staking.nominatorSlashInEra.entries(123); // should take a param

+  // nmap with keys
+  await api.query.assets.approvals.keys(123, 'blah');
+  await api.query.assets.account.keys(123);
+  await api.query.assets.account.entries(123);
+  await api.query.assets.blah.keys();
+
  // check range
  await api.query.balances.freeBalance.range<Balance>(['0x1234'], pairs.bob.address);

@@ -3,4 +3,4 @@

 // Auto-generated by @polkadot/dev, do not edit

-export const packageInfo = { name: '@polkadot/api', version: '4.5.1' };
+export const packageInfo = { name: '@polkadot/api', version: '4.16.1' };
@@ -1,7 +1,9 @@
 // Copyright 2017-2021 @polkadot/api authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import type { ApiOptions, SubmittableExtrinsic } from '../types';
+import type { SubmittableExtrinsic } from '../types';
+
+import { jest } from '@jest/globals';

 import { createPair } from '@polkadot/keyring/pair';
 import { createTestKeyring } from '@polkadot/keyring/testing';
@@ -44,23 +46,20 @@ describe('ApiPromise', (): void => {
  }

  beforeEach((): void => {
-    jest.setTimeout(3000000);
+    jest.setTimeout(10000);
    provider = new MockProvider(registry);
  });

+  afterEach(async () => {
+    await provider.disconnect();
+  });
+
  describe('initialization', (): void => {
    it('Create API instance with metadata map and makes the runtime, rpc, state & extrinsics available', async (): Promise<void> => {
-      const rpcData = await provider.send('state_getMetadata', []);
+      const rpcData = await provider.send<string>('state_getMetadata', []);
      const genesisHash = registry.createType('Hash', await provider.send('chain_getBlockHash', [])).toHex();
      const specVersion = 0;
-      const metadata: any = {};
-      const key = `${genesisHash}-${specVersion}`;
-
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-      metadata[key] = rpcData;
-
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      const api = await ApiPromise.create({ metadata, provider, registry } as ApiOptions);
+      const api = await ApiPromise.create({ metadata: { [`${genesisHash}-${specVersion}`]: rpcData }, provider, registry });

      expect(api.genesisHash).toBeDefined();
      expect(api.runtimeMetadata).toBeDefined();
@@ -69,6 +68,8 @@ describe('ApiPromise', (): void => {
      expect(api.query).toBeDefined();
      expect(api.tx).toBeDefined();
      expect(api.derive).toBeDefined();
+
+      await api.disconnect();
    });

    it('Create API instance without metadata and makes the runtime, rpc, state & extrinsics available', async (): Promise<void> => {
@@ -82,6 +83,8 @@ describe('ApiPromise', (): void => {
      expect(api.query).toBeDefined();
      expect(api.tx).toBeDefined();
      expect(api.derive).toBeDefined();
+
+      await api.disconnect();
    });

    it('Create API instance will error on failure to await ready', async (): Promise<void> => {
@@ -90,17 +93,22 @@ describe('ApiPromise', (): void => {
          super({ provider });
        }

-        protected _loadMeta (): Promise<boolean> {
+        protected override _loadMeta (): Promise<boolean> {
          throw new Error('Simulate failure to load meta');
        }
      }

+      const api = new ErrorApiPromise();
+
      try {
-        await new ErrorApiPromise().isReadyOrError;
+        await api.isReadyOrError;
+
        fail('Expected an error but none occurred.');
      } catch {
        // Pass
      }
+
+      await api.disconnect();
    });
  });

@@ -110,31 +118,35 @@ describe('ApiPromise', (): void => {
    const SIG = '0x659effefbbe5ab4d7136ebb5084b959eb424e32b862307371be4721ac2c46334245af4f1476c36c5e5aff04396c2fdd2ce561ec90382821d4aa071b559b1db0f';

    it('signs data using a specified keyring', async (): Promise<void> => {
-      const api = new ApiPromise({ provider, registry });
+      const api = await ApiPromise.create({ provider, registry });
+      const sig = await api.sign(aliceEd, TEST);

-      expect(
-        await api.sign(aliceEd, TEST)
-      ).toEqual(SIG);
+      expect(sig).toEqual(SIG);
+
+      await api.disconnect();
    });

    it('signs data using an external signer', async (): Promise<void> => {
-      const api = new ApiPromise({
+      const api = await ApiPromise.create({
        provider,
        registry,
        signer: new SingleAccountSigner(registry, aliceEd)
      });
+      const sig = await api.sign(ADDR, TEST);

-      expect(
-        await api.sign(ADDR, TEST)
-      ).toEqual(SIG);
+      expect(sig).toEqual(SIG);
+
+      await api.disconnect();
    });
  });

  describe('decorator.signAsync', (): void => {
    it('signs a transfer using an external signer', async (): Promise<void> => {
-      const { transfer } = await createTransfer();
+      const { api, transfer } = await createTransfer();

      expect(transfer.signature.toHex()).toEqual(TRANSFER_SIG);
+
+      await api.disconnect();
    });
  });

@@ -144,6 +156,8 @@ describe('ApiPromise', (): void => {

      expect(api.tx(transfer.toHex()).signature.toHex()).toEqual(TRANSFER_SIG);
      expect(api.tx(transfer).signature.toHex()).toEqual(TRANSFER_SIG);
+
+      await api.disconnect();
    });
  });
 });
@@ -211,7 +211,19 @@ export class ApiPromise extends ApiBase<'promise'> {
   * ```
   */
  public static create (options?: ApiOptions): Promise<ApiPromise> {
-    return new ApiPromise(options).isReady;
+    const instance = new ApiPromise(options);
+
+    if (options && options.throwOnConnect) {
+      return instance.isReadyOrError;
+    }
+
+    // Swallow any rejections on isReadyOrError
+    // (in Node 15.x this creates issues, when not being looked at)
+    instance.isReadyOrError.catch(() => {
+      // ignore
+    });
+
+    return instance.isReady;
  }

  /**
@@ -235,18 +247,14 @@ export class ApiPromise extends ApiBase<'promise'> {
    super(options, 'promise', decorateMethod);

    this.#isReadyPromise = new Promise((resolve): void => {
-      super.once('ready', (): void => {
-        resolve(this);
-      });
+      super.once('ready', () => resolve(this));
    });

    this.#isReadyOrErrorPromise = new Promise((resolve, reject): void => {
-      super.once('ready', (): void => {
-        resolve(this);
-      });
-      super.once('error', (e): void => {
-        reject(e);
-      });
+      const tracker = promiseTracker(resolve, reject);
+
+      super.once('ready', () => tracker.resolve(this));
+      super.once('error', (e) => tracker.reject(e));
    });
  }

@@ -1,60 +0,0 @@
-// Copyright 2017-2021 @polkadot/api authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from '@polkadot/x-rxjs';
-import type { SubmittableExtrinsic } from '../submittable/types';
-
-import { createTestPairs } from '@polkadot/keyring/testingPairs';
-import { MockProvider } from '@polkadot/rpc-provider/mock';
-import { TypeRegistry } from '@polkadot/types/create';
-import { map, switchMap } from '@polkadot/x-rxjs/operators';
-
-import { SingleAccountSigner } from '../../test/util';
-import { ApiRx } from '.';
-
-describe('ApiRx', (): void => {
-  const registry = new TypeRegistry();
-  const keyring = createTestPairs({ type: 'ed25519' });
-  let provider: MockProvider;
-
-  beforeEach((): void => {
-    jest.setTimeout(3000000);
-    provider = new MockProvider(registry);
-  });
-
-  describe('decorator.signAsync', (): void => {
-    it('signs a transfer using an external signer', (): void => {
-      const signer = new SingleAccountSigner(registry, keyring.alice_session);
-
-      ApiRx.create({ provider, registry, signer }).pipe(
-        switchMap((api: ApiRx): Observable<SubmittableExtrinsic<'rxjs'>> =>
-          api.tx.balances
-            .transfer(keyring.eve.address, 12345)
-            .signAsync(keyring.alice_session, {})
-        ),
-        map((tx: SubmittableExtrinsic<'rxjs'>): void => {
-          expect(tx.signature.toHex()).toEqual(
-            '0x97f3cfe5088fcd575313e983f45d02b0f630e7b94ff9a3ac50e20cd096a8f554fda73d42ead891b5a1d3ce5607d83f20b0c6570b555e949cfb5763d0abcd590b'
-          );
-        })
-      );
-    });
-
-    it('allows the second argument to signAsync to be omitted', () => {
-      const signer = new SingleAccountSigner(registry, keyring.alice_session);
-
-      ApiRx.create({ provider, registry, signer }).pipe(
-        switchMap((api: ApiRx): Observable<SubmittableExtrinsic<'rxjs'>> =>
-          api.tx.balances
-            .transfer(keyring.eve.address, 12345)
-            .signAsync(keyring.alice_session)
-        ),
-        map((tx: SubmittableExtrinsic<'rxjs'>): void => {
-          expect(tx.signature.toHex()).toEqual(
-            '0x97f3cfe5088fcd575313e983f45d02b0f630e7b94ff9a3ac50e20cd096a8f554fda73d42ead891b5a1d3ce5607d83f20b0c6570b555e949cfb5763d0abcd590b'
-          );
-        })
-      );
-    });
-  });
-});
@@ -165,9 +165,7 @@ export class ApiRx extends ApiBase<'rxjs'> {
    this.#isReadyRx = from<Promise<ApiRx>>(
      // You can create an observable from an event, however my mind groks this form better
      new Promise((resolve): void => {
-        super.on('ready', (): void => {
-          resolve(this);
-        });
+        super.on('ready', () => resolve(this));
      })
    );
  }
@@ -32,14 +32,17 @@ export class SubmittableResult implements ISubmittableResult {

  public readonly dispatchInfo?: DispatchInfo;

+  public readonly internalError?: Error;
+
  public readonly events: EventRecord[];

  public readonly status: ExtrinsicStatus;

-  constructor ({ dispatchError, dispatchInfo, events, status }: SubmittableResultValue) {
+  constructor ({ dispatchError, dispatchInfo, events, internalError, status }: SubmittableResultValue) {
    this.dispatchError = dispatchError || extractError(events);
    this.dispatchInfo = dispatchInfo || extractInfo(events);
    this.events = events || [];
+    this.internalError = internalError;
    this.status = status;
  }

@@ -85,6 +88,7 @@ export class SubmittableResult implements ISubmittableResult {
      dispatchError: this.dispatchError?.toHuman(),
      dispatchInfo: this.dispatchInfo?.toHuman(),
      events: this.events.map((event) => event.toHuman(isExtended)),
+      internalError: this.internalError?.message.toString(),
      status: this.status.toHuman(isExtended)
    };
  }
@@ -11,7 +11,7 @@ import type { AddressOrPair, SignerOptions, SubmittableDryRunResult, Submittable

 import { assert, isBn, isFunction, isNumber, isString, isU8a } from '@polkadot/util';
 import { of } from '@polkadot/x-rxjs';
-import { first, map, mapTo, mergeMap, switchMap, tap } from '@polkadot/x-rxjs/operators';
+import { catchError, first, map, mapTo, mergeMap, switchMap, tap } from '@polkadot/x-rxjs/operators';

 import { ApiBase } from '../base';
 import { filterEvents, isKeyringPair } from '../util';
@@ -110,7 +110,7 @@ export function createClass <ApiType extends ApiTypes> ({ api, apiType, decorate
     * @description Sign a transaction, returning the this to allow chaining, i.e. .sign(...).send(). When options, e.g. nonce/blockHash are not specified, it will be inferred. To retrieve eg. nonce use `signAsync` (the preferred interface, this is provided for backwards compatibility)
     * @deprecated
     */
-    public sign (account: IKeyringPair, optionsOrNonce?: Partial<SignerOptions>): this {
+    public override sign (account: IKeyringPair, optionsOrNonce?: Partial<SignerOptions>): this {
      super.sign(account, this.#makeSignOptions(this.#optionsOrNonce(optionsOrNonce), {}));

      return this;
@@ -242,6 +242,9 @@ export function createClass <ApiType extends ApiTypes> ({ api, apiType, decorate
            events: filterEvents(hash, block, events, status),
            status
          }))
+        ),
+        catchError((internalError: Error) =>
+          of(this.#transformResult(new SubmittableResult({ internalError, status })))
        )
      );
    }
@@ -10,6 +10,7 @@ export interface SubmittableResultValue {
  dispatchError?: DispatchError;
  dispatchInfo?: DispatchInfo;
  events?: EventRecord[];
+  internalError?: Error;
  status: ExtrinsicStatus;
 }

@@ -1,30 +1,12 @@
 // Copyright 2017-2021 @polkadot/api authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 import type { AnyFunction, Callback, Codec, CodecArg } from '@polkadot/types/types';
 import type { Observable } from '@polkadot/x-rxjs';

-// Prepend an element V onto the beginning of a tuple T.
-// Cons<1, [2,3,4]> is [1,2,3,4]
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export type Cons<V, T extends any[]> = ((v: V, ...t: T) => void) extends ((...r: infer R) => void)
-  ? R
-  : never;
+export type Push<T extends readonly unknown[], V> = [...T, V]

-// Append an element V onto the end of a tuple T
-// Push<[1,2,3],4> is [1,2,3,4]
-// note that this DOES NOT PRESERVE optionality/readonly in tuples.
-// So unfortunately Push<[1, 2?, 3?], 4> is [1,2|undefined,3|undefined,4]
-export type Push<T extends any[], V> = (
-  (
-    Cons<any, Required<T>> extends infer R
-      ? { [K in keyof R]: K extends keyof T ? T[K] : V }
-      : never
-  ) extends infer P
-    ? P extends any[] ? P : never
-    : never
-);
+export type DropLast<T extends readonly unknown[]> = T extends readonly [...infer U, any?] ? U : [...T];

 export type ApiTypes = 'promise' | 'rxjs';

@@ -75,8 +57,9 @@ export interface DecorateMethodOptions {

 export type DecorateFn <T extends Codec> = (...args: any[]) => Observable<T>;

+// FIXME We need a solution for NMap
 export interface PaginationOptions<ArgType = CodecArg> {
-  arg?: ArgType;
+  args: ArgType[];
  pageSize: number;
  startKey?: string;
 }
@@ -4,7 +4,6 @@
 // Augment the modules
 import '@polkadot/api/augment';

-import type BN from 'bn.js';
 import type { DeriveCustom, ExactDerive } from '@polkadot/api-derive';
 import type { Metadata } from '@polkadot/metadata';
 import type { RpcInterface } from '@polkadot/rpc-core/types';
@@ -12,6 +11,7 @@ import type { ProviderInterface, ProviderInterfaceEmitted } from '@polkadot/rpc-
 import type { ExtDef } from '@polkadot/types/extrinsic/signedExtensions/types';
 import type { Hash, RuntimeVersion } from '@polkadot/types/interfaces';
 import type { DefinitionRpc, DefinitionRpcSub, RegisteredTypes, Registry, SignatureOptions, Signer } from '@polkadot/types/types';
+import type { BN } from '@polkadot/util';
 import type { ApiBase } from '../base';
 import type { DeriveAllSections } from '../util/decorate';
 import type { QueryableConsts } from './consts';
@@ -69,6 +69,14 @@ export interface ApiOptions extends RegisteredTypes {
   * @description The source object to use for runtime information (only used when cloning)
   */
  source?: ApiBase<any>;
+  /**
+   * @description Throws an error when the initial connection fails (same as isReadyOrError)
+   */
+  throwOnConnect?: boolean;
+  /**
+   * @description Throws an error when some types are unknown (useful with throwOnConnect)
+   */
+  throwOnUnknown?: boolean;
 }

 // A smaller interface of ApiRx, used in derive and in SubmittableExtrinsic
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 import type { Json, Raw } from '@polkadot/types/codec';
-import type { AnyFunction, Callback } from '@polkadot/types/types';
+import type { AnyFunction, Callback, DefinitionRpc } from '@polkadot/types/types';
 import type { Observable } from '@polkadot/x-rxjs';

 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -11,6 +11,7 @@ import { ApiTypes, PromiseResult, Push, RxResult, UnsubscribePromise } from './b
 export interface RpcRxResult<F extends AnyFunction> extends RxResult<F> {
  json (...args: Parameters<F>): Observable<Json>;
  raw (...args: Parameters<F>): Observable<Raw>;
+  meta: DefinitionRpc;
 }

 export interface RpcPromiseResult<F extends AnyFunction> extends PromiseResult<F> {
@@ -18,6 +19,7 @@ export interface RpcPromiseResult<F extends AnyFunction> extends PromiseResult<F
  json (...args: Push<Parameters<F>, Callback<Json>>): UnsubscribePromise;
  raw (...args: Parameters<F>): Promise<Raw>;
  raw (...args: Push<Parameters<F>, Callback<Raw>>): UnsubscribePromise;
+  meta: DefinitionRpc;
 }

 export type RpcMethodResult<ApiType extends ApiTypes, F extends AnyFunction> = ApiType extends 'rxjs'
@@ -6,7 +6,7 @@ import type { Hash } from '@polkadot/types/interfaces';
 import type { StorageEntry } from '@polkadot/types/primitive/types';
 import type { AnyFunction, AnyTuple, Callback, Codec, CodecArg, IStorageKey } from '@polkadot/types/types';
 import type { Observable } from '@polkadot/x-rxjs';
-import type { ApiTypes, MethodResult, ObsInnerType, PaginationOptions, PromiseOrObs, UnsubscribePromise } from './base';
+import type { ApiTypes, DropLast, MethodResult, ObsInnerType, PaginationOptions, PromiseOrObs, UnsubscribePromise } from './base';

 interface StorageEntryObservableMulti {
  <T extends Codec>(args: (CodecArg[] | CodecArg)[]): Observable<T[]>;
@@ -18,15 +18,16 @@ interface StorageEntryPromiseMulti {
 }

 export interface StorageEntryPromiseOverloads {
-  (arg1?: CodecArg, arg2?: CodecArg): Promise<Codec>;
-  <T extends Codec>(arg1?: CodecArg, arg2?: CodecArg): Promise<T>;
+  (arg1?: CodecArg, arg2?: CodecArg, arg3?: CodecArg): Promise<Codec>;
+  <T extends Codec>(arg1?: CodecArg, arg2?: CodecArg, arg3?: CodecArg): Promise<T>;
  <T extends Codec>(callback: Callback<T>): UnsubscribePromise;
  <T extends Codec>(arg: CodecArg, callback: Callback<T>): UnsubscribePromise;
  <T extends Codec>(arg1: CodecArg, arg2: CodecArg, callback: Callback<T>): UnsubscribePromise;
+  <T extends Codec>(arg1: CodecArg, arg2: CodecArg, arg3: CodecArg, callback: Callback<T>): UnsubscribePromise;
 }

 // This is the most generic typings we can have for a storage entry function
-type GenericStorageEntryFunction = (arg1?: CodecArg, arg2?: CodecArg) => Observable<Codec>
+type GenericStorageEntryFunction = (...args: CodecArg[]) => Observable<Codec>

 export type QueryableStorageEntry<ApiType extends ApiTypes, A extends AnyTuple = AnyTuple> =
  ApiType extends 'rxjs'
@@ -38,15 +39,15 @@ export type QueryableStorageEntry<ApiType extends ApiTypes, A extends AnyTuple =
 export interface StorageEntryBase<ApiType extends ApiTypes, F extends AnyFunction, A extends AnyTuple = AnyTuple> {
  at: <T extends Codec | any = ObsInnerType<ReturnType<F>>>(hash: Hash | Uint8Array | string, ...args: Parameters<F>) => PromiseOrObs<ApiType, T>;
  creator: StorageEntry;
-  entries: <T extends Codec | any = ObsInnerType<ReturnType<F>>, K extends AnyTuple = A>(arg?: Parameters<F>[0]) => PromiseOrObs<ApiType, [StorageKey<K>, T][]>;
-  entriesAt: <T extends Codec | any = ObsInnerType<ReturnType<F>>, K extends AnyTuple = A>(hash: Hash | Uint8Array | string, arg?: Parameters<F>[0]) => PromiseOrObs<ApiType, [StorageKey<K>, T][]>;
+  entries: <T extends Codec | any = ObsInnerType<ReturnType<F>>, K extends AnyTuple = A>(...args: DropLast<Parameters<F>>) => PromiseOrObs<ApiType, [StorageKey<K>, T][]>;
+  entriesAt: <T extends Codec | any = ObsInnerType<ReturnType<F>>, K extends AnyTuple = A>(hash: Hash | Uint8Array | string, ...args: DropLast<Parameters<F>>) => PromiseOrObs<ApiType, [StorageKey<K>, T][]>;
  entriesPaged: <T extends Codec | any = ObsInnerType<ReturnType<F>>, K extends AnyTuple = A>(opts: PaginationOptions<Parameters<F>[0]>) => PromiseOrObs<ApiType, [StorageKey<K>, T][]>;
  hash: (...args: Parameters<F>) => PromiseOrObs<ApiType, Hash>;
  is: (key: IStorageKey<AnyTuple>) => key is IStorageKey<A>;
  key: (...args: Parameters<F>) => string;
-  keyPrefix: () => string;
-  keys: <K extends AnyTuple = A> (arg?: any) => PromiseOrObs<ApiType, StorageKey<K>[]>;
-  keysAt: <K extends AnyTuple = A> (hash: Hash | Uint8Array | string, arg?: any) => PromiseOrObs<ApiType, StorageKey<K>[]>;
+  keyPrefix: (...args: DropLast<Parameters<F>>) => string;
+  keys: <K extends AnyTuple = A> (...args: DropLast<Parameters<F>>) => PromiseOrObs<ApiType, StorageKey<K>[]>;
+  keysAt: <K extends AnyTuple = A> (hash: Hash | Uint8Array | string, ...args: DropLast<Parameters<F>>) => PromiseOrObs<ApiType, StorageKey<K>[]>;
  keysPaged: <K extends AnyTuple = A> (opts: PaginationOptions<Parameters<F>[0]>) => PromiseOrObs<ApiType, StorageKey<K>[]>;
  // @deprecated The underlying RPC this been marked unsafe and is generally not exposed
  range: <T extends Codec | any = ObsInnerType<ReturnType<F>>>([from, to]: [Hash | Uint8Array | string, Hash | Uint8Array | string | undefined] | [Hash | Uint8Array | string], ...args: Parameters<F>) => PromiseOrObs<ApiType, [Hash, T][]>;
@@ -80,10 +81,7 @@ export type QueryableStorageMulti<ApiType extends ApiTypes> =
 // eslint-disable-next-line @typescript-eslint/no-empty-interface,@typescript-eslint/no-unused-vars
 export interface AugmentedQueries<ApiType extends ApiTypes> { }

-export interface StorageEntryDoubleMap<ApiType extends ApiTypes, F extends AnyFunction, A extends AnyTuple> extends StorageEntryBase<ApiType, F, A> {
-  keyPrefix: (key1?: Parameters<F>[0]) => string;
-}
-
 export type AugmentedQuery<ApiType extends ApiTypes, F extends AnyFunction, A extends AnyTuple = AnyTuple> = MethodResult<ApiType, F> & StorageEntryBase<ApiType, F, A>;

-export type AugmentedQueryDoubleMap<ApiType extends ApiTypes, F extends AnyFunction, A extends AnyTuple = AnyTuple> = MethodResult<ApiType, F> & StorageEntryDoubleMap<ApiType, F, A>;
+// backwards compatibility-only
+export type AugmentedQueryDoubleMap<ApiType extends ApiTypes, F extends AnyFunction, A extends AnyTuple = AnyTuple> = AugmentedQuery<ApiType, F, A>;
@@ -66,14 +66,14 @@ describe('extractStorageArgs', (): void => {
    expect(
      (): any =>
        extractStorageArgs(storage.staking.erasStakers, [])
-    ).toThrow('staking.erasStakers(EraIndex, AccountId) is a doublemap, requiring 2 arguments, 0 found');
+    ).toThrow('staking.erasStakers(EraIndex, AccountId) is a double map, requiring 2 arguments, 0 found');
  });

  it('validates doublemap, 2 args (failing with 1 arg)', (): void => {
    expect(
      (): any =>
        extractStorageArgs(storage.staking.erasStakers, [123])
-    ).toThrow('staking.erasStakers(EraIndex, AccountId) is a doublemap, requiring 2 arguments, 1 found');
+    ).toThrow('staking.erasStakers(EraIndex, AccountId) is a double map, requiring 2 arguments, 1 found');
  });

  // Linked maps have been removed
@@ -6,14 +6,14 @@ import type { StorageEntry } from '@polkadot/types/primitive/types';

 import { assert, isUndefined } from '@polkadot/util';

-function sig ({ method, section }: StorageEntry, ...args: Type[]): string {
+function sig ({ method, section }: StorageEntry, args: Type[]): string {
  return `${section}.${method}(${args.join(', ')})`;
 }

 function doDoubleMap (creator: StorageEntry, args: unknown[]): [StorageEntry, [any, any]] {
  const { key1, key2 } = creator.meta.type.asDoubleMap;

-  assert(args.length === 2, `${sig(creator, key1, key2)} is a doublemap, requiring 2 arguments, ${args.length} found`);
+  assert(args.length === 2, () => `${sig(creator, [key1, key2])} is a double map, requiring 2 arguments, ${args.length} found`);

  // pass as tuple
  return [creator, args as [any, any]];
@@ -22,7 +22,7 @@ function doDoubleMap (creator: StorageEntry, args: unknown[]): [StorageEntry, [a
 function doMap (creator: StorageEntry, args: unknown[]): [StorageEntry] | [StorageEntry, any] {
  const { key } = creator.meta.type.asMap;

-  assert(args.length === 1, `${sig(creator, key)} is a map, requiring 1 argument, ${args.length} found`);
+  assert(args.length === 1, () => `${sig(creator, [key])} is a map, requiring 1 argument, ${args.length} found`);

  // expand
  return args.length
@@ -30,18 +30,29 @@ function doMap (creator: StorageEntry, args: unknown[]): [StorageEntry] | [Stora
    : [creator];
 }

+function doNMap (creator: StorageEntry, args: unknown[]): [StorageEntry, any[]] {
+  const { keyVec } = creator.meta.type.asNMap;
+
+  assert(args.length === keyVec.length, () => `${sig(creator, keyVec)} is a multi map, requiring ${keyVec.length} arguments, ${args.length} found`);
+
+  // pass as tuple
+  return [creator, args];
+}
+
 // sets up the arguments in the form of [creator, args] ready to be used in a storage
 // call. Additionally, it verifies that the correct number of arguments have been passed
-export function extractStorageArgs (creator: StorageEntry, _args: unknown[]): [StorageEntry, [any, any]] | [StorageEntry] | [StorageEntry, any] {
+export function extractStorageArgs (creator: StorageEntry, _args: unknown[]): [StorageEntry, any[]] | [StorageEntry] | [StorageEntry, any] {
  const args = _args.filter((arg) => !isUndefined(arg));

  if (creator.meta.type.isDoubleMap) {
    return doDoubleMap(creator, args);
  } else if (creator.meta.type.isMap) {
    return doMap(creator, args);
+  } else if (creator.meta.type.isNMap) {
+    return doNMap(creator, args);
  }

-  assert(args.length === 0, `${sig(creator)} does not take any arguments, ${args.length} found`);
+  assert(args.length === 0, () => `${sig(creator, [])} does not take any arguments, ${args.length} found`);

  // no args
  return [creator];
@@ -1,23 +1,28 @@
 // Copyright 2017-2021 @polkadot/api authors & contributors
 // SPDX-License-Identifier: Apache-2.0

+import { jest } from '@jest/globals';
+
 import { ApiPromise, WsProvider } from '@polkadot/api';

-function createApi (): Promise<ApiPromise> {
-  jest.setTimeout(30000);
-  process.env.NODE_ENV = 'test';
+describe('misc online tests', (): void => {
+  let api: ApiPromise;

-  const provider = new WsProvider('wss://kusama-rpc.polkadot.io');
-  // const provider = new WsProvider('wss://westend-rpc.polkadot.io/');
-  // const provider = new WsProvider('ws://127.0.0.1:9944/');
+  beforeEach(async () => {
+    jest.setTimeout(30000);
+    process.env.NODE_ENV = 'test';

-  return new ApiPromise({ provider }).isReady;
-}
+    // const provider = new WsProvider('wss://kusama-rpc.polkadot.io');
+    const provider = new WsProvider('wss://westend-rpc.polkadot.io/');
+
+    api = await ApiPromise.create({ provider });
+  });
+
+  afterEach(async () => {
+    await api.disconnect();
+  });

-describe.skip('misc quick tests', (): void => {
  it.skip('retrieves balances correctly', async (): Promise<void> => {
-    const api = await createApi();
-
    console.error(JSON.stringify(
      await api.query.system.account('FPzukZw2mphWsXDqdkNzLaxnanjZEWH9i2vqwobTdtde5me')
    ));
@@ -27,8 +32,6 @@ describe.skip('misc quick tests', (): void => {
  });

  it.skip('handles map keys', async (): Promise<void> => {
-    const api = await createApi();
-
    console.time('map.keys');

    const keys = await api.query.system.account.keys();
@@ -39,8 +42,6 @@ describe.skip('misc quick tests', (): void => {
  });

  it.skip('handles map entries', async (): Promise<void> => {
-    const api = await createApi();
-
    console.time('map.entries');

    const entries = await api.query.system.account.entries(); // api.query.indices.accounts.entries();
@@ -51,7 +52,6 @@ describe.skip('misc quick tests', (): void => {
  });

  it.skip('handles doublemap entries', async (): Promise<void> => {
-    const api = await createApi();
    const activeEra = await api.query.staking.activeEra();

    console.error(JSON.stringify(
@@ -60,20 +60,14 @@ describe.skip('misc quick tests', (): void => {
  });

  it.skip('does something in society', async (): Promise<void> => {
-    const api = await createApi();
-
    console.error(JSON.stringify(
      await api.query.society.defenderVotes('Dab4bfYTZRUDMWjYAUQuFbDreQ9mt7nULWu3Dw7jodbzVe9')
    ));
  });

-  it.skip('allows for range queries', async (): Promise<void> => {
-    const api = await createApi();
-    const header = await api.rpc.chain.getHeader();
+  it('expose rpc and rx definition', (): void => {
+    console.error(api.rpc.payment.queryFeeDetails.meta);

-    console.error(JSON.stringify(
-      (await api.query.staking.activeEra.range([header.parentHash, header.hash], 'Dab4bfYTZRUDMWjYAUQuFbDreQ9mt7nULWu3Dw7jodbzVe9'))
-        .map(([block, value]) => [block, value.toRawType(), value.toHuman()])
-    ));
+    console.error(api.rx.rpc.chain.getBlock.meta);
  });
 });
@@ -7,6 +7,8 @@ import type { Option } from '@polkadot/types/codec';
 import type { AccountId, AccountIndex, AccountInfo, Address, Balance, BlockNumber, Index } from '@polkadot/types/interfaces';
 import type { Observable } from '@polkadot/x-rxjs';

+import { jest } from '@jest/globals';
+
 import { ApiPromise, WsProvider } from '@polkadot/api';
 import { memo } from '@polkadot/api-derive/util/memo';
 import { combineLatest, of } from '@polkadot/x-rxjs';
@@ -1,6 +1,6 @@
 {
  "name": "@polkadot/metadata",
-  "version": "4.5.1",
+  "version": "4.16.1",
  "type": "module",
  "description": "Helpers to extract information from runtime metadata",
  "main": "index.js",
@@ -8,6 +8,9 @@
    "./detectPackage.js",
    "./detectPackage.cjs"
  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
  "repository": "github:polkadot-js/api",
  "author": "Jaco Greeff <jacogr@gmail.com>",
  "maintainers": [],
@@ -16,14 +19,13 @@
  "bugs": "https://github.com/polkadot-js/api/issues",
  "homepage": "https://github.com/polkadot-js/api/tree/master/packages/type-metadata#readme",
  "dependencies": {
-    "@babel/runtime": "^7.13.10",
-    "@polkadot/types": "4.5.1",
-    "@polkadot/types-known": "4.5.1",
-    "@polkadot/util": "^6.1.1",
-    "@polkadot/util-crypto": "^6.1.1",
-    "bn.js": "^4.11.9"
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/types": "4.16.1",
+    "@polkadot/types-known": "4.16.1",
+    "@polkadot/util": "^6.10.1",
+    "@polkadot/util-crypto": "^6.10.1"
  },
  "devDependencies": {
-    "@polkadot/keyring": "^6.1.1"
+    "@polkadot/keyring": "^6.10.1"
  }
 }
@@ -9,10 +9,20 @@ describe('MagicNumber', (): void => {
  const registry = new TypeRegistry();

  it('succeeds when the magic number matches', (): void => {
-    expect((): MagicNumber => new MagicNumber(registry, MAGIC_NUMBER)).not.toThrow();
+    expect(
+      () => new MagicNumber(registry, MAGIC_NUMBER)
+    ).not.toThrow();
+  });
+
+  it('succeeds when the magic number is empty', (): void => {
+    expect(
+      () => new MagicNumber(registry)
+    ).not.toThrow();
  });

  it('fails when the magic number mismatches', (): void => {
-    expect((): MagicNumber => new MagicNumber(registry, 0x12345)).toThrow(/MagicNumber/);
+    expect(
+      () => new MagicNumber(registry, 0x12345678)
+    ).toThrow(/MagicNumber mismatch/);
  });
 });
@@ -13,9 +13,7 @@ export class MagicNumber extends U32 {
    super(registry, value);

    if (!this.isEmpty) {
-      const magic = registry.createType('u32', MAGIC_NUMBER);
-
-      assert(this.eq(magic), `MagicNumber mismatch: expected ${magic.toHex()}, found ${this.toHex()}`);
+      assert(this.eq(MAGIC_NUMBER), () => `MagicNumber mismatch: expected ${registry.createType('u32', MAGIC_NUMBER).toHex()}, found ${this.toHex()}`);
    }
  }
 }
@@ -3,7 +3,7 @@

 import type { Registry } from '@polkadot/types/types';

-import { isString, u8aConcat, u8aToU8a } from '@polkadot/util';
+import { isHex, isU8a, u8aToU8a } from '@polkadot/util';

 import { MetadataVersioned } from './MetadataVersioned';

@@ -11,37 +11,39 @@ import { MetadataVersioned } from './MetadataVersioned';
 const VERSION_IDX = 4;

 // magic + lowest supported version
-const EMPTY_METADATA = u8aConcat(new Uint8Array([0x6d, 0x65, 0x74, 0x61, 9]));
+const EMPTY_METADATA = new Uint8Array([0x6d, 0x65, 0x74, 0x61, 9]);
 const EMPTY_U8A = new Uint8Array();

-function sanitizeInput (_value: Uint8Array | string = EMPTY_U8A): Uint8Array {
-  if (isString(_value)) {
-    return sanitizeInput(u8aToU8a(_value));
-  }
-
-  return _value.length === 0
-    ? EMPTY_METADATA
-    : _value;
+function toU8a (value: Uint8Array | string = EMPTY_U8A): Uint8Array {
+  return isHex(value)
+    ? toU8a(u8aToU8a(value))
+    : isU8a(value) && value.length === 0
+      ? EMPTY_METADATA
+      : value;
 }

-function decodeMetadata (registry: Registry, _value?: Uint8Array | string): MetadataVersioned {
-  const value = sanitizeInput(_value);
-  const version = value[VERSION_IDX];
+function decodeMetadata (registry: Registry, _value?: Uint8Array | string | Map<string, unknown> | Record<string, unknown>): MetadataVersioned {
+  if (!_value || isU8a(_value) || isHex(_value)) {
+    const value = toU8a(_value);
+    const version = value[VERSION_IDX];

-  try {
-    return new MetadataVersioned(registry, value);
-  } catch (error) {
-    // This is an f-ing hack as a follow-up to another ugly hack
-    // https://github.com/polkadot-js/api/commit/a9211690be6b68ad6c6dad7852f1665cadcfa5b2
-    // when we fail on V9, try to re-parse it as v10... yes... HACK
-    if (version === 9) {
-      value[VERSION_IDX] = 10;
+    try {
+      return new MetadataVersioned(registry, value);
+    } catch (error) {
+      // This is an f-ing hack as a follow-up to another ugly hack
+      // https://github.com/polkadot-js/api/commit/a9211690be6b68ad6c6dad7852f1665cadcfa5b2
+      // when we fail on V9, try to re-parse it as v10... yes... HACK
+      if (version === 9) {
+        value[VERSION_IDX] = 10;

-      return decodeMetadata(registry, value);
+        return decodeMetadata(registry, value);
+      }
+
+      throw error;
    }
-
-    throw error;
  }
+
+  return new MetadataVersioned(registry, _value);
 }

 /**
@@ -50,7 +52,7 @@ function decodeMetadata (registry: Registry, _value?: Uint8Array | string): Meta
 * The versioned runtime metadata as a decoded structure
 */
 export class Metadata extends MetadataVersioned {
-  constructor (registry: Registry, value?: Uint8Array | string) {
+  constructor (registry: Registry, value?: Uint8Array | string | Map<string, unknown> | Record<string, unknown>) {
    super(registry, decodeMetadata(registry, value));
  }
 }
@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/metadata authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import type { MetadataAll, MetadataLatest, MetadataV9, MetadataV10, MetadataV11, MetadataV12 } from '@polkadot/types/interfaces/metadata';
+import type { MetadataAll, MetadataLatest, MetadataV9, MetadataV10, MetadataV11, MetadataV12, MetadataV13 } from '@polkadot/types/interfaces/metadata';
 import type { AnyJson, Registry } from '@polkadot/types/types';

 import { Struct } from '@polkadot/types/codec';
@@ -10,13 +10,16 @@ import { assert } from '@polkadot/util';
 import { toV10 } from './v9/toV10';
 import { toV11 } from './v10/toV11';
 import { toV12 } from './v11/toV12';
-import { toLatest } from './v12/toLatest';
+import { toV13 } from './v12/toV13';
+import { toLatest } from './v13/toLatest';
 import { MagicNumber } from './MagicNumber';
 import { getUniqTypes, toCallsOnly } from './util';

-type MetaMapped = MetadataV9 | MetadataV10 | MetadataV11 | MetadataV12;
-type MetaVersions = 9 | 10 | 11 | 12 | 13;
-type MetaAsX = 'asV9' | 'asV10' | 'asV11' | 'asV12';
+type MetaMapped = MetadataV9 | MetadataV10 | MetadataV11 | MetadataV12 | MetadataV13;
+type MetaAsX = 'asV9' | 'asV10' | 'asV11' | 'asV12' | 'asV13';
+type MetaVersions = 'latest' | 9 | 10 | 11 | 12 | 13;
+
+const LATEST_VERSION = 13;

 /**
 * @name MetadataVersioned
@@ -24,7 +27,7 @@ type MetaAsX = 'asV9' | 'asV10' | 'asV11' | 'asV12';
 * The versioned runtime metadata as a decoded structure
 */
 export class MetadataVersioned extends Struct {
-  readonly #converted = new Map<number, MetaMapped>();
+  readonly #converted = new Map<MetaVersions, MetaMapped>();

  constructor (registry: Registry, value?: unknown) {
    super(registry, {
@@ -34,16 +37,18 @@ export class MetadataVersioned extends Struct {
  }

  #assertVersion = (version: number): boolean => {
-    assert(this.version <= version, `Cannot convert metadata from v${this.version} to v${version}`);
+    assert(this.version <= version, () => `Cannot convert metadata from version ${this.version} to ${version}`);

    return this.version === version;
  };

  #getVersion = <T extends MetaMapped, F extends MetaMapped>(version: MetaVersions, fromPrev: (registry: Registry, input: F, metaVersion: number) => T): T => {
    const asCurr = `asV${version}` as MetaAsX;
-    const asPrev = `asV${version - 1}` as MetaAsX;
+    const asPrev = version === 'latest'
+      ? `asV${LATEST_VERSION}` as MetaAsX
+      : `asV${version - 1}` as MetaAsX;

-    if (this.#assertVersion(version)) {
+    if (version !== 'latest' && this.#assertVersion(version)) {
      return this.#metadata()[asCurr] as T;
    }

@@ -101,16 +106,23 @@ export class MetadataVersioned extends Struct {
    return this.#getVersion(12, toV12);
  }

+  /**
+   * @description Returns the wrapped values as a V13 object
+   */
+  public get asV13 (): MetadataV13 {
+    return this.#getVersion(13, toV13);
+  }
+
  /**
   * @description Returns the wrapped values as a latest version object
   */
  public get asLatest (): MetadataLatest {
    // This is non-existent & latest - applied here to do the module-specific type conversions
-    return this.#getVersion(13, toLatest);
+    return this.#getVersion('latest', toLatest);
  }

  /**
-   * @description
+   * @description The magicNumber for the Metadata (known constant)
   */
  public get magicNumber (): MagicNumber {
    return this.get('magicNumber') as MagicNumber;
@@ -130,9 +142,9 @@ export class MetadataVersioned extends Struct {
  /**
   * @description Converts the Object to JSON, typically used for RPC transfers
   */
-  public toJSON (): Record<string, AnyJson> {
-    // HACK(y): ensure that we apply the aliasses if we have not done so already, this is
-    // needed to ensure we have the overrides as intended (only applied in toLatest)
+  public override toJSON (): Record<string, AnyJson> {
+    // HACK(y): ensure that we apply the aliases if we have not done so already, this is
+    // needed to ensure we have the correct overrides (which is only applied in toLatest)
    // eslint-disable-next-line no-unused-expressions
    this.asLatest;

@@ -17,7 +17,7 @@ function init (meta: string): [Constants, TypeRegistry] {

  registry.setMetadata(metadata);

-  return [decorateConstants(registry, metadata.asLatest), registry];
+  return [decorateConstants(registry, metadata.asLatest, 12), registry];
 }

 describe('decorateConstants', (): void => {
@@ -8,7 +8,8 @@ import type { ConstantCodec, Constants, ModuleConstants } from '../types';
 import { hexToU8a, stringCamelCase } from '@polkadot/util';

 /** @internal */
-export function decorateConstants (registry: Registry, { modules }: MetadataLatest): Constants {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function decorateConstants (registry: Registry, { modules }: MetadataLatest, _metaVersion: number): Constants {
  return modules.reduce((result: Constants, { constants, name }): Constants => {
    if (constants.isEmpty) {
      return result;
@@ -16,7 +16,7 @@ export function createUnchecked (registry: Registry, section: string, callIndex:
  const funcName = stringCamelCase(callMetadata.name);

  const extrinsicFn = (...args: any[]): Call => {
-    assert(expectedArgs.length === args.length, `Extrinsic ${section}.${funcName} expects ${expectedArgs.length.valueOf()} arguments, got ${args.length}.`);
+    assert(expectedArgs.length === args.length, () => `Extrinsic ${section}.${funcName} expects ${expectedArgs.length.valueOf()} arguments, got ${args.length}.`);

    return registry.createType('Call', {
      args,
@@ -1,10 +1,9 @@
 // Copyright 2017-2021 @polkadot/metadata authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import BN from 'bn.js';
-
 import { createTestPairs } from '@polkadot/keyring/testingPairs';
 import { TypeRegistry } from '@polkadot/types/create';
+import { BN } from '@polkadot/util';

 import { Metadata } from '../../Metadata';
 import metadataStatic from '../../static';
@@ -46,7 +46,7 @@ describe('Decorated', () => {
  });

  it('should return constants with the correct type and value', (): void => {
-    const consts = decorateConstants(registry, metadata.asLatest);
+    const consts = decorateConstants(registry, metadata.asLatest, metadata.version);

    expect(consts.democracy.cooloffPeriod).toBeInstanceOf(registry.createClass('BlockNumber'));
    expect(consts.democracy.cooloffPeriod.toHex()).toEqual('0x000c4e00');
@@ -20,13 +20,14 @@ export function expandMetadata (registry: Registry, metadata: Metadata): Decorat
  assert(metadata instanceof Metadata, 'You need to pass a valid Metadata instance to Decorated');

  const latest = metadata.asLatest;
+  const version = metadata.version;

  return {
-    consts: decorateConstants(registry, latest),
-    errors: decorateErrors(registry, latest, metadata.version),
-    events: decorateEvents(registry, latest, metadata.version),
-    query: decorateStorage(registry, latest, metadata.version),
-    tx: decorateExtrinsics(registry, latest, metadata.version)
+    consts: decorateConstants(registry, latest, version),
+    errors: decorateErrors(registry, latest, version),
+    events: decorateEvents(registry, latest, version),
+    query: decorateStorage(registry, latest, version),
+    tx: decorateExtrinsics(registry, latest, version)
  };
 }

--- a/Show More
+++ b/Show More