[CI Skip] release/stable 4.11.1

skip-checks: true

.123trigger

@@ -1,4 +1,4 @@
-25
+29
 1.4.2
 1.6.2
 1.11.2
@@ -8,10 +8,18 @@
 2.8.2
 3.2.2
 3.2.3
-
 3.3.2
 3.6.2
 3.6.3
 3.6.4
 3.7.2
-3.7.3
+3.7.3
+3.9.2
+3.9.3
+3.10.2
+4.0.2
+4.0.3
+
+4.6.2
+4.7.2
+4.9.2

.eslintrc.js

@@ -24,8 +24,6 @@ module.exports = {
     ...base.rules,
     // add override for any (a metric ton of them, initial conversion)
     '@typescript-eslint/no-explicit-any': 'off',
-    // these should be removed, there are 8 of them as errors
-    '@typescript-eslint/no-non-null-assertion': 'off',
     // this seems very broken atm, false positives
     '@typescript-eslint/unbound-method': 'off'
   }

.nvmrc

@@ -1 +1 @@
-12
+14

.yarnrc.yml

@@ -10,4 +10,4 @@ plugins:
   - path: .yarn/plugins/@yarnpkg/plugin-version.cjs
     spec: "@yarnpkg/plugin-version"
 
-yarnPath: .yarn/releases/yarn-2.4.0.cjs
+yarnPath: .yarn/releases/yarn-2.4.1.cjs

CHANGELOG.md

@@ -1,5 +1,359 @@
 # CHANGELOG
 
+## 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.
+
+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
+- Add `Westend` known upgrade block for runtime 50
+- Align types with latest Substrate master
+- Adjust keepalive `system_health` timer
+
+
+## 4.4.1 Apr 5, 2021
+
+Upgrade priority: Low. Recommended with usage with the Rococo testnet.
+
+Changes:
+
+- Add `ServiceQuality` type for Cumulus
+- Adjust XCM MultiLocation type (X5 to X8 junctions)
+- Add Polkadot 29 upgrade block
+
+
+## 4.3.1 Mar 29, 2021
+
+Upgrade priority: Low.
+
+Contributed:
+
+- Fix documentation on ABI parameters (Thanks to https://github.com/vminkov)
+
+Changes:
+
+- Warn on usage of deprecated contract interfaces
+- Update `ParaInfo` type
+- Council should be optional in treasury derives
+- Allow extraction of session derives indexes with no staking
+
+
+## 4.2.1 Mar 22, 2021
+
+Upgrade priority: Low. Recommended when tracking the latest updates from Substrate.
+
+Contributed:
+
+- Fix contract even decoding on Substrate 3 (Thanks to https://github.com/vminkov)
+
+Changes:
+
+- Adjust `Extender{Header, SignedBlock}` types to ensure at-block `Header` types are used
+- Explicit definition for new Rococo triple refcount `AccountData` types
+- Convert metadata private class fields to ES-private
+- Adjust `SignedBlock` type for new `justifications` field
+- Optimize society derive for multi accounts
+- Bump metadata to latest substrate version
+
+
+## 4.1.1 Mar 15, 2021
+
+Upgrade priority: Low. Recommended when tracking the latest updates from Substrate.
+
+Changes:
+
+- Fix author extraction for last block in a session
+- Expand `SignerPayload` to inject/expose custom signed extensions
+- `ConsensusEngineId` formats non-Ascii engines correctly
+- Allow `getBlock/Header` derives to use as-at registry (instead of latest)
+- Cleanup `RpcCore` augmentation (removing TS warnings on typegen chains)
+- Add upgrade block for Kusama 2029
+- Ensure that type alias overrides also apply to map keys
+- Check type generation against fallbacks (build-time only sanity check)
+- Add `mmr_generateProof` RPC
+- Align types with latest substrate master
+- Apply latest Polkadot auctions/crowdloan/parachains/slots types
+
+
+## 4.0.3 Mar 8, 2021
+
+Upgrade priority: Low. Recommended if you use the API to sync the full chain, most notably Polkadot.
+
+Contributed:
+
+- Re-add unused historical `SudoBalances` to `ProxyType` (Thanks to https://github.com/emostov)
+
+
+## 4.0.2 Mar 8, 2021
+
+Upgrade priority: High. Required if you are using 4.0.1 in a Node.js environment.
+
+Changes:
+
+- Fix import from `@polkadot/x-rxjs` in Node environments (From common)
+- Add correct types for `Phase` is new validator elections module
+
+
+## 4.0.1 Mar 7, 2021
+
+Upgrade priority: Low. Recommended for users wanting to keep updated with chain changes.
+
+**Important** In the 4.0 version the default package type has been changed to ESM modules by default. This should not affect usage, however since the output formats changed, a new major version is required.
+
+Contributed:
+
+- Expose `unknownTypes` on the registry interface (Thanks to https://github.com/ii-ii-ii)
+
+Changes:
+
+- Build to ESM by default (with cjs versions via export map)
+- Enum `.toSON()` now encodes all keys as `camelCase` (aligning with the output from Substrate)
+- Add `createdAtHash?: Hash` to `Codec` interface (filled-in by storage retrievals)
+- Expose the source hash as `wamHash` on Abi parsed instances
+- Use `parentHash` when creating mortal era (handles frequent forks better)
+- Add `AccountInfoWithTripleRefCount` to cater for latest Substrate
+- Add upgrade block for Westend 49
+
+
+## 3.11.1 Feb 28, 2021
+
+Upgrade priority: Low. Recommended for users wanting to keep updated with chain changes.
+
+Contributed:
+
+- Clean Websocket states on disconnects (Thanks to https://github.com/ianhe8x)
+- Support for C-like indexed enums (Thanks to https://github.com/xlc)
+
+Changes:
+
+- Adjust council derives to cater for current-generation candidate mapping
+- Allow for override of codec hasher (& output type)
+- Adjust submittables to submit hex-encoded addresses to queries
+- Adjust initialization to always retrieve tx version from Metadata only
+- Update election types as per latest Substrate
+- Add types for the new gilt module
+- Upgrade to the latest Substrate metadata
+- Adjust package detection to check for local monorepo dependencies
+- Ensure that metadata `.toJSON()` does apply type aliasses
+
+
+## 3.10.2 Feb 23, 2021
+
+Upgrade priority: Medium. Recommended for users of chains where `MultiAddress` is in-use and blocks are decoded.
+
+Changes:
+
+- Fix decoding for `MultiAddress` enum where non-`AccountId` variable-lengths are provided as part of a stream
+- Added known Polkadot 28 upgrade block
+- Update for latest Substrate contracts `Schedule` types
+
+
+## 3.10.1 Feb 22, 2021
+
+Upgrade priority: Low.
+
+Changes:
+
+- Adjust ConsumedWeight types to align with Rust module code
+- Check for connection status in subscription unsubscribe
+- Adjust staking reward derives ordering for better performance
+- Adapt detection imports to remove `.json` dependencies (Better behavior using Node.js with ESM)
+
+
+## 3.9.3 Feb 16, 2021
+
+Upgrade priority: Low. Recommended for parachain builders since it contains the updated parachain types.
+
+Changes:
+
+- Adjusted parachain `PersistedValidationData` structure
+
+
+## 3.9.2 Feb 15, 2021
+
+Upgrade priority: Low. Recommended for parachain builders since it contains the latest parachain types.
+
+Contributed:
+
+- Update README links (Thanks to https://github.com/wirednkod)
+
+Changes:
+
+- Added missing Culmulus `ParachainInherentData` & `MessageQueueChain` types
+- Add alias for `system_unstable_networkState` RPC
+
+
+## 3.9.1 Feb 14, 2021
+
+Upgrade priority: Low.
+
+- **Important** The `Result<T, E>` has been updated in the generation and the base types to follow the Rust version 100%. This means `{as, is}Error` is now available as `{as, is}Err` on the `Result` type. The older versions can still be used, but the `*Error` interfaces are now marked as deprecated.
+
+Changes:
+
+- Adjust `Result<T, E>` interface to be 100% compatible with the Rust version
+- Add the `2028` upgrade to the known upgrades (optimizing certain `.at` queries)
+- Adjust council derives to cater for latest Substrate & Polkadot
+- Adjust Rococo know type definitions to cater for the latest update
+- Update types for latest Polkadot/Substrate
+- Add generic arguments for TypeScript users to `.entries/.keys` to deal with the key typings
+
+
 ## 3.8.1 Feb 7, 2021
 
 Upgrade priority: Low. Recommended for users of the latest Substrate master, especially using contracts.

README.md

@@ -7,7 +7,7 @@
 
 # @polkadot/api
 
-This library provides a clean wrapper around all the methods exposed by a Polkadot/Substrate network client and defines all the types exposed by a node. For complete documentation around the classes, interfaces and their use, visit the [documentation portal](https://polkadot.js.org/api/).
+This library provides a clean wrapper around all the methods exposed by a Polkadot/Substrate network client and defines all the types exposed by a node. For complete documentation around the classes, interfaces and their use, visit the [documentation portal](https://polkadot.js.org/docs/api/).
 
 If you are an existing user, please be sure to track the [CHANGELOG](CHANGELOG.md) and [UPGRADING](UPGRADING.md) guides when changing versions.
 
@@ -21,8 +21,8 @@ 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/api/substrate/rpc.html) exposed by a Polkadot network client
+- [@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
 
 Type definitions for interfaces as exposed by Polkadot & Substrate clients -

jest.config.cjs

@@ -3,7 +3,8 @@
 
 const config = require('@polkadot/dev/config/jest.cjs');
 
-module.exports = Object.assign({}, config, {
+module.exports = {
+  ...config,
   moduleNameMapper: {
     '@polkadot/api-(contract|derive)(.*)$': '<rootDir>/packages/api-$1/src/$2',
     // eslint-disable-next-line sort-keys
@@ -26,5 +27,5 @@ module.exports = Object.assign({}, config, {
     '<rootDir>/packages/types/build',
     '<rootDir>/packages/types-known/build'
   ],
-  resolver: '@polkadot/dev/config/jest-resolver.cjs'
+  transformIgnorePatterns: ['/node_modules/(?!@polkadot|@babel/runtime/helpers/esm/)']
-});
+};

package.json

@@ -8,7 +8,7 @@
     "packages/*"
   ],
   "resolutions": {
-    "typescript": "^4.1.3"
+    "typescript": "^4.2.4"
   },
   "scripts": {
     "build": "yarn build:interfaces && polkadot-dev-build-ts",
@@ -25,14 +25,14 @@
     "test:watch": "polkadot-dev-run-test --watch"
   },
   "devDependencies": {
-    "@babel/core": "^7.12.13",
+    "@babel/core": "^7.14.3",
-    "@babel/register": "^7.12.13",
+    "@babel/register": "^7.13.16",
-    "@babel/runtime": "^7.12.13",
+    "@babel/runtime": "^7.14.0",
-    "@polkadot/dev": "^0.61.25",
+    "@polkadot/dev": "^0.62.16",
-    "@polkadot/ts": "^0.3.59",
+    "@polkadot/ts": "^0.3.66",
     "@polkadot/typegen": "workspace:packages/typegen",
-    "@types/jest": "^26.0.20",
+    "@types/jest": "^26.0.23",
     "copyfiles": "^2.4.1"
   },
-  "version": "3.8.1"
+  "version": "4.11.1"
 }

packages/api-contract/README.md

@@ -8,7 +8,7 @@ import { Abi } from '@polkadot/api-contract';
 
 const wsProvider = new WsProvider(<...Node Url...>);
 const api = await ApiPromise.create({ provider: wsProvider });
-const abi = new Abi(api.registry, <...JSON ABI...>);
+const abi = new Abi(<...JSON ABI...>, api.registry.getChainProperties());
 
 api.tx.contracts
   .call(<contract addr>, <value>, <max gas>, abi.messages.<method name>(<...params...>))

packages/api-contract/package.json

@@ -1,9 +1,16 @@
 {
   "name": "@polkadot/api-contract",
-  "version": "3.8.1",
+  "version": "4.11.1",
+  "type": "module",
   "description": "Interfaces for interacting with contracts and contract ABIs",
   "main": "index.js",
-  "sideEffects": false,
+  "sideEffects": [
+    "./detectPackage.js",
+    "./detectPackage.cjs"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
   "contributors": [],
@@ -12,11 +19,11 @@
   "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.12.13",
+    "@babel/runtime": "^7.14.0",
-    "@polkadot/api": "3.8.1",
+    "@polkadot/api": "4.11.1",
-    "@polkadot/types": "3.8.1",
+    "@polkadot/types": "4.11.1",
-    "@polkadot/util": "^5.6.1",
+    "@polkadot/util": "^6.5.1",
-    "@polkadot/x-rxjs": "^5.6.1",
+    "@polkadot/x-rxjs": "^6.5.1",
     "bn.js": "^4.11.9"
   }
 }

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

@@ -1,10 +1,18 @@
 // Copyright 2017-2021 @polkadot/api-contract authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { blake2AsHex } from '@polkadot/util-crypto';
+
 import abis from '../test/contracts';
 import { Abi } from '.';
 
 interface JSONAbi {
+  source: {
+    compiler: string,
+    hash: string,
+    language: string,
+    wasm: string
+  },
   spec: {
     messages: {
       name: string[] | string
@@ -27,4 +35,18 @@ describe('Abi', (): void => {
       }
     });
   });
+
+  it('has the correct hash for the source', (): void => {
+    const bundle = abis.ink_flipperBundle as JSONAbi;
+    const abi = new Abi(bundle as any);
+
+    // manual
+    expect(bundle.source.hash).toEqual(blake2AsHex(bundle.source.wasm));
+
+    // the Codec hash
+    expect(bundle.source.hash).toEqual(abi.project.source.wasm.hash.toHex());
+
+    // the hash as per the actual Abi
+    expect(bundle.source.hash).toEqual(abi.project.source.wasmHash.toHex());
+  });
 });

packages/api-contract/src/Abi.ts

@@ -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;
       }
@@ -143,6 +141,7 @@ 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,
@@ -151,11 +150,12 @@ export class Abi {
         args: this.#decodeArgs(args, data),
         message
       }),
-      identifier: spec.name.toString(),
+      identifier,
       index,
+      method: stringCamelCase(identifier),
       selector: spec.selector,
-      toU8a: (params: CodecArg[], additional?: Uint8Array) =>
+      toU8a: (params: CodecArg[]) =>
-        this.#encodeArgs(spec, args, params, additional)
+        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 => {
+  #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}`);
+    assert(data.length === args.length, () => `Expected ${args.length} arguments to contract message '${name.toString()}', found ${data.length}`);
 
     return compactAddLength(
       u8aConcat(
         this.registry.createType('ContractSelector', selector).toU8a(),
-        ...args.map(({ type }, index) => this.registry.createType(type.type as 'Text', data[index]).toU8a()),
+        ...args.map(({ type }, index) => this.registry.createType(type.type as 'Text', data[index]).toU8a())
-        additional
       )
     );
   }

packages/api-contract/src/MetaRegistry.ts

@@ -14,8 +14,8 @@ interface PartialTypeSpec {
 }
 
 // convert the offset into project-specific, index-1
-export function getRegistryOffset (id: SiLookupTypeId): number {
+export function getRegistryOffset (id: SiLookupTypeId, typeOffset: number): number {
-  return id.toNumber() - 1;
+  return id.toNumber() - typeOffset;
 }
 
 const PRIMITIVE_ALIAS: Record<string, keyof InterfaceTypes> = {
@@ -28,11 +28,16 @@ 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();
 
+    // type indexes are 1-based pre-1.0 and 0-based post-1.0
+    this.typeOffset = metadataVersion.split('.')[0] === '0' ? 1 : 0;
+
     if (chainProperties) {
       this.setChainProperties(chainProperties);
     }
@@ -43,7 +48,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 +83,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);
@@ -128,7 +136,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 +152,27 @@ 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() } : {})
+        ...(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,

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

@@ -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,6 @@ 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(isFunction(api.rx.tx.contracts?.instantiateWithCode), 'You need to connect to a node with a V3 contracts module. Your node does not expose api.tx.contracts.instantiateWithCode on this instance');
   }
 }

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

@@ -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[c.method])) {
-
+        this.#tx[c.method] = createBluePrintTx((o, p) => this.#deploy(c, o, p));
-      if (isUndefined(this.#tx[messageName])) {
-        this.#tx[messageName] = 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>> => {
+  #deploy = (constructorOrId: AbiConstructor | string | number, { gasLimit = BN_ZERO, salt, value = BN_ZERO }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, BlueprintSubmittableResult<ApiType>> => {
-    const encodedSalt = encodeSalt(salt);
+    return this.api.tx.contracts
-    const withSalt = this.api.tx.contracts.instantiate.meta.args.length === 5;
+      .instantiate(
-    const encoded = this.abi.findConstructor(constructorOrId).toU8a(params, withSalt ? EMPTY_SALT : encodedSalt);
+        value,
-    const tx = withSalt
+        gasLimit,
-      ? this.api.tx.contracts.instantiate(value, gasLimit, this.codeHash, encoded, encodedSalt)
+        this.codeHash,
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        this.abi.findConstructor(constructorOrId).toU8a(params),
-      // @ts-ignore old style with salt included
+        encodeSalt(salt)
-      : this.api.tx.contracts.instantiate(value, gasLimit, this.codeHash, encoded);
+      )
-
+      .withResultTransform((result: ISubmittableResult) =>
-    return tx.withResultTransform((result: ISubmittableResult) =>
+        new BlueprintSubmittableResult(result, applyOnEvent(result, ['Instantiated'], ([record]: EventRecord[]) =>
-      new BlueprintSubmittableResult(result, applyOnEvent(result, ['Instantiated'], ([record]: EventRecord[]) =>
+          new Contract<ApiType>(this.api, this.abi, record.event.data[1] as AccountId, this._decorateMethod)
-        new Contract<ApiType>(this.api, this.abi, record.event.data[1] as AccountId, this._decorateMethod)
+        ))
-      ))
+      );
-    );
   }
 }

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

@@ -3,22 +3,21 @@
 
 import type { SubmittableExtrinsic } from '@polkadot/api/submittable/types';
 import type { ApiTypes, DecorateMethod } from '@polkadot/api/types';
-import type { EventRecord, Hash } from '@polkadot/types/interfaces';
+import type { EventRecord } from '@polkadot/types/interfaces';
 import type { AnyJson, CodecArg, ISubmittableResult } from '@polkadot/types/types';
 import type { AbiConstructor, BlueprintOptions } from '../types';
 import type { MapConstructorExec } from './types';
 
 import { SubmittableResult } from '@polkadot/api';
 import { ApiBase } from '@polkadot/api/base';
-import { assert, compactAddLength, isFunction, isUndefined, isWasm, stringCamelCase, u8aToU8a } from '@polkadot/util';
+import { assert, BN_ZERO, compactAddLength, isUndefined, isWasm, u8aToU8a } from '@polkadot/util';
-import { blake2AsU8a } from '@polkadot/util-crypto';
 
 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';
+import { createBluePrintTx, encodeSalt } from './util';
 
 export class CodeSubmittableResult<ApiType extends ApiTypes> extends SubmittableResult {
   public readonly blueprint?: Blueprint<ApiType>;
@@ -47,77 +46,35 @@ 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[c.method])) {
-
+        this.#tx[c.method] = createBluePrintTx((o, p) => this.#instantiate(c, o, p));
-      if (isUndefined(this.#tx[messageName])) {
-        this.#tx[messageName] = createBluePrintTx((o, p) => this.#instantiate(c, o, p));
       }
     });
   }
 
