@pezkuwi/api-derive 16.5.5

package/src/session/progress.ts

@@ -0,0 +1,130 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { Option, u64 } from '@pezkuwi/types';
+import type { BlockNumber, SessionIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveSessionInfo, DeriveSessionProgress } from '../types.js';
+
+import { combineLatest, map, of, switchMap } from 'rxjs';
+
+import { objectSpread } from '@pezkuwi/util';
+
+import { memo } from '../util/index.js';
+
+type ResultSlotsNoSession = [u64, u64, u64];
+type ResultSlots = [u64, u64, u64, Option<SessionIndex>];
+type ResultSlotsFlat = [u64, u64, u64, SessionIndex];
+
+function withProgressField (field: 'eraLength' | 'eraProgress' | 'sessionProgress'): (instanceId: string, api: DeriveApi) => () => Observable<BlockNumber> {
+  return (instanceId: string, api: DeriveApi) =>
+    memo(instanceId, (): Observable<BlockNumber> =>
+      api.derive.session.progress().pipe(
+        map((info) => info[field])
+      )
+    );
+}
+
+function createDerive (api: DeriveApi, info: DeriveSessionInfo, [currentSlot, epochIndex, epochOrGenesisStartSlot, activeEraStartSessionIndex]: ResultSlotsFlat): DeriveSessionProgress {
+  const epochStartSlot = epochIndex.mul(info.sessionLength).iadd(epochOrGenesisStartSlot);
+  const sessionProgress = currentSlot.sub(epochStartSlot);
+  const eraProgress = info.currentIndex.sub(activeEraStartSessionIndex).imul(info.sessionLength).iadd(sessionProgress);
+
+  return objectSpread({
+    eraProgress: api.registry.createType('BlockNumber', eraProgress),
+    sessionProgress: api.registry.createType('BlockNumber', sessionProgress)
+  }, info);
+}
+
+function queryAura (api: DeriveApi): Observable<DeriveSessionProgress> {
+  return api.derive.session.info().pipe(
+    map((info): DeriveSessionProgress =>
+      objectSpread({
+        eraProgress: api.registry.createType('BlockNumber'),
+        sessionProgress: api.registry.createType('BlockNumber')
+      }, info)
+    )
+  );
+}
+
+function queryBabe (api: DeriveApi): Observable<[DeriveSessionInfo, ResultSlotsFlat]> {
+  return api.derive.session.info().pipe(
+    switchMap((info): Observable<[DeriveSessionInfo, ResultSlots | ResultSlotsNoSession]> =>
+      combineLatest([
+        of(info),
+        // we may have no staking, but have babe (permissioned)
+        api.query.staking?.erasStartSessionIndex
+          ? api.queryMulti<ResultSlots>([
+            api.query.babe.currentSlot,
+            api.query.babe.epochIndex,
+            api.query.babe.genesisSlot,
+            [api.query.staking.erasStartSessionIndex, info.activeEra]
+          ])
+          : api.queryMulti<ResultSlotsNoSession>([
+            api.query.babe.currentSlot,
+            api.query.babe.epochIndex,
+            api.query.babe.genesisSlot
+          ])
+      ])
+    ),
+    map(([info, [currentSlot, epochIndex, genesisSlot, optStartIndex]]): [DeriveSessionInfo, ResultSlotsFlat] => [
+      info, [currentSlot, epochIndex, genesisSlot, optStartIndex && optStartIndex.isSome ? optStartIndex.unwrap() : api.registry.createType('SessionIndex', 1)]
+    ])
+  );
+}
+
+/**
+ * @name progress
+ * @description Retrieves session information and progress.
+ * @example
+ * ```javascript
+ * api.derive.session.progress((progress) => {
+ *   console.log(`Session progress ${JSON.stringify(progress)}`);
+ * });
+ * ```
+ */
+export function progress (instanceId: string, api: DeriveApi): () => Observable<DeriveSessionProgress> {
+  return memo(instanceId, (): Observable<DeriveSessionProgress> =>
+    api.query.babe
+      ? queryBabe(api).pipe(
+        map(([info, slots]: [DeriveSessionInfo, ResultSlotsFlat]): DeriveSessionProgress =>
+          createDerive(api, info, slots)
+        )
+      )
+      : queryAura(api)
+  );
+}
+
+/**
+ * @name eraLenght
+ * @description Retrieves the total length of the current era.
+ * @example
+ * ```javascript
+ * api.derive.session.eraLength((length) => {
+ *   console.log(`Current era length: ${length} sessions`);
+ * });
+ * ```
+ */
+export const eraLength = /*#__PURE__*/ withProgressField('eraLength');
+/**
+ * @name eraProgress
+ * @description Retrieves the progress of the current era.
+ * @example
+ * ```javascript
+ * api.derive.session.eraProgress((progress) => {
+ *   console.log(`Current era progress: ${progress} sessions`);
+ * });
+ * ```
+ */
+export const eraProgress = /*#__PURE__*/ withProgressField('eraProgress');
+/**
+ * @name sessionProgress
+ * @description Retrieves the progress of the current session.
+ * @example
+ * ```javascript
+ *   api.derive.session.sessionProgress((progress) => {
+ *   console.log(`Current session progress: ${progress} slots`);
+ * });
+ * ```
+ */
+export const sessionProgress = /*#__PURE__*/ withProgressField('sessionProgress');

