@pezkuwi/api-derive 16.5.5 → 16.5.6

package/src/staking/stakerRewards.ts

@@ -1,298 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { u32, Vec } from '@pezkuwi/types';
-import type { AccountId, EraIndex } from '@pezkuwi/types/interfaces';
-import type { PalletStakingStakingLedger, SpStakingExposure, SpStakingExposurePage } from '@pezkuwi/types/lookup';
-import type { BN } from '@pezkuwi/util';
-import type { DeriveApi, DeriveEraPoints, DeriveEraPrefs, DeriveEraRewards, DeriveEraValPoints, DeriveEraValPrefs, DeriveStakerExposure, DeriveStakerReward, DeriveStakerRewardValidator } from '../types.js';
-import type { DeriveStakingQuery } from './types.js';
-
-import { combineLatest, map, of, switchMap } from 'rxjs';
-
-import { BN_BILLION, BN_ZERO, objectSpread } from '@pezkuwi/util';
-
-import { firstMemo, memo } from '../util/index.js';
-
-type ErasResult = [DeriveEraPoints[], DeriveEraPrefs[], DeriveEraRewards[]];
-
-// handle compatibility between generations of structures
-function extractCompatRewards (claimedRewardsEras: Vec<u32>, ledger?: PalletStakingStakingLedger): u32[] {
-  const l = ledger
-    ? (
-      ledger.legacyClaimedRewards ||
-    (ledger as PalletStakingStakingLedger & { claimedRewards: Vec<u32> }).claimedRewards
-    )?.toArray()
-    : [] as unknown as Vec<u32>;
-
-  return (claimedRewardsEras.toArray() || []).concat(l);
-}
-
-function parseRewards (api: DeriveApi, stashId: AccountId, [erasPoints, erasPrefs, erasRewards]: ErasResult, exposures: DeriveStakerExposure[], claimedRewardsEras: Vec<u32>): DeriveStakerReward[] {
-  return exposures.map(({ era, isEmpty, isValidator, nominating, validators: eraValidators }): DeriveStakerReward => {
-    const { eraPoints, validators: allValPoints } = erasPoints.find((p) => p.era.eq(era)) || { eraPoints: BN_ZERO, validators: {} as DeriveEraValPoints };
-    const { eraReward } = erasRewards.find((r) => r.era.eq(era)) || { eraReward: api.registry.createType('Balance') };
-    const { validators: allValPrefs } = erasPrefs.find((p) => p.era.eq(era)) || { validators: {} as DeriveEraValPrefs };
-    const validators: Record<string, DeriveStakerRewardValidator> = {};
-    const stakerId = stashId.toString();
-
-    Object.entries(eraValidators).forEach(([validatorId, exposure]): void => {
-      const valPoints = allValPoints[validatorId] || BN_ZERO;
-      const valComm = allValPrefs[validatorId]?.commission.unwrap() || BN_ZERO;
-      const expTotal = (exposure as SpStakingExposure).total
-        ? (exposure as SpStakingExposure).total?.unwrap()
-        : (exposure as SpStakingExposurePage).pageTotal
-          ? (exposure as SpStakingExposurePage).pageTotal?.unwrap()
-          : BN_ZERO;
-      let avail = BN_ZERO;
-      let value: BN | undefined;
-
-      if (!(expTotal.isZero() || valPoints.isZero() || eraPoints.isZero())) {
-        avail = eraReward.mul(valPoints).div(eraPoints);
-
-        const valCut = valComm.mul(avail).div(BN_BILLION);
-        let staked: BN;
-
-        if (validatorId === stakerId) {
-          if ((exposure as SpStakingExposure).own) {
-            staked = (exposure as SpStakingExposure).own.unwrap();
-          } else {
-            const expAccount = exposure.others.find(({ who }) => who.eq(validatorId));
-
-            staked = expAccount
-              ? expAccount.value.unwrap()
-              : BN_ZERO;
-          }
-        } else {
-          const stakerExp = exposure.others.find(({ who }) => who.eq(stakerId));
-
-          staked = stakerExp
-            ? stakerExp.value.unwrap()
-            : BN_ZERO;
-        }
-
-        value = avail.sub(valCut).imul(staked).div(expTotal).iadd(validatorId === stakerId ? valCut : BN_ZERO);
-      }
-
-      validators[validatorId] = {
-        total: api.registry.createType('Balance', avail),
-        value: api.registry.createType('Balance', value)
-      };
-    });
-
-    return {
-      era,
-      eraReward,
-      // This might not always be accurate as you need validator account information in order to see if the rewards have been claimed.
-      // This is possibly adjusted in `filterRewards` when need be.
-      isClaimed: claimedRewardsEras.some((c) => c.eq(era)),
-      isEmpty,
-      isValidator,
-      nominating,
-      validators
-    };
-  });
-}
-
-function allUniqValidators (rewards: DeriveStakerReward[][]): [string[], string[][]] {
-  return rewards.reduce(([all, perStash]: [string[], string[][]], rewards) => {
-    const uniq: string[] = [];
-
-    perStash.push(uniq);
-    rewards.forEach(({ validators }) =>
-      Object.keys(validators).forEach((validatorId): void => {
-        if (!uniq.includes(validatorId)) {
-          uniq.push(validatorId);
-
-          if (!all.includes(validatorId)) {
-            all.push(validatorId);
-          }
-        }
-      })
-    );
-
-    return [all, perStash];
-  }, [[], []]);
-}
-
-function removeClaimed (validators: string[], queryValidators: DeriveStakingQuery[], reward: DeriveStakerReward, claimedRewardsEras: Vec<u32>): void {
-  const rm: string[] = [];
-
-  Object.keys(reward.validators).forEach((validatorId): void => {
-    const index = validators.indexOf(validatorId);
-
-    if (index !== -1) {
-      const valLedger = queryValidators[index].stakingLedger;
-
-      if (extractCompatRewards(claimedRewardsEras, valLedger).some((e) => reward.era?.eq(e))) {
-        rm.push(validatorId);
-      }
-    }
-  });
-
-  rm.forEach((validatorId): void => {
-    delete reward.validators[validatorId];
-  });
-}
-
-function filterRewards (eras: EraIndex[], valInfo: [string, DeriveStakingQuery][], { claimedRewardsEras, rewards, stakingLedger }: { rewards: DeriveStakerReward[]; stakingLedger: PalletStakingStakingLedger, claimedRewardsEras: Vec<u32> }): DeriveStakerReward[] {
-  const filter = eras.filter((e) => !extractCompatRewards(claimedRewardsEras, stakingLedger).some((s) => s?.eq(e)));
-  const validators = valInfo.map(([v]) => v);
-  const queryValidators = valInfo.map(([, q]) => q);
-
-  return rewards
-    .filter(({ isEmpty }) => !isEmpty)
-    .filter((reward): boolean => {
-      if (!filter.some((e) => reward.era.eq(e))) {
-        return false;
-      }
-
-      removeClaimed(validators, queryValidators, reward, claimedRewardsEras);
-
-      return true;
-    })
-    .filter(({ validators }) => Object.keys(validators).length !== 0)
-    .map((reward) => {
-      let isClaimed = reward.isClaimed;
-      const valKeys = Object.keys(reward.validators);
-
-      if (!reward.isClaimed && valKeys.length) {
-        for (const key of valKeys) {
-          const info = queryValidators.find((i) => i.accountId.toString() === key);
-
-          if (info) {
-            isClaimed = info.claimedRewardsEras?.toArray().some((era) => era.eq(reward.era));
-            break;
-          }
-        }
-      }
-
-      return objectSpread({}, reward, {
-        isClaimed,
-        nominators: reward.nominating.filter((n) => reward.validators[n.validatorId])
-      });
-    });
-}
-
-export function _stakerRewardsEras (instanceId: string, api: DeriveApi): (eras: EraIndex[], withActive?: boolean) => Observable<ErasResult> {
-  return memo(instanceId, (eras: EraIndex[], withActive = false): Observable<ErasResult> =>
-    combineLatest([
-      api.derive.staking._erasPoints(eras, withActive),
-      api.derive.staking._erasPrefs(eras, withActive),
-      api.derive.staking._erasRewards(eras, withActive)
-    ])
-  );
-}
-
-export function _stakerRewards (instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive?: boolean) => Observable<DeriveStakerReward[][]> {
-  return memo(instanceId, (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive = false): Observable<DeriveStakerReward[][]> => {
-    // Ensures that when number or string types are passed in they are sanitized
-    // Ref: https://github.com/polkadot-js/api/issues/5910
-    const sanitizedEras: EraIndex[] = eras.map((e) => typeof e === 'number' || typeof e === 'string' ? api.registry.createType('u32', e) : e);
-
-    return combineLatest([
-      api.derive.staking.queryMulti(accountIds, { withClaimedRewardsEras: true, withLedger: true }),
-      api.derive.staking._stakerExposures(accountIds, sanitizedEras, withActive),
-      api.derive.staking._stakerRewardsEras(sanitizedEras, withActive)
-    ]).pipe(
-      switchMap(([queries, exposures, erasResult]): Observable<DeriveStakerReward[][]> => {
-        const allRewards = queries.map(({ claimedRewardsEras, stakingLedger, stashId }, index): DeriveStakerReward[] =>
-          (!stashId || (!stakingLedger && !claimedRewardsEras))
-            ? []
-            : parseRewards(api, stashId, erasResult, exposures[index], claimedRewardsEras)
-        );
-
-        if (withActive) {
-          return of(allRewards);
-        }
-
-        const [allValidators, stashValidators] = allUniqValidators(allRewards);
-
-        return api.derive.staking.queryMulti(allValidators, { withClaimedRewardsEras: true, withLedger: true }).pipe(
-          map((queriedVals): DeriveStakerReward[][] =>
-            queries.map(({ claimedRewardsEras, stakingLedger }, index): DeriveStakerReward[] =>
-              filterRewards(
-                eras,
-                stashValidators[index]
-                  .map((validatorId): [string, DeriveStakingQuery | undefined] => [
-                    validatorId,
-                    queriedVals.find((q) => q.accountId.eq(validatorId))
-                  ])
-                  .filter((v): v is [string, DeriveStakingQuery] => !!v[1]),
-                {
-                  claimedRewardsEras,
-                  rewards: allRewards[index],
-                  stakingLedger
-                }
-              )
-            )
-          )
-        );
-      })
-    );
-  }
-  );
-}
-
-/**
- * @name stakerRewards
- * @description Staking rewards history for a given staker.
- * @param { Uint8Array | string } accountId The stakers AccountId.
- * @param { boolean } withActive Whether to include the active era.
- * @example
- * ```javascript
- * const rewards = await api.derive.staking.stakerRewards(
- *   ALICE, //Alice accountId
- *   false
- * );
- * ```
- */
-export const stakerRewards = /*#__PURE__*/ firstMemo(
-  (api: DeriveApi, accountId: Uint8Array | string, withActive?: boolean) =>
-    api.derive.staking.erasHistoric(withActive).pipe(
-      switchMap((eras) => api.derive.staking._stakerRewards([accountId], eras, withActive))
-    )
-);
-
-/**
- * @name stakerRewardsMultiEras
- * @description Staking rewards for multiple stakers over specific eras.
- * @param { Uint8Array | string } accountIds List of stakers identified by their AccountId.
- * @param { EraIndex[] } eras Eras for which to retrieve the data.
- * @example
- * ```javascript
- * const rewards = await api.derive.staking.stakerRewardsMultiEras(
- *   [ALICE, BOB, CHARLIER], //accountIds
- *   [100,101]  //eras
- * );
- * ```
- */
-export function stakerRewardsMultiEras (instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], eras: EraIndex[]) => Observable<DeriveStakerReward[][]> {
-  return memo(instanceId, (accountIds: (Uint8Array | string)[], eras: EraIndex[]): Observable<DeriveStakerReward[][]> =>
-    accountIds.length && eras.length
-      ? api.derive.staking._stakerRewards(accountIds, eras, false)
-      : of([])
-  );
-}
-
-/**
- * @name stakerRewardsMulti
- * @description Staking rewards for multiple stakers.
- * @param { Uint8Array | string } accountIds List of stakers identified by their AccountId.
- * @param { boolean } withActive Whether to include the active era.
- * @example
- * ```javascript
- * const rewards = await api.derive.staking.stakerRewardsMulti(
- *   [ALICE, BOB, CHARLIER], //accountIds
- *   true
- * );
- * ```
- */
-export function stakerRewardsMulti (instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], withActive?: boolean) => Observable<DeriveStakerReward[][]> {
-  return memo(instanceId, (accountIds: (Uint8Array | string)[], withActive = false): Observable<DeriveStakerReward[][]> =>
-    api.derive.staking.erasHistoric(withActive).pipe(
-      switchMap((eras) => api.derive.staking.stakerRewardsMultiEras(accountIds, eras))
-    )
-  );
-}

