[CI Skip] release/stable 1.21.1

skip-checks: true

CHANGELOG.md

@@ -1,11 +1,31 @@
 # CHANGELOG
 
+## 1.21.1 Jun 23, 2020
+
+- Fix subscriptions never unsubscribing after the id swap in 1.18.1 (Thanks to https://github.com/dillu24 for testing iterations)
+- Add support for `CheckMortality` signed extension (old `CheckEra` is now an alias)
+- Promise API will default to using `getStorage` on non-subscription calls, reducing RPC overhead
+- Optimize derive BN allocations, using in-place operators as applicable
+- Add new substrate types for Babe EquivocationProof
+- Adjust `Releases` enum to use a shared instance
+
+## 1.20.1 Jun 22, 2020
+
+- **Important** RPC for `account_nextIndex` has been moved to `system_accountNextIndex` (Aligning with Substrate as a primary alias)
+- Cleanup map entries support with only Substrate 2.0-era RPCs (when introduced)
+- Add `system_dryRun` RPC
+- Optimize `derive.staking.queryMulti` retrievals with additional per-type batching
+- Add `derive.staking.waitingInfo` (same as `electedInfo` for waiting validators)
+- Adjust types & metadata for latest Substrate
+- `@polkadot/util` 2.15
+
 ## 1.19.1 Jun 16, 2020
 
 - Improve typing on `.entries()` queries (Thanks to https://github.com/monitz87)
 - Align metadata and types with latest Substrate
 - Update Polkadot types for current evolution of parachains
 - Allow for type aliasing on events (aligning with calls & queries)
+- `@polkadot/util` 2.14
 
 ## 1.18.1 Jun 8, 2020
 

lerna.json

@@ -9,5 +9,5 @@
   "packages": [
     "packages/*"
   ],
-  "version": "1.19.1"
+  "version": "1.21.1"
 }

package.json

@@ -24,15 +24,15 @@
     "test:watch": "polkadot-dev-run-test --watch"
   },
   "devDependencies": {
-    "@babel/core": "^7.10.2",
-    "@babel/register": "^7.10.1",
-    "@babel/runtime": "^7.10.2",
-    "@polkadot/dev": "^0.55.10",
+    "@babel/core": "^7.10.3",
+    "@babel/register": "^7.10.3",
+    "@babel/runtime": "^7.10.3",
+    "@polkadot/dev": "^0.55.12",
     "@polkadot/ts": "^0.3.26",
     "@polkadot/typegen": "workspace:packages/typegen",
     "@types/jest": "^26.0.0",
     "@vuepress/plugin-search": "^1.5.2",
     "copyfiles": "^2.3.0"
   },
-  "version": "1.19.1"
+  "version": "1.21.1"
 }

packages/api-contract/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/api-contract",
-  "version": "1.19.1",
+  "version": "1.21.1",
   "description": "Interfaces for interacting with contracts and contract ABIs",
   "main": "index.js",
   "keywords": [
@@ -26,11 +26,11 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api-contract#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.2",
-    "@polkadot/api": "1.19.1",
-    "@polkadot/rpc-core": "1.19.1",
-    "@polkadot/types": "1.19.1",
-    "@polkadot/util": "^2.14.1",
+    "@babel/runtime": "^7.10.3",
+    "@polkadot/api": "1.21.1",
+    "@polkadot/rpc-core": "1.21.1",
+    "@polkadot/types": "1.21.1",
+    "@polkadot/util": "^2.15.1",
     "bn.js": "^5.1.2",
     "rxjs": "^6.5.5"
   }

packages/api-derive/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/api-derive",
-  "version": "1.19.1",
+  "version": "1.21.1",
   "description": "Common functions used across Polkadot, derived from RPC calls and storage queries.",
   "main": "index.js",
   "keywords": [
@@ -27,18 +27,18 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api-derive#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.2",
-    "@polkadot/api": "1.19.1",
-    "@polkadot/rpc-core": "1.19.1",
-    "@polkadot/rpc-provider": "1.19.1",
-    "@polkadot/types": "1.19.1",
-    "@polkadot/util": "^2.14.1",
-    "@polkadot/util-crypto": "^2.14.1",
+    "@babel/runtime": "^7.10.3",
+    "@polkadot/api": "1.21.1",
+    "@polkadot/rpc-core": "1.21.1",
+    "@polkadot/rpc-provider": "1.21.1",
+    "@polkadot/types": "1.21.1",
+    "@polkadot/util": "^2.15.1",
+    "@polkadot/util-crypto": "^2.15.1",
     "bn.js": "^5.1.2",
     "memoizee": "^0.4.14",
     "rxjs": "^6.5.5"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^2.14.1"
+    "@polkadot/keyring": "^2.15.1"
   }
 }

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

@@ -82,15 +82,15 @@ function calcVotesPrev (votesFor: DeriveReferendumVote[]): DeriveReferendumVoteS
     if (vote.isAye) {
       state.allAye.push(derived);
       state.voteCountAye++;
-      state.votedAye = state.votedAye.add(counted);
+      state.votedAye.iadd(counted);
     } else {
       state.allNay.push(derived);
       state.voteCountNay++;
-      state.votedNay = state.votedNay.add(counted);
+      state.votedNay.iadd(counted);
     }
 
     state.voteCount++;