package/src/session/types.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Option, u32, u64 } from '@pezkuwi/types';
+import type { BlockNumber, EraIndex, Moment, SessionIndex } from '@pezkuwi/types/interfaces';
+
+export interface DeriveSessionIndexes {
+  activeEra: EraIndex;
+  activeEraStart: Option<Moment>;
+  currentEra: EraIndex;
+  currentIndex: SessionIndex;
+  validatorCount: u32;
+}
+
+export interface DeriveSessionInfo extends DeriveSessionIndexes {
+  eraLength: BlockNumber;
+  isEpoch: boolean;
+  sessionLength: u64;
+  sessionsPerEra: SessionIndex;
+}
+
+export interface DeriveSessionProgress extends DeriveSessionInfo {
+  eraProgress: BlockNumber;
+  sessionProgress: BlockNumber;
+}

package/src/society/candidates.ts

@@ -0,0 +1,71 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { AccountId32, BalanceOf } from '@pezkuwi/types/interfaces';
+import type { PalletSocietyBid, PalletSocietyBidKind, PalletSocietyCandidacy } from '@pezkuwi/types/lookup';
+import type { ITuple } from '@pezkuwi/types/types';
+import type { Option, Vec } from '@pezkuwi/types-codec';
+import type { DeriveApi, DeriveSocietyCandidate } from '../types.js';
+
+import { combineLatest, map, of, switchMap } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+type ResultSuspend = Option<ITuple<[BalanceOf, PalletSocietyBidKind]>>;
+type Result = [PalletSocietyBid[], ResultSuspend[]]
+
+function getPrev (api: DeriveApi): Observable<DeriveSocietyCandidate[]> {
+  return api.query.society.candidates<Vec<PalletSocietyBid>>().pipe(
+    switchMap((candidates): Observable<Result> =>
+      combineLatest([
+        of(candidates),
+        api.query.society['suspendedCandidates'].multi<Option<ITuple<[BalanceOf, PalletSocietyBidKind]>>>(
+          candidates.map(({ who }) => who)
+        )
+      ])
+    ),
+    map(([candidates, suspended]: Result): DeriveSocietyCandidate[] =>
+      candidates.map(({ kind, value, who }, index) => ({
+        accountId: who,
+        isSuspended: suspended[index].isSome,
+        kind,
+        value
+      }))
+    )
+  );
+}
+
+function getCurr (api: DeriveApi) {
+  return api.query.society.candidates.entries().pipe(
+    map((entries) =>
+      entries
+        .filter(([, opt]) => opt.isSome)
+        .map(([{ args: [accountId] }, opt]): [AccountId32, PalletSocietyCandidacy] => [accountId, opt.unwrap()])
+        // FIXME We are missing the new fields from the candidate record
+        .map(([accountId, { bid, kind }]) => ({
+          accountId,
+          isSuspended: false,
+          kind,
+          value: bid
+        }))
+    )
+  );
+}
+
+/**
+ * @name candidate
+ * @description Retrieves the list of candidates for the society module.
+ * @example
+ * ```javascript
+ * const societyCandidates = await api.derive.society.candidates();
+ * console.log(societyCandidates);
+ * ```
+ */
+export function candidates (instanceId: string, api: DeriveApi): () => Observable<DeriveSocietyCandidate[]> {
+  return memo(instanceId, (): Observable<DeriveSocietyCandidate[]> =>
+    api.query.society['suspendedCandidates'] && api.query.society.candidates.creator.meta.type.isPlain
+      ? getPrev(api)
+      : getCurr(api)
+  );
+}