package/src/staking/stakerSlashes.ts

@@ -1,45 +0,0 @@
-// 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 { DeriveApi, DeriveStakerSlashes } from '../types.js';
-
-import { map } from 'rxjs';
-
-import { memo } from '../util/index.js';
-import { erasHistoricApplyAccount } from './util.js';
-
-export function _stakerSlashes (instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerSlashes[]> {
-  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean): Observable<DeriveStakerSlashes[]> => {
-    const stakerId = api.registry.createType('AccountId', accountId).toString();
-
-    return api.derive.staking._erasSlashes(eras, withActive).pipe(
-      map((slashes): DeriveStakerSlashes[] =>
-        slashes.map(({ era, nominators, validators }): DeriveStakerSlashes => ({
-          era,
-          total: nominators[stakerId] || validators[stakerId] || api.registry.createType('Balance')
-        }))
-      )
-    );
-  });
-}
-
-/**
- * @name stakerSlashes
- * @param { Uint8Array | string } accountId The stakers AccountId.
- * @param { boolean } withActive Whether to include the active era.
- * @description Retrieve the historical slashes (penalties) for a given staker.
- * @example
- * ```javascript
- *  const stakerSlashes = await api.derive.staking.stakerSlashes(
- *   ALICE, //Alice accountId
- *   true
- * );
- * console.log(
- *   'Staker Slashes:',
- *   stakerSlashes.map(({ era, total }) => `Era ${era}: Slashed ${total.toString()}`)
- * );
- * ```
- */
-export const stakerSlashes = /*#__PURE__*/ erasHistoricApplyAccount('_stakerSlashes');

