@pezkuwi/api-derive 16.5.5

package/src/staking/electedInfo.ts

@@ -0,0 +1,54 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveStakingElected, StakingQueryFlags } from '../types.js';
+
+import { map, switchMap } from 'rxjs';
+
+import { arrayFlatten } from '@pezkuwi/util';
+
+import { memo } from '../util/index.js';
+
+const DEFAULT_FLAGS = { withController: true, withExposure: true, withPrefs: true };
+
+function combineAccounts (nextElected: AccountId[], validators: AccountId[]): AccountId[] {
+  return arrayFlatten([nextElected, validators.filter((v) => !nextElected.find((n) => n.eq(v)))]);
+}
+
+/**
+ * @name electedInfo
+ * @param {StakingQueryFlags} flags? (Optional) Query flags to filter the staking data.
+ * @param {number} page? (Optional) The page index for paginated results.
+ * @description Retrieves detailed staking information about the next elected validators and their associated staking data.
+ * @example
+ * ```javascript
+ * const { nextElected, validators, info } =
+ *   await api.derive.staking.electedInfo();
+ * console.log(
+ *   "Next Elected Validators:",
+ *   nextElected.map((acc) => acc.toString())
+ * );
+ * console.log(
+ *   "Current Validators:",
+ *   validators.map((acc) => acc.toString())
+ * );
+ * console.log("Validator Staking Info:", info);
+ * ```
+ */
+export function electedInfo (instanceId: string, api: DeriveApi): (flags?: StakingQueryFlags, page?: number) => Observable<DeriveStakingElected> {
+  return memo(instanceId, (flags: StakingQueryFlags = DEFAULT_FLAGS, page = 0): Observable<DeriveStakingElected> =>
+    api.derive.staking.validators().pipe(
+      switchMap(({ nextElected, validators }): Observable<DeriveStakingElected> =>
+        api.derive.staking.queryMulti(combineAccounts(nextElected, validators), flags, page).pipe(
+          map((info): DeriveStakingElected => ({
+            info,
+            nextElected,
+            validators
+          }))
+        )
+      )
+    )
+  );
+}

package/src/staking/erasExposure.ts