package/src/society/index.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './candidates.js';
+export * from './info.js';
+export * from './member.js';
+export * from './members.js';

package/src/society/info.ts

@@ -0,0 +1,50 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { Option, u32, Vec } from '@pezkuwi/types';
+import type { AccountId, BalanceOf } from '@pezkuwi/types/interfaces';
+import type { PalletSocietyBid } from '@pezkuwi/types/lookup';
+import type { DeriveApi, DeriveSociety } from '../types.js';
+
+import { combineLatest, map, of } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+type Result = [Vec<PalletSocietyBid>, Option<AccountId> | undefined, Option<AccountId>, Option<AccountId>, u32 | undefined, BalanceOf]
+
+/**
+ * @name info
+ * @description Get the overall info for a society.
+ * @example
+ * ```javascript
+ * const societyInfo = await api.derive.society.candidates();
+ * console.log(societyInfo);
+ * ```
+ */
+export function info (instanceId: string, api: DeriveApi): () => Observable<DeriveSociety> {
+  return memo(instanceId, (): Observable<DeriveSociety> =>
+    combineLatest<Result>([
+      api.query.society.bids(),
+      api.query.society['defender']
+        ? api.query.society['defender']<Option<AccountId>>()
+        : of(undefined),
+      api.query.society.founder(),
+      api.query.society.head(),
+      api.query.society['maxMembers']
+        ? api.query.society['maxMembers']<u32>()
+        : of(undefined),
+      api.query.society.pot()
+    ]).pipe(
+      map(([bids, defender, founder, head, maxMembers, pot]: Result): DeriveSociety => ({
+        bids,
+        defender: defender?.unwrapOr(undefined),
+        founder: founder.unwrapOr(undefined),
+        hasDefender: (defender?.isSome && head.isSome && !head.eq(defender)) || false,
+        head: head.unwrapOr(undefined),
+        maxMembers,
+        pot
+      }))
+    )
+  );
+}

package/src/society/member.ts

@@ -0,0 +1,28 @@
+// 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, DeriveSocietyMember } from '../types.js';
+
+import { map } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+/**
+ * @name member
+ * @description Get the member info for a society.
+ * @param { AccountId } accountId
+ * @example
+ * ```javascript
+ * const member = await api.derive.society.member(ALICE);
+ * console.log(member);
+ * ```
+ */
+export function member (instanceId: string, api: DeriveApi): (accountId: AccountId) => Observable<DeriveSocietyMember> {
+  return memo(instanceId, (accountId: AccountId): Observable<DeriveSocietyMember> =>
+    api.derive.society._members([accountId]).pipe(
+      map(([result]) => result)
+    )
+  );
+}

package/src/society/members.ts