package/src/staking/stashes.ts

@@ -1,55 +0,0 @@
-// 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 } from '../types.js';
-
-import { map, startWith, switchMap } from 'rxjs';
-
-import { drr, memo } from '../util/index.js';
-
-function onBondedEvent (api: DeriveApi): Observable<number> {
-  let current = Date.now();
-
-  return api.query.system.events().pipe(
-    map((events): number => {
-      current = events.filter(({ event, phase }): boolean => {
-        try {
-          return phase.isApplyExtrinsic &&
-            event.section === 'staking' &&
-            event.method === 'Bonded';
-        } catch {
-          return false;
-        }
-      })
-        ? Date.now()
-        : current;
-
-      return current;
-    }),
-    startWith(current),
-    drr({ skipTimeout: true })
-  );
-}
-
-/**
- * @name stashes
- * @description Retrieve the list of all validator stashes.
- * @example
- * ```javascript
- * const stashes = await api.derive.staking.stashes();
- * console.log(
- *   "Validator Stashes:",
- *   stashes.map((s) => s.toString())
- * );
- * ```
- */
-export function stashes (instanceId: string, api: DeriveApi): () => Observable<AccountId[]> {
-  return memo(instanceId, (): Observable<AccountId[]> =>
-    onBondedEvent(api).pipe(
-      switchMap(() => api.query.staking.validators.keys()),
-      map((keys) => keys.map(({ args: [v] }) => v).filter((a) => a))
-    )
-  );
-}