@@ -0,0 +1,105 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { Option, StorageKey, u32 } from '@pezkuwi/types';
+import type { AccountId, AccountId32, EraIndex } from '@pezkuwi/types/interfaces';
+import type { SpStakingExposure, SpStakingExposurePage } from '@pezkuwi/types/lookup';
+import type { DeriveApi, DeriveEraExposurePaged, DeriveEraNominatorExposure, DeriveEraValidatorExposure, DeriveEraValidatorExposurePaged } from '../types.js';
+
+import { map, of } from 'rxjs';
+
+import { memo } from '../util/index.js';
+import { getEraCache, setEraCache } from './cache.js';
+import { combineEras, erasHistoricApply, singleEra } from './util.js';
+
+type KeysAndExposures = [StorageKey<[EraIndex, AccountId]>, SpStakingExposure][];
+type KeysAndExposuresPaged = [StorageKey<[u32, AccountId32, u32]>, Option<SpStakingExposurePage>][];
+
+const CACHE_KEY = 'eraExposure';
+
+function mapStakersClipped (era: EraIndex, stakers: KeysAndExposures): DeriveEraExposurePaged {
+  const nominators: DeriveEraNominatorExposure = {};
+  const validators: DeriveEraValidatorExposure = {};
+
+  stakers.forEach(([key, exposure]): void => {
+    const validatorId = key.args[1].toString();
+
+    validators[validatorId] = exposure;
+
+    exposure.others.forEach(({ who }, validatorIndex): void => {
+      const nominatorId = who.toString();
+
+      nominators[nominatorId] = nominators[nominatorId] || [];
+      nominators[nominatorId].push({ validatorId, validatorIndex });
+    });
+  });
+
+  return { era, nominators, validators };
+}
+
+function mapStakersPaged (era: EraIndex, stakers: KeysAndExposuresPaged): DeriveEraExposurePaged {
+  const nominators: DeriveEraNominatorExposure = {};
+  const validators: DeriveEraValidatorExposurePaged = {};
+
+  stakers.forEach(([key, exposureOpt]): void => {
+    if (exposureOpt.isSome) {
+      const validatorId = key.args[1].toString();
+      const exposure = exposureOpt.unwrap();
+
+      validators[validatorId] = exposure;
+
+      exposure.others.forEach(({ who }, validatorIndex): void => {
+        const nominatorId = who.toString();
+
+        nominators[nominatorId] = nominators[nominatorId] || [];
+        nominators[nominatorId].push({ validatorId, validatorIndex });
+      });
+    }
+  });
+
+  return { era, nominators, validators };
+}
+
+/**
+ * erasStakersClipped will be deprecated and replaced with erasStakersPaged. Therefore support is given for both
+ * storage queries until erasStakersClipped has been completely out of use.
+ */
+export function _eraExposure (instanceId: string, api: DeriveApi): (era: EraIndex, withActive?: boolean) => Observable<DeriveEraExposurePaged> {
+  return memo(instanceId, (era: EraIndex, withActive = false): Observable<DeriveEraExposurePaged> => {
+    const [cacheKey, cached] = getEraCache<DeriveEraExposurePaged>(CACHE_KEY, era, withActive);
+
+    return cached
+      ? of(cached)
+      : api.query.staking.erasStakersPaged
+        ? api.query.staking.erasStakersPaged.entries<Option<SpStakingExposurePage>>(era).pipe(
+          map((r) => setEraCache(cacheKey, withActive, mapStakersPaged(era, r)))
+        )
+        : api.query.staking.erasStakersClipped.entries(era).pipe(
+          map((r) => setEraCache(cacheKey, withActive, mapStakersClipped(era, r)))
+        );
+  });
+}
+
+/**
+ * @name eraExposure
+ * @description Retrieves the staking exposure (nominators and total stake) for a specific era.
+ * @param {EraIndex} eras The staking era to query.
+ * @example
+ * ```javascript
+ * const era = api.createType("EraIndex", 1000);
+ * const exposure = await api.derive.staking.eraExposure(era);
+ * ```
+ */
+export const eraExposure = /*#__PURE__*/ singleEra('_eraExposure');
+export const _erasExposure = /*#__PURE__*/ combineEras('_eraExposure');
+/**
+ * @name erasExposure
+ * @description Retrieves staking exposure details for multiple past eras.
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ * @example
+ * ```javascript
+ * const exposure = await api.derive.staking.erasExposure(true);
+ * ```
+ */
+export const erasExposure = /*#__PURE__*/ erasHistoricApply('_erasExposure');

package/src/staking/erasHistoric.ts

@@ -0,0 +1,47 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { u32 } from '@pezkuwi/types';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi } from '../types.js';
+
+import { combineLatest, map, of } from 'rxjs';
+
+import { BN_ONE, BN_ZERO } from '@pezkuwi/util';
+
+import { memo } from '../util/index.js';
+
+/**
+ * @name erasHistoric
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ */
+export function erasHistoric (instanceId: string, api: DeriveApi): (withActive?: boolean) => Observable<EraIndex[]> {
+  return memo(instanceId, (withActive?: boolean): Observable<EraIndex[]> =>
+    combineLatest([
+      api.query.staking.activeEra(),
+      api.consts.staking.historyDepth
+        ? of(api.consts.staking.historyDepth)
+        : api.query.staking['historyDepth']<u32>()
+    ]).pipe(
+      map(([activeEraOpt, historyDepth]): EraIndex[] => {
+        const result: EraIndex[] = [];
+        const max = historyDepth.toNumber();
+        const activeEra: BN = activeEraOpt.unwrapOrDefault().index;
+        let lastEra = activeEra;
+
+        while (lastEra.gte(BN_ZERO) && (result.length < max)) {
+          if ((lastEra !== activeEra) || (withActive === true)) {
+            result.push(api.registry.createType('EraIndex', lastEra));
+          }
+
+          lastEra = lastEra.sub(BN_ONE);
+        }
+
+        // go from oldest to newest
+        return result.reverse();
+      })
+    )
+  );
+}