@@ -0,0 +1,107 @@
+// 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 { PalletSocietyVote, PalletSocietyVouchingStatus } from '@pezkuwi/types/lookup';
+import type { ITuple } from '@pezkuwi/types/types';
+import type { bool, Option, u32, u128, Vec } from '@pezkuwi/types-codec';
+import type { DeriveApi, DeriveSocietyMember } from '../types.js';
+
+import { combineLatest, map, of, switchMap } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+function _membersPrev (api: DeriveApi, accountIds: AccountId[]): Observable<DeriveSocietyMember[]> {
+  return combineLatest([
+    of(accountIds),
+    api.query.society.payouts.multi<Vec<ITuple<[u32, u128]>>>(accountIds),
+    api.query.society['strikes'].multi<u32>(accountIds),
+    api.query.society.defenderVotes.multi<Option<PalletSocietyVote>>(accountIds),
+    api.query.society.suspendedMembers.multi<bool>(accountIds),
+    api.query.society['vouching'].multi<Option<PalletSocietyVouchingStatus>>(accountIds)
+  ]).pipe(
+    map(([accountIds, payouts, strikes, defenderVotes, suspended, vouching]) =>
+      accountIds.map((accountId, index) => ({
+        accountId,
+        isDefenderVoter: defenderVotes[index].isSome,
+        isSuspended: suspended[index].isTrue,
+        payouts: payouts[index],
+        strikes: strikes[index],
+        vote: defenderVotes[index].unwrapOr(undefined),
+        vouching: vouching[index].unwrapOr(undefined)
+      }))
+    )
+  );
+}
+
+function _membersCurr (api: DeriveApi, accountIds: AccountId[]): Observable<DeriveSocietyMember[]> {
+  return combineLatest([
+    of(accountIds),
+    api.query.society.members.multi(accountIds),
+    api.query.society.payouts.multi(accountIds),
+    api.query.society.challengeRoundCount().pipe(
+      switchMap((round) =>
+        api.query.society.defenderVotes.multi(accountIds.map((accountId) => [round, accountId]))
+      )
+    ),
+    api.query.society.suspendedMembers.multi(accountIds)
+  ]).pipe(
+    map(([accountIds, members, payouts, defenderVotes, suspendedMembers]) =>
+      accountIds
+        .map((accountId, index) =>
+          members[index].isSome
+            ? {
+              accountId,
+              isDefenderVoter: defenderVotes[index].isSome,
+              isSuspended: suspendedMembers[index].isSome,
+              member: members[index].unwrap(),
+              payouts: payouts[index].payouts
+            }
+            : null
+        )
+        .filter((m): m is NonNullable<typeof m> => !!m)
+        .map(({ accountId, isDefenderVoter, isSuspended, member, payouts }) => ({
+          accountId,
+          isDefenderVoter,
+          isSuspended,
+          payouts,
+          strikes: member.strikes,
+          vouching: member.vouching.unwrapOr(undefined)
+        }))
+    )
+  );
+}
+
+export function _members (instanceId: string, api: DeriveApi): (accountIds: AccountId[]) => Observable<DeriveSocietyMember[]> {
+  return memo(instanceId, (accountIds: AccountId[]): Observable<DeriveSocietyMember[]> =>
+    api.query.society.members.creator.meta.type.isMap
+      ? _membersCurr(api, accountIds)
+      : _membersPrev(api, accountIds)
+  );
+}
+
+/**
+ * @name members
+ * @description Get the society members.
+ * @example
+ * ```javascript
+ * const members = await api.derive.society.members();
+ * console.log(members);
+ * ```
+ */
+export function members (instanceId: string, api: DeriveApi): () => Observable<DeriveSocietyMember[]> {
+  return memo(instanceId, (): Observable<DeriveSocietyMember[]> =>
+    api.query.society.members.creator.meta.type.isMap
+      ? api.query.society.members.keys().pipe(
+        switchMap((keys) =>
+          api.derive.society._members(
+            keys.map(({ args: [accountId] }) => accountId)
+          )
+        )
+      )
+      : api.query.society.members<Vec<AccountId>>().pipe(
+        switchMap((members) => api.derive.society._members(members))
+      )
+  );
+}

package/src/society/types.ts

@@ -0,0 +1,33 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { u32 } from '@pezkuwi/types';
+import type { AccountId, Balance, BalanceOf, BlockNumber, StrikeCount } from '@pezkuwi/types/interfaces';
+import type { PalletSocietyBid, PalletSocietyBidKind, PalletSocietyVote, PalletSocietyVouchingStatus } from '@pezkuwi/types/lookup';
+
+export interface DeriveSociety {
+  bids: PalletSocietyBid[];
+  defender?: AccountId | undefined;
+  hasDefender: boolean;
+  head?: AccountId | undefined;
+  founder?: AccountId | undefined;
+  maxMembers?: u32 | undefined;
+  pot: BalanceOf;
+}
+
+export interface DeriveSocietyCandidate {
+  accountId: AccountId;
+  kind: PalletSocietyBidKind;
+  value: Balance;
+  isSuspended: boolean;
+}
+
+export interface DeriveSocietyMember {
+  accountId: AccountId;
+  isDefenderVoter: boolean;
+  isSuspended: boolean;
+  payouts: [BlockNumber, Balance][];
+  strikes: StrikeCount;
+  vote?: PalletSocietyVote | undefined;
+  vouching?: PalletSocietyVouchingStatus | undefined;
+}