-  /**
-   * @description Deploy the code bundle, creating a Blueprint.
-   * @deprecated Use the `code.tx.<constructor>(...) format to put code and deploy
-   */
-  public createBlueprint (): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> {
-    return this.api.tx.contracts
-      .putCode(compactAddLength(this.code))
-      .withResultTransform((result: ISubmittableResult) =>
-        new CodeSubmittableResult(result, applyOnEvent(result, ['CodeStored'], ([record]: EventRecord[]) =>
-          new Blueprint<ApiType>(this.api, this.abi, record.event.data[0] as Hash, this._decorateMethod)
-        ))
-      );
-  }
-
-  /**
-   * @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>> {
-    return this.#instantiate(constructorOrId, options, params);
-  }
-
   public get tx (): MapConstructorExec<ApiType> {
     return this.#tx;
   }
 
-  #instantiate = (constructorOrId: AbiConstructor | string | number, options: 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 isFunction(this.api.tx.contracts.instantiateWithCode)
-      ? this.#instantiateSingle(constructorOrId, options, params)
-      : this.#instantiateBatch(constructorOrId, options, params);
-  }
-
-  #instantiateSingle = (constructorOrId: AbiConstructor | string | number, { gasLimit = 0, salt, value = 0 }: 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))
+      .instantiateWithCode(
-      .withResultTransform(this.#transformEvents);
+        value,
-  }
+        gasLimit,
-
+        compactAddLength(this.code),
-  #instantiateBatch = (constructorOrId: AbiConstructor | string | number, { gasLimit = 0, salt, value = 0 }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> => {
+        this.abi.findConstructor(constructorOrId).toU8a(params),
-    const encodedSalt = encodeSalt(salt);
+        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);
+      .withResultTransform((result: ISubmittableResult) =>
-    const codeHash = blake2AsU8a(this.code);
+        new CodeSubmittableResult(result, ...(applyOnEvent(result, ['CodeStored', 'Instantiated'], (records: EventRecord[]) =>
-
+          records.reduce<[Blueprint<ApiType>?, Contract<ApiType>?]>(([blueprint, contract], { event }) =>
-    return this.api.tx.utility.batch([
+            this.api.events.contracts.Instantiated.is(event)
-      this.api.tx.contracts.putCode(compactAddLength(this.code)),
+              ? [blueprint, new Contract<ApiType>(this.api, this.abi, event.data[1], this._decorateMethod)]
-      withSalt
+              : this.api.events.contracts.CodeStored.is(event)
-        ? this.api.tx.contracts.instantiate(value, gasLimit, codeHash, encoded, encodedSalt)
+                ? [new Blueprint<ApiType>(this.api, this.abi, event.data[0], this._decorateMethod), contract]
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                : [blueprint, contract],
-        // @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>?])
-    ) || []));
   }
 }

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

@@ -4,25 +4,27 @@
 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 { AccountId, EventRecord, Weight } from '@polkadot/types/interfaces';
-import type { AnyJson, CodecArg, ISubmittableResult, Registry } from '@polkadot/types/types';
+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 type { ContractCallResult, ContractCallSend, ContractQuery, ContractTx, MapMessageQuery, MapMessageTx } from './types';
 
 import BN from 'bn.js';
 
 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_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');
 
 function createQuery <ApiType extends ApiTypes> (fn: (origin: string | AccountId | Uint8Array, options: ContractOptions, params: CodecArg[]) => ContractCallResult<ApiType, ContractCallOutcome>): ContractQuery<ApiType> {
@@ -39,13 +41,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): ContractGeneric<ContractOptions, T> {
-  return (messageOrId: AbiMessage | string | number, options: BigInt | string | number | BN | ContractOptions, ...params: CodecArg[]): T =>
-    isOptions(options)
-      ? fn(messageOrId, options, params)
-      : fn(messageOrId, ...extractOptions(options, params));
-}
-
 export class ContractSubmittableResult extends SubmittableResult {
   public readonly contractEvents?: DecodedEvent[];
 
@@ -56,51 +51,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> = {};
@@ -109,18 +65,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);
-    this.read = createWithId(this.#read);
 
     this.abi.messages.forEach((m): void => {
-      const messageName = stringCamelCase(m.identifier);
+      if (isUndefined(this.#tx[m.method])) {
-
+        this.#tx[m.method] = createTx((o, p) => this.#exec(m, o, p));
-      if (isUndefined(this.#tx[messageName])) {
-        this.#tx[messageName] = createTx((o, p) => this.#exec(m, o, p));
       }
 
-      if (isUndefined(this.#query[messageName])) {
+      if (isUndefined(this.#query[m.method])) {
-        this.#query[messageName] = createQuery((f, o, p) => this.#read(m, o, p).send(f));
+        this.#query[m.method] = createQuery((f, o, p) => this.#read(m, o, p).send(f));
       }
     });
   }
@@ -142,21 +94,27 @@ 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) =>
-        new ContractSubmittableResult(result, applyOnEvent(result, ['ContractExecution'], (records: EventRecord[]) =>
+        // ContractEmitted is the current generation, ContractExecution is the previous generation
+        new ContractSubmittableResult(result, applyOnEvent(result, ['ContractEmitted', 'ContractExecution'], (records: EventRecord[]) =>
           records
             .map(({ event: { data: [, data] } }): DecodedEvent | null => {
               try {
@@ -172,7 +130,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);
@@ -180,24 +138,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({
+        this.api.rx.rpc.contracts
-          dest: this.address,
+          .call({
-          gasLimit: this.#getGas(gasLimit, true),
+            dest: this.address,
-          inputData: message.toU8a(params),
+            gasLimit: this.#getGas(gasLimit, true),
-          origin,
+            inputData: message.toU8a(params),
-          value
+            origin,
-        }).pipe(map((json): ContractCallOutcome => {
+            value
-          const { debugMessage, gasConsumed, result } = mapExecResult(this.registry, json.toJSON());
+          })
-
+          .pipe(
-          return {
+            map(({ debugMessage, gasConsumed, result }): ContractCallOutcome => ({
-            debugMessage,
+              debugMessage,
-            gasConsumed,
+              gasConsumed,
-            output: result.isOk && message.returnType
+              output: result.isOk && message.returnType
-              ? formatData(this.registry, result.asOk.data, message.returnType)
+                ? createTypeUnsafe(this.registry, message.returnType.type, [result.asOk.data.toU8a(true)], { isPedantic: true })
-              : null,
+                : null,
-            result
+              result
-          };
+            }))
-        }))
+          )
       )
     };
   }

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

@@ -11,10 +11,7 @@ export const mockApi = {
   rx: {
     tx: {
       contracts: {
-        instantiate: (): never => {
+        instantiateWithCode: (): never => {
-          throw new Error('mock');
-        },
-        putCode: (): never => {
           throw new Error('mock');
         }
       }

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

@@ -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> {

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

@@ -30,14 +30,12 @@ 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> {
-  const api = await ApiPromise.create();
+  const api = await ApiPromise.create({
+    hasher: (data: Uint8Array): Uint8Array => data
+  });
   const pairs = createTestPairs();
 
   // eslint-disable-next-line @typescript-eslint/no-floating-promises

packages/api-contract/src/detectPackage.ts

@@ -0,0 +1,10 @@
+// Copyright 2017-2021 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { packageInfo as apiInfo } from '@polkadot/api/packageInfo';
+import { packageInfo as typesInfo } from '@polkadot/types/packageInfo';
+import { detectPackage } from '@polkadot/util';
+
+import { packageInfo } from './packageInfo';
+
+detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname, [apiInfo, typesInfo]);

packages/api-contract/src/index.ts

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

packages/api-contract/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Auto-generated by @polkadot/dev, do not edit
+
+export const packageInfo = { name: '@polkadot/api-contract', version: '4.11.1' };

packages/api-contract/src/types.ts

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

packages/api-contract/src/util.ts

@@ -2,24 +2,18 @@
 // 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 { 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' | 'ContractExecution' | 'Instantiated';
+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);

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

@@ -0,0 +1,6 @@
+[
+  {
+    "info": 6,
+    "type": "bool"
+  }
+]

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

@@ -6,5 +6,6 @@ export { default as dns } from './dns.json';
 export { default as erc20 } from './erc20.json';
 export { default as erc721 } from './erc721.json';
 export { default as flipper } from './flipper.json';
+export { default as flipperBundle } from './flipper.contract.json';
 export { default as incrementer } from './incrementer.json';
 export { default as multisigPlain } from './multisig_plain.json';

packages/api-derive/package.json

@@ -1,9 +1,16 @@
 {
   "name": "@polkadot/api-derive",
-  "version": "3.8.1",
+  "version": "4.11.1",
+  "type": "module",
   "description": "Common functions used across Polkadot, derived from RPC calls and storage queries.",
   "main": "index.js",
-  "sideEffects": false,
+  "sideEffects": [
+    "./detectPackage.js",
+    "./detectPackage.cjs"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
   "contributors": [],
@@ -12,17 +19,17 @@
   "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.12.13",
+    "@babel/runtime": "^7.14.0",
-    "@polkadot/api": "3.8.1",
+    "@polkadot/api": "4.11.1",
-    "@polkadot/rpc-core": "3.8.1",
+    "@polkadot/rpc-core": "4.11.1",
-    "@polkadot/types": "3.8.1",
+    "@polkadot/types": "4.11.1",
-    "@polkadot/util": "^5.6.1",
+    "@polkadot/util": "^6.5.1",
-    "@polkadot/util-crypto": "^5.6.1",
+    "@polkadot/util-crypto": "^6.5.1",
-    "@polkadot/x-rxjs": "^5.6.1",
+    "@polkadot/x-rxjs": "^6.5.1",
     "bn.js": "^4.11.9"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^5.6.1",
+    "@polkadot/keyring": "^6.5.1",
-    "@polkadot/rpc-provider": "3.8.1"
+    "@polkadot/rpc-provider": "4.11.1"
   }
 }

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

@@ -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

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

@@ -17,6 +17,12 @@ type BalanceResult = [Balance, Balance, Balance, Balance];
 
 type Result = [Index, BalanceResult[]];
 
+type DeriveCustomAccount = ApiInterfaceRx['derive'] & {
+  [custom: string]: {
+    customAccount?: ApiInterfaceRx['query']['balances']['account']
+  }
+}
+
 function getBalance (api: ApiInterfaceRx, [freeBalance, reservedBalance, frozenFee, frozenMisc]: BalanceResult): DeriveBalancesAccountData {
   return {
     freeBalance,
@@ -55,7 +61,13 @@ function queryBalancesFree (api: ApiInterfaceRx, accountId: AccountId): Observab
 }
 
 function queryBalancesAccount (api: ApiInterfaceRx, accountId: AccountId, modules: string[] = ['balances']): Observable<Result> {
-  const balances = modules.map((m): QueryableStorageMultiArg<'rxjs'> => [api.query[m].account, accountId]);
+  const balances = modules.map(
+    (m): QueryableStorageMultiArg<'rxjs'> => [
+      (api.derive as DeriveCustomAccount)[m]?.customAccount || api.query[m].account,
+      accountId
+    ]
+  );
+
   const extract = (data: AccountData[]) =>
     data.map(({ feeFrozen, free, miscFrozen, reserved }): BalanceResult => [free, reserved, feeFrozen, miscFrozen]);
 
@@ -75,9 +87,11 @@ function queryCurrent (api: ApiInterfaceRx, accountId: AccountId): Observable<Re
       const { feeFrozen, free, miscFrozen, reserved } = (infoOrTuple as AccountInfo).nonce
         ? (infoOrTuple as AccountInfo).data
         : (infoOrTuple as [Index, AccountData])[1];
-      const accountNonce = (infoOrTuple as AccountInfo).nonce || (infoOrTuple as [Index, AccountData])[0];
 
-      return [accountNonce, [[free, reserved, feeFrozen, miscFrozen]]];
+      return [
+        (infoOrTuple as AccountInfo).nonce || (infoOrTuple as [Index, AccountData])[0],
+        [[free, reserved, feeFrozen, miscFrozen]]
+      ];
     })
   );
 }

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

@@ -9,7 +9,7 @@ import type { DeriveBalancesAccount, DeriveBalancesAccountData, DeriveBalancesAl
 
 import BN from 'bn.js';
 
-import { bnMax } from '@polkadot/util';
+import { bnMax, isFunction } from '@polkadot/util';
 import { combineLatest, of } from '@polkadot/x-rxjs';
 import { map, switchMap } from '@polkadot/x-rxjs/operators';
 
@@ -27,6 +27,12 @@ interface AllLocked {
   vestingLocked: Balance
 }
 
+type DeriveCustomLocks = ApiInterfaceRx['derive'] & {
+  [custom: string]: {
+    customLocks?: ApiInterfaceRx['query']['balances']['locks']
+  }
+}
+
 const VESTING_ID = '0x76657374696e6720';
 
 function calcLocked (api: ApiInterfaceRx, bestNumber: BlockNumber, locks: (BalanceLock | BalanceLockTo212)[]): AllLocked {
@@ -38,11 +44,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)));
@@ -54,11 +60,10 @@ function calcLocked (api: ApiInterfaceRx, bestNumber: BlockNumber, locks: (Balan
 
 function calcShared (api: ApiInterfaceRx, bestNumber: BlockNumber, data: DeriveBalancesAccountData, locks: (BalanceLock | BalanceLockTo212)[]): DeriveBalancesAllAccountData {
   const { allLocked, lockedBalance, lockedBreakdown, vestingLocked } = calcLocked(api, bestNumber, locks);
-  const availableBalance = api.registry.createType('Balance', allLocked ? 0 : bnMax(new BN(0), data.freeBalance.sub(lockedBalance)));
 
   return {
     ...data,
-    availableBalance,
+    availableBalance: api.registry.createType('Balance', allLocked ? 0 : bnMax(new BN(0), data.freeBalance.sub(lockedBalance))),
     lockedBalance,
     lockedBreakdown,
     vestingLocked
@@ -75,8 +80,6 @@ function calcBalances (api: ApiInterfaceRx, [data, bestNumber, [vesting, allLock
   const vestedNow = isStarted ? perBlock.mul(bestNumber.sub(startingBlock)) : new BN(0);
   const vestedBalance = vestedNow.gt(vestingTotal) ? vestingTotal : api.registry.createType('Balance', vestedNow);
   const isVesting = isStarted && !shared.vestingLocked.isZero();
-  const vestedClaimable = api.registry.createType('Balance', isVesting ? shared.vestingLocked.sub(vestingTotal.sub(vestedBalance)) : 0);
-  const vestingEndBlock = api.registry.createType('BlockNumber', isVesting ? vestingTotal.div(perBlock).add(startingBlock) : 0);
 
   return {
     ...shared,
@@ -85,8 +88,8 @@ function calcBalances (api: ApiInterfaceRx, [data, bestNumber, [vesting, allLock
     additional: allLocks.filter((_, index) => index !== 0).map((l, index) => calcShared(api, bestNumber, data.additional[index], l)),
     isVesting,
     vestedBalance,
-    vestedClaimable,
+    vestedClaimable: api.registry.createType('Balance', isVesting ? shared.vestingLocked.sub(vestingTotal.sub(vestedBalance)) : 0),
-    vestingEndBlock,
+    vestingEndBlock: api.registry.createType('BlockNumber', isVesting ? vestingTotal.div(perBlock).add(startingBlock) : 0),
     vestingPerBlock: perBlock,
     vestingTotal
   };
@@ -112,11 +115,17 @@ function queryOld (api: ApiInterfaceRx, accountId: AccountId): Observable<Result
   );
 }
 
+const isNonNullable = <T>(nullable: T): nullable is NonNullable<T> => !!nullable;
+
 // current (balances, vesting)
 function queryCurrent (api: ApiInterfaceRx, accountId: AccountId, balanceInstances: string[] = ['balances']): Observable<ResultBalance> {
-  const lockCalls = balanceInstances.map((m) => api.query[m].locks);
+  const lockCalls = balanceInstances.map(
+    (m): ApiInterfaceRx['query']['balances']['locks'] | undefined =>
+      (api.derive as DeriveCustomLocks)[m]?.customLocks || api.query[m as 'balances']?.locks
+  );
+
   const lockEmpty = lockCalls.map((c) => !c);
-  const lockQueries = lockCalls.filter((c) => c).map((c): QueryableStorageMultiArg<'rxjs'> => [c, accountId]);
+  const lockQueries = lockCalls.filter(isNonNullable).map((c): QueryableStorageMultiArg<'rxjs'> => [c, accountId]);
 
   return (
     api.query.vesting?.vesting
@@ -166,7 +175,7 @@ export function all (instanceId: string, api: ApiInterfaceRx): (address: Account
           ? combineLatest([
             of(account),
             api.derive.chain.bestNumber(),
-            api.query.system?.account || api.query.balances?.account
+            isFunction(api.query.system?.account) || isFunction(api.query.balances?.account)
               ? queryCurrent(api, account.accountId, balanceInstances)
               : queryOld(api, account.accountId)
           ])

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

@@ -23,7 +23,7 @@ describe('bounties derive', () => {
   let storageKey: (index: number) => StorageKey;
   let defaultBounty: () => Bounty;
   let emptyOption: <T extends Codec> (typeName: keyof InterfaceTypes) => Option<T>;
-  let optionOf: <T extends Codec> (value: T)=> Option<T>;
+  let optionOf: <T extends Codec> (value: T) => Option<T>;
   let bountyIndex: (index: number) => BountyIndex;
   let proposalIndex: (index: number) => ProposalIndex;
   let bytes: (value: string) => Bytes;

packages/api-derive/src/bounties/bounties.ts

@@ -3,7 +3,7 @@
 
 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { DeriveBounties, DeriveCollectiveProposal } from '@polkadot/api-derive/types';
-import type { Bytes, Option, StorageKey } from '@polkadot/types';
+import type { Bytes, Option } from '@polkadot/types';
 import type { Bounty, BountyIndex, ProposalIndex } from '@polkadot/types/interfaces';
 
 import { memo } from '@polkadot/api-derive/util';
@@ -32,21 +32,25 @@ function parseResult ([maybeBounties, maybeDescriptions, ids, bountyProposals]:
 }
 
 export function bounties (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveBounties> {
-  const bountyBase = api.query.bounties ? api.query.bounties : api.query.treasury;
+  const bountyBase = api.query.bounties || api.query.treasury;
 
   return memo(instanceId, (): Observable<DeriveBounties> =>
     combineLatest([
       bountyBase.bountyCount<BountyIndex>(),
-      api.query.council ? api.query.council.proposalCount<ProposalIndex>() : of(0)
+      api.query.council
+        ? api.query.council.proposalCount<ProposalIndex>()
+        : of(0)
     ]).pipe(
       switchMap(() =>
         combineLatest([
-          bountyBase.bounties.keys(),
+          bountyBase.bounties.keys<[BountyIndex]>(),
-          api.derive.council ? api.derive.council.proposals() : of([])
+          api.derive.council
+            ? api.derive.council.proposals()
+            : of([])
         ])
       ),
       switchMap(([keys, proposals]): Observable<Result> => {
-        const ids = (keys as StorageKey<[BountyIndex]>[]).map(({ args: [id] }) => id);
+        const ids = keys.map(({ args: [id] }) => id);
 
         return combineLatest([
           bountyBase.bounties.multi<Option<Bounty>>(ids),

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

@@ -3,11 +3,12 @@
 
 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { Observable } from '@polkadot/x-rxjs';
+import type { SignedBlockExtended } from '../type/types';
 
 import { combineLatest, of } from '@polkadot/x-rxjs';
 import { catchError, map } from '@polkadot/x-rxjs/operators';
 
-import { SignedBlockExtended } from '../type';
+import { createSignedBlockExtended } from '../type';
 import { memo } from '../util';
 
 /**
@@ -33,7 +34,7 @@ export function getBlock (instanceId: string, api: ApiInterfaceRx): (hash: Uint8
         : of([])
     ]).pipe(
       map(([signedBlock, events, validators]): SignedBlockExtended =>
-        new SignedBlockExtended(api.registry, signedBlock, events, validators)
+        createSignedBlockExtended(api.registry, signedBlock, events, validators)
       ),
       catchError((): Observable<undefined> =>
         // where rpc.chain.getHeader throws, we will land here - it can happen that

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

@@ -3,11 +3,12 @@
 
 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { Observable } from '@polkadot/x-rxjs';
+import type { HeaderExtended } from '../type/types';
 
 import { combineLatest, of } from '@polkadot/x-rxjs';
 import { catchError, map } from '@polkadot/x-rxjs/operators';
 
-import { HeaderExtended } from '../type';
+import { createHeaderExtended } from '../type';
 import { memo } from '../util';
 
 /**
@@ -33,7 +34,7 @@ export function getHeader (instanceId: string, api: ApiInterfaceRx): (hash: Uint
         : of([])
     ]).pipe(
       map(([header, validators]): HeaderExtended =>
-        new HeaderExtended(api.registry, header, validators)
+        createHeaderExtended(header.registry, header, validators)
       ),
       catchError((): Observable<undefined> =>
         // where rpc.chain.getHeader throws, we will land here - it can happen that

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

@@ -2,13 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { ApiInterfaceRx } from '@polkadot/api/types';
-import type { AccountId, EventRecord, SignedBlock } from '@polkadot/types/interfaces';
+import type { Vec } from '@polkadot/types';
+import type { EventRecord, SignedBlock } from '@polkadot/types/interfaces';
 import type { Observable } from '@polkadot/x-rxjs';
+import type { HeaderExtended, SignedBlockExtended } from '../type/types';
 
 import { combineLatest, of } from '@polkadot/x-rxjs';
 import { map, switchMap } from '@polkadot/x-rxjs/operators';
 
-import { SignedBlockExtended } from '../type';
+import { createSignedBlockExtended } from '../type';
 import { memo } from '../util';
 
 /**
@@ -18,17 +20,17 @@ import { memo } from '../util';
 export function subscribeNewBlocks (instanceId: string, api: ApiInterfaceRx): () => Observable<SignedBlockExtended> {
   return memo(instanceId, (): Observable<SignedBlockExtended> =>
     api.derive.chain.subscribeNewHeads().pipe(
-      switchMap((header): Observable<[SignedBlock, EventRecord[], AccountId[] | undefined]> => {
+      switchMap((header): Observable<[SignedBlock, Vec<EventRecord>, HeaderExtended]> => {
-        const blockHash = header.hash;
+        const blockHash = header.createdAtHash || header.hash;
 
         return combineLatest(
           api.rpc.chain.getBlock(blockHash),
           api.query.system.events.at(blockHash),
-          of(header.validators)
+          of(header)
         );
       }),
-      map(([block, events, validators]) =>
+      map(([block, events, header]) =>
-        new SignedBlockExtended(api.registry, block, events, validators)
+        createSignedBlockExtended(block.registry, block, events, header.validators)
       )
     )
   );

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

@@ -3,11 +3,12 @@
 
 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { Observable } from '@polkadot/x-rxjs';
+import type { HeaderExtended } from '../type/types';
 
 import { combineLatest, of } from '@polkadot/x-rxjs';
 import { map } from '@polkadot/x-rxjs/operators';
 
-import { HeaderExtended } from '../type';
+import { createHeaderExtended } from '../type';
 import { memo } from '../util';
 
 /**
@@ -29,10 +30,13 @@ export function subscribeNewHeads (instanceId: string, api: ApiInterfaceRx): ()
       api.rpc.chain.subscribeNewHeads(),
       api.query.session
         ? api.query.session.validators()
-        : of([])
+        : of(undefined)
     ]).pipe(
-      map(([header, validators]): HeaderExtended =>
+      map(([header, validators]): HeaderExtended => {
-        new HeaderExtended(api.registry, header, validators)
+        header.createdAtHash = header.hash;
-      )
+
-    ));
+        return createHeaderExtended(header.registry, header, validators);
+      })
+    )
+  );
 }

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

@@ -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> =>

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

@@ -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'));
 }

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

@@ -3,7 +3,7 @@
 
 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { Vec } from '@polkadot/types';
-import type { AccountId, Balance } from '@polkadot/types/interfaces';
+import type { AccountId, Balance, Voter } from '@polkadot/types/interfaces';
 import type { ITuple } from '@polkadot/types/types';
 import type { Observable } from '@polkadot/x-rxjs';
 import type { DeriveCouncilVote, DeriveCouncilVotes } from '../types';
@@ -13,18 +13,25 @@ import { map } from '@polkadot/x-rxjs/operators';
 
 import { memo } from '../util';
 
+// Voter is current tuple is 2.x-era
+type VoteEntry = Voter | ITuple<[Balance, Vec<AccountId>]>;
+
+function isVoter (value: VoteEntry): value is Voter {
+  return !Array.isArray(value);
+}
+
 function retrieveStakeOf (api: ApiInterfaceRx): Observable<[AccountId, Balance][]> {
-  return (api.query.electionsPhragmen || api.query.elections).stakeOf.entries<Balance>().pipe(
+  return (api.query.phragmenElection || api.query.electionsPhragmen || api.query.elections).stakeOf.entries<Balance, [AccountId]>().pipe(
     map((entries) =>
-      entries.map(([key, stake]) => [key.args[0] as AccountId, stake])
+      entries.map(([{ args: [accountId] }, stake]) => [accountId, stake])
     )
   );
 }
 
 function retrieveVoteOf (api: ApiInterfaceRx): Observable<[AccountId, AccountId[]][]> {
-  return (api.query.electionsPhragmen || api.query.elections).votesOf.entries<Vec<AccountId>>().pipe(
+  return (api.query.phragmenElection || api.query.electionsPhragmen || api.query.elections).votesOf.entries<Vec<AccountId>, [AccountId]>().pipe(
     map((entries) =>
-      entries.map(([key, votes]) => [key.args[0] as AccountId, votes])
+      entries.map(([{ args: [accountId] }, votes]) => [accountId, votes])
     )
   );
 }
@@ -54,20 +61,23 @@ 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<ITuple<[Balance, Vec<AccountId>]>>().pipe(
+  return elections.voting.entries<VoteEntry, [AccountId]>().pipe(
     map((entries): DeriveCouncilVotes =>
-      entries.map(([key, [stake, votes]]): [AccountId, DeriveCouncilVote] =>
+      entries.map(([{ args: [accountId] }, value]): [AccountId, DeriveCouncilVote] => [
-        [key.args[0] as AccountId, { stake, votes }]
+        accountId,
-      )
+        isVoter(value)
+          ? { stake: value.stake, votes: value.votes }
+          : { stake: value[0], votes: value[1] }
+      ])
     )
   );
 }
 
 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)
   );

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

@@ -51,7 +51,7 @@ function schedulerEntries (api: ApiInterfaceRx): Observable<[BlockNumber[], Opti
       api.query.scheduler.agenda.keys()
     ),
     switchMap((keys) => {
-      const blockNumbers = keys.map((key) => key.args[0]);
+      const blockNumbers = keys.map(({ args: [blockNumber] }) => blockNumber);
 
       return combineLatest([
         of(blockNumbers),

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

@@ -51,7 +51,7 @@ function parse ([proposals, images, optDepositors]: Result): DeriveProposal[] {
 
 export function proposals (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveProposal[]> {
   return memo(instanceId, (): Observable<DeriveProposal[]> =>
-    api.query.democracy?.publicProps && api.query.democracy?.preimages
+    isFunction(api.query.democracy?.publicProps) && isFunction(api.query.democracy?.preimages)
       ? api.query.democracy.publicProps<Proposals>().pipe(
         switchMap((proposals) =>
           combineLatest([

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

@@ -67,9 +67,9 @@ function extractVotes (mapped: [AccountId, Voting][], referendumId: BN): DeriveR
 }
 
 function votesCurr (api: ApiInterfaceRx, referendumId: BN): Observable<DeriveReferendumVote[]> {
-  return api.query.democracy.votingOf.entries<Voting>().pipe(
+  return api.query.democracy.votingOf.entries<Voting, [AccountId]>().pipe(
     map((allVoting): DeriveReferendumVote[] => {
-      const mapped = allVoting.map(([key, voting]): [AccountId, Voting] => [key.args[0], voting]);
+      const mapped = allVoting.map(([{ args: [accountId] }, voting]): [AccountId, Voting] => [accountId, voting]);
       const votes = extractVotes(mapped, referendumId);
       const delegations = mapped
         .filter(([, voting]) => voting.isDelegating)

packages/api-derive/src/detectPackage.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2021 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { packageInfo as apiInfo } from '@polkadot/api/packageInfo';
+import { packageInfo as coreInfo } from '@polkadot/rpc-core/packageInfo';
+import { packageInfo as typesInfo } from '@polkadot/types/packageInfo';
+import { detectPackage } from '@polkadot/util';
+
+import { packageInfo } from './packageInfo';
+
+detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname, [apiInfo, coreInfo, typesInfo]);

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

@@ -3,7 +3,7 @@
 
 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { u32, Vec } from '@polkadot/types';
-import type { AccountId, Balance, BlockNumber } from '@polkadot/types/interfaces';
+import type { AccountId, Balance, BlockNumber, SeatHolder } from '@polkadot/types/interfaces';
 import type { ITuple } from '@polkadot/types/types';
 import type { Observable } from '@polkadot/x-rxjs';
 import type { DeriveElectionsInfo } from './types';
@@ -12,14 +12,43 @@ import { map } from '@polkadot/x-rxjs/operators';
 
 import { memo } from '../util';
 
-function sortAccounts ([, balanceA]: ITuple<[AccountId, Balance]>, [, balanceB]: ITuple<[AccountId, Balance]>): number {
+// SeatHolder is current tuple is 2.x-era Substrate
+type Member = SeatHolder | ITuple<[AccountId, Balance]>;
+
+type Candidate = AccountId | ITuple<[AccountId, Balance]>;
+
+function isSeatHolder (value: Member): value is SeatHolder {
+  return !Array.isArray(value);
+}
+
+function isCandidateTuple (value: Candidate): value is ITuple<[AccountId, Balance]> {
+  return Array.isArray(value);
+}
+
+function getAccountTuple (value: Member): [AccountId, Balance] {
+  return isSeatHolder(value)
+    ? [value.who, value.stake]
+    : value;
+}
+
+function getCandidate (value: Candidate): AccountId {
+  return isCandidateTuple(value)
+    ? value[0]
+    : value;
+}
+
+function sortAccounts ([, balanceA]: [AccountId, Balance], [, balanceB]: [AccountId, Balance]): number {
   return balanceB.cmp(balanceA);
 }
 
 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<AccountId>, Vec<ITuple<[AccountId, Balance]>>, Vec<ITuple<[AccountId, Balance]>>]>([
+  return api.queryMulti<[Vec<AccountId>, Vec<Candidate>, Vec<Member>, Vec<Member>]>([
     api.query.council.members,
     api.query[section].candidates,
     api.query[section].members,
@@ -28,13 +57,13 @@ function queryElections (api: ApiInterfaceRx): Observable<DeriveElectionsInfo> {
     map(([councilMembers, candidates, members, runnersUp]): DeriveElectionsInfo => ({
       candidacyBond: api.consts[section].candidacyBond as Balance,
       candidateCount: api.registry.createType('u32', candidates.length),
-      candidates,
+      candidates: candidates.map(getCandidate),
       desiredRunnersUp: api.consts[section].desiredRunnersUp as u32,
       desiredSeats: api.consts[section].desiredMembers as u32,
       members: members.length
-        ? members.sort(sortAccounts)
+        ? members.map(getAccountTuple).sort(sortAccounts)
         : councilMembers.map((accountId): [AccountId, Balance] => [accountId, api.registry.createType('Balance')]),
-      runnersUp: runnersUp.sort(sortAccounts),
+      runnersUp: runnersUp.map(getAccountTuple).sort(sortAccounts),
       termDuration: api.consts[section].termDuration as BlockNumber,
       votingBond: api.consts[section].votingBond as Balance
     }))

packages/api-derive/src/index.ts

@@ -1,6 +1,8 @@
 // Copyright 2017-2021 @polkadot/api-derive authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import './detectPackage';
+
 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { AnyFunction } from '@polkadot/types/types';
 import type { Observable } from '@polkadot/x-rxjs';
@@ -14,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';
@@ -22,9 +25,10 @@ import * as technicalCommittee from './technicalCommittee';
 import * as treasury from './treasury';
 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
@@ -44,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'],

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

@@ -0,0 +1,4 @@
+// Copyright 2017-2021 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './proposals';

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

@@ -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'));
+}

packages/api-derive/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Auto-generated by @polkadot/dev, do not edit
+
+export const packageInfo = { name: '@polkadot/api-derive', version: '4.11.1' };

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

@@ -13,7 +13,7 @@ import { map } from '@polkadot/x-rxjs/operators';
 import { memo } from '../util';
 
 // parse into Indexes
-function parse ([activeEra, activeEraStart, currentEra, currentIndex, validatorCount]: [EraIndex, Option<Moment>, EraIndex, SessionIndex, u32]): DeriveSessionIndexes {
+function parse ([currentIndex, activeEra, activeEraStart, currentEra, validatorCount]: [SessionIndex, EraIndex, Option<Moment>, EraIndex, u32]): DeriveSessionIndexes {
   return {
     activeEra,
     activeEraStart,
@@ -24,42 +24,57 @@ function parse ([activeEra, activeEraStart, currentEra, currentIndex, validatorC
 }
 
 // query based on latest
-function query (api: ApiInterfaceRx): Observable<DeriveSessionIndexes> {
+function queryStaking (api: ApiInterfaceRx): Observable<DeriveSessionIndexes> {
-  return api.queryMulti<[Option<ActiveEraInfo>, Option<EraIndex>, SessionIndex, u32]>([
+  return api.queryMulti<[SessionIndex, Option<ActiveEraInfo>, Option<EraIndex>, u32]>([
+    api.query.session.currentIndex,
     api.query.staking.activeEra,
     api.query.staking.currentEra,
-    api.query.session.currentIndex,
     api.query.staking.validatorCount
   ]).pipe(
-    map(([activeOpt, currentEra, currentIndex, validatorCount]): DeriveSessionIndexes => {
+    map(([currentIndex, activeOpt, currentEra, validatorCount]): DeriveSessionIndexes => {
       const { index, start } = activeOpt.unwrapOrDefault();
 
       return parse([
+        currentIndex,
         index,
         start,
         currentEra.unwrapOrDefault(),
-        currentIndex,
         validatorCount
       ]);
     })
   );
 }
 
+// query based on latest
+function querySession (api: ApiInterfaceRx): Observable<DeriveSessionIndexes> {
+  return api.query.session.currentIndex().pipe(
+    map((currentIndex): DeriveSessionIndexes => parse([
+      currentIndex,
+      api.registry.createType('EraIndex'),
+      api.registry.createType('Option<Moment>'),
+      api.registry.createType('EraIndex'),
+      api.registry.createType('u32')
+    ]))
+  );
+}
+
 // empty set when none is available
 function empty (api: ApiInterfaceRx): Observable<DeriveSessionIndexes> {
   return of(parse([
+    api.registry.createType('SessionIndex', 1),
     api.registry.createType('EraIndex'),
     api.registry.createType('Option<Moment>'),
     api.registry.createType('EraIndex'),
-    api.registry.createType('SessionIndex', 1),
     api.registry.createType('u32')
   ]));
 }
 
 export function indexes (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveSessionIndexes> {
   return memo(instanceId, (): Observable<DeriveSessionIndexes> =>
-    api.query.session && api.query.staking
+    api.query.session
-      ? query(api)
+      ? api.query.staking
+        ? queryStaking(api)
+        : querySession(api)
       : empty(api)
   );
 }

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

@@ -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
+    api.derive.session.indexes().pipe(
-      ? queryBabe(api)
+      map((indexes) => {
-      : queryAura(api)
+        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
+        };
+      })
+    )
   );
 }

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

@@ -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)

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

@@ -2,9 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { ApiInterfaceRx } from '@polkadot/api/types';
-import type { bool, Option, Vec } from '@polkadot/types';
+import type { AccountId } from '@polkadot/types/interfaces';
-import type { AccountId, Balance, BlockNumber, SocietyVote, StrikeCount, VouchingStatus } from '@polkadot/types/interfaces';
-import type { ITuple } from '@polkadot/types/types';
 import type { Observable } from '@polkadot/x-rxjs';
 import type { DeriveSocietyMember } from '../types';
 
@@ -12,28 +10,13 @@ import { map } from '@polkadot/x-rxjs/operators';
 
 import { memo } from '../util';
 
-type Result = [Vec<ITuple<[BlockNumber, Balance]>>, StrikeCount, Option<SocietyVote>, bool, Option<VouchingStatus>];
-
 /**
  * @description Get the member info for a society
  */
 export function member (instanceId: string, api: ApiInterfaceRx): (accountId: AccountId) => Observable<DeriveSocietyMember> {
   return memo(instanceId, (accountId: AccountId): Observable<DeriveSocietyMember> =>
-    api.queryMulti<Result>([
+    api.derive.society._members([accountId]).pipe(
-      [api.query.society.payouts, accountId],
+      map(([result]) => result)
-      [api.query.society.strikes, accountId],
-      [api.query.society.defenderVotes, accountId],
-      [api.query.society.suspendedMembers, accountId],
-      [api.query.society.vouching, accountId]
-    ]).pipe(
-      map(([payouts, strikes, defenderVotes, suspended, vouching]: Result): DeriveSocietyMember => ({
-        accountId,
-        isSuspended: suspended.isTrue,
-        payouts,
-        strikes,
-        vote: defenderVotes.unwrapOr(undefined),
-        vouching: vouching.unwrapOr(undefined)
-      }))
     )
   );
 }

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

@@ -2,28 +2,51 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { ApiInterfaceRx } from '@polkadot/api/types';
-import type { AccountId } from '@polkadot/types/interfaces';
+import type { bool, Option, Vec } from '@polkadot/types';
+import type { AccountId, Balance, BlockNumber, SocietyVote, StrikeCount, VouchingStatus } from '@polkadot/types/interfaces';
+import type { ITuple } from '@polkadot/types/types';
 import type { Observable } from '@polkadot/x-rxjs';
 import type { DeriveSocietyMember } from '../types';
 
-import { combineLatest } from '@polkadot/x-rxjs';
+import { combineLatest, of } from '@polkadot/x-rxjs';
-import { switchMap } from '@polkadot/x-rxjs/operators';
+import { map, switchMap } from '@polkadot/x-rxjs/operators';
 
 import { memo } from '../util';
 
+type Result = [AccountId[], Vec<ITuple<[BlockNumber, Balance]>>[], StrikeCount[], Option<SocietyVote>[], bool[], Option<VouchingStatus>[]];
+
+export function _members (instanceId: string, api: ApiInterfaceRx): (accountIds: AccountId[]) => Observable<DeriveSocietyMember[]> {
+  return memo(instanceId, (accountIds: AccountId[]): Observable<DeriveSocietyMember[]> =>
+    combineLatest<Result>([
+      of(accountIds),
+      api.query.society.payouts.multi(accountIds),
+      api.query.society.strikes.multi(accountIds),
+      api.query.society.defenderVotes.multi(accountIds),
+      api.query.society.suspendedMembers.multi(accountIds),
+      api.query.society.vouching.multi(accountIds)
+    ]).pipe(
+      map(([accountIds, payouts, strikes, defenderVotes, suspended, vouching]) =>
+        accountIds.map((accountId, index) => ({
+          accountId,
+          isDefenderVoter: defenderVotes[index].isSome,
+          isSuspended: suspended[index].isTrue,
+          payouts: payouts[index],
+          strikes: strikes[index],
+          vote: defenderVotes[index].unwrapOr(undefined),
+          vouching: vouching[index].unwrapOr(undefined)
+        }))
+      )
+    )
+  );
+}
+
 /**
  * @description Get the member info for a society
  */
 export function members (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveSocietyMember[]> {
   return memo(instanceId, (): Observable<DeriveSocietyMember[]> =>
     api.query.society.members<AccountId[]>().pipe(
-      switchMap((members): Observable<DeriveSocietyMember[]> =>
+      switchMap((members) => api.derive.society._members(members))
-        combineLatest(
-          members.map((accountId): Observable<DeriveSocietyMember> =>
-            api.derive.society.member(accountId)
-          )
-        )
-      )
     )
   );
 }

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

@@ -3,7 +3,7 @@
 
 import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { StorageKey } from '@polkadot/types';
-import type { EraIndex, Exposure } from '@polkadot/types/interfaces';
+import type { AccountId, EraIndex, Exposure } from '@polkadot/types/interfaces';
 import type { Observable } from '@polkadot/x-rxjs';
 import type { DeriveEraExposure, DeriveEraNominatorExposure, DeriveEraValidatorExposure } from '../types';
 
@@ -12,7 +12,7 @@ import { map, switchMap } from '@polkadot/x-rxjs/operators';
 
 import { deriveCache, memo } from '../util';
 
-type KeysAndExposures = [StorageKey, Exposure][];
+type KeysAndExposures = [StorageKey<[EraIndex, AccountId]>, Exposure][];
 
 const CACHE_KEY = 'eraExposure';
 

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

@@ -1,55 +1,37 @@
 // Copyright 2017-2021 @polkadot/api-derive authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { ApiInterfaceRx } from '@polkadot/api/types';
+import type { ApiInterfaceRx, QueryableStorageMultiArg } from '@polkadot/api/types';
 import type { EraIndex, Exposure } from '@polkadot/types/interfaces';
 import type { Observable } from '@polkadot/x-rxjs';
 import type { DeriveOwnExposure } from '../types';
 
-import { combineLatest, of } from '@polkadot/x-rxjs';
+import { of } from '@polkadot/x-rxjs';
 import { map, switchMap } from '@polkadot/x-rxjs/operators';
 
-import { deriveCache, memo } from '../util';
+import { memo } from '../util';
 
-const CACHE_KEY = 'ownExposure';
+export function _ownExposures (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveOwnExposure[]> {
-
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function _ownExposure (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, era: EraIndex, withActive: boolean) => Observable<DeriveOwnExposure> {
+  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], _withActive: boolean): Observable<DeriveOwnExposure[]> =>
-  return memo(instanceId, (accountId: Uint8Array | string, era: EraIndex, withActive: boolean): Observable<DeriveOwnExposure> => {
+    eras.length
-    const cacheKey = `${CACHE_KEY}-${era.toString()}-${accountId.toString()}`;
+      ? api.queryMulti<Exposure[]>([
-    const cached = withActive
+        ...eras.map((era): QueryableStorageMultiArg<'rxjs'> => [api.query.staking.erasStakersClipped, [era, accountId]]),
-      ? undefined
+        ...eras.map((era): QueryableStorageMultiArg<'rxjs'> => [api.query.staking.erasStakers, [era, accountId]])
-      : deriveCache.get<DeriveOwnExposure>(cacheKey);
-
-    return cached
-      ? of(cached)
-      : api.queryMulti<[Exposure, Exposure]>([
-        [api.query.staking.erasStakersClipped, [era, accountId]],
-        [api.query.staking.erasStakers, [era, accountId]]
       ]).pipe(
-        map(([clipped, exposure]): DeriveOwnExposure => {
+        map((all): DeriveOwnExposure[] =>
-          const value = { clipped, era, exposure };
+          eras.map((era, index) => ({ clipped: all[index], era, exposure: all[eras.length + index] }))
-
+        )
-          !withActive && deriveCache.set(cacheKey, value);
+      )
-
+      : of([])
-          return value;
+  );
-        })
-      );
-  });
 }
 
 export function ownExposure (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, era: EraIndex) => Observable<DeriveOwnExposure> {
   return memo(instanceId, (accountId: Uint8Array | string, era: EraIndex): Observable<DeriveOwnExposure> =>
-    api.derive.staking._ownExposure(accountId, era, true)
+    api.derive.staking._ownExposures(accountId, [era], true).pipe(
-  );
+      map(([first]) => first)
-}
+    )
-
-export function _ownExposures (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveOwnExposure[]> {
-  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean): Observable<DeriveOwnExposure[]> =>
-    eras.length
-      ? combineLatest(
-        eras.map((era) => api.derive.staking._ownExposure(accountId, era, withActive))
-      )
-      : of([])
   );
 }
 

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

@@ -1,62 +1,44 @@
 // Copyright 2017-2021 @polkadot/api-derive authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { ApiInterfaceRx } from '@polkadot/api/types';
+import type { ApiInterfaceRx, QueryableStorageMultiArg } from '@polkadot/api/types';
 import type { Option } from '@polkadot/types';
 import type { BalanceOf, EraIndex, Perbill } from '@polkadot/types/interfaces';
 import type { ITuple } from '@polkadot/types/types';
 import type { Observable } from '@polkadot/x-rxjs';
 import type { DeriveStakerSlashes } from '../types';
 
-import { combineLatest, of } from '@polkadot/x-rxjs';
+import { of } from '@polkadot/x-rxjs';
 import { map, switchMap } from '@polkadot/x-rxjs/operators';
 
-import { deriveCache, memo } from '../util';
+import { memo } from '../util';
 
-const CACHE_KEY = 'ownSlash';
+export function _ownSlashes (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerSlashes[]> {
-
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function _ownSlash (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, era: EraIndex, withActive: boolean) => Observable<DeriveStakerSlashes> {
+  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], _withActive: boolean): Observable<DeriveStakerSlashes[]> =>
-  return memo(instanceId, (accountId: Uint8Array | string, era: EraIndex, withActive: boolean): Observable<DeriveStakerSlashes> => {
+    eras.length
-    const cacheKey = `${CACHE_KEY}-${era.toString()}-${accountId.toString()}`;
+      ? api.queryMulti<(Option<ITuple<[Perbill, BalanceOf]>> | Option<BalanceOf>)[]>([
-    const cached = withActive
+        ...eras.map((era): QueryableStorageMultiArg<'rxjs'> => [api.query.staking.validatorSlashInEra, [era, accountId]]),
-      ? undefined
+        ...eras.map((era): QueryableStorageMultiArg<'rxjs'> => [api.query.staking.nominatorSlashInEra, [era, accountId]])
-      : deriveCache.get<DeriveStakerSlashes>(cacheKey);
-
-    return cached
-      ? of(cached)
-      : api.queryMulti<[Option<BalanceOf>, Option<ITuple<[Perbill, BalanceOf]>>]>([
-        [api.query.staking.nominatorSlashInEra, [era, accountId]],
-        [api.query.staking.validatorSlashInEra, [era, accountId]]
       ]).pipe(
-        map(([optNom, optVal]): DeriveStakerSlashes => {
+        map((values): DeriveStakerSlashes[] =>
-          const value = {
+          eras.map((era, index) => ({
             era,
-            total: optVal.isSome
+            total: values[index].isSome
-              ? optVal.unwrap()[1]
+              ? (values[index].unwrap() as ITuple<[Perbill, BalanceOf]>)[1]
-              : optNom.unwrapOrDefault()
+              : (values[index + eras.length].unwrapOrDefault() as BalanceOf)
-          };
+          }))
-
+        )
-          !withActive && deriveCache.set(cacheKey, value);
+      )
-
+      : of([])
-          return value;
+  );
-        })
-      );
-  });
 }
 
 export function ownSlash (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, era: EraIndex) => Observable<DeriveStakerSlashes> {
   return memo(instanceId, (accountId: Uint8Array | string, era: EraIndex): Observable<DeriveStakerSlashes> =>
-    api.derive.staking._ownSlash(accountId, era, true)
+    api.derive.staking._ownSlashes(accountId, [era], true).pipe(
-  );
+      map(([first]) => first)
-}
+    )
-
-export function _ownSlashes (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerSlashes[]> {
-  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean): Observable<DeriveStakerSlashes[]> =>
-    eras.length
-      ? combineLatest(
-        eras.map((era) => api.derive.staking._ownSlash(accountId, era, withActive))
-      )
-      : of([])
   );
 }
 

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

