[CI Skip] release/stable 4.11.1

skip-checks: true

.123trigger

@@ -20,4 +20,6 @@
 4.0.2
 4.0.3
 
-4.6.2
+4.6.2
+4.7.2
+4.9.2

.nvmrc

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

CHANGELOG.md

@@ -1,5 +1,112 @@
 # 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.

README.md

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

package.json

@@ -25,14 +25,14 @@
     "test:watch": "polkadot-dev-run-test --watch"
   },
   "devDependencies": {
-    "@babel/core": "^7.13.16",
+    "@babel/core": "^7.14.3",
     "@babel/register": "^7.13.16",
-    "@babel/runtime": "^7.13.17",
+    "@babel/runtime": "^7.14.0",
-    "@polkadot/dev": "^0.62.10",
+    "@polkadot/dev": "^0.62.16",
-    "@polkadot/ts": "^0.3.63",
+    "@polkadot/ts": "^0.3.66",
     "@polkadot/typegen": "workspace:packages/typegen",
-    "@types/jest": "^26.0.22",
+    "@types/jest": "^26.0.23",
     "copyfiles": "^2.4.1"
   },
-  "version": "4.7.1"
+  "version": "4.11.1"
 }

packages/api-contract/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/api-contract",
-  "version": "4.7.1",
+  "version": "4.11.1",
   "type": "module",
   "description": "Interfaces for interacting with contracts and contract ABIs",
   "main": "index.js",
@@ -19,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.13.17",
+    "@babel/runtime": "^7.14.0",
-    "@polkadot/api": "4.7.1",
+    "@polkadot/api": "4.11.1",
-    "@polkadot/types": "4.7.1",
+    "@polkadot/types": "4.11.1",
-    "@polkadot/util": "^6.3.1",
+    "@polkadot/util": "^6.5.1",
-    "@polkadot/x-rxjs": "^6.3.1",
+    "@polkadot/x-rxjs": "^6.5.1",
     "bn.js": "^4.11.9"
   }
 }

packages/api-contract/src/Abi.ts

@@ -10,8 +10,6 @@ import { assert, assertReturn, compactAddLength, compactStripLength, isNumber, i
 
 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 {
@@ -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, {
@@ -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}`);
 
     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,7 +83,7 @@ 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`);
 
@@ -87,10 +92,13 @@ export class MetaRegistry extends TypeRegistry {
 
   #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 => {

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

@@ -10,17 +10,14 @@ import type { MapConstructorExec } from './types';
 
 import { SubmittableResult } from '@polkadot/api';
 import { ApiBase } from '@polkadot/api/base';
-import { assert, compactAddLength, isFunction, isUndefined, isWasm, logger, stringCamelCase, u8aToU8a } from '@polkadot/util';
+import { 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';
-
-const l = logger('Code');
 
 export class CodeSubmittableResult<ApiType extends ApiTypes> extends SubmittableResult {
   public readonly blueprint?: Blueprint<ApiType>;
@@ -49,10 +46,8 @@ export class Code<ApiType extends ApiTypes> extends Base<ApiType> {
     assert(isWasm(this.code), 'No WASM code provided');
 
     this.abi.constructors.forEach((c): void => {
-      const messageName = stringCamelCase(c.identifier);
+      if (isUndefined(this.#tx[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));
       }
     });
   }
@@ -61,55 +56,25 @@ export class Code<ApiType extends ApiTypes> extends Base<ApiType> {
     return this.#tx;
   }
 
-  /**
+  #instantiate = (constructorOrId: AbiConstructor | string | number, { gasLimit = BN_ZERO, salt, value = BN_ZERO }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> => {
-   * @description Deploy the code bundle and the contract, creating a Blueprint.
-   * @deprecated Use the `code.tx.<constructor>(...) format to put code and deploy
-   */
-  public createContract (constructorOrId: AbiConstructor | string | number, options: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> {
-    l.warn('.createContract is deprecated, use code.tx.<constructorName>(...) instead (where code refers to this instance)');
-
-    return this.#instantiate(constructorOrId, options, params);
-  }
-
-  #instantiate = (constructorOrId: AbiConstructor | string | number, options: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> => {
-    return isFunction(this.api.tx.contracts.instantiateWithCode)
-      ? this.#instantiateCurrent(constructorOrId, options, params)
-      : this.#instantiatePrev(constructorOrId, options, params);
-  }
-
-  #instantiateCurrent = (constructorOrId: AbiConstructor | string | number, { gasLimit = 0, salt, value = 0 }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> => {
     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),
-  #instantiatePrev = (constructorOrId: AbiConstructor | string | number, { gasLimit = 0, salt, value = 0 }: BlueprintOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> => {
+        this.abi.findConstructor(constructorOrId).toU8a(params),
-    assert(isFunction(this.api.tx.utility?.batch), 'Your chain does not include the utility pallet, for contracts v2 deployment, this is required');
+        encodeSalt(salt)
-
+      )
-    const encodedSalt = encodeSalt(salt);
+      .withResultTransform((result: ISubmittableResult) =>
-    const withSalt = this.api.tx.contracts.instantiate.meta.args.length === 5;
+        new CodeSubmittableResult(result, ...(applyOnEvent(result, ['CodeStored', 'Instantiated'], (records: EventRecord[]) =>
-    const encoded = this.abi.findConstructor(constructorOrId).toU8a(params, withSalt ? EMPTY_SALT : encodedSalt);
+          records.reduce<[Blueprint<ApiType>?, Contract<ApiType>?]>(([blueprint, contract], { event }) =>
-    const codeHash = blake2AsU8a(this.code);
+            this.api.events.contracts.Instantiated.is(event)
-
+              ? [blueprint, new Contract<ApiType>(this.api, this.abi, event.data[1], this._decorateMethod)]
-    return this.api.tx.utility.batch([
+              : this.api.events.contracts.CodeStored.is(event)
-      this.api.tx.contracts.putCode(compactAddLength(this.code)),
+                ? [new Blueprint<ApiType>(this.api, this.abi, event.data[0], this._decorateMethod), contract]
-      withSalt
+                : [blueprint, contract],
-        ? this.api.tx.contracts.instantiate(value, gasLimit, codeHash, encoded, encodedSalt)
+          [])
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        ) || []))
-        // @ts-ignore old style with salt included in the params itself
+      );
-        : this.api.tx.contracts.instantiate(value, gasLimit, codeHash, encoded)
-    ]).withResultTransform(this.#transformEvents);
-  }
-
-  #transformEvents = (result: ISubmittableResult): CodeSubmittableResult<ApiType> => {
-    return new CodeSubmittableResult(result, ...(applyOnEvent(result, ['CodeStored', 'Instantiated'], (records: EventRecord[]) =>
-      records.reduce(([blueprint, contract], { event }): [Blueprint<ApiType>?, Contract<ApiType>?] =>
-        this.api.events.contracts.Instantiated.is(event)
-          ? [blueprint, new Contract<ApiType>(this.api, this.abi, event.data[1], this._decorateMethod)]
-          : this.api.events.contracts.CodeStored.is(event)
-            ? [new Blueprint<ApiType>(this.api, this.abi, event.data[0], this._decorateMethod), contract]
-            : [blueprint, contract],
-      [] as [Blueprint<ApiType>?, Contract<ApiType>?])
-    ) || []));
   }
 }

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

@@ -4,24 +4,25 @@
 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');
@@ -40,16 +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, warn?: string): ContractGeneric<ContractOptions, T> {
-  return (messageOrId: AbiMessage | string | number, options: BigInt | string | number | BN | ContractOptions, ...params: CodecArg[]): T => {
-    warn && l.warn(warn);
-
-    return isOptions(options)
-      ? fn(messageOrId, options, params)
-      : fn(messageOrId, ...extractOptions(options, params));
-  };
-}
-
 export class ContractSubmittableResult extends SubmittableResult {
   public readonly contractEvents?: DecodedEvent[];
 
@@ -60,51 +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> = {};
@@ -113,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, '.exec is deprecated, use contract.tx.<messageName>(...) instead (where contract refers to this instance)');
-    this.read = createWithId(this.#read, '.read is deprecated, use contract.query.<messageName>(...) instead (where contract refers to this instance)');
 
     this.abi.messages.forEach((m): void => {
-      const messageName = stringCamelCase(m.identifier);
+      if (isUndefined(this.#tx[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));
       }
     });
   }
@@ -146,19 +94,24 @@ export class Contract<ApiType extends ApiTypes> extends Base<ApiType> {
   #getGas = (_gasLimit: BigInt | BN | string | number, isCall = false): BN => {
     const gasLimit = bnToBn(_gasLimit);
 
-    return gasLimit.lten(0)
+    return gasLimit.lte(BN_ZERO)
       ? isCall
         ? MAX_CALL_GAS
         : (this.api.consts.system.blockWeights
           ? this.api.consts.system.blockWeights.maxBlock
           : this.api.consts.system.maximumBlockWeight as Weight
-        ).muln(64).divn(100)
+        ).muln(64).div(BN_HUNDRED)
       : gasLimit;
   }
 
-  #exec = (messageOrId: AbiMessage | string | number, { gasLimit = 0, value = 0 }: ContractOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType> => {
+  #exec = (messageOrId: AbiMessage | string | number, { gasLimit = BN_ZERO, value = BN_ZERO }: ContractOptions, params: CodecArg[]): SubmittableExtrinsic<ApiType> => {
     return this.api.tx.contracts
-      .call(this.address, value, this.#getGas(gasLimit), this.abi.findMessage(messageOrId).toU8a(params))
+      .call(
+        this.address,
+        value,
+        this.#getGas(gasLimit),
+        this.abi.findMessage(messageOrId).toU8a(params)
+      )
       .withResultTransform((result: ISubmittableResult) =>
         // ContractEmitted is the current generation, ContractExecution is the previous generation
         new ContractSubmittableResult(result, applyOnEvent(result, ['ContractEmitted', 'ContractExecution'], (records: EventRecord[]) =>
@@ -177,7 +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);
@@ -185,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,10 +30,6 @@ async function checkContract (api: ApiPromise, pairs: TestKeyringMap): Promise<v
   // execute
   await contract.tx.inc({ gasLimit: 1234 }, 123).signAndSend(pairs.eve);
   await contract.tx.inc(123, 456, 69).signAndSend(pairs.eve);
-
-  // deprecated
-  await contract.read('get', {}).send(pairs.eve.address);
-  await contract.exec('inc', {}, 123).signAndSend(pairs.dave);
 }
 
 async function main (): Promise<void> {

packages/api-contract/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/api-contract', version: '4.7.1' };
+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' | '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-derive/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/api-derive",
-  "version": "4.7.1",
+  "version": "4.11.1",
   "type": "module",
   "description": "Common functions used across Polkadot, derived from RPC calls and storage queries.",
   "main": "index.js",
@@ -19,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.13.17",
+    "@babel/runtime": "^7.14.0",
-    "@polkadot/api": "4.7.1",
+    "@polkadot/api": "4.11.1",
-    "@polkadot/rpc-core": "4.7.1",
+    "@polkadot/rpc-core": "4.11.1",
-    "@polkadot/types": "4.7.1",
+    "@polkadot/types": "4.11.1",
-    "@polkadot/util": "^6.3.1",
+    "@polkadot/util": "^6.5.1",
-    "@polkadot/util-crypto": "^6.3.1",
+    "@polkadot/util-crypto": "^6.5.1",
-    "@polkadot/x-rxjs": "^6.3.1",
+    "@polkadot/x-rxjs": "^6.5.1",
     "bn.js": "^4.11.9"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^6.3.1",
+    "@polkadot/keyring": "^6.5.1",
-    "@polkadot/rpc-provider": "4.7.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/all.ts

@@ -44,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)));

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