package/src/staking/account.ts

@@ -0,0 +1,112 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { Balance } from '@pezkuwi/types/interfaces';
+import type { PalletStakingStakingLedger, PalletStakingUnlockChunk } from '@pezkuwi/types/lookup';
+import type { DeriveApi, DeriveSessionInfo, DeriveStakingAccount, DeriveStakingKeys, DeriveStakingQuery, DeriveUnlocking } from '../types.js';
+import type { StakingQueryFlags } from './types.js';
+
+import { combineLatest, map, switchMap } from 'rxjs';
+
+import { BN, BN_ZERO, objectSpread } from '@pezkuwi/util';
+
+import { firstMemo, memo } from '../util/index.js';
+
+const QUERY_OPTS = {
+  withDestination: true,
+  withLedger: true,
+  withNominations: true,
+  withPrefs: true
+};
+
+function groupByEra (list: PalletStakingUnlockChunk[]): Record<string, BN> {
+  return list.reduce((map: Record<string, BN>, { era, value }): Record<string, BN> => {
+    const key = era.toString();
+
+    map[key] = (map[key] || BN_ZERO).add(value.unwrap());
+
+    return map;
+  }, {});
+}
+
+function calculateUnlocking (api: DeriveApi, stakingLedger: PalletStakingStakingLedger | undefined, sessionInfo: DeriveSessionInfo): DeriveUnlocking[] | undefined {
+  const results = Object
+    .entries(groupByEra(
+      (stakingLedger?.unlocking || []).filter(({ era }) => era.unwrap().gt(sessionInfo.activeEra))
+    ))
+    .map(([eraString, value]): DeriveUnlocking => ({
+      remainingEras: new BN(eraString).isub(sessionInfo.activeEra),
+      value: api.registry.createType('Balance', value)
+    }));
+
+  return results.length
+    ? results
+    : undefined;
+}
+
+function redeemableSum (api: DeriveApi, stakingLedger: PalletStakingStakingLedger | undefined, sessionInfo: DeriveSessionInfo): Balance {
+  return api.registry.createType('Balance', (stakingLedger?.unlocking || [] as PalletStakingUnlockChunk[]).reduce((total, { era, value }): BN => {
+    // aligns with https://github.com/paritytech/substrate/blob/fdfdc73f9e64dc47934b72eb9af3e1989e4ba699/frame/staking/src/pallet/mod.rs#L973-L975
+    // (ensure currentEra >= era passed, as per https://github.com/paritytech/substrate/blob/fdfdc73f9e64dc47934b72eb9af3e1989e4ba699/frame/staking/src/lib.rs#L477-L494)
+    // NOTE: Previously we used activeEra >= era, which is incorrect for the last session
+    return era.unwrap().gt(sessionInfo.currentEra)
+      ? total
+      : total.iadd(value.unwrap());
+  }, new BN(0)));
+}
+
+function parseResult (api: DeriveApi, sessionInfo: DeriveSessionInfo, keys: DeriveStakingKeys, query: DeriveStakingQuery): DeriveStakingAccount {
+  return objectSpread({}, keys, query, {
+    redeemable: redeemableSum(api, query.stakingLedger, sessionInfo),
+    unlocking: calculateUnlocking(api, query.stakingLedger, sessionInfo)
+  });
+}
+
+/**
+ * @name accounts
+ * @param {(Uint8Array | string)[]} accountIds List of account stashes
+ * @param {StakingQueryFlags} opts optional filtering flag
+ * @description From a list of stashes, fill in all the relevant staking details
+ * @example
+ * ```javascript
+ * const accounts = await api.derive.staking.accounts([
+ *  "149B17nn7zVL4SkLSNmANupEkGexUBAxVrdk4bbWFZYibkFc",
+ * ]);
+ * console.log("First account staking info:", accounts[0]);
+ * ```
+ */
+export function accounts (instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], opts?: StakingQueryFlags) => Observable<DeriveStakingAccount[]> {
+  return memo(instanceId, (accountIds: (Uint8Array | string)[], opts: StakingQueryFlags = QUERY_OPTS): Observable<DeriveStakingAccount[]> =>
+    api.derive.session.info().pipe(
+      switchMap((sessionInfo) =>
+        combineLatest([
+          api.derive.staking.keysMulti(accountIds),
+          api.derive.staking.queryMulti(accountIds, opts)
+        ]).pipe(
+          map(([keys, queries]) =>
+            queries.map((q, index) => parseResult(api, sessionInfo, keys[index], q))
+          )
+        )
+      )
+    )
+  );
+}
+
+/**
+ * @name account
+ * @param {(Uint8Array | string)} accountId AccountId of the stash.
+ * @param {StakingQueryFlags} opts (Optional) filtering flag.
+ * @description From a stash, retrieve the controllerId and fill in all the relevant staking details.
+ * @example
+ * ```javascript
+ * const accountStakingData = await api.derive.staking.account(
+ *   "149B17nn7zVL4SkLSNmANupEkGexUBAxVrdk4bbWFZYibkFc"
+ * );
+ * console.log(accountStakingData);
+ * ```
+ */
+export const account = /*#__PURE__*/ firstMemo(
+  (api: DeriveApi, accountId: Uint8Array | string, opts?: StakingQueryFlags) =>
+    api.derive.staking.accounts([accountId], opts)
+);