@@ -10,36 +10,46 @@ import { map, switchMap } from '@polkadot/x-rxjs/operators';
 
 import { memo } from '../util';
 
-export function _stakerExposure (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerExposure[]> {
+export function _stakerExposures (instanceId: string, api: ApiInterfaceRx): (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerExposure[][]> {
-  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean): Observable<DeriveStakerExposure[]> => {
+  return memo(instanceId, (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive: boolean): Observable<DeriveStakerExposure[][]> => {
-    const stakerId = api.registry.createType('AccountId', accountId).toString();
+    const stakerIds = accountIds.map((a) => api.registry.createType('AccountId', a).toString());
 
     return api.derive.staking._erasExposure(eras, withActive).pipe(
-      map((exposures): DeriveStakerExposure[] =>
+      map((exposures): DeriveStakerExposure[][] =>
-        exposures.map(({ era, nominators: allNominators, validators: allValidators }): DeriveStakerExposure => {
+        stakerIds.map((stakerId) =>
-          const isValidator = !!allValidators[stakerId];
+          exposures.map(({ era, nominators: allNominators, validators: allValidators }): DeriveStakerExposure => {
-          const validators: DeriveEraValidatorExposure = {};
+            const isValidator = !!allValidators[stakerId];
-          const nominating = allNominators[stakerId] || [];
+            const validators: DeriveEraValidatorExposure = {};
+            const nominating = allNominators[stakerId] || [];
 
-          if (isValidator) {
+            if (isValidator) {
-            validators[stakerId] = allValidators[stakerId];
+              validators[stakerId] = allValidators[stakerId];
-          } else if (nominating) {
+            } else if (nominating) {
-            nominating.forEach(({ validatorId }): void => {
+              nominating.forEach(({ validatorId }): void => {
-              validators[validatorId] = allValidators[validatorId];
+                validators[validatorId] = allValidators[validatorId];
-            });
+              });
-          }
+            }
 
-          return { era, isEmpty: !Object.keys(validators).length, isValidator, nominating, validators };
+            return { era, isEmpty: !Object.keys(validators).length, isValidator, nominating, validators };
-        })
+          })
+        )
       )
     );
   });
 }
 
-export function stakerExposure (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, withActive?: boolean) => Observable<DeriveStakerExposure[]> {
+export function stakerExposures (instanceId: string, api: ApiInterfaceRx): (accountIds: (Uint8Array | string)[], withActive?: boolean) => Observable<DeriveStakerExposure[][]> {
-  return memo(instanceId, (accountId: Uint8Array | string, withActive = false): Observable<DeriveStakerExposure[]> =>
+  return memo(instanceId, (accountIds: (Uint8Array | string)[], withActive = false): Observable<DeriveStakerExposure[][]> =>
     api.derive.staking.erasHistoric(withActive).pipe(
-      switchMap((eras) => api.derive.staking._stakerExposure(accountId, eras, withActive))
+      switchMap((eras) => api.derive.staking._stakerExposures(accountIds, eras, withActive))
+    )
+  );
+}
+
+export function stakerExposure (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, withActive?: boolean) => Observable<DeriveStakerExposure[]> {
+  return memo(instanceId, (accountId: Uint8Array | string, withActive = false): Observable<DeriveStakerExposure[]> =>
+    api.derive.staking.stakerExposures([accountId, withActive]).pipe(
+      map(([first]) => first)
     )
   );
 }

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

@@ -2,25 +2,22 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { ApiInterfaceRx } from '@polkadot/api/types';
-import type { Option } from '@polkadot/types';
+import type { AccountId, EraIndex, StakingLedger } from '@polkadot/types/interfaces';
-import type { AccountId, EraIndex, StakingLedger, StakingLedgerTo240 } from '@polkadot/types/interfaces';
 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, isFunction } from '@polkadot/util';
+import { BN_BILLION, BN_ZERO } from '@polkadot/util';
 import { combineLatest, of } from '@polkadot/x-rxjs';
 import { map, switchMap } from '@polkadot/x-rxjs/operators';
 
 import { memo } from '../util';
 
-type ErasResult = [{ unwrapOr: (value: BN) => BN }, DeriveEraPoints[], DeriveEraPrefs[], DeriveEraRewards[]];
+type ErasResult = [DeriveEraPoints[], DeriveEraPrefs[], DeriveEraRewards[]];
 
-const MIN_ONE = new BN(-1);
+function parseRewards (api: ApiInterfaceRx, stashId: AccountId, [erasPoints, erasPrefs, erasRewards]: ErasResult, exposures: DeriveStakerExposure[]): DeriveStakerReward[] {
-
-function parseRewards (api: ApiInterfaceRx, stashId: AccountId, [, erasPoints, erasPrefs, erasRewards]: ErasResult, exposures: DeriveStakerExposure[]): DeriveStakerReward[] {
   return exposures.map(({ era, isEmpty, isValidator, nominating, validators: eraValidators }): DeriveStakerReward => {
     const { eraPoints, validators: allValPoints } = erasPoints.find((p) => p.era.eq(era)) || { eraPoints: BN_ZERO, validators: {} };
     const { eraReward } = erasRewards.find((r) => r.era.eq(era)) || { eraReward: api.registry.createType('Balance') };
@@ -31,7 +28,7 @@ function parseRewards (api: ApiInterfaceRx, stashId: AccountId, [, erasPoints, e
     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;
 
@@ -71,32 +68,25 @@ function parseRewards (api: ApiInterfaceRx, stashId: AccountId, [, erasPoints, e
   });
 }
 
-function uniqValidators (rewards: DeriveStakerReward[]): string[] {
+function allUniqValidators (rewards: DeriveStakerReward[][]): [string[], string[][]] {
-  const uniq: string[] = [];
+  return rewards.reduce(([all, perStash]: [string[], string[][]], rewards) => {
+    const uniq: string[] = [];
 
-  rewards.forEach(({ validators }): void => {
+    perStash.push(uniq);
-    Object.keys(validators).forEach((validatorId): void => {
+    rewards.forEach(({ validators }) =>
-      if (!uniq.includes(validatorId)) {
+      Object.keys(validators).forEach((validatorId): void => {
-        uniq.push(validatorId);
+        if (!uniq.includes(validatorId)) {
-      }
+          uniq.push(validatorId);
-    });
-  });
 
-  return uniq;
+          if (!all.includes(validatorId)) {
-}
+            all.push(validatorId);
+          }
+        }
+      })
+    );
 
-function isOldLedger (ledger?: StakingLedger | StakingLedgerTo240): ledger is StakingLedgerTo240 {
+    return [all, perStash];
-  return !!(ledger as StakingLedgerTo240)?.lastReward;
+  }, [[], []]);
-}
-
-function filterEra (era: EraIndex, stakingLedger: StakingLedger): boolean {
-  return isOldLedger(stakingLedger)
-    ? era.gt(stakingLedger.lastReward.unwrapOr(MIN_ONE))
-    : !stakingLedger.claimedRewards.some((e) => e.eq(era));
-}
-
-function filterEras (eras: EraIndex[], stakingLedger: StakingLedger): EraIndex[] {
-  return eras.filter((era) => filterEra(era, stakingLedger));
 }
 
 function removeClaimed (validators: string[], queryValidators: DeriveStakingQuery[], reward: DeriveStakerReward): void {
@@ -119,43 +109,34 @@ function removeClaimed (validators: string[], queryValidators: DeriveStakingQuer
   });
 }
 
-function filterRewards (api: ApiInterfaceRx, eras: EraIndex[], { migrateEra, rewards, stakingLedger }: { migrateEra: BN, rewards: DeriveStakerReward[]; stakingLedger: StakingLedger }): Observable<DeriveStakerReward[]> {
+function filterRewards (eras: EraIndex[], valInfo: [string, DeriveStakingQuery][], { rewards, stakingLedger }: { rewards: DeriveStakerReward[]; stakingLedger: StakingLedger }): DeriveStakerReward[] {
-  const validators = uniqValidators(rewards);
+  const filter = eras.filter((era) => !stakingLedger.claimedRewards.some((e) => e.eq(era)));
-  const filter = filterEras(eras, stakingLedger);
+  const validators = valInfo.map(([v]) => v);
+  const queryValidators = valInfo.map(([, q]) => q);
 
-  return api.derive.staking.queryMulti(validators, { withLedger: true }).pipe(
+  return rewards
-    map((queryValidators): DeriveStakerReward[] =>
+    .filter(({ isEmpty }) => !isEmpty)
-      rewards
+    .filter((reward): boolean => {
-        .filter(({ isEmpty }) => !isEmpty)
+      if (!filter.some((filter) => reward.era.eq(filter))) {
-        .filter((reward): boolean => {
+        return false;
-          if (!filter.some((filter) => reward.era.eq(filter))) {
+      }
-            return false;
-          } else if (reward.era.lt(migrateEra)) {
-            // we filter again here, the actual ledger may have changed, e.g. something has been claimed
-            return filterEra(reward.era, stakingLedger);
-          }
 
-          reward.isStakerPayout = true;
+      reward.isStakerPayout = true;
 
-          removeClaimed(validators, queryValidators, reward);
+      removeClaimed(validators, queryValidators, reward);
 
-          return true;
+      return true;
-        })
+    })
-        .filter(({ validators }) => Object.keys(validators).length !== 0)
+    .filter(({ validators }) => Object.keys(validators).length !== 0)
-        .map((reward) => ({
+    .map((reward) => ({
-          ...reward,
+      ...reward,
-          nominators: reward.nominating.filter((n) => reward.validators[n.validatorId])
+      nominators: reward.nominating.filter((n) => reward.validators[n.validatorId])
-        }))
+    }));
-    )
-  );
 }
 
 export function _stakerRewardsEras (instanceId: string, api: ApiInterfaceRx): (eras: EraIndex[], withActive: boolean) => Observable<ErasResult> {
   return memo(instanceId, (eras: EraIndex[], withActive: boolean): Observable<ErasResult> =>
     combineLatest([
-      isFunction(api.query.staking.migrateEra)
-        ? api.query.staking.migrateEra<Option<EraIndex>>()
-        : of(api.registry.createType('Option<EraIndex>')),
       api.derive.staking._erasPoints(eras, withActive),
       api.derive.staking._erasPrefs(eras, withActive),
       api.derive.staking._erasRewards(eras, withActive)
@@ -163,23 +144,39 @@ export function _stakerRewardsEras (instanceId: string, api: ApiInterfaceRx): (e
   );
 }
 
-export function _stakerRewards (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerReward[]> {
+export function _stakerRewards (instanceId: string, api: ApiInterfaceRx): (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerReward[][]> {
-  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean): Observable<DeriveStakerReward[]> =>
+  return memo(instanceId, (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive: boolean): Observable<DeriveStakerReward[][]> =>
     combineLatest([
-      api.derive.staking.query(accountId, { withLedger: true }),
+      api.derive.staking.queryMulti(accountIds, { withLedger: true }),
-      api.derive.staking._stakerExposure(accountId, eras, withActive),
+      api.derive.staking._stakerExposures(accountIds, eras, withActive),
       api.derive.staking._stakerRewardsEras(eras, withActive)
     ]).pipe(
-      switchMap(([{ stakingLedger, stashId }, exposures, erasResult]): Observable<DeriveStakerReward[]> => {
+      switchMap(([queries, exposures, erasResult]): Observable<DeriveStakerReward[][]> => {
-        if (!stashId || !stakingLedger) {
+        const allRewards = queries.map(({ stakingLedger, stashId }, index): DeriveStakerReward[] =>
-          return of([]);
+          (!stashId || !stakingLedger)
+            ? []
+            : parseRewards(api, stashId, erasResult, exposures[index])
+        );
+
+        if (withActive) {
+          return of(allRewards);
         }
 
-        const rewards = parseRewards(api, stashId, erasResult, exposures);
+        const [allValidators, stashValidators] = allUniqValidators(allRewards);
 
-        return withActive
+        return api.derive.staking.queryMulti(allValidators, { withLedger: true }).pipe(
-          ? of(rewards)
+          map((queriedVals): DeriveStakerReward[][] => {
-          : filterRewards(api, eras, { migrateEra: erasResult[0].unwrapOr(BN_ZERO), rewards, stakingLedger });
+            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 });
+            });
+          })
+        );
       })
     )
   );
@@ -188,7 +185,8 @@ export function _stakerRewards (instanceId: string, api: ApiInterfaceRx): (accou
 export function stakerRewards (instanceId: string, api: ApiInterfaceRx): (accountId: Uint8Array | string, withActive?: boolean) => Observable<DeriveStakerReward[]> {
   return memo(instanceId, (accountId: Uint8Array | string, withActive = false): Observable<DeriveStakerReward[]> =>
     api.derive.staking.erasHistoric(withActive).pipe(
-      switchMap((eras) => api.derive.staking._stakerRewards(accountId, eras, withActive))
+      switchMap((eras) => api.derive.staking._stakerRewards([accountId], eras, withActive)),
+      map(([first]) => first)
     )
   );
 }
@@ -196,7 +194,7 @@ export function stakerRewards (instanceId: string, api: ApiInterfaceRx): (accoun
 export function stakerRewardsMultiEras (instanceId: string, api: ApiInterfaceRx): (accountIds: (Uint8Array | string)[], eras: EraIndex[]) => Observable<DeriveStakerReward[][]> {
   return memo(instanceId, (accountIds: (Uint8Array | string)[], eras: EraIndex[]): Observable<DeriveStakerReward[][]> =>
     accountIds.length && eras.length
-      ? combineLatest(accountIds.map((acc) => api.derive.staking._stakerRewards(acc, eras, false)))
+      ? api.derive.staking._stakerRewards(accountIds, eras, false)
       : of([])
   );
 }

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

@@ -5,17 +5,42 @@ import type { ApiInterfaceRx } from '@polkadot/api/types';
 import type { AccountId } from '@polkadot/types/interfaces';
 import type { Observable } from '@polkadot/x-rxjs';
 
-import { map } from '@polkadot/x-rxjs/operators';
+import { map, startWith, switchMap } from '@polkadot/x-rxjs/operators';
 
-import { memo } from '../util';
+import { drr, memo } from '../util';
+
+function onBondedEvent (api: ApiInterfaceRx): Observable<number> {
+  let current = Date.now();
+
+  return api.query.system.events().pipe(
+    map((events): number => {
+      current = events.filter(({ event, phase }): boolean => {
+        try {
+          return phase.isApplyExtrinsic &&
+            event.section === 'staking' &&
+            event.method === 'Bonded';
+        } catch {
+          return false;
+        }
+      })
+        ? Date.now()
+        : current;
+
+      return current;
+    }),
+    startWith(current),
+    drr({ skipTimeout: true })
+  );
+}
 
 /**
  * @description Retrieve the list of all validator stashes
  */
 export function stashes (instanceId: string, api: ApiInterfaceRx): () => Observable<AccountId[]> {
   return memo(instanceId, (): Observable<AccountId[]> =>
-    api.query.staking.validators.keys().pipe(
+    onBondedEvent(api).pipe(
-      map((keys) => keys.map((key) => key.args[0]).filter((a) => a))
+      switchMap(() => api.query.staking.validators.keys()),
+      map((keys) => keys.map(({ args: [validatorId] }) => validatorId).filter((a) => a))
     )
   );
 }

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

@@ -18,7 +18,7 @@ export function nextElected (instanceId: string, api: ApiInterfaceRx): () => Obs
         // only populate for next era in the last session, so track both here - entries are not
         // subscriptions, so we need a trigger - currentIndex acts as that trigger to refresh
         switchMap(({ currentEra }) => api.query.staking.erasStakers.keys(currentEra)),
-        map((keys) => keys.map((key) => key.args[1]))
+        map((keys) => keys.map(({ args: [, accountId] }) => accountId))
       )
       : api.query.staking.currentElected<AccountId[]>()
   );

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

@@ -61,7 +61,9 @@ function retrieveProposals (api: ApiInterfaceRx, proposalCount: ProposalIndex, a
 
   return combineLatest([
     api.query.treasury.proposals.multi<Option<TreasuryProposal>>(allIds),
-    api.derive.council.proposals()
+    api.derive.council
+      ? api.derive.council.proposals()
+      : of([] as DeriveCollectiveProposal[])
   ]).pipe(
     map(([allProposals, councilProposals]: [Option<TreasuryProposal>[], DeriveCollectiveProposal[]]): DeriveTreasuryProposals =>
       parseResult(api, { allIds, allProposals, approvalIds, councilProposals, proposalCount })

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

@@ -33,10 +33,19 @@ function nextNonce (api: ApiInterfaceRx, address: string): Observable<Index> {
 function signingHeader (api: ApiInterfaceRx): Observable<Header> {
   return combineLatest([
     api.rpc.chain.getHeader(),
-    api.rpc.chain.getFinalizedHead().pipe(
+    api.rpc.chain.getFinalizedHead()
-      switchMap((hash) => api.rpc.chain.getHeader(hash))
-    )
   ]).pipe(
+    switchMap(([bestHeader, finHash]) =>
+      // retrieve the headers - in the case of the current block, we use the parent
+      // to minimize (not completely remove) the impact that forks do have on the system
+      // (when at genesis, just return the current header as the last known)
+      bestHeader.parentHash.isEmpty
+        ? of([bestHeader, bestHeader])
+        : combineLatest([
+          api.rpc.chain.getHeader(bestHeader.parentHash),
+          api.rpc.chain.getHeader(finHash)
+        ])
+    ),
     map(([current, finalized]) =>
       // determine the hash to use, current when lag > max, else finalized
       current.number.unwrap().sub(finalized.number.unwrap()).gt(MAX_FINALITY_LAG)

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

@@ -2,43 +2,41 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { AccountId, Header } from '@polkadot/types/interfaces';
-import type { Constructor, Registry } from '@polkadot/types/types';
+import type { Registry } from '@polkadot/types/types';
-
+import type { HeaderExtended } from './types';
-import { Struct } from '@polkadot/types';
-import runtimeTypes from '@polkadot/types/interfaces/runtime/definitions';
 
 import { extractAuthor } from './util';
 
-// We can ignore the properties, added via Struct.with
+export function createHeaderExtended (registry: Registry, header?: Header, validators?: AccountId[]): HeaderExtended {
-const _Header = Struct.with(runtimeTypes.types.Header as any) as Constructor<Header>;
+  // an instance of the base extrinsic for us to extend
+  const HeaderBase = registry.createClass('Header');
 
-/**
+  class Implementation extends HeaderBase implements HeaderExtended {
- * @name HeaderExtended
+    readonly #author?: AccountId;
- * @description
+    readonly #validators?: AccountId[];
- * A [[Block]] header with an additional `author` field that indicates the block author
- */
-export class HeaderExtended extends _Header {
-  readonly #author?: AccountId;
-  readonly #validators?: AccountId[];
 
-  constructor (registry: Registry, header?: Header, validators?: AccountId[]) {
+    constructor (registry: Registry, header?: Header, validators?: AccountId[]) {
-    super(registry, header);
+      super(registry, header);
 
-    this.#author = extractAuthor(this.digest, validators);
+      this.#author = extractAuthor(this.digest, validators);
-    this.#validators = validators;
+      this.#validators = validators;
+      this.createdAtHash = header?.createdAtHash;
+    }
+
+    /**
+     * @description Convenience method, returns the author for the block
+     */
+    public get author (): AccountId | undefined {
+      return this.#author;
+    }
+
+    /**
+     * @description Convenience method, returns the validators for the block
+     */
+    public get validators (): AccountId[] | undefined {
+      return this.#validators;
+    }
   }
 
-  /**
+  return new Implementation(registry, header, validators);
-   * @description Convenience method, returns the author for the block
-   */
-  public get author (): AccountId | undefined {
-    return this.#author;
-  }
-
-  /**
-   * @description Convenience method, returns the validators for the block
-   */
-  public get validators (): AccountId[] | undefined {
-    return this.#validators;
-  }
 }

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

@@ -1,24 +1,12 @@
 // Copyright 2017-2021 @polkadot/api-derive authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { AccountId, DispatchError, DispatchInfo, Event, EventRecord, Extrinsic, SignedBlock } from '@polkadot/types/interfaces';
+import type { AccountId, DispatchError, DispatchInfo, EventRecord, Extrinsic, SignedBlock } from '@polkadot/types/interfaces';
-import type { Constructor, Registry } from '@polkadot/types/types';
+import type { Registry } from '@polkadot/types/types';
-
+import type { SignedBlockExtended, TxWithEvent } from './types';
-import { Struct } from '@polkadot/types';
-import runtimeTypes from '@polkadot/types/interfaces/runtime/definitions';
 
 import { extractAuthor } from './util';
 
-// We can ignore the properties, added via Struct.with
-const _SignedBlock = Struct.with(runtimeTypes.types.SignedBlock as any) as Constructor<SignedBlock>;
-
-interface TxWithEvent {
-  dispatchError?: DispatchError;
-  dispatchInfo?: DispatchInfo;
-  events: Event[];
-  extrinsic: Extrinsic;
-}
-
 function mapExtrinsics (extrinsics: Extrinsic[], records: EventRecord[]): TxWithEvent[] {
   return extrinsics.map((extrinsic, index): TxWithEvent => {
     let dispatchError: DispatchError | undefined;
@@ -43,42 +31,45 @@ function mapExtrinsics (extrinsics: Extrinsic[], records: EventRecord[]): TxWith
   });
 }
 
-/**
+export function createSignedBlockExtended (registry: Registry, block?: SignedBlock, events?: EventRecord[], validators?: AccountId[]): SignedBlockExtended {
- * @name SignedBlockExtended
+  // an instance of the base extrinsic for us to extend
- * @description
+  const SignedBlockBase = registry.createClass('SignedBlock');
- * A [[Block]] header with an additional `author` field that indicates the block author
- */
-export class SignedBlockExtended extends _SignedBlock {
-  readonly #author?: AccountId;
-  readonly #events: EventRecord[];
-  readonly #extrinsics: TxWithEvent[];
 
-  constructor (registry: Registry, block?: SignedBlock, events?: EventRecord[], sessionValidators?: AccountId[]) {
+  class Implementation extends SignedBlockBase implements SignedBlockExtended {
-    super(registry, block);
+    readonly #author?: AccountId;
+    readonly #events: EventRecord[];
+    readonly #extrinsics: TxWithEvent[];
 
-    this.#author = extractAuthor(this.block.header.digest, sessionValidators);
+    constructor (registry: Registry, block?: SignedBlock, events?: EventRecord[], validators?: AccountId[]) {
-    this.#events = events || ([] as EventRecord[]);
+      super(registry, block);
-    this.#extrinsics = mapExtrinsics(this.block.extrinsics, this.#events);
+
+      this.#author = extractAuthor(this.block.header.digest, validators);
+      this.#events = events || ([] as EventRecord[]);
+      this.#extrinsics = mapExtrinsics(this.block.extrinsics, this.#events);
+      this.createdAtHash = block?.createdAtHash;
+    }
+
+    /**
+     * @description Convenience method, returns the author for the block
+     */
+    public get author (): AccountId | undefined {
+      return this.#author;
+    }
+
+    /**
+     * @description Convenience method, returns the events associated with the block
+     */
+    public get events (): EventRecord[] {
+      return this.#events;
+    }
+
+    /**
+     * @description Returns the extrinsics and their events, mapped
+     */
+    public get extrinsics (): TxWithEvent[] {
+      return this.#extrinsics;
+    }
   }
 
-  /**
+  return new Implementation(registry, block, events, validators);
-   * @description Convenience method, returns the author for the block
-   */
-  public get author (): AccountId | undefined {
-    return this.#author;
-  }
-
-  /**
-   * @description Convenience method, returns the events associated with the block
-   */
-  public get events (): EventRecord[] {
-    return this.#events;
-  }
-
-  /**
-   * @description Returns the extrinsics and their events, mapped
-   */
-  public get extrinsics (): TxWithEvent[] {
-    return this.#extrinsics;
-  }
 }

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

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

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

@@ -0,0 +1,22 @@
+// Copyright 2017-2021 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AccountId, DispatchError, DispatchInfo, Event, EventRecord, Extrinsic, Header, SignedBlock } from '@polkadot/types/interfaces';
+
+export interface HeaderExtended extends Header {
+  readonly author: AccountId | undefined;
+  readonly validators: AccountId[] | undefined;
+}
+
+export interface SignedBlockExtended extends SignedBlock {
+  readonly author: AccountId | undefined;
+  readonly events: EventRecord[];
+  readonly extrinsics: TxWithEvent[];
+}
+
+export interface TxWithEvent {
+  dispatchError?: DispatchError;
+  dispatchInfo?: DispatchInfo;
+  events: Event[];
+  extrinsic: Extrinsic;
+}

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

@@ -5,20 +5,43 @@ import type { AccountId, Digest } from '@polkadot/types/interfaces';
 
 export function extractAuthor (digest: Digest, sessionValidators: AccountId[] = []): AccountId | undefined {
   const [citem] = digest.logs.filter(({ type }) => type === 'Consensus');
+  const [pitem] = digest.logs.filter(({ type }) => type === 'PreRuntime');
+  const [sitem] = digest.logs.filter(({ type }) => type === 'Seal');
 
-  if (citem) {
+  let accountId: AccountId | undefined;
-    const [engine, data] = citem.asConsensus;
 
-    return engine.extractAuthor(data, sessionValidators);
+  // This is critical to be first for BABE (before Consensus)
-  } else {
+  // If not first, we end up dropping the author at session-end
-    const [pitem] = digest.logs.filter(({ type }) => type === 'PreRuntime');
+  if (pitem) {
-
+    try {
-    if (pitem) {
       const [engine, data] = pitem.asPreRuntime;
 
-      return engine.extractAuthor(data, sessionValidators);
+      accountId = engine.extractAuthor(data, sessionValidators);
+    } catch {
+      // ignore
     }
   }
 
-  return undefined;
+  if (!accountId && citem) {
+    try {
+      const [engine, data] = citem.asConsensus;
+
+      accountId = engine.extractAuthor(data, sessionValidators);
+    } catch {
+      // ignore
+    }
+  }
+
+  // SEAL, still used in e.g. Kulupu for pow
+  if (!accountId && sitem) {
+    try {
+      const [engine, data] = sitem.asSeal;
+
+      accountId = engine.extractAuthor(data, sessionValidators);
+    } catch {
+      // ignore
+    }
+  }
+
+  return accountId;
 }

packages/api-derive/src/types.ts

@@ -12,6 +12,7 @@ export * from './elections/types';
 export * from './parachains/types';
 export * from './session/types';
 export * from './staking/types';
+export * from './type/types';
 
 export interface DeriveBalancesAccountData {
   freeBalance: Balance;
@@ -107,6 +108,7 @@ export interface DeriveSocietyCandidate {
 
 export interface DeriveSocietyMember {
   accountId: AccountId;
+  isDefenderVoter: boolean;
   isSuspended: boolean;
   payouts: [BlockNumber, Balance][];
   strikes: StrikeCount;

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

@@ -5,7 +5,7 @@ import type { DeriveCache } from './types';
 
 const mapCache = new Map<string, any>();
 
-const deriveMapCache: DeriveCache = {
+export const deriveMapCache: DeriveCache = {
   del: (key: string): void => {
     mapCache.delete(key);
   },
@@ -24,11 +24,9 @@ const deriveMapCache: DeriveCache = {
   }
 };
 
-const deriveNoopCache: DeriveCache = {
+export const deriveNoopCache: DeriveCache = {
   del: (): void => undefined,
   forEach: () => undefined,
   get: (): undefined => undefined,
   set: (_: string, value: unknown): unknown => value
 };
-
-export { deriveMapCache, deriveNoopCache };

packages/api/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@polkadot/api",
-  "version": "3.8.1",
+  "version": "4.11.1",
+  "type": "module",
   "description": "Promise and RxJS wrappers around the Polkadot JS RPC",
   "main": "index.js",
   "sideEffects": [
     "./detectPackage.js",
-    "./detectPackage.mjs"
+    "./detectPackage.cjs"
   ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
   "contributors": [],
@@ -15,17 +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.12.13",
+    "@babel/runtime": "^7.14.0",
-    "@polkadot/api-derive": "3.8.1",
+    "@polkadot/api-derive": "4.11.1",
-    "@polkadot/keyring": "^5.6.1",
+    "@polkadot/keyring": "^6.5.1",
-    "@polkadot/metadata": "3.8.1",
+    "@polkadot/metadata": "4.11.1",
-    "@polkadot/rpc-core": "3.8.1",
+    "@polkadot/rpc-core": "4.11.1",
-    "@polkadot/rpc-provider": "3.8.1",
+    "@polkadot/rpc-provider": "4.11.1",
-    "@polkadot/types": "3.8.1",
+    "@polkadot/types": "4.11.1",
-    "@polkadot/types-known": "3.8.1",
+    "@polkadot/types-known": "4.11.1",
-    "@polkadot/util": "^5.6.1",
+    "@polkadot/util": "^6.5.1",
-    "@polkadot/util-crypto": "^5.6.1",
+    "@polkadot/util-crypto": "^6.5.1",
-    "@polkadot/x-rxjs": "^5.6.1",
+    "@polkadot/x-rxjs": "^6.5.1",
     "bn.js": "^4.11.9",
     "eventemitter3": "^4.0.7"
   }

packages/api/src/augment/consts.ts

@@ -3,7 +3,8 @@
 
 import type { Vec, u16, u32, u64, u8 } from '@polkadot/types';
 import type { Codec } from '@polkadot/types/types';
-import type { Balance, BalanceOf, BlockNumber, LockIdentifier, ModuleId, Moment, Perbill, Percent, Permill, RuntimeDbWeight, Weight } from '@polkadot/types/interfaces/runtime';
+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';
 import type { RuntimeVersion } from '@polkadot/types/interfaces/state';
@@ -14,13 +15,10 @@ import type { ApiTypes } from '@polkadot/api/types';
 declare module '@polkadot/api/types/consts' {
   export interface AugmentedConsts<ApiType> {
     babe: {
-      [key: string]: Codec;
       /**
-       * The number of **slots** that an epoch takes. We couple sessions to
+       * The amount of time, in slots, that each epoch should last.
-       * epochs, i.e. we start a new session once the new epoch begins.
+       * NOTE: Currently it is not possible to change the epoch duration after
-       * NOTE: Currently it is not possible to change the epoch duration
+       * the chain has started. Attempting to do so will brick block production.
-       * after the chain has started. Attempting to do so will brick block
-       * production.
        **/
       epochDuration: u64 & AugmentedConst<ApiType>;
       /**
@@ -31,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.
        **/
@@ -69,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.
        **/
@@ -106,15 +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 nesting level of a call/instantiate stack. A reasonable default
-       * value is 100.
-       **/
-      maxDepth: u32 & AugmentedConst<ApiType>;
-      /**
-       * The maximum size of a storage value in bytes. A reasonable default is 16 KiB.
-       **/
-      maxValueSize: u32 & AugmentedConst<ApiType>;
       /**
        * The fraction of the deposit that should be used as rent per block.
        * 
@@ -123,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.
        * 
@@ -139,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.
        **/
@@ -178,21 +183,128 @@ 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: {
+      /**
+       * 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.
+       **/
+      signedPhase: BlockNumber & AugmentedConst<ApiType>;
+      /**
+       * The minimum amount of improvement to the solution score that defines a solution as
+       * "better" (in any phase).
+       **/
+      solutionImprovementThreshold: Perbill & AugmentedConst<ApiType>;
+      /**
+       * 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>;
-      moduleId: LockIdentifier & 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: {
+      /**
+       * Portion of the queue which is free from ordering and just a FIFO.
+       * 
+       * Must be no greater than `MaxQueueLen`.
+       **/
+      fifoQueueLen: u32 & AugmentedConst<ApiType>;
+      /**
+       * The number of blocks between consecutive attempts to issue more gilts in an effort to
+       * get to the target amount to be frozen.
+       * 
+       * A larger value results in fewer storage hits each block, but a slower period to get to
+       * the target.
+       **/
+      intakePeriod: BlockNumber & AugmentedConst<ApiType>;
+      /**
+       * The maximum amount of bids that can be turned into issued gilts each block. A larger
+       * value here means less of the block available for transactions should there be a glut of
+       * bids to make into gilts to reach the target.
+       **/
+      maxIntakeBids: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum number of items that may be in each duration queue.
+       **/
+      maxQueueLen: u32 & AugmentedConst<ApiType>;
+      /**
+       * The minimum amount of funds that may be offered to freeze for a gilt. Note that this
+       * does not actually limit the amount which may be frozen in a gilt since gilts may be
+       * split up in order to satisfy the desired amount of funds under gilts.
+       * 
+       * It should be at least big enough to ensure that there is no possible storage spam attack
+       * or queue-filling attack.
+       **/
+      minFreeze: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * The base period for the duration queues. This is the common multiple across all
+       * supported freezing durations that can be bid upon.
+       **/
+      period: BlockNumber & AugmentedConst<ApiType>;
+      /**
+       * Number of duration queues in total. This sets the maximum duration supported, which is
+       * 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>;
       /**
@@ -219,21 +331,36 @@ 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>;
-      moduleId: ModuleId & 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.
@@ -247,19 +374,27 @@ declare module '@polkadot/api/types/consts' {
        * The maximum amount of signatories allowed for a given multisig.
        **/
       maxSignatories: u16 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
     };
     proxy: {
-      [key: string]: Codec;
       /**
-       * `AnnouncementDepositBase` metadata shadow.
+       * The base amount of currency needed to reserve for creating an announcement.
+       * 
+       * This is held when a new storage item holding a `Balance` is created (typically 16 bytes).
        **/
       announcementDepositBase: BalanceOf & AugmentedConst<ApiType>;
       /**
-       * `AnnouncementDepositFactor` metadata shadow.
+       * The amount of currency needed per announcement made.
+       * 
+       * This is held for adding an `AccountId`, `Hash` and `BlockNumber` (typically 68 bytes)
+       * into a pre-existing storage value.
        **/
       announcementDepositFactor: BalanceOf & AugmentedConst<ApiType>;
       /**
-       * `MaxPending` metadata shadow.
+       * The maximum amount of time-delayed announcements that are allowed to be pending.
        **/
       maxPending: u32 & AugmentedConst<ApiType>;
       /**
@@ -268,21 +403,36 @@ declare module '@polkadot/api/types/consts' {
       maxProxies: u16 & AugmentedConst<ApiType>;
       /**
        * The base amount of currency needed to reserve for creating a proxy.
+       * 
+       * This is held for an additional storage item whose value size is
+       * `sizeof(Balance)` bytes and whose key size is `sizeof(AccountId)` bytes.
        **/
       proxyDepositBase: BalanceOf & AugmentedConst<ApiType>;
       /**
        * The amount of currency needed per proxy added.
+       * 
+       * This is held for adding 32 bytes plus an instance of `ProxyType` more into a pre-existing
+       * storage value. Thus, when configuring `ProxyDepositFactor` one should take into account
+       * `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>;
       /**
@@ -291,11 +441,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.
        **/
@@ -304,6 +463,10 @@ declare module '@polkadot/api/types/consts' {
        * The number of blocks between membership challenges.
        **/
       challengePeriod: BlockNumber & AugmentedConst<ApiType>;
+      /**
+       * Maximum candidate intake per round.
+       **/
+      maxCandidateIntake: u32 & AugmentedConst<ApiType>;
       /**
        * The number of times a member may vote the wrong way (or not at all, when they are a skeptic)
        * before they become suspended.
@@ -312,7 +475,7 @@ declare module '@polkadot/api/types/consts' {
       /**
        * The societies's module id
        **/
-      moduleId: ModuleId & AugmentedConst<ApiType>;
+      palletId: PalletId & AugmentedConst<ApiType>;
       /**
        * The amount of incentive paid within each period. Doesn't include VoterTip.
        **/
@@ -326,29 +489,20 @@ 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>;
       /**
-       * The number of blocks before the end of the era from which election submissions are allowed.
+       * Maximum number of nominations per nominator.
-       * 
-       * Setting this to zero will disable the offchain compute and only on-chain seq-phragmen will
-       * be used.
-       * 
-       * This is bounded by being within the last session. Hence, setting it to a value more than the
-       * length of a session will be pointless.
        **/
-      electionLookahead: BlockNumber & AugmentedConst<ApiType>;
+      maxNominations: u32 & AugmentedConst<ApiType>;
-      /**
-       * Maximum number of balancing iterations to run in the offchain submission.
-       * 
-       * If set to 0, balance_solution will not be executed at all.
-       **/
-      maxIterations: u32 & AugmentedConst<ApiType>;
       /**
        * The maximum number of nominators rewarded for each validator.
        * 
@@ -356,10 +510,6 @@ declare module '@polkadot/api/types/consts' {
        * their reward. This used to limit the i/o cost for the nominator payout.
        **/
       maxNominatorRewardedPerValidator: u32 & AugmentedConst<ApiType>;
-      /**
-       * The threshold of improvement that should be provided for a new solution to be accepted.
-       **/
-      minSolutionScoreBump: Perbill & AugmentedConst<ApiType>;
       /**
        * Number of sessions per era.
        **/
@@ -372,9 +522,12 @@ declare module '@polkadot/api/types/consts' {
        * 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).
        **/
@@ -403,9 +556,12 @@ declare module '@polkadot/api/types/consts' {
        * 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
@@ -413,9 +569,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.
        **/
@@ -436,9 +595,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.
        **/
@@ -447,9 +609,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.
        **/
@@ -457,7 +622,7 @@ declare module '@polkadot/api/types/consts' {
       /**
        * The treasury's module id, used for deriving its sovereign account ID.
        **/
-      moduleId: ModuleId & AugmentedConst<ApiType>;
+      palletId: PalletId & AugmentedConst<ApiType>;
       /**
        * Fraction of a proposal's value that should be bonded in order to place the proposal.
        * An accepted proposal gets these back. A rejected proposal does not.
@@ -471,13 +636,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 to be transferred to create a new vesting schedule.
+       * The minimum amount transferred to call `vested_transfer`.
        **/
       minVestedTransfer: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
     };
   }
 

packages/api/src/augment/errors.ts

@@ -6,19 +6,10 @@ import type { ApiTypes } from '@polkadot/api/types';
 declare module '@polkadot/api/types/errors' {
   export interface AugmentedErrors<ApiType> {
     assets: {
-      [key: string]: AugmentedError<ApiType>;
-      /**
-       * Transfer amount should be non-zero.
-       **/
-      AmountZero: AugmentedError<ApiType>;
       /**
        * Invalid metadata given.
        **/
       BadMetadata: AugmentedError<ApiType>;
-      /**
-       * Some internal state is broken.
-       **/
-      BadState: AugmentedError<ApiType>;
       /**
        * Invalid witness data given.
        **/
@@ -48,24 +39,27 @@ declare module '@polkadot/api/types/errors' {
        **/
       NoPermission: AugmentedError<ApiType>;
       /**
-       * A mint operation lead to an overflow.
+       * No provider reference exists to allow a non-zero balance of a non-self-sufficient asset.
        **/
-      Overflow: AugmentedError<ApiType>;
+      NoProvider: AugmentedError<ApiType>;
       /**
-       * Attempt to destroy an asset class when non-zombie, reference-bearing accounts exist.
+       * No approval exists that would allow the transfer.
        **/
-      RefsLeft: AugmentedError<ApiType>;
+      Unapproved: AugmentedError<ApiType>;
-      /**
-       * Too many zombie accounts in use.
-       **/
-      TooManyZombies: AugmentedError<ApiType>;
       /**
        * The given asset ID is unknown.
        **/
       Unknown: AugmentedError<ApiType>;
+      /**
+       * 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.
        **/
@@ -94,9 +88,30 @@ declare module '@polkadot/api/types/errors' {
        * Uncles already set in the block.
        **/
       UnclesAlreadySet: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    babe: {
+      /**
+       * A given equivocation report is valid but already previously reported.
+       **/
+      DuplicateOffenceReport: AugmentedError<ApiType>;
+      /**
+       * An equivocation proof provided as part of an equivocation report is invalid.
+       **/
+      InvalidEquivocationProof: AugmentedError<ApiType>;
+      /**
+       * 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
        **/
@@ -121,17 +136,16 @@ declare module '@polkadot/api/types/errors' {
        * Account liquidity restrictions prevent withdrawal
        **/
       LiquidityRestrictions: AugmentedError<ApiType>;
-      /**
-       * Got an overflow after adding
-       **/
-      Overflow: 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.
        **/
@@ -169,9 +183,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
@@ -191,7 +208,7 @@ declare module '@polkadot/api/types/errors' {
       /**
        * A contract could not be evicted because it has enough balance to pay rent.
        * 
-       * This can be returned from [`Module::claim_surcharge`] because the target
+       * This can be returned from [`Pallet::claim_surcharge`] because the target
        * contract has enough balance to pay for its rent.
        **/
       ContractNotEvictable: AugmentedError<ApiType>;
@@ -199,6 +216,10 @@ declare module '@polkadot/api/types/errors' {
        * 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.
        **/
@@ -206,7 +227,7 @@ declare module '@polkadot/api/types/errors' {
       /**
        * Removal of a contract failed because the deletion queue is full.
        * 
-       * This can happen when either calling [`Module::claim_surcharge`] or `seal_terminate`.
+       * This can happen when either calling [`Pallet::claim_surcharge`] or `seal_terminate`.
        * The queue is filled by deleting contracts and emptied by a fixed amount each block.
        * Trying again during another block is the only way to resolve this issue.
        **/
@@ -297,6 +318,12 @@ 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>;
       /**
        * The amount of topics passed to `seal_deposit_events` exceeds the limit.
        **/
@@ -311,9 +338,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!
        **/
@@ -354,9 +384,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
        **/
@@ -449,10 +482,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
        **/
@@ -481,10 +510,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
        **/
@@ -498,9 +523,34 @@ declare module '@polkadot/api/types/errors' {
        * Invalid upper bound.
        **/
       WrongUpperBound: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    electionProviderMultiPhase: {
+      /**
+       * OCW submitted solution for wrong round
+       **/
+      OcwCallWrongEra: AugmentedError<ApiType>;
+      /**
+       * Submission was too early.
+       **/
+      PreDispatchEarlySubmission: AugmentedError<ApiType>;
+      /**
+       * Submission was too weak, score-wise.
+       **/
+      PreDispatchWeakSubmission: AugmentedError<ApiType>;
+      /**
+       * Wrong number of winners presented.
+       **/
+      PreDispatchWrongWinnerCount: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     elections: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * Duplicated candidate submission.
        **/
@@ -569,9 +619,51 @@ declare module '@polkadot/api/types/errors' {
        * Cannot vote when no candidates or members exist.
        **/
       UnableToVote: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    gilt: {
+      /**
+       * The amount of the bid is less than the minimum allowed.
+       **/
+      AmountTooSmall: AugmentedError<ApiType>;
+      /**
+       * The queue for the bid's duration is full and the amount bid is too low to get in through
+       * replacing an existing bid.
+       **/
+      BidTooLow: AugmentedError<ApiType>;
+      /**
+       * The duration is the bid is greater than the number of queues.
+       **/
+      DurationTooBig: AugmentedError<ApiType>;
+      /**
+       * The duration of the bid is less than one.
+       **/
+      DurationTooSmall: AugmentedError<ApiType>;
+      /**
+       * Gilt not yet at expiry date.
+       **/
+      NotExpired: AugmentedError<ApiType>;
+      /**
+       * The given bid for retraction is not found.
+       **/
+      NotFound: AugmentedError<ApiType>;
+      /**
+       * Not the owner of the gilt.
+       **/
+      NotOwner: AugmentedError<ApiType>;
+      /**
+       * 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.
        **/
@@ -602,9 +694,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.
        **/
@@ -669,9 +764,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.
        **/
@@ -680,9 +778,72 @@ declare module '@polkadot/api/types/errors' {
        * Non existent public key.
        **/
       InvalidKey: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    indices: {
+      /**
+       * The index was not available.
+       **/
+      InUse: AugmentedError<ApiType>;
+      /**
+       * The index was not already assigned.
+       **/
+      NotAssigned: AugmentedError<ApiType>;
+      /**
+       * The index is assigned to another account.
+       **/
+      NotOwner: AugmentedError<ApiType>;
+      /**
+       * The source and destination accounts are identical.
+       **/
+      NotTransfer: AugmentedError<ApiType>;
+      /**
+       * The index is permanent and may not be freed/changed.
+       **/
+      Permanent: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    lottery: {
+      /**
+       * A lottery has already ended.
+       **/
+      AlreadyEnded: AugmentedError<ApiType>;
+      /**
+       * You are already participating in the lottery with this call.
+       **/
+      AlreadyParticipating: AugmentedError<ApiType>;
+      /**
+       * Failed to encode calls
+       **/
+      EncodingFailed: AugmentedError<ApiType>;
+      /**
+       * A lottery is already in progress.
+       **/
+      InProgress: AugmentedError<ApiType>;
+      /**
+       * The call is not valid for an open lottery.
+       **/
+      InvalidCall: AugmentedError<ApiType>;
+      /**
+       * A lottery has not been configured.
+       **/
+      NotConfigured: 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.
        **/
@@ -691,6 +852,10 @@ declare module '@polkadot/api/types/errors' {
        * The data to be stored is already stored.
        **/
       AlreadyStored: AugmentedError<ApiType>;
+      /**
+       * The maximum weight information provided was too low.
+       **/
+      MaxWeightTooLow: AugmentedError<ApiType>;
       /**
        * Threshold must be 2 or greater.
        **/
@@ -731,17 +896,16 @@ declare module '@polkadot/api/types/errors' {
        * A timepoint was given, yet no multisig operation is underway.
        **/
       UnexpectedTimepoint: AugmentedError<ApiType>;
-      /**
-       * The maximum weight information provided was too low.
-       **/
-      WeightTooLow: AugmentedError<ApiType>;
       /**
        * 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.
        **/
@@ -774,9 +938,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
        **/
@@ -829,10 +996,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
        **/
@@ -845,9 +1008,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
        **/
@@ -864,9 +1030,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.
        **/
@@ -887,9 +1056,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.
        **/
@@ -962,9 +1134,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.
        **/
@@ -985,10 +1160,6 @@ declare module '@polkadot/api/types/errors' {
        * A nomination target was supplied that was blocked or otherwise not a validator.
        **/
       BadTarget: AugmentedError<ApiType>;
-      /**
-       * The call is not allowed at the given time due to restrictions of election period.
-       **/
-      CallNotAllowed: AugmentedError<ApiType>;
       /**
        * Duplicate index.
        **/
@@ -1045,75 +1216,26 @@ declare module '@polkadot/api/types/errors' {
        * Can not rebond without unlocking chunks.
        **/
       NoUnlockChunk: AugmentedError<ApiType>;
-      /**
-       * Error while building the assignment type from the compact. This can happen if an index
-       * is invalid, or if the weights _overflow_.
-       **/
-      OffchainElectionBogusCompact: AugmentedError<ApiType>;
-      /**
-       * The submitted result has unknown edges that are not among the presented winners.
-       **/
-      OffchainElectionBogusEdge: AugmentedError<ApiType>;
-      /**
-       * The election size is invalid.
-       **/
-      OffchainElectionBogusElectionSize: AugmentedError<ApiType>;
-      /**
-       * One of the submitted nominators has an edge to which they have not voted on chain.
-       **/
-      OffchainElectionBogusNomination: AugmentedError<ApiType>;
-      /**
-       * One of the submitted nominators is not an active nominator on chain.
-       **/
-      OffchainElectionBogusNominator: AugmentedError<ApiType>;
-      /**
-       * The claimed score does not match with the one computed from the data.
-       **/
-      OffchainElectionBogusScore: AugmentedError<ApiType>;
-      /**
-       * A self vote must only be originated from a validator to ONLY themselves.
-       **/
-      OffchainElectionBogusSelfVote: AugmentedError<ApiType>;
-      /**
-       * One of the submitted winners is not an active candidate on chain (index is out of range
-       * in snapshot).
-       **/
-      OffchainElectionBogusWinner: AugmentedError<ApiType>;
-      /**
-       * Incorrect number of winners were presented.
-       **/
-      OffchainElectionBogusWinnerCount: AugmentedError<ApiType>;
-      /**
-       * The submitted result is received out of the open window.
-       **/
-      OffchainElectionEarlySubmission: AugmentedError<ApiType>;
-      /**
-       * One of the submitted nominators has an edge which is submitted before the last non-zero
-       * slash of the target.
-       **/
-      OffchainElectionSlashedNomination: AugmentedError<ApiType>;
-      /**
-       * The submitted result is not as good as the one stored on chain.
-       **/
-      OffchainElectionWeakSubmission: AugmentedError<ApiType>;
-      /**
-       * The snapshot data of the current window is missing.
-       **/
-      SnapshotUnavailable: AugmentedError<ApiType>;
       /**
        * Too many nomination targets supplied.
        **/
       TooManyTargets: 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.
        * 
@@ -1138,9 +1260,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!
        **/
@@ -1181,9 +1306,26 @@ 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: {
+      /**
+       * Already a member.
+       **/
+      AlreadyMember: AugmentedError<ApiType>;
+      /**
+       * Not a member.
+       **/
+      NotMember: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     tips: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * The tip was already found/started.
        **/
@@ -1208,9 +1350,12 @@ declare module '@polkadot/api/types/errors' {
        * The tip hash is unknown.
        **/
       UnknownTip: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     treasury: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * Proposer's balance is too low.
        **/
@@ -1219,9 +1364,16 @@ 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>;
     };
     vesting: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * Amount being transferred is too low to create a vesting schedule.
        **/
@@ -1234,6 +1386,10 @@ declare module '@polkadot/api/types/errors' {
        * The account given is not vesting.
        **/
       NotVesting: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
   }
 

packages/api/src/augment/events.ts

@@ -9,12 +9,13 @@ import type { MemberCount, ProposalIndex } from '@polkadot/types/interfaces/coll
 import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
 import type { PropIndex, ReferendumIndex } from '@polkadot/types/interfaces/democracy';
 import type { VoteThreshold } from '@polkadot/types/interfaces/elections';
+import type { ActiveIndex } from '@polkadot/types/interfaces/gilt';
 import type { AuthorityList } from '@polkadot/types/interfaces/grandpa';
 import type { RegistrarIndex } from '@polkadot/types/interfaces/identity';
 import type { CallIndex } from '@polkadot/types/interfaces/lottery';
 import type { Kind, OpaqueTimeSlot } from '@polkadot/types/interfaces/offences';
 import type { ProxyType } from '@polkadot/types/interfaces/proxy';
-import type { AccountId, AccountIndex, AssetId, Balance, BlockNumber, CallHash, Hash, PhantomData } from '@polkadot/types/interfaces/runtime';
+import type { AccountId, AccountIndex, AssetId, Balance, BalanceOf, BlockNumber, CallHash, Hash, PhantomData } from '@polkadot/types/interfaces/runtime';
 import type { TaskAddress } from '@polkadot/types/interfaces/scheduler';
 import type { IdentificationTuple, SessionIndex } from '@polkadot/types/interfaces/session';
 import type { ElectionCompute, EraIndex } from '@polkadot/types/interfaces/staking';
@@ -26,11 +27,25 @@ 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\]
+       **/
+      ApprovalCancelled: AugmentedEvent<ApiType, [AssetId, AccountId, AccountId]>;
+      /**
+       * (Additional) funds have been approved for transfer to a destination account.
+       * \[asset_id, source, delegate, amount\]
+       **/
+      ApprovedTransfer: AugmentedEvent<ApiType, [AssetId, AccountId, AccountId, TAssetBalance]>;
       /**
        * Some asset `asset_id` was frozen. \[asset_id\]
        **/
       AssetFrozen: AugmentedEvent<ApiType, [AssetId]>;
+      /**
+       * An asset has had its attributes changed by the `Force` origin.
+       * \[id\]
+       **/
+      AssetStatusChanged: AugmentedEvent<ApiType, [AssetId]>;
       /**
        * Some asset `asset_id` was thawed. \[asset_id\]
        **/
@@ -51,10 +66,6 @@ declare module '@polkadot/api/types/events' {
        * Some asset class was force-created. \[asset_id, owner\]
        **/
       ForceCreated: AugmentedEvent<ApiType, [AssetId, AccountId]>;
-      /**
-       * Some assets was transferred by an admin. \[asset_id, from, to, amount\]
-       **/
-      ForceTransferred: AugmentedEvent<ApiType, [AssetId, AccountId, AccountId, TAssetBalance]>;
       /**
        * Some account `who` was frozen. \[asset_id, who\]
        **/
@@ -64,13 +75,13 @@ declare module '@polkadot/api/types/events' {
        **/
       Issued: AugmentedEvent<ApiType, [AssetId, AccountId, TAssetBalance]>;
       /**
-       * The maximum amount of zombies allowed has changed. \[asset_id, max_zombies\]
+       * Metadata has been cleared for an asset. \[asset_id\]
        **/
-      MaxZombiesChanged: AugmentedEvent<ApiType, [AssetId, u32]>;
+      MetadataCleared: AugmentedEvent<ApiType, [AssetId]>;
       /**
-       * New metadata has been set for an asset. \[asset_id, name, symbol, decimals\]
+       * New metadata has been set for an asset. \[asset_id, name, symbol, decimals, is_frozen\]
        **/
-      MetadataSet: AugmentedEvent<ApiType, [AssetId, Bytes, Bytes, u8]>;
+      MetadataSet: AugmentedEvent<ApiType, [AssetId, Bytes, Bytes, u8, bool]>;
       /**
        * The owner changed \[asset_id, owner\]
        **/
@@ -87,9 +98,18 @@ declare module '@polkadot/api/types/events' {
        * Some assets were transferred. \[asset_id, from, to, amount\]
        **/
       Transferred: AugmentedEvent<ApiType, [AssetId, AccountId, AccountId, TAssetBalance]>;
+      /**
+       * An `amount` was transferred in its entirety from `owner` to `destination` by
+       * the approved `delegate`.
+       * \[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\]
        **/
@@ -125,9 +145,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\]
        **/
@@ -156,9 +179,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\]
@@ -225,9 +251,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\]
@@ -265,9 +294,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.
        **/
@@ -344,9 +376,46 @@ 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: {
+      /**
+       * The election has been finalized, with `Some` of the given computation, or else if the
+       * election failed, `None`.
+       **/
+      ElectionFinalized: AugmentedEvent<ApiType, [Option<ElectionCompute>]>;
+      /**
+       * An account has been rewarded for their signed submission being finalized.
+       **/
+      Rewarded: AugmentedEvent<ApiType, [AccountId]>;
+      /**
+       * The signed phase of the given round has started.
+       **/
+      SignedPhaseStarted: AugmentedEvent<ApiType, [u32]>;
+      /**
+       * An account has been slashed for submitting an invalid signed submission.
+       **/
+      Slashed: AugmentedEvent<ApiType, [AccountId]>;
+      /**
+       * A solution was stored with the given compute.
+       * 
+       * If the solution is signed, this means that it hasn't yet been processed. If the
+       * solution is unsigned, this means that it has also been processed.
+       **/
+      SolutionStored: AugmentedEvent<ApiType, [ElectionCompute]>;
+      /**
+       * 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.
@@ -369,10 +438,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
+       * A new term with \[new_members\]. This indicates that enough candidates existed to run
-       * election, not that enough have has been elected. The inner value must be examined for
+       * the election, not that enough have has been elected. The inner value must be examined
-       * this purpose. A `NewTerm(\[\])` indicates that some candidates got their bond slashed and
+       * for this purpose. A `NewTerm(\[\])` indicates that some candidates got their bond
-       * none were elected, whilst `EmptyTerm` means that no candidates existed to begin with.
+       * slashed and none were elected, whilst `EmptyTerm` means that no candidates existed to
+       * begin with.
        **/
       NewTerm: AugmentedEvent<ApiType, [Vec<ITuple<[AccountId, Balance]>>]>;
       /**
@@ -383,9 +453,38 @@ 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: {
+      /**
+       * A bid was successfully placed.
+       * \[ who, amount, duration \]
+       **/
+      BidPlaced: AugmentedEvent<ApiType, [AccountId, BalanceOf, u32]>;
+      /**
+       * A bid was successfully removed (before being accepted as a gilt).
+       * \[ who, amount, duration \]
+       **/
+      BidRetracted: AugmentedEvent<ApiType, [AccountId, BalanceOf, u32]>;
+      /**
+       * A bid was accepted as a gilt. The balance may not be released until expiry.
+       * \[ index, expiry, who, amount \]
+       **/
+      GiltIssued: AugmentedEvent<ApiType, [ActiveIndex, BlockNumber, AccountId, BalanceOf]>;
+      /**
+       * An expired gilt has been thawed.
+       * \[ 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\]
        **/
@@ -398,9 +497,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\]
        **/
@@ -443,9 +545,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.
        **/
@@ -458,9 +563,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\]
        **/
@@ -473,9 +581,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!
        **/
@@ -492,9 +603,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\]
@@ -512,19 +626,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
+       * (kind-specific) time slot. This event is not deposited for duplicate slashes.
-       * element indicates of the offence was applied (true) or queued (false)
+       * \[kind, timeslot\].
-       * \[kind, timeslot, applied\].
        **/
-      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\]
        **/
@@ -538,9 +657,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\]
@@ -569,9 +691,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\]
        **/
@@ -584,17 +709,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).
        **/
@@ -662,9 +793,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\]
        * 
@@ -697,13 +831,9 @@ declare module '@polkadot/api/types/events' {
        **/
       Slash: AugmentedEvent<ApiType, [AccountId, Balance]>;
       /**
-       * A new solution for the upcoming election has been stored. \[compute\]
+       * A new set of stakers was elected.
        **/
-      SolutionStored: AugmentedEvent<ApiType, [ElectionCompute]>;
+      StakingElection: AugmentedEvent<ApiType, []>;
-      /**
-       * A new set of stakers was elected with the given \[compute\].
-       **/
-      StakingElection: AugmentedEvent<ApiType, [ElectionCompute]>;
       /**
        * An account has unbonded this amount. \[stash, amount\]
        **/
@@ -713,9 +843,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.
        **/
@@ -728,9 +861,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.
        **/
@@ -751,9 +887,16 @@ declare module '@polkadot/api/types/events' {
        * A new \[account\] was created.
        **/
       NewAccount: AugmentedEvent<ApiType, [AccountId]>;
+      /**
+       * 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\]
@@ -791,9 +934,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.
        **/
@@ -818,9 +964,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\]
        **/
@@ -841,9 +990,12 @@ 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>;
     };
     treasury: {
-      [key: string]: AugmentedEvent<ApiType>;
       /**
        * Some funds have been allocated. \[proposal_index, award, beneficiary\]
        **/
@@ -873,9 +1025,12 @@ 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>;
     };
     utility: {
-      [key: string]: AugmentedEvent<ApiType>;
       /**
        * Batch of dispatches completed fully with no error.
        **/
@@ -885,9 +1040,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.
        **/
@@ -898,6 +1056,10 @@ declare module '@polkadot/api/types/events' {
        * \[account, unvested\]
        **/
       VestingUpdated: AugmentedEvent<ApiType, [AccountId, Balance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
     };
   }
 

packages/api/src/augment/query.ts

@@ -3,27 +3,28 @@
 
 import type { Bytes, Data, Option, U8aFixed, Vec, bool, u32, u64 } from '@polkadot/types';
 import type { AnyNumber, ITuple, Observable } from '@polkadot/types/types';
-import type { 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, MaybeRandomness, NextConfigDescriptor, Randomness } from '@polkadot/types/interfaces/babe';
+import type { BabeAuthorityWeight, BabeEpochConfiguration, MaybeRandomness, NextConfigDescriptor, Randomness } from '@polkadot/types/interfaces/babe';
 import type { AccountData, BalanceLock } 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';
 import type { SetId, StoredPendingChange, StoredState } from '@polkadot/types/interfaces/grandpa';
 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 { 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, ElectionResult, ElectionScore, ElectionStatus, EraIndex, EraRewardPoints, Exposure, Forcing, Nominations, RewardDestination, SeatHolder, SlashingSpans, SpanIndex, SpanRecord, StakingLedger, UnappliedSlash, ValidatorPrefs, Voter } from '@polkadot/types/interfaces/staking';
+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 { 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';
@@ -34,11 +35,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: 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.
        **/
@@ -47,9 +53,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.
        **/
@@ -62,9 +71,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.
        **/
@@ -79,10 +91,22 @@ declare module '@polkadot/api/types/storage' {
        * Current slot number.
        **/
       currentSlot: AugmentedQuery<ApiType, () => Observable<Slot>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The configuration for the current epoch. Should never be `None` as it is initialized in genesis.
+       **/
+      epochConfig: AugmentedQuery<ApiType, () => Observable<Option<BabeEpochConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;
       /**
        * Current epoch index.
        **/
       epochIndex: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The block numbers when the last and current epoch have started, respectively `N-1` and
+       * `N`.
+       * NOTE: We track this is in order to annotate the block number when a given pool of
+       * entropy was fixed (i.e. it was known to chain observers). Since epochs are defined in
+       * slots, which may be skipped, the block numbers may not line up with the slot numbers.
+       **/
+      epochStart: AugmentedQuery<ApiType, () => Observable<ITuple<[BlockNumber, BlockNumber]>>, []> & QueryableStorageEntry<ApiType, []>;
       /**
        * The slot at which the first epoch actually started. This is 0
        * until the first block of the chain.
@@ -106,13 +130,18 @@ declare module '@polkadot/api/types/storage' {
        **/
       nextAuthorities: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AuthorityId, BabeAuthorityWeight]>>>, []> & QueryableStorageEntry<ApiType, []>;
       /**
-       * Next epoch configuration, if changed.
+       * The configuration for the next epoch, `None` if the config will not change
+       * (you can fallback to `EpochConfig` instead in that case).
        **/
-      nextEpochConfig: AugmentedQuery<ApiType, () => Observable<Option<NextConfigDescriptor>>, []> & QueryableStorageEntry<ApiType, []>;
+      nextEpochConfig: AugmentedQuery<ApiType, () => Observable<Option<BabeEpochConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;
       /**
        * Next epoch randomness.
        **/
       nextRandomness: AugmentedQuery<ApiType, () => Observable<Randomness>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Pending epoch configuration change that will be applied when the next epoch is enacted.
+       **/
+      pendingEpochConfigChange: AugmentedQuery<ApiType, () => Observable<Option<NextConfigDescriptor>>, []> & QueryableStorageEntry<ApiType, []>;
       /**
        * The epoch randomness for the *current* epoch.
        * 
@@ -142,13 +171,16 @@ 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.
        * 
-       * NOTE: This is only used in the case that this module is used to store balances.
+       * NOTE: This is only used in the case that this pallet is used to store balances.
        **/
       account: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<AccountData>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
       /**
@@ -166,9 +198,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.
        **/
@@ -185,9 +220,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.
        **/
@@ -202,10 +240,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.
        * 
@@ -217,9 +251,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).
        **/
@@ -244,9 +281,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.
@@ -322,9 +362,53 @@ 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: {
+      /**
+       * Current phase.
+       **/
+      currentPhase: AugmentedQuery<ApiType, () => Observable<ElectionPhase>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Desired number of targets to elect for this round.
+       * 
+       * Only exists when [`Snapshot`] is present.
+       **/
+      desiredTargets: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Current best solution, signed or unsigned, queued to be returned upon `elect`.
+       **/
+      queuedSolution: AugmentedQuery<ApiType, () => Observable<Option<ReadySolution>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Internal counter for the number of rounds.
+       * 
+       * This is useful for de-duplication of transactions submitted to the pool, and general
+       * diagnostics of the pallet.
+       * 
+       * This is merely incremented once per every time that an upstream `elect` is called.
+       **/
+      round: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Snapshot data of the round.
+       * 
+       * This is created at the beginning of the signed phase and cleared upon calling `elect`.
+       **/
+      snapshot: AugmentedQuery<ApiType, () => Observable<Option<RoundSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The metadata of the [`RoundSnapshot`]
+       * 
+       * 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.
@@ -357,9 +441,38 @@ 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: {
+      /**
+       * The currently active gilts, indexed according to the order of creation.
+       **/
+      active: AugmentedQuery<ApiType, (arg: ActiveIndex | AnyNumber | Uint8Array) => Observable<Option<ActiveGilt>>, [ActiveIndex]> & QueryableStorageEntry<ApiType, [ActiveIndex]>;
+      /**
+       * Information relating to the gilts currently active.
+       **/
+      activeTotal: AugmentedQuery<ApiType, () => Observable<ActiveGiltsTotal>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The queues of bids ready to become gilts. Indexed by duration (in `Period`s).
+       **/
+      queues: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<GiltBid>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * The totals of items and balances within each queue. Saves a lot of storage reads in the
+       * case of sparsely packed queues.
+       * 
+       * The vector is indexed by duration in `Period`s, offset by one, so information on the queue
+       * 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.
@@ -388,9 +501,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.
        * 
@@ -417,21 +533,29 @@ 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 current session.
+       * The block number after which it's ok to send heartbeats in the current
+       * session.
        * 
-       * At the beginning of each session we set this to a value that should
+       * At the beginning of each session we set this to a value that should fall
-       * fall roughly in the middle of the session duration.
+       * roughly in the middle of the session duration. The idea is to first wait for
-       * The idea is to first wait for the validators to produce a block
+       * the validators to produce a block in the current session, so that the
-       * in the current session, so that the heartbeat later on will not be necessary.
+       * heartbeat later on will not be necessary.
+       * 
+       * This value will only be used as a fallback if we fail to get a proper session
+       * progress estimate from `NextSessionRotation`, as those estimates should be
+       * more accurate then the value we calculate for `HeartbeatAfter`.
        **/
       heartbeatAfter: AugmentedQuery<ApiType, () => Observable<BlockNumber>, []> & QueryableStorageEntry<ApiType, []>;
       /**
@@ -442,17 +566,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`.
@@ -478,9 +608,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.
        * 
@@ -496,26 +629,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]>;
+      concurrentReportsIndex: AugmentedQuery<ApiType, (arg1: Kind | string | Uint8Array, arg2: 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, []>;
       /**
        * The primary structure that holds all offence records keyed by report identifiers.
        **/
@@ -529,9 +663,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).
        **/
@@ -541,25 +678,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.
        * 
@@ -570,9 +713,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.
        **/
@@ -587,9 +733,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.
        **/
@@ -622,9 +771,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.
        **/
@@ -685,14 +837,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.
        * 
@@ -723,15 +878,16 @@ declare module '@polkadot/api/types/storage' {
        * set, it might be active or not.
        **/
       currentEra: AugmentedQuery<ApiType, () => Observable<Option<EraIndex>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The last planned session scheduled by the session pallet.
+       * 
+       * This is basically in sync with the call to [`SessionManager::new_session`].
+       **/
+      currentPlannedSession: AugmentedQuery<ApiType, () => Observable<SessionIndex>, []> & QueryableStorageEntry<ApiType, []>;
       /**
        * The earliest era for which we have a pending, unapplied slash.
        **/
       earliestUnappliedSlash: AugmentedQuery<ApiType, () => Observable<Option<EraIndex>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Flag to control the execution of the offchain election. When `Open(_)`, we accept
-       * solutions to be submitted.
-       **/
-      eraElectionStatus: AugmentedQuery<ApiType, () => Observable<ElectionStatus>, []> & QueryableStorageEntry<ApiType, []>;
       /**
        * Rewards for the last `HISTORY_DEPTH` eras.
        * If reward hasn't been set or has been removed then 0 reward is returned.
@@ -745,7 +901,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.
        * 
@@ -759,7 +915,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.
        * 
@@ -779,7 +935,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.
        * 
@@ -806,11 +962,6 @@ declare module '@polkadot/api/types/storage' {
        * invulnerables) and restricted to testnets.
        **/
       invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * True if the current **planned** session is final. Note that this does not take era
-       * forcing into account.
-       **/
-      isCurrentSessionFinal: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
       /**
        * Map from all (unlocked) "controller" accounts to the info regarding the staking.
        **/
@@ -826,21 +977,11 @@ declare module '@polkadot/api/types/storage' {
       /**
        * 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.
        **/
       payee: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<RewardDestination>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
-      /**
-       * The next validator set. At the end of an era, if this is available (potentially from the
-       * result of an offchain worker), it is immediately used. Otherwise, the on-chain election
-       * is executed.
-       **/
-      queuedElected: AugmentedQuery<ApiType, () => Observable<Option<ElectionResult>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * The score of the current [`QueuedElected`].
-       **/
-      queuedScore: AugmentedQuery<ApiType, () => Observable<Option<ElectionScore>>, []> & QueryableStorageEntry<ApiType, []>;
       /**
        * Slashing spans for stash accounts.
        **/
@@ -851,16 +992,6 @@ declare module '@polkadot/api/types/storage' {
        * The rest of the slashed value is handled by the `Slash`.
        **/
       slashRewardFraction: AugmentedQuery<ApiType, () => Observable<Perbill>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Snapshot of nominators at the beginning of the current election window. This should only
-       * have a value when [`EraElectionStatus`] == `ElectionStatus::Open(_)`.
-       **/
-      snapshotNominators: AugmentedQuery<ApiType, () => Observable<Option<Vec<AccountId>>>, []> & QueryableStorageEntry<ApiType, []>;
-      /**
-       * Snapshot of validators at the beginning of the current election window. This should only
-       * have a value when [`EraElectionStatus`] == `ElectionStatus::Open(_)`.
-       **/
-      snapshotValidators: AugmentedQuery<ApiType, () => Observable<Option<Vec<AccountId>>>, []> & QueryableStorageEntry<ApiType, []>;
       /**
        * Records information about the maximum slash of a stash within a slashing span,
        * as well as how much reward has been paid out.
@@ -870,7 +1001,7 @@ declare module '@polkadot/api/types/storage' {
        * True if network has been upgraded to this version.
        * Storage version of the pallet.
        * 
-       * This is set to v5.0.0 for new networks.
+       * This is set to v6.0.0 for new networks.
        **/
       storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []> & QueryableStorageEntry<ApiType, []>;
       /**
@@ -889,17 +1020,23 @@ declare module '@polkadot/api/types/storage' {
        * 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.
        **/
@@ -966,17 +1103,20 @@ declare module '@polkadot/api/types/storage' {
        **/
       parentHash: AugmentedQuery<ApiType, () => Observable<Hash>, []> & QueryableStorageEntry<ApiType, []>;
       /**
-       * True if we have upgraded so that AccountInfo contains two types of `RefCount`. False
+       * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
        * (default) if not.
        **/
-      upgradedToDualRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
+      upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
       /**
        * 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).
        **/
@@ -1001,9 +1141,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.
        **/
@@ -1012,9 +1155,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?
        **/
@@ -1023,9 +1169,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.
@@ -1037,14 +1186,20 @@ 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>;
     };
     treasury: {
-      [key: string]: QueryableStorageEntry<ApiType>;
       /**
        * Proposal indices that have been approved but not yet awarded.
        **/
@@ -1057,13 +1212,20 @@ 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>;
     };
     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>;
     };
   }
 

packages/api/src/augment/rpc.ts

@@ -6,19 +6,21 @@ 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';
 import type { EncodedFinalityProofs, JustificationNotification, ReportedRoundStates } from '@polkadot/types/interfaces/grandpa';
+import type { MmrLeafProof } from '@polkadot/types/interfaces/mmr';
 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' {
@@ -63,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
@@ -120,6 +128,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
        **/
@@ -133,7 +145,7 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
       /**
        * Instructs the manual-seal authorship task to finalize a block
        **/
-      finalizeBlock: AugmentedRpc<(hash: BlockHash | string | Uint8Array, justification?: Justification | string | Uint8Array) => Observable<bool>>;
+      finalizeBlock: AugmentedRpc<(hash: BlockHash | string | Uint8Array, justification?: Justification) => Observable<bool>>;
     };
     eth: {
       /**
@@ -315,6 +327,12 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
        **/
       subscribeJustifications: AugmentedRpc<() => Observable<JustificationNotification>>;
     };
+    mmr: {
+      /**
+       * Generate MMR proof for given leaf index.
+       **/
+      generateProof: AugmentedRpc<(leafIndex: u64 | AnyNumber | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<MmrLeafProof>>;
+    };
     net: {
       /**
        * Returns true if client is actively listening for network connections. Otherwise false.
@@ -333,11 +351,11 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
       /**
        * Get offchain local storage under given key and prefix
        **/
-      localStorageGet: AugmentedRpc<(kind: StorageKind | '__UNUSED' | 'PERSISTENT' | 'LOCAL' | number | Uint8Array, key: Bytes | string | Uint8Array) => Observable<Option<Bytes>>>;
+      localStorageGet: AugmentedRpc<(kind: StorageKind | 'PERSISTENT' | 'LOCAL' | number | Uint8Array, key: Bytes | string | Uint8Array) => Observable<Option<Bytes>>>;
       /**
        * Set offchain local storage under given key and prefix
        **/
-      localStorageSet: AugmentedRpc<(kind: StorageKind | '__UNUSED' | 'PERSISTENT' | 'LOCAL' | number | Uint8Array, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => Observable<Null>>;
+      localStorageSet: AugmentedRpc<(kind: StorageKind | 'PERSISTENT' | 'LOCAL' | number | Uint8Array, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => Observable<Null>>;
     };
     payment: {
       /**
@@ -364,6 +382,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
        **/
@@ -428,6 +450,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: {
       /**
@@ -496,6 +522,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
        **/

packages/api/src/augment/tx.ts

@@ -3,22 +3,23 @@
 
 import type { Bytes, Compact, Data, Option, U8aFixed, Vec, bool, u16, u32, u64, u8 } from '@polkadot/types';
 import type { AnyNumber, ITuple } from '@polkadot/types/types';
-import type { TAssetBalance } from '@polkadot/types/interfaces/assets';
+import type { AssetDestroyWitness, TAssetBalance } from '@polkadot/types/interfaces/assets';
-import type { BabeEquivocationProof } from '@polkadot/types/interfaces/babe';
+import type { BabeEquivocationProof, NextConfigDescriptor } from '@polkadot/types/interfaces/babe';
 import type { MemberCount, ProposalIndex } from '@polkadot/types/interfaces/collective';
-import type { CodeHash, Gas, Schedule } from '@polkadot/types/interfaces/contracts';
+import type { CodeHash } from '@polkadot/types/interfaces/contracts';
 import type { AccountVote, Conviction, PropIndex, Proposal, ReferendumIndex } from '@polkadot/types/interfaces/democracy';
 import type { Renouncing } from '@polkadot/types/interfaces/elections';
 import type { Extrinsic, Signature } from '@polkadot/types/interfaces/extrinsics';
+import type { ActiveIndex } from '@polkadot/types/interfaces/gilt';
 import type { GrandpaEquivocationProof, KeyOwnerProof } from '@polkadot/types/interfaces/grandpa';
 import type { IdentityFields, IdentityInfo, IdentityJudgement, RegistrarIndex } from '@polkadot/types/interfaces/identity';
 import type { Heartbeat } from '@polkadot/types/interfaces/imOnline';
 import type { ProxyType } from '@polkadot/types/interfaces/proxy';
-import type { AccountId, AccountIndex, AssetId, Balance, BalanceOf, BlockNumber, Call, CallHashOf, ChangesTrieConfiguration, Hash, Header, KeyValue, LookupSource, Moment, OpaqueCall, Perbill, Percent, Weight } from '@polkadot/types/interfaces/runtime';
+import type { AccountId, AccountIndex, AssetId, Balance, BalanceOf, BlockNumber, Call, CallHashOf, ChangesTrieConfiguration, Hash, Header, KeyValue, LookupSource, Moment, OpaqueCall, Perbill, Percent, Perquintill, Weight } from '@polkadot/types/interfaces/runtime';
 import type { Period, Priority } from '@polkadot/types/interfaces/scheduler';
 import type { Keys } from '@polkadot/types/interfaces/session';
 import type { SocietyJudgement } from '@polkadot/types/interfaces/society';
-import type { CompactAssignments, ElectionScore, ElectionSize, EraIndex, RewardDestination, ValidatorIndex, ValidatorPrefs } from '@polkadot/types/interfaces/staking';
+import type { EraIndex, RawSolution, RewardDestination, SolutionOrSnapshotSize, ValidatorPrefs } from '@polkadot/types/interfaces/staking';
 import type { Key } from '@polkadot/types/interfaces/system';
 import type { BountyIndex } from '@polkadot/types/interfaces/treasury';
 import type { Timepoint } from '@polkadot/types/interfaces/utility';
@@ -28,7 +29,29 @@ import type { ApiTypes, SubmittableExtrinsic } from '@polkadot/api/types';
 declare module '@polkadot/api/types/submittable' {
   export interface AugmentedSubmittables<ApiType> {
     assets: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
+      /**
+       * Approve an amount of asset for transfer by a delegated third-party account.
+       * 
+       * Origin must be Signed.
+       * 
+       * Ensures that `ApprovalDeposit` worth of `Currency` is reserved from signing account
+       * for the purpose of holding the approval. If some non-zero amount of assets is already
+       * approved from signing account to `delegate`, then it is topped up or unreserved to
+       * meet the right value.
+       * 
+       * NOTE: The signing account does not need to own `amount` of assets at the point of
+       * making this call.
+       * 
+       * - `id`: The identifier of the asset.
+       * - `delegate`: The account to delegate permission to transfer asset.
+       * - `amount`: The amount of asset that may be transferred by `delegate`. If there is
+       * already an approval in place, then this acts additively.
+       * 
+       * Emits `ApprovedTransfer` on success.
+       * 
+       * Weight: `O(1)`
+       **/
+      approveTransfer: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, delegate: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, Compact<TAssetBalance>]>;
       /**
        * Reduce the balance of `who` by as much as possible up to `amount` assets of `id`.
        * 
@@ -47,24 +70,50 @@ declare module '@polkadot/api/types/submittable' {
        * Modes: Post-existence of `who`; Pre & post Zombie-status of `who`.
        **/
       burn: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, who: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, Compact<TAssetBalance>]>;
+      /**
+       * Cancel all of some asset approved for delegated transfer by a third-party account.
+       * 
+       * Origin must be Signed and there must be an approval in place between signer and
+       * `delegate`.
+       * 
+       * Unreserves any deposit previously reserved by `approve_transfer` for the approval.
+       * 
+       * - `id`: The identifier of the asset.
+       * - `delegate`: The account delegated permission to transfer asset.
+       * 
+       * Emits `ApprovalCancelled` on success.
+       * 
+       * Weight: `O(1)`
+       **/
+      cancelApproval: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, delegate: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource]>;
+      /**
+       * Clear the metadata for an asset.
+       * 
+       * Origin must be Signed and the sender should be the Owner of the asset `id`.
+       * 
+       * Any deposit is freed for the asset owner.
+       * 
+       * - `id`: The identifier of the asset to clear.
+       * 
+       * Emits `MetadataCleared`.
+       * 
+       * Weight: `O(1)`
+       **/
+      clearMetadata: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>]>;
       /**
        * Issue a new class of fungible assets from a public origin.
        * 
-       * This new asset class has no assets initially.
+       * This new asset class has no assets initially and its owner is the origin.
        * 
        * The origin must be Signed and the sender must have sufficient funds free.
        * 
-       * Funds of sender are reserved according to the formula:
+       * Funds of sender are reserved by `AssetDeposit`.
-       * `AssetDepositBase + AssetDepositPerZombie * max_zombies`.
        * 
        * Parameters:
        * - `id`: The identifier of the new asset. This must not be currently in use to identify
        * an existing asset.
-       * - `owner`: The owner of this class of assets. The owner has full superuser permissions
+       * - `admin`: The admin of this class of assets. The admin is the initial address of each
-       * over this asset, but may later change and configure the permissions using `transfer_ownership`
+       * member of the asset class's admin team.
-       * and `set_team`.
-       * - `max_zombies`: The total number of accounts which may hold assets in this class yet
-       * have no existential deposit.
        * - `min_balance`: The minimum balance of this new asset that any single account must
        * have. If an account's balance is reduced below this, then it collapses to zero.
        * 
@@ -72,20 +121,79 @@ declare module '@polkadot/api/types/submittable' {
        * 
        * Weight: `O(1)`
        **/
-      create: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, admin: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, maxZombies: u32 | AnyNumber | Uint8Array, minBalance: TAssetBalance | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, u32, TAssetBalance]>;
+      create: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, admin: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, minBalance: TAssetBalance | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, TAssetBalance]>;
       /**
-       * Destroy a class of fungible assets owned by the sender.
+       * Destroy a class of fungible assets.
        * 
-       * The origin must be Signed and the sender must be the owner of the asset `id`.
+       * The origin must conform to `ForceOrigin` or must be Signed and the sender must be the
+       * owner of the asset `id`.
        * 
        * - `id`: The identifier of the asset to be destroyed. This must identify an existing
        * asset.
        * 
        * Emits `Destroyed` event when successful.
        * 
-       * Weight: `O(z)` where `z` is the number of zombie accounts.
+       * Weight: `O(c + p + a)` where:
+       * - `c = (witness.accounts - witness.sufficients)`
+       * - `s = witness.sufficients`
+       * - `a = witness.approvals`
        **/
-      destroy: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, zombiesWitness: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, Compact<u32>]>;
+      destroy: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, witness: AssetDestroyWitness | { accounts?: any; sufficients?: any; approvals?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, AssetDestroyWitness]>;
+      /**
+       * Alter the attributes of a given asset.
+       * 
+       * Origin must be `ForceOrigin`.
+       * 
+       * - `id`: The identifier of the asset.
+       * - `owner`: The new Owner of this asset.
+       * - `issuer`: The new Issuer of this asset.
+       * - `admin`: The new Admin of this asset.
+       * - `freezer`: The new Freezer of this asset.
+       * - `min_balance`: The minimum balance of this new asset that any single account must
+       * have. If an account's balance is reduced below this, then it collapses to zero.
+       * - `is_sufficient`: Whether a non-zero balance of this asset is deposit of sufficient
+       * value to account for the state bloat associated with its balance storage. If set to
+       * `true`, then non-zero balances may be stored without a `consumer` reference (and thus
+       * an ED in the Balances pallet or whatever else is used to control user-account state
+       * growth).
+       * - `is_frozen`: Whether this asset class is frozen except for permissioned/admin
+       * instructions.
+       * 
+       * Emits `AssetStatusChanged` with the identity of the asset.
+       * 
+       * Weight: `O(1)`
+       **/
+      forceAssetStatus: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, owner: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, issuer: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, admin: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, freezer: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, minBalance: Compact<TAssetBalance> | AnyNumber | Uint8Array, isSufficient: bool | boolean | Uint8Array, isFrozen: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, LookupSource, LookupSource, LookupSource, Compact<TAssetBalance>, bool, bool]>;
+      /**
+       * Cancel all of some asset approved for delegated transfer by a third-party account.
+       * 
+       * Origin must be either ForceOrigin or Signed origin with the signer being the Admin
+       * account of the asset `id`.
+       * 
+       * Unreserves any deposit previously reserved by `approve_transfer` for the approval.
+       * 
+       * - `id`: The identifier of the asset.
+       * - `delegate`: The account delegated permission to transfer asset.
+       * 
+       * Emits `ApprovalCancelled` on success.
+       * 
+       * Weight: `O(1)`
+       **/
+      forceCancelApproval: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, owner: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, delegate: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, LookupSource]>;
+      /**
+       * Clear the metadata for an asset.
+       * 
+       * Origin must be ForceOrigin.
+       * 
+       * Any deposit is returned.
+       * 
+       * - `id`: The identifier of the asset to clear.
+       * 
+       * Emits `MetadataCleared`.
+       * 
+       * Weight: `O(1)`
+       **/
+      forceClearMetadata: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>]>;
       /**
        * Issue a new class of fungible assets from a privileged origin.
        * 
@@ -109,20 +217,24 @@ declare module '@polkadot/api/types/submittable' {
        * 
        * Weight: `O(1)`
        **/
-      forceCreate: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, owner: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, maxZombies: Compact<u32> | AnyNumber | Uint8Array, minBalance: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, Compact<u32>, Compact<TAssetBalance>]>;
+      forceCreate: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, owner: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, isSufficient: bool | boolean | Uint8Array, minBalance: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, bool, Compact<TAssetBalance>]>;
       /**
-       * Destroy a class of fungible assets.
+       * Force the metadata for an asset to some value.
        * 
-       * The origin must conform to `ForceOrigin`.
+       * Origin must be ForceOrigin.
        * 
-       * - `id`: The identifier of the asset to be destroyed. This must identify an existing
+       * Any deposit is left alone.
-       * asset.
        * 
-       * Emits `Destroyed` event when successful.
+       * - `id`: The identifier of the asset to update.
+       * - `name`: The user friendly name of this asset. Limited in length by `StringLimit`.
+       * - `symbol`: The exchange symbol for this asset. Limited in length by `StringLimit`.
+       * - `decimals`: The number of decimals this asset uses to represent one unit.
        * 
-       * Weight: `O(1)`
+       * Emits `MetadataSet`.
+       * 
+       * Weight: `O(N + S)` where N and S are the length of the name and symbol respectively.
        **/
-      forceDestroy: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, zombiesWitness: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, Compact<u32>]>;
+      forceSetMetadata: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, name: Bytes | string | Uint8Array, symbol: Bytes | string | Uint8Array, decimals: u8 | AnyNumber | Uint8Array, isFrozen: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, Bytes, Bytes, u8, bool]>;
       /**
        * Move some assets from one account to another.
        * 
@@ -185,30 +297,9 @@ declare module '@polkadot/api/types/submittable' {
        * Modes: Pre-existing balance of `beneficiary`; Account pre-existence of `beneficiary`.
        **/
       mint: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, beneficiary: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, Compact<TAssetBalance>]>;
-      /**
-       * Set the maximum number of zombie accounts for an asset.
-       * 
-       * Origin must be Signed and the sender should be the Owner of the asset `id`.
-       * 
-       * Funds of sender are reserved according to the formula:
-       * `AssetDepositBase + AssetDepositPerZombie * max_zombies` taking into account
-       * any already reserved funds.
-       * 
-       * - `id`: The identifier of the asset to update zombie count.
-       * - `max_zombies`: The new number of zombies allowed for this asset.
-       * 
-       * Emits `MaxZombiesChanged`.
-       * 
-       * Weight: `O(1)`
-       **/
-      setMaxZombies: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, maxZombies: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, Compact<u32>]>;
       /**
        * Set the metadata for an asset.
        * 
-       * NOTE: There is no `unset_metadata` call. Simply pass an empty name, symbol,
-       * and 0 decimals to this function to remove the metadata of an asset and
-       * return your deposit.
-       * 
        * Origin must be Signed and the sender should be the Owner of the asset `id`.
        * 
        * Funds of sender are reserved according to the formula:
@@ -220,7 +311,7 @@ declare module '@polkadot/api/types/submittable' {
        * - `symbol`: The exchange symbol for this asset. Limited in length by `StringLimit`.
        * - `decimals`: The number of decimals this asset uses to represent one unit.
        * 
-       * Emits `MaxZombiesChanged`.
+       * Emits `MetadataSet`.
        * 
        * Weight: `O(1)`
        **/
@@ -286,12 +377,54 @@ declare module '@polkadot/api/types/submittable' {
        * of sender; Account pre-existence of `target`.
        **/
       transfer: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, target: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, Compact<TAssetBalance>]>;
+      /**
+       * Transfer some asset balance from a previously delegated account to some third-party
+       * account.
+       * 
+       * Origin must be Signed and there must be an approval in place by the `owner` to the
+       * signer.
+       * 
+       * If the entire amount approved for transfer is transferred, then any deposit previously
+       * reserved by `approve_transfer` is unreserved.
+       * 
+       * - `id`: The identifier of the asset.
+       * - `owner`: The account which previously approved for a transfer of at least `amount` and
+       * from which the asset balance will be withdrawn.
+       * - `destination`: The account to which the asset balance of `amount` will be transferred.
+       * - `amount`: The amount of assets to transfer.
+       * 
+       * Emits `TransferredApproved` on success.
+       * 
+       * Weight: `O(1)`
+       **/
+      transferApproved: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, owner: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, destination: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, LookupSource, Compact<TAssetBalance>]>;
+      /**
+       * Move some assets from the sender account to another, keeping the sender account alive.
+       * 
+       * Origin must be Signed.
+       * 
+       * - `id`: The identifier of the asset to have some amount transferred.
+       * - `target`: The account to be credited.
+       * - `amount`: The amount by which the sender's balance of assets should be reduced and
+       * `target`'s balance increased. The amount actually transferred may be slightly greater in
+       * the case that the transfer would otherwise take the sender balance above zero but below
+       * the minimum balance. Must be greater than zero.
+       * 
+       * Emits `Transferred` with the actual amount transferred. If this takes the source balance
+       * to below the minimum for the asset, then the amount transferred is increased to take it
+       * to zero.
+       * 
+       * Weight: `O(1)`
+       * Modes: Pre-existence of `target`; Post-existence of sender; Prior & post zombie-status
+       * of sender; Account pre-existence of `target`.
+       **/
+      transferKeepAlive: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, target: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: Compact<TAssetBalance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource, Compact<TAssetBalance>]>;
       /**
        * Change the Owner of an asset.
        * 
        * Origin must be Signed and the sender should be the Owner of the asset `id`.
        * 
-       * - `id`: The identifier of the asset to be frozen.
+       * - `id`: The identifier of the asset.
        * - `owner`: The new Owner of this asset.
        * 
        * Emits `OwnerChanged`.
@@ -299,16 +432,29 @@ declare module '@polkadot/api/types/submittable' {
        * Weight: `O(1)`
        **/
       transferOwnership: AugmentedSubmittable<(id: Compact<AssetId> | AnyNumber | Uint8Array, owner: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<AssetId>, LookupSource]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     authorship: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Provide a set of uncles.
        **/
       setUncles: AugmentedSubmittable<(newUncles: Vec<Header> | (Header | { parentHash?: any; number?: any; stateRoot?: any; extrinsicsRoot?: any; digest?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Header>]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     babe: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
+      /**
+       * Plan an epoch config change. The epoch config change is recorded and will be enacted on
+       * the next call to `enact_epoch_change`. The config will be activated one epoch after.
+       * Multiple calls to this method will replace any existing planned config change that had
+       * not been enacted yet.
+       **/
+      planConfigChange: AugmentedSubmittable<(config: NextConfigDescriptor | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NextConfigDescriptor]>;
       /**
        * Report authority equivocation/misbehavior. This method will verify
        * the equivocation proof and validate the given key ownership proof
@@ -327,9 +473,12 @@ declare module '@polkadot/api/types/submittable' {
        * reporter.
        **/
       reportEquivocationUnsigned: AugmentedSubmittable<(equivocationProof: BabeEquivocationProof | { offender?: any; slotNumber?: any; firstHeader?: any; secondHeader?: any } | string | Uint8Array, keyOwnerProof: KeyOwnerProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [BabeEquivocationProof, KeyOwnerProof]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     balances: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Exactly as `transfer`, except the origin must be root and the source account may be
        * specified.
@@ -396,7 +545,7 @@ declare module '@polkadot/api/types/submittable' {
        * 
        * 99% of the time you want [`transfer`] instead.
        * 
-       * [`transfer`]: struct.Module.html#method.transfer
+       * [`transfer`]: struct.Pallet.html#method.transfer
        * # <weight>
        * - Cheaper than transfer because account cannot be killed.
        * - Base Weight: 51.4 µs
@@ -404,9 +553,12 @@ declare module '@polkadot/api/types/submittable' {
        * #</weight>
        **/
       transferKeepAlive: AugmentedSubmittable<(dest: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<Balance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<Balance>]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     bounties: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Accept the curator role for a bounty.
        * A deposit will be reserved from curator and refund upon successful payout.
@@ -526,9 +678,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       unassignCurator: AugmentedSubmittable<(bountyId: Compact<BountyIndex> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BountyIndex>]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     contracts: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Makes a call to an account, optionally transferring some balance.
        * 
@@ -538,7 +693,7 @@ declare module '@polkadot/api/types/submittable' {
        * * If no account exists and the call value is not less than `existential_deposit`,
        * a regular account will be created and any value will be transferred.
        **/
-      call: AugmentedSubmittable<(dest: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<BalanceOf> | AnyNumber | Uint8Array, gasLimit: Compact<Gas> | AnyNumber | Uint8Array, data: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<BalanceOf>, Compact<Gas>, Bytes]>;
+      call: AugmentedSubmittable<(dest: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<BalanceOf> | AnyNumber | Uint8Array, gasLimit: Compact<Weight> | AnyNumber | Uint8Array, data: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<BalanceOf>, Compact<Weight>, Bytes]>;
       /**
        * Allows block producers to claim a small reward for evicting a contract. If a block
        * producer fails to do so, a regular users will be allowed to claim the reward.
@@ -558,7 +713,7 @@ declare module '@polkadot/api/types/submittable' {
        * code deployment step. Instead, the `code_hash` of an on-chain deployed wasm binary
        * must be supplied.
        **/
-      instantiate: AugmentedSubmittable<(endowment: Compact<BalanceOf> | AnyNumber | Uint8Array, gasLimit: Compact<Gas> | AnyNumber | Uint8Array, codeHash: CodeHash | string | Uint8Array, data: Bytes | string | Uint8Array, salt: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>, Compact<Gas>, CodeHash, Bytes, Bytes]>;
+      instantiate: AugmentedSubmittable<(endowment: Compact<BalanceOf> | AnyNumber | Uint8Array, gasLimit: Compact<Weight> | AnyNumber | Uint8Array, codeHash: CodeHash | string | Uint8Array, data: Bytes | string | Uint8Array, salt: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>, Compact<Weight>, CodeHash, Bytes, Bytes]>;
       /**
        * Instantiates a new contract from the supplied `code` optionally transferring
        * some balance.
@@ -571,7 +726,7 @@ declare module '@polkadot/api/types/submittable' {
        * * `gas_limit`: The gas limit enforced when executing the constructor.
        * * `code`: The contract code to deploy in raw bytes.
        * * `data`: The input data to pass to the contract constructor.
-       * * `salt`: Used for the address derivation. See [`Self::contract_address`].
+       * * `salt`: Used for the address derivation. See [`Pallet::contract_address`].
        * 
        * Instantiation is executed as follows:
        * 
@@ -582,16 +737,13 @@ declare module '@polkadot/api/types/submittable' {
        * - The `endowment` is transferred to the new account.
        * - The `deploy` function is executed in the context of the newly-created account.
        **/
-      instantiateWithCode: AugmentedSubmittable<(endowment: Compact<BalanceOf> | AnyNumber | Uint8Array, gasLimit: Compact<Gas> | AnyNumber | Uint8Array, code: Bytes | string | Uint8Array, data: Bytes | string | Uint8Array, salt: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>, Compact<Gas>, Bytes, Bytes, Bytes]>;
+      instantiateWithCode: AugmentedSubmittable<(endowment: Compact<BalanceOf> | AnyNumber | Uint8Array, gasLimit: Compact<Weight> | AnyNumber | Uint8Array, code: Bytes | string | Uint8Array, data: Bytes | string | Uint8Array, salt: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>, Compact<Weight>, Bytes, Bytes, Bytes]>;
       /**
-       * Updates the schedule for metering contracts.
+       * Generic tx
-       * 
-       * The schedule must have a greater version than the stored schedule.
        **/
-      updateSchedule: AugmentedSubmittable<(schedule: Schedule | { version?: any; enablePrintln?: any; limits?: any; instructionWeights?: any; hostFnWeights?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Schedule]>;
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     council: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Close a vote that is either approved, disapproved or whose voting period has ended.
        * 
@@ -728,9 +880,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       vote: AugmentedSubmittable<(proposal: Hash | string | Uint8Array, index: Compact<ProposalIndex> | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash, Compact<ProposalIndex>, bool]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     democracy: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Permanently place a proposal into the blacklist. This prevents it from ever being
        * proposed again.
@@ -1061,9 +1216,35 @@ declare module '@polkadot/api/types/submittable' {
        * Weight: `O(R)` where R is the number of referendums the voter has voted on.
        **/
       vote: AugmentedSubmittable<(refIndex: Compact<ReferendumIndex> | AnyNumber | Uint8Array, vote: AccountVote | { Standard: any } | { Split: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<ReferendumIndex>, AccountVote]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
+    };
+    electionProviderMultiPhase: {
+      /**
+       * Submit a solution for the unsigned phase.
+       * 
+       * The dispatch origin fo this call must be __none__.
+       * 
+       * This submission is checked on the fly. Moreover, this unsigned solution is only
+       * validated when submitted to the pool from the **local** node. Effectively, this means
+       * that only active validators can submit this transaction when authoring a block (similar
+       * to an inherent).
+       * 
+       * To prevent any incorrect solution (and thus wasted time/weight), this transaction will
+       * panic if the solution submitted by the validator is invalid in any way, effectively
+       * putting their authoring reward at risk.
+       * 
+       * No deposit or reward is associated with this submission.
+       **/
+      submitUnsigned: AugmentedSubmittable<(solution: RawSolution | { compact?: any; score?: any; round?: any } | string | Uint8Array, witness: SolutionOrSnapshotSize | { voters?: any; targets?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [RawSolution, SolutionOrSnapshotSize]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     elections: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Clean all voters who are defunct (i.e. they do not serve any purpose at all). The
        * deposit of the removed voters are returned.
@@ -1112,8 +1293,8 @@ declare module '@polkadot/api/types/submittable' {
        * origin is removed as a runner-up.
        * - `origin` is a current member. In this case, the deposit is unreserved and origin is
        * removed as a member, consequently not being a candidate for the next round anymore.
-       * Similar to [`remove_members`], if replacement runners exists, they are immediately used.
+       * Similar to [`remove_members`], if replacement runners exists, they are immediately
-       * If the prime is renouncing, then no prime will exist until the next round.
+       * used. If the prime is renouncing, then no prime will exist until the next round.
        * 
        * The dispatch origin of this call must be signed, and have one of the above roles.
        * 
@@ -1166,9 +1347,63 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       vote: AugmentedSubmittable<(votes: Vec<AccountId> | (AccountId | string | Uint8Array)[], value: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId>, Compact<BalanceOf>]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
+    };
+    gilt: {
+      /**
+       * Place a bid for a gilt to be issued.
+       * 
+       * Origin must be Signed, and account must have at least `amount` in free balance.
+       * 
+       * - `amount`: The amount of the bid; these funds will be reserved. If the bid is
+       * successfully elevated into an issued gilt, then these funds will continue to be
+       * reserved until the gilt expires. Must be at least `MinFreeze`.
+       * - `duration`: The number of periods for which the funds will be locked if the gilt is
+       * issued. It will expire only after this period has elapsed after the point of issuance.
+       * Must be greater than 1 and no more than `QueueCount`.
+       * 
+       * Complexities:
+       * - `Queues[duration].len()` (just take max).
+       **/
+      placeBid: AugmentedSubmittable<(amount: Compact<BalanceOf> | AnyNumber | Uint8Array, duration: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>, u32]>;
+      /**
+       * Retract a previously placed bid.
+       * 
+       * Origin must be Signed, and the account should have previously issued a still-active bid
+       * of `amount` for `duration`.
+       * 
+       * - `amount`: The amount of the previous bid.
+       * - `duration`: The duration of the previous bid.
+       **/
+      retractBid: AugmentedSubmittable<(amount: Compact<BalanceOf> | AnyNumber | Uint8Array, duration: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<BalanceOf>, u32]>;
+      /**
+       * Set target proportion of gilt-funds.
+       * 
+       * Origin must be `AdminOrigin`.
+       * 
+       * - `target`: The target proportion of effective issued funds that should be under gilts
+       * at any one time.
+       **/
+      setTarget: AugmentedSubmittable<(target: Compact<Perquintill> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<Perquintill>]>;
+      /**
+       * Remove an active but expired gilt. Reserved funds under gilt are freed and balance is
+       * adjusted to ensure that the funds grow or shrink to maintain the equivalent proportion
+       * of effective total issued funds.
+       * 
+       * Origin must be Signed and the account must be the owner of the gilt of the given index.
+       * 
+       * - `index`: The index of the gilt to be thawed.
+       **/
+      thaw: AugmentedSubmittable<(index: Compact<ActiveIndex> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<ActiveIndex>]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     grandpa: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Note that the current authority set of the GRANDPA finality gadget has
        * stalled. This will trigger a forced authority set change at the beginning
@@ -1198,9 +1433,12 @@ declare module '@polkadot/api/types/submittable' {
        * reporter.
        **/
       reportEquivocationUnsigned: AugmentedSubmittable<(equivocationProof: GrandpaEquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: KeyOwnerProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [GrandpaEquivocationProof, KeyOwnerProof]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     identity: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Add a registrar to the system.
        * 
@@ -1462,9 +1700,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       setSubs: AugmentedSubmittable<(subs: Vec<ITuple<[AccountId, Data]>> | ([AccountId | string | Uint8Array, Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[AccountId, Data]>>]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     imOnline: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * # <weight>
        * - Complexity: `O(K + E)` where K is length of `Keys` (heartbeat.validators_len)
@@ -1477,9 +1718,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       heartbeat: AugmentedSubmittable<(heartbeat: Heartbeat | { blockNumber?: any; networkState?: any; sessionIndex?: any; authorityIndex?: any; validatorsLen?: any } | string | Uint8Array, signature: Signature | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Heartbeat, Signature]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     indices: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Assign an previously unassigned index.
        * 
@@ -1589,9 +1833,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       transfer: AugmentedSubmittable<(updated: AccountId | string | Uint8Array, index: AccountIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, AccountIndex]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     lottery: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Buy a ticket to enter the lottery.
        * 
@@ -1635,9 +1882,12 @@ declare module '@polkadot/api/types/submittable' {
        * This extrinsic must be called by the `ManagerOrigin`.
        **/
       stopRepeat: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     multisig: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Register approval for a dispatch to be made from a deterministic composite account if
        * approved by a total of `threshold - 1` of `other_signatories`.
@@ -1774,9 +2024,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       cancelAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId> | (AccountId | string | Uint8Array)[], timepoint: Timepoint | { height?: any; index?: any } | string | Uint8Array, callHash: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16, Vec<AccountId>, Timepoint, U8aFixed]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     proxy: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Register a proxy account for the sender that is able to make calls on its behalf.
        * 
@@ -1885,7 +2138,7 @@ declare module '@polkadot/api/types/submittable' {
        **/
       proxy: AugmentedSubmittable<(real: AccountId | string | Uint8Array, forceProxyType: Option<ProxyType> | null | object | string | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, Option<ProxyType>, Call]>;
       /**
-       * Dispatch the given `call` from an account that the sender is authorised for through
+       * Dispatch the given `call` from an account that the sender is authorized for through
        * `add_proxy`.
        * 
        * Removes any corresponding announcement(s).
@@ -1969,9 +2222,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       removeProxy: AugmentedSubmittable<(delegate: AccountId | string | Uint8Array, proxyType: ProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | number | Uint8Array, delay: BlockNumber | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, ProxyType, BlockNumber]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     recovery: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Send a call through a recovered account.
        * 
@@ -2171,9 +2427,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       vouchRecovery: AugmentedSubmittable<(lost: AccountId | string | Uint8Array, rescuer: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, AccountId]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     scheduler: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Cancel an anonymously scheduled task.
        * 
@@ -2242,9 +2501,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       scheduleNamedAfter: AugmentedSubmittable<(id: Bytes | string | Uint8Array, after: BlockNumber | AnyNumber | Uint8Array, maybePeriodic: Option<Period> | null | object | string | Uint8Array, priority: Priority | AnyNumber | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, BlockNumber, Option<Period>, Priority, Call]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     session: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Removes any session key(s) of the function caller.
        * This doesn't take effect until the next session.
@@ -2277,9 +2539,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       setKeys: AugmentedSubmittable<(keys: Keys, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Keys, Bytes]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     society: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * A user outside of the society can make a bid for entry.
        * 
@@ -2597,9 +2862,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       vouch: AugmentedSubmittable<(who: AccountId | string | Uint8Array, value: BalanceOf | AnyNumber | Uint8Array, tip: BalanceOf | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, BalanceOf, BalanceOf]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     staking: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Take the origin account as a stash and lock up `value` of its balance. `controller` will
        * be the account that controls it.
@@ -2624,7 +2892,7 @@ declare module '@polkadot/api/types/submittable' {
        * - Write: Bonded, Payee, [Origin Account], Locks, Ledger
        * # </weight>
        **/
-      bond: AugmentedSubmittable<(controller: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<BalanceOf> | AnyNumber | Uint8Array, payee: RewardDestination | { Staked: any } | { Stash: any } | { Controller: any } | { Account: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<BalanceOf>, RewardDestination]>;
+      bond: AugmentedSubmittable<(controller: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<BalanceOf> | AnyNumber | Uint8Array, payee: RewardDestination | { Staked: any } | { Stash: any } | { Controller: any } | { Account: any } | { None: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<BalanceOf>, RewardDestination]>;
       /**
        * Add some extra amount that have appeared in the stash `free_balance` into the balance up
        * for staking.
@@ -2930,7 +3198,7 @@ declare module '@polkadot/api/types/submittable' {
        * - Write: Payee
        * # </weight>
        **/
-      setPayee: AugmentedSubmittable<(payee: RewardDestination | { Staked: any } | { Stash: any } | { Controller: any } | { Account: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [RewardDestination]>;
+      setPayee: AugmentedSubmittable<(payee: RewardDestination | { Staked: any } | { Stash: any } | { Controller: any } | { Account: any } | { None: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [RewardDestination]>;
       /**
        * Sets the ideal number of validators.
        * 
@@ -2942,70 +3210,6 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       setValidatorCount: AugmentedSubmittable<(updated: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
-      /**
-       * Submit an election result to the chain. If the solution:
-       * 
-       * 1. is valid.
-       * 2. has a better score than a potentially existing solution on chain.
-       * 
-       * then, it will be _put_ on chain.
-       * 
-       * A solution consists of two pieces of data:
-       * 
-       * 1. `winners`: a flat vector of all the winners of the round.
-       * 2. `assignments`: the compact version of an assignment vector that encodes the edge
-       * weights.
-       * 
-       * Both of which may be computed using _phragmen_, or any other algorithm.
-       * 
-       * Additionally, the submitter must provide:
-       * 
-       * - The `score` that they claim their solution has.
-       * 
-       * Both validators and nominators will be represented by indices in the solution. The
-       * indices should respect the corresponding types ([`ValidatorIndex`] and
-       * [`NominatorIndex`]). Moreover, they should be valid when used to index into
-       * [`SnapshotValidators`] and [`SnapshotNominators`]. Any invalid index will cause the
-       * solution to be rejected. These two storage items are set during the election window and
-       * may be used to determine the indices.
-       * 
-       * A solution is valid if:
-       * 
-       * 0. It is submitted when [`EraElectionStatus`] is `Open`.
-       * 1. Its claimed score is equal to the score computed on-chain.
-       * 2. Presents the correct number of winners.
-       * 3. All indexes must be value according to the snapshot vectors. All edge values must
-       * also be correct and should not overflow the granularity of the ratio type (i.e. 256
-       * or billion).
-       * 4. For each edge, all targets are actually nominated by the voter.
-       * 5. Has correct self-votes.
-       * 
-       * A solutions score is consisted of 3 parameters:
-       * 
-       * 1. `min { support.total }` for each support of a winner. This value should be maximized.
-       * 2. `sum { support.total }` for each support of a winner. This value should be minimized.
-       * 3. `sum { support.total^2 }` for each support of a winner. This value should be
-       * minimized (to ensure less variance)
-       * 
-       * # <weight>
-       * The transaction is assumed to be the longest path, a better solution.
-       * - Initial solution is almost the same.
-       * - Worse solution is retraced in pre-dispatch-checks which sets its own weight.
-       * # </weight>
-       **/
-      submitElectionSolution: AugmentedSubmittable<(winners: Vec<ValidatorIndex> | (ValidatorIndex | AnyNumber | Uint8Array)[], compact: CompactAssignments | { votes1?: any; votes2?: any; votes3?: any; votes4?: any; votes5?: any; votes6?: any; votes7?: any; votes8?: any; votes9?: any; votes10?: any; votes11?: any; votes12?: any; votes13?: any; votes14?: any; votes15?: any; votes16?: any } | string | Uint8Array, score: ElectionScore, era: EraIndex | AnyNumber | Uint8Array, size: ElectionSize | { validators?: any; nominators?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ValidatorIndex>, CompactAssignments, ElectionScore, EraIndex, ElectionSize]>;
-      /**
-       * Unsigned version of `submit_election_solution`.
-       * 
-       * Note that this must pass the [`ValidateUnsigned`] check which only allows transactions
-       * from the local node to be included. In other words, only the block author can include a
-       * transaction in the block.
-       * 
-       * # <weight>
-       * See [`submit_election_solution`].
-       * # </weight>
-       **/
-      submitElectionSolutionUnsigned: AugmentedSubmittable<(winners: Vec<ValidatorIndex> | (ValidatorIndex | AnyNumber | Uint8Array)[], compact: CompactAssignments | { votes1?: any; votes2?: any; votes3?: any; votes4?: any; votes5?: any; votes6?: any; votes7?: any; votes8?: any; votes9?: any; votes10?: any; votes11?: any; votes12?: any; votes13?: any; votes14?: any; votes15?: any; votes16?: any } | string | Uint8Array, score: ElectionScore, era: EraIndex | AnyNumber | Uint8Array, size: ElectionSize | { validators?: any; nominators?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ValidatorIndex>, CompactAssignments, ElectionScore, EraIndex, ElectionSize]>;
       /**
        * Schedule a portion of the stash to be unlocked ready for transfer out after the bond
        * period ends. If this leaves an amount actively bonded less than
@@ -3060,7 +3264,7 @@ declare module '@polkadot/api/types/submittable' {
        * - Write: Nominators, Validators
        * # </weight>
        **/
-      validate: AugmentedSubmittable<(prefs: ValidatorPrefs | { commission?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [ValidatorPrefs]>;
+      validate: AugmentedSubmittable<(prefs: ValidatorPrefs | { commission?: any; blocked?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [ValidatorPrefs]>;
       /**
        * Remove any unlocked chunks from the `unlocking` queue from our management.
        * 
@@ -3095,9 +3299,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       withdrawUnbonded: AugmentedSubmittable<(numSlashingSpans: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     sudo: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo key.
        * 
@@ -3150,9 +3357,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       sudoUncheckedWeight: AugmentedSubmittable<(call: Call | { callIndex?: any; args?: any } | string | Uint8Array, weight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Weight]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     system: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * A dispatch that will fill the block weight up to the given ratio.
        **/
@@ -3187,11 +3397,18 @@ declare module '@polkadot/api/types/submittable' {
        * 
        * # <weight>
        * - `O(1)`
-       * - Base Weight: 0.665 µs, independent of remark length.
-       * - No DB operations.
        * # </weight>
        **/
       remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
+      /**
+       * Make some on-chain remark and emit event.
+       * 
+       * # <weight>
+       * - `O(b)` where b is the length of the remark.
+       * - 1 event.
+       * # </weight>
+       **/
+      remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
       /**
        * Set the new changes trie configuration.
        * 
@@ -3251,9 +3468,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       setStorage: AugmentedSubmittable<(items: Vec<KeyValue> | (KeyValue)[]) => SubmittableExtrinsic<ApiType>, [Vec<KeyValue>]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     technicalCommittee: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Close a vote that is either approved, disapproved or whose voting period has ended.
        * 
@@ -3390,9 +3610,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       vote: AugmentedSubmittable<(proposal: Hash | string | Uint8Array, index: Compact<ProposalIndex> | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [Hash, Compact<ProposalIndex>, bool]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     technicalMembership: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Add a member `who` to the set.
        * 
@@ -3440,9 +3663,12 @@ declare module '@polkadot/api/types/submittable' {
        * Prime membership is *not* passed from `remove` to `add`, if extant.
        **/
       swapMember: AugmentedSubmittable<(remove: AccountId | string | Uint8Array, add: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId, AccountId]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     timestamp: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Set the current time.
        * 
@@ -3461,9 +3687,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       set: AugmentedSubmittable<(now: Compact<Moment> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<Moment>]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     tips: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Close and payout a tip.
        * 
@@ -3596,9 +3825,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       tipNew: AugmentedSubmittable<(reason: Bytes | string | Uint8Array, who: AccountId | string | Uint8Array, tipValue: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, AccountId, Compact<BalanceOf>]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     treasury: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary
        * and the original deposit will be returned.
@@ -3636,9 +3868,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       rejectProposal: AugmentedSubmittable<(proposalId: Compact<ProposalIndex> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<ProposalIndex>]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     utility: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Send a call through an indexed pseudonym of the sender.
        * 
@@ -3692,9 +3927,12 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | { callIndex?: any; args?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
     vesting: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Force a vested transfer.
        * 
@@ -3719,7 +3957,7 @@ declare module '@polkadot/api/types/submittable' {
        * Unlock any vested funds of the sender account.
        * 
        * The dispatch origin for this call must be _Signed_ and the sender must have funds still
-       * locked under this module.
+       * locked under this pallet.
        * 
        * Emits either `VestingCompleted` or `VestingUpdated`.
        * 
@@ -3737,7 +3975,7 @@ declare module '@polkadot/api/types/submittable' {
        * The dispatch origin for this call must be _Signed_.
        * 
        * - `target`: The account whose vested funds should be unlocked. Must have funds still
-       * locked under this module.
+       * locked under this pallet.
        * 
        * Emits either `VestingCompleted` or `VestingUpdated`.
        * 
@@ -3768,6 +4006,10 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       vestedTransfer: AugmentedSubmittable<(target: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, schedule: VestingInfo | { locked?: any; perBlock?: any; startingBlock?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, VestingInfo]>;
+      /**
+       * Generic tx
+       **/
+      [key: string]: SubmittableExtrinsicFunction<ApiType>;
     };
   }
 

packages/api/src/base/Decorate.ts

@@ -39,7 +39,7 @@ interface MetaDecoration {
 }
 
 // the max amount of keys/values that we will retrieve at once
-const PAGE_SIZE = 384;
+const PAGE_SIZE = 256;
 
 const l = logger('api/init');
 
@@ -79,7 +79,7 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
 
   protected _rpc?: DecoratedRpc<ApiType, RpcInterface>;
 
-  protected _rpcCore: RpcCore;
+  protected _rpcCore: RpcCore & RpcInterface;
 
   protected _runtimeChain?: Text;
 
@@ -136,6 +136,7 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
 
     this.#instanceId = `${++instanceCounter}`;
     this.#registry = options.source?.registry || options.registry || new TypeRegistry();
+    this._rx.registry = this.#registry;
 
     const thisProvider = options.source
       ? options.source._rpcCore.provider.clone()
@@ -144,10 +145,11 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
     this._decorateMethod = decorateMethod;
     this._options = options;
     this._type = type;
-    this._rpcCore = new RpcCore(this.#instanceId, this.#registry, thisProvider, this._options.rpc);
+
+    // The RPC interface decorates the known interfaces on init
+    this._rpcCore = new RpcCore(this.#instanceId, this.#registry, thisProvider, this._options.rpc) as (RpcCore & RpcInterface);
     this._isConnected = new BehaviorSubject(this._rpcCore.provider.isConnected);
     this._rx.hasSubscriptions = this._rpcCore.provider.hasSubscriptions;
-    this._rx.registry = this.#registry;
   }
 
   /**
@@ -260,7 +262,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(', ')}`);
@@ -268,20 +271,13 @@ 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
+    deletion.forEach(([, { method, section }]): void => {
-      .filter(([key]): boolean => hasResults
+      delete (this._rpc as Record<string, Record<string, unknown>>)[section][method];
-        ? !exposed.includes(key) && key !== 'rpc_methods' // rpc_methods doesn't appear, v1
+      delete (this._rx.rpc as Record<string, Record<string, unknown>>)[section][method];
-        : 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];
-      });
   }
 
-  protected _decorateRpc<ApiType extends ApiTypes> (rpc: RpcCore, decorateMethod: DecorateMethod<ApiType>, input: Partial<DecoratedRpc<ApiType, RpcInterface>> = {}): DecoratedRpc<ApiType, RpcInterface> {
+  protected _decorateRpc<ApiType extends ApiTypes> (rpc: RpcCore & RpcInterface, decorateMethod: DecorateMethod<ApiType>, input: Partial<DecoratedRpc<ApiType, RpcInterface>> = {}): DecoratedRpc<ApiType, RpcInterface> {
     return rpc.sections.reduce((out, _sectionName): DecoratedRpc<ApiType, RpcInterface> => {
       const sectionName = _sectionName as keyof DecoratedRpc<ApiType, RpcInterface>;
 
@@ -295,6 +291,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;
@@ -358,7 +356,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 */
@@ -367,51 +365,60 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
 
     decorated.creator = creator;
 
-    decorated.at = decorateMethod((hash: Hash, arg1?: Arg, arg2?: Arg): Observable<Codec> =>
+    decorated.at = decorateMethod((hash: Hash, ...args: Arg[]): Observable<Codec> =>
-      this._rpcCore.state.getStorage(getArgs(arg1, arg2), hash));
+      this._rpcCore.state.getStorage(getArgs(args), hash));
 
-    decorated.hash = decorateMethod((arg1?: Arg, arg2?: Arg): Observable<Hash> =>
+    decorated.hash = decorateMethod((...args: Arg[]): Observable<Hash> =>
-      this._rpcCore.state.getStorageHash(getArgs(arg1, arg2)));
+      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 =>
+    decorated.key = (...args: Arg[]): string =>
-      u8aToHex(compactStripLength(creator(creator.meta.type.isDoubleMap ? [arg1, arg2] : arg1))[1]);
+      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 =>
+    decorated.keyPrefix = (...keys: Arg[]): string =>
-      u8aToHex(creator.keyPrefix(key1));
+      u8aToHex(creator.keyPrefix(...keys));
 
-    decorated.range = decorateMethod((range: [Hash, Hash?], arg1?: Arg, arg2?: Arg): Observable<[Hash, Codec][]> =>
+    decorated.range = decorateMethod((range: [Hash, Hash?], ...args: Arg[]): Observable<[Hash, Codec][]> =>
-      this._decorateStorageRange(decorated, [arg1, arg2], range));
+      this._decorateStorageRange(decorated, args, range));
 
-    decorated.size = decorateMethod((arg1?: Arg, arg2?: Arg): Observable<u64> =>
+    decorated.size = decorateMethod((...args: Arg[]): Observable<u64> =>
-      this._rpcCore.state.getStorageSize(getArgs(arg1, arg2)));
+      this._rpcCore.state.getStorageSize(getArgs(args)));
 
-    decorated.sizeAt = decorateMethod((hash: Hash | Uint8Array | string, arg1?: Arg, arg2?: Arg): Observable<u64> =>
+    decorated.sizeAt = decorateMethod((hash: Hash | Uint8Array | string, ...args: Arg[]): Observable<u64> =>
-      this._rpcCore.state.getStorageSize(getArgs(arg1, arg2), hash));
+      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][]> =>
+        memo(this.#instanceId, (...args: Arg[]): Observable<[StorageKey, Codec][]> =>
-          this._retrieveMapEntries(creator, null, doubleMapArg)));
+          this._retrieveMapEntries(creator, null, args)));
 
       decorated.entriesAt = decorateMethod(
-        memo(this.#instanceId, (hash: Hash | Uint8Array | string, doubleMapArg?: Arg): Observable<[StorageKey, Codec][]> =>
+        memo(this.#instanceId, (hash: Hash | Uint8Array | string, ...args: Arg[]): Observable<[StorageKey, Codec][]> =>
-          this._retrieveMapEntries(creator, hash, doubleMapArg)));
+          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[]> =>
+        memo(this.#instanceId, (...args: Arg[]): Observable<StorageKey[]> =>
-          this._retrieveMapKeys(creator, null, doubleMapArg)));
+          this._retrieveMapKeys(creator, null, args)));
 
       decorated.keysAt = decorateMethod(
-        memo(this.#instanceId, (hash: Hash | Uint8Array | string, doubleMapArg?: Arg): Observable<StorageKey[]> =>
+        memo(this.#instanceId, (hash: Hash | Uint8Array | string, ...args: Arg[]): Observable<StorageKey[]> =>
-          this._retrieveMapKeys(creator, hash, doubleMapArg)));
+          this._retrieveMapKeys(creator, hash, args)));
 
       decorated.keysPaged = decorateMethod(
         memo(this.#instanceId, (opts: PaginationOptions): Observable<StorageKey[]> =>
@@ -445,7 +452,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
@@ -476,10 +483,10 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
     );
   }
 
-  private _retrieveMapKeys ({ iterKey, meta, method, section }: StorageEntry, at: Hash | Uint8Array | string | null, arg?: Arg): Observable<StorageKey[]> {
+  private _retrieveMapKeys ({ iterKey, meta, method, section }: StorageEntry, at: Hash | Uint8Array | string | null, args: Arg[]): 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(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)
@@ -492,9 +499,11 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
         )
       ),
       tap((keys): void => {
-        keys.length === PAGE_SIZE
+        setTimeout((): void => {
-          ? startSubject.next(keys[PAGE_SIZE - 1].toHex())
+          keys.length === PAGE_SIZE
-          : startSubject.complete();
+            ? startSubject.next(keys[PAGE_SIZE - 1].toHex())
+            : startSubject.complete();
+        }, 0);
       }),
       toArray(), // toArray since we want to startSubject to be completed
       map((keysArr: StorageKey[][]) => arrayFlatten(keysArr))
@@ -502,21 +511,21 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
   }
 
   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(

packages/api/src/base/Getters.ts

@@ -9,7 +9,7 @@ import type { ApiInterfaceRx, ApiTypes, DecoratedErrors, DecoratedEvents, Decora
 
 import { assertReturn } from '@polkadot/util';
 
-import { packageInfo } from '../detectPackage';
+import { packageInfo } from '../packageInfo';
 import { Init } from './Init';
 
 interface PkgJson {

packages/api/src/base/Init.ts

@@ -1,8 +1,9 @@
 // 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, SignedBlock } from '@polkadot/types/interfaces';
+import type { ChainProperties, Hash, RuntimeVersion } from '@polkadot/types/interfaces';
 import type { Registry } from '@polkadot/types/types';
 import type { Observable, Subscription } from '@polkadot/x-rxjs';
 import type { ApiBase, ApiOptions, ApiTypes, DecorateMethod } from '../types';
@@ -12,18 +13,16 @@ import BN from 'bn.js';
 
 import { Metadata } from '@polkadot/metadata';
 import { TypeRegistry } from '@polkadot/types/create';
-import { LATEST_EXTRINSIC_VERSION } from '@polkadot/types/extrinsic/Extrinsic';
+import { getSpecAlias, getSpecExtensions, getSpecHasher, getSpecRpc, getSpecTypes, getUpgradeVersion } from '@polkadot/types-known';
-import { getSpecAlias, getSpecExtensions, getSpecRpc, getSpecTypes, getUpgradeVersion } from '@polkadot/types-known';
+import { assert, BN_ZERO, logger, stringify, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
-import { assert, BN_ZERO, logger, 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';
 
+import { detectedCapabilities } from './capabilities';
 import { Decorate } from './Decorate';
-import { detectedCapabilities } from './util';
 
-const KEEPALIVE_INTERVAL = 15000;
+const KEEPALIVE_INTERVAL = 10000;
-const DEFAULT_BLOCKNUMBER = { unwrap: () => BN_ZERO };
 
 const l = logger('api/init');
 
@@ -32,7 +31,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);
@@ -59,7 +58,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);
@@ -85,6 +84,7 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
     registry.setChainProperties(chainProps || this.registry.getChainProperties());
     registry.setKnownTypes(this._options);
     registry.register(getSpecTypes(registry, chain, version.specName, version.specVersion));
+    registry.setHasher(getSpecHasher(registry, chain, version.specName));
 
     // for bundled types, pull through the aliases defined
     if (registry.knownTypes.typesBundle) {
@@ -102,10 +102,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> {
+  public async getBlockRegistry (blockHash: Uint8Array): Promise<VersionedRegistry> {
-    // shortcut in the case where we have an immediate-same request
+    const existingViaHash = this.#registries.find(({ lastBlockHash }) =>
-    const lastBlockHash = u8aToU8a(blockHash);
+      lastBlockHash && u8aEq(lastBlockHash, blockHash)
-    const existingViaHash = this.#registries.find((r) => r.lastBlockHash && u8aEq(lastBlockHash, r.lastBlockHash));
+    );
 
     if (existingViaHash) {
       return existingViaHash;
@@ -116,39 +116,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)
+    const header = this.registry.createType('HeaderPartial',
-      ? { number: DEFAULT_BLOCKNUMBER, parentHash: this._genesisHash }
+      this._genesisHash.eq(blockHash)
-      : await this._rpcCore.chain.getHeader(blockHash).toPromise();
+        ? { 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 [firstVersion, lastVersion] = getUpgradeVersion(this._genesisHash, header.number);
-    const version = (firstVersion && (lastVersion || firstVersion.specVersion.eq(this._runtimeVersion.specVersion)))
+    const version = this.registry.createType('RuntimeVersionPartial',
-      ? { specName: this._runtimeVersion.specName, specVersion: firstVersion.specVersion }
+      (firstVersion && (lastVersion || firstVersion.specVersion.eq(this._runtimeVersion.specVersion)))
-      : await this._rpcCore.state.getRuntimeVersion(header.parentHash).toPromise();
+        ? { 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,
-    const registry = this._initRegistry(new TypeRegistry(), this._runtimeChain as Text, version, metadata);
+      await (this._rpcCore.state.getMetadata as RpcInterfaceMethod).raw(header.parentHash).toPromise()
-
+    );
-    // For now, since this is new we ignore the capability lookups (this could be useful once proven)
+    const registry = this._initRegistry(new TypeRegistry(blockHash), this._runtimeChain as Text, version, metadata);
-    // 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 +162,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 +196,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 +243,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);
             })
           )
       )
@@ -285,35 +292,44 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
     return [genesisHash, metadata];
   }
 
-  private async _initFromMeta (metadata: Metadata): Promise<boolean> {
+  private _initFromMeta (metadata: Metadata): boolean {
-    const metaExtrinsic = metadata.asLatest.extrinsic;
+    this._extrinsicType = metadata.asLatest.extrinsic.version.toNumber();
-
-    // only inject if we are not a clone (global init)
-    if (metaExtrinsic.version.gt(BN_ZERO)) {
-      this._extrinsicType = metaExtrinsic.version.toNumber();
-    } else if (!this._options.source) {
-      // detect the extrinsic version in-use based on the last block
-      const { block: { extrinsics: [firstTx] } }: SignedBlock = await this._rpcCore.chain.getBlock().toPromise();
-
-      // If we haven't sync-ed to 1 yes, this won't have any values
-      this._extrinsicType = firstTx ? firstTx.type : LATEST_EXTRINSIC_VERSION;
-    }
-
     this._rx.extrinsicType = this._extrinsicType;
     this._rx.genesisHash = this._genesisHash;
     this._rx.runtimeVersion = this._runtimeVersion as RuntimeVersion; // must be set here
 
     // 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);
@@ -333,7 +349,7 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
       }
 
       this.#healthTimer = setInterval((): void => {
-        this._rpcCore.system.health().toPromise().catch(() => null);
+        this._rpcCore.system.health().toPromise().catch((error) => l.warn(`Health keepalive check failed: ${(error as Error).message}`));
       }, KEEPALIVE_INTERVAL);
     } catch (_error) {
       const error = new Error(`FATAL: Unable to initialize the API: ${(_error as Error).message}`);
@@ -349,10 +365,7 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
     this.emit('disconnected');
     this._isConnected.next(false);
 
-    if (this.#healthTimer) {
+    this._unsubscribeHealth();
-      clearInterval(this.#healthTimer);
-      this.#healthTimer = null;
-    }
   };
 
   #onProviderError = (error: Error): void => {

packages/api/src/base/capabilities.ts

@@ -0,0 +1,190 @@
+// Copyright 2017-2021 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ApiInterfaceRx } from '@polkadot/api/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 { catchError, map, take } from '@polkadot/x-rxjs/operators';
+
+// the order and types needs to map with the all array setup below
+type ExtractedQ = [Releases | null];
+
+type ExtractedR = [Raw | null, Raw | null];
+
+type ExtractedC = [u32 | null, u32 | null];
+
+type DetectedKeys = keyof Pick<InterfaceTypes, 'AccountInfo' | 'ValidatorPrefs'>;
+
+type DetectedValues = keyof InterfaceTypes;
+
+interface DetectedTypes extends Record<DetectedKeys, DetectedValues> {
+  AccountInfo: 'AccountInfoWithRefCount' | 'AccountInfoWithDualRefCount' | 'AccountInfoWithTripleRefCount',
+  Keys: 'SessionKeys1' | 'SessionKeys2' | 'SessionKeys3' | 'SessionKeys4' | 'SessionKeys5' | 'SessionKeys6' | 'SessionKeys7' | 'SessionKeys8' | 'SessionKeys9' | 'SessionKeys10';
+  RefCount: 'u8' | 'u32',
+  SlotRange: Record<string, unknown>;
+  ValidatorPrefs: 'ValidatorPrefsWithBlocked' | 'ValidatorPrefsWithCommission';
+  WinningData: string;
+}
+
+interface AvailableMap<T> {
+  filtered: T[];
+  included: boolean[];
+  original: 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, refcount1Length, refcount2Length, refcount3Length }: Constants, [leasePeriodsPerSlot, slotRangeCount]: ExtractedC, [stakingVersion]: ExtractedQ, [keys, accountInfo]: ExtractedR): Partial<DetectedTypes> {
+  const types: Partial<DetectedTypes> = {};
+
+  // AccountInfo
+  if (accountInfo) {
+    const length = accountInfo.length;
+
+    if (length === refcount1Length) {
+      types.AccountInfo = 'AccountInfoWithRefCount';
+    } else if (length === refcount2Length) {
+      types.AccountInfo = 'AccountInfoWithDualRefCount';
+    } else if (length === refcount3Length) {
+      types.AccountInfo = 'AccountInfoWithTripleRefCount';
+    }
+  }
+
+  // ValidatorPrefs
+  if (stakingVersion) {
+    if (stakingVersion.index >= 4) { // v1 = index 0, V5 = index 4
+      types.ValidatorPrefs = 'ValidatorPrefsWithBlocked';
+    } else {
+      types.ValidatorPrefs = 'ValidatorPrefsWithCommission';
+    }
+  }
+
+  // Keys
+  if (keys) {
+    try {
+      const [offset, numItems] = compactFromU8a(keys);
+      const tupleLength = (keys.length - offset) / numItems.toNumber();
+      const numIds = tupleLength / accountIdLength;
+      const numIdsRound = Math.floor(numIds);
+
+      assert(numIds >= 2 && numIds <= 11, () => `Detected ${numIds} in Keys, should be >= 2 and <= 11`);
+
+      if (numIdsRound !== numIds) {
+        // Beefy?
+        if ((((numIdsRound - 1) * accountIdLength) + 33) === tupleLength) {
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          types.Keys = `SessionKeys${numIdsRound - 1}B`;
+        } else {
+          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 {
+      // ignore
+    }
+  }
+
+  // auctions
+  if (leasePeriodsPerSlot && slotRangeCount) {
+    const _enum: string[] = [];
+
+    for (let i = 0; leasePeriodsPerSlot.gtn(i); i++) {
+      for (let j = i; leasePeriodsPerSlot.gtn(j); j++) {
+        _enum.push(`${NumberMap[i]}${NumberMap[j]}`);
+      }
+    }
+
+    types.SlotRange = { _enum };
+    types.WinningData = `[WinningDataEntry; ${slotRangeCount.toNumber()}]`;
+  }
+
+  return types;
+}
+
+function filterEntries <T> (original: T[]): AvailableMap<T> {
+  const included = original.map((c) => !!c);
+
+  return {
+    filtered: original.filter((_, index) => included[index]),
+    included,
+    original
+  };
+}
+
+function extractResults <R, T = unknown> (results: unknown[], map: AvailableMap<T>): R {
+  let offset = -1;
+
+  return map.included.map((isIncluded) =>
+    isIncluded
+      ? results[++offset]
+      : null
+  ) as unknown as R;
+}
+
+/**
+ * @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.staking?.storageVersion
+  ]);
+  const raws = filterEntries([
+    api.query.session?.queuedKeys.key(),
+    api.query.system?.account?.key(emptyAccountId)
+  ]);
+
+  return combineLatest([
+    consts.filtered.length
+      ? blockHash
+        // FIXME consts don't have .at as of yet...
+        ? of([])
+        : of(consts.filtered)
+      : of([]),
+    queries.filtered.length
+      ? blockHash
+        ? combineLatest(queries.filtered.map((c) => c.at(blockHash)))
+        : api.queryMulti(queries.filtered)
+      : of([]),
+    raws.filtered.length
+      ? blockHash
+        ? 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: 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),
+    catchError(() => of({}))
+  );
+}

packages/api/src/base/index.ts

@@ -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();
   }
 

packages/api/src/base/util.ts

@@ -1,74 +0,0 @@
-// Copyright 2017-2021 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { ApiInterfaceRx } from '@polkadot/api/types';
-import type { bool } from '@polkadot/types';
-import type { Releases } from '@polkadot/types/interfaces';
-import type { InterfaceTypes } from '@polkadot/types/types';
-
-import { combineLatest, Observable, of } from '@polkadot/x-rxjs';
-import { map, take } from '@polkadot/x-rxjs/operators';
-
-// the order and types needs to map with the all array setup below
-type Extracted = [bool | null, bool | null, Releases | null];
-
-type DetectedKeys = keyof Pick<InterfaceTypes, 'AccountInfo' | 'ValidatorPrefs'>;
-
-type DetectedValues = keyof InterfaceTypes;
-
-interface DetectedTypes extends Record<DetectedKeys, DetectedValues> {
-  AccountInfo: 'AccountInfoWithRefCount' | 'AccountInfoWithProviders',
-  ValidatorPrefs: 'ValidatorPrefsWithBlocked' | 'ValidatorPrefsWithCommission';
-}
-
-function mapCapabilities ([systemRefcount32, systemRefcountDual, stakingVersion]: Extracted): Partial<DetectedTypes> {
-  const types: Partial<DetectedTypes> = {};
-
-  // AccountInfo
-  if (systemRefcountDual && systemRefcountDual.isTrue) {
-    types.AccountInfo = 'AccountInfoWithProviders';
-  } else if (systemRefcount32 && systemRefcount32.isTrue) {
-    types.AccountInfo = 'AccountInfoWithRefCount';
-  }
-
-  // ValidatorPrefs
-  if (stakingVersion) {
-    if (stakingVersion.index >= 4) { // v1 = index 0, V5 = index 4
-      types.ValidatorPrefs = 'ValidatorPrefsWithBlocked';
-    } else {
-      types.ValidatorPrefs = 'ValidatorPrefsWithCommission';
-    }
-  }
-
-  return types;
-}
-
-/**
- * @description Query the chain for the specific capabilities
- */
-export function detectedCapabilities (api: ApiInterfaceRx, blockHash?: Uint8Array | string | undefined): Observable<Partial<DetectedTypes>> {
-  const all = [
-    api.query.system?.upgradedToU32RefCount,
-    api.query.system?.upgradedToDualRefCount,
-    api.query.staking?.storageVersion
-  ];
-  const included = all.map((c) => !!c);
-  const filtered = all.filter((_, index) => included[index]);
-
-  return (
-    filtered.length
-      ? blockHash
-        ? combineLatest(filtered.map((c) => c.at(blockHash)))
-        : api.queryMulti(filtered)
-      : of([])
-  ).pipe(
-    map((results): Partial<DetectedTypes> => {
-      let offset = -1;
-
-      return mapCapabilities(
-        included.map((isIncluded) => isIncluded ? results[++offset] : null) as Extracted
-      );
-    }),
-    take(1)
-  );
-}

packages/api/src/checkTypes.manual.ts

@@ -3,12 +3,12 @@
 
 // Simple non-runnable checks to test type definitions in the editor itself
 
+import type { HeaderExtended } from '@polkadot/api-derive/types';
 import type { StorageKey } from '@polkadot/types';
 import type { AccountId, Balance, DispatchErrorModule, Event, Header, Index } from '@polkadot/types/interfaces';
 import type { AnyTuple, IExtrinsic, IMethod } from '@polkadot/types/types';
 
 import { ApiPromise } from '@polkadot/api';
-import { HeaderExtended } from '@polkadot/api-derive';
 import { createTestPairs, TestKeyringMap } from '@polkadot/keyring/testingPairs';
 import { createTypeUnsafe, TypeRegistry } from '@polkadot/types/create';
 
@@ -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);
 

packages/api/src/detectPackage.ts

@@ -1,25 +1,14 @@
 // Copyright 2017-2021 @polkadot/api authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-// For esm, this should be import.meta.url or to get the same behavior as __dirname, we can use
+import { packageInfo as deriveInfo } from '@polkadot/api-derive/packageInfo';
-//
+import { packageInfo as metaInfo } from '@polkadot/metadata/packageInfo';
-//   new URL(import.meta.url).pathname)
+import { packageInfo as coreInfo } from '@polkadot/rpc-core/packageInfo';
-//
+import { packageInfo as providerInfo } from '@polkadot/rpc-provider/packageInfo';
-// The issue is the WP4 has "some" issues with import.meta.url. So because of bundlers, we can't have
+import { packageInfo as typesInfo } from '@polkadot/types/packageInfo';
-// nice things... In this case it is even worse since import.meta.url won't even make it compile, so
+import { packageInfo as knownInfo } from '@polkadot/types-known/packageInfo';
-// there is a complete dead end with usage thereof
-//
-// When that is fixed, a solution is to have both .js & .mjs files, with the following content -
-//
-// cjs: util.detectPackage(packageInfo, () => __dirname);
-// esm: detectPackage(packageInfo, () => import.meta.url);
-//
-// With the above we additionally need a .d.ts to just export the packageInfo
-
 import { detectPackage } from '@polkadot/util';
 
-import packageInfo from './package-info.json';
+import { packageInfo } from './packageInfo';
 
-detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname);
+detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname, [deriveInfo, metaInfo, coreInfo, providerInfo, typesInfo, knownInfo]);
-
-export { packageInfo };

packages/api/src/index.ts

@@ -6,7 +6,7 @@ import './detectPackage';
 export { Keyring } from '@polkadot/keyring';
 export { WsProvider } from '@polkadot/rpc-provider/ws';
 
+export { packageInfo } from './packageInfo';
 export { ApiPromise } from './promise';
-export { ApiRx } from './rx';
-
 export { SubmittableResult } from './submittable';
+export { ApiRx } from './rx';

packages/api/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/api authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Auto-generated by @polkadot/dev, do not edit
+
+export const packageInfo = { name: '@polkadot/api', version: '4.11.1' };

packages/api/src/promise/index.spec.ts

@@ -1,7 +1,7 @@
 // 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 { createPair } from '@polkadot/keyring/pair';
 import { createTestKeyring } from '@polkadot/keyring/testing';
@@ -44,23 +44,16 @@ describe('ApiPromise', (): void => {
   }
 
   beforeEach((): void => {
-    jest.setTimeout(3000000);
+    jest.setTimeout(10000);
     provider = new MockProvider(registry);
   });
 
   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 api = await ApiPromise.create({ metadata: { [`${genesisHash}-${specVersion}`]: rpcData }, provider, registry });
-      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);
 
       expect(api.genesisHash).toBeDefined();
       expect(api.runtimeMetadata).toBeDefined();

packages/api/src/promise/index.ts

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

packages/api/src/rx/index.ts

@@ -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 => {
+        super.on('ready', () => resolve(this));
-          resolve(this);
-        });
       })
     );
   }

packages/api/src/submittable/Result.ts

@@ -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)
     };
   }

packages/api/src/submittable/createClass.ts

@@ -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';
@@ -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 })))
         )
       );
     }

packages/api/src/submittable/types.ts

@@ -10,6 +10,7 @@ export interface SubmittableResultValue {
   dispatchError?: DispatchError;
   dispatchInfo?: DispatchInfo;
   events?: EventRecord[];
+  internalError?: Error;
   status: ExtrinsicStatus;
 }
 

packages/api/src/types/base.ts

@@ -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.
+export type Push<T extends readonly unknown[], V> = [...T, V]
-// 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;
 
-// Append an element V onto the end of a tuple T
+export type DropLast<T extends readonly unknown[]> = T extends readonly [...infer U, any?] ? U : [...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 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;
 }

packages/api/src/types/index.ts

@@ -69,6 +69,10 @@ 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;
 }
 
 // A smaller interface of ApiRx, used in derive and in SubmittableExtrinsic

packages/api/src/types/rpc.ts

@@ -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'

packages/api/src/types/storage.ts

@@ -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>;
+  (arg1?: CodecArg, arg2?: CodecArg, arg3?: CodecArg): Promise<Codec>;
-  <T extends Codec>(arg1?: CodecArg, arg2?: CodecArg): Promise<T>;
+  <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'
@@ -35,19 +36,19 @@ export type QueryableStorageEntry<ApiType extends ApiTypes, A extends AnyTuple =
     // eslint-disable-next-line no-use-before-define
     : AugmentedQuery<'promise', GenericStorageEntryFunction, A> & StorageEntryPromiseOverloads;
 
-export interface StorageEntryBase<ApiType extends ApiTypes, F extends AnyFunction, 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>>>(arg?: Parameters<F>[0]) => PromiseOrObs<ApiType, [StorageKey<A>, 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>>>(hash: Hash | Uint8Array | string, arg?: Parameters<F>[0]) => PromiseOrObs<ApiType, [StorageKey<A>, 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>>>(opts: PaginationOptions<Parameters<F>[0]>) => PromiseOrObs<ApiType, [StorageKey<A>, 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;
+  keyPrefix: (...args: DropLast<Parameters<F>>) => string;
-  keys: (arg?: any) => PromiseOrObs<ApiType, StorageKey<A>[]>;
+  keys: <K extends AnyTuple = A> (...args: DropLast<Parameters<F>>) => PromiseOrObs<ApiType, StorageKey<K>[]>;
-  keysAt: (hash: Hash | Uint8Array | string, arg?: any) => PromiseOrObs<ApiType, StorageKey<A>[]>;
+  keysAt: <K extends AnyTuple = A> (hash: Hash | Uint8Array | string, ...args: DropLast<Parameters<F>>) => PromiseOrObs<ApiType, StorageKey<K>[]>;
-  keysPaged: (opts: PaginationOptions<Parameters<F>[0]>) => PromiseOrObs<ApiType, StorageKey<A>[]>;
+  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][]>;
   size: (...args: Parameters<F>) => PromiseOrObs<ApiType, u64>;
@@ -80,10 +81,4 @@ 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>;

packages/api/src/util/validate.spec.ts

@@ -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