@@ -21,7 +21,7 @@ function isVoter (value: VoteEntry): value is Voter {
 }
 
 function retrieveStakeOf (api: ApiInterfaceRx): Observable<[AccountId, Balance][]> {
-  return (api.query.electionsPhragmen || api.query.elections).stakeOf.entries<Balance, [AccountId]>().pipe(
+  return (api.query.phragmenElection || api.query.electionsPhragmen || api.query.elections).stakeOf.entries<Balance, [AccountId]>().pipe(
     map((entries) =>
       entries.map(([{ args: [accountId] }, stake]) => [accountId, stake])
     )
@@ -29,7 +29,7 @@ function retrieveStakeOf (api: ApiInterfaceRx): Observable<[AccountId, Balance][
 }
 
 function retrieveVoteOf (api: ApiInterfaceRx): Observable<[AccountId, AccountId[]][]> {
-  return (api.query.electionsPhragmen || api.query.elections).votesOf.entries<Vec<AccountId>, [AccountId]>().pipe(
+  return (api.query.phragmenElection || api.query.electionsPhragmen || api.query.elections).votesOf.entries<Vec<AccountId>, [AccountId]>().pipe(
     map((entries) =>
       entries.map(([{ args: [accountId] }, votes]) => [accountId, votes])
     )
@@ -61,7 +61,7 @@ function retrievePrev (api: ApiInterfaceRx): Observable<DeriveCouncilVotes> {
 }
 
 function retrieveCurrent (api: ApiInterfaceRx): Observable<DeriveCouncilVotes> {
-  const elections = (api.query.electionsPhragmen || api.query.elections);
+  const elections = (api.query.phragmenElection || api.query.electionsPhragmen || api.query.elections);
 
   return elections.voting.entries<VoteEntry, [AccountId]>().pipe(
     map((entries): DeriveCouncilVotes =>
@@ -77,7 +77,7 @@ function retrieveCurrent (api: ApiInterfaceRx): Observable<DeriveCouncilVotes> {
 
 export function votes (instanceId: string, api: ApiInterfaceRx): () => Observable<DeriveCouncilVotes> {
   return memo(instanceId, (): Observable<DeriveCouncilVotes> =>
-    (api.query.electionsPhragmen || api.query.elections).stakeOf
+    (api.query.phragmenElection || api.query.electionsPhragmen || api.query.elections).stakeOf
       ? retrievePrev(api)
       : retrieveCurrent(api)
   );

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

@@ -42,7 +42,11 @@ function sortAccounts ([, balanceA]: [AccountId, Balance], [, balanceB]: [Accoun
 }
 
 function queryElections (api: ApiInterfaceRx): Observable<DeriveElectionsInfo> {
-  const section = api.query.electionsPhragmen ? 'electionsPhragmen' : 'elections';
+  const section = api.query.phragmenElection
+    ? 'phragmenElection'
+    : api.query.electionsPhragmen
+      ? 'electionsPhragmen'
+      : 'elections';
 
   return api.queryMulti<[Vec<AccountId>, Vec<Candidate>, Vec<Member>, Vec<Member>]>([
     api.query.council.members,

packages/api-derive/src/index.ts

@@ -16,6 +16,7 @@ import * as council from './council';
 import * as democracy from './democracy';
 import * as elections from './elections';
 import * as imOnline from './imOnline';
+import * as membership from './membership';
 import * as parachains from './parachains';
 import * as session from './session';
 import * as society from './society';
@@ -27,7 +28,7 @@ import * as tx from './tx';
 export { packageInfo } from './packageInfo';
 export * from './type';
 
-export const derive = { accounts, balances, bounties, chain, contracts, council, democracy, elections, imOnline, parachains, session, society, staking, technicalCommittee, treasury, tx };
+export const derive = { accounts, balances, bounties, chain, contracts, council, democracy, elections, imOnline, membership, parachains, session, society, staking, technicalCommittee, treasury, tx };
 
 type DeriveSection<Section> = {
   [Method in keyof Section]: Section[Method] extends AnyFunction
@@ -47,8 +48,9 @@ const deriveAvail: Record<string, string[]> = {
   contracts: ['contracts'],
   council: ['council'],
   democracy: ['democracy'],
-  elections: ['electionsPhragmen', 'elections'],
+  elections: ['phragmenElection', 'electionsPhragmen', 'elections'],
   imOnline: ['imOnline'],
+  membership: ['membership'],
   parachains: ['parachains', 'registrar'],
   session: ['session'],
   society: ['society'],

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

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/api-derive', version: '4.7.1' };
+export const packageInfo = { name: '@polkadot/api-derive', version: '4.11.1' };

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

@@ -28,7 +28,7 @@ function parseRewards (api: ApiInterfaceRx, stashId: AccountId, [erasPoints, era
     Object.entries(eraValidators).forEach(([validatorId, exposure]): void => {
       const valPoints = allValPoints[validatorId] || BN_ZERO;
       const valComm = allValPrefs[validatorId]?.commission.unwrap() || BN_ZERO;
-      const expTotal = exposure.total.unwrap();
+      const expTotal = exposure.total?.unwrap() || BN_ZERO;
       let avail = BN_ZERO;
       let value: BN | undefined;
 

packages/api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/api",
-  "version": "4.7.1",
+  "version": "4.11.1",
   "type": "module",
   "description": "Promise and RxJS wrappers around the Polkadot JS RPC",
   "main": "index.js",
@@ -19,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.13.17",
+    "@babel/runtime": "^7.14.0",
-    "@polkadot/api-derive": "4.7.1",
+    "@polkadot/api-derive": "4.11.1",
-    "@polkadot/keyring": "^6.3.1",
+    "@polkadot/keyring": "^6.5.1",
-    "@polkadot/metadata": "4.7.1",
+    "@polkadot/metadata": "4.11.1",
-    "@polkadot/rpc-core": "4.7.1",
+    "@polkadot/rpc-core": "4.11.1",
-    "@polkadot/rpc-provider": "4.7.1",
+    "@polkadot/rpc-provider": "4.11.1",
-    "@polkadot/types": "4.7.1",
+    "@polkadot/types": "4.11.1",
-    "@polkadot/types-known": "4.7.1",
+    "@polkadot/types-known": "4.11.1",
-    "@polkadot/util": "^6.3.1",
+    "@polkadot/util": "^6.5.1",
-    "@polkadot/util-crypto": "^6.3.1",
+    "@polkadot/util-crypto": "^6.5.1",
-    "@polkadot/x-rxjs": "^6.3.1",
+    "@polkadot/x-rxjs": "^6.5.1",
     "bn.js": "^4.11.9",
     "eventemitter3": "^4.0.7"
   }

packages/api/src/augment/consts.ts

@@ -3,6 +3,7 @@
 
 import type { Vec, u16, u32, u64, u8 } from '@polkadot/types';
 import type { Codec } from '@polkadot/types/types';
+import type { Schedule } from '@polkadot/types/interfaces/contracts';
 import type { Balance, BalanceOf, BlockNumber, LockIdentifier, Moment, PalletId, Perbill, Percent, Permill, RuntimeDbWeight, Weight } from '@polkadot/types/interfaces/runtime';
 import type { SessionIndex } from '@polkadot/types/interfaces/session';
 import type { EraIndex } from '@polkadot/types/interfaces/staking';
@@ -14,7 +15,6 @@ import type { ApiTypes } from '@polkadot/api/types';
 declare module '@polkadot/api/types/consts' {
   export interface AugmentedConsts<ApiType> {
     babe: {
-      [key: string]: Codec;
       /**
        * The amount of time, in slots, that each epoch should last.
        * NOTE: Currently it is not possible to change the epoch duration after
@@ -29,16 +29,22 @@ declare module '@polkadot/api/types/consts' {
        * the probability of a slot being empty).
        **/
       expectedBlockTime: Moment & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
     };
     balances: {
-      [key: string]: Codec;
       /**
        * The minimum amount required to keep an account open.
        **/
       existentialDeposit: Balance & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
     };
     bounties: {
-      [key: string]: Codec;
       /**
        * Percentage of the curator fee that will be reserved upfront as deposit for bounty curator.
        **/
@@ -67,9 +73,12 @@ declare module '@polkadot/api/types/consts' {
        * Maximum acceptable reason length.
        **/
       maximumReasonLength: u32 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
     };
     contracts: {
-      [key: string]: Codec;
       /**
        * The maximum number of tries that can be queued for deletion.
        **/
@@ -104,20 +113,6 @@ declare module '@polkadot/api/types/consts' {
        * It works the same as [`Self::DepositPerStorageByte`] but for storage items.
        **/
       depositPerStorageItem: BalanceOf & AugmentedConst<ApiType>;
-      /**
-       * The maximum length of a contract code in bytes. This limit applies to the instrumented
-       * version of the code. Therefore `instantiate_with_code` can fail even when supplying
-       * a wasm binary below this maximum size.
-       **/
-      maxCodeSize: u32 & AugmentedConst<ApiType>;
-      /**
-       * The maximum nesting level of a call/instantiate stack.
-       **/
-      maxDepth: u32 & AugmentedConst<ApiType>;
-      /**
-       * The maximum size of a storage value and event payload in bytes.
-       **/
-      maxValueSize: u32 & AugmentedConst<ApiType>;
       /**
        * The fraction of the deposit that should be used as rent per block.
        * 
@@ -126,6 +121,10 @@ declare module '@polkadot/api/types/consts' {
        * This determines how high this rent payment is per block as a fraction of the deposit.
        **/
       rentFraction: Perbill & AugmentedConst<ApiType>;
+      /**
+       * Cost schedule and limits.
+       **/
+      schedule: Schedule & AugmentedConst<ApiType>;
       /**
        * Number of block delay an extrinsic claim surcharge has.
        * 
@@ -142,9 +141,12 @@ declare module '@polkadot/api/types/consts' {
        * The minimum amount required to generate a tombstone.
        **/
       tombstoneDeposit: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
     };
     democracy: {
-      [key: string]: Codec;
       /**
        * Period in blocks where an external proposal may not be re-submitted after being vetoed.
        **/
@@ -181,9 +183,19 @@ declare module '@polkadot/api/types/consts' {
        * How often (in blocks) to check for new votes.
        **/
       votingPeriod: BlockNumber & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
     };
     electionProviderMultiPhase: {
-      [key: string]: Codec;
+      /**
+       * The repeat threshold of the offchain worker.
+       * 
+       * For example, if it is 5, that means that at least 5 blocks will elapse between attempts
+       * to submit the worker's solution.
+       **/
+      offchainRepeat: BlockNumber & AugmentedConst<ApiType>;
       /**
        * Duration of the signed phase.
        **/
@@ -197,9 +209,12 @@ declare module '@polkadot/api/types/consts' {
        * Duration of the unsigned phase.
        **/
       unsignedPhase: BlockNumber & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
     };
     elections: {
-      [key: string]: Codec;
       /**
        * How much should be locked up in order to submit one's candidacy.
        **/
@@ -233,9 +248,12 @@ declare module '@polkadot/api/types/consts' {
        * The amount of bond that need to be locked for each vote (32 bytes).
        **/
       votingBondFactor: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
     };
     gilt: {
-      [key: string]: Codec;
       /**
        * Portion of the queue which is free from ordering and just a FIFO.
        * 
@@ -279,11 +297,14 @@ declare module '@polkadot/api/types/consts' {
        * this value multiplied by `Period`.
        **/
       queueCount: u32 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
     };
     identity: {
-      [key: string]: Codec;
       /**
-       * The amount held on deposit for a registered identity.
+       * The amount held on deposit for a registered identity
        **/
       basicDeposit: BalanceOf & AugmentedConst<ApiType>;
       /**
@@ -310,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>;
+      /**
+       * 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.
@@ -338,9 +374,12 @@ 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;
       /**
        * The base amount of currency needed to reserve for creating an announcement.
        * 
@@ -377,15 +416,23 @@ declare module '@polkadot/api/types/consts' {
        * `32 + proxy_type.encode().len()` bytes of data.
        **/
       proxyDepositFactor: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
     };
     recovery: {
-      [key: string]: Codec;
       /**
        * The base amount of currency needed to reserve for creating a recovery configuration.
+       * 
+       * This is held for an additional storage item whose value size is
+       * `2 + sizeof(BlockNumber, Balance)` bytes.
        **/
       configDepositBase: BalanceOf & AugmentedConst<ApiType>;
       /**
        * The amount of currency needed per additional user when creating a recovery configuration.
+       * 
+       * This is held for adding `sizeof(AccountId)` bytes more into a pre-existing storage value.
        **/
       friendDepositFactor: BalanceOf & AugmentedConst<ApiType>;
       /**
@@ -394,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.
        **/
@@ -433,9 +489,12 @@ 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.
        **/
@@ -463,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).
        **/
@@ -494,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
@@ -504,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.
        **/
@@ -527,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.
        **/
@@ -538,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.
        **/
@@ -562,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 transferred to call `vested_transfer`.
        **/
       minVestedTransfer: BalanceOf & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
     };
   }
 

packages/api/src/augment/errors.ts

@@ -6,7 +6,6 @@ import type { ApiTypes } from '@polkadot/api/types';
 declare module '@polkadot/api/types/errors' {
   export interface AugmentedErrors<ApiType> {
     assets: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * Invalid metadata given.
        **/
@@ -43,10 +42,6 @@ declare module '@polkadot/api/types/errors' {
        * No provider reference exists to allow a non-zero balance of a non-self-sufficient asset.
        **/
       NoProvider: AugmentedError<ApiType>;
-      /**
-       * A mint operation lead to an overflow.
-       **/
-      Overflow: AugmentedError<ApiType>;
       /**
        * No approval exists that would allow the transfer.
        **/
@@ -59,9 +54,12 @@ declare module '@polkadot/api/types/errors' {
        * The source account would not survive the transfer and it needs to stay alive.
        **/
       WouldDie: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     authorship: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * The uncle is genesis.
        **/
@@ -90,9 +88,12 @@ declare module '@polkadot/api/types/errors' {
        * Uncles already set in the block.
        **/
       UnclesAlreadySet: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     babe: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * A given equivocation report is valid but already previously reported.
        **/
@@ -105,9 +106,12 @@ declare module '@polkadot/api/types/errors' {
        * A key ownership proof provided as part of an equivocation report is invalid.
        **/
       InvalidKeyOwnershipProof: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     balances: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * Beneficiary account must pre-exist
        **/
@@ -132,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.
        **/
@@ -180,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
@@ -210,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.
        **/
@@ -308,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.
        **/
@@ -322,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!
        **/
@@ -365,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
        **/
@@ -460,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
        **/
@@ -492,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
        **/
@@ -509,9 +523,16 @@ declare module '@polkadot/api/types/errors' {
        * Invalid upper bound.
        **/
       WrongUpperBound: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     electionProviderMultiPhase: {
-      [key: string]: AugmentedError<ApiType>;
+      /**
+       * OCW submitted solution for wrong round
+       **/
+      OcwCallWrongEra: AugmentedError<ApiType>;
       /**
        * Submission was too early.
        **/
@@ -524,9 +545,12 @@ declare module '@polkadot/api/types/errors' {
        * Wrong number of winners presented.
        **/
       PreDispatchWrongWinnerCount: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     elections: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * Duplicated candidate submission.
        **/
@@ -595,9 +619,12 @@ declare module '@polkadot/api/types/errors' {
        * Cannot vote when no candidates or members exist.
        **/
       UnableToVote: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     gilt: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * The amount of the bid is less than the minimum allowed.
        **/
@@ -631,9 +658,12 @@ declare module '@polkadot/api/types/errors' {
        * Gilt index is unknown.
        **/
       Unknown: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     grandpa: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * Attempt to signal GRANDPA change with one already pending.
        **/
@@ -664,9 +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.
        **/
@@ -731,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.
        **/
@@ -742,9 +778,12 @@ declare module '@polkadot/api/types/errors' {
        * Non existent public key.
        **/
       InvalidKey: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     indices: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * The index was not available.
        **/
@@ -765,9 +804,12 @@ declare module '@polkadot/api/types/errors' {
        * The index is permanent and may not be freed/changed.
        **/
       Permanent: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     lottery: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * A lottery has already ended.
        **/
@@ -792,17 +834,16 @@ declare module '@polkadot/api/types/errors' {
        * A lottery has not been configured.
        **/
       NotConfigured: AugmentedError<ApiType>;
-      /**
-       * An overflow has occurred.
-       **/
-      Overflow: AugmentedError<ApiType>;
       /**
        * Too many calls for a single lottery.
        **/
       TooManyCalls: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     multisig: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * Call is already approved by this signatory.
        **/
@@ -859,9 +900,12 @@ declare module '@polkadot/api/types/errors' {
        * A different timepoint was given to the multisig operation that is underway.
        **/
       WrongTimepoint: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     proxy: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * Account is already a proxy.
        **/
@@ -894,9 +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
        **/
@@ -949,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
        **/
@@ -965,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
        **/
@@ -984,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.
        **/
@@ -1007,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.
        **/
@@ -1082,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.
        **/
@@ -1165,16 +1220,22 @@ declare module '@polkadot/api/types/errors' {
        * 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.
        * 
@@ -1199,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!
        **/
@@ -1242,9 +1306,12 @@ declare module '@polkadot/api/types/errors' {
        * The given weight bound for the proposal was too low.
        **/
       WrongProposalWeight: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     technicalMembership: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * Already a member.
        **/
@@ -1253,9 +1320,12 @@ declare module '@polkadot/api/types/errors' {
        * Not a member.
        **/
       NotMember: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
     };
     tips: {
-      [key: string]: AugmentedError<ApiType>;
       /**
        * The tip was already found/started.
        **/
@@ -1280,9 +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.
        **/
@@ -1291,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.
        **/
@@ -1306,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

@@ -27,7 +27,6 @@ import type { ApiTypes } from '@polkadot/api/types';
 declare module '@polkadot/api/types/events' {
   export interface AugmentedEvents<ApiType> {
     assets: {
-      [key: string]: AugmentedEvent<ApiType>;
       /**
        * An approval for account `delegate` was cancelled by `owner`.
        * \[id, owner, delegate\]
@@ -105,9 +104,12 @@ declare module '@polkadot/api/types/events' {
        * \[id, owner, delegate, destination\]
        **/
       TransferredApproved: AugmentedEvent<ApiType, [AssetId, AccountId, AccountId, AccountId, TAssetBalance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
     };
     balances: {
-      [key: string]: AugmentedEvent<ApiType>;
       /**
        * A balance was set by root. \[who, free, reserved\]
        **/
@@ -143,9 +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\]
        **/
@@ -174,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\]
@@ -243,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\]
@@ -283,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.
        **/
@@ -362,9 +376,12 @@ declare module '@polkadot/api/types/events' {
        * An external proposal has been vetoed. \[who, proposal_hash, until\]
        **/
       Vetoed: AugmentedEvent<ApiType, [AccountId, Hash, BlockNumber]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
     };
     electionProviderMultiPhase: {
-      [key: string]: AugmentedEvent<ApiType>;
       /**
        * The election has been finalized, with `Some` of the given computation, or else if the
        * election failed, `None`.
@@ -393,9 +410,12 @@ declare module '@polkadot/api/types/events' {
        * The unsigned phase of the given round has started.
        **/
       UnsignedPhaseStarted: AugmentedEvent<ApiType, [u32]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
     };
     elections: {
-      [key: string]: AugmentedEvent<ApiType>;
       /**
        * A \[candidate\] was slashed by \[amount\] due to failing to obtain a seat as member or
        * runner-up.
@@ -433,9 +453,12 @@ declare module '@polkadot/api/types/events' {
        * A \[seat holder\] was slashed by \[amount\] by being forcefully removed from the set.
        **/
       SeatHolderSlashed: AugmentedEvent<ApiType, [AccountId, Balance]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
     };
     gilt: {
-      [key: string]: AugmentedEvent<ApiType>;
       /**
        * A bid was successfully placed.
        * \[ who, amount, duration \]
@@ -456,9 +479,12 @@ declare module '@polkadot/api/types/events' {
        * \[ index, who, original_amount, additional_amount \]
        **/
       GiltThawed: AugmentedEvent<ApiType, [ActiveIndex, AccountId, BalanceOf, BalanceOf]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
     };
     grandpa: {
-      [key: string]: AugmentedEvent<ApiType>;
       /**
        * New authority set has been applied. \[authority_set\]
        **/
@@ -471,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\]
        **/
@@ -516,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.
        **/
@@ -531,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\]
        **/
@@ -546,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!
        **/
@@ -565,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\]
@@ -585,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\]
        **/
@@ -611,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\]
@@ -642,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\]
        **/
@@ -657,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).
        **/
@@ -735,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\]
        * 
@@ -782,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.
        **/
@@ -797,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.
        **/
@@ -824,9 +891,12 @@ declare module '@polkadot/api/types/events' {
        * On on-chain remark happened. \[origin, remark_hash\]
        **/
       Remarked: AugmentedEvent<ApiType, [AccountId, Hash]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
     };
     technicalCommittee: {
-      [key: string]: AugmentedEvent<ApiType>;
       /**
        * A motion was approved by the required threshold.
        * \[proposal_hash\]
@@ -864,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.
        **/
@@ -891,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\]
        **/
@@ -914,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\]
        **/
@@ -946,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.
        **/
@@ -958,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.
        **/
@@ -971,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,13 +3,13 @@
 
 import type { Bytes, Data, Option, U8aFixed, Vec, bool, u32, u64 } from '@polkadot/types';
 import type { AnyNumber, ITuple, Observable } from '@polkadot/types/types';
-import type { AssetApproval, AssetApprovalKey, AssetBalance, AssetDetails, AssetMetadata } from '@polkadot/types/interfaces/assets';
+import type { AssetApproval, AssetBalance, AssetDetails, AssetMetadata } from '@polkadot/types/interfaces/assets';
 import type { UncleEntryItem } from '@polkadot/types/interfaces/authorship';
 import type { BabeAuthorityWeight, BabeEpochConfiguration, MaybeRandomness, NextConfigDescriptor, Randomness } from '@polkadot/types/interfaces/babe';
 import type { AccountData, BalanceLock } from '@polkadot/types/interfaces/balances';
 import type { ProposalIndex, Votes } from '@polkadot/types/interfaces/collective';
 import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
-import type { CodeHash, ContractInfo, DeletedContract, PrefabWasmModule, Schedule } from '@polkadot/types/interfaces/contracts';
+import type { CodeHash, ContractInfo, DeletedContract, PrefabWasmModule } from '@polkadot/types/interfaces/contracts';
 import type { PreimageStatus, PropIndex, Proposal, ReferendumIndex, ReferendumInfo, Voting } from '@polkadot/types/interfaces/democracy';
 import type { VoteThreshold } from '@polkadot/types/interfaces/elections';
 import type { ActiveGilt, ActiveGiltsTotal, ActiveIndex, GiltBid } from '@polkadot/types/interfaces/gilt';
@@ -17,7 +17,7 @@ import type { SetId, StoredPendingChange, StoredState } from '@polkadot/types/in
 import type { RegistrarInfo, Registration } from '@polkadot/types/interfaces/identity';
 import type { AuthIndex } from '@polkadot/types/interfaces/imOnline';
 import type { CallIndex, LotteryConfig } from '@polkadot/types/interfaces/lottery';
-import type { DeferredOffenceOf, Kind, OffenceDetails, OpaqueTimeSlot, ReportIdOf } from '@polkadot/types/interfaces/offences';
+import type { Kind, OffenceDetails, OpaqueTimeSlot, ReportIdOf } from '@polkadot/types/interfaces/offences';
 import type { ProxyAnnouncement, ProxyDefinition } from '@polkadot/types/interfaces/proxy';
 import type { ActiveRecovery, RecoveryConfig } from '@polkadot/types/interfaces/recovery';
 import type { AccountId, AccountIndex, AssetId, Balance, BalanceOf, BlockNumber, Hash, KeyTypeId, Moment, OpaqueCall, Perbill, Releases, Slot, ValidatorId } from '@polkadot/types/interfaces/runtime';
@@ -35,16 +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: AugmentedQueryDoubleMap<ApiType, (key1: AssetId | AnyNumber | Uint8Array, key2: AssetApprovalKey | { owner?: any; delegate?: any } | string | Uint8Array) => Observable<Option<AssetApproval>>, [AssetId, AssetApprovalKey]> & QueryableStorageEntry<ApiType, [AssetId, AssetApprovalKey]>;
+      approvals: AugmentedQuery<ApiType, (arg1: AssetId | AnyNumber | Uint8Array, arg2: AccountId | string | Uint8Array, arg3: AccountId | string | Uint8Array) => Observable<Option<AssetApproval>>, [AssetId, AccountId, AccountId]> & QueryableStorageEntry<ApiType, [AssetId, AccountId, AccountId]>;
       /**
        * Details of an asset.
        **/
@@ -53,9 +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.
        **/
@@ -68,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.
        **/
@@ -165,9 +171,12 @@ declare module '@polkadot/api/types/storage' {
        * TWOX-NOTE: `SegmentIndex` is an increasing integer, so this is okay.
        **/
       underConstruction: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Randomness>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
     };
     balances: {
-      [key: string]: QueryableStorageEntry<ApiType>;
       /**
        * The balance of an account.
        * 
@@ -189,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.
        **/
@@ -208,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.
        **/
@@ -225,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.
        * 
@@ -240,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).
        **/
@@ -267,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.
@@ -345,9 +362,12 @@ declare module '@polkadot/api/types/storage' {
        * TWOX-NOTE: SAFE as `AccountId`s are crypto hashes anyway.
        **/
       votingOf: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Voting>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
     };
     electionProviderMultiPhase: {
-      [key: string]: QueryableStorageEntry<ApiType>;
       /**
        * Current phase.
        **/
@@ -383,9 +403,12 @@ declare module '@polkadot/api/types/storage' {
        * Only exists when [`Snapshot`] is present.
        **/
       snapshotMetadata: AugmentedQuery<ApiType, () => Observable<Option<SolutionOrSnapshotSize>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
     };
     elections: {
-      [key: string]: QueryableStorageEntry<ApiType>;
       /**
        * The present candidate list. A current member or runner-up can never enter this vector
        * and is always implicitly assumed to be a candidate.
@@ -418,9 +441,12 @@ declare module '@polkadot/api/types/storage' {
        * TWOX-NOTE: SAFE as `AccountId` is a crypto hash.
        **/
       voting: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Voter>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
     };
     gilt: {
-      [key: string]: QueryableStorageEntry<ApiType>;
       /**
        * The currently active gilts, indexed according to the order of creation.
        **/
@@ -441,9 +467,12 @@ declare module '@polkadot/api/types/storage' {
        * whose duration is one `Period` would be storage `0`.
        **/
       queueTotals: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, BalanceOf]>>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
     };
     grandpa: {
-      [key: string]: QueryableStorageEntry<ApiType>;
       /**
        * The number of changes (both in terms of keys and underlying economic responsibilities)
        * in the "set" of Grandpa validators from genesis.
@@ -472,9 +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.
        * 
@@ -501,14 +533,17 @@ declare module '@polkadot/api/types/storage' {
        * context. If the account is not some other account's sub-identity, then just `None`.
        **/
       superOf: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Option<ITuple<[AccountId, Data]>>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
     };
     imOnline: {
-      [key: string]: QueryableStorageEntry<ApiType>;
       /**
        * For each session index, we keep a mapping of `ValidatorId<T>` to the
        * number of blocks authored by the given authority.
        **/
-      authoredBlocks: AugmentedQueryDoubleMap<ApiType, (key1: SessionIndex | AnyNumber | Uint8Array, key2: ValidatorId | string | Uint8Array) => Observable<u32>, [SessionIndex, ValidatorId]> & QueryableStorageEntry<ApiType, [SessionIndex, ValidatorId]>;
+      authoredBlocks: AugmentedQuery<ApiType, (arg1: SessionIndex | AnyNumber | Uint8Array, arg2: ValidatorId | string | Uint8Array) => Observable<u32>, [SessionIndex, ValidatorId]> & QueryableStorageEntry<ApiType, [SessionIndex, ValidatorId]>;
       /**
        * The block number after which it's ok to send heartbeats in the current
        * session.
@@ -531,17 +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`.
@@ -567,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.
        * 
@@ -585,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.
        **/
@@ -618,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).
        **/
@@ -630,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.
        * 
@@ -659,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.
        **/
@@ -676,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.
        **/
@@ -711,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.
        **/
@@ -774,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.
        * 
@@ -835,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.
        * 
@@ -849,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.
        * 
@@ -869,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.
        * 
@@ -911,7 +977,7 @@ 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.
        **/
@@ -954,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.
        **/
@@ -1039,9 +1111,12 @@ declare module '@polkadot/api/types/storage' {
        * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
        **/
       upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
     };
     technicalCommittee: {
-      [key: string]: QueryableStorageEntry<ApiType>;
       /**
        * The current members of the collective. This is stored sorted (just by value).
        **/
@@ -1066,9 +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.
        **/
@@ -1077,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?
        **/
@@ -1088,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.
@@ -1102,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.
        **/
@@ -1122,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

@@ -10,7 +10,7 @@ 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';
@@ -20,7 +20,7 @@ import type { StorageKind } from '@polkadot/types/interfaces/offchain';
 import type { FeeDetails, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
 import type { RpcMethods } from '@polkadot/types/interfaces/rpc';
 import type { AccountId, BlockNumber, H160, H256, H64, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime';
-import type { ReadProof, RuntimeVersion } from '@polkadot/types/interfaces/state';
+import type { ReadProof, RuntimeVersion, TraceBlockResponse } from '@polkadot/types/interfaces/state';
 import type { ApplyExtrinsicResult, ChainProperties, ChainType, Health, NetworkState, NodeRole, PeerInfo, SyncState } from '@polkadot/types/interfaces/system';
 
 declare module '@polkadot/rpc-core/types.jsonrpc' {
@@ -128,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
        **/
@@ -378,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
        **/
@@ -442,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: {
       /**
@@ -510,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

@@ -6,7 +6,7 @@ import type { AnyNumber, ITuple } from '@polkadot/types/types';
 import type { AssetDestroyWitness, TAssetBalance } from '@polkadot/types/interfaces/assets';
 import type { BabeEquivocationProof, NextConfigDescriptor } from '@polkadot/types/interfaces/babe';
 import type { MemberCount, ProposalIndex } from '@polkadot/types/interfaces/collective';
-import type { CodeHash, 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';
@@ -29,7 +29,6 @@ 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.
        * 
@@ -433,16 +432,22 @@ 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.
@@ -468,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.
@@ -545,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.
@@ -667,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.
        * 
@@ -725,17 +739,11 @@ declare module '@polkadot/api/types/submittable' {
        **/
       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's version cannot be less than the version of the stored schedule.
-       * If a schedule does not change the instruction weights the version does not
-       * need to be increased. Therefore we allow storing a schedule that has the same
-       * version as the stored one.
        **/
-      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.
        * 
@@ -872,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.
@@ -1205,9 +1216,12 @@ 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: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Submit a solution for the unsigned phase.
        * 
@@ -1225,9 +1239,12 @@ declare module '@polkadot/api/types/submittable' {
        * 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.
@@ -1330,9 +1347,12 @@ 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: {
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
       /**
        * Place a bid for a gilt to be issued.
        * 
@@ -1378,9 +1398,12 @@ declare module '@polkadot/api/types/submittable' {
        * - `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
@@ -1410,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.
        * 
@@ -1674,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)
@@ -1689,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.
        * 
@@ -1801,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.
        * 
@@ -1847,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`.
@@ -1986,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.
        * 
@@ -2181,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.
        * 
@@ -2383,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.
        * 
@@ -2454,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.
@@ -2489,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.
        * 
@@ -2809,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.
@@ -3243,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.
        * 
@@ -3298,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.
        **/
@@ -3406,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.
        * 
@@ -3545,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.
        * 
@@ -3595,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.
        * 
@@ -3616,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.
        * 
@@ -3751,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.
@@ -3791,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.
        * 
@@ -3847,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.
        * 
@@ -3923,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');
 
@@ -262,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(', ')}`);
@@ -270,17 +271,10 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
 
     // loop through all entries we have (populated in decorate) and filter as required
     // only remove when we have results and method missing, or with no results if optional
-    allKnown
+    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 & RpcInterface, decorateMethod: DecorateMethod<ApiType>, input: Partial<DecoratedRpc<ApiType, RpcInterface>> = {}): DecoratedRpc<ApiType, RpcInterface> {
@@ -297,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;
@@ -360,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 */
@@ -369,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[]> =>
@@ -447,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
@@ -478,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)
@@ -506,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/Init.ts

@@ -1,6 +1,7 @@
 // Copyright 2017-2021 @polkadot/api authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { RpcInterfaceMethod } from '@polkadot/rpc-core/types';
 import type { Text } from '@polkadot/types';
 import type { ChainProperties, Hash, RuntimeVersion } from '@polkadot/types/interfaces';
 import type { Registry } from '@polkadot/types/types';
@@ -22,7 +23,6 @@ import { detectedCapabilities } from './capabilities';
 import { Decorate } from './Decorate';
 
 const KEEPALIVE_INTERVAL = 10000;
-const DEFAULT_BLOCKNUMBER = { unwrap: () => BN_ZERO };
 
 const l = logger('api/init');
 
@@ -31,7 +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);
@@ -58,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);
@@ -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,
+      await (this._rpcCore.state.getMetadata as RpcInterfaceMethod).raw(header.parentHash).toPromise()
+    );
     const registry = this._initRegistry(new TypeRegistry(blockHash), this._runtimeChain as Text, version, metadata);
 
-    // For now, since this is new we ignore the capability lookups (this could be useful once proven)
-    // this._detectCapabilities(registry, blockHash);
-
     // add our new registry
-    const result = { isDefault: false, lastBlockHash, metadata, metadataConsts: null, registry, specVersion: version.specVersion };
+    const result = { isDefault: false, lastBlockHash: blockHash, metadata, metadataConsts: null, registry, specVersion: version.specVersion };
 
     this.#registries.push(result);
 
+    // TODO This could be useful for historic, disabled due to cross-looping, i.e. .at queries
+    // this._detectCapabilities(registry, blockHash);
+
     return result;
   }
 
@@ -156,10 +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))})` : ''}: ${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);
             })
           )
       )
@@ -293,15 +300,36 @@ export abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
 
     // inject metadata and adjust the types as detected
     this.injectMetadata(metadata, true);
-    this._detectCapabilities();
 
     // derive is last, since it uses the decorated rx
     this._rx.derive = this._decorateDeriveRx(this._rxDecorateMethod);
     this._derive = this._decorateDerive(this._decorateMethod);
 
+    // detect the on-chain capabilities
+    this._detectCapabilities(this.registry);
+
     return true;
   }
 
+  private _unsubscribeHealth (): void {
+    if (this.#healthTimer) {
+      clearInterval(this.#healthTimer);
+      this.#healthTimer = null;
+    }
+  }
+
+  private _unsubscribeUpdates (): void {
+    if (this.#updateSub) {
+      this.#updateSub.unsubscribe();
+      this.#updateSub = null;
+    }
+  }
+
+  protected _unsubscribe (): void {
+    this._unsubscribeHealth();
+    this._unsubscribeUpdates();
+  }
+
   #onProviderConnect = async (): Promise<void> => {
     this.emit('connected');
     this._isConnected.next(true);
@@ -337,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

@@ -2,18 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { ApiInterfaceRx } from '@polkadot/api/types';
-import type { bool, Raw, u32 } from '@polkadot/types';
+import type { Raw, u32 } from '@polkadot/types';
 import type { Releases } from '@polkadot/types/interfaces';
 import type { InterfaceTypes } from '@polkadot/types/types';
 
 import { assert, compactFromU8a } from '@polkadot/util';
 import { combineLatest, Observable, of } from '@polkadot/x-rxjs';
-import { map, take } from '@polkadot/x-rxjs/operators';
+import { catchError, map, take } from '@polkadot/x-rxjs/operators';
 
 // the order and types needs to map with the all array setup below
-type ExtractedQ = [bool | null, bool | null, bool | null, Releases | null];
+type ExtractedQ = [Releases | null];
 
-type ExtractedR = [Raw | null];
+type ExtractedR = [Raw | null, Raw | null];
 
 type ExtractedC = [u32 | null, u32 | null];
 
@@ -38,23 +38,26 @@ interface AvailableMap<T> {
 
 interface Constants {
   accountIdLength: number;
+  refcount1Length: number;
+  refcount2Length: number;
+  refcount3Length: number;
 }
 
 const NumberMap = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten'];
 
-function mapCapabilities ({ accountIdLength }: Constants, [leasePeriodsPerSlot, slotRangeCount]: ExtractedC, [systemRefcount32, systemRefcountDual, systemRefcountTriple, stakingVersion]: ExtractedQ, [keys]: ExtractedR): Partial<DetectedTypes> {
+function mapCapabilities ({ accountIdLength, refcount1Length, refcount2Length, refcount3Length }: Constants, [leasePeriodsPerSlot, slotRangeCount]: ExtractedC, [stakingVersion]: ExtractedQ, [keys, accountInfo]: ExtractedR): Partial<DetectedTypes> {
   const types: Partial<DetectedTypes> = {};
 
   // AccountInfo
-  if (systemRefcountTriple && systemRefcountTriple.isTrue) {
+  if (accountInfo) {
-    types.AccountInfo = 'AccountInfoWithTripleRefCount';
+    const length = accountInfo.length;
-  } else if (systemRefcountDual && systemRefcountDual.isTrue) {
-    types.AccountInfo = 'AccountInfoWithDualRefCount';
-  } else {
-    types.AccountInfo = 'AccountInfoWithRefCount';
 
-    if (!systemRefcount32 || systemRefcount32.isFalse) {
+    if (length === refcount1Length) {
-      types.RefCount = 'u8';
+      types.AccountInfo = 'AccountInfoWithRefCount';
+    } else if (length === refcount2Length) {
+      types.AccountInfo = 'AccountInfoWithDualRefCount';
+    } else if (length === refcount3Length) {
+      types.AccountInfo = 'AccountInfoWithTripleRefCount';
     }
   }
 
@@ -91,8 +94,8 @@ function mapCapabilities ({ accountIdLength }: Constants, [leasePeriodsPerSlot,
         // @ts-ignore
         types.Keys = `SessionKeys${numIds - 1}`;
       }
-    } catch (error) {
+    } catch {
-      console.error(error);
+      // ignore
     }
   }
 
@@ -115,9 +118,12 @@ function mapCapabilities ({ accountIdLength }: Constants, [leasePeriodsPerSlot,
 
 function filterEntries <T> (original: T[]): AvailableMap<T> {
   const included = original.map((c) => !!c);
-  const filtered = original.filter((_, index) => included[index]);
 
-  return { filtered, included, original };
+  return {
+    filtered: original.filter((_, index) => included[index]),
+    included,
+    original
+  };
 }
 
 function extractResults <R, T = unknown> (results: unknown[], map: AvailableMap<T>): R {
@@ -134,18 +140,17 @@ function extractResults <R, T = unknown> (results: unknown[], map: AvailableMap<
  * @description Query the chain for the specific capabilities
  */
 export function detectedCapabilities (api: ApiInterfaceRx, blockHash?: Uint8Array | string | undefined): Observable<Partial<DetectedTypes>> {
+  const emptyAccountId = api.registry.createType('AccountId');
   const consts = filterEntries([
     api.consts.auctions?.leasePeriodsPerSlot,
     api.consts.auctions?.slotRangeCount
   ]);
   const queries = filterEntries([
-    api.query.system?.upgradedToU32RefCount,
-    api.query.system?.upgradedToDualRefCount,
-    api.query.system?.upgradedToTripleRefCount,
     api.query.staking?.storageVersion
   ]);
   const raws = filterEntries([
-    api.query.session?.queuedKeys
+    api.query.session?.queuedKeys.key(),
+    api.query.system?.account?.key(emptyAccountId)
   ]);
 
   return combineLatest([
@@ -162,20 +167,24 @@ export function detectedCapabilities (api: ApiInterfaceRx, blockHash?: Uint8Arra
       : of([]),
     raws.filtered.length
       ? blockHash
-        ? combineLatest(raws.filtered.map((k) => api.rpc.state.getStorage.raw(k.key(), blockHash)))
+        ? combineLatest(raws.filtered.map((k) => api.rpc.state.getStorage.raw(k, blockHash)))
-        : combineLatest(raws.filtered.map((k) => api.rpc.state.getStorage.raw(k.key())))
+        : combineLatest(raws.filtered.map((k) => api.rpc.state.getStorage.raw(k)))
       : of([])
   ]).pipe(
     map(([cResults, qResults, rResults]): Partial<DetectedTypes> =>
       mapCapabilities(
         {
-          accountIdLength: api.registry.createType('AccountId').encodedLength
+          accountIdLength: emptyAccountId.encodedLength,
+          refcount1Length: api.registry.createType('AccountInfoWithRefCount').encodedLength,
+          refcount2Length: api.registry.createType('AccountInfoWithDualRefCount').encodedLength,
+          refcount3Length: api.registry.createType('AccountInfoWithTripleRefCount').encodedLength
         },
         extractResults<ExtractedC>(cResults, consts),
         extractResults<ExtractedQ>(qResults, queries),
         extractResults<ExtractedR>(rResults, raws)
       )
     ),
-    take(1)
+    take(1),
+    catchError(() => of({}))
   );
 }

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/checkTypes.manual.ts

@@ -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/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/api', version: '4.7.1' };
+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/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/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/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'
@@ -38,15 +39,15 @@ export type QueryableStorageEntry<ApiType extends ApiTypes, A extends AnyTuple =
 export interface StorageEntryBase<ApiType extends ApiTypes, F extends AnyFunction, A extends AnyTuple = AnyTuple> {
   at: <T extends Codec | any = ObsInnerType<ReturnType<F>>>(hash: Hash | Uint8Array | string, ...args: Parameters<F>) => PromiseOrObs<ApiType, T>;
   creator: StorageEntry;
-  entries: <T extends Codec | any = ObsInnerType<ReturnType<F>>, K extends AnyTuple = A>(arg?: Parameters<F>[0]) => PromiseOrObs<ApiType, [StorageKey<K>, T][]>;
+  entries: <T extends Codec | any = ObsInnerType<ReturnType<F>>, K extends AnyTuple = A>(...args: DropLast<Parameters<F>>) => PromiseOrObs<ApiType, [StorageKey<K>, T][]>;
-  entriesAt: <T extends Codec | any = ObsInnerType<ReturnType<F>>, K extends AnyTuple = A>(hash: Hash | Uint8Array | string, arg?: Parameters<F>[0]) => PromiseOrObs<ApiType, [StorageKey<K>, T][]>;
+  entriesAt: <T extends Codec | any = ObsInnerType<ReturnType<F>>, K extends AnyTuple = A>(hash: Hash | Uint8Array | string, ...args: DropLast<Parameters<F>>) => PromiseOrObs<ApiType, [StorageKey<K>, T][]>;
   entriesPaged: <T extends Codec | any = ObsInnerType<ReturnType<F>>, K extends AnyTuple = A>(opts: PaginationOptions<Parameters<F>[0]>) => PromiseOrObs<ApiType, [StorageKey<K>, T][]>;
   hash: (...args: Parameters<F>) => PromiseOrObs<ApiType, Hash>;
   is: (key: IStorageKey<AnyTuple>) => key is IStorageKey<A>;
   key: (...args: Parameters<F>) => string;
-  keyPrefix: () => string;
+  keyPrefix: (...args: DropLast<Parameters<F>>) => string;
-  keys: <K extends AnyTuple = A> (arg?: any) => PromiseOrObs<ApiType, StorageKey<K>[]>;
+  keys: <K extends AnyTuple = A> (...args: DropLast<Parameters<F>>) => PromiseOrObs<ApiType, StorageKey<K>[]>;
-  keysAt: <K extends AnyTuple = A> (hash: Hash | Uint8Array | string, arg?: any) => PromiseOrObs<ApiType, StorageKey<K>[]>;
+  keysAt: <K extends AnyTuple = A> (hash: Hash | Uint8Array | string, ...args: DropLast<Parameters<F>>) => PromiseOrObs<ApiType, StorageKey<K>[]>;
   keysPaged: <K extends AnyTuple = A> (opts: PaginationOptions<Parameters<F>[0]>) => PromiseOrObs<ApiType, StorageKey<K>[]>;
   // @deprecated The underlying RPC this been marked unsafe and is generally not exposed
   range: <T extends Codec | any = ObsInnerType<ReturnType<F>>>([from, to]: [Hash | Uint8Array | string, Hash | Uint8Array | string | undefined] | [Hash | Uint8Array | string], ...args: Parameters<F>) => PromiseOrObs<ApiType, [Hash, T][]>;
@@ -80,10 +81,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

packages/api/src/util/validate.ts

@@ -6,14 +6,14 @@ import type { StorageEntry } from '@polkadot/types/primitive/types';
 
 import { assert, isUndefined } from '@polkadot/util';
 
-function sig ({ method, section }: StorageEntry, ...args: Type[]): string {
+function sig ({ method, section }: StorageEntry, args: Type[]): string {
   return `${section}.${method}(${args.join(', ')})`;
 }
 
 function doDoubleMap (creator: StorageEntry, args: unknown[]): [StorageEntry, [any, any]] {
   const { key1, key2 } = creator.meta.type.asDoubleMap;
 
-  assert(args.length === 2, () => `${sig(creator, key1, key2)} is a doublemap, requiring 2 arguments, ${args.length} found`);
+  assert(args.length === 2, () => `${sig(creator, [key1, key2])} is a double map, requiring 2 arguments, ${args.length} found`);
 
   // pass as tuple
   return [creator, args as [any, any]];
@@ -22,7 +22,7 @@ function doDoubleMap (creator: StorageEntry, args: unknown[]): [StorageEntry, [a
 function doMap (creator: StorageEntry, args: unknown[]): [StorageEntry] | [StorageEntry, any] {
   const { key } = creator.meta.type.asMap;
 
-  assert(args.length === 1, () => `${sig(creator, key)} is a map, requiring 1 argument, ${args.length} found`);
+  assert(args.length === 1, () => `${sig(creator, [key])} is a map, requiring 1 argument, ${args.length} found`);
 
   // expand
   return args.length
@@ -30,18 +30,29 @@ function doMap (creator: StorageEntry, args: unknown[]): [StorageEntry] | [Stora
     : [creator];
 }
 
+function doNMap (creator: StorageEntry, args: unknown[]): [StorageEntry, any[]] {
+  const { keyVec } = creator.meta.type.asNMap;
+
+  assert(args.length === keyVec.length, () => `${sig(creator, keyVec)} is a multi map, requiring ${keyVec.length} arguments, ${args.length} found`);
+
+  // pass as tuple
+  return [creator, args];
+}
+
 // sets up the arguments in the form of [creator, args] ready to be used in a storage
 // call. Additionally, it verifies that the correct number of arguments have been passed
-export function extractStorageArgs (creator: StorageEntry, _args: unknown[]): [StorageEntry, [any, any]] | [StorageEntry] | [StorageEntry, any] {
+export function extractStorageArgs (creator: StorageEntry, _args: unknown[]): [StorageEntry, any[]] | [StorageEntry] | [StorageEntry, any] {
   const args = _args.filter((arg) => !isUndefined(arg));
 
   if (creator.meta.type.isDoubleMap) {
     return doDoubleMap(creator, args);
   } else if (creator.meta.type.isMap) {
     return doMap(creator, args);
+  } else if (creator.meta.type.isNMap) {
+    return doNMap(creator, args);
   }
 
-  assert(args.length === 0, () => `${sig(creator)} does not take any arguments, ${args.length} found`);
+  assert(args.length === 0, () => `${sig(creator, [])} does not take any arguments, ${args.length} found`);
 
   // no args
   return [creator];

packages/api/test/api.spec.ts

@@ -14,7 +14,7 @@ function createApi (): Promise<ApiPromise> {
   return new ApiPromise({ provider }).isReady;
 }
 
-describe.skip('misc quick tests', (): void => {
+describe('misc quick tests', (): void => {
   it.skip('retrieves balances correctly', async (): Promise<void> => {
     const api = await createApi();
 
@@ -76,4 +76,12 @@ describe.skip('misc quick tests', (): void => {
         .map(([block, value]) => [block, value.toRawType(), value.toHuman()])
     ));
   });
+
+  it('expose rpc and rx definition', async (): Promise<void> => {
+    const api = await createApi();
+
+    console.error(api.rpc.payment.queryFeeDetails.meta);
+
+    console.error(api.rx.rpc.chain.getBlock.meta);
+  });
 });

packages/metadata/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/metadata",
-  "version": "4.7.1",
+  "version": "4.11.1",
   "type": "module",
   "description": "Helpers to extract information from runtime metadata",
   "main": "index.js",
@@ -19,14 +19,14 @@
   "bugs": "https://github.com/polkadot-js/api/issues",
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/type-metadata#readme",
   "dependencies": {
-    "@babel/runtime": "^7.13.17",
+    "@babel/runtime": "^7.14.0",
-    "@polkadot/types": "4.7.1",
+    "@polkadot/types": "4.11.1",
-    "@polkadot/types-known": "4.7.1",
+    "@polkadot/types-known": "4.11.1",
-    "@polkadot/util": "^6.3.1",
+    "@polkadot/util": "^6.5.1",
-    "@polkadot/util-crypto": "^6.3.1",
+    "@polkadot/util-crypto": "^6.5.1",
     "bn.js": "^4.11.9"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^6.3.1"
+    "@polkadot/keyring": "^6.5.1"
   }
 }

packages/metadata/src/MagicNumber.spec.ts

@@ -9,10 +9,20 @@ describe('MagicNumber', (): void => {
   const registry = new TypeRegistry();
 
   it('succeeds when the magic number matches', (): void => {
-    expect((): MagicNumber => new MagicNumber(registry, MAGIC_NUMBER)).not.toThrow();
+    expect(
+      () => new MagicNumber(registry, MAGIC_NUMBER)
+    ).not.toThrow();
+  });
+
+  it('succeeds when the magic number is empty', (): void => {
+    expect(
+      () => new MagicNumber(registry)
+    ).not.toThrow();
   });
 
   it('fails when the magic number mismatches', (): void => {
-    expect((): MagicNumber => new MagicNumber(registry, 0x12345)).toThrow(/MagicNumber/);
+    expect(
+      () => new MagicNumber(registry, 0x12345678)
+    ).toThrow(/MagicNumber mismatch/);
   });
 });

packages/metadata/src/MagicNumber.ts

@@ -13,9 +13,7 @@ export class MagicNumber extends U32 {
     super(registry, value);
 
     if (!this.isEmpty) {
-      const magic = registry.createType('u32', MAGIC_NUMBER);
+      assert(this.eq(MAGIC_NUMBER), () => `MagicNumber mismatch: expected ${registry.createType('u32', MAGIC_NUMBER).toHex()}, found ${this.toHex()}`);
-
-      assert(this.eq(magic), () => `MagicNumber mismatch: expected ${magic.toHex()}, found ${this.toHex()}`);
     }
   }
 }

packages/metadata/src/Metadata.ts

@@ -3,7 +3,7 @@
 
 import type { Registry } from '@polkadot/types/types';
 
-import { isString, u8aConcat, u8aToU8a } from '@polkadot/util';
+import { isHex, isU8a, u8aToU8a } from '@polkadot/util';
 
 import { MetadataVersioned } from './MetadataVersioned';
 
@@ -11,37 +11,39 @@ import { MetadataVersioned } from './MetadataVersioned';
 const VERSION_IDX = 4;
 
 // magic + lowest supported version
-const EMPTY_METADATA = u8aConcat(new Uint8Array([0x6d, 0x65, 0x74, 0x61, 9]));
+const EMPTY_METADATA = new Uint8Array([0x6d, 0x65, 0x74, 0x61, 9]);
 const EMPTY_U8A = new Uint8Array();
 
-function sanitizeInput (_value: Uint8Array | string = EMPTY_U8A): Uint8Array {
+function toU8a (value: Uint8Array | string = EMPTY_U8A): Uint8Array {
-  if (isString(_value)) {
+  return isHex(value)
-    return sanitizeInput(u8aToU8a(_value));
+    ? toU8a(u8aToU8a(value))
-  }
+    : isU8a(value) && value.length === 0
-
+      ? EMPTY_METADATA
-  return _value.length === 0
+      : value;
-    ? EMPTY_METADATA
-    : _value;
 }
 
-function decodeMetadata (registry: Registry, _value?: Uint8Array | string): MetadataVersioned {
+function decodeMetadata (registry: Registry, _value?: Uint8Array | string | Map<string, unknown> | Record<string, unknown>): MetadataVersioned {
-  const value = sanitizeInput(_value);
+  if (!_value || isU8a(_value) || isHex(_value)) {
-  const version = value[VERSION_IDX];
+    const value = toU8a(_value);
+    const version = value[VERSION_IDX];
 
-  try {
+    try {
-    return new MetadataVersioned(registry, value);
+      return new MetadataVersioned(registry, value);
-  } catch (error) {
+    } catch (error) {
-    // This is an f-ing hack as a follow-up to another ugly hack
+      // This is an f-ing hack as a follow-up to another ugly hack
-    // https://github.com/polkadot-js/api/commit/a9211690be6b68ad6c6dad7852f1665cadcfa5b2
+      // https://github.com/polkadot-js/api/commit/a9211690be6b68ad6c6dad7852f1665cadcfa5b2
-    // when we fail on V9, try to re-parse it as v10... yes... HACK
+      // when we fail on V9, try to re-parse it as v10... yes... HACK
-    if (version === 9) {
+      if (version === 9) {
-      value[VERSION_IDX] = 10;
+        value[VERSION_IDX] = 10;
 
-      return decodeMetadata(registry, value);
+        return decodeMetadata(registry, value);
+      }
+
+      throw error;
     }
-
-    throw error;
   }
+
+  return new MetadataVersioned(registry, _value);
 }
 
 /**
@@ -50,7 +52,7 @@ function decodeMetadata (registry: Registry, _value?: Uint8Array | string): Meta
  * The versioned runtime metadata as a decoded structure
  */
 export class Metadata extends MetadataVersioned {
-  constructor (registry: Registry, value?: Uint8Array | string) {
+  constructor (registry: Registry, value?: Uint8Array | string | Map<string, unknown> | Record<string, unknown>) {
     super(registry, decodeMetadata(registry, value));
   }
 }

packages/metadata/src/MetadataVersioned.ts

@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/metadata authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { MetadataAll, MetadataLatest, MetadataV9, MetadataV10, MetadataV11, MetadataV12 } from '@polkadot/types/interfaces/metadata';
+import type { MetadataAll, MetadataLatest, MetadataV9, MetadataV10, MetadataV11, MetadataV12, MetadataV13 } from '@polkadot/types/interfaces/metadata';
 import type { AnyJson, Registry } from '@polkadot/types/types';
 
 import { Struct } from '@polkadot/types/codec';
@@ -10,13 +10,16 @@ import { assert } from '@polkadot/util';
 import { toV10 } from './v9/toV10';
 import { toV11 } from './v10/toV11';
 import { toV12 } from './v11/toV12';
-import { toLatest } from './v12/toLatest';
+import { toV13 } from './v12/toV13';
+import { toLatest } from './v13/toLatest';
 import { MagicNumber } from './MagicNumber';
 import { getUniqTypes, toCallsOnly } from './util';
 
-type MetaMapped = MetadataV9 | MetadataV10 | MetadataV11 | MetadataV12;
+type MetaMapped = MetadataV9 | MetadataV10 | MetadataV11 | MetadataV12 | MetadataV13;
-type MetaVersions = 9 | 10 | 11 | 12 | 13;
+type MetaAsX = 'asV9' | 'asV10' | 'asV11' | 'asV12' | 'asV13';
-type MetaAsX = 'asV9' | 'asV10' | 'asV11' | 'asV12';
+type MetaVersions = 'latest' | 9 | 10 | 11 | 12 | 13;
+
+const LATEST_VERSION = 13;
 
 /**
  * @name MetadataVersioned
@@ -24,7 +27,7 @@ type MetaAsX = 'asV9' | 'asV10' | 'asV11' | 'asV12';
  * The versioned runtime metadata as a decoded structure
  */
 export class MetadataVersioned extends Struct {
-  readonly #converted = new Map<number, MetaMapped>();
+  readonly #converted = new Map<MetaVersions, MetaMapped>();
 
   constructor (registry: Registry, value?: unknown) {
     super(registry, {
@@ -34,16 +37,18 @@ export class MetadataVersioned extends Struct {
   }
 
   #assertVersion = (version: number): boolean => {
-    assert(this.version <= version, () => `Cannot convert metadata from v${this.version} to v${version}`);
+    assert(this.version <= version, () => `Cannot convert metadata from version ${this.version} to ${version}`);
 
     return this.version === version;
   };
 
   #getVersion = <T extends MetaMapped, F extends MetaMapped>(version: MetaVersions, fromPrev: (registry: Registry, input: F, metaVersion: number) => T): T => {
     const asCurr = `asV${version}` as MetaAsX;
-    const asPrev = `asV${version - 1}` as MetaAsX;
+    const asPrev = version === 'latest'
+      ? `asV${LATEST_VERSION}` as MetaAsX
+      : `asV${version - 1}` as MetaAsX;
 
-    if (this.#assertVersion(version)) {
+    if (version !== 'latest' && this.#assertVersion(version)) {
       return this.#metadata()[asCurr] as T;
     }
 
@@ -101,16 +106,23 @@ export class MetadataVersioned extends Struct {
     return this.#getVersion(12, toV12);
   }
 
+  /**
+   * @description Returns the wrapped values as a V13 object
+   */
+  public get asV13 (): MetadataV13 {
+    return this.#getVersion(13, toV13);
+  }
+
   /**
    * @description Returns the wrapped values as a latest version object
    */
   public get asLatest (): MetadataLatest {
     // This is non-existent & latest - applied here to do the module-specific type conversions
-    return this.#getVersion(13, toLatest);
+    return this.#getVersion('latest', toLatest);
   }
 
   /**
-   * @description
+   * @description The magicNumber for the Metadata (known constant)
    */
   public get magicNumber (): MagicNumber {
     return this.get('magicNumber') as MagicNumber;
@@ -131,8 +143,8 @@ export class MetadataVersioned extends Struct {
    * @description Converts the Object to JSON, typically used for RPC transfers
    */
   public toJSON (): Record<string, AnyJson> {
-    // HACK(y): ensure that we apply the aliasses if we have not done so already, this is
+    // HACK(y): ensure that we apply the aliases if we have not done so already, this is
-    // needed to ensure we have the overrides as intended (only applied in toLatest)
+    // needed to ensure we have the correct overrides (which is only applied in toLatest)
     // eslint-disable-next-line no-unused-expressions
     this.asLatest;
 

packages/metadata/src/decorate/constants/index.spec.ts

@@ -17,7 +17,7 @@ function init (meta: string): [Constants, TypeRegistry] {
 
   registry.setMetadata(metadata);
 
-  return [decorateConstants(registry, metadata.asLatest), registry];
+  return [decorateConstants(registry, metadata.asLatest, 12), registry];
 }
 
 describe('decorateConstants', (): void => {

packages/metadata/src/decorate/constants/index.ts

@@ -8,7 +8,8 @@ import type { ConstantCodec, Constants, ModuleConstants } from '../types';
 import { hexToU8a, stringCamelCase } from '@polkadot/util';
 
 /** @internal */
-export function decorateConstants (registry: Registry, { modules }: MetadataLatest): Constants {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function decorateConstants (registry: Registry, { modules }: MetadataLatest, _metaVersion: number): Constants {
   return modules.reduce((result: Constants, { constants, name }): Constants => {
     if (constants.isEmpty) {
       return result;

packages/metadata/src/decorate/index.spec.ts

@@ -46,7 +46,7 @@ describe('Decorated', () => {
   });
 
   it('should return constants with the correct type and value', (): void => {
-    const consts = decorateConstants(registry, metadata.asLatest);
+    const consts = decorateConstants(registry, metadata.asLatest, metadata.version);
 
     expect(consts.democracy.cooloffPeriod).toBeInstanceOf(registry.createClass('BlockNumber'));
     expect(consts.democracy.cooloffPeriod.toHex()).toEqual('0x000c4e00');

packages/metadata/src/decorate/index.ts

@@ -20,13 +20,14 @@ export function expandMetadata (registry: Registry, metadata: Metadata): Decorat
   assert(metadata instanceof Metadata, 'You need to pass a valid Metadata instance to Decorated');
 
   const latest = metadata.asLatest;
+  const version = metadata.version;
 
   return {
-    consts: decorateConstants(registry, latest),
+    consts: decorateConstants(registry, latest, version),
-    errors: decorateErrors(registry, latest, metadata.version),
+    errors: decorateErrors(registry, latest, version),
-    events: decorateEvents(registry, latest, metadata.version),
+    events: decorateEvents(registry, latest, version),
-    query: decorateStorage(registry, latest, metadata.version),
+    query: decorateStorage(registry, latest, version),
-    tx: decorateExtrinsics(registry, latest, metadata.version)
+    tx: decorateExtrinsics(registry, latest, version)
   };
 }
 

packages/metadata/src/decorate/storage/createFunction.spec.ts

@@ -28,7 +28,7 @@ describe('createFunction', (): void => {
       method: 'NextKeys',
       prefix: 'Session',
       section: 'session'
-    }, { metaVersion: 9 });
+    }, {});
 
     expect(
       u8aToHex(
@@ -49,4 +49,52 @@ describe('createFunction', (): void => {
       '5eb36b60f0fc4b9177116eba3e5cd57fea6289a57f5f5b9ffeb0475c66e7a521' // blake2
     );
   });
+
+  it('allows creating of NMap keys (with Bytes)', (): void => {
+    const storageFn = createFunction(registry, {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      meta: {
+        type: {
+          asNMap: {
+            hashers: [
+              registry.createType('StorageHasher', 'Twox64Concat'),
+              registry.createType('StorageHasher', 'Blake2_256'),
+              registry.createType('StorageHasher', 'Blake2_256')
+            ],
+            keyVec: [
+              new Text(registry, 'Bytes'),
+              new Text(registry, 'AccountId'),
+              new Text(registry, 'AccountId')
+            ],
+            value: new Text(registry, 'SessionKeys5')
+          },
+          isNMap: true
+        }
+      } as any,
+      method: 'NextKeys',
+      prefix: 'Session',
+      section: 'session'
+    }, {});
+
+    expect(
+      u8aToHex(
+        storageFn([
+          // hex, without length prefix
+          '0x3a73657373696f6e3a6b657973',
+          // addresses
+          'DB2mp5nNhbFN86J9hxoAog8JALMhDXgwvWMxrRMLNUFMEY4',
+          'DB2mp5nNhbFN86J9hxoAog8JALMhDXgwvWMxrRMLNUFMEY4'
+        ])
+      )
+    ).toEqual(
+      '0x' +
+      'd901' + // length
+      'cec5070d609dd3497f72bde07fc96ba0' + // twox 128
+      '4c014e6bf8b8c2c011e7290b85696bb3' + // twox 128
+      '9fe6329cc0b39e09' + // twox 64
+      '343a73657373696f6e3a6b657973' + // twox 64 (concat, with length)
+      '5eb36b60f0fc4b9177116eba3e5cd57fea6289a57f5f5b9ffeb0475c66e7a521' + // blake2
+      '5eb36b60f0fc4b9177116eba3e5cd57fea6289a57f5f5b9ffeb0475c66e7a521' // blake2
+    );
+  });
 });

packages/metadata/src/decorate/storage/createFunction.ts

@@ -8,16 +8,15 @@ import type { Codec, Registry } from '@polkadot/types/types';
 import BN from 'bn.js';
 
 import { Raw } from '@polkadot/types/codec';
-import { StorageKey } from '@polkadot/types/primitive';
+import { StorageKey, Type } from '@polkadot/types/primitive';
-import { assert, compactAddLength, compactStripLength, isNull, isUndefined, stringLowerFirst, u8aConcat } from '@polkadot/util';
+import { assert, compactAddLength, compactStripLength, isNull, isUndefined, stringCamelCase, stringify, stringLowerFirst, u8aConcat, u8aToU8a } from '@polkadot/util';
 import { xxhashAsU8a } from '@polkadot/util-crypto';
 
-import { getHasher, HasherFunction } from './getHasher';
+import { getHasher } from './getHasher';
 
 export interface CreateItemOptions {
   key?: string;
-  metaVersion: number;
+  skipHashing?: boolean;
-  skipHashing?: boolean; // We don't hash the keys defined in ./substrate.ts
 }
 
 export interface CreateItemFn {
@@ -34,81 +33,41 @@ interface IterFn {
 
 type CreateArgType = boolean | string | number | null | BN | BigInt | Uint8Array | Codec;
 
-const EMPTY_U8A = new Uint8Array([]);
+type U8aHasher = (input: Uint8Array) => Uint8Array;
-const NULL_HASHER = (value: Uint8Array): Uint8Array => value;
 
-// get the hashers, the base (and  in the case of DoubleMap), the second key
-/** @internal */
-function getHashers ({ meta: { type } }: CreateItemFn): [HasherFunction, HasherFunction?] {
-  if (type.isDoubleMap) {
-    return [
-      getHasher(type.asDoubleMap.hasher),
-      getHasher(type.asDoubleMap.key2Hasher)
-    ];
-  } else if (type.isMap) {
-    return [getHasher(type.asMap.hasher)];
-  }
-
-  // the default
-  return [getHasher()];
-}
-
-// create a base prefixed key
-/** @internal */
 function createPrefixedKey ({ method, prefix }: CreateItemFn): Uint8Array {
   return u8aConcat(xxhashAsU8a(prefix, 128), xxhashAsU8a(method, 128));
 }
 
-// create a key for a DoubleMap type
+function createKeyRaw (registry: Registry, itemFn: CreateItemFn, keys: Type[], hashers: U8aHasher[], args: CreateArgType[]): Uint8Array {
-/** @internal */
+  const { method, section } = itemFn;
-function createKeyDoubleMap (registry: Registry, itemFn: CreateItemFn, args: [CreateArgType, CreateArgType], [hasher1, hasher2]: [HasherFunction, HasherFunction?]): Uint8Array {
-  const { meta: { name, type } } = itemFn;
 
-  // since we are passing an almost-unknown through, trust, but verify
+  return u8aConcat(
-  assert(Array.isArray(args) && !isUndefined(args[0]) && !isNull(args[0]) && !isUndefined(args[1]) && !isNull(args[1]), () => `${(name || 'unknown').toString()} is a DoubleMap and requires two arguments`);
-
-  // if this fails, we have bigger issues
-  assert(!isUndefined(hasher2), '2 hashing functions should be defined for DoubleMaps');
-
-  const [key1, key2] = args;
-  const map = type.asDoubleMap;
-  const val1 = registry.createType(map.key1.toString() as 'Raw', key1).toU8a();
-  const val2 = registry.createType(map.key2.toString() as 'Raw', key2).toU8a();
-
-  // as per createKey, always add the length prefix (underlying it is Bytes)
-  return compactAddLength(u8aConcat(
     createPrefixedKey(itemFn),
-    hasher1(val1),
+    ...keys.map((type, index): Uint8Array => {
-    hasher2(val2)
+      const arg = args[index];
-  ));
+
+      assert(!isUndefined(arg) && !isNull(arg), () => `Call to ${stringCamelCase(section || 'unknown')}.${stringCamelCase(method || 'unknown')} has a null or undefined argument at position ${index}`);
+
+      return hashers[index](registry.createType(type.toString() as 'Raw', arg).toU8a());
+    })
+  );
 }
 
-// create a key for either a map or a plain value
+function createKey (registry: Registry, itemFn: CreateItemFn, keys: Type[], hashers: U8aHasher[], args: CreateArgType[]): Uint8Array {
-/** @internal */
+  const { method, section } = itemFn;
-function createKey (registry: Registry, itemFn: CreateItemFn, arg: CreateArgType, hasher: (value: Uint8Array) => Uint8Array): Uint8Array {
-  const { meta: { name, type } } = itemFn;
-  let param: Uint8Array = EMPTY_U8A;
 
-  if (type.isMap) {
+  assert(Array.isArray(args) && args.length === keys.length, () => `Call to ${stringCamelCase(section || 'unknown')}.${stringCamelCase(method || 'unknown')} needs ${keys.length} arguments, found ${stringify(args)}`);
-    const map = type.asMap;
 
-    assert(!isUndefined(arg) && !isNull(arg), () => `${name.toString()} is a Map and requires one argument`);
+  // as per createKey, always add the length prefix (underlying it is Bytes)
-
+  return compactAddLength(
-    param = registry.createType(map.key.toString() as 'Raw', arg).toU8a();
+    createKeyRaw(registry, itemFn, keys, hashers, args)
-  }
+  );
-
-  // StorageKey is a Bytes, so is length-prefixed
-  return compactAddLength(u8aConcat(
-    createPrefixedKey(itemFn),
-    param.length
-      ? hasher(param)
-      : EMPTY_U8A
-  ));
 }
 
 // attach the metadata to expand to a StorageFunction
 /** @internal */
-function expandWithMeta ({ meta, method, prefix, section }: CreateItemFn, _storageFn: (arg?: CreateArgType | [CreateArgType?, CreateArgType?]) => Uint8Array): StorageEntry {
+function expandWithMeta ({ meta, method, prefix, section }: CreateItemFn, _storageFn: (arg?: CreateArgType | CreateArgType[]) => Uint8Array): StorageEntry {
   const storageFn = _storageFn as StorageEntry;
 
   storageFn.meta = meta;
@@ -127,48 +86,58 @@ function expandWithMeta ({ meta, method, prefix, section }: CreateItemFn, _stora
 }
 
 /** @internal */
-function extendHeadMeta (registry: Registry, { meta: { documentation, name, type }, section }: CreateItemFn, { method }: StorageEntry, iterFn: (arg?: any) => Raw): (arg?: any) => StorageKey {
+function extendHeadMeta (registry: Registry, { meta: { documentation, name, type }, section }: CreateItemFn, { method }: StorageEntry, iterFn: (...args: unknown[]) => Raw): (...args: unknown[]) => StorageKey {
   const outputType = type.isMap
-    ? type.asMap.key.toString()
+    ? type.asMap.key
-    : type.asDoubleMap.key1.toString();
+    : type.isDoubleMap
+      ? type.asDoubleMap.key1
+      : type.asNMap.keyVec[0];
 
   // metadata with a fallback value using the type of the key, the normal
   // meta fallback only applies to actual entry values, create one for head
   (iterFn as IterFn).meta = registry.createType('StorageEntryMetadataLatest', {
     documentation,
-    fallback: registry.createType('Bytes', registry.createType(outputType as 'Raw').toHex()),
+    fallback: registry.createType('Bytes', registry.createType(outputType.toString() as 'Raw').toHex()),
     modifier: registry.createType('StorageEntryModifierLatest', 1), // required
     name,
-    type: registry.createType('StorageEntryTypeLatest', registry.createType('Type', type.isMap ? type.asMap.key : type.asDoubleMap.key1), 0)
+    type: registry.createType('StorageEntryTypeLatest', registry.createType('Type', outputType), 0)
   });
 
-  const prefixKey = registry.createType('StorageKey', iterFn, { method, section });
+  return (...args: unknown[]) =>
-
+    registry.createType('StorageKey', iterFn(...args), { method, section });
-  return (arg?: any) =>
-    !isUndefined(arg) && !isNull(arg)
-      ? registry.createType('StorageKey', iterFn(arg), { method, section })
-      : prefixKey;
 }
 
 // attach the full list hashing for prefixed maps
 /** @internal */
 function extendPrefixedMap (registry: Registry, itemFn: CreateItemFn, storageFn: StorageEntry): StorageEntry {
-  const { meta: { type } } = itemFn;
+  const { meta: { type }, method, section } = itemFn;
 
-  storageFn.iterKey = extendHeadMeta(registry, itemFn, storageFn, (arg?: any): Raw => {
+  storageFn.iterKey = extendHeadMeta(registry, itemFn, storageFn, (...args: unknown[]): Raw => {
-    assert(type.isDoubleMap || isUndefined(arg), 'Filtering arguments for keys/entries are only valid on double maps');
+    assert(
-
+      (
-    return new Raw(
+        (args.length === 0) ||
-      registry,
+        (type.isDoubleMap && args.length === 1) ||
-      type.isDoubleMap && !isUndefined(arg) && !isNull(arg)
+        (type.isNMap && args.length === (type.asNMap.hashers.length - 1))
-        ? u8aConcat(
+      ),
-          createPrefixedKey(itemFn),
+      () => `Iteration ${stringCamelCase(section || 'unknown')}.${stringCamelCase(method || 'unknown')} needs arguments to be one less than the full arguments, found [${args.join(', ')}]`
-          getHasher(type.asDoubleMap.hasher)(
-            registry.createType(type.asDoubleMap.key1.toString() as 'Raw', arg).toU8a()
-          )
-        )
-        : createPrefixedKey(itemFn)
     );
+
+    if (args.length) {
+      if (type.isDoubleMap) {
+        return new Raw(registry, createKeyRaw(registry, itemFn, [type.asDoubleMap.key1], [getHasher(type.asDoubleMap.hasher)], args as CreateArgType[]));
+      } else if (type.isNMap) {
+        const keys = [...type.asNMap.keyVec];
+        const hashers = type.asNMap.hashers.map((h) => getHasher(h));
+
+        // remove the last entry
+        keys.pop();
+        hashers.pop();
+
+        return new Raw(registry, createKeyRaw(registry, itemFn, keys, hashers, args as CreateArgType[]));
+      }
+    }
+
+    return new Raw(registry, createKeyRaw(registry, itemFn, [], [], []));
   });
 
   return storageFn;
@@ -177,24 +146,30 @@ function extendPrefixedMap (registry: Registry, itemFn: CreateItemFn, storageFn:
 /** @internal */
 export function createFunction (registry: Registry, itemFn: CreateItemFn, options: CreateItemOptions): StorageEntry {
   const { meta: { type } } = itemFn;
-  const [hasher, key2Hasher] = getHashers(itemFn);
 
   // Can only have zero or one argument:
   //   - storage.system.account(address)
   //   - storage.timestamp.blockPeriod()
-  // For doublemap queries the params is passed in as an tuple, [key1, key2]
+  // For higher-map queries the params are passed in as an tuple, [key1, key2]
-  const storageFn = expandWithMeta(itemFn, (arg?: CreateArgType | [CreateArgType?, CreateArgType?]): Uint8Array =>
+  const storageFn = expandWithMeta(itemFn, (arg?: CreateArgType | CreateArgType[]) =>
-    type.isDoubleMap
+    type.isPlain
-      ? createKeyDoubleMap(registry, itemFn, arg as [CreateArgType, CreateArgType], [hasher, key2Hasher])
+      ? options.skipHashing
-      : createKey(registry, itemFn, arg as CreateArgType, options.skipHashing ? NULL_HASHER : hasher)
+        ? compactAddLength(u8aToU8a(options.key))
+        : createKey(registry, itemFn, [], [], [])
+      : type.isMap
+        ? createKey(registry, itemFn, [type.asMap.key], [getHasher(type.asMap.hasher)], [arg as CreateArgType])
+        : type.isDoubleMap
+          ? createKey(registry, itemFn, [type.asDoubleMap.key1, type.asDoubleMap.key2], [getHasher(type.asDoubleMap.hasher), getHasher(type.asDoubleMap.key2Hasher)], arg as CreateArgType[])
+          : createKey(registry, itemFn, type.asNMap.keyVec, type.asNMap.hashers.map((h) => getHasher(h)), arg as CreateArgType[])
   );
 
-  if (type.isMap || type.isDoubleMap) {
+  if (type.isMap || type.isDoubleMap || type.isNMap) {
     extendPrefixedMap(registry, itemFn, storageFn);
   }
 
-  storageFn.keyPrefix = (arg?: any): Uint8Array =>
+  storageFn.keyPrefix = (...args: unknown[]): Uint8Array =>
-    (storageFn.iterKey && storageFn.iterKey(arg)) || compactStripLength(storageFn())[1];
+    (storageFn.iterKey && storageFn.iterKey(...args)) ||
+    compactStripLength(storageFn())[1];
 
   return storageFn;
 }

packages/metadata/src/decorate/storage/getHasher.ts

@@ -31,6 +31,6 @@ const HASHERS: Record<keyof typeof AllHashers, HasherFunction> = {
 };
 
 /** @internal */
-export function getHasher (hasher?: StorageHasher): HasherFunction {
+export function getHasher (hasher: StorageHasher): HasherFunction {
-  return HASHERS[hasher?.type as 'Identity'] || DEFAULT_FN;
+  return HASHERS[hasher.type as 'Identity'] || DEFAULT_FN;
 }

packages/metadata/src/decorate/storage/getStorage.spec.ts

@@ -2,19 +2,21 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { TypeRegistry } from '@polkadot/types/create';
+import { compactAddLength, u8aToU8a } from '@polkadot/util';
 
 import { getStorage } from './getStorage';
 
 describe('getSorage', (): void => {
   const registry = new TypeRegistry();
-  const storage = getStorage(registry, 8);
+  const storage = getStorage(registry);
 
   it('should return well known keys', (): void => {
     expect(typeof storage.substrate).toBe('object');
 
+    expect(storage.substrate.code()).toEqual(compactAddLength(u8aToU8a(':code')));
+
     expect(storage.substrate.changesTrieConfig).toBeTruthy();
     expect(storage.substrate.childStorageKeyPrefix).toBeTruthy();
-    expect(storage.substrate.code).toBeTruthy();
     expect(storage.substrate.extrinsicIndex).toBeTruthy();
     expect(storage.substrate.heapPages).toBeTruthy();
   });

packages/metadata/src/decorate/storage/getStorage.ts

@@ -8,12 +8,12 @@ import type { Storage } from '../types';
 import { substrate } from './substrate';
 
 /** @internal */
-export function getStorage (registry: Registry, metaVersion: number): Storage {
+export function getStorage (registry: Registry): Storage {
   return {
     substrate: Object
       .entries(substrate)
       .reduce((storage: Record<string, StorageEntry>, [key, fn]): Record<string, StorageEntry> => {
-        (storage as Record<string, unknown>)[key] = fn(registry, metaVersion);
+        (storage as Record<string, unknown>)[key] = fn(registry);
 
         return storage;
       }, {})

packages/metadata/src/decorate/storage/index.spec.ts

@@ -21,7 +21,11 @@ describe('decorateStorage', (): void => {
     const query = decorateStorage(registry, metadata.asLatest, metadata.version);
 
     it('should throw if the storage function expects an argument', (): void => {
-      expect(() => query.balances.account()).toThrowError(/requires one argument/);
+      expect(() => query.balances.account()).toThrowError('Call to balances.account has a null or undefined argument at position 0');
+    });
+
+    it('should throw if the storage function expects multiple arguments', (): void => {
+      expect(() => query.staking.erasStakers([1])).toThrowError('Call to staking.erasStakers needs 2 arguments, found [1]');
     });
 
     it('should return a value if the storage function does not expect an argument', (): void => {

packages/metadata/src/decorate/storage/index.ts

@@ -11,7 +11,8 @@ import { createFunction } from './createFunction';
 import { getStorage } from './getStorage';
 
 /** @internal */
-export function decorateStorage (registry: Registry, { modules }: MetadataLatest, metaVersion: number): Storage {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function decorateStorage (registry: Registry, { modules }: MetadataLatest, _metaVersion: number): Storage {
   return modules.reduce((result: Storage, moduleMetadata): Storage => {
     if (moduleMetadata.storage.isNone) {
       return result;
@@ -31,11 +32,11 @@ export function decorateStorage (registry: Registry, { modules }: MetadataLatest
         method,
         prefix,
         section
-      }, { metaVersion });
+      }, {});
 
       return newModule;
     }, {} as ModuleStorage);
 
     return result;
-  }, { ...getStorage(registry, metaVersion) });
+  }, { ...getStorage(registry) });
 }

packages/metadata/src/decorate/storage/substrate.spec.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2021 @polkadot/metadata authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { TypeRegistry } from '@polkadot/types/create';
+import { compactAddLength, u8aToU8a } from '@polkadot/util';
+
+import { substrate } from './substrate';
+
+const registry = new TypeRegistry();
+
+describe('substrate', (): void => {
+  it('creates a well-known :code key', (): void => {
+    expect(
+      substrate.code(registry)()
+    ).toEqual(
+      compactAddLength(u8aToU8a(':code'))
+    );
+  });
+});

packages/metadata/src/decorate/storage/substrate.ts

@@ -12,23 +12,24 @@ interface SubstrateMetadata {
   type: string;
 }
 
-type Creator = (registry: Registry, metaVersion: number) => StorageEntry;
+type Creator = (registry: Registry) => StorageEntry;
 
 // Small helper function to factorize code on this page.
 /** @internal */
-function createRuntimeFunction (method: string, key: string, { documentation, type }: SubstrateMetadata): (registry: Registry, metaVersion: number) => StorageEntry {
+function createRuntimeFunction (method: string, key: string, { documentation, type }: SubstrateMetadata): (registry: Registry) => StorageEntry {
-  return (registry: Registry, metaVersion: number): StorageEntry =>
+  return (registry: Registry): StorageEntry =>
     createFunction(registry, {
       meta: {
         documentation: registry.createType('Vec<Text>', [documentation]),
         modifier: registry.createType('StorageEntryModifierLatest', 1), // required
+        name: registry.createType('Text', method),
         toJSON: (): any => key,
         type: registry.createType('StorageEntryTypeLatest', type, 0)
       } as StorageEntryMetadataLatest,
       method,
       prefix: 'Substrate',
       section: 'substrate'
-    }, { key, metaVersion, skipHashing: true });
+    }, { key, skipHashing: true });
 }
 
 export const substrate: Record<string, Creator> = {

packages/metadata/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/metadata', version: '4.7.1' };
+export const packageInfo = { name: '@polkadot/metadata', version: '4.11.1' };

packages/metadata/src/static.ts

@@ -1,6 +1,6 @@
 // Copyright 2017-2021 @polkadot/metadata authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import metadata from './v12/static';
+import metadata from './v13/static';
 
 export default metadata;

packages/metadata/src/util/flattenUniq.ts

@@ -4,16 +4,16 @@
 type Types = string | Types[];
 
 /** @internal */
-export function flattenUniq (list: Types[]): string[] {
+export function flattenUniq (list: Types[], start: string[] = []): string[] {
-  const flat = list.reduce((result: string[], entry): string[] => {
+  return [...new Set(
-    return result.concat(
+    list.reduce((result: string[], entry): string[] => {
-      Array.isArray(entry)
+      if (Array.isArray(entry)) {
-        ? flattenUniq(entry)
+        return flattenUniq(entry, result);
-        : entry
+      }
-    );
-  }, []);
 
-  return [...new Set(flat)]
+      result.push(entry);
-    .filter((value: string) => value)
+
-    .sort();
+      return result;
+    }, start)
+  )];
 }

packages/metadata/src/util/getUniqTypes.ts

@@ -12,10 +12,11 @@ type Arg = { type: Type } & Codec;
 
 type Item = {
   type: {
-    isDoubleMap?: boolean;
+    isDoubleMap: boolean;
     isMap: boolean;
+    isNMap: boolean;
     isPlain: boolean;
-    asDoubleMap?: {
+    asDoubleMap: {
       key1: Text;
       key2: Text;
       value: Text;
@@ -24,16 +25,15 @@ type Item = {
       key: Text;
       value: Text;
     };
+    asNMap: {
+      keyVec: Text[];
+      value: Text;
+    },
     asPlain: Text;
   };
 } & Codec;
 
-type Storage = Option<Vec<Item> | {
+type Storage = Option<{ items: Vec<Item> } & Codec>;
-  // v0
-  functions?: Vec<Item>;
-  // V7+
-  items?: Vec<Item>;
-} & Codec>;
 
 type Call = { args: Vec<Arg> } & Codec;
 
@@ -44,12 +44,6 @@ type Event = { args: Vec<Type> } & Codec;
 type Events = Option<Vec<Event>>;
 
 type Module = {
-  // V0
-  module?: {
-    call: {
-      functions: Vec<Call>;
-    };
-  };
   // V1+
   calls?: Calls;
   // V6+
@@ -60,30 +54,25 @@ type Module = {
 
 interface ExtractionMetadata {
   modules: Vec<Module>;
-
-  // V0
-  outerEvent?: {
-    events: Vec<[Text, Vec<Event>] & Codec>;
-  };
 }
 
 /** @internal */
 function unwrapCalls (mod: Module): Call[] {
   return mod.calls
     ? mod.calls.unwrapOr([])
-    // V0
+    : [];
-    : mod.module
+}
-      ? mod.module.call.functions
+
-      : [];
+/** @internal */
+function typeToString ({ type }: Arg): string {
+  return type.toString();
 }
 
 /** @internal */
 function getCallNames ({ modules }: ExtractionMetadata): string[][][] {
   return modules.map((mod): string[][] =>
     unwrapCalls(mod).map(({ args }): string[] =>
-      args.map((arg): string =>
+      args.map(typeToString)
-        arg.type.toString()
-      )
     )
   );
 }
@@ -91,90 +80,66 @@ function getCallNames ({ modules }: ExtractionMetadata): string[][][] {
 /** @internal */
 function getConstantNames ({ modules }: ExtractionMetadata): string[][] {
   return modules.map(({ constants }): string[] =>
-    constants
+    (constants || []).map(typeToString)
-      ? constants.map((constant): string =>
-        constant.type.toString()
-      )
-      : []
   );
 }
 
 /** @internal */
 function unwrapEvents (events?: Events): Event[] {
-  if (!events) {
+  return events
-    return [];
+    ? events.unwrapOr([])
-  }
+    : [];
-
-  return events.unwrapOr([]);
 }
 
 /** @internal */
-function getEventNames ({ modules, outerEvent }: ExtractionMetadata): string[][][] {
+function getEventNames ({ modules }: ExtractionMetadata): string[][][] {
-  const mapArg = ({ args }: Event): string[] =>
-    args.map((arg): string =>
-      arg.toString()
-    );
-
-  // V0
-  if (outerEvent) {
-    return outerEvent.events.map(([, events]): string[][] =>
-      events.map(mapArg)
-    );
-  }
-
-  // V1+
   return modules.map(({ events }): string[][] =>
-    unwrapEvents(events).map(mapArg)
+    unwrapEvents(events).map(({ args }: Event): string[] =>
+      args.map((a) => a.toString())
+    )
   );
 }
 
 /** @internal */
 function unwrapStorage (storage?: Storage): Item[] {
-  if (!storage) {
+  return storage
-    return [];
+    ? storage.unwrapOr({ items: [] }).items
-  }
+    : [];
-
-  const data = storage.unwrapOr([]);
-
-  return Array.isArray(data)
-    ? data
-    : (data.items || data.functions) as Item[];
 }
 
 /** @internal */
 function getStorageNames ({ modules }: ExtractionMetadata): string[][][] {
   return modules.map(({ storage }): string[][] =>
-    unwrapStorage(storage).map(({ type }): string[] => {
+    unwrapStorage(storage).map(({ type }) =>
-      if (type.isDoubleMap && type.asDoubleMap) {
+      type.isPlain
-        return [
+        ? [
-          type.asDoubleMap.key1.toString(),
-          type.asDoubleMap.key2.toString(),
-          type.asDoubleMap.value.toString()
-        ];
-      } else if (type.isMap) {
-        return [
-          type.asMap.key.toString(),
-          type.asMap.value.toString()
-        ];
-      } else {
-        return [
           type.asPlain.toString()
-        ];
+        ]
-      }
+        : type.isMap
-    })
+          ? [
+            type.asMap.value.toString(),
+            type.asMap.key.toString()
+          ]
+          : type.isDoubleMap
+            ? [
+              type.asDoubleMap.value.toString(),
+              type.asDoubleMap.key1.toString(),
+              type.asDoubleMap.key2.toString()
+            ]
+            : [
+              type.asNMap.value.toString(),
+              ...type.asNMap.keyVec.map((k) => k.toString())
+            ]
+    )
   );
 }
 
 /** @internal */
 export function getUniqTypes (registry: Registry, meta: ExtractionMetadata, throwError: boolean): string[] {
-  const types = flattenUniq([
+  return validateTypes(registry, throwError, flattenUniq([
     getCallNames(meta),
     getConstantNames(meta),
     getEventNames(meta),
     getStorageNames(meta)
-  ]);
+  ]));
-
-  validateTypes(registry, types, throwError);
-
-  return types;
 }

packages/metadata/src/util/validateTypes.ts

@@ -11,8 +11,10 @@ import { flattenUniq } from './flattenUniq';
 const l = logger('metadata');
 
 /** @internal */
-export function validateTypes (registry: Registry, types: string[], throwError: boolean): void {
+export function validateTypes (registry: Registry, throwError: boolean, types: string[]): string[] {
-  const missing = flattenUniq(extractTypes(types)).filter((type) => !registry.hasType(type));
+  const missing = flattenUniq(extractTypes(types))
+    .filter((type) => !registry.hasType(type))
+    .sort();
 
   if (missing.length !== 0) {
     const message = `Unknown types found, no types for ${missing.join(', ')}`;
@@ -23,4 +25,6 @@ export function validateTypes (registry: Registry, types: string[], throwError:
       l.warn(message);
     }
   }
+
+  return types;
 }

packages/metadata/src/v12/static-substrate.json

@@ -6917,6 +6917,12 @@
               "documentation": [
                 " No proposal or bounty at that index."
               ]
+            },
+            {
+              "name": "TooManyApprovals",
+              "documentation": [
+                " Too many approvals in the queue."
+              ]
             }
           ],
           "index": 17

packages/metadata/src/v12/toV13.ts

@@ -0,0 +1,12 @@
+// Copyright 2017-2021 @polkadot/metadata authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { MetadataV12, MetadataV13 } from '@polkadot/types/interfaces/metadata';
+import type { Registry } from '@polkadot/types/types';
+
+/**
+ * @internal
+ **/
+export function toV13 (registry: Registry, metadata: MetadataV12): MetadataV13 {
+  return registry.createType('MetadataV13', metadata);
+}

packages/metadata/src/v13/Metadata.spec.ts

@@ -0,0 +1,18 @@
+// Copyright 2017-2021 @polkadot/metadata authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { TypeRegistry } from '@polkadot/types/create';
+
+import { decodeLatestSubstrate, defaultValues, toLatest } from '../util/testUtil';
+import substrateData from './static';
+import substrateJson from './static-substrate.json';
+
+describe('MetadataV13 (substrate)', (): void => {
+  const registry = new TypeRegistry();
+
+  decodeLatestSubstrate(registry, 13, substrateData, substrateJson);
+
+  toLatest(registry, 13, substrateData);
+
+  defaultValues(registry, substrateData, true, true);
+});

packages/metadata/src/v13/toLatest.ts

@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/metadata authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { EventMetadataLatest, EventMetadataV12, FunctionMetadataLatest, FunctionMetadataV12, MetadataLatest, MetadataV12, ModuleConstantMetadataLatest, ModuleConstantMetadataV12, ModuleMetadataLatest, ModuleMetadataV12, StorageEntryMetadataLatest, StorageMetadataLatest, StorageMetadataV12 } from '@polkadot/types/interfaces/metadata';
+import type { EventMetadataLatest, EventMetadataV13, FunctionMetadataLatest, FunctionMetadataV13, MetadataLatest, MetadataV13, ModuleConstantMetadataLatest, ModuleConstantMetadataV13, ModuleMetadataLatest, ModuleMetadataV13, StorageEntryMetadataLatest, StorageMetadataLatest, StorageMetadataV13 } from '@polkadot/types/interfaces/metadata';
 import type { OverrideModuleType, Registry } from '@polkadot/types/types';
 
 import { Type } from '@polkadot/types/primitive';
@@ -16,11 +16,13 @@ const KNOWN_ORIGINS: Record<string, string> = {
   TechnicalCommittee: 'CollectiveOrigin'
 };
 
+const BOXES = [['<', '>'], ['<', ','], [',', '>'], ['(', ')'], ['(', ','], [',', ','], [',', ')']];
+
 /**
  * Find and apply the correct type override
  * @internal
  **/
-function setTypeOverride (sectionTypes: OverrideModuleType, ...types: Type[]): void {
+function setTypeOverride (sectionTypes: OverrideModuleType, types: Type[]): void {
   types.forEach((type): void => {
     const override = Object.keys(sectionTypes).find((aliased) => type.eq(aliased));
 
@@ -29,9 +31,11 @@ function setTypeOverride (sectionTypes: OverrideModuleType, ...types: Type[]): v
     } else {
       // FIXME: NOT happy with this approach, but gets over the initial hump cased by (Vec<Announcement>,BalanceOf)
       const orig = type.toString();
-      const alias = Object.entries(sectionTypes).reduce((result: string, [from, to]): string =>
+      const alias = Object
-        [['<', '>'], ['<', ','], [',', '>'], ['(', ')'], ['(', ','], [',', ','], [',', ')']].reduce((result, [one, two]): string =>
+        .entries(sectionTypes)
-          result.replace(`${one}${from}${two}`, `${one}${to}${two}`), result), orig);
+        .reduce((result: string, [from, to]) =>
+          BOXES.reduce((result, [one, two]) =>
+            result.replace(`${one}${from}${two}`, `${one}${to}${two}`), result), orig);
 
       if (orig !== alias) {
         type.setOverride(alias);
@@ -44,9 +48,9 @@ function setTypeOverride (sectionTypes: OverrideModuleType, ...types: Type[]): v
  * Apply module-specific type overrides (always be done as part of toLatest)
  * @internal
  **/
-function convertCalls (registry: Registry, calls: FunctionMetadataV12[], sectionTypes: OverrideModuleType): FunctionMetadataLatest[] {
+function convertCalls (registry: Registry, calls: FunctionMetadataV13[], sectionTypes: OverrideModuleType): FunctionMetadataLatest[] {
   return calls.map((c): FunctionMetadataLatest => {
-    c.args.forEach(({ type }) => setTypeOverride(sectionTypes, type));
+    setTypeOverride(sectionTypes, c.args.map(({ type }) => type));
 
     return registry.createType('FunctionMetadataLatest', c);
   });
@@ -56,9 +60,9 @@ function convertCalls (registry: Registry, calls: FunctionMetadataV12[], section
  * Apply module-specific type overrides (always be done as part of toLatest)
  * @internal
  */
-function convertConstants (registry: Registry, constants: ModuleConstantMetadataV12[], sectionTypes: OverrideModuleType): ModuleConstantMetadataLatest[] {
+function convertConstants (registry: Registry, constants: ModuleConstantMetadataV13[], sectionTypes: OverrideModuleType): ModuleConstantMetadataLatest[] {
   return constants.map((c): ModuleConstantMetadataLatest => {
-    setTypeOverride(sectionTypes, c.type);
+    setTypeOverride(sectionTypes, [c.type]);
 
     return registry.createType('ModuleConstantMetadataLatest', c);
   });
@@ -68,9 +72,9 @@ function convertConstants (registry: Registry, constants: ModuleConstantMetadata
  * Apply module-specific type overrides (always be done as part of toLatest)
  * @internal
  **/
-function convertEvents (registry: Registry, events: EventMetadataV12[], sectionTypes: OverrideModuleType): EventMetadataLatest[] {
+function convertEvents (registry: Registry, events: EventMetadataV13[], sectionTypes: OverrideModuleType): EventMetadataLatest[] {
   return events.map((e): EventMetadataLatest => {
-    e.args.forEach((type) => setTypeOverride(sectionTypes, type));
+    setTypeOverride(sectionTypes, e.args.map((type) => type));
 
     return registry.createType('EventMetadataLatest', e);
   });
@@ -80,16 +84,18 @@ function convertEvents (registry: Registry, events: EventMetadataV12[], sectionT
  * Apply module-specific storage type overrides (always part of toLatest)
  * @internal
  **/
-function convertStorage (registry: Registry, { items, prefix }: StorageMetadataV12, sectionTypes: OverrideModuleType): StorageMetadataLatest {
+function convertStorage (registry: Registry, { items, prefix }: StorageMetadataV13, sectionTypes: OverrideModuleType): StorageMetadataLatest {
   return registry.createType('StorageMetadataLatest', {
     items: items.map((s): StorageEntryMetadataLatest => {
-      if (s.type.isDoubleMap) {
+      setTypeOverride(sectionTypes,
-        setTypeOverride(sectionTypes, s.type.asDoubleMap.value, s.type.asDoubleMap.key1, s.type.asDoubleMap.key2);
+        s.type.isPlain
-      } else if (s.type.isMap) {
+          ? [s.type.asPlain]
-        setTypeOverride(sectionTypes, s.type.asMap.value, s.type.asMap.key);
+          : s.type.isMap
-      } else {
+            ? [s.type.asMap.value, s.type.asMap.key]
-        setTypeOverride(sectionTypes, s.type.asPlain);
+            : s.type.isDoubleMap
-      }
+              ? [s.type.asDoubleMap.value, s.type.asDoubleMap.key1, s.type.asDoubleMap.key2]
+              : [s.type.asNMap.value, ...s.type.asNMap.keyVec]
+      );
 
       return registry.createType('StorageEntryMetadataLatest', s);
     }),
@@ -98,13 +104,15 @@ function convertStorage (registry: Registry, { items, prefix }: StorageMetadataV
 }
 
 // generate & register the OriginCaller type
-function registerOriginCaller (registry: Registry, modules: ModuleMetadataV12[], metaVersion: number): void {
+function registerOriginCaller (registry: Registry, modules: ModuleMetadataV13[], metaVersion: number): void {
   registry.register({
     OriginCaller: {
       _enum: modules
         .map((mod, index): [string, number] => [
           mod.name.toString(),
-          metaVersion >= 12 ? mod.index.toNumber() : index
+          metaVersion >= 12
+            ? mod.index.toNumber()
+            : index
         ])
         .sort((a, b) => a[1] - b[1])
         .reduce((result: Record<string, string>, [name, index]): Record<string, string> => {
@@ -121,7 +129,7 @@ function registerOriginCaller (registry: Registry, modules: ModuleMetadataV12[],
 }
 
 /** @internal */
-function createModule (registry: Registry, mod: ModuleMetadataV12, { calls, constants, events, storage }: { calls: FunctionMetadataV12[] | null, constants: ModuleConstantMetadataV12[], events: EventMetadataV12[] | null, storage: StorageMetadataV12 | null }): ModuleMetadataLatest {
+function createModule (registry: Registry, mod: ModuleMetadataV13, { calls, constants, events, storage }: { calls: FunctionMetadataV13[] | null, constants: ModuleConstantMetadataV13[], events: EventMetadataV13[] | null, storage: StorageMetadataV13 | null }): ModuleMetadataLatest {
   const sectionTypes = getModuleTypes(registry, stringCamelCase(mod.name));
 
   return registry.createType('ModuleMetadataLatest', {
@@ -138,7 +146,7 @@ function createModule (registry: Registry, mod: ModuleMetadataV12, { calls, cons
  * most-recent metadata, since it allows us a chance to actually apply call and storage specific type aliasses
  * @internal
  **/
-export function toLatest (registry: Registry, { extrinsic, modules }: MetadataV12, metaVersion: number): MetadataLatest {
+export function toLatest (registry: Registry, { extrinsic, modules }: MetadataV13, metaVersion: number): MetadataLatest {
   registerOriginCaller(registry, modules, metaVersion);
 
   return registry.createType('MetadataLatest', {

packages/rpc-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/rpc-core",
-  "version": "4.7.1",
+  "version": "4.11.1",
   "type": "module",
   "description": "A JavaScript wrapper for the Polkadot JsonRPC interface",
   "main": "index.js",
@@ -19,14 +19,14 @@
   "bugs": "https://github.com/polkadot-js/api/issues",
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/rpc-core#readme",
   "dependencies": {
-    "@babel/runtime": "^7.13.17",
+    "@babel/runtime": "^7.14.0",
-    "@polkadot/metadata": "4.7.1",
+    "@polkadot/metadata": "4.11.1",
-    "@polkadot/rpc-provider": "4.7.1",
+    "@polkadot/rpc-provider": "4.11.1",
-    "@polkadot/types": "4.7.1",
+    "@polkadot/types": "4.11.1",
-    "@polkadot/util": "^6.3.1",
+    "@polkadot/util": "^6.5.1",
-    "@polkadot/x-rxjs": "^6.3.1"
+    "@polkadot/x-rxjs": "^6.5.1"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^6.3.1"
+    "@polkadot/keyring": "^6.5.1"
   }
 }

packages/rpc-core/src/index.ts

@@ -84,7 +84,7 @@ export class RpcCore {
 
   #registryDefault: Registry;
 
-  #getBlockRegistry?: (blockHash: string | Uint8Array) => Promise<{ registry: Registry }>;
+  #getBlockRegistry?: (blockHash: Uint8Array) => Promise<{ registry: Registry }>;
 
   readonly #storageCache = new Map<string, string | null>();
 
@@ -140,8 +140,10 @@ export class RpcCore {
   /**
    * @description Sets a registry swap (typically from Api)
    */
-  public setRegistrySwap (registrySwap: (blockHash: string | Uint8Array) => Promise<{ registry: Registry }>): void {
+  public setRegistrySwap (registrySwap: (blockHash: Uint8Array) => Promise<{ registry: Registry }>): void {
-    this.#getBlockRegistry = registrySwap;
+    this.#getBlockRegistry = memoize(registrySwap, {
+      getInstanceId: () => this.#instanceId
+    });
   }
 
   public addUserInterfaces<Section extends keyof RpcInterface> (userRpc: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>): void {
@@ -176,12 +178,6 @@ export class RpcCore {
 
         this.mapping.set(jsonrpc, { ...def, isSubscription, jsonrpc, method, section });
 
-        // FIXME Remove any here
-        // To do so, remove `RpcInterfaceMethod` from './types.ts', and refactor
-        // every method inside this class to take:
-        // `<S extends keyof RpcInterface, M extends keyof RpcInterface[S]>`
-        // Not doing so, because it makes this class a little bit less readable,
-        // and leaving it as-is doesn't harm much
         (exposed as Record<string, unknown>)[method] = isSubscription
           ? this._createMethodSubscribe(section, method, def as DefinitionRpcSub)
           : this._createMethodSend(section, method, def);
@@ -190,13 +186,14 @@ export class RpcCore {
       }, {} as RpcInterface[Section]);
   }
 
-  private _memomize (creator: (outputAs: OutputType) => (...values: any[]) => Observable<any>): Memoized<RpcInterfaceMethod> {
+  private _memomize (creator: <T> (outputAs: OutputType) => (...values: unknown[]) => Observable<T>, def: DefinitionRpc): Memoized<RpcInterfaceMethod> {
     const memoized = memoize(creator('scale') as RpcInterfaceMethod, {
       getInstanceId: () => this.#instanceId
     });
 
     memoized.json = creator('json');
     memoized.raw = creator('raw');
+    memoized.meta = def;
 
     return memoized;
   }
@@ -204,30 +201,29 @@ export class RpcCore {
   private _createMethodSend (section: string, method: string, def: DefinitionRpc): RpcInterfaceMethod {
     const rpcName = def.endpoint || `${section}_${method}`;
     const hashIndex = def.params.findIndex(({ isHistoric }) => isHistoric);
-    const cacheIndex = def.params.findIndex(({ isCached }) => isCached);
     let memoized: null | Memoized<RpcInterfaceMethod> = null;
 
     // execute the RPC call, doing a registry swap for historic as applicable
-    const callWithRegistry = async (outputAs: OutputType, values: any[]): Promise<Codec | Codec[]> => {
+    const callWithRegistry = async <T> (outputAs: OutputType, values: unknown[]): Promise<T> => {
       const blockHash = hashIndex === -1
         ? null
-        : values[hashIndex] as Uint8Array;
+        : values[hashIndex] as (Uint8Array | string | null | undefined);
-      const { registry } = blockHash && this.#getBlockRegistry
+      const { registry } = outputAs === 'scale' && blockHash && this.#getBlockRegistry
-        ? await this.#getBlockRegistry(blockHash)
+        ? await this.#getBlockRegistry(u8aToU8a(blockHash))
         : { registry: this.#registryDefault };
       const params = this._formatInputs(registry, null, def, values);
-      const data = await this.provider.send(rpcName, params.map((param): AnyJson => param.toJSON())) as AnyJson;
+      const data = await this.provider.send<AnyJson>(rpcName, params.map((param) => param.toJSON()));
 
       return outputAs === 'scale'
-        ? this._formatOutput(registry, blockHash, method, def, params, data)
+        ? this._formatOutput(registry, blockHash, method, def, params, data) as unknown as T
-        : registry.createType(outputAs === 'raw' ? 'Raw' : 'Json', data);
+        : registry.createType(outputAs === 'raw' ? 'Raw' : 'Json', data) as unknown as T;
     };
 
-    const creator = (outputAs: OutputType) => (...values: any[]): Observable<any> => {
+    const creator = <T> (outputAs: OutputType) => (...values: unknown[]): Observable<T> => {
-      const isDelayed = (hashIndex !== -1 && !!values[hashIndex]) || (cacheIndex !== -1 && !!values[cacheIndex]);
+      const isDelayed = outputAs === 'scale' && hashIndex !== -1 && !!values[hashIndex];
 
-      return new Observable((observer: Observer<any>): VoidCallback => {
+      return new Observable((observer: Observer<T>): VoidCallback => {
-        callWithRegistry(outputAs, values)
+        callWithRegistry<T>(outputAs, values)
           .then((value): void => {
             observer.next(value);
             observer.complete();
@@ -251,7 +247,7 @@ export class RpcCore {
       );
     };
 
-    memoized = this._memomize(creator);
+    memoized = this._memomize(creator, def);
 
     return memoized;
   }
@@ -276,8 +272,8 @@ export class RpcCore {
     const subType = `${section}_${updateType}`;
     let memoized: null | Memoized<RpcInterfaceMethod> = null;
 
-    const creator = (outputAs: OutputType) => (...values: unknown[]): Observable<any> => {
+    const creator = <T> (outputAs: OutputType) => (...values: unknown[]): Observable<T> => {
-      return new Observable((observer: Observer<any>): VoidCallback => {
+      return new Observable((observer: Observer<T>): VoidCallback => {
         // Have at least an empty promise, as used in the unsubscribe
         let subscriptionPromise: Promise<number | string | null> = Promise.resolve(null);
         const registry = this.#registryDefault;
@@ -292,7 +288,7 @@ export class RpcCore {
           const params = this._formatInputs(registry, null, def, values);
           const paramsJson = params.map((param): AnyJson => param.toJSON());
 
-          const update = (error?: Error | null, result?: any): void => {
+          const update = (error?: Error | null, result?: T): void => {
             if (error) {
               logErrorMessage(method, def, error);
 
@@ -302,8 +298,8 @@ export class RpcCore {
             try {
               observer.next(
                 outputAs === 'scale'
-                  ? this._formatOutput(registry, null, method, def, params, result)
+                  ? this._formatOutput(registry, null, method, def, params, result) as unknown as T
-                  : registry.createType(outputAs === 'raw' ? 'Raw' : 'Json', result)
+                  : registry.createType(outputAs === 'raw' ? 'Raw' : 'Json', result) as unknown as T
               );
             } catch (error) {
               observer.error(error);
@@ -332,12 +328,12 @@ export class RpcCore {
       }).pipe(drr());
     };
 
-    memoized = this._memomize(creator);
+    memoized = this._memomize(creator, def);
 
     return memoized;
   }
 
-  private _formatInputs (registry: Registry, blockHash: Uint8Array | string | null | undefined, def: DefinitionRpc, inputs: any[]): Codec[] {
+  private _formatInputs (registry: Registry, blockHash: Uint8Array | string | null | undefined, def: DefinitionRpc, inputs: unknown[]): Codec[] {
     const reqArgCount = def.params.filter(({ isOptional }) => !isOptional).length;
     const optText = reqArgCount === def.params.length
       ? ''
@@ -350,11 +346,11 @@ export class RpcCore {
     );
   }
 
-  private _formatOutput (registry: Registry, blockHash: Uint8Array | string | null | undefined, method: string, rpc: DefinitionRpc, params: Codec[], result?: any): Codec | Codec[] {
+  private _formatOutput (registry: Registry, blockHash: Uint8Array | string | null | undefined, method: string, rpc: DefinitionRpc, params: Codec[], result?: unknown): Codec | Codec[] {
     if (rpc.type === 'StorageData') {
       const key = params[0] as StorageKey;
 
-      return this._formatStorageData(registry, blockHash, key, result);
+      return this._formatStorageData(registry, blockHash, key, result as string);
     } else if (rpc.type === 'StorageChangeSet') {
       const keys = params[0] as Vec<StorageKey>;
 
@@ -438,27 +434,23 @@ export class RpcCore {
       ? ''
       : ` entry ${entryIndex}:`;
 
-    if (meta.modifier.isOptional) {
-      let inner = null;
-
-      if (!isEmpty) {
-        try {
-          inner = createTypeUnsafe(registry, type, [input], { blockHash, isPedantic: true });
-        } catch (error) {
-          l.error(`Unable to decode storage ${key.section || 'unknown'}.${key.method || 'unknown'}:${entryNum}`, (error as Error).message);
-        }
-      }
-
-      const option = new Option(registry, createClass(registry, type), inner);
-
-      if (blockHash) {
-        option.createdAtHash = registry.createType('Hash', blockHash);
-      }
-
-      return option;
-    }
-
     try {
+      if (meta.modifier.isOptional) {
+        let inner = null;
+
+        if (!isEmpty) {
+          inner = createTypeUnsafe(registry, type, [input], { blockHash, isPedantic: true });
+        }
+
+        const option = new Option(registry, createClass(registry, type), inner);
+
+        if (blockHash) {
+          option.createdAtHash = registry.createType('Hash', blockHash);
+        }
+
+        return option;
+      }
+
       return createTypeUnsafe(registry, type, [
         isEmpty
           ? meta.fallback
@@ -467,9 +459,7 @@ export class RpcCore {
           : input
       ], { blockHash, isPedantic: true });
     } catch (error) {
-      l.error(`Unable to decode storage ${key.section || 'unknown'}.${key.method || 'unknown'}:${entryNum}`, (error as Error).message);
+      throw new Error(`Unable to decode storage ${key.section || 'unknown'}.${key.method || 'unknown'}:${entryNum}: ${(error as Error).message}`);
-
-      return createTypeUnsafe(registry, 'Raw', [input], { blockHash });
     }
   }
 }

packages/rpc-core/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/rpc-core', version: '4.7.1' };
+export const packageInfo = { name: '@polkadot/rpc-core', version: '4.11.1' };

packages/rpc-core/src/types.ts

@@ -1,12 +1,15 @@
 // Copyright 2017-2021 @polkadot/rpc-core authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { Json, Raw } from '@polkadot/types';
+import type { Codec, DefinitionRpc } from '@polkadot/types/types';
 import type { Observable } from '@polkadot/x-rxjs';
 
 export * from './types.jsonrpc';
 
 export interface RpcInterfaceMethod {
-  (...params: any[]): Observable<any>;
+  <T extends Codec> (...params: unknown[]): Observable<T>;
-  json (...params: any[]): Observable<any>;
+  json (...params: unknown[]): Observable<Json>;
-  raw (...params: any[]): Observable<any>;
+  raw (...params: unknown[]): Observable<Raw>;
+  meta: DefinitionRpc;
 }

packages/rpc-core/src/util/drr.ts

@@ -22,7 +22,7 @@ const CMP = (a: unknown, b: unknown): boolean =>
   stringify({ t: a }) === stringify({ t: b });
 
 const ERR = (error: Error): Observable<never> => {
-  l.error(error);
+  l.error(error.message);
 
   throw error;
 };

packages/rpc-provider/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/rpc-provider",
-  "version": "4.7.1",
+  "version": "4.11.1",
   "type": "module",
   "description": "Transport providers for the API",
   "main": "index.js",
@@ -19,19 +19,19 @@
   "bugs": "https://github.com/polkadot-js/api/issues",
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/rpc-provider#readme",
   "dependencies": {
-    "@babel/runtime": "^7.13.17",
+    "@babel/runtime": "^7.14.0",
-    "@polkadot/types": "4.7.1",
+    "@polkadot/types": "4.11.1",
-    "@polkadot/util": "^6.3.1",
+    "@polkadot/util": "^6.5.1",
-    "@polkadot/util-crypto": "^6.3.1",
+    "@polkadot/util-crypto": "^6.5.1",
-    "@polkadot/x-fetch": "^6.3.1",
+    "@polkadot/x-fetch": "^6.5.1",
-    "@polkadot/x-global": "^6.3.1",
+    "@polkadot/x-global": "^6.5.1",
-    "@polkadot/x-ws": "^6.3.1",
+    "@polkadot/x-ws": "^6.5.1",
     "bn.js": "^4.11.9",
     "eventemitter3": "^4.0.7"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^6.3.1",
+    "@polkadot/keyring": "^6.5.1",
-    "@polkadot/metadata": "4.7.1",
+    "@polkadot/metadata": "4.11.1",
     "mock-socket": "^9.0.3",
     "nock": "^13.0.11"
   }

packages/rpc-provider/src/http/index.ts

@@ -103,7 +103,7 @@ export class HttpProvider implements ProviderInterface {
   /**
    * @summary Send HTTP POST Request with Body to configured HTTP Endpoint.
    */
-  public async send (method: string, params: any[]): Promise<any> {
+  public async send <T = any> (method: string, params: unknown[]): Promise<T> {
     const body = this.#coder.encodeJson(method, params);
     const response = await fetch(this.#endpoint, {
       body,
@@ -121,14 +121,14 @@ export class HttpProvider implements ProviderInterface {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const result = await response.json();
 
-    return this.#coder.decodeResponse(result);
+    return this.#coder.decodeResponse(result) as T;
   }
 
   /**
    * @summary Subscriptions are not supported with the HttpProvider, see [[WsProvider]].
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/require-await
-  public async subscribe (types: string, method: string, params: any[], cb: ProviderInterfaceCallback): Promise<number> {
+  public async subscribe (types: string, method: string, params: unknown[], cb: ProviderInterfaceCallback): Promise<number> {
     l.error(ERROR_SUBSCRIBE);
 
     throw new Error(ERROR_SUBSCRIBE);

packages/rpc-provider/src/mock/index.ts

@@ -53,23 +53,24 @@ export class MockProvider implements ProviderInterface {
 
   private requests: Record<string, (...params: any[]) => unknown> = {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-unsafe-member-access
-    chain_getBlock: (hash: string): any => this.registry.createType('SignedBlock', rpcSignedBlock.result).toJSON(),
+    chain_getBlock: () => this.registry.createType('SignedBlock', rpcSignedBlock.result).toJSON(),
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    chain_getBlockHash: (blockNumber: number): string => '0x1234',
+    chain_getBlockHash: () => '0x1234',
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     chain_getFinalizedHead: () => this.registry.createType('Header', rpcHeader.result).hash,
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     chain_getHeader: () => this.registry.createType('Header', rpcHeader.result).toJSON(),
     rpc_methods: () => this.registry.createType('RpcMethods').toJSON(),
-    state_getKeys: (): string[] => [],
+    state_getKeys: () => [],
-    state_getKeysPaged: (): string[] => [],
+    state_getKeysPaged: () => [],
-    state_getMetadata: (): string => rpcMetadata,
+    state_getMetadata: () => rpcMetadata,
-    state_getRuntimeVersion: (): string => this.registry.createType('RuntimeVersion').toHex(),
+    state_getRuntimeVersion: () => this.registry.createType('RuntimeVersion').toHex(),
-    state_getStorage: (storage: MockStateDb, params: any[]): string => u8aToHex(storage[(params[0] as string)]),
+    state_getStorage: (storage: MockStateDb, [key]: string[]) => u8aToHex(storage[key]),
-    system_chain: (): string => 'mockChain',
+    system_chain: () => 'mockChain',
-    system_name: (): string => 'mockClient',
+    system_name: () => 'mockClient',
-    system_properties: (): Record<string, number | string> => ({ ss58Format: 42 }),
+    system_properties: () => ({ ss58Format: 42 }),
-    system_version: (): string => '9.8.7'
+    system_upgradedToTripleRefCount: () => this.registry.createType('bool', true),
+    system_version: () => '9.8.7'
   };
 
   public subscriptions: MockStateSubscriptions = SUBSCRIPTIONS.reduce((subs, name): MockStateSubscriptions => {
@@ -120,15 +121,17 @@ export class MockProvider implements ProviderInterface {
   }
 
   // eslint-disable-next-line @typescript-eslint/require-await
-  public async send (method: string, params: any[]): Promise<unknown> {
+  public async send <T = any> (method: string, params: unknown[]): Promise<T> {
+    l.debug(() => ['send', method, params]);
+
     assert(this.requests[method], () => `provider.send: Invalid method '${method}'`);
 
-    return this.requests[method](this.db, params);
+    return this.requests[method](this.db, params) as T;
   }
 
   // eslint-disable-next-line @typescript-eslint/require-await
   public async subscribe (type: string, method: string, ...params: unknown[]): Promise<number> {
-    l.debug((): any => ['subscribe', method, params]);
+    l.debug(() => ['subscribe', method, params]);
 
     assert(this.subscriptions[method], () => `provider.subscribe: Invalid method '${method}'`);
 
@@ -149,7 +152,7 @@ export class MockProvider implements ProviderInterface {
   public async unsubscribe (type: string, method: string, id: number): Promise<boolean> {
     const sub = this.subscriptionMap[id];
 
-    l.debug((): any => ['unsubscribe', id, sub]);
+    l.debug(() => ['unsubscribe', id, sub]);
 
     assert(sub, () => `Unable to find subscription for ${id}`);
 

packages/rpc-provider/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/rpc-provider', version: '4.7.1' };
+export const packageInfo = { name: '@polkadot/rpc-provider', version: '4.11.1' };

packages/rpc-provider/src/types.ts

@@ -49,7 +49,7 @@ export interface ProviderInterface {
   connect (): Promise<void>;
   disconnect (): Promise<void>;
   on (type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void;
-  send (method: string, params: any[]): Promise<any>;
+  send <T = any> (method: string, params: unknown[]): Promise<T>;
-  subscribe (type: string, method: string, params: any[], cb: ProviderInterfaceCallback): Promise<number | string>;
+  subscribe (type: string, method: string, params: unknown[], cb: ProviderInterfaceCallback): Promise<number | string>;
   unsubscribe (type: string, method: string, id: number | string): Promise<boolean>;
 }

packages/rpc-provider/src/ws/index.ts

@@ -23,16 +23,16 @@ interface SubscriptionHandler {
 interface WsStateAwaiting {
   callback: ProviderInterfaceCallback;
   method: string;
-  params: any[];
+  params: unknown[];
   subscription?: SubscriptionHandler;
 }
 
 interface WsStateSubscription extends SubscriptionHandler {
   method: string;
-  params: any[];
+  params: unknown[];
 }
 
-const ALIASSES: { [index: string]: string } = {
+const ALIASES: { [index: string]: string } = {
   chain_finalisedHead: 'chain_finalizedHead',
   chain_subscribeFinalisedHeads: 'chain_subscribeFinalizedHeads',
   chain_unsubscribeFinalisedHeads: 'chain_unsubscribeFinalizedHeads'
@@ -178,8 +178,10 @@ export class WsProvider implements ProviderInterface {
         : new WebSocket(this.#endpoints[this.#endpointIndex], undefined, undefined, this.#headers, undefined, {
           // default: true
           fragmentOutgoingMessages: true,
-          // default: 16K
+          // default: 16K (bump, the Node has issues with too many fragments, e.g. on setCode)
-          fragmentationThreshold: 256 * 1024
+          fragmentationThreshold: 256 * 1024,
+          // default: 8MB (however Polkadot api.query.staking.erasStakers.entries(356) is over that)
+          maxReceivedMessageSize: 16 * 1024 * 1024
         });
 
       this.#websocket.onclose = this.#onSocketClose;
@@ -225,7 +227,6 @@ export class WsProvider implements ProviderInterface {
 
       // 1000 - Normal closure; the connection successfully completed
       this.#websocket.close(1000);
-      this.#websocket = null;
     } catch (error) {
       l.error(error);
 
@@ -255,7 +256,7 @@ export class WsProvider implements ProviderInterface {
    * @param params Encoded parameters as applicable for the method
    * @param subscription Subscription details (internally used)
    */
-  public send <T = any> (method: string, params: any[], subscription?: SubscriptionHandler): Promise<T> {
+  public send <T = any> (method: string, params: unknown[], subscription?: SubscriptionHandler): Promise<T> {
     return new Promise<T>((resolve, reject): void => {
       try {
         assert(this.isConnected && !isNull(this.#websocket), 'WebSocket is not connected');
@@ -263,10 +264,10 @@ export class WsProvider implements ProviderInterface {
         const json = this.#coder.encodeJson(method, params);
         const id = this.#coder.getId();
 
-        const callback = (error?: Error | null, result?: any): void => {
+        const callback = (error?: Error | null, result?: T): void => {
           error
             ? reject(error)
-            : resolve(result);
+            : resolve(result as T);
         };
 
         l.debug(() => ['calling', method, json]);
@@ -288,11 +289,6 @@ export class WsProvider implements ProviderInterface {
   /**
    * @name subscribe
    * @summary Allows subscribing to a specific event.
-   * @param  {string}                     type     Subscription type
-   * @param  {string}                     method   Subscription method
-   * @param  {any[]}                 params   Parameters
-   * @param  {ProviderInterfaceCallback} callback Callback
-   * @return {Promise<number>}                     Promise resolving to the dd of the subscription you can use with [[unsubscribe]].
    *
    * @example
    * <BR>
@@ -308,7 +304,7 @@ export class WsProvider implements ProviderInterface {
    * })
    * ```
    */
-  public subscribe (type: string, method: string, params: any[], callback: ProviderInterfaceCallback): Promise<number | string> {
+  public subscribe (type: string, method: string, params: unknown[], callback: ProviderInterfaceCallback): Promise<number | string> {
     return this.send<number | string>(method, params, { callback, type });
   }
 
@@ -339,7 +335,7 @@ export class WsProvider implements ProviderInterface {
     }
   }
 
-  #emit = (type: ProviderInterfaceEmitted, ...args: any[]): void => {
+  #emit = (type: ProviderInterfaceEmitted, ...args: unknown[]): void => {
     this.#eventemitter.emit(type, ...args);
   }
 
@@ -351,9 +347,19 @@ export class WsProvider implements ProviderInterface {
     }
 
     this.#isConnected = false;
+
+    if (this.#websocket) {
+      this.#websocket.onclose = null;
+      this.#websocket.onerror = null;
+      this.#websocket.onmessage = null;
+      this.#websocket.onopen = null;
+      this.#websocket = null;
+    }
+
     this.#emit('disconnected');
+
     // reject all hanging requests
-    eraseRecord(this.#handlers, (handler) => handler.callback(error, undefined));
+    eraseRecord(this.#handlers, (h) => h.callback(error, undefined));
     eraseRecord(this.#waitingForId);
 
     if (this.#autoConnectMs > 0) {
@@ -419,7 +425,7 @@ export class WsProvider implements ProviderInterface {
   }
 
   #onSocketMessageSubscribe = (response: JsonRpcResponse): void => {
-    const method = ALIASSES[response.method as string] || response.method || 'invalid';
+    const method = ALIASES[response.method as string] || response.method || 'invalid';
     const subId = `${method}::${response.params.subscription}`;
     const handler = this.#subscriptions[subId];
 

packages/typegen/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/typegen",
-  "version": "4.7.1",
+  "version": "4.11.1",
   "type": "module",
   "description": "Type generation scripts",
   "main": "index.js",
@@ -26,20 +26,20 @@
   "bugs": "https://github.com/polkadot-js/api/issues",
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/typegen#readme",
   "dependencies": {
-    "@babel/core": "^7.13.16",
+    "@babel/core": "^7.14.3",
     "@babel/register": "^7.13.16",
-    "@babel/runtime": "^7.13.17",
+    "@babel/runtime": "^7.14.0",
-    "@polkadot/api": "4.7.1",
+    "@polkadot/api": "4.11.1",
-    "@polkadot/metadata": "4.7.1",
+    "@polkadot/metadata": "4.11.1",
-    "@polkadot/rpc-provider": "4.7.1",
+    "@polkadot/rpc-provider": "4.11.1",
-    "@polkadot/types": "4.7.1",
+    "@polkadot/types": "4.11.1",
-    "@polkadot/util": "^6.3.1",
+    "@polkadot/util": "^6.5.1",
     "handlebars": "^4.7.7",
     "websocket": "^1.0.34",
-    "yargs": "^16.2.0"
+    "yargs": "^17.0.1"
   },
   "devDependencies": {
     "@types/websocket": "^1.0.2",
-    "@types/yargs": "^16.0.1"
+    "@types/yargs": "^17.0.0"
   }
 }

packages/typegen/src/extractChain.ts

@@ -25,6 +25,8 @@ async function run (ws: string): Promise<void> {
   api.runtimeMetadata.getUniqTypes(false);
 }
 
+type ArgV = { ws: string };
+
 export function main (): void {
   // retrieve and parse arguments - we do this globally, since this is a single command
   const { ws } = yargs
@@ -38,7 +40,7 @@ export function main (): void {
         required: true,
         type: 'string'
       }
-    }).argv;
+    }).argv as ArgV;
 
   run(ws)
     .then((): void => {

packages/typegen/src/fromChain.ts

@@ -38,6 +38,8 @@ function generate (metaHex: string, pkg: string | undefined, output: string, isS
   process.exit(0);
 }
 
+type ArgV = { endpoint: string; output: string; package?: string; strict?: boolean };
+
 export function main (): void {
   const { endpoint, output, package: pkg, strict: isStrict } = yargs.strict().options({
     endpoint: {
@@ -58,7 +60,7 @@ export function main (): void {
       description: 'Turns on strict mode, no output of catch-all generic versions',
       type: 'boolean'
     }
-  }).argv;
+  }).argv as ArgV;
 
   if (endpoint.startsWith('wss://') || endpoint.startsWith('ws://')) {
     try {

packages/typegen/src/fromDefs.ts

@@ -9,6 +9,8 @@ import * as substrateDefs from '@polkadot/types/interfaces/definitions';
 import { generateInterfaceTypes } from './generate/interfaceRegistry';
 import { generateTsDef } from './generate/tsDef';
 
+type ArgV = { input: string; package: string };
+
 export function main (): void {
   const { input, package: pkg } = yargs.strict().options({
     input: {
@@ -21,7 +23,7 @@ export function main (): void {
       required: true,
       type: 'string'
     }
-  }).argv;
+  }).argv as ArgV;
 
   // eslint-disable-next-line @typescript-eslint/no-var-requires
   const userDefs = require(path.join(process.cwd(), input, 'definitions.ts')) as Record<string, any>;

packages/typegen/src/generate/query.ts

@@ -25,36 +25,58 @@ function entrySignature (allDefs: Record<string, ModuleTypes>, registry: Registr
 
     return ['', '', formatType(allDefs, outputType, imports)];
   } else if (storageEntry.type.isMap) {
+    const map = storageEntry.type.asMap;
+
     // Find similar types of the `key` type
-    const similarTypes = getSimilarTypes(registry, allDefs, storageEntry.type.asMap.key.toString(), imports);
+    const similarTypes = getSimilarTypes(registry, allDefs, map.key.toString(), imports);
 
     setImports(allDefs, imports, [
       ...similarTypes,
-      storageEntry.type.asMap.value.toString()
+      map.value.toString()
     ]);
 
     return [
-      formatType(allDefs, storageEntry.type.asMap.key.toString(), imports),
+      formatType(allDefs, map.key.toString(), imports),
       `arg: ${similarTypes.join(' | ')}`,
       formatType(allDefs, outputType, imports)
     ];
   } else if (storageEntry.type.isDoubleMap) {
+    const dm = storageEntry.type.asDoubleMap;
+
     // Find similar types of `key1` and `key2` types
-    const similarTypes1 = getSimilarTypes(registry, allDefs, storageEntry.type.asDoubleMap.key1.toString(), imports);
+    const similarTypes1 = getSimilarTypes(registry, allDefs, dm.key1.toString(), imports);
-    const similarTypes2 = getSimilarTypes(registry, allDefs, storageEntry.type.asDoubleMap.key2.toString(), imports);
+    const similarTypes2 = getSimilarTypes(registry, allDefs, dm.key2.toString(), imports);
 
     setImports(allDefs, imports, [
       ...similarTypes1,
       ...similarTypes2,
-      storageEntry.type.asDoubleMap.value.toString()
+      dm.value.toString()
     ]);
 
     const key1Types = similarTypes1.join(' | ');
     const key2Types = similarTypes2.join(' | ');
 
     return [
-      [formatType(allDefs, storageEntry.type.asDoubleMap.key1.toString(), imports), formatType(allDefs, storageEntry.type.asDoubleMap.key2.toString(), imports)].join(', '),
+      [formatType(allDefs, dm.key1.toString(), imports), formatType(allDefs, dm.key2.toString(), imports)].join(', '),
-      `key1: ${key1Types}, key2: ${key2Types}`,
+      `arg1: ${key1Types}, arg2: ${key2Types}`,
+      formatType(allDefs, outputType, imports)
+    ];
+  } else if (storageEntry.type.isNMap) {
+    const nmap = storageEntry.type.asNMap;
+
+    // Find similar types for all keys
+    const similarTypes = nmap.keyVec.map((k) => getSimilarTypes(registry, allDefs, k.toString(), imports));
+
+    setImports(allDefs, imports, [
+      ...similarTypes.reduce<string[]>((all, t) => all.concat(t), []),
+      nmap.value.toString()
+    ]);
+
+    const keyTypes = similarTypes.map((t) => t.join(' | '));
+
+    return [
+      nmap.keyVec.map((k) => formatType(allDefs, k.toString(), imports)).join(', '),
+      keyTypes.map((t, i) => `arg${i + 1}: ${t}`).join(', '),
       formatType(allDefs, outputType, imports)
     ];
   }
@@ -82,16 +104,11 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr
           .sort(compareName)
           .map((storageEntry) => {
             const [args, params, returnType] = entrySignature(allDefs, registry, storageEntry, imports);
-            let entryType = 'AugmentedQuery';
-
-            if (storageEntry.type.isDoubleMap) {
-              entryType = `${entryType}DoubleMap`;
-            }
 
             return {
               args,
               docs: storageEntry.documentation,
-              entryType,
+              entryType: 'AugmentedQuery',
               name: stringCamelCase(storageEntry.name),
               params,
               returnType

packages/typegen/src/metadataMd.ts

@@ -195,7 +195,7 @@ function addConstants (metadata: MetadataLatest): string {
 
 /** @internal */
 function addStorage (metadata: MetadataLatest): string {
-  const { substrate } = getSubstrateStorage(metadata.registry, 12);
+  const { substrate } = getSubstrateStorage(metadata.registry);
   const moduleSections = metadata.modules
     .sort(sortByName)
     .filter((moduleMetadata) => !moduleMetadata.storage.isNone)
@@ -210,7 +210,9 @@ function addStorage (metadata: MetadataLatest): string {
               ? ('`' + func.type.asMap.key.toString() + '`')
               : func.type.isDoubleMap
                 ? ('`' + func.type.asDoubleMap.key1.toString() + ', ' + func.type.asDoubleMap.key2.toString() + '`')
-                : '';
+                : func.type.isNMap
+                  ? ('`' + func.type.asNMap.keyVec.map((k) => k.toString()).join(', ') + '`')
+                  : '';
             const methodName = stringLowerFirst(func.name);
             const outputType = unwrapStorageType(func.type, func.modifier.isOptional);
 

packages/typegen/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/typegen', version: '4.7.1' };
+export const packageInfo = { name: '@polkadot/typegen', version: '4.11.1' };

packages/typegen/src/templates/consts.hbs

@@ -6,13 +6,16 @@ declare module '@polkadot/api/types/consts' {
   export interface AugmentedConsts<ApiType> {
     {{#each modules}}
     {{{name}}}: {
-      {{#unless @root.isStrict}}
+      {{#each items}}
-      [key: string]: Codec;
-      {{/unless}}
-      {{~#each items}}
       {{> docs}}
       {{{name}}}: {{{type}}} & AugmentedConst<ApiType>;
       {{/each}}
+      {{#unless @root.isStrict}}
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
+      {{/unless}}
     };
     {{/each}}
   }