package/src/staking/cache.ts

@@ -0,0 +1,48 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+
+import { deriveCache } from '../util/index.js';
+
+export function getEraCache <T> (CACHE_KEY: string, era: EraIndex, withActive?: boolean): [string, T | undefined] {
+  const cacheKey = `${CACHE_KEY}-${era.toString()}`;
+
+  return [
+    cacheKey,
+    withActive
+      ? undefined
+      : deriveCache.get<T>(cacheKey)
+  ];
+}
+
+export function getEraMultiCache <T> (CACHE_KEY: string, eras: EraIndex[], withActive?: boolean): T[] {
+  const cached: T[] = withActive
+    ? []
+    : eras
+      .map((e) => deriveCache.get<T>(`${CACHE_KEY}-${e.toString()}`))
+      .filter((v): v is T => !!v);
+
+  return cached;
+}
+
+export function setEraCache <T extends { era: EraIndex }> (cacheKey: string, withActive: boolean, value: T): T {
+  !withActive && deriveCache.set(cacheKey, value);
+
+  return value;
+}
+
+export function setEraMultiCache <T extends { era: EraIndex }> (CACHE_KEY: string, withActive: boolean, values: T[]): T[] {
+  !withActive && values.forEach((v) => deriveCache.set(`${CACHE_KEY}-${v.era.toString()}`, v));
+
+  return values;
+}
+
+export function filterCachedEras <T extends { era: EraIndex }> (eras: EraIndex[], cached: T[], query: T[]): T[] {
+  return eras
+    .map((e) =>
+      cached.find(({ era }) => e.eq(era)) ||
+      query.find(({ era }) => e.eq(era))
+    )
+    .filter((e): e is T => !!e);
+}

package/src/staking/currentPoints.ts

@@ -0,0 +1,28 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { PalletStakingEraRewardPoints } from '@pezkuwi/types/lookup';
+import type { DeriveApi } from '../types.js';
+
+import { switchMap } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+/**
+ * @name currentPoints
+ * @description Retrieve the staking overview, including elected and points earned.
+ * @example
+ * ```javascript
+ * const currentPoints = await api.derive.staking.currentPoints();
+ * console.log(currentPoints.toHuman());
+ * ```
+ */
+export function currentPoints (instanceId: string, api: DeriveApi): () => Observable<PalletStakingEraRewardPoints> {
+  return memo(instanceId, (): Observable<PalletStakingEraRewardPoints> =>
+    api.derive.session.indexes().pipe(
+      switchMap(({ activeEra }) =>
+        api.query.staking.erasRewardPoints(activeEra)
+      )
+    ));
+}