package/src/staking/types.ts

@@ -1,174 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Option, u32, Vec } from '@pezkuwi/types';
-import type { AccountId, Balance, EraIndex, RewardPoint } from '@pezkuwi/types/interfaces';
-import type { PalletStakingRewardDestination, PalletStakingStakingLedger, PalletStakingValidatorPrefs, SpStakingExposure, SpStakingExposurePage, SpStakingPagedExposureMetadata } from '@pezkuwi/types/lookup';
-import type { BN } from '@pezkuwi/util';
-import type { DeriveSessionIndexes } from '../session/types.js';
-
-export type DeriveEraValPoints = Record<string, RewardPoint>;
-
-export type DeriveEraValPrefs = Record<string, PalletStakingValidatorPrefs>;
-
-export type DeriveEraValSlash = Record<string, Balance>;
-
-export interface DeriveEraPoints {
-  era: EraIndex;
-  eraPoints: RewardPoint;
-  validators: DeriveEraValPoints;
-}
-
-export interface DeriveEraPrefs {
-  era: EraIndex;
-  validators: DeriveEraValPrefs;
-}
-
-export interface DeriveEraRewards {
-  era: EraIndex;
-  eraReward: Balance;
-}
-
-export interface DeriveEraSlashes {
-  era: EraIndex;
-  nominators: DeriveEraValSlash;
-  validators: DeriveEraValSlash;
-}
-
-export interface DeriveStakerPoints {
-  era: EraIndex;
-  eraPoints: RewardPoint;
-  points: RewardPoint;
-}
-
-export interface DeriveOwnExposure {
-  clipped: SpStakingExposure;
-  exposurePaged: Option<SpStakingExposurePage>;
-  era: EraIndex;
-  exposure: SpStakingExposure;
-  exposureMeta: Option<SpStakingPagedExposureMetadata>;
-}
-
-export interface DeriveEraExposureNominating {
-  validatorId: string;
-  validatorIndex: number;
-}
-
-export type DeriveEraNominatorExposure = Record<string, DeriveEraExposureNominating[]>;
-
-export type DeriveEraValidatorExposure = Record<string, SpStakingExposure>;
-
-export type DeriveEraValidatorExposurePaged = Record<string, SpStakingExposurePage | SpStakingExposure>;
-
-export interface DeriveEraExposure {
-  era: EraIndex;
-  nominators: DeriveEraNominatorExposure;
-  validators: DeriveEraValidatorExposure;
-}
-
-export interface DeriveEraExposurePaged {
-  era: EraIndex;
-  nominators: DeriveEraNominatorExposure;
-  validators: DeriveEraValidatorExposurePaged;
-}
-
-export interface DeriveStakerExposure {
-  era: EraIndex;
-  isEmpty: boolean;
-  isValidator: boolean;
-  nominating: DeriveEraExposureNominating[];
-  validators: DeriveEraValidatorExposurePaged;
-}
-
-export interface DeriveStakerPrefs {
-  era: EraIndex;
-  validatorPrefs: PalletStakingValidatorPrefs;
-}
-
-export interface DeriveStakerRewardValidator {
-  total: Balance;
-  value: Balance;
-}
-
-export interface DeriveStakerReward {
-  era: EraIndex;
-  eraReward: Balance;
-  isClaimed: boolean;
-  isEmpty: boolean;
-  isValidator: boolean;
-  nominating: DeriveEraExposureNominating[];
-  validators: Record<string, DeriveStakerRewardValidator>;
-}
-
-export interface DeriveStakerSlashes {
-  era: EraIndex;
-  total: Balance;
-}
-
-export type DeriveOwnSlashes = DeriveStakerSlashes;
-
-export interface DeriveStakingKeys {
-  nextSessionIds: AccountId[];
-  sessionIds: AccountId[];
-}
-
-export interface DeriveStakingValidators {
-  nextElected: AccountId[];
-  validators: AccountId[];
-}
-
-export interface DeriveStakingStash {
-  controllerId: AccountId | null;
-  // Legacy Support for erasStakers
-  exposureEraStakers: SpStakingExposure;
-  exposurePaged: Option<SpStakingExposurePage>;
-  exposureMeta: Option<SpStakingPagedExposureMetadata>;
-  nominators: AccountId[];
-  rewardDestination: PalletStakingRewardDestination | null;
-  stashId: AccountId;
-  validatorPrefs: PalletStakingValidatorPrefs;
-  claimedRewardsEras: Vec<u32>
-}
-
-export interface DeriveStakingQuery extends DeriveStakingStash {
-  accountId: AccountId;
-  stakingLedger: PalletStakingStakingLedger;
-}
-
-export interface DeriveStakingElected {
-  info: DeriveStakingQuery[];
-  nextElected: AccountId[];
-  validators: AccountId[];
-}
-
-export interface DeriveStakingWaiting {
-  info: DeriveStakingQuery[];
-  waiting: AccountId[];
-}
-
-export interface DeriveUnlocking {
-  remainingEras: BN;
-  value: Balance;
-}
-
-export interface DeriveStakingAccount extends DeriveStakingQuery, DeriveStakingKeys {
-  redeemable?: Balance;
-  unlocking?: DeriveUnlocking[];
-}
-
-export interface DeriveStakingOverview extends DeriveSessionIndexes {
-  nextElected: AccountId[];
-  validators: AccountId[];
-}
-
-export interface StakingQueryFlags {
-  withController?: boolean;
-  withDestination?: boolean;
-  withExposure?: boolean;
-  withExposureErasStakersLegacy?: boolean,
-  withLedger?: boolean;
-  withNominations?: boolean;
-  withPrefs?: boolean;
-  withExposureMeta?: boolean;
-  withClaimedRewardsEras?: boolean;
-}