-    state.votedTotal = state.votedTotal.add(counted);
+    state.votedTotal.iadd(counted);
 
     return state;
   }, {

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

@@ -17,9 +17,9 @@ type ResultSlots = [u64, u64, u64, Option<SessionIndex>];
 type ResultSlotsFlat = [u64, u64, u64, SessionIndex];
 
 function createDerive (api: ApiInterfaceRx, info: DeriveSessionInfo, [currentSlot, epochIndex, epochOrGenesisStartSlot, activeEraStartSessionIndex]: ResultSlotsFlat): DeriveSessionProgress {
-  const epochStartSlot = epochIndex.mul(info.sessionLength).add(epochOrGenesisStartSlot);
+  const epochStartSlot = epochIndex.mul(info.sessionLength).iadd(epochOrGenesisStartSlot);
   const sessionProgress = currentSlot.sub(epochStartSlot);
-  const eraProgress = info.currentIndex.sub(activeEraStartSessionIndex).mul(info.sessionLength).add(sessionProgress);
+  const eraProgress = info.currentIndex.sub(activeEraStartSessionIndex).imul(info.sessionLength).iadd(sessionProgress);
 
   return {
     ...info,

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

@@ -7,7 +7,7 @@ import { Balance, StakingLedger, UnlockChunk } from '@polkadot/types/interfaces'
 import { DeriveSessionInfo, DeriveStakingAccount, DeriveStakingQuery, DeriveUnlocking } from '../types';
 
 import BN from 'bn.js';
-import { Observable, combineLatest } from 'rxjs';
+import { Observable } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
 
 import { isUndefined } from '@polkadot/util';
@@ -21,7 +21,7 @@ function groupByEra (list: UnlockChunk[]): Record<string, BN> {
 
     map[key] = !map[key]
       ? value.unwrap()
-      : map[key].add(value.unwrap());
+      : map[key].iadd(value.unwrap());
 
     return map;
   }, {});
@@ -32,8 +32,8 @@ function calculateUnlocking (api: ApiInterfaceRx, stakingLedger: StakingLedger |
     return undefined;
   }
 
-  const unlockingChunks = stakingLedger.unlocking.filter(({ era }): boolean =>
-    era.unwrap().sub(sessionInfo.activeEra).gtn(0)
+  const unlockingChunks = stakingLedger.unlocking.filter(({ era }) =>
+    era.unwrap().gt(sessionInfo.activeEra)
   );
 
   if (!unlockingChunks.length) {
@@ -43,11 +43,13 @@ function calculateUnlocking (api: ApiInterfaceRx, stakingLedger: StakingLedger |
   // group the unlock chunks that have the same era and sum their values
   const groupedResult = groupByEra(unlockingChunks);
   const results = Object.entries(groupedResult).map(([eraString, value]): DeriveUnlocking => ({
-    remainingEras: new BN(eraString).sub(sessionInfo.activeEra),
+    remainingEras: new BN(eraString).isub(sessionInfo.activeEra),
     value: api.registry.createType('Balance', value)
   }));
 
-  return results.length ? results : undefined;
+  return results.length
+    ? results
+    : undefined;
 }
 
 function redeemableSum (api: ApiInterfaceRx, stakingLedger: StakingLedger | undefined, sessionInfo: DeriveSessionInfo): Balance {
@@ -57,7 +59,7 @@ function redeemableSum (api: ApiInterfaceRx, stakingLedger: StakingLedger | unde
 
   return api.registry.createType('Balance', stakingLedger.unlocking.reduce((total, { era, value }): BN => {
     return sessionInfo.activeEra.gte(era.unwrap())
-      ? total.add(value.unwrap())
+      ? total.iadd(value.unwrap())
       : total;
   }, new BN(0)));
 }
@@ -70,23 +72,6 @@ function parseResult (api: ApiInterfaceRx, sessionInfo: DeriveSessionInfo, query
   };
 }
 
-export function _account (api: ApiInterfaceRx): (sessionInfo: DeriveSessionInfo, accountId: Uint8Array | string) => Observable<DeriveStakingAccount> {
-  return memo((sessionInfo: DeriveSessionInfo, accountId: Uint8Array | string): Observable<DeriveStakingAccount> =>
-    api.derive.staking.query(accountId).pipe(
-      map((query) => parseResult(api, sessionInfo, query))
-    ));
-}
-
-/**
- * @description From a stash, retrieve the controllerId and fill in all the relevant staking details
- */
-export function account (api: ApiInterfaceRx): (accountId: Uint8Array | string) => Observable<DeriveStakingAccount> {
-  return memo((accountId: Uint8Array | string): Observable<DeriveStakingAccount> =>
-    api.derive.session.info().pipe(
-      switchMap((sessionInfo) => api.derive.staking._account(sessionInfo, accountId))
-    ));
-}
-
 /**
  * @description From a list of stashes, fill in all the relevant staking details
  */
@@ -94,7 +79,21 @@ export function accounts (api: ApiInterfaceRx): (accountIds: (Uint8Array | strin
   return memo((accountIds: (Uint8Array | string)[]): Observable<DeriveStakingAccount[]> =>
     api.derive.session.info().pipe(
       switchMap((sessionInfo) =>
-        combineLatest(accountIds.map((accountId) => api.derive.staking._account(sessionInfo, accountId)))
+        api.derive.staking.queryMulti(accountIds).pipe(
+          map((queries) => queries.map((query) => parseResult(api, sessionInfo, query)))
+        )
       )
-    ));
+    )
+  );
+}
+
+/**
+ * @description From a stash, retrieve the controllerId and fill in all the relevant staking details
+ */
+export function account (api: ApiInterfaceRx): (accountId: Uint8Array | string) => Observable<DeriveStakingAccount> {
+  return memo((accountId: Uint8Array | string): Observable<DeriveStakingAccount> =>
+    api.derive.staking.accounts([accountId]).pipe(
+      map(([first]) => first)
+    )
+  );
 }

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

@@ -3,10 +3,9 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { AccountId } from '@polkadot/types/interfaces';
-import { DeriveStakingQuery, DeriveStakingElected } from '../types';
+import { DeriveStakingElected } from '../types';
 
-import { Observable, combineLatest, of } from 'rxjs';
+import { Observable } from 'rxjs';
 import { map, switchMap } from 'rxjs/operators';
 
 import { memo } from '../util';
@@ -14,18 +13,14 @@ import { memo } from '../util';
 export function electedInfo (api: ApiInterfaceRx): () => Observable<DeriveStakingElected> {
   return memo((): Observable<DeriveStakingElected> =>
     api.derive.staking.validators().pipe(
-      switchMap(({ nextElected }): Observable<[AccountId[], DeriveStakingQuery[]]> =>
-        combineLatest([
-          of(nextElected),
-          combineLatest(
-            nextElected.map((accountId) => api.derive.staking.query(accountId))
-          )
-        ])
-      ),
-      map(([nextElected, info]): DeriveStakingElected => ({
-        info,
-        nextElected
-      }))
+      switchMap(({ nextElected }): Observable<DeriveStakingElected> =>
+        api.derive.staking.queryMulti(nextElected).pipe(
+          map((info): DeriveStakingElected => ({
+            info,
+            nextElected
+          }))
+        )
+      )
     )
   );
 }

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

@@ -21,3 +21,4 @@ export * from './stakerRewards';
 export * from './stakerSlashes';
 export * from './stashes';
 export * from './validators';
+export * from './waitingInfo';

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

@@ -3,7 +3,7 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { ApiInterfaceRx } from '@polkadot/api/types';
-import { AccountId, Exposure, Keys, Nominations, RewardDestination, ValidatorPrefs } from '@polkadot/types/interfaces';
+import { AccountId, EraIndex, Exposure, Keys, Nominations, RewardDestination, StakingLedger, ValidatorPrefs } from '@polkadot/types/interfaces';
 import { ITuple } from '@polkadot/types/types';
 import { DeriveStakingQuery } from '../types';
 
@@ -16,7 +16,7 @@ import { memo } from '../util';
 
 type MultiResult = [Option<AccountId>, Option<ITuple<[Nominations]> | Nominations>, RewardDestination, ITuple<[ValidatorPrefs]> | ValidatorPrefs, Option<Keys>, Exposure];
 
-function unwrapSessionIds (stashId: AccountId, queuedKeys: [AccountId, Keys][], nextKeys: Option<Keys>): { nextSessionIds: AccountId[]; sessionIds: AccountId[] } {
+function parseSessionIds (stashId: AccountId, queuedKeys: [AccountId, Keys][], nextKeys: Option<Keys>): { nextSessionIds: AccountId[]; sessionIds: AccountId[] } {
   const sessionIds = (queuedKeys.find(([currentId]): boolean =>
     currentId.eq(stashId)
   ) || [undefined, [] as AccountId[]])[1];
@@ -28,6 +28,31 @@ function unwrapSessionIds (stashId: AccountId, queuedKeys: [AccountId, Keys][],
   };
 }
 
+function parseController (stashId: AccountId, queuedKeys: Vec<ITuple<[AccountId, Keys]>>, [controllerIdOpt, nominatorsOpt, rewardDestination, validatorPrefs, nextKeys, exposure]: MultiResult, stakingLedgerOpt: Option<StakingLedger>): DeriveStakingQuery {
+  const controllerId = controllerIdOpt.unwrapOr(null);
+  const nominators = nominatorsOpt.unwrapOr(null);
+
+  return controllerId && stakingLedgerOpt.isSome
+    ? {
+      accountId: stashId,
+      controllerId,
+      exposure,
+      nominators: nominators
+        ? Array.isArray(nominators)
+          ? nominators[0].targets
+          : nominators.targets
+        : [],
+      rewardDestination,
+      stakingLedger: stakingLedgerOpt.unwrapOr(undefined),
+      stashId,
+      validatorPrefs: Array.isArray(validatorPrefs)
+        ? validatorPrefs[0]
+        : validatorPrefs,
+      ...parseSessionIds(stashId, queuedKeys, nextKeys)
+    }
+    : { accountId: stashId, nextSessionIds: [], sessionIds: [] };
+}
+
 function retrievePrev (api: ApiInterfaceRx, stashId: AccountId): Observable<MultiResult> {
   return api.queryMulti<MultiResult>([
     [api.query.staking.bonded, stashId],
@@ -39,64 +64,43 @@ function retrievePrev (api: ApiInterfaceRx, stashId: AccountId): Observable<Mult
   ]);
 }
 
-function retrieveCurr (api: ApiInterfaceRx, stashId: AccountId): Observable<MultiResult> {
-  return api.derive.session.indexes().pipe(
-    switchMap(({ activeEra }) =>
-      api.queryMulti<MultiResult>([
-        [api.query.staking.bonded, stashId],
-        [api.query.staking.nominators, stashId],
-        [api.query.staking.payee, stashId],
-        [api.query.staking.validators, stashId],
-        api.consts.session?.dedupKeyPrefix
-          ? [api.query.session.nextKeys, [api.consts.session.dedupKeyPrefix, stashId]]
-          : [api.query.session.nextKeys, stashId],
-        [api.query.staking.erasStakers, [activeEra, stashId]]
-      ])
+function retrieveCurr (api: ApiInterfaceRx, stashIds: AccountId[], activeEra: EraIndex): Observable<MultiResult[]> {
+  return combineLatest([
+    api.query.staking.bonded.multi<Option<AccountId>>(stashIds),
+    api.query.staking.nominators.multi<Option<Nominations>>(stashIds),
+    api.query.staking.payee.multi<RewardDestination>(stashIds),
+    api.query.staking.validators.multi<ValidatorPrefs>(stashIds),
+    api.consts.session?.dedupKeyPrefix
+      ? api.query.session.nextKeys.multi<Option<Keys>>(stashIds.map((stashId) => [api.consts.session.dedupKeyPrefix, stashId]))
+      : api.query.session.nextKeys.multi<Option<Keys>>(stashIds),
+    api.query.staking.erasStakers.multi<Exposure>(stashIds.map((stashId) => [activeEra, stashId]))
+  ]).pipe(
+    map(([controllerIdOpt, nominatorsOpt, rewardDestination, validatorPrefs, nextKeys, exposure]): MultiResult[] =>
+      controllerIdOpt.map((controllerIdOpt, index): MultiResult =>
+        [controllerIdOpt, nominatorsOpt[index], rewardDestination[index], validatorPrefs[index], nextKeys[index], exposure[index]]
+      )
     )
   );
 }
 
-function retrieveController (api: ApiInterfaceRx, stashId: AccountId, queuedKeys: Vec<ITuple<[AccountId, Keys]>>, [controllerIdOpt, nominatorsOpt, rewardDestination, validatorPrefs, nextKeys, exposure]: MultiResult): Observable<DeriveStakingQuery> {
-  const controllerId = controllerIdOpt.unwrapOr(null);
-  const nominators = nominatorsOpt.unwrapOr(null);
+function retrieveControllers (api: ApiInterfaceRx, optControllerIds: Option<AccountId>[]): Observable<Option<StakingLedger>[]> {
+  const ids = optControllerIds.filter((opt) => opt.isSome).map((opt) => opt.unwrap());
 
-  return controllerId
-    ? api.query.staking.ledger(controllerId).pipe(
-      map((stakingLedgerOpt): DeriveStakingQuery => ({
-        accountId: stashId,
-        controllerId,
-        exposure,
-        nominators: nominators
-          ? Array.isArray(nominators)
-            ? nominators[0].targets
-            : nominators.targets
-          : [],
-        rewardDestination,
-        stakingLedger: stakingLedgerOpt.unwrapOr(undefined),
-        stashId,
-        validatorPrefs: Array.isArray(validatorPrefs)
-          ? validatorPrefs[0]
-          : validatorPrefs,
-        ...unwrapSessionIds(stashId, queuedKeys, nextKeys)
-      }))
-    )
-    : of({ accountId: stashId, nextSessionIds: [], sessionIds: [] });
-}
+  if (!ids.length) {
+    return of(optControllerIds.map(() => api.registry.createType('Option<StakingLedger>')));
+  }
 
-export function queryWithQueued (api: ApiInterfaceRx): (accountId: Uint8Array | string, queuedKeys: Vec<ITuple<[AccountId, Keys]>>) => Observable<DeriveStakingQuery> {
-  return memo((accountId: Uint8Array | string, queuedKeys: Vec<ITuple<[AccountId, Keys]>>): Observable<DeriveStakingQuery> => {
-    const stashId = api.registry.createType('AccountId', accountId);
+  return api.query.staking.ledger.multi<Option<StakingLedger>>(ids).pipe(
+    map((optLedgers): Option<StakingLedger>[] => {
+      let offset = -1;
 
-    return (
-      isFunction(api.query.staking.erasStakers)
-        ? retrieveCurr(api, stashId)
-        : retrievePrev(api, stashId)
-    ).pipe(
-      switchMap((result): Observable<DeriveStakingQuery> =>
-        retrieveController(api, stashId, queuedKeys, result)
-      )
-    );
-  });
+      return optControllerIds.map((opt): Option<StakingLedger> =>
+        opt.isSome
+          ? optLedgers[++offset]
+          : api.registry.createType('Option<StakingLedger>')
+      );
+    })
+  );
 }
 
 /**
@@ -104,8 +108,8 @@ export function queryWithQueued (api: ApiInterfaceRx): (accountId: Uint8Array |
  */
 export function query (api: ApiInterfaceRx): (accountId: Uint8Array | string) => Observable<DeriveStakingQuery> {
   return memo((accountId: Uint8Array | string): Observable<DeriveStakingQuery> =>
-    api.query.session.queuedKeys<Vec<ITuple<[AccountId, Keys]>>>().pipe(
-      switchMap((queuedKeys) => api.derive.staking.queryWithQueued(accountId, queuedKeys))
+    api.derive.staking.queryMulti([accountId]).pipe(
+      map(([first]) => first)
     )
   );
 }
@@ -113,10 +117,27 @@ export function query (api: ApiInterfaceRx): (accountId: Uint8Array | string) =>
 export function queryMulti (api: ApiInterfaceRx): (accountIds: (Uint8Array | string)[]) => Observable<DeriveStakingQuery[]> {
   return memo((accountIds: (Uint8Array | string)[]): Observable<DeriveStakingQuery[]> =>
     accountIds.length
-      ? api.query.session.queuedKeys<Vec<ITuple<[AccountId, Keys]>>>().pipe(
-        switchMap((queuedKeys) => combineLatest(
-          accountIds.map((acc) => api.derive.staking.queryWithQueued(acc, queuedKeys))
-        ))
+      ? combineLatest([
+        api.query.session.queuedKeys<Vec<ITuple<[AccountId, Keys]>>>(),
+        api.derive.session.indexes()
+      ]).pipe(
+        switchMap(([queuedKeys, { activeEra }]): Observable<DeriveStakingQuery[]> => {
+          const stashIds = accountIds.map((accountId) => api.registry.createType('AccountId', accountId));
+
+          return (
+            isFunction(api.query.staking.erasStakers)
+              ? retrieveCurr(api, stashIds, activeEra)
+              : combineLatest(stashIds.map((stashId) => retrievePrev(api, stashId)))
+          ).pipe(
+            switchMap((results): Observable<DeriveStakingQuery[]> =>
+              retrieveControllers(api, results.map(([optController]) => optController)).pipe(
+                map((stakingLedgerOpts) =>
+                  stashIds.map((stashId, index) => parseController(stashId, queuedKeys, results[index], stakingLedgerOpts[index]))
+                )
+              )
+            )
+          );
+        })
       )
       : of([])
   );

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

@@ -52,7 +52,7 @@ function parseRewards (api: ApiInterfaceRx, stashId: AccountId, [, erasPoints, e
             : ZERO;
         }
 
-        value = avail.sub(valCut).mul(staked).div(expTotal).add(validatorId === stakerId ? valCut : ZERO);
+        value = avail.sub(valCut).imul(staked).div(expTotal).iadd(validatorId === stakerId ? valCut : ZERO);
       }
 
       validators[validatorId] = {

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

@@ -96,6 +96,11 @@ export interface DeriveStakingElected {
   info: DeriveStakingQuery[];
 }
 
+export interface DeriveStakingWaiting {
+  info: DeriveStakingQuery[];
+  waiting: AccountId[];
+}
+
 export interface DeriveStakingValidators {
   nextElected: AccountId[];
   validators: AccountId[];

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

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

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

@@ -0,0 +1,32 @@
+// Copyright 2017-2020 @polkadot/api-derive authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { ApiInterfaceRx } from '@polkadot/api/types';
+import { DeriveStakingWaiting } from '../types';
+
+import { Observable, combineLatest } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+
+import { memo } from '../util';
+
+export function waitingInfo (api: ApiInterfaceRx): () => Observable<DeriveStakingWaiting> {
+  return memo((): Observable<DeriveStakingWaiting> =>
+    combineLatest([
+      api.derive.staking.validators(),
+      api.derive.staking.stashes()
+    ]).pipe(
+      switchMap(([{ nextElected }, stashes]): Observable<DeriveStakingWaiting> => {
+        const elected = nextElected.map((a) => a.toString());
+        const waiting = stashes.filter((v) => !elected.includes(v.toString()));
+
+        return api.derive.staking.queryMulti(waiting).pipe(
+          map((info): DeriveStakingWaiting => ({
+            info,
+            waiting
+          }))
+        );
+      })
+    )
+  );
+}

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

@@ -20,7 +20,7 @@ interface Result {
 
 function latestNonce (api: ApiInterfaceRx, address: string): Observable<Index> {
   return api.derive.balances.account(address).pipe(
-    map(({ accountNonce }): Index => accountNonce)
+    map(({ accountNonce }) => accountNonce)
   );
 }
 
@@ -31,7 +31,7 @@ function signingHeader (api: ApiInterfaceRx): Observable<Header> {
       switchMap((hash) => api.rpc.chain.getHeader(hash))
     )
   ]).pipe(
-    map(([current, finalized]): Header =>
+    map(([current, finalized]) =>
       // determine the hash to use, current when lag > max, else finalized
       current.number.unwrap().sub(finalized.number.unwrap()).gt(MAX_FINALITY_LAG)
         ? current
@@ -57,7 +57,7 @@ export function signingInfo (api: ApiInterfaceRx): (address: string, nonce?: Any
         header,
         mortalLength: MORTAL_PERIOD
           .div(api.consts.babe?.expectedBlockTime || api.consts.timestamp?.minimumPeriod.muln(2) || FALLBACK_PERIOD)
-          .add(MAX_FINALITY_LAG)
+          .iadd(MAX_FINALITY_LAG)
           .toNumber(),
         nonce
       }))

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

@@ -3,15 +3,11 @@
 // of the Apache-2.0 license. See the LICENSE file for details.v
 
 import createMemo from 'memoizee';
-import { Observable, Observer } from 'rxjs';
+import { Observable, Observer, TeardownLogic } from 'rxjs';
 import { drr } from '@polkadot/rpc-core/rxjs';
 
 type ObsFn <T> = (...params: any[]) => Observable<T>;
 
-// Normalize via JSON.stringify, allow e.g. AccountId -> ss58
-// eslint-disable-next-line @typescript-eslint/unbound-method
-const normalizer = JSON.stringify;
-
 // Wraps a derive, doing 2 things to optimize calls -
 //   1. creates a memo of the inner fn -> Observable, removing when unsubscribed
 //   2. wraps the observable in a drr() (which includes an unsub delay)
@@ -19,15 +15,19 @@ const normalizer = JSON.stringify;
 export function memo <T> (inner: ObsFn<T>): ObsFn<T> {
   const cached = createMemo(
     (...params: any[]): Observable<T> =>
-      new Observable((observer: Observer<T>): VoidCallback => {
-        const sub = inner(...params).subscribe(observer);
+      new Observable((observer: Observer<T>): TeardownLogic => {
+        const subscription = inner(...params).subscribe(observer);
 
         return (): void => {
           cached.delete(...params);
-          sub.unsubscribe();
+          subscription.unsubscribe();
         };
       }).pipe(drr()),
-    { normalizer }
+    {
+      // Normalize via JSON.stringify, allow e.g. AccountId -> ss58
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      normalizer: JSON.stringify
+    }
   );
 
   return cached;

packages/api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/api",
-  "version": "1.19.1",
+  "version": "1.21.1",
   "description": "Promise and RxJS wrappers around the Polkadot JS RPC",
   "main": "index.js",
   "keywords": [
@@ -26,21 +26,21 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/api#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.2",
-    "@polkadot/api-derive": "1.19.1",
-    "@polkadot/keyring": "^2.14.1",
-    "@polkadot/metadata": "1.19.1",
-    "@polkadot/rpc-core": "1.19.1",
-    "@polkadot/rpc-provider": "1.19.1",
-    "@polkadot/types": "1.19.1",
-    "@polkadot/types-known": "1.19.1",
-    "@polkadot/util": "^2.14.1",
-    "@polkadot/util-crypto": "^2.14.1",
+    "@babel/runtime": "^7.10.3",
+    "@polkadot/api-derive": "1.21.1",
+    "@polkadot/keyring": "^2.15.1",
+    "@polkadot/metadata": "1.21.1",
+    "@polkadot/rpc-core": "1.21.1",
+    "@polkadot/rpc-provider": "1.21.1",
+    "@polkadot/types": "1.21.1",
+    "@polkadot/types-known": "1.21.1",
+    "@polkadot/util": "^2.15.1",
+    "@polkadot/util-crypto": "^2.15.1",
     "bn.js": "^5.1.2",
     "eventemitter3": "^4.0.4",
     "rxjs": "^6.5.5"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^2.14.1"
+    "@polkadot/keyring": "^2.15.1"
   }
 }

packages/api/src/augment/consts.ts

@@ -3,8 +3,8 @@
 
 import { Codec } from '@polkadot/types/types';
 import { Vec } from '@polkadot/types/codec';
-import { u32, u64 } from '@polkadot/types/primitive';
-import { Balance, BalanceOf, BlockNumber, LockIdentifier, ModuleId, Moment, Percent, Permill, RuntimeDbWeight, Weight } from '@polkadot/types/interfaces/runtime';
+import { u16, u32, u64 } from '@polkadot/types/primitive';
+import { Balance, BalanceOf, BlockNumber, LockIdentifier, ModuleId, Moment, Perbill, Percent, Permill, RuntimeDbWeight, Weight } from '@polkadot/types/interfaces/runtime';
 import { SessionIndex } from '@polkadot/types/interfaces/session';
 import { EraIndex } from '@polkadot/types/interfaces/staking';
 import { WeightToFeeCoefficient } from '@polkadot/types/interfaces/support';
@@ -176,6 +176,40 @@ declare module '@polkadot/metadata/Decorated/consts/types' {
        **/
       subAccountDeposit: AugmentedConst<BalanceOf>;
     };
+    proxy: {
+      [index: string]: AugmentedConst<object & Codec>;
+      /**
+       * The maximum amount of proxies allowed for a single account.
+       **/
+      maxProxies: AugmentedConst<u16>;
+      /**
+       * The base amount of currency needed to reserve for creating a proxy.
+       **/
+      proxyDepositBase: AugmentedConst<BalanceOf>;
+      /**
+       * The amount of currency needed per proxy added.
+       **/
+      proxyDepositFactor: AugmentedConst<BalanceOf>;
+    };
+    recovery: {
+      [index: string]: AugmentedConst<object & Codec>;
+      /**
+       * The base amount of currency needed to reserve for creating a recovery configuration.
+       **/
+      configDepositBase: AugmentedConst<BalanceOf>;
+      /**
+       * The amount of currency needed per additional user when creating a recovery configuration.
+       **/
+      friendDepositFactor: AugmentedConst<BalanceOf>;
+      /**
+       * The maximum amount of friends allowed in a recovery configuration.
+       **/
+      maxFriends: AugmentedConst<u16>;
+      /**
+       * The base amount of currency needed to reserve for starting a recovery.
+       **/
+      recoveryDeposit: AugmentedConst<BalanceOf>;
+    };
     society: {
       [index: string]: AugmentedConst<object & Codec>;
       /**
@@ -215,10 +249,45 @@ declare module '@polkadot/metadata/Decorated/consts/types' {
        * Number of eras that staked funds must remain bonded for.
        **/
       bondingDuration: AugmentedConst<EraIndex>;
+      /**
+       * The number of blocks before the end of the era from which election submissions are allowed.
+       * 
+       * Setting this to zero will disable the offchain compute and only on-chain seq-phragmen will
+       * be used.
+       * 
+       * This is bounded by being within the last session. Hence, setting it to a value more than the
+       * length of a session will be pointless.
+       **/
+      electionLookahead: AugmentedConst<BlockNumber>;
+      /**
+       * Maximum number of balancing iterations to run in the offchain submission.
+       * 
+       * If set to 0, balance_solution will not be executed at all.
+       **/
+      maxIterations: AugmentedConst<u32>;
+      /**
+       * The maximum number of nominators rewarded for each validator.
+       * 
+       * For each validator only the `$MaxNominatorRewardedPerValidator` biggest stakers can claim
+       * their reward. This used to limit the i/o cost for the nominator payout.
+       **/
+      maxNominatorRewardedPerValidator: AugmentedConst<u32>;
+      /**
+       * The threshold of improvement that should be provided for a new solution to be accepted.
+       **/
+      minSolutionScoreBump: AugmentedConst<Perbill>;
       /**
        * Number of sessions per era.
        **/
       sessionsPerEra: AugmentedConst<SessionIndex>;
+      /**
+       * Number of eras that slashes are deferred by, after computation.
+       * 
+       * This should be less than the bonding duration.
+       * Set to 0 if slashes should be applied immediately, without opportunity for
+       * intervention.
+       **/
+      slashDeferDuration: AugmentedConst<EraIndex>;
     };
     system: {
       [index: string]: AugmentedConst<object & Codec>;

packages/api/src/augment/query.ts

@@ -6,22 +6,22 @@ import { Option, U8aFixed, Vec } from '@polkadot/types/codec';
 import { Bytes, Data, bool, u32, u64 } from '@polkadot/types/primitive';
 import { UncleEntryItem } from '@polkadot/types/interfaces/authorship';
 import { BabeAuthorityWeight, MaybeRandomness, NextConfigDescriptor, Randomness } from '@polkadot/types/interfaces/babe';
-import { AccountData, BalanceLock, ReleasesBalances } from '@polkadot/types/interfaces/balances';
+import { AccountData, BalanceLock } from '@polkadot/types/interfaces/balances';
 import { ProposalIndex, Votes } from '@polkadot/types/interfaces/collective';
 import { AuthorityId } from '@polkadot/types/interfaces/consensus';
 import { CodeHash, ContractInfo, PrefabWasmModule, Schedule } from '@polkadot/types/interfaces/contracts';
-import { PreimageStatus, PropIndex, Proposal, ReferendumIndex, ReferendumInfo, ReleasesDemocracy, Voting } from '@polkadot/types/interfaces/democracy';
+import { PreimageStatus, PropIndex, Proposal, ReferendumIndex, ReferendumInfo, Voting } from '@polkadot/types/interfaces/democracy';
 import { VoteThreshold } from '@polkadot/types/interfaces/elections';
 import { SetId, StoredPendingChange, StoredState } from '@polkadot/types/interfaces/grandpa';
 import { RegistrarInfo, Registration } from '@polkadot/types/interfaces/identity';
 import { AuthIndex } from '@polkadot/types/interfaces/imOnline';
 import { DeferredOffenceOf, Kind, OffenceDetails, OpaqueTimeSlot, ReportIdOf } from '@polkadot/types/interfaces/offences';
 import { ActiveRecovery, RecoveryConfig } from '@polkadot/types/interfaces/recovery';
-import { AccountId, AccountIndex, Balance, BalanceOf, BlockNumber, ExtrinsicsWeight, Hash, KeyTypeId, Moment, Perbill, ProxyType, ValidatorId } from '@polkadot/types/interfaces/runtime';
+import { AccountId, AccountIndex, Balance, BalanceOf, BlockNumber, ExtrinsicsWeight, Hash, KeyTypeId, Moment, Perbill, ProxyType, Releases, ValidatorId } from '@polkadot/types/interfaces/runtime';
 import { Scheduled, TaskAddress } from '@polkadot/types/interfaces/scheduler';
 import { Keys, SessionIndex } from '@polkadot/types/interfaces/session';
 import { Bid, BidKind, SocietyVote, StrikeCount, VouchingStatus } from '@polkadot/types/interfaces/society';
-import { ActiveEraInfo, ElectionResult, ElectionScore, ElectionStatus, EraIndex, EraRewardPoints, Exposure, Forcing, Nominations, ReleasesStaking, RewardDestination, SlashingSpans, SpanIndex, SpanRecord, StakingLedger, UnappliedSlash, ValidatorPrefs } from '@polkadot/types/interfaces/staking';
+import { ActiveEraInfo, ElectionResult, ElectionScore, ElectionStatus, EraIndex, EraRewardPoints, Exposure, Forcing, Nominations, RewardDestination, SlashingSpans, SpanIndex, SpanRecord, StakingLedger, UnappliedSlash, ValidatorPrefs } from '@polkadot/types/interfaces/staking';
 import { AccountInfo, DigestOf, EventIndex, EventRecord, LastRuntimeUpgradeInfo, Phase } from '@polkadot/types/interfaces/system';
 import { OpenTip, TreasuryProposal } from '@polkadot/types/interfaces/treasury';
 import { Multiplier } from '@polkadot/types/interfaces/txpayment';
@@ -134,7 +134,7 @@ declare module '@polkadot/api/types/storage' {
        * 
        * This is set to v2.0.0 for new networks.
        **/
-      storageVersion: AugmentedQuery<ApiType, () => Observable<ReleasesBalances>> & QueryableStorageEntry<ApiType>;
+      storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>> & QueryableStorageEntry<ApiType>;
       /**
        * The total units issued in the system.
        **/
@@ -262,7 +262,7 @@ declare module '@polkadot/api/types/storage' {
        * 
        * New networks start with last version.
        **/
-      storageVersion: AugmentedQuery<ApiType, () => Observable<Option<ReleasesDemocracy>>> & QueryableStorageEntry<ApiType>;
+      storageVersion: AugmentedQuery<ApiType, () => Observable<Option<Releases>>> & QueryableStorageEntry<ApiType>;
       /**
        * All votes for a particular voter. We store the balance for the number of votes that we
        * have recorded. The second item is the total amount of delegations, that will be added.
@@ -392,6 +392,7 @@ declare module '@polkadot/api/types/storage' {
     };
     multisig: {
       [index: string]: QueryableStorageEntry<ApiType>;
+      calls: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<ITuple<[Bytes, AccountId, BalanceOf]>>>> & QueryableStorageEntry<ApiType>;
       /**
        * The set of open multisig operations.
        **/
@@ -751,7 +752,7 @@ declare module '@polkadot/api/types/storage' {
        * 
        * This is set to v3.0.0 for new networks.
        **/
-      storageVersion: AugmentedQuery<ApiType, () => Observable<ReleasesStaking>> & QueryableStorageEntry<ApiType>;
+      storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>> & QueryableStorageEntry<ApiType>;
       /**
        * All unapplied slashes that are queued for later.
        **/
@@ -902,6 +903,7 @@ declare module '@polkadot/api/types/storage' {
     transactionPayment: {
       [index: string]: QueryableStorageEntry<ApiType>;
       nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<Multiplier>> & QueryableStorageEntry<ApiType>;
+      storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>> & QueryableStorageEntry<ApiType>;
     };
     treasury: {
       [index: string]: QueryableStorageEntry<ApiType>;

packages/api/src/augment/rpc.ts

@@ -19,16 +19,10 @@ import { RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
 import { RpcMethods } from '@polkadot/types/interfaces/rpc';
 import { AccountId, BlockNumber, H256, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime';
 import { ReadProof, RuntimeVersion } from '@polkadot/types/interfaces/state';
-import { ChainProperties, ChainType, Health, NetworkState, NodeRole, PeerInfo } from '@polkadot/types/interfaces/system';
+import { ApplyExtrinsicResult, ChainProperties, ChainType, Health, NetworkState, NodeRole, PeerInfo } from '@polkadot/types/interfaces/system';
 
 declare module '@polkadot/rpc-core/types.jsonrpc' {
   export interface RpcInterface {
-    account: {
-      /**
-       * Retrieves the next accountIndex as available on the node
-       **/
-      nextIndex: AugmentedRpc<(accountId: AccountId | string | Uint8Array) => Observable<Index>>;
-    };
     author: {
       /**
        * Returns true if the keystore has private keys for the given public key and key type.
@@ -244,6 +238,10 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
       subscribeStorage: AugmentedRpc<<T = Codec[]>(keys?: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[]) => Observable<T>>;
     };
     system: {
+      /**
+       * Retrieves the next accountIndex as available on the node
+       **/
+      accountNextIndex: AugmentedRpc<(accountId: AccountId | string | Uint8Array) => Observable<Index>>;
       /**
        * Adds a reserved peer
        **/
@@ -256,6 +254,10 @@ declare module '@polkadot/rpc-core/types.jsonrpc' {
        * Retrieves the chain type
        **/
       chainType: AugmentedRpc<() => Observable<ChainType>>;
+      /**
+       * Dry run an extrinsic at a given block
+       **/
+      dryRun: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ApplyExtrinsicResult>>;
       /**
        * Return health status of the node
        **/

packages/api/src/augment/tx.ts

@@ -9,10 +9,10 @@ import { CodeHash, Gas, Schedule } from '@polkadot/types/interfaces/contracts';
 import { AccountVote, Conviction, PropIndex, Proposal, ReferendumIndex } from '@polkadot/types/interfaces/democracy';
 import { DefunctVoter, Renouncing } from '@polkadot/types/interfaces/elections';
 import { Extrinsic, Signature } from '@polkadot/types/interfaces/extrinsics';
-import { EquivocationProof, KeyOwnerProof } from '@polkadot/types/interfaces/grandpa';
+import { GrandpaEquivocationProof, KeyOwnerProof } from '@polkadot/types/interfaces/grandpa';
 import { IdentityFields, IdentityInfo, IdentityJudgement, RegistrarIndex } from '@polkadot/types/interfaces/identity';
 import { Heartbeat } from '@polkadot/types/interfaces/imOnline';
-import { AccountId, AccountIndex, Address, Balance, BalanceOf, BlockNumber, Call, ChangesTrieConfiguration, Hash, Header, KeyValue, LookupSource, Moment, Perbill, ProxyType, Weight } from '@polkadot/types/interfaces/runtime';
+import { AccountId, AccountIndex, Address, Balance, BalanceOf, BlockNumber, Call, ChangesTrieConfiguration, Hash, Header, KeyValue, LookupSource, Moment, Perbill, Percent, ProxyType, Weight } from '@polkadot/types/interfaces/runtime';
 import { Period, Priority } from '@polkadot/types/interfaces/scheduler';
 import { Keys } from '@polkadot/types/interfaces/session';
 import { SocietyJudgement } from '@polkadot/types/interfaces/society';
@@ -878,7 +878,7 @@ declare module '@polkadot/api/types/submittable' {
        * submission of invalid equivocation reports, a mandatory pre-validation of
        * the extrinsic is implemented in a `SignedExtension`.
        **/
-      reportEquivocation: AugmentedSubmittable<(equivocationProof: EquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: KeyOwnerProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>>;
+      reportEquivocation: AugmentedSubmittable<(equivocationProof: GrandpaEquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: KeyOwnerProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>>;
     };
     identity: {
       [index: string]: SubmittableExtrinsicFunction<ApiType>;
@@ -1280,7 +1280,7 @@ declare module '@polkadot/api/types/submittable' {
        * - Write: Multisig Storage, [Caller Account]
        * # </weight>
        **/
-      approveAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId> | (AccountId | string | Uint8Array)[], maybeTimepoint: Option<Timepoint> | null | object | string | Uint8Array, callHash: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>>;
+      approveAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId> | (AccountId | string | Uint8Array)[], maybeTimepoint: Option<Timepoint> | null | object | string | Uint8Array, callHash: U8aFixed | string | Uint8Array, maxWeight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<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`.
@@ -1324,16 +1324,37 @@ declare module '@polkadot/api/types/submittable' {
        * `DepositBase + threshold * DepositFactor`.
        * -------------------------------
        * - Base Weight:
-       * - Create: 46.55 + 0.089 * S µs
-       * - Approve: 34.03 + .112 * S µs
-       * - Complete: 40.36 + .225 * S µs
+       * - Create:          41.89 + 0.118 * S + .002 * Z µs
+       * - Create w/ Store: 53.57 + 0.119 * S + .003 * Z µs
+       * - Approve:         31.39 + 0.136 * S + .002 * Z µs
+       * - Complete:        39.94 + 0.26  * S + .002 * Z µs
        * - DB Weight:
-       * - Reads: Multisig Storage, [Caller Account]
-       * - Writes: Multisig Storage, [Caller Account]
+       * - Reads: Multisig Storage, [Caller Account], Calls (if `store_call`)
+       * - Writes: Multisig Storage, [Caller Account], Calls (if `store_call`)
        * - Plus Call Weight
        * # </weight>
        **/
-      asMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId> | (AccountId | string | Uint8Array)[], maybeTimepoint: Option<Timepoint> | null | object | string | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>>;
+      asMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec<AccountId> | (AccountId | string | Uint8Array)[], maybeTimepoint: Option<Timepoint> | null | object | string | Uint8Array, call: Bytes | string | Uint8Array, storeCall: bool | boolean | Uint8Array, maxWeight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>>;
+      /**
+       * Immediately dispatch a multi-signature call using a single approval from the caller.
+       * 
+       * The dispatch origin for this call must be _Signed_.
+       * 
+       * - `other_signatories`: The accounts (other than the sender) who are part of the
+       * multi-signature, but do not participate in the approval process.
+       * - `call`: The call to be executed.
+       * 
+       * Result is equivalent to the dispatched result.
+       * 
+       * # <weight>
+       * O(Z + C) where Z is the length of the call and C its execution weight.
+       * -------------------------------
+       * - Base Weight: 33.72 + 0.002 * Z µs
+       * - DB Weight: None
+       * - Plus Call Weight
+       * # </weight>
+       **/
+      asMultiThreshold1: AugmentedSubmittable<(otherSignatories: Vec<AccountId> | (AccountId | string | Uint8Array)[], call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>>;
       /**
        * Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously
        * for this operation will be unreserved on success.
@@ -1357,10 +1378,10 @@ declare module '@polkadot/api/types/submittable' {
        * - I/O: 1 read `O(S)`, one remove.
        * - Storage: removes one item.
        * ----------------------------------
-       * - Base Weight: 37.6 + 0.084 * S
+       * - Base Weight: 36.07 + 0.124 * S
        * - DB Weight:
-       * - Read: Multisig Storage, [Caller Account]
-       * - Write: Multisig Storage, [Caller Account]
+       * - Read: Multisig Storage, [Caller Account], Refund Account, Calls
+       * - Write: Multisig Storage, [Caller Account], Refund Account, Calls
        * # </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>>;
@@ -2235,6 +2256,17 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       forceUnstake: AugmentedSubmittable<(stash: AccountId | string | Uint8Array, numSlashingSpans: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>>;
+      /**
+       * Increments the ideal number of validators.
+       * 
+       * The dispatch origin must be Root.
+       * 
+       * # <weight>
+       * Base Weight: 1.717 µs
+       * Read/Write: Validator Count
+       * # </weight>
+       **/
+      increaseValidatorCount: AugmentedSubmittable<(additional: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>>;
       /**
        * Declare the desire to nominate `targets` for the origin controller.
        * 
@@ -2320,6 +2352,17 @@ declare module '@polkadot/api/types/submittable' {
        * # </weight>
        **/
       rebond: AugmentedSubmittable<(value: Compact<BalanceOf> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>>;
+      /**
+       * Scale up the ideal number of validators by a factor.
+       * 
+       * The dispatch origin must be Root.
+       * 
+       * # <weight>
+       * Base Weight: 1.717 µs
+       * Read/Write: Validator Count
+       * # </weight>
+       **/
+      scaleValidatorCount: AugmentedSubmittable<(factor: Percent | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>>;
       /**
        * (Re-)set the controller of a stash.
        * 
@@ -3144,6 +3187,28 @@ declare module '@polkadot/api/types/submittable' {
     };
     vesting: {
       [index: string]: SubmittableExtrinsicFunction<ApiType>;
+      /**
+       * Force a vested transfer.
+       * 
+       * The dispatch origin for this call must be _Root_.
+       * 
+       * - `source`: The account whose funds should be transferred.
+       * - `target`: The account that should be transferred the vested funds.
+       * - `amount`: The amount of funds to transfer and will be vested.
+       * - `schedule`: The vesting schedule attached to the transfer.
+       * 
+       * Emits `VestingCreated`.
+       * 
+       * # <weight>
+       * - `O(1)`.
+       * - DbWeight: 4 Reads, 4 Writes
+       * - Reads: Vesting Storage, Balances Locks, Target Account, Source Account
+       * - Writes: Vesting Storage, Balances Locks, Target Account, Source Account
+       * - Benchmark: 100.3 + .365 * l µs (min square analysis)
+       * - Using 100 µs fixed. Assuming less than 50 locks on any user, else we may want factor in number of locks.
+       * # </weight>
+       **/
+      forceVestedTransfer: AugmentedSubmittable<(source: LookupSource | Address | AccountId | AccountIndex | string | Uint8Array, target: LookupSource | Address | AccountId | AccountIndex | string | Uint8Array, schedule: VestingInfo | { locked?: any; perBlock?: any; startingBlock?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>>;
       /**
        * Unlock any vested funds of the sender account.
        * 

packages/api/src/base/Decorate.ts

@@ -11,7 +11,7 @@ import { ApiInterfaceRx, ApiOptions, ApiTypes, DecorateMethod, DecoratedRpc, Dec
 
 import BN from 'bn.js';
 import { BehaviorSubject, Observable, combineLatest, of } from 'rxjs';
-import { map, switchMap, take, tap, toArray } from 'rxjs/operators';
+import { map, switchMap, tap, toArray } from 'rxjs/operators';
 import decorateDerive, { ExactDerive } from '@polkadot/api-derive';
 import { memo } from '@polkadot/api-derive/util';
 import DecoratedMeta from '@polkadot/metadata/Decorated';
@@ -145,7 +145,7 @@ export default abstract class Decorate<ApiType extends ApiTypes> extends Events
   /**
    * @description Creates an instance of a type as registered
    */
-  public createType <K extends keyof InterfaceTypes> (type: K, ...params: any[]): InterfaceTypes[K] {
+  public createType <K extends keyof InterfaceTypes> (type: K, ...params: unknown[]): InterfaceTypes[K] {
     return this.registry.createType(type, ...params);
   }
 
@@ -320,68 +320,50 @@ export default 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: any[]): any[] => 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 */
 
     // FIXME We probably want to be able to query the full list with non-subs as well
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const decorated = this.hasSubscriptions && creator.iterKey && creator.meta.type.isMap && creator.meta.type.asMap.linked.isTrue
       ? this._decorateStorageLinked(creator, decorateMethod)
-      : decorateMethod((...args: any[]): Observable<Codec> => (
-        this.hasSubscriptions
-          ? this._rpcCore.state
-            // Unfortunately for one-shot calls we also use .subscribeStorage here
-            .subscribeStorage<[Codec]>([getArgs(...args)])
-            // state_storage returns an array of values, since we have just subscribed to
-            // a single entry, we pull that from the array and return it as-is
-            .pipe(map(([data]): Codec => data))
-          : this._rpcCore.state.getStorage(getArgs(...args))
-      ), { methodName: creator.method });
+      : this._decorateStorageCall(creator, decorateMethod);
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     decorated.creator = creator;
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
     decorated.at = decorateMethod((hash: Hash, arg1?: Arg, arg2?: Arg): Observable<Codec> =>
       this._rpcCore.state.getStorage(getArgs(arg1, arg2), hash));
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
     decorated.hash = decorateMethod((arg1?: Arg, arg2?: Arg): Observable<Hash> =>
       this._rpcCore.state.getStorageHash(getArgs(arg1, arg2)));
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     decorated.key = (arg1?: Arg, arg2?: Arg): string =>
       u8aToHex(compactStripLength(creator(creator.meta.type.isDoubleMap ? [arg1, arg2] : arg1))[1]);
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     decorated.keyPrefix = (key1?: Arg): string =>
       u8aToHex(creator.keyPrefix(key1));
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
     decorated.range = decorateMethod((range: [Hash, Hash?], arg1?: Arg, arg2?: Arg): Observable<[Hash, Codec][]> =>
       this._decorateStorageRange(decorated, [arg1, arg2], range));
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
     decorated.size = decorateMethod((arg1?: Arg, arg2?: Arg): Observable<u64> =>
       this._rpcCore.state.getStorageSize(getArgs(arg1, arg2)));
 
     // .keys() & .entries() only available on map types
     if (creator.iterKey && (creator.meta.type.isMap || creator.meta.type.isDoubleMap)) {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
       decorated.entries = decorateMethod(
         memo((doubleMapArg?: Arg): Observable<[StorageKey, Codec][]> =>
           this._retrieveMapEntries(creator, doubleMapArg)));
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
       decorated.entriesPaged = decorateMethod(
         memo((opts: PaginationOptions): Observable<[StorageKey, Codec][]> =>
           this._retrieveMapEntriesPaged(creator, opts)));
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
       decorated.keys = decorateMethod(
         memo((doubleMapArg?: Arg): Observable<StorageKey[]> =>
           this._retrieveMapKeys(creator, doubleMapArg)));
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
       decorated.keysPaged = decorateMethod(
         memo((opts: PaginationOptions): Observable<StorageKey[]> =>
           this._retrieveMapKeysPaged(creator, opts)));
@@ -390,15 +372,32 @@ export default abstract class Decorate<ApiType extends ApiTypes> extends Events
     // only support multi where subs are available
     if (this.hasSubscriptions) {
       // When using double map storage function, user need to pass double map key as an array
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
       decorated.multi = decorateMethod((args: (Arg | Arg[])[]): Observable<Codec[]> =>
         this._rpcCore.state.subscribeStorage(
           args.map((arg: Arg[] | Arg): [StorageEntry, Arg | Arg[]] => [creator, arg])));
     }
 
+    /* eslint-enable @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment */
+
     return this._decorateFunctionMeta(creator as any, decorated) as unknown as QueryableStorageEntry<ApiType>;
   }
 
+  // Decorate the base storage call. In the case or rxjs or promise-without-callback (await)
+  // we make a subscription, alternatively we push this through a single-shot query
+  private _decorateStorageCall<ApiType extends ApiTypes> (creator: StorageEntry, decorateMethod: DecorateMethod<ApiType>): ReturnType<DecorateMethod<ApiType>> {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return decorateMethod((...args: unknown[]): Observable<Codec> => {
+      return this.hasSubscriptions
+        ? this._rpcCore.state.subscribeStorage<[Codec]>([extractStorageArgs(creator, args)]).pipe(
+          map(([data]) => data) // extract first/only result from list
+        )
+        : this._rpcCore.state.getStorage(extractStorageArgs(creator, args));
+    }, {
+      methodName: creator.method,
+      overrideNoSub: (...args: unknown[]) => this._rpcCore.state.getStorage(extractStorageArgs(creator, args))
+    });
+  }
+
   private _decorateStorageRange<ApiType extends ApiTypes> (decorated: QueryableStorageEntry<ApiType>, args: [Arg?, Arg?], range: [Hash, Hash?]): Observable<[Hash, Codec][]> {
     const outputType = unwrapStorageType(decorated.creator.meta.type, decorated.creator.meta.modifier.isOptional);
 
@@ -412,6 +411,8 @@ export default abstract class Decorate<ApiType extends ApiTypes> extends Events
       ));
   }
 
+  // This is deprecated/removed on substrate - we still have some live chains, eg. Edgeware needing it, so it
+  // has not been dropped yet. Slated for removal in API 2.0
   private _decorateStorageLinked<ApiType extends ApiTypes> (creator: StorageEntry, decorateMethod: DecorateMethod<ApiType>): ReturnType<DecorateMethod<ApiType>> {
     const result = new Map<Codec, ITuple<[Codec, Linkage<Codec>]> | null>();
     let subject: BehaviorSubject<LinkageResult>;
@@ -477,15 +478,15 @@ export default abstract class Decorate<ApiType extends ApiTypes> extends Events
     // this handles the case where the head changes effectively, i.e. a new entry
     // appears at the top of the list, the new getNext gets kicked off
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return decorateMethod((...args: any[]): Observable<LinkageResult | [Codec, Linkage<Codec>]> =>
+    return decorateMethod((...args: unknown[]): Observable<LinkageResult | [Codec, Linkage<Codec>]> =>
       args.length
         ? this._rpcCore.state
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           .subscribeStorage<[[Codec, Linkage<Codec>]]>([[creator, ...args]])
-          .pipe(map(([data]): [Codec, Linkage<Codec>] => data))
+          .pipe(map(([data]) => data))
         : this._rpcCore.state
           .subscribeStorage<[LinkageResult]>([iterKey()])
-          .pipe(switchMap(([key]): Observable<LinkageResult> => getNext(head = key)))
+          .pipe(switchMap(([key]) => getNext(head = key)))
     );
   }
 
@@ -495,35 +496,28 @@ export default abstract class Decorate<ApiType extends ApiTypes> extends Events
     const headKey = iterKey(arg).toHex();
     const startSubject = new BehaviorSubject<string>(headKey);
 
-    return this._rpcCore.state.getKeysPaged
-      ? startSubject.pipe(
-        switchMap((startKey) =>
-          this._rpcCore.state.getKeysPaged(headKey, PAGE_SIZE_KEYS, startKey).pipe(
-            map((keys) => keys.map((key) => key.setMeta(meta)))
-          )
-        ),
-        tap((keys): void => {
-          keys.length === PAGE_SIZE_KEYS
-            ? startSubject.next(keys[PAGE_SIZE_KEYS - 1].toHex())
-            : startSubject.complete();
-        }),
-        toArray(), // toArray since we want to startSubject to be completed
-        map((keysArr: StorageKey[][]) => keysArr.reduce((result: StorageKey[], keys) => result.concat(keys), []))
-      )
-      : this._rpcCore.state.getKeys(headKey).pipe(
-        map((keys) => keys.map((key) => key.setMeta(meta)))
-      );
+    return startSubject.pipe(
+      switchMap((startKey) =>
+        this._rpcCore.state.getKeysPaged(headKey, PAGE_SIZE_KEYS, startKey).pipe(
+          map((keys) => keys.map((key) => key.setMeta(meta)))
+        )
+      ),
+      tap((keys): void => {
+        keys.length === PAGE_SIZE_KEYS
+          ? startSubject.next(keys[PAGE_SIZE_KEYS - 1].toHex())
+          : startSubject.complete();
+      }),
+      toArray(), // toArray since we want to startSubject to be completed
+      map((keysArr: StorageKey[][]) => keysArr.reduce((result: StorageKey[], keys) => result.concat(keys), []))
+    );
   }
 
   private _retrieveMapKeysPaged ({ iterKey, meta }: 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');
 
     const headKey = iterKey(opts.arg).toHex();
-    const getKeysPaged = this._rpcCore.state.getKeysPaged;
 
-    assert(getKeysPaged, 'Pagination not supported by the chain');
-
-    return getKeysPaged(headKey, opts.pageSize, opts.startKey || headKey).pipe(
+    return this._rpcCore.state.getKeysPaged(headKey, opts.pageSize, opts.startKey || headKey).pipe(
       map((keys) => keys.map((key) => key.setMeta(meta)))
     );
   }
@@ -535,13 +529,11 @@ export default abstract class Decorate<ApiType extends ApiTypes> extends Events
           of(keys),
           ...Array(Math.ceil(keys.length / PAGE_SIZE_VALS))
             .fill(0)
-            .map((_, index): Observable<Codec[]> => {
-              const keyset = keys.slice(index * PAGE_SIZE_VALS, (index * PAGE_SIZE_VALS) + PAGE_SIZE_VALS);
-
-              return this._rpcCore.state.queryStorageAt
-                ? this._rpcCore.state.queryStorageAt<Codec[]>(keyset)
-                : this._rpcCore.state.subscribeStorage<Codec[]>(keyset).pipe(take(1));
-            })
+            .map((_, index): Observable<Codec[]> =>
+              this._rpcCore.state.queryStorageAt<Codec[]>(
+                keys.slice(index * PAGE_SIZE_VALS, (index * PAGE_SIZE_VALS) + PAGE_SIZE_VALS)
+              )
+            )
         ])
       ),
       map(([keys, ...valsArr]): [StorageKey, Codec][] =>
@@ -557,9 +549,7 @@ export default abstract class Decorate<ApiType extends ApiTypes> extends Events
       switchMap((keys) =>
         combineLatest<[StorageKey[], ...Codec[][]]>([
           of(keys),
-          this._rpcCore.state.queryStorageAt
-            ? this._rpcCore.state.queryStorageAt<Codec[]>(keys)
-            : this._rpcCore.state.subscribeStorage<Codec[]>(keys).pipe(take(1))
+          this._rpcCore.state.queryStorageAt<Codec[]>(keys)
         ])
       ),
       map(([keys, ...valsArr]): [StorageKey, Codec][] =>

packages/api/src/promise/Api.ts

@@ -2,31 +2,30 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { AnyFunction, Callback, Codec } from '@polkadot/types/types';
-import { ApiOptions, DecorateMethodOptions, ObsInnerType, StorageEntryPromiseOverloads, UnsubscribePromise } from '../types';
+import { Callback, Codec } from '@polkadot/types/types';
+import { ApiOptions, DecorateFn, DecorateMethodOptions, ObsInnerType, StorageEntryPromiseOverloads, UnsubscribePromise, VoidFn } from '../types';
 
-import { Observable, EMPTY } from 'rxjs';
-import { catchError, first, tap } from 'rxjs/operators';
+import { EMPTY, Observable, Subscription } from 'rxjs';
+import { catchError, tap } from 'rxjs/operators';
 import { isFunction, assert } from '@polkadot/util';
 
 import ApiBase from '../base';
 import Combinator, { CombinatorCallback, CombinatorFunction } from './Combinator';
 
-interface Tracker {
+interface Tracker<T> {
   reject: (value: Error) => Observable<never>;
-  resolve: (value: () => void) => void;
+  resolve: (value: T) => void;
 }
 
 // extract the arguments and callback params from a value array possibly containing a callback
-function extractArgs (args: any[], needsCallback: boolean): [any[], Callback<Codec> | undefined] {
+function extractArgs (args: unknown[], needsCallback: boolean): [unknown[], Callback<Codec> | undefined] {
   let callback: Callback<Codec> | undefined;
   const actualArgs = args.slice();
 
   // If the last arg is a function, we pop it, put it into callback.
   // actualArgs will then hold the actual arguments to be passed to `method`
   if (args.length && isFunction(args[args.length - 1])) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    callback = actualArgs.pop();
+    callback = actualArgs.pop() as Callback<Codec>;
   }
 
   // When we need a subscription, ensure that a valid callback is actually passed
@@ -36,64 +35,75 @@ function extractArgs (args: any[], needsCallback: boolean): [any[], Callback<Cod
 }
 
 // a Promise completion tracker, wrapping an isComplete variable that ensures the promise only resolves once
-function promiseTracker (resolve: (value: () => void) => void, reject: (value: Error) => void): Tracker {
+function promiseTracker<T> (resolve: (value: T) => void, reject: (value: Error) => void): Tracker<T> {
   let isCompleted = false;
 
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  const complete = (fn: Function, value: any): void => {
-    if (!isCompleted) {
-      isCompleted = true;
-
-      fn(value);
-    }
-  };
-
   return {
     reject: (error: Error): Observable<never> => {
-      complete(reject, error);
+      if (!isCompleted) {
+        isCompleted = true;
+
+        reject(error);
+      }
 
       return EMPTY;
     },
-    resolve: (value: any): void => {
-      complete(resolve, value);
+    resolve: (value: T): void => {
+      if (!isCompleted) {
+        isCompleted = true;
+
+        resolve(value);
+      }
     }
   };
 }
 
+// Decorate a call for a single-shot result - retrieve and then immediate unsubscribe
+function decorateCall<Method extends DecorateFn<ObsInnerType<ReturnType<Method>>>> (method: Method, actualArgs: unknown[]): Promise<ObsInnerType<ReturnType<Method>>> {
+  return new Promise((resolve, reject): void => {
+    // single result tracker - either reject with Error or resolve with Codec result
+    const tracker = promiseTracker(resolve, reject);
+
+    // errors reject immediately, any result unsubscribes and resolves
+    const subscription: Subscription = method(...actualArgs).pipe(
+      catchError((error) => tracker.reject(error))
+    ).subscribe((result): void => {
+      tracker.resolve(result);
+      setImmediate(() => subscription.unsubscribe());
+    });
+  });
+}
+
+// Decorate a subscription where we have a result callback specified
+function decorateSubscribe<Method extends DecorateFn<ObsInnerType<ReturnType<Method>>>> (method: Method, actualArgs: unknown[], resultCb: Callback<Codec>): UnsubscribePromise {
+  return new Promise<VoidFn>((resolve, reject): void => {
+    // either reject with error or resolve with unsubscribe callback
+    const tracker = promiseTracker(resolve, reject);
+
+    // errors reject immediately, the first result resolves with an unsubscribe promise, all results via callback
+    const subscription: Subscription = method(...actualArgs).pipe(
+      catchError((error) => tracker.reject(error)),
+      tap(() => tracker.resolve(() => subscription.unsubscribe()))
+    ).subscribe((result): void => {
+      // We use setImmediate here to ensure that the Promise above (tracker) has resolved, before returning
+      // the first result. By putting is back in the queue, the promise above is guarded for first execution
+      setImmediate(() => resultCb(result) as void);
+    });
+  });
+}
+
 /**
  * @description Decorate method for ApiPromise, where the results are converted to the Promise equivalent
  */
-export function decorateMethod<Method extends AnyFunction> (method: Method, options?: DecorateMethodOptions): StorageEntryPromiseOverloads {
+export function decorateMethod<Method extends DecorateFn<ObsInnerType<ReturnType<Method>>>> (method: Method, options?: DecorateMethodOptions): StorageEntryPromiseOverloads {
   const needsCallback = options && options.methodName && options.methodName.includes('subscribe');
 
-  return function (...args: any[]): Promise<ObsInnerType<ReturnType<Method>>> | UnsubscribePromise {
-    const [actualArgs, callback] = extractArgs(args, !!needsCallback);
+  return function (...args: unknown[]): Promise<ObsInnerType<ReturnType<Method>>> | UnsubscribePromise {
+    const [actualArgs, resultCb] = extractArgs(args, !!needsCallback);
 
-    if (!callback) {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
-      return method(...actualArgs).pipe(first()).toPromise() as Promise<ObsInnerType<ReturnType<Method>>>;
-    }
-
-    return new Promise((resolve, reject): void => {
-      const tracker = promiseTracker(resolve, reject);
-
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
-      const subscription: { unsubscribe: () => void } = method(...actualArgs).pipe(
-        // if we find an error (invalid params, etc), reject the promise
-        catchError((error): Observable<never> => tracker.reject(error)),
-        // upon the first result, resolve with the unsub function
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return
-        tap(() => tracker.resolve(() => subscription.unsubscribe()))
-      ).subscribe((result: any): void => {
-        if (setImmediate) {
-          // eslint-disable-next-line @typescript-eslint/no-misused-promises
-          setImmediate(() => callback(result) as void);
-        } else {
-          // eslint-disable-next-line @typescript-eslint/no-floating-promises
-          callback(result);
-        }
-      });
-    }) as UnsubscribePromise;
+    return resultCb
+      ? decorateSubscribe(method, actualArgs, resultCb)
+      : decorateCall((options?.overrideNoSub as Method) || method, actualArgs);
   } as StorageEntryPromiseOverloads;
 }
 

packages/api/src/rx/Api.ts

@@ -2,14 +2,14 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { AnyFunction } from '@polkadot/types/types';
-import { ApiOptions } from '../types';
+import { Codec } from '@polkadot/types/types';
+import { ApiOptions, DecorateFn } from '../types';
 
 import { from, Observable } from 'rxjs';
 
 import ApiBase from '../base';
 
-export function decorateMethod <Method extends AnyFunction> (method: Method): Method {
+export function decorateMethod <Method extends DecorateFn<Codec>> (method: Method): Method {
   return method;
 }
 

packages/api/src/types/base.ts

@@ -2,7 +2,7 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { Observable } from 'rxjs';
+import type { Observable } from 'rxjs';
 import { AnyFunction, Callback, Codec, CodecArg } from '@polkadot/types/types';
 
 // Prepend an element V onto the beginning of a tuple T.
@@ -30,7 +30,9 @@ export type ApiTypes = 'promise' | 'rxjs';
 // Returns the inner type of an Observable
 export type ObsInnerType<O extends Observable<any>> = O extends Observable<infer U> ? U : never;
 
-export type UnsubscribePromise = Promise<() => void>;
+export type VoidFn = () => void;
+
+export type UnsubscribePromise = Promise<VoidFn>;
 
 // FIXME The day TS has higher-kinded types, we can remove this hardcoded stuff
 export type PromiseOrObs<ApiType extends ApiTypes, T> = ApiType extends 'rxjs'
@@ -66,8 +68,11 @@ export type MethodResult<ApiType extends ApiTypes, F extends AnyFunction> = ApiT
 // information. This describes it.
 export interface DecorateMethodOptions {
   methodName?: string;
+  overrideNoSub?: (...args: unknown[]) => Observable<Codec>;
 }
 
+export type DecorateFn <T extends Codec> = (...args: any[]) => Observable<T>;
+
 export interface PaginationOptions<ArgType = CodecArg> {
   arg?: ArgType;
   pageSize: number;

packages/api/src/types/index.ts

@@ -5,10 +5,11 @@
 // Augment the modules
 import '@polkadot/api/augment';
 
-import BN from 'bn.js';
+import type BN from 'bn.js';
 import { DeriveCustom, ExactDerive } from '@polkadot/api-derive';
 import { Constants } from '@polkadot/metadata/Decorated/types';
 import { RpcInterface } from '@polkadot/rpc-core/types';
+import { ProviderInterface, ProviderInterfaceEmitted } from '@polkadot/rpc-provider/types';
 import { Metadata } from '@polkadot/types';
 import { Hash, RuntimeVersion } from '@polkadot/types/interfaces';
 import { DefinitionRpc, DefinitionRpcSub, Signer, SignatureOptions, Registry, RegisteredTypes } from '@polkadot/types/types';
@@ -18,7 +19,6 @@ import ApiBase from '../base';
 import { DecoratedRpc } from './rpc';
 import { QueryableStorage, QueryableStorageMulti } from './storage';
 import { SubmittableExtrinsics } from './submittable';
-import { ProviderInterface, ProviderInterfaceEmitted } from '@polkadot/rpc-provider/types';
 
 export { Signer, SignerResult } from '@polkadot/types/types';
 export { default as ApiBase } from '../base';

packages/api/src/util/augmentObject.ts

@@ -32,7 +32,7 @@ function extractKeys (src: Record<string, Record<string, any>>, dst: Record<stri
 }
 
 function findSectionExcludes (a: string[], b: string[]): string[] {
-  return a.filter((section): boolean => !b.includes(section));
+  return a.filter((section) => !b.includes(section));
 }
 
 function extractSections (src: Record<string, Record<string, any>>, dst: Record<string, Record<string, any>>): StringsStrings {
@@ -49,15 +49,15 @@ function findMethodExcludes (src: Record<string, Record<string, any>>, dst: Reco
   const dstSections = Object.keys(dst);
 
   return dstSections
-    .filter((section): boolean => srcSections.includes(section))
+    .filter((section) => srcSections.includes(section))
     .reduce((rmMethods: string[], section): string[] => {
       const srcMethods = Object.keys(src[section]);
 
       return rmMethods.concat(
         ...Object
           .keys(dst[section])
-          .filter((method): boolean => !srcMethods.includes(method))
-          .map((method): string => `${section}.${method}`)
+          .filter((method) => !srcMethods.includes(method))
+          .map((method) => `${section}.${method}`)
       );
     }, []);
 }

packages/api/src/util/filterEvents.ts

@@ -24,7 +24,7 @@ export default function filterEvents (extHash: H256, { block: { extrinsics, head
     return;
   }
 
-  return allEvents.filter(({ phase }): boolean =>
+  return allEvents.filter(({ phase }) =>
     // only ApplyExtrinsic has the extrinsic index
     phase.isApplyExtrinsic && phase.asApplyExtrinsic.eqn(index)
   );

packages/api/src/util/validate.ts

@@ -11,7 +11,7 @@ function sig ({ method, section }: StorageEntry, ...args: Type[]): string {
   return `${section}.${method}(${args.join(', ')})`;
 }
 
-function doDoubleMap (creator: StorageEntry, args: any[]): [StorageEntry, [any, any]] {
+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`);
@@ -20,7 +20,7 @@ function doDoubleMap (creator: StorageEntry, args: any[]): [StorageEntry, [any,
   return [creator, args as [any, any]];
 }
 
-function doMap (creator: StorageEntry, args: any[]): [StorageEntry] | [StorageEntry, any] {
+function doMap (creator: StorageEntry, args: unknown[]): [StorageEntry] | [StorageEntry, any] {
   const { key, linked } = creator.meta.type.asMap;
 
   linked.isTrue
@@ -35,7 +35,7 @@ function doMap (creator: StorageEntry, args: any[]): [StorageEntry] | [StorageEn
 
 // 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: any[]): [StorageEntry, [any, any]] | [StorageEntry] | [StorageEntry, any] {
+export function extractStorageArgs (creator: StorageEntry, _args: unknown[]): [StorageEntry, [any, any]] | [StorageEntry] | [StorageEntry, any] {
   const args = _args.filter((arg) => !isUndefined(arg));
 
   if (creator.meta.type.isDoubleMap) {

packages/metadata/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/metadata",
-  "version": "1.19.1",
+  "version": "1.21.1",
   "description": "Helpers to extract information from runtime metadata",
   "main": "index.js",
   "publishConfig": {
@@ -26,14 +26,14 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/type-metadata#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.2",
-    "@polkadot/types": "1.19.1",
-    "@polkadot/types-known": "1.19.1",
-    "@polkadot/util": "^2.14.1",
-    "@polkadot/util-crypto": "^2.14.1",
+    "@babel/runtime": "^7.10.3",
+    "@polkadot/types": "1.21.1",
+    "@polkadot/types-known": "1.21.1",
+    "@polkadot/util": "^2.15.1",
+    "@polkadot/util-crypto": "^2.15.1",
     "bn.js": "^5.1.2"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^2.14.1"
+    "@polkadot/keyring": "^2.15.1"
   }
 }

packages/metadata/src/Metadata/v11/static-substrate.json

@@ -1285,7 +1285,7 @@
                 "name": "StorageVersion",
                 "modifier": "Default",
                 "type": {
-                  "Plain": "ReleasesBalances"
+                  "Plain": "Releases"
                 },
                 "fallback": "0x00",
                 "documentation": [
@@ -1588,7 +1588,16 @@
                 "type": {
                   "Plain": "Multiplier"
                 },
-                "fallback": "0x00000000000000000000000000000000",
+                "fallback": "0x000064a7b3b6e00d0000000000000000",
+                "documentation": []
+              },
+              {
+                "name": "StorageVersion",
+                "modifier": "Default",
+                "type": {
+                  "Plain": "Releases"
+                },
+                "fallback": "0x00",
                 "documentation": []
               }
             ]
@@ -2139,7 +2148,7 @@
                 "name": "StorageVersion",
                 "modifier": "Default",
                 "type": {
-                  "Plain": "ReleasesStaking"
+                  "Plain": "Releases"
                 },
                 "fallback": "0x03",
                 "documentation": [
@@ -2464,6 +2473,44 @@
                 " # </weight>"
               ]
             },
+            {
+              "name": "increase_validator_count",
+              "args": [
+                {
+                  "name": "additional",
+                  "type": "Compact<u32>"
+                }
+              ],
+              "documentation": [
+                " Increments the ideal number of validators.",
+                "",
+                " The dispatch origin must be Root.",
+                "",
+                " # <weight>",
+                " Base Weight: 1.717 µs",
+                " Read/Write: Validator Count",
+                " # </weight>"
+              ]
+            },
+            {
+              "name": "scale_validator_count",
+              "args": [
+                {
+                  "name": "factor",
+                  "type": "Percent"
+                }
+              ],
+              "documentation": [
+                " Scale up the ideal number of validators by a factor.",
+                "",
+                " The dispatch origin must be Root.",
+                "",
+                " # <weight>",
+                " Base Weight: 1.717 µs",
+                " Read/Write: Validator Count",
+                " # </weight>"
+              ]
+            },
             {
               "name": "force_no_eras",
               "args": [],
@@ -2938,6 +2985,61 @@
               "documentation": [
                 " Number of eras that staked funds must remain bonded for."
               ]
+            },
+            {
+              "name": "SlashDeferDuration",
+              "type": "EraIndex",
+              "value": "0xa8000000",
+              "documentation": [
+                " Number of eras that slashes are deferred by, after computation. ",
+                "",
+                " This should be less than the bonding duration. ",
+                " Set to 0 if slashes should be applied immediately, without opportunity for",
+                " intervention."
+              ]
+            },
+            {
+              "name": "ElectionLookahead",
+              "type": "BlockNumber",
+              "value": "0x32000000",
+              "documentation": [
+                " The number of blocks before the end of the era from which election submissions are allowed.",
+                "",
+                " Setting this to zero will disable the offchain compute and only on-chain seq-phragmen will",
+                " be used.",
+                "",
+                " This is bounded by being within the last session. Hence, setting it to a value more than the",
+                " length of a session will be pointless."
+              ]
+            },
+            {
+              "name": "MaxIterations",
+              "type": "u32",
+              "value": "0x0a000000",
+              "documentation": [
+                " Maximum number of balancing iterations to run in the offchain submission. ",
+                "",
+                " If set to 0, balance_solution will not be executed at all."
+              ]
+            },
+            {
+              "name": "MinSolutionScoreBump",
+              "type": "Perbill",
+              "value": "0x20a10700",
+              "documentation": [
+                " The threshold of improvement that should be provided for a new solution to be accepted."
+              ]
+            },
+            {
+              "name": "MaxNominatorRewardedPerValidator",
+              "type": "u32",
+              "value": "0x40000000",
+              "documentation": [
+                " The maximum number of nominators rewarded for each validator.",
+                "",
+                " For each validator only the `$MaxNominatorRewardedPerValidator` biggest stakers can claim",
+                " their reward. This used to limit the i/o cost for the nominator payout."
+              ]
             }
           ],
           "errors": [
@@ -3523,7 +3625,7 @@
                 "name": "StorageVersion",
                 "modifier": "Optional",
                 "type": {
-                  "Plain": "ReleasesDemocracy"
+                  "Plain": "Releases"
                 },
                 "fallback": "0x00",
                 "documentation": [
@@ -4955,7 +5057,7 @@
                 "DispatchResult"
               ],
               "documentation": [
-                " A motion was executed; `bool` is true if returned without error."
+                " A motion was executed; result will be `Ok` if it returned without error."
               ]
             },
             {
@@ -4965,7 +5067,7 @@
                 "DispatchResult"
               ],
               "documentation": [
-                " A single member did some action; `bool` is true if returned without error."
+                " A single member did some action; result will be `Ok` if it returned without error."
               ]
             },
             {
@@ -4976,7 +5078,7 @@
                 "MemberCount"
               ],
               "documentation": [
-                " A proposal was closed after its duration was up."
+                " A proposal was closed because its threshold was reached or after its duration was up."
               ]
             }
           ],
@@ -5021,7 +5123,7 @@
             {
               "name": "TooEarly",
               "documentation": [
-                " The close call is made too early, before the end of the voting."
+                " The close call was made too early, before the end of the voting."
               ]
             },
             {
@@ -5403,7 +5505,7 @@
                 "DispatchResult"
               ],
               "documentation": [
-                " A motion was executed; `bool` is true if returned without error."
+                " A motion was executed; result will be `Ok` if it returned without error."
               ]
             },
             {
@@ -5413,7 +5515,7 @@
                 "DispatchResult"
               ],
               "documentation": [
-                " A single member did some action; `bool` is true if returned without error."
+                " A single member did some action; result will be `Ok` if it returned without error."
               ]
             },
             {
@@ -5424,7 +5526,7 @@
                 "MemberCount"
               ],
               "documentation": [
-                " A proposal was closed after its duration was up."
+                " A proposal was closed because its threshold was reached or after its duration was up."
               ]
             }
           ],
@@ -5469,7 +5571,7 @@
             {
               "name": "TooEarly",
               "documentation": [
-                " The close call is made too early, before the end of the voting."
+                " The close call was made too early, before the end of the voting."
               ]
             },
             {
@@ -6289,7 +6391,7 @@
               "args": [
                 {
                   "name": "equivocation_proof",
-                  "type": "EquivocationProof"
+                  "type": "GrandpaEquivocationProof"
                 },
                 {
                   "name": "key_owner_proof",
@@ -9750,7 +9852,40 @@
               ]
             }
           ],
-          "constants": [],
+          "constants": [
+            {
+              "name": "ConfigDepositBase",
+              "type": "BalanceOf",
+              "value": "0x00406352bfc601000000000000000000",
+              "documentation": [
+                " The base amount of currency needed to reserve for creating a recovery configuration."
+              ]
+            },
+            {
+              "name": "FriendDepositFactor",
+              "type": "BalanceOf",
+              "value": "0x00203d88792d00000000000000000000",
+              "documentation": [
+                " The amount of currency needed per additional user when creating a recovery configuration."
+              ]
+            },
+            {
+              "name": "MaxFriends",
+              "type": "u16",
+              "value": "0x0900",
+              "documentation": [
+                " The maximum amount of friends allowed in a recovery configuration."
+              ]
+            },
+            {
+              "name": "RecoveryDeposit",
+              "type": "BalanceOf",
+              "value": "0x00406352bfc601000000000000000000",
+              "documentation": [
+                " The base amount of currency needed to reserve for starting a recovery."
+              ]
+            }
+          ],
           "errors": [
             {
               "name": "NotAllowed",
@@ -9959,6 +10094,44 @@
                 " - Using 100 µs fixed. Assuming less than 50 locks on any user, else we may want factor in number of locks.",
                 " # </weight>"
               ]
+            },
+            {
+              "name": "force_vested_transfer",
+              "args": [
+                {
+                  "name": "source",
+                  "type": "LookupSource"
+                },
+                {
+                  "name": "target",
+                  "type": "LookupSource"
+                },
+                {
+                  "name": "schedule",
+                  "type": "VestingInfo"
+                }
+              ],
+              "documentation": [
+                " Force a vested transfer.",
+                "",
+                " The dispatch origin for this call must be _Root_.",
+                "",
+                " - `source`: The account whose funds should be transferred.",
+                " - `target`: The account that should be transferred the vested funds.",
+                " - `amount`: The amount of funds to transfer and will be vested.",
+                " - `schedule`: The vesting schedule attached to the transfer.",
+                "",
+                " Emits `VestingCreated`.",
+                "",
+                " # <weight>",
+                " - `O(1)`.",
+                " - DbWeight: 4 Reads, 4 Writes",
+                "     - Reads: Vesting Storage, Balances Locks, Target Account, Source Account",
+                "     - Writes: Vesting Storage, Balances Locks, Target Account, Source Account",
+                " - Benchmark: 100.3 + .365 * l µs (min square analysis)",
+                " - Using 100 µs fixed. Assuming less than 50 locks on any user, else we may want factor in number of locks.",
+                " # </weight>"
+              ]
             }
           ],
           "events": [
@@ -10446,7 +10619,32 @@
               ]
             }
           ],
-          "constants": [],
+          "constants": [
+            {
+              "name": "ProxyDepositBase",
+              "type": "BalanceOf",
+              "value": "0x00f09e544c3900000000000000000000",
+              "documentation": [
+                " The base amount of currency needed to reserve for creating a proxy."
+              ]
+            },
+            {
+              "name": "ProxyDepositFactor",
+              "type": "BalanceOf",
+              "value": "0x0060aa7714b400000000000000000000",
+              "documentation": [
+                " The amount of currency needed per proxy added."
+              ]
+            },
+            {
+              "name": "MaxProxies",
+              "type": "u16",
+              "value": "0x2000",
+              "documentation": [
+                " The maximum amount of proxies allowed for a single account."
+              ]
+            }
+          ],
           "errors": [
             {
               "name": "TooMany",
@@ -10507,10 +10705,56 @@
                 "documentation": [
                   " The set of open multisig operations."
                 ]
+              },
+              {
+                "name": "Calls",
+                "modifier": "Optional",
+                "type": {
+                  "Map": {
+                    "hasher": "Identity",
+                    "key": "[u8;32]",
+                    "value": "(Bytes,AccountId,BalanceOf)",
+                    "linked": false
+                  }
+                },
+                "fallback": "0x00",
+                "documentation": []
               }
             ]
           },
           "calls": [
+            {
+              "name": "as_multi_threshold_1",
+              "args": [
+                {
+                  "name": "other_signatories",
+                  "type": "Vec<AccountId>"
+                },
+                {
+                  "name": "call",
+                  "type": "Call"
+                }
+              ],
+              "documentation": [
+                " Immediately dispatch a multi-signature call using a single approval from the caller.",
+                "",
+                " The dispatch origin for this call must be _Signed_.",
+                "",
+                " - `other_signatories`: The accounts (other than the sender) who are part of the",
+                " multi-signature, but do not participate in the approval process.",
+                " - `call`: The call to be executed.",
+                "",
+                " Result is equivalent to the dispatched result.",
+                "",
+                " # <weight>",
+                " O(Z + C) where Z is the length of the call and C its execution weight.",
+                " -------------------------------",
+                " - Base Weight: 33.72 + 0.002 * Z µs",
+                " - DB Weight: None",
+                " - Plus Call Weight",
+                " # </weight>"
+              ]
+            },
             {
               "name": "as_multi",
               "args": [
@@ -10528,7 +10772,15 @@
                 },
                 {
                   "name": "call",
-                  "type": "Call"
+                  "type": "Bytes"
+                },
+                {
+                  "name": "store_call",
+                  "type": "bool"
+                },
+                {
+                  "name": "max_weight",
+                  "type": "Weight"
                 }
               ],
               "documentation": [
@@ -10574,12 +10826,13 @@
                 "   `DepositBase + threshold * DepositFactor`.",
                 " -------------------------------",
                 " - Base Weight:",
-                "     - Create: 46.55 + 0.089 * S µs",
-                "     - Approve: 34.03 + .112 * S µs",
-                "     - Complete: 40.36 + .225 * S µs",
+                "     - Create:          41.89 + 0.118 * S + .002 * Z µs",
+                "     - Create w/ Store: 53.57 + 0.119 * S + .003 * Z µs",
+                "     - Approve:         31.39 + 0.136 * S + .002 * Z µs",
+                "     - Complete:        39.94 + 0.26  * S + .002 * Z µs",
                 " - DB Weight:",
-                "     - Reads: Multisig Storage, [Caller Account]",
-                "     - Writes: Multisig Storage, [Caller Account]",
+                "     - Reads: Multisig Storage, [Caller Account], Calls (if `store_call`)",
+                "     - Writes: Multisig Storage, [Caller Account], Calls (if `store_call`)",
                 " - Plus Call Weight",
                 " # </weight>"
               ]
@@ -10602,6 +10855,10 @@
                 {
                   "name": "call_hash",
                   "type": "[u8;32]"
+                },
+                {
+                  "name": "max_weight",
+                  "type": "Weight"
                 }
               ],
               "documentation": [
@@ -10689,10 +10946,10 @@
                 " - I/O: 1 read `O(S)`, one remove.",
                 " - Storage: removes one item.",
                 " ----------------------------------",
-                " - Base Weight: 37.6 + 0.084 * S",
+                " - Base Weight: 36.07 + 0.124 * S",
                 " - DB Weight:",
-                "     - Read: Multisig Storage, [Caller Account]",
-                "     - Write: Multisig Storage, [Caller Account]",
+                "     - Read: Multisig Storage, [Caller Account], Refund Account, Calls",
+                "     - Write: Multisig Storage, [Caller Account], Refund Account, Calls",
                 " # </weight>"
               ]
             }
@@ -10754,9 +11011,9 @@
           "constants": [],
           "errors": [
             {
-              "name": "ZeroThreshold",
+              "name": "MinimumThreshold",
               "documentation": [
-                " Threshold is too low (zero)."
+                " Threshold must be 2 or greater."
               ]
             },
             {
@@ -10824,6 +11081,18 @@
               "documentation": [
                 " A timepoint was given, yet no multisig operation is underway."
               ]
+            },
+            {
+              "name": "WeightTooLow",
+              "documentation": [
+                " The maximum weight information provided was too low."
+              ]
+            },
+            {
+              "name": "AlreadyStored",
+              "documentation": [
+                " The data to be stored is already stored."
+              ]
             }
           ]
         }

packages/rpc-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/rpc-core",
-  "version": "1.19.1",
+  "version": "1.21.1",
   "description": "A JavaScript wrapper for the Polkadot JsonRPC interface",
   "main": "index.js",
   "keywords": [
@@ -26,15 +26,15 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/rpc-core#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.2",
-    "@polkadot/metadata": "1.19.1",
-    "@polkadot/rpc-provider": "1.19.1",
-    "@polkadot/types": "1.19.1",
-    "@polkadot/util": "^2.14.1",
+    "@babel/runtime": "^7.10.3",
+    "@polkadot/metadata": "1.21.1",
+    "@polkadot/rpc-provider": "1.21.1",
+    "@polkadot/types": "1.21.1",
+    "@polkadot/util": "^2.15.1",
     "memoizee": "^0.4.14",
     "rxjs": "^6.5.5"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^2.14.1"
+    "@polkadot/keyring": "^2.15.1"
   }
 }

packages/rpc-core/src/index.ts

@@ -12,10 +12,15 @@ import { combineLatest, from, Observable, Observer, of, throwError } from 'rxjs'
 import { catchError, map, publishReplay, refCount, switchMap } from 'rxjs/operators';
 import jsonrpc from '@polkadot/types/interfaces/jsonrpc';
 import { Option, StorageKey, Vec, createClass, createTypeUnsafe } from '@polkadot/types';
-import { assert, hexToU8a, isFunction, isNull, isNumber, isUndefined, logger, u8aToU8a } from '@polkadot/util';
+import { assert, hexToU8a, isFunction, isNull, isUndefined, logger, u8aToU8a } from '@polkadot/util';
 
 import { drr } from './rxjs';
 
+interface StorageChangeSetJSON {
+  block: string;
+  changes: [string, string | null][];
+}
+
 const l = logger('rpc-core');
 
 const EMPTY_META = {
@@ -75,8 +80,6 @@ export default class Rpc implements RpcInterface {
   // these via the createInterfaces inside the constructor. However... this is not quite visible. The reason
   // why we don't do for individual assignments is to allow user-defined RPCs to also be defined
 
-  public readonly account!: RpcInterface['account'];
-
   public readonly author!: RpcInterface['author'];
 
   public readonly babe!: RpcInterface['babe'];
@@ -212,7 +215,7 @@ export default class Rpc implements RpcInterface {
   }
 
   // create a subscriptor, it subscribes once and resolves with the id as subscribe
-  private _createSubscriber ({ paramsJson, subName, subType, update }: { subType: string; subName: string; paramsJson: AnyJson[]; update: ProviderInterfaceCallback }, errorHandler: (error: Error) => void): Promise<number> {
+  private _createSubscriber ({ paramsJson, subName, subType, update }: { subType: string; subName: string; paramsJson: AnyJson[]; update: ProviderInterfaceCallback }, errorHandler: (error: Error) => void): Promise<number | string> {
     return new Promise((resolve, reject): void => {
       this.provider
         .subscribe(subType, subName, paramsJson, update)
@@ -229,11 +232,12 @@ export default class Rpc implements RpcInterface {
     const subName = `${section}_${subMethod}`;
     const unsubName = `${section}_${unsubMethod}`;
     const subType = `${section}_${updateType}`;
+    let memoized: null | RpcInterfaceMethod & memoizee.Memoized<RpcInterfaceMethod> = null;
 
-    const creator = (isRaw: boolean) => (...values: any[]): Observable<any> => {
+    const creator = (isRaw: boolean) => (...values: unknown[]): Observable<any> => {
       return new Observable((observer: Observer<any>): VoidCallback => {
         // Have at least an empty promise, as used in the unsubscribe
-        let subscriptionPromise: Promise<number | void> = Promise.resolve();
+        let subscriptionPromise: Promise<number | string | null> = Promise.resolve(null);
 
         const errorHandler = (error: Error): void => {
           logErrorMessage(method, def, error);
@@ -279,22 +283,21 @@ export default class Rpc implements RpcInterface {
           //    api.query.system.account(addr1).subscribe(); // will output 6 instead of 7 if we don't clear cache
           //    // that's because all our observables are replay(1)
           // ```
-          // eslint-disable-next-line @typescript-eslint/no-use-before-define
-          memoized.delete(...values);
+          memoized && memoized.delete(...values);
 
           // Unsubscribe from provider
           subscriptionPromise
             .then((subscriptionId): Promise<boolean> =>
-              isNumber(subscriptionId)
-                ? this.provider.unsubscribe(subType, unsubName, subscriptionId)
-                : Promise.resolve(false)
+              isNull(subscriptionId)
+                ? Promise.resolve(false)
+                : this.provider.unsubscribe(subType, unsubName, subscriptionId)
             )
-            .catch((error: Error): void => logErrorMessage(method, def, error));
+            .catch((error: Error) => logErrorMessage(method, def, error));
         };
       }).pipe(drr());
     };
 
-    const memoized = memoizee(this._createMethodWithRaw(creator), {
+    memoized = memoizee(this._createMethodWithRaw(creator), {
       // Dynamic length for argument
       length: false,
       // Normalize args so that different args that should be cached
@@ -341,10 +344,10 @@ export default class Rpc implements RpcInterface {
       const keys = params[0] as Vec<StorageKey>;
 
       return keys
-        ? this._formatStorageSet(keys, (result as { changes: [string, string | null][] }).changes)
+        ? this._formatStorageSet(keys, (result as StorageChangeSetJSON).changes)
         : this.registry.createType('StorageChangeSet', result);
     } else if (rpc.type === 'Vec<StorageChangeSet>') {
-      const mapped = (result as { block: string; changes: [string, string | null][] }[]).map(({ block, changes }): [Hash, Codec[]] => [
+      const mapped = (result as StorageChangeSetJSON[]).map(({ block, changes }): [Hash, Codec[]] => [
         this.registry.createType('Hash', block),
         this._formatStorageSet(params[0] as Vec<StorageKey>, changes)
       ]);

packages/rpc-core/src/rxjs/refCountDelay.ts

@@ -2,7 +2,7 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { asapScheduler, ConnectableObservable, MonoTypeOperatorFunction, Observable, Subscription } from 'rxjs';
+import { asapScheduler, ConnectableObservable, MonoTypeOperatorFunction, Observable, Subscription, TeardownLogic } from 'rxjs';
 
 const DELAY = 1750;
 
@@ -11,7 +11,7 @@ function refCountDelayInner <T> (source: Observable<T>): Observable<T> {
   // state: 0 = disconnected, 1 = disconnecting, 2 = connecting, 3 = connected
   let [state, refCount, connection, scheduler] = [0, 0, Subscription.EMPTY, Subscription.EMPTY];
 
-  return new Observable((ob) => {
+  return new Observable((ob): TeardownLogic => {
     source.subscribe(ob);
 
     if (refCount++ === 0) {
@@ -27,12 +27,14 @@ function refCountDelayInner <T> (source: Observable<T>): Observable<T> {
     return (): void => {
       if (--refCount === 0) {
         if (state === 2) {
-          state = 0; scheduler.unsubscribe();
+          state = 0;
+          scheduler.unsubscribe();
         } else {
           // state === 3
           state = 1;
           scheduler = asapScheduler.schedule((): void => {
-            state = 0; connection.unsubscribe();
+            state = 0;
+            connection.unsubscribe();
           }, DELAY);
         }
       }

packages/rpc-provider/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/rpc-provider",
-  "version": "1.19.1",
+  "version": "1.21.1",
   "description": "Transport providers for the API",
   "main": "index.js",
   "keywords": [
@@ -26,18 +26,18 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/rpc-provider#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.2",
-    "@polkadot/metadata": "1.19.1",
-    "@polkadot/types": "1.19.1",
-    "@polkadot/util": "^2.14.1",
-    "@polkadot/util-crypto": "^2.14.1",
+    "@babel/runtime": "^7.10.3",
+    "@polkadot/metadata": "1.21.1",
+    "@polkadot/types": "1.21.1",
+    "@polkadot/util": "^2.15.1",
+    "@polkadot/util-crypto": "^2.15.1",
     "bn.js": "^5.1.2",
     "eventemitter3": "^4.0.4",
     "isomorphic-fetch": "^2.2.1",
     "websocket": "^1.0.31"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^2.14.1",
+    "@polkadot/keyring": "^2.15.1",
     "mock-socket": "^9.0.3",
     "nock": "^12.0.3"
   }

packages/rpc-provider/src/types.ts

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

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

@@ -247,8 +247,8 @@ export default class WsProvider implements WSProviderInterface {
    * })
    * ```
    */
-  public async subscribe (type: string, method: string, params: any[], callback: ProviderInterfaceCallback): Promise<number> {
-    const id = await this.send(method, params, { callback, type }) as Promise<number>;
+  public async subscribe (type: string, method: string, params: any[], callback: ProviderInterfaceCallback): Promise<number | string> {
+    const id = await this.send(method, params, { callback, type }) as Promise<number | string>;
 
     return id;
   }
@@ -256,7 +256,7 @@ export default class WsProvider implements WSProviderInterface {
   /**
    * @summary Allows unsubscribing to subscriptions made with [[subscribe]].
    */
-  public async unsubscribe (type: string, method: string, id: number): Promise<boolean> {
+  public async unsubscribe (type: string, method: string, id: number | string): Promise<boolean> {
     const subscription = `${type}::${id}`;
 
     // FIXME This now could happen with re-subscriptions. The issue is that with a re-sub

packages/typegen/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/typegen",
-  "version": "1.19.1",
+  "version": "1.21.1",
   "description": "Type generation scripts",
   "main": "index.js",
   "bin": {
@@ -33,14 +33,14 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/typegen#readme",
   "dependencies": {
-    "@babel/core": "^7.10.2",
-    "@babel/register": "^7.10.1",
-    "@babel/runtime": "^7.10.2",
-    "@polkadot/api": "1.19.1",
-    "@polkadot/metadata": "1.19.1",
-    "@polkadot/rpc-provider": "1.19.1",
-    "@polkadot/types": "1.19.1",
-    "@polkadot/util": "^2.14.1",
+    "@babel/core": "^7.10.3",
+    "@babel/register": "^7.10.3",
+    "@babel/runtime": "^7.10.3",
+    "@polkadot/api": "1.21.1",
+    "@polkadot/metadata": "1.21.1",
+    "@polkadot/rpc-provider": "1.21.1",
+    "@polkadot/types": "1.21.1",
+    "@polkadot/util": "^2.15.1",
     "handlebars": "^4.7.6",
     "websocket": "^1.0.31",
     "yargs": "^15.3.1"

packages/types-known/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/types-known",
-  "version": "1.19.1",
+  "version": "1.21.1",
   "description": "A JavaScript wrapper for the Polkadot JsonRPC interface",
   "main": "index.js",
   "keywords": [
@@ -26,9 +26,9 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/types-known#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.2",
-    "@polkadot/types": "1.19.1",
-    "@polkadot/util": "^2.14.1",
+    "@babel/runtime": "^7.10.3",
+    "@polkadot/types": "1.21.1",
+    "@polkadot/util": "^2.15.1",
     "bn.js": "^5.1.2"
   },
   "devDependencies": {

packages/types-known/src/modules.ts

@@ -6,8 +6,10 @@ import { OverrideModuleType } from '@polkadot/types/types';
 
 // type overrides for modules (where duplication between modules exist)
 const typesModules: Record<string, OverrideModuleType> = {
+  babe: {
+    EquivocationProof: 'BabeEquivocationProof'
+  },
   balances: {
-    Releases: 'ReleasesBalances',
     Status: 'BalanceStatus'
   },
   contract: { // old metadata & naming
@@ -17,8 +19,9 @@ const typesModules: Record<string, OverrideModuleType> = {
   contracts: {
     StorageKey: 'ContractStorageKey'
   },
-  democracy: {
-    Releases: 'ReleasesDemocracy'
+  grandpa: {
+    Equivocation: 'GrandpaEquivocation',
+    EquivocationProof: 'GrandpaEquivocationProof'
   },
   identity: {
     Judgement: 'IdentityJudgement'
@@ -31,8 +34,7 @@ const typesModules: Record<string, OverrideModuleType> = {
     Vote: 'SocietyVote'
   },
   staking: {
-    Compact: 'CompactAssignments',
-    Releases: 'ReleasesStaking'
+    Compact: 'CompactAssignments'
   },
   treasury: {
     Proposal: 'TreasuryProposal'

packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/types",
-  "version": "1.19.1",
+  "version": "1.21.1",
   "description": "Implementation of the Parity codec",
   "main": "index.js",
   "keywords": [
@@ -26,17 +26,17 @@
   },
   "homepage": "https://github.com/polkadot-js/api/tree/master/packages/types#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.2",
-    "@polkadot/metadata": "1.19.1",
-    "@polkadot/util": "^2.14.1",
-    "@polkadot/util-crypto": "^2.14.1",
+    "@babel/runtime": "^7.10.3",
+    "@polkadot/metadata": "1.21.1",
+    "@polkadot/util": "^2.15.1",
+    "@polkadot/util-crypto": "^2.15.1",
     "@types/bn.js": "^4.11.6",
     "bn.js": "^5.1.2",
     "memoizee": "^0.4.14",
     "rxjs": "^6.5.5"
   },
   "devDependencies": {
-    "@polkadot/keyring": "^2.14.1",
+    "@polkadot/keyring": "^2.15.1",
     "@types/memoizee": "^0.4.4"
   }
 }

packages/types/src/augment/registry.ts

@@ -7,21 +7,21 @@ import { BlockAttestations, IncludedBlocks, MoreAttestations } from '@polkadot/t
 import { RawAuraPreDigest } from '@polkadot/types/interfaces/aura';
 import { ExtrinsicOrHash, ExtrinsicStatus } from '@polkadot/types/interfaces/author';
 import { UncleEntryItem } from '@polkadot/types/interfaces/authorship';
-import { AllowedSlots, BabeAuthorityWeight, BabeBlockWeight, BabeWeight, EpochAuthorship, MaybeRandomness, MaybeVrf, NextConfigDescriptor, NextConfigDescriptorV1, Randomness, RawBabePreDigest, RawBabePreDigestCompat, RawBabePreDigestPrimary, RawBabePreDigestPrimaryTo159, RawBabePreDigestSecondaryPlain, RawBabePreDigestSecondaryTo159, RawBabePreDigestSecondaryVRF, RawBabePreDigestTo159, SlotNumber, VrfData, VrfOutput, VrfProof } from '@polkadot/types/interfaces/babe';
-import { AccountData, BalanceLock, BalanceLockTo212, BalanceStatus, Reasons, ReleasesBalances, VestingSchedule, WithdrawReasons } from '@polkadot/types/interfaces/balances';
+import { AllowedSlots, BabeAuthorityWeight, BabeBlockWeight, BabeEquivocationProof, BabeWeight, EpochAuthorship, MaybeRandomness, MaybeVrf, NextConfigDescriptor, NextConfigDescriptorV1, Randomness, RawBabePreDigest, RawBabePreDigestCompat, RawBabePreDigestPrimary, RawBabePreDigestPrimaryTo159, RawBabePreDigestSecondaryPlain, RawBabePreDigestSecondaryTo159, RawBabePreDigestSecondaryVRF, RawBabePreDigestTo159, SlotNumber, VrfData, VrfOutput, VrfProof } from '@polkadot/types/interfaces/babe';
+import { AccountData, BalanceLock, BalanceLockTo212, BalanceStatus, Reasons, VestingSchedule, WithdrawReasons } from '@polkadot/types/interfaces/balances';
 import { BlockHash } from '@polkadot/types/interfaces/chain';
 import { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate';
 import { EthereumAddress, StatementKind } from '@polkadot/types/interfaces/claims';
 import { MemberCount, ProposalIndex, Votes, VotesTo230 } from '@polkadot/types/interfaces/collective';
 import { AuthorityId, RawVRFOutput } from '@polkadot/types/interfaces/consensus';
 import { AliveContractInfo, CodeHash, ContractCallRequest, ContractExecResult, ContractExecResultSuccess, ContractInfo, ContractStorageKey, Gas, PrefabWasmModule, PrefabWasmModuleReserved, Schedule, ScheduleTo212, SeedOf, TombstoneContractInfo, TrieId } from '@polkadot/types/interfaces/contracts';
-import { AccountVote, AccountVoteSplit, AccountVoteStandard, Conviction, Delegations, PreimageStatus, PreimageStatusAvailable, PriorLock, PropIndex, Proposal, ProxyState, ReferendumIndex, ReferendumInfo, ReferendumInfoFinished, ReferendumInfoTo239, ReferendumStatus, ReleasesDemocracy, Tally, Voting, VotingDelegating, VotingDirect, VotingDirectVote } from '@polkadot/types/interfaces/democracy';
+import { AccountVote, AccountVoteSplit, AccountVoteStandard, Conviction, Delegations, PreimageStatus, PreimageStatusAvailable, PriorLock, PropIndex, Proposal, ProxyState, ReferendumIndex, ReferendumInfo, ReferendumInfoFinished, ReferendumInfoTo239, ReferendumStatus, Tally, Voting, VotingDelegating, VotingDirect, VotingDirectVote } from '@polkadot/types/interfaces/democracy';
 import { ApprovalFlag, DefunctVoter, Renouncing, SetIndex, Vote, VoteIndex, VoteThreshold, VoterInfo } from '@polkadot/types/interfaces/elections';
 import { CreatedBlock, ImportedAux } from '@polkadot/types/interfaces/engine';
 import { Account, Log, Vicinity } from '@polkadot/types/interfaces/evm';
 import { EcdsaSignature, Ed25519Signature, Extrinsic, ExtrinsicEra, ExtrinsicPayload, ExtrinsicPayloadUnknown, ExtrinsicPayloadV1, ExtrinsicPayloadV2, ExtrinsicPayloadV3, ExtrinsicPayloadV4, ExtrinsicSignatureV1, ExtrinsicSignatureV2, ExtrinsicSignatureV3, ExtrinsicSignatureV4, ExtrinsicUnknown, ExtrinsicV1, ExtrinsicV2, ExtrinsicV3, ExtrinsicV4, ImmortalEra, MortalEra, MultiSignature, Signature, SignerPayload, Sr25519Signature } from '@polkadot/types/interfaces/extrinsics';
 import { AssetOptions, Owner, PermissionLatest, PermissionVersions, PermissionsV1 } from '@polkadot/types/interfaces/genericAsset';
-import { AuthorityIndex, AuthorityList, AuthorityWeight, Equivocation, EquivocationProof, GrandpaEquivocation, GrandpaPrevote, KeyOwnerProof, NextAuthority, PendingPause, PendingResume, Precommits, Prevotes, ReportedRoundStates, RoundState, SetId, StoredPendingChange, StoredState } from '@polkadot/types/interfaces/grandpa';
+import { AuthorityIndex, AuthorityList, AuthorityWeight, GrandpaEquivocation, GrandpaEquivocationProof, GrandpaEquivocationValue, GrandpaPrevote, KeyOwnerProof, NextAuthority, PendingPause, PendingResume, Precommits, Prevotes, ReportedRoundStates, RoundState, SetId, StoredPendingChange, StoredState } from '@polkadot/types/interfaces/grandpa';
 import { IdentityFields, IdentityInfo, IdentityInfoAdditional, IdentityJudgement, RegistrarIndex, RegistrarInfo, Registration, RegistrationJudgement } from '@polkadot/types/interfaces/identity';
 import { AuthIndex, AuthoritySignature, Heartbeat, HeartbeatTo244, OpaqueMultiaddr, OpaqueNetworkState, OpaquePeerId } from '@polkadot/types/interfaces/imOnline';
 import { CallMetadataV0, DoubleMapTypeLatest, DoubleMapTypeV10, DoubleMapTypeV11, DoubleMapTypeV3, DoubleMapTypeV4, DoubleMapTypeV5, DoubleMapTypeV6, DoubleMapTypeV7, DoubleMapTypeV8, DoubleMapTypeV9, ErrorMetadataV10, ErrorMetadataV11, ErrorMetadataV8, ErrorMetadataV9, EventMetadataLatest, EventMetadataV0, EventMetadataV1, EventMetadataV10, EventMetadataV11, EventMetadataV2, EventMetadataV3, EventMetadataV4, EventMetadataV5, EventMetadataV6, EventMetadataV7, EventMetadataV8, EventMetadataV9, ExtrinsicMetadataLatest, ExtrinsicMetadataV11, FunctionArgumentMetadataLatest, FunctionArgumentMetadataV0, FunctionArgumentMetadataV1, FunctionArgumentMetadataV10, FunctionArgumentMetadataV11, FunctionArgumentMetadataV2, FunctionArgumentMetadataV3, FunctionArgumentMetadataV4, FunctionArgumentMetadataV5, FunctionArgumentMetadataV6, FunctionArgumentMetadataV7, FunctionArgumentMetadataV8, FunctionArgumentMetadataV9, FunctionMetadataLatest, FunctionMetadataV0, FunctionMetadataV1, FunctionMetadataV10, FunctionMetadataV11, FunctionMetadataV2, FunctionMetadataV3, FunctionMetadataV4, FunctionMetadataV5, FunctionMetadataV6, FunctionMetadataV7, FunctionMetadataV8, FunctionMetadataV9, MapTypeLatest, MapTypeV0, MapTypeV10, MapTypeV11, MapTypeV2, MapTypeV3, MapTypeV4, MapTypeV5, MapTypeV6, MapTypeV7, MapTypeV8, MapTypeV9, MetadataAll, MetadataLatest, MetadataV0, MetadataV1, MetadataV10, MetadataV11, MetadataV2, MetadataV3, MetadataV4, MetadataV5, MetadataV6, MetadataV7, MetadataV8, MetadataV9, ModuleConstantMetadataLatest, ModuleConstantMetadataV10, ModuleConstantMetadataV11, ModuleConstantMetadataV6, ModuleConstantMetadataV7, ModuleConstantMetadataV8, ModuleConstantMetadataV9, ModuleMetadataLatest, ModuleMetadataV0, ModuleMetadataV1, ModuleMetadataV10, ModuleMetadataV11, ModuleMetadataV2, ModuleMetadataV3, ModuleMetadataV4, ModuleMetadataV5, ModuleMetadataV6, ModuleMetadataV7, ModuleMetadataV8, ModuleMetadataV9, OuterDispatchCallV0, OuterDispatchMetadataV0, OuterEventEventMetadataEventsV0, OuterEventEventMetadataV0, OuterEventMetadataV0, PlainTypeLatest, PlainTypeV0, PlainTypeV10, PlainTypeV11, PlainTypeV2, PlainTypeV3, PlainTypeV4, PlainTypeV5, PlainTypeV6, PlainTypeV7, PlainTypeV8, PlainTypeV9, RuntimeModuleMetadataV0, StorageEntryMetadataLatest, StorageEntryMetadataV10, StorageEntryMetadataV11, StorageEntryMetadataV6, StorageEntryMetadataV7, StorageEntryMetadataV8, StorageEntryMetadataV9, StorageEntryModifierLatest, StorageEntryModifierV10, StorageEntryModifierV11, StorageEntryModifierV6, StorageEntryModifierV7, StorageEntryModifierV8, StorageEntryModifierV9, StorageEntryTypeLatest, StorageEntryTypeV10, StorageEntryTypeV11, StorageEntryTypeV6, StorageEntryTypeV7, StorageEntryTypeV8, StorageEntryTypeV9, StorageFunctionMetadataV0, StorageFunctionMetadataV1, StorageFunctionMetadataV2, StorageFunctionMetadataV3, StorageFunctionMetadataV4, StorageFunctionMetadataV5, StorageFunctionModifierV0, StorageFunctionModifierV1, StorageFunctionModifierV2, StorageFunctionModifierV3, StorageFunctionModifierV4, StorageFunctionModifierV5, StorageFunctionTypeV0, StorageFunctionTypeV1, StorageFunctionTypeV2, StorageFunctionTypeV3, StorageFunctionTypeV4, StorageFunctionTypeV5, StorageHasher, StorageHasherV10, StorageHasherV11, StorageHasherV4, StorageHasherV5, StorageHasherV6, StorageHasherV7, StorageHasherV8, StorageHasherV9, StorageMetadataLatest, StorageMetadataV0, StorageMetadataV10, StorageMetadataV11, StorageMetadataV7, StorageMetadataV8, StorageMetadataV9 } from '@polkadot/types/interfaces/metadata';
@@ -31,14 +31,14 @@ import { AbridgedCandidateReceipt, AttestedCandidate, AuctionIndex, Bidder, Cand
 import { RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
 import { ActiveRecovery, RecoveryConfig } from '@polkadot/types/interfaces/recovery';
 import { RpcMethods } from '@polkadot/types/interfaces/rpc';
-import { AccountId, AccountIdOf, AccountIndex, Address, AssetId, Balance, BalanceOf, Block, BlockNumber, Call, ChangesTrieConfiguration, Consensus, ConsensusEngineId, Digest, DigestItem, DispatchClass, DispatchInfo, DispatchInfoTo190, DispatchInfoTo244, ExtrinsicsWeight, Fixed128, Fixed64, H160, H256, H512, Hash, Header, Index, Justification, KeyTypeId, KeyValue, LockIdentifier, LookupSource, LookupTarget, ModuleId, Moment, Origin, Pays, Perbill, Percent, Permill, Perquintill, Phantom, PhantomData, PreRuntime, ProxyType, RuntimeDbWeight, Seal, SealV0, SignedBlock, StorageData, ValidatorId, Weight, WeightMultiplier } from '@polkadot/types/interfaces/runtime';
+import { AccountId, AccountIdOf, AccountIndex, Address, AssetId, Balance, BalanceOf, Block, BlockNumber, Call, ChangesTrieConfiguration, Consensus, ConsensusEngineId, Digest, DigestItem, ExtrinsicsWeight, Fixed128, Fixed64, H160, H256, H512, Hash, Header, Index, Justification, KeyTypeId, KeyValue, LockIdentifier, LookupSource, LookupTarget, ModuleId, Moment, Origin, Pays, Perbill, Percent, Permill, Perquintill, Phantom, PhantomData, PreRuntime, ProxyType, Releases, RuntimeDbWeight, Seal, SealV0, SignedBlock, StorageData, ValidatorId, Weight, WeightMultiplier } from '@polkadot/types/interfaces/runtime';
 import { Period, Priority, SchedulePeriod, SchedulePriority, Scheduled, TaskAddress } from '@polkadot/types/interfaces/scheduler';
 import { FullIdentification, IdentificationTuple, Keys, MembershipProof, SessionIndex, SessionKeys1, SessionKeys2, SessionKeys3, SessionKeys4, SessionKeys5, SessionKeys6, ValidatorCount } from '@polkadot/types/interfaces/session';
 import { Bid, BidKind, SocietyJudgement, SocietyVote, StrikeCount, VouchingStatus } from '@polkadot/types/interfaces/society';
-import { ActiveEraInfo, CompactAssignments, CompactScore, ElectionCompute, ElectionResult, ElectionScore, ElectionSize, ElectionStatus, EraIndex, EraPoints, EraRewardPoints, EraRewards, Exposure, Forcing, IndividualExposure, KeyType, MomentOf, Nominations, NominatorIndex, OffchainAccuracy, PerU16, PhragmenScore, Points, ReleasesStaking, RewardDestination, RewardPoint, SlashJournalEntry, SlashingSpans, SlashingSpansTo204, SpanIndex, SpanRecord, StakingLedger, StakingLedgerTo223, StakingLedgerTo240, UnappliedSlash, UnappliedSlashOther, UnlockChunk, ValidatorIndex, ValidatorPrefs, ValidatorPrefsTo145, ValidatorPrefsTo196 } from '@polkadot/types/interfaces/staking';
+import { ActiveEraInfo, CompactAssignments, CompactScore, ElectionCompute, ElectionResult, ElectionScore, ElectionSize, ElectionStatus, EraIndex, EraPoints, EraRewardPoints, EraRewards, Exposure, Forcing, IndividualExposure, KeyType, MomentOf, Nominations, NominatorIndex, OffchainAccuracy, PerU16, PhragmenScore, Points, RewardDestination, RewardPoint, SlashJournalEntry, SlashingSpans, SlashingSpansTo204, SpanIndex, SpanRecord, StakingLedger, StakingLedgerTo223, StakingLedgerTo240, UnappliedSlash, UnappliedSlashOther, UnlockChunk, ValidatorIndex, ValidatorPrefs, ValidatorPrefsTo145, ValidatorPrefsTo196 } from '@polkadot/types/interfaces/staking';
 import { ApiId, KeyValueOption, ReadProof, RuntimeVersion, RuntimeVersionApi, StorageChangeSet } from '@polkadot/types/interfaces/state';
 import { WeightToFeeCoefficient } from '@polkadot/types/interfaces/support';
-import { AccountInfo, ChainProperties, ChainType, DigestOf, DispatchError, DispatchErrorModule, DispatchErrorTo198, DispatchResult, DispatchResultOf, DispatchResultTo198, Event, EventId, EventIndex, EventRecord, EventRecordTo76, Health, Key, LastRuntimeUpgradeInfo, NetworkState, NetworkStatePeerset, NetworkStatePeersetInfo, NodeRole, NotConnectedPeer, Peer, PeerEndpoint, PeerEndpointAddr, PeerInfo, PeerPing, Phase, RefCount } from '@polkadot/types/interfaces/system';
+import { AccountInfo, ApplyExtrinsicResult, ChainProperties, ChainType, DigestOf, DispatchClass, DispatchError, DispatchErrorModule, DispatchErrorTo198, DispatchInfo, DispatchInfoTo190, DispatchInfoTo244, DispatchOutcome, DispatchResult, DispatchResultOf, DispatchResultTo198, Event, EventId, EventIndex, EventRecord, EventRecordTo76, Health, InvalidTransaction, Key, LastRuntimeUpgradeInfo, NetworkState, NetworkStatePeerset, NetworkStatePeersetInfo, NodeRole, NotConnectedPeer, Peer, PeerEndpoint, PeerEndpointAddr, PeerInfo, PeerPing, Phase, RefCount, TransactionValidityError, UnknownTransaction } from '@polkadot/types/interfaces/system';
 import { OpenTip, OpenTipFinder, OpenTipTip, TreasuryProposal } from '@polkadot/types/interfaces/treasury';
 import { Multiplier } from '@polkadot/types/interfaces/txpayment';
 import { CallHash, Multisig, Timepoint } from '@polkadot/types/interfaces/utility';
@@ -171,18 +171,6 @@ declare module '@polkadot/types/types/registry' {
     DigestItem: DigestItem;
     'Option<DigestItem>': Option<DigestItem>;
     'Vec<DigestItem>': Vec<DigestItem>;
-    DispatchClass: DispatchClass;
-    'Option<DispatchClass>': Option<DispatchClass>;
-    'Vec<DispatchClass>': Vec<DispatchClass>;
-    DispatchInfo: DispatchInfo;
-    'Option<DispatchInfo>': Option<DispatchInfo>;
-    'Vec<DispatchInfo>': Vec<DispatchInfo>;
-    DispatchInfoTo190: DispatchInfoTo190;
-    'Option<DispatchInfoTo190>': Option<DispatchInfoTo190>;
-    'Vec<DispatchInfoTo190>': Vec<DispatchInfoTo190>;
-    DispatchInfoTo244: DispatchInfoTo244;
-    'Option<DispatchInfoTo244>': Option<DispatchInfoTo244>;
-    'Vec<DispatchInfoTo244>': Vec<DispatchInfoTo244>;
     ExtrinsicsWeight: ExtrinsicsWeight;
     'Option<ExtrinsicsWeight>': Option<ExtrinsicsWeight>;
     'Vec<ExtrinsicsWeight>': Vec<ExtrinsicsWeight>;
@@ -268,6 +256,9 @@ declare module '@polkadot/types/types/registry' {
     ProxyType: ProxyType;
     'Option<ProxyType>': Option<ProxyType>;
     'Vec<ProxyType>': Vec<ProxyType>;
+    Releases: Releases;
+    'Option<Releases>': Option<Releases>;
+    'Vec<Releases>': Vec<Releases>;
     RuntimeDbWeight: RuntimeDbWeight;
     'Option<RuntimeDbWeight>': Option<RuntimeDbWeight>;
     'Vec<RuntimeDbWeight>': Vec<RuntimeDbWeight>;
@@ -316,16 +307,19 @@ declare module '@polkadot/types/types/registry' {
     'Compact<BabeBlockWeight>': Compact<BabeBlockWeight>;
     'Option<BabeBlockWeight>': Option<BabeBlockWeight>;
     'Vec<BabeBlockWeight>': Vec<BabeBlockWeight>;
+    BabeEquivocationProof: BabeEquivocationProof;
+    'Option<BabeEquivocationProof>': Option<BabeEquivocationProof>;
+    'Vec<BabeEquivocationProof>': Vec<BabeEquivocationProof>;
+    BabeWeight: BabeWeight;
+    'Compact<BabeWeight>': Compact<BabeWeight>;
+    'Option<BabeWeight>': Option<BabeWeight>;
+    'Vec<BabeWeight>': Vec<BabeWeight>;
     MaybeRandomness: MaybeRandomness;
     'Option<MaybeRandomness>': Option<MaybeRandomness>;
     'Vec<MaybeRandomness>': Vec<MaybeRandomness>;
     MaybeVrf: MaybeVrf;
     'Option<MaybeVrf>': Option<MaybeVrf>;
     'Vec<MaybeVrf>': Vec<MaybeVrf>;
-    BabeWeight: BabeWeight;
-    'Compact<BabeWeight>': Compact<BabeWeight>;
-    'Option<BabeWeight>': Option<BabeWeight>;
-    'Vec<BabeWeight>': Vec<BabeWeight>;
     EpochAuthorship: EpochAuthorship;
     'Option<EpochAuthorship>': Option<EpochAuthorship>;
     'Vec<EpochAuthorship>': Vec<EpochAuthorship>;
@@ -387,9 +381,6 @@ declare module '@polkadot/types/types/registry' {
     BalanceStatus: BalanceStatus;
     'Option<BalanceStatus>': Option<BalanceStatus>;
     'Vec<BalanceStatus>': Vec<BalanceStatus>;
-    ReleasesBalances: ReleasesBalances;
-    'Option<ReleasesBalances>': Option<ReleasesBalances>;
-    'Vec<ReleasesBalances>': Vec<ReleasesBalances>;
     Reasons: Reasons;
     'Option<Reasons>': Option<Reasons>;
     'Vec<Reasons>': Vec<Reasons>;
@@ -515,9 +506,6 @@ declare module '@polkadot/types/types/registry' {
     ReferendumStatus: ReferendumStatus;
     'Option<ReferendumStatus>': Option<ReferendumStatus>;
     'Vec<ReferendumStatus>': Vec<ReferendumStatus>;
-    ReleasesDemocracy: ReleasesDemocracy;
-    'Option<ReleasesDemocracy>': Option<ReleasesDemocracy>;
-    'Vec<ReleasesDemocracy>': Vec<ReleasesDemocracy>;
     Tally: Tally;
     'Option<Tally>': Option<Tally>;
     'Vec<Tally>': Vec<Tally>;
@@ -676,15 +664,15 @@ declare module '@polkadot/types/types/registry' {
     'Compact<AuthorityWeight>': Compact<AuthorityWeight>;
     'Option<AuthorityWeight>': Option<AuthorityWeight>;
     'Vec<AuthorityWeight>': Vec<AuthorityWeight>;
-    Equivocation: Equivocation;
-    'Option<Equivocation>': Option<Equivocation>;
-    'Vec<Equivocation>': Vec<Equivocation>;
-    EquivocationProof: EquivocationProof;
-    'Option<EquivocationProof>': Option<EquivocationProof>;
-    'Vec<EquivocationProof>': Vec<EquivocationProof>;
     GrandpaEquivocation: GrandpaEquivocation;
     'Option<GrandpaEquivocation>': Option<GrandpaEquivocation>;
     'Vec<GrandpaEquivocation>': Vec<GrandpaEquivocation>;
+    GrandpaEquivocationProof: GrandpaEquivocationProof;
+    'Option<GrandpaEquivocationProof>': Option<GrandpaEquivocationProof>;
+    'Vec<GrandpaEquivocationProof>': Vec<GrandpaEquivocationProof>;
+    GrandpaEquivocationValue: GrandpaEquivocationValue;
+    'Option<GrandpaEquivocationValue>': Option<GrandpaEquivocationValue>;
+    'Vec<GrandpaEquivocationValue>': Vec<GrandpaEquivocationValue>;
     GrandpaPrevote: GrandpaPrevote;
     'Option<GrandpaPrevote>': Option<GrandpaPrevote>;
     'Vec<GrandpaPrevote>': Vec<GrandpaPrevote>;
@@ -945,9 +933,6 @@ declare module '@polkadot/types/types/registry' {
     PhragmenScore: PhragmenScore;
     'Option<PhragmenScore>': Option<PhragmenScore>;
     'Vec<PhragmenScore>': Vec<PhragmenScore>;
-    ReleasesStaking: ReleasesStaking;
-    'Option<ReleasesStaking>': Option<ReleasesStaking>;
-    'Vec<ReleasesStaking>': Vec<ReleasesStaking>;
     RewardDestination: RewardDestination;
     'Option<RewardDestination>': Option<RewardDestination>;
     'Vec<RewardDestination>': Vec<RewardDestination>;
@@ -1008,6 +993,9 @@ declare module '@polkadot/types/types/registry' {
     AccountInfo: AccountInfo;
     'Option<AccountInfo>': Option<AccountInfo>;
     'Vec<AccountInfo>': Vec<AccountInfo>;
+    ApplyExtrinsicResult: ApplyExtrinsicResult;
+    'Option<ApplyExtrinsicResult>': Option<ApplyExtrinsicResult>;
+    'Vec<ApplyExtrinsicResult>': Vec<ApplyExtrinsicResult>;
     ChainProperties: ChainProperties;
     'Option<ChainProperties>': Option<ChainProperties>;
     'Vec<ChainProperties>': Vec<ChainProperties>;
@@ -1017,6 +1005,9 @@ declare module '@polkadot/types/types/registry' {
     DigestOf: DigestOf;
     'Option<DigestOf>': Option<DigestOf>;
     'Vec<DigestOf>': Vec<DigestOf>;
+    DispatchClass: DispatchClass;
+    'Option<DispatchClass>': Option<DispatchClass>;
+    'Vec<DispatchClass>': Vec<DispatchClass>;
     DispatchError: DispatchError;
     'Option<DispatchError>': Option<DispatchError>;
     'Vec<DispatchError>': Vec<DispatchError>;
@@ -1026,6 +1017,18 @@ declare module '@polkadot/types/types/registry' {
     DispatchErrorTo198: DispatchErrorTo198;
     'Option<DispatchErrorTo198>': Option<DispatchErrorTo198>;
     'Vec<DispatchErrorTo198>': Vec<DispatchErrorTo198>;
+    DispatchInfo: DispatchInfo;
+    'Option<DispatchInfo>': Option<DispatchInfo>;
+    'Vec<DispatchInfo>': Vec<DispatchInfo>;
+    DispatchInfoTo190: DispatchInfoTo190;
+    'Option<DispatchInfoTo190>': Option<DispatchInfoTo190>;
+    'Vec<DispatchInfoTo190>': Vec<DispatchInfoTo190>;
+    DispatchInfoTo244: DispatchInfoTo244;
+    'Option<DispatchInfoTo244>': Option<DispatchInfoTo244>;
+    'Vec<DispatchInfoTo244>': Vec<DispatchInfoTo244>;
+    DispatchOutcome: DispatchOutcome;
+    'Option<DispatchOutcome>': Option<DispatchOutcome>;
+    'Vec<DispatchOutcome>': Vec<DispatchOutcome>;
     DispatchResult: DispatchResult;
     'Option<DispatchResult>': Option<DispatchResult>;
     'Vec<DispatchResult>': Vec<DispatchResult>;
@@ -1054,6 +1057,9 @@ declare module '@polkadot/types/types/registry' {
     Health: Health;
     'Option<Health>': Option<Health>;
     'Vec<Health>': Vec<Health>;
+    InvalidTransaction: InvalidTransaction;
+    'Option<InvalidTransaction>': Option<InvalidTransaction>;
+    'Vec<InvalidTransaction>': Vec<InvalidTransaction>;
     Key: Key;
     'Option<Key>': Option<Key>;
     'Vec<Key>': Vec<Key>;
@@ -1097,6 +1103,12 @@ declare module '@polkadot/types/types/registry' {
     'Compact<RefCount>': Compact<RefCount>;
     'Option<RefCount>': Option<RefCount>;
     'Vec<RefCount>': Vec<RefCount>;
+    TransactionValidityError: TransactionValidityError;
+    'Option<TransactionValidityError>': Option<TransactionValidityError>;
+    'Vec<TransactionValidityError>': Vec<TransactionValidityError>;
+    UnknownTransaction: UnknownTransaction;
+    'Option<UnknownTransaction>': Option<UnknownTransaction>;
+    'Vec<UnknownTransaction>': Vec<UnknownTransaction>;
     OpenTip: OpenTip;
     'Option<OpenTip>': Option<OpenTip>;
     'Vec<OpenTip>': Vec<OpenTip>;

packages/types/src/create/registry.ts

@@ -153,7 +153,7 @@ export class TypeRegistry implements Registry {
   /**
    * @description Creates an instance of a type as registered
    */
-  public createType <K extends keyof InterfaceTypes> (type: K, ...params: any[]): InterfaceTypes[K] {
+  public createType <K extends keyof InterfaceTypes> (type: K, ...params: unknown[]): InterfaceTypes[K] {
     return createType(this, type, ...params);
   }
 

packages/types/src/extrinsic/signedExtensions/emptyCheck.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2020 @polkadot/types authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+export default {
+  extra: {},
+  types: {}
+};

packages/types/src/extrinsic/signedExtensions/polkadot.ts

@@ -4,29 +4,13 @@
 
 import { ExtDef } from './types';
 
+import EmptyCheck from './emptyCheck';
+
 export default {
-  LimitParathreadCommits: {
-    extra: {},
-    types: {}
-  },
-  OnlyStakingAndClaims: {
-    extra: {},
-    types: {}
-  },
-  PrevalidateAttests: {
-    extra: {},
-    types: {}
-  },
-  RestrictFunctionality: {
-    extra: {},
-    types: {}
-  },
-  TransactionCallFilter: {
-    extra: {},
-    types: {}
-  },
-  ValidateDoubleVoteReports: {
-    extra: {},
-    types: {}
-  }
+  LimitParathreadCommits: EmptyCheck,
+  OnlyStakingAndClaims: EmptyCheck,
+  PrevalidateAttests: EmptyCheck,
+  RestrictFunctionality: EmptyCheck,
+  TransactionCallFilter: EmptyCheck,
+  ValidateDoubleVoteReports: EmptyCheck
 } as ExtDef;

packages/types/src/extrinsic/signedExtensions/substrate.ts

@@ -4,6 +4,17 @@
 
 import { ExtDef } from './types';
 
+import EmptyCheck from './emptyCheck';
+
+const CheckMortality = {
+  extra: {
+    blockHash: 'Hash'
+  },
+  types: {
+    era: 'ExtrinsicEra'
+  }
+};
+
 export default {
   ChargeTransactionPayment: {
     extra: {},
@@ -11,24 +22,15 @@ export default {
       tip: 'Compact<Balance>'
     }
   },
-  CheckBlockGasLimit: {
-    extra: {},
-    types: {}
-  },
-  CheckEra: {
-    extra: {
-      blockHash: 'Hash'
-    },
-    types: {
-      era: 'ExtrinsicEra'
-    }
-  },
+  CheckBlockGasLimit: EmptyCheck,
+  CheckEra: CheckMortality,
   CheckGenesis: {
     extra: {
       genesisHash: 'Hash'
     },
     types: {}
   },
+  CheckMortality,
   CheckNonce: {
     extra: {},
     types: {
@@ -53,16 +55,7 @@ export default {
     },
     types: {}
   },
-  CheckWeight: {
-    extra: {},
-    types: {}
-  },
-  LockStakingStatus: {
-    extra: {},
-    types: {}
-  },
-  ValidateEquivocationReport: {
-    extra: {},
-    types: {}
-  }
+  CheckWeight: EmptyCheck,
+  LockStakingStatus: EmptyCheck,
+  ValidateEquivocationReport: EmptyCheck
 } as ExtDef;

packages/types/src/interfaces/account/definitions.ts

@@ -1,25 +0,0 @@
-// Copyright 2017-2020 @polkadot/types authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-// order important in structs... :)
-/* eslint-disable sort-keys */
-
-import { Definitions } from '../../types';
-
-export default {
-  rpc: {
-    nextIndex: {
-      alias: ['system_accountNextIndex'],
-      description: 'Retrieves the next accountIndex as available on the node',
-      params: [
-        {
-          name: 'accountId',
-          type: 'AccountId'
-        }
-      ],
-      type: 'Index'
-    }
-  },
-  types: {}
-} as Definitions;

packages/types/src/interfaces/account/index.ts

@@ -1,4 +0,0 @@
-// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
-/* eslint-disable */
-
-export * from './types';

packages/types/src/interfaces/account/types.ts

@@ -1,4 +0,0 @@
-// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
-/* eslint-disable */
-
-export type PHANTOM_ACCOUNT = 'account';

packages/types/src/interfaces/babe/definitions.ts

@@ -21,10 +21,15 @@ export default {
     },
     BabeAuthorityWeight: 'u64',
     BabeBlockWeight: 'u32',
+    BabeEquivocationProof: {
+      offender: 'AuthorityId',
+      slotNumber: 'SlotNumber',
+      firstHeader: 'Header',
+      secondHeader: 'Header'
+    },
+    BabeWeight: 'u64',
     MaybeRandomness: 'Option<Randomness>',
     MaybeVrf: 'Option<VrfData>',
-    // TODO Remove as soon as merged and metadata static updated
-    BabeWeight: 'u64',
     EpochAuthorship: {
       primary: 'Vec<u64>',
       secondary: 'Vec<u64>'

packages/types/src/interfaces/babe/types.ts

@@ -4,7 +4,8 @@
 import { ITuple } from '@polkadot/types/types';
 import { Enum, Option, Struct, U8aFixed, Vec } from '@polkadot/types/codec';
 import { u32, u64 } from '@polkadot/types/primitive';
-import { Hash } from '@polkadot/types/interfaces/runtime';
+import { AuthorityId } from '@polkadot/types/interfaces/consensus';
+import { Hash, Header } from '@polkadot/types/interfaces/runtime';
 
 /** @name AllowedSlots */
 export interface AllowedSlots extends Enum {
@@ -19,6 +20,14 @@ export interface BabeAuthorityWeight extends u64 {}
 /** @name BabeBlockWeight */
 export interface BabeBlockWeight extends u32 {}
 
+/** @name BabeEquivocationProof */
+export interface BabeEquivocationProof extends Struct {
+  readonly offender: AuthorityId;
+  readonly slotNumber: SlotNumber;
+  readonly firstHeader: Header;
+  readonly secondHeader: Header;
+}
+
 /** @name BabeWeight */
 export interface BabeWeight extends u64 {}
 

packages/types/src/interfaces/balances/definitions.ts

@@ -30,9 +30,6 @@ export default {
     BalanceStatus: {
       _enum: ['Free', 'Reserved']
     },
-    ReleasesBalances: {
-      _enum: ['V1_0_0', 'V2_0_0']
-    },
     Reasons: {
       _enum: ['Fee', 'Misc', 'All']
     },

packages/types/src/interfaces/balances/types.ts

@@ -40,12 +40,6 @@ export interface Reasons extends Enum {
   readonly isAll: boolean;
 }
 
-/** @name ReleasesBalances */
-export interface ReleasesBalances extends Enum {
-  readonly isV100: boolean;
-  readonly isV200: boolean;
-}
-
 /** @name VestingSchedule */
 export interface VestingSchedule extends Struct {
   readonly offset: Balance;

packages/types/src/interfaces/definitions.ts

@@ -45,7 +45,6 @@ export { default as metadata } from './metadata/definitions';
 export { default as rpc } from './rpc/definitions';
 
 // rpc-only definitions
-export { default as account } from './account/definitions';
 export { default as author } from './author/definitions';
 export { default as chain } from './chain/definitions';
 export { default as childstate } from './childstate/definitions';

packages/types/src/interfaces/democracy/definitions.ts

@@ -96,9 +96,6 @@ export default {
       delay: 'BlockNumber',
       tally: 'Tally'
     },
-    ReleasesDemocracy: {
-      _enum: ['V1']
-    },
     Tally: {
       ayes: 'Balance',
       nays: 'Balance',

packages/types/src/interfaces/democracy/types.ts

@@ -112,11 +112,6 @@ export interface ReferendumStatus extends Struct {
   readonly tally: Tally;
 }
 
-/** @name ReleasesDemocracy */
-export interface ReleasesDemocracy extends Enum {
-  readonly isV1: boolean;
-}
-
 /** @name Tally */
 export interface Tally extends Struct {
   readonly ayes: Balance;

packages/types/src/interfaces/grandpa/definitions.ts

@@ -19,17 +19,17 @@ export default {
     AuthorityIndex: 'u64',
     AuthorityList: 'Vec<NextAuthority>',
     AuthorityWeight: 'u64',
-    Equivocation: {
+    GrandpaEquivocation: {
       _enum: {
-        Prevote: 'GrandpaEquivocation',
-        Precommit: 'GrandpaEquivocation'
+        Prevote: 'GrandpaEquivocationValue',
+        Precommit: 'GrandpaEquivocationValue'
       }
     },
-    EquivocationProof: {
+    GrandpaEquivocationProof: {
       setId: 'SetId',
-      equivocation: 'Equivocation'
+      equivocation: 'GrandpaEquivocation'
     },
-    GrandpaEquivocation: {
+    GrandpaEquivocationValue: {
       roundNumber: 'u64',
       identity: 'AuthorityId',
       first: '(GrandpaPrevote, AuthoritySignature)',

packages/types/src/interfaces/grandpa/types.ts

@@ -18,22 +18,22 @@ export interface AuthorityList extends Vec<NextAuthority> {}
 /** @name AuthorityWeight */
 export interface AuthorityWeight extends u64 {}
 
-/** @name Equivocation */
-export interface Equivocation extends Enum {
-  readonly isPrevote: boolean;
-  readonly asPrevote: GrandpaEquivocation;
-  readonly isPrecommit: boolean;
-  readonly asPrecommit: GrandpaEquivocation;
-}
-
-/** @name EquivocationProof */
-export interface EquivocationProof extends Struct {
-  readonly setId: SetId;
-  readonly equivocation: Equivocation;
-}
-
 /** @name GrandpaEquivocation */
-export interface GrandpaEquivocation extends Struct {
+export interface GrandpaEquivocation extends Enum {
+  readonly isPrevote: boolean;
+  readonly asPrevote: GrandpaEquivocationValue;
+  readonly isPrecommit: boolean;
+  readonly asPrecommit: GrandpaEquivocationValue;
+}
+
+/** @name GrandpaEquivocationProof */
+export interface GrandpaEquivocationProof extends Struct {
+  readonly setId: SetId;
+  readonly equivocation: GrandpaEquivocation;
+}
+
+/** @name GrandpaEquivocationValue */
+export interface GrandpaEquivocationValue extends Struct {
   readonly roundNumber: u64;
   readonly identity: AuthorityId;
   readonly first: ITuple<[GrandpaPrevote, AuthoritySignature]>;

packages/types/src/interfaces/payment/types.ts

@@ -2,7 +2,8 @@
 /* eslint-disable */
 
 import { Struct } from '@polkadot/types/codec';
-import { Balance, DispatchClass, Weight } from '@polkadot/types/interfaces/runtime';
+import { Balance, Weight } from '@polkadot/types/interfaces/runtime';
+import { DispatchClass } from '@polkadot/types/interfaces/system';
 
 /** @name RuntimeDispatchInfo */
 export interface RuntimeDispatchInfo extends Struct {

packages/types/src/interfaces/runtime/definitions.ts

@@ -39,23 +39,6 @@ export default {
         PreRuntime: 'PreRuntime' // 6
       }
     },
-    DispatchClass: {
-      _enum: ['Normal', 'Operational', 'Mandatory']
-    },
-    DispatchInfo: {
-      weight: 'Weight',
-      class: 'DispatchClass',
-      paysFee: 'Pays'
-    },
-    DispatchInfoTo190: {
-      weight: 'Weight',
-      class: 'DispatchClass'
-    },
-    DispatchInfoTo244: {
-      weight: 'Weight',
-      class: 'DispatchClass',
-      paysFee: 'bool'
-    },
     ExtrinsicsWeight: {
       normal: 'Weight',
       operational: 'Weight'
@@ -95,6 +78,9 @@ export default {
     ProxyType: {
       _enum: ['Any', 'NonTransfer', 'Governance', 'Staking']
     },
+    Releases: {
+      _enum: ['V1', 'V2', 'V3', 'V4', 'V5', 'V6', 'V7', 'V8', 'V9', 'V10']
+    },
     RuntimeDbWeight: {
       read: 'Weight',
       write: 'Weight'

packages/types/src/interfaces/runtime/types.ts

@@ -4,7 +4,7 @@
 import { ITuple } from '@polkadot/types/types';
 import { Compact, Enum, Int, Struct, U8aFixed, Vec } from '@polkadot/types/codec';
 import { GenericAccountId, GenericAccountIndex, GenericAddress, GenericBlock, GenericCall, GenericConsensusEngineId } from '@polkadot/types/generic';
-import { Bytes, DoNotConstruct, Null, StorageKey, bool, u128, u32, u64, u8 } from '@polkadot/types/primitive';
+import { Bytes, DoNotConstruct, Null, StorageKey, u128, u32, u64, u8 } from '@polkadot/types/primitive';
 import { AuthorityId } from '@polkadot/types/interfaces/consensus';
 import { Signature } from '@polkadot/types/interfaces/extrinsics';
 
@@ -73,33 +73,6 @@ export interface DigestItem extends Enum {
   readonly asPreRuntime: PreRuntime;
 }
 
-/** @name DispatchClass */
-export interface DispatchClass extends Enum {
-  readonly isNormal: boolean;
-  readonly isOperational: boolean;
-  readonly isMandatory: boolean;
-}
-
-/** @name DispatchInfo */
-export interface DispatchInfo extends Struct {
-  readonly weight: Weight;
-  readonly class: DispatchClass;
-  readonly paysFee: Pays;
-}
-
-/** @name DispatchInfoTo190 */
-export interface DispatchInfoTo190 extends Struct {
-  readonly weight: Weight;
-  readonly class: DispatchClass;
-}
-
-/** @name DispatchInfoTo244 */
-export interface DispatchInfoTo244 extends Struct {
-  readonly weight: Weight;
-  readonly class: DispatchClass;
-  readonly paysFee: bool;
-}
-
 /** @name ExtrinsicsWeight */
 export interface ExtrinsicsWeight extends Struct {
   readonly normal: Weight;
@@ -198,6 +171,20 @@ export interface ProxyType extends Enum {
   readonly isStaking: boolean;
 }
 
+/** @name Releases */
+export interface Releases extends Enum {
+  readonly isV1: boolean;
+  readonly isV2: boolean;
+  readonly isV3: boolean;
+  readonly isV4: boolean;
+  readonly isV5: boolean;
+  readonly isV6: boolean;
+  readonly isV7: boolean;
+  readonly isV8: boolean;
+  readonly isV9: boolean;
+  readonly isV10: boolean;
+}
+
 /** @name RuntimeDbWeight */
 export interface RuntimeDbWeight extends Struct {
   readonly read: Weight;

packages/types/src/interfaces/staking/definitions.ts

@@ -100,9 +100,6 @@ export default {
     PerU16: 'u16',
     PhragmenScore: '[u128; 3]',
     Points: 'u32',
-    ReleasesStaking: {
-      _enum: ['V1_0_0', 'V2_0_0', 'V3_0_0', 'V4_0_0']
-    },
     RewardDestination: {
       _enum: [
         'Staked',

packages/types/src/interfaces/staking/types.ts

@@ -136,14 +136,6 @@ export interface PhragmenScore extends Vec<u128> {}
 /** @name Points */
 export interface Points extends u32 {}
 
-/** @name ReleasesStaking */
-export interface ReleasesStaking extends Enum {
-  readonly isV100: boolean;
-  readonly isV200: boolean;
-  readonly isV300: boolean;
-  readonly isV400: boolean;
-}
-
 /** @name RewardDestination */
 export interface RewardDestination extends Enum {
   readonly isStaked: boolean;

packages/types/src/interfaces/system/definitions.ts

@@ -9,6 +9,33 @@ import { Definitions } from '../../types';
 
 export default {
   rpc: {
+    accountNextIndex: {
+      alias: ['account_nextIndex'],
+      description: 'Retrieves the next accountIndex as available on the node',
+      params: [
+        {
+          name: 'accountId',
+          type: 'AccountId'
+        }
+      ],
+      type: 'Index'
+    },
+    dryRun: {
+      alias: ['system_dryRunAt'],
+      description: 'Dry run an extrinsic at a given block',
+      params: [
+        {
+          name: 'extrinsic',
+          type: 'Bytes'
+        },
+        {
+          name: 'at',
+          type: 'BlockHash',
+          isOptional: true
+        }
+      ],
+      type: 'ApplyExtrinsicResult'
+    },
     name: {
       description: 'Retrieves the node name',
       params: [],
@@ -91,6 +118,7 @@ export default {
       refcount: 'RefCount',
       data: 'AccountData'
     },
+    ApplyExtrinsicResult: 'Result<DispatchOutcome, TransactionValidityError>',
     ChainProperties: {
       ss58Format: 'Option<u8>',
       tokenDecimals: 'Option<u32>',
@@ -105,6 +133,9 @@ export default {
       }
     },
     DigestOf: 'Digest',
+    DispatchClass: {
+      _enum: ['Normal', 'Operational', 'Mandatory']
+    },
     DispatchError: {
       _enum: {
         Other: 'Null',
@@ -121,6 +152,21 @@ export default {
       module: 'Option<u8>',
       error: 'u8'
     },
+    DispatchInfo: {
+      weight: 'Weight',
+      class: 'DispatchClass',
+      paysFee: 'Pays'
+    },
+    DispatchInfoTo190: {
+      weight: 'Weight',
+      class: 'DispatchClass'
+    },
+    DispatchInfoTo244: {
+      weight: 'Weight',
+      class: 'DispatchClass',
+      paysFee: 'bool'
+    },
+    DispatchOutcome: 'Result<(), DispatchError>',
     DispatchResult: 'Result<(), DispatchError>',
     DispatchResultOf: 'DispatchResult',
     DispatchResultTo198: 'Result<(), Text>',
@@ -141,6 +187,20 @@ export default {
       isSyncing: 'bool',
       shouldHavePeers: 'bool'
     },
+    InvalidTransaction: {
+      _enum: {
+        Call: 'Null',
+        Payment: 'Null',
+        Future: 'Null',
+        Stale: 'Null',
+        BadProof: 'Null',
+        AncientBirthBlock: 'Null',
+        ExhaustsResources: 'Null',
+        Custom: 'u8',
+        BadMandatory: 'Null',
+        MandatoryDispatch: 'Null'
+      }
+    },
     Key: 'Bytes',
     LastRuntimeUpgradeInfo: {
       specVersion: 'Compact<u32>',
@@ -214,6 +274,19 @@ export default {
         Initialization: 'Null'
       }
     },
-    RefCount: 'u8'
+    RefCount: 'u8',
+    TransactionValidityError: {
+      _enum: {
+        Invalid: 'InvalidTransaction',
+        Unknown: 'UnknownTransaction'
+      }
+    },
+    UnknownTransaction: {
+      _enum: {
+        CannotLookup: 'Null',
+        NoUnsignedValidator: 'Null',
+        Custom: 'u8'
+      }
+    }
   }
 } as Definitions;

packages/types/src/interfaces/system/types.ts

@@ -6,7 +6,7 @@ import { Compact, Enum, HashMap, Option, Result, Struct, U8aFixed, Vec } from '@
 import { GenericEvent } from '@polkadot/types/generic';
 import { Bytes, Text, bool, u32, u64, u8 } from '@polkadot/types/primitive';
 import { AccountData } from '@polkadot/types/interfaces/balances';
-import { BlockNumber, Digest, Hash, Index } from '@polkadot/types/interfaces/runtime';
+import { BlockNumber, Digest, Hash, Index, Pays, Weight } from '@polkadot/types/interfaces/runtime';
 
 /** @name AccountInfo */
 export interface AccountInfo extends Struct {
@@ -15,6 +15,14 @@ export interface AccountInfo extends Struct {
   readonly data: AccountData;
 }
 
+/** @name ApplyExtrinsicResult */
+export interface ApplyExtrinsicResult extends Result<DispatchOutcome, TransactionValidityError> {
+  readonly isError: boolean;
+  readonly asError: TransactionValidityError;
+  readonly isOk: boolean;
+  readonly asOk: DispatchOutcome;
+}
+
 /** @name ChainProperties */
 export interface ChainProperties extends Struct {
   readonly ss58Format: Option<u8>;
@@ -34,6 +42,13 @@ export interface ChainType extends Enum {
 /** @name DigestOf */
 export interface DigestOf extends Digest {}
 
+/** @name DispatchClass */
+export interface DispatchClass extends Enum {
+  readonly isNormal: boolean;
+  readonly isOperational: boolean;
+  readonly isMandatory: boolean;
+}
+
 /** @name DispatchError */
 export interface DispatchError extends Enum {
   readonly isOther: boolean;
@@ -55,6 +70,34 @@ export interface DispatchErrorTo198 extends Struct {
   readonly error: u8;
 }
 
+/** @name DispatchInfo */
+export interface DispatchInfo extends Struct {
+  readonly weight: Weight;
+  readonly class: DispatchClass;
+  readonly paysFee: Pays;
+}
+
+/** @name DispatchInfoTo190 */
+export interface DispatchInfoTo190 extends Struct {
+  readonly weight: Weight;
+  readonly class: DispatchClass;
+}
+
+/** @name DispatchInfoTo244 */
+export interface DispatchInfoTo244 extends Struct {
+  readonly weight: Weight;
+  readonly class: DispatchClass;
+  readonly paysFee: bool;
+}
+
+/** @name DispatchOutcome */
+export interface DispatchOutcome extends Result<ITuple<[]>, DispatchError> {
+  readonly isError: boolean;
+  readonly asError: DispatchError;
+  readonly isOk: boolean;
+  readonly asOk: ITuple<[]>;
+}
+
 /** @name DispatchResult */
 export interface DispatchResult extends Result<ITuple<[]>, DispatchError> {
   readonly isError: boolean;
@@ -103,6 +146,21 @@ export interface Health extends Struct {
   readonly shouldHavePeers: bool;
 }
 
+/** @name InvalidTransaction */
+export interface InvalidTransaction extends Enum {
+  readonly isCall: boolean;
+  readonly isPayment: boolean;
+  readonly isFuture: boolean;
+  readonly isStale: boolean;
+  readonly isBadProof: boolean;
+  readonly isAncientBirthBlock: boolean;
+  readonly isExhaustsResources: boolean;
+  readonly isCustom: boolean;
+  readonly asCustom: u8;
+  readonly isBadMandatory: boolean;
+  readonly isMandatoryDispatch: boolean;
+}
+
 /** @name Key */
 export interface Key extends Bytes {}
 
@@ -199,4 +257,20 @@ export interface Phase extends Enum {
 /** @name RefCount */
 export interface RefCount extends u8 {}
 
+/** @name TransactionValidityError */
+export interface TransactionValidityError extends Enum {
+  readonly isInvalid: boolean;
+  readonly asInvalid: InvalidTransaction;
+  readonly isUnknown: boolean;
+  readonly asUnknown: UnknownTransaction;
+}
+
+/** @name UnknownTransaction */
+export interface UnknownTransaction extends Enum {
+  readonly isCannotLookup: boolean;
+  readonly isNoUnsignedValidator: boolean;
+  readonly isCustom: boolean;
+  readonly asCustom: u8;
+}
+
 export type PHANTOM_SYSTEM = 'system';

packages/types/src/interfaces/types.ts

@@ -35,7 +35,6 @@ export * from './claims/types';
 export * from './parachains/types';
 export * from './metadata/types';
 export * from './rpc/types';
-export * from './account/types';
 export * from './author/types';
 export * from './chain/types';
 export * from './childstate/types';

packages/types/src/types/helpers.ts

@@ -2,6 +2,8 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
+import { Codec } from './codec';
+
 import BN from 'bn.js';
 
 // We cannot inline this into CodecArg, TS thrws up when building docs
@@ -26,4 +28,6 @@ export type ArrayElementType<T extends ReadonlyArray<unknown>> = T extends Reado
 
 export type BareOpts = boolean | Record<string, boolean>;
 
-export type Callback<T> = (result: T) => void | Promise<void>;
+export type Callback<T, E = undefined> = E extends Codec
+  ? (result: T, extra: E) => void | Promise<void>
+  : (result: T) => void | Promise<void>;

packages/types/src/types/registry.ts

@@ -121,7 +121,7 @@ export interface Registry {
   findMetaEvent (eventIndex: Uint8Array): Constructor<any>;
 
   createClass <K extends keyof InterfaceTypes> (type: K): Constructor<InterfaceTypes[K]>;
-  createType <K extends keyof InterfaceTypes> (type: K, ...params: any[]): InterfaceTypes[K];
+  createType <K extends keyof InterfaceTypes> (type: K, ...params: unknown[]): InterfaceTypes[K];
   get <T extends Codec = Codec> (name: string, withUnknown?: boolean): Constructor<T> | undefined;
   getChainProperties (): ChainProperties | undefined;
   getDefinition (name: string): string | undefined;