package/src/staking/erasPoints.ts

@@ -0,0 +1,67 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { PalletStakingEraRewardPoints } from '@pezkuwi/types/lookup';
+import type { DeriveApi, DeriveEraPoints, DeriveEraValPoints } from '../types.js';
+
+import { map, of } from 'rxjs';
+
+import { BN_ZERO } from '@pezkuwi/util';
+
+import { memo } from '../util/index.js';
+import { filterCachedEras, getEraMultiCache, setEraMultiCache } from './cache.js';
+import { erasHistoricApply, filterEras } from './util.js';
+
+const CACHE_KEY = 'eraPoints';
+
+function mapValidators ({ individual }: PalletStakingEraRewardPoints): DeriveEraValPoints {
+  return [...individual.entries()]
+    .filter(([, points]) => points.gt(BN_ZERO))
+    .reduce((result: DeriveEraValPoints, [validatorId, points]): DeriveEraValPoints => {
+      result[validatorId.toString()] = points;
+
+      return result;
+    }, {});
+}
+
+function mapPoints (eras: EraIndex[], points: PalletStakingEraRewardPoints[]): DeriveEraPoints[] {
+  return eras.map((era, index): DeriveEraPoints => ({
+    era,
+    eraPoints: points[index].total,
+    validators: mapValidators(points[index])
+  }));
+}
+
+export function _erasPoints (instanceId: string, api: DeriveApi): (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraPoints[]> {
+  return memo(instanceId, (eras: EraIndex[], withActive: boolean): Observable<DeriveEraPoints[]> => {
+    if (!eras.length) {
+      return of([]);
+    }
+
+    const cached = getEraMultiCache<DeriveEraPoints>(CACHE_KEY, eras, withActive);
+    const remaining = filterEras(eras, cached);
+
+    return !remaining.length
+      ? of(cached)
+      : api.query.staking.erasRewardPoints.multi(remaining).pipe(
+        map((p) => filterCachedEras(eras, cached, setEraMultiCache(CACHE_KEY, withActive, mapPoints(remaining, p))))
+      );
+  });
+}
+
+/**
+ * @name erasPoints
+ * @description Retrieves historical era points with its validators.
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ * @example
+ * ```javascript
+ * const points = await api.derive.staking.erasPoints(true);
+ * console.log(
+ *   "Validator points:",
+ *   points.map(({ era, eraPoints }) => `Era: ${era}, points ${eraPoints}`)
+ * );
+ * ```
+ */
+export const erasPoints = /*#__PURE__*/ erasHistoricApply('_erasPoints');

package/src/staking/erasPrefs.ts

@@ -0,0 +1,63 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { StorageKey } from '@pezkuwi/types';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { PalletStakingValidatorPrefs } from '@pezkuwi/types/lookup';
+import type { DeriveApi, DeriveEraPrefs, DeriveEraValPrefs } from '../types.js';
+
+import { map, of } from 'rxjs';
+
+import { memo } from '../util/index.js';
+import { getEraCache, setEraCache } from './cache.js';
+import { combineEras, erasHistoricApply, singleEra } from './util.js';
+
+const CACHE_KEY = 'eraPrefs';
+
+function mapPrefs (era: EraIndex, all: [StorageKey, PalletStakingValidatorPrefs][]): DeriveEraPrefs {
+  const validators: DeriveEraValPrefs = {};
+
+  all.forEach(([key, prefs]): void => {
+    validators[key.args[1].toString()] = prefs;
+  });
+
+  return { era, validators };
+}
+
+export function _eraPrefs (instanceId: string, api: DeriveApi): (era: EraIndex, withActive: boolean) => Observable<DeriveEraPrefs> {
+  return memo(instanceId, (era: EraIndex, withActive: boolean): Observable<DeriveEraPrefs> => {
+    const [cacheKey, cached] = getEraCache<DeriveEraPrefs>(CACHE_KEY, era, withActive);
+
+    return cached
+      ? of(cached)
+      : api.query.staking.erasValidatorPrefs.entries(era).pipe(
+        map((r) => setEraCache(cacheKey, withActive, mapPrefs(era, r)))
+      );
+  });
+}
+
+/**
+ * @name eraPrefs
+ * @description Retrieves the validators commission preferences for a given staking era.
+ * @param {EraIndex} era The staking era to query.
+ * @example
+ * ```javascript
+ * const era = api.createType("EraIndex", 1000);
+ * const prefs = await api.derive.staking.eraPrefs(era);
+ * console.log(JSON.stringify(prefs));
+ * ```
+ */
+export const eraPrefs = /*#__PURE__*/ singleEra('_eraPrefs');
+export const _erasPrefs = /*#__PURE__*/ combineEras('_eraPrefs');
+
+/**
+ * @name erasPrefs
+ * @description Retrieves validators commission preferences for multiple past staking eras
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ * @example
+ * ```javascript
+ * const prefs = await api.derive.staking.erasPrefs(true);
+ * ```
+ */
+export const erasPrefs = /*#__PURE__*/ erasHistoricApply('_erasPrefs');

package/src/staking/erasRewards.ts

@@ -0,0 +1,52 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { Option } from '@pezkuwi/types';
+import type { Balance, EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraRewards } from '../types.js';
+
+import { map, of } from 'rxjs';
+
+import { memo } from '../util/index.js';
+import { filterCachedEras, getEraMultiCache, setEraMultiCache } from './cache.js';
+import { erasHistoricApply, filterEras } from './util.js';
+
+const CACHE_KEY = 'eraRewards';
+
+function mapRewards (eras: EraIndex[], optRewards: Option<Balance>[]): DeriveEraRewards[] {
+  return eras.map((era, index): DeriveEraRewards => ({
+    era,
+    eraReward: optRewards[index].unwrapOrDefault()
+  }));
+}
+
+export function _erasRewards (instanceId: string, api: DeriveApi): (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraRewards[]> {
+  return memo(instanceId, (eras: EraIndex[], withActive: boolean): Observable<DeriveEraRewards[]> => {
+    if (!eras.length) {
+      return of([]);
+    }
+
+    const cached = getEraMultiCache<DeriveEraRewards>(CACHE_KEY, eras, withActive);
+    const remaining = filterEras(eras, cached);
+
+    if (!remaining.length) {
+      return of(cached);
+    }
+
+    return api.query.staking.erasValidatorReward.multi(remaining).pipe(
+      map((r) => filterCachedEras(eras, cached, setEraMultiCache(CACHE_KEY, withActive, mapRewards(remaining, r))))
+    );
+  });
+}
+
+/**
+ * @name erasRewards
+ * @description Retrieves rewards for historical eras.
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ * @example
+ * ```javascript
+ * const rewards = await api.derive.staking.erasRewards(true);
+ * ```
+ */
+export const erasRewards = /*#__PURE__*/ erasHistoricApply('_erasRewards');

package/src/staking/erasSlashes.ts

@@ -0,0 +1,69 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { Option, StorageKey } from '@pezkuwi/types';
+import type { BalanceOf, EraIndex, Perbill } from '@pezkuwi/types/interfaces';
+import type { ITuple } from '@pezkuwi/types/types';
+import type { DeriveApi, DeriveEraSlashes, DeriveEraValSlash } from '../types.js';
+
+import { combineLatest, map, of } from 'rxjs';
+
+import { memo } from '../util/index.js';
+import { getEraCache, setEraCache } from './cache.js';
+import { combineEras, erasHistoricApply, singleEra } from './util.js';
+
+const CACHE_KEY = 'eraSlashes';
+
+function mapSlashes (era: EraIndex, noms: [StorageKey, Option<BalanceOf>][], vals: [StorageKey, Option<ITuple<[Perbill, BalanceOf]>>][]): DeriveEraSlashes {
+  const nominators: DeriveEraValSlash = {};
+  const validators: DeriveEraValSlash = {};
+
+  noms.forEach(([key, optBalance]): void => {
+    nominators[key.args[1].toString()] = optBalance.unwrap();
+  });
+
+  vals.forEach(([key, optRes]): void => {
+    validators[key.args[1].toString()] = optRes.unwrapOrDefault()[1];
+  });
+
+  return { era, nominators, validators };
+}
+
+export function _eraSlashes (instanceId: string, api: DeriveApi): (era: EraIndex, withActive: boolean) => Observable<DeriveEraSlashes> {
+  return memo(instanceId, (era: EraIndex, withActive: boolean): Observable<DeriveEraSlashes> => {
+    const [cacheKey, cached] = getEraCache<DeriveEraSlashes>(CACHE_KEY, era, withActive);
+
+    return cached
+      ? of(cached)
+      : combineLatest([
+        api.query.staking.nominatorSlashInEra.entries(era),
+        api.query.staking.validatorSlashInEra.entries(era)
+      ]).pipe(
+        map(([n, v]) => setEraCache(cacheKey, withActive, mapSlashes(era, n, v)))
+      );
+  });
+}
+
+/**
+ * @name eraSlashes
+ * @description Retrieves the slashes for a specific staking era.
+ * @param {EraIndex} eras The staking era to query.
+ * @example
+ * ```javascript
+ * const era = api.createType("EraIndex", 1000);
+ * const slashes = await api.derive.staking.eraSlashes(era);
+ * ```
+ */
+export const eraSlashes = /*#__PURE__*/ singleEra('_eraSlashes');
+export const _erasSlashes = /*#__PURE__*/ combineEras('_eraSlashes');
+/**
+ * @name erasSlashes
+ * @description Retrieves slashes for historical eras.
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ * @example
+ * ```javascript
+ * const slashes = await api.derive.staking.erasSlashes(true);
+ * ```
+ */
+export const erasSlashes = /*#__PURE__*/ erasHistoricApply('_erasSlashes');

package/src/staking/index.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './account.js';
+export * from './currentPoints.js';
+export * from './electedInfo.js';
+export * from './erasExposure.js';
+export * from './erasHistoric.js';
+export * from './erasPoints.js';
+export * from './erasPrefs.js';
+export * from './erasRewards.js';
+export * from './erasSlashes.js';
+export * from './keys.js';
+export * from './overview.js';
+export * from './ownExposure.js';
+export * from './ownSlashes.js';
+export * from './query.js';
+export * from './stakerExposure.js';
+export * from './stakerPoints.js';
+export * from './stakerPrefs.js';
+export * from './stakerRewards.js';
+export * from './stakerSlashes.js';
+export * from './stashes.js';
+export * from './validators.js';
+export * from './waitingInfo.js';

package/src/staking/keys.ts

@@ -0,0 +1,86 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { Option } from '@pezkuwi/types';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { KitchensinkRuntimeSessionKeys } from '@pezkuwi/types/lookup';
+import type { DeriveApi } from '../types.js';
+import type { DeriveStakingKeys } from './types.js';
+
+import { combineLatest, map, of, switchMap } from 'rxjs';
+
+import { firstMemo, memo } from '../util/index.js';
+
+function extractsIds (stashId: Uint8Array | string, queuedKeys: [AccountId, KitchensinkRuntimeSessionKeys | AccountId[]][], nextKeys: Option<KitchensinkRuntimeSessionKeys>): DeriveStakingKeys {
+  const sessionIds = (queuedKeys.find(([currentId]) => currentId.eq(stashId)) || [undefined, [] as AccountId[]])[1];
+  const nextSessionIds = nextKeys.unwrapOr([] as AccountId[]);
+
+  return {
+    nextSessionIds: Array.isArray(nextSessionIds)
+      ? nextSessionIds
+      : [...nextSessionIds.values()] as AccountId[],
+    sessionIds: Array.isArray(sessionIds)
+      ? sessionIds
+      : [...sessionIds.values()] as AccountId[]
+  };
+}
+
+/**
+ * @name keys
+ * @param { Uint8Array | string } stashId The stash account ID whose session keys are to be retrieved.
+ * @description Retrieves the session keys associated with a given stash account.
+ * @example
+ * ```javascript
+ * const keys = await api.derive.staking.keys(
+ *   ALICE
+ * );
+ * console.log(
+ *   "Session keys:",
+ *   keys.sessionIds.map((key) => `Key: ${key}`)
+ * );
+ * ```
+ */
+export const keys = /*#__PURE__*/ firstMemo(
+  (api: DeriveApi, stashId: Uint8Array | string) =>
+    api.derive.staking.keysMulti([stashId])
+);
+
+/**
+ * @name keysMulti
+ * @description Retrieves session keys for multiple stash accounts.
+ * @param { (Uint8Array | string)[] } stashIds Array of stash account IDs.
+ * @example
+ * ```javascript
+ * const keysMulti = await api.derive.staking.keysMulti([ ALICE, BOB ]);
+ * keysMulti.forEach((keys) => {
+ *   console.log(
+ *     "Session keys:",
+ *     keys.sessionIds.map((key) => `Key: ${key}`)
+ *   );
+ * });
+ * ```
+ */
+export function keysMulti (instanceId: string, api: DeriveApi): (stashIds: (Uint8Array | string)[]) => Observable<DeriveStakingKeys[]> {
+  return memo(instanceId, (stashIds: (Uint8Array | string)[]): Observable<DeriveStakingKeys[]> =>
+    stashIds.length
+      ? api.query.session.queuedKeys().pipe(
+        switchMap((queuedKeys) =>
+          combineLatest([
+            of(queuedKeys),
+            // eslint-disable-next-line @typescript-eslint/dot-notation
+            api.consts['session']?.['dedupKeyPrefix']
+              // eslint-disable-next-line @typescript-eslint/dot-notation
+              ? api.query.session.nextKeys.multi(stashIds.map((s) => [api.consts['session']['dedupKeyPrefix'], s]))
+              : combineLatest(stashIds.map((s) => api.query.session.nextKeys(s)))
+          ])
+        ),
+        map(([queuedKeys, nextKeys]) =>
+          stashIds.map((stashId, index) =>
+            extractsIds(stashId, queuedKeys, nextKeys[index])
+          )
+        )
+      )
+      : of([])
+  );
+}

package/src/staking/overview.ts

@@ -0,0 +1,42 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveStakingOverview } from '../types.js';
+
+import { combineLatest, map } from 'rxjs';
+
+import { objectSpread } from '@pezkuwi/util';
+
+import { memo } from '../util/index.js';
+
+/**
+ * @name overview
+ * @description Retrieve the staking overview, including elected validators and points earned.
+ * @example
+ * ```javascript
+ * const {
+ *   activeEra,
+ *   activeEraStart,
+ *   currentEra,
+ *   currentIndex,
+ *   nextElected,
+ *   validatorCount,
+ *   validators,
+ * } = await api.derive.staking.overview();
+ * ```
+ */
+export function overview (instanceId: string, api: DeriveApi): () => Observable<DeriveStakingOverview> {
+  return memo(instanceId, (): Observable<DeriveStakingOverview> =>
+    combineLatest([
+      api.derive.session.indexes(),
+      api.derive.staking.validators()
+    ]).pipe(
+      map(([indexes, { nextElected, validators }]): DeriveStakingOverview =>
+        objectSpread({}, indexes, {
+          nextElected,
+          validators
+        })
+      )
+    ));
+}