package/src/staking/util.ts

@@ -1,94 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { ObsInnerType } from '@pezkuwi/api-base/types';
-import type { u32 } from '@pezkuwi/types';
-import type { EraIndex } from '@pezkuwi/types/interfaces';
-import type { AnyNumber } from '@pezkuwi/types-codec/types';
-import type { ExactDerive } from '../derive.js';
-import type { DeriveApi } from '../types.js';
-
-import { BehaviorSubject, combineLatest, map, of, switchMap, tap, toArray } from 'rxjs';
-
-import { arrayChunk, arrayFlatten, nextTick } from '@pezkuwi/util';
-
-import { memo } from '../util/index.js';
-
-type ApplyReturn<T extends keyof ExactDerive['staking']> = ReturnType<ExactDerive['staking'][T]>;
-
-// only retrieve a maximum of 14 eras (84 / 6) at a time
-// (This is not empirically calculated. Rather smaller sizes take longer
-// time due to the serial nature, large sizes may tie up the RPCs)
-const ERA_CHUNK_SIZE = 14;
-
-function chunkEras <T> (eras: EraIndex[], fn: (eras: EraIndex[]) => Observable<T[]>): Observable<T[]> {
-  const chunked = arrayChunk(eras, ERA_CHUNK_SIZE);
-  let index = 0;
-  const subject = new BehaviorSubject<EraIndex[]>(chunked[index]);
-
-  return subject.pipe(
-    switchMap(fn),
-    tap((): void => {
-      nextTick((): void => {
-        index++;
-
-        index === chunked.length
-          ? subject.complete()
-          : subject.next(chunked[index]);
-      });
-    }),
-    toArray(),
-    map(arrayFlatten)
-  );
-}
-
-export function filterEras <T extends { era: EraIndex }> (eras: EraIndex[], list: T[]): EraIndex[] {
-  return eras.filter((e) => !list.some(({ era }) => e.eq(era)));
-}
-
-export function erasHistoricApply <F extends '_erasExposure' | '_erasPoints' | '_erasPrefs' | '_erasRewards' | '_erasSlashes'> (fn: F): (instanceId: string, api: DeriveApi) => (withActive?: boolean) => ApplyReturn<F> {
-  return (instanceId: string, api: DeriveApi) =>
-    // Cannot quite get the typing right, but it is right in the code
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    memo(instanceId, (withActive = false) =>
-      api.derive.staking.erasHistoric(withActive).pipe(
-        switchMap((e) => api.derive.staking[fn](e, withActive))
-      )
-    ) as any;
-}
-
-export function erasHistoricApplyAccount <F extends '_ownExposures' | '_ownSlashes' | '_stakerPoints' | '_stakerPrefs' | '_stakerSlashes'> (fn: F): (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, withActive?: boolean) => ApplyReturn<F> {
-  return (instanceId: string, api: DeriveApi) =>
-    // Cannot quite get the typing right, but it is right in the code
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    memo(instanceId, (accountId: string | Uint8Array, withActive = false, page?: u32 | AnyNumber) =>
-      api.derive.staking.erasHistoric(withActive).pipe(
-        switchMap((e) => api.derive.staking[fn](accountId, e, withActive, page || 0))
-      )
-    ) as any;
-}
-
-export function singleEra <F extends '_eraExposure' | '_eraPrefs' | '_eraSlashes'> (fn: F): (instanceId: string, api: DeriveApi) => (era: EraIndex) => ApplyReturn<F> {
-  return (instanceId: string, api: DeriveApi) =>
-    // Cannot quite get the typing right, but it is right in the code
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    memo(instanceId, (era: EraIndex) =>
-      api.derive.staking[fn](era, true)
-    ) as any;
-}
-
-export function combineEras <F extends '_eraExposure' | '_eraPrefs' | '_eraSlashes'> (fn: F): (instanceId: string, api: DeriveApi) => (eras: EraIndex[], withActive: boolean) => Observable<ObsInnerType<ApplyReturn<F>>[]> {
-  return (instanceId: string, api: DeriveApi) =>
-    // Cannot quite get the typing right, but it is right in the code
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    memo(instanceId, (eras: EraIndex[], withActive: boolean) =>
-      !eras.length
-        ? of([])
-        : chunkEras(eras, (eras) =>
-          combineLatest(
-            eras.map((e) => api.derive.staking[fn](e, withActive))
-          )
-        )
-    ) as any;
-}