@pezkuwi/api-derive 16.5.5

package/src/staking/ownExposure.ts

@@ -0,0 +1,83 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { Option, u32 } from '@pezkuwi/types';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { SpStakingExposure, SpStakingExposurePage, SpStakingPagedExposureMetadata } from '@pezkuwi/types/lookup';
+import type { AnyNumber } from '@pezkuwi/types-codec/types';
+import type { DeriveApi, DeriveOwnExposure } from '../types.js';
+
+import { combineLatest, map, of } from 'rxjs';
+
+import { firstMemo, memo } from '../util/index.js';
+import { erasHistoricApplyAccount } from './util.js';
+
+export function _ownExposures (instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean, page: u32 | AnyNumber) => Observable<DeriveOwnExposure[]> {
+  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], _withActive: boolean, page: u32 | AnyNumber): Observable<DeriveOwnExposure[]> => {
+    const emptyStakingExposure = api.registry.createType<SpStakingExposure>('Exposure');
+    // The reason we don't explicitly make the actual types is for compatibility. If the chain doesn't have the noted type it will fail
+    // on construction. Therefore we just make an empty option.
+    const emptyOptionPage = api.registry.createType<Option<SpStakingExposurePage>>('Option<Null>');
+    const emptyOptionMeta = api.registry.createType<Option<SpStakingPagedExposureMetadata>>('Option<Null>');
+
+    return eras.length
+      ? combineLatest([
+        // Backwards and forward compat for historical integrity when using `erasHistoricApplyAccount`
+        api.query.staking.erasStakersClipped
+          ? combineLatest(eras.map((e) => api.query.staking.erasStakersClipped(e, accountId)))
+          : of(eras.map((_) => emptyStakingExposure)),
+        api.query.staking.erasStakers
+          ? combineLatest(eras.map((e) => api.query.staking.erasStakers(e, accountId)))
+          : of(eras.map((_) => emptyStakingExposure)),
+        api.query.staking.erasStakersPaged
+          ? combineLatest(eras.map((e) => api.query.staking.erasStakersPaged<Option<SpStakingExposurePage>>(e, accountId, page)))
+          : of(eras.map((_) => emptyOptionPage)),
+        api.query.staking.erasStakersOverview
+          ? combineLatest(eras.map((e) => api.query.staking.erasStakersOverview(e, accountId)))
+          : of(eras.map((_) => emptyOptionMeta))
+      ]).pipe(
+        map(([clp, exp, paged, expMeta]): DeriveOwnExposure[] =>
+          eras.map((era, index) => ({ clipped: clp[index], era, exposure: exp[index], exposureMeta: expMeta[index], exposurePaged: paged[index] }))
+        )
+      )
+      : of([]);
+  }
+  );
+}
+
+/**
+ * @name ownExposure
+ * @description Retrieves the staking exposure of a validator for a specific era, including their own stake.
+ * @param { Uint8Array | string } accountId The validator stash account.
+ * @param {EraIndex} era The staking era to query.
+ * @param { u32 | AnyNumber } page? (Optional) The pagination index.
+ * @example
+ * ```javascript
+ * const era = api.createType("EraIndex", 1000);
+ * const exposure = await api.derive.staking.ownExposure(
+ *   "11VR4pF6c7kfBhfmuwwjWY3FodeYBKWx7ix2rsRCU2q6hqJ",
+ *   era
+ * );
+ * console.log(JSON.stringify(exposure));
+ * ```
+ */
+export const ownExposure = /*#__PURE__*/ firstMemo(
+  (api: DeriveApi, accountId: Uint8Array | string, era: EraIndex, page?: u32 | AnyNumber) =>
+    api.derive.staking._ownExposures(accountId, [era], true, page || 0)
+);
+
+/**
+ * @name ownExposures
+ * @description Retrieves staking exposures for a validator across multiple historical eras.
+ * @param { Uint8Array | string } accountId The validator stash account.
+ * @param { boolean } withActive Whether to include the active era.
+ * @example
+ * ```javascript
+ * const exposures = await api.derive.staking.ownExposures(
+ *   ALICE,
+ *   true
+ * );
+ * ```
+ */
+export const ownExposures = /*#__PURE__*/ erasHistoricApplyAccount('_ownExposures');

package/src/staking/ownSlashes.ts

@@ -0,0 +1,68 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { BalanceOf, EraIndex, Perbill } from '@pezkuwi/types/interfaces';
+import type { ITuple } from '@pezkuwi/types/types';
+import type { DeriveApi, DeriveStakerSlashes } from '../types.js';
+
+import { combineLatest, map, of } from 'rxjs';
+
+import { firstMemo, memo } from '../util/index.js';
+import { erasHistoricApplyAccount } from './util.js';
+
+export function _ownSlashes (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[]> =>
+    eras.length
+      ? combineLatest([
+        combineLatest(eras.map((e) => api.query.staking.validatorSlashInEra(e, accountId))),
+        combineLatest(eras.map((e) => api.query.staking.nominatorSlashInEra(e, accountId)))
+      ]).pipe(
+        map(([vals, noms]): DeriveStakerSlashes[] =>
+          eras.map((era, index) => ({
+            era,
+            total: vals[index].isSome
+              ? (vals[index].unwrap() as ITuple<[Perbill, BalanceOf]>)[1]
+              : (noms[index].unwrapOrDefault() as BalanceOf)
+          }))
+        )
+      )
+      : of([])
+  );
+}
+
+/**
+ * @name ownSlash
+ * @description Retrieves the slashes applied to a specific account in a given era.
+ * @param { Uint8Array | string } accountId The validator stash account.
+ * @param {EraIndex} era The staking era to query.
+ * @example
+ * ```javascript
+ * const era = api.createType("EraIndex", 1000);
+ * const slashedAmount = await api.derive.staking.ownSlash(
+ *   ALICE,
+ *   era
+ * );
+ * console.log(`Era: ${slashedAmount.era}, total ${slashedAmount.total}`);
+ * ```
+ */
+export const ownSlash = /*#__PURE__*/ firstMemo(
+  (api: DeriveApi, accountId: Uint8Array | string, era: EraIndex) =>
+    api.derive.staking._ownSlashes(accountId, [era], true)
+);
+
+/**
+ * @name ownSlashes
+ * @description Retrieves the slashes for a specific account across all historic eras.
+ * @param { Uint8Array | string } accountId The validator stash account.
+ * @param { boolean } withActive Whether to include the active era.
+ * @example
+ * ```javascript
+ * const slashes = await api.derive.staking.ownSlashes(
+ *   ALICE,
+ *   true
+ * );
+ * console.log(slashes);
+ * ```
+ */
+export const ownSlashes = /*#__PURE__*/ erasHistoricApplyAccount('_ownSlashes');

package/src/staking/query.ts

@@ -0,0 +1,230 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { Option, StorageKey, u32, Vec } from '@pezkuwi/types';
+import type { AccountId, EraIndex } from '@pezkuwi/types/interfaces';
+import type { PalletStakingNominations, PalletStakingRewardDestination, PalletStakingStakingLedger, PalletStakingValidatorPrefs, SpStakingExposure, SpStakingExposurePage, SpStakingPagedExposureMetadata } from '@pezkuwi/types/lookup';
+import type { AnyNumber } from '@pezkuwi/types-codec/types';
+import type { DeriveApi, DeriveStakingQuery, StakingQueryFlags } from '../types.js';
+
+import { combineLatest, map, of, switchMap } from 'rxjs';
+
+import { firstMemo, memo } from '../util/index.js';
+
+// handle compatibility between generations of structures
+function rewardDestinationCompat (rewardDestination: PalletStakingRewardDestination | Option<PalletStakingRewardDestination>): PalletStakingRewardDestination | null {
+  // We ensure the type is an Option by checking if isSome is a boolean. When isSome doesn't exist it will always return undefined.
+  return typeof (rewardDestination as Option<PalletStakingRewardDestination>).isSome === 'boolean'
+    ? (rewardDestination as Option<PalletStakingRewardDestination>).unwrapOr(null)
+    : (rewardDestination as PalletStakingRewardDestination);
+}
+
+function filterClaimedRewards (api: DeriveApi, cl: number[]): Vec<u32> {
+  return api.registry.createType('Vec<u32>', cl.filter((c) => c !== -1));
+}
+
+function filterRewards (stashIds: AccountId[], eras: number[], claimedRewards: [StorageKey<[u32, AccountId]>, Vec<u32>][], stakersOverview: [StorageKey<[u32, AccountId]>, Option<SpStakingPagedExposureMetadata>][]): number[][] {
+  const claimedData: Record<string, Map<number, u32[]>> = {};
+  const overviewData: Record<string, Map<number, u32>> = {};
+  const ids = stashIds.map((i) => i.toString());
+
+  claimedRewards.forEach(([keys, rewards]) => {
+    const id = keys.args[1].toString();
+    const era = keys.args[0].toNumber();
+
+    if (ids.includes(id)) {
+      if (claimedData[id]) {
+        claimedData[id].set(era, rewards.toArray());
+      } else {
+        claimedData[id] = new Map();
+        claimedData[id].set(era, rewards.toArray());
+      }
+    }
+  });
+
+  stakersOverview.forEach(([keys, overview]) => {
+    const id = keys.args[1].toString();
+    const era = keys.args[0].toNumber();
+
+    if (ids.includes(id) && overview.isSome) {
+      if (overviewData[id]) {
+        overviewData[id].set(era, overview.unwrap().pageCount);
+      } else {
+        overviewData[id] = new Map();
+        overviewData[id].set(era, overview.unwrap().pageCount);
+      }
+    }
+  });
+
+  return stashIds.map((id) => {
+    const rewardsPerEra = claimedData[id.toString()];
+    const overviewPerEra = overviewData[id.toString()];
+
+    return eras.map((era) => {
+      if (rewardsPerEra && rewardsPerEra.has(era) && overviewPerEra && overviewPerEra.has(era)) {
+        const rewards = rewardsPerEra.get(era) as unknown as u32[];
+        const pageCount = overviewPerEra.get(era) as unknown as u32;
+
+        return rewards.length === pageCount.toNumber()
+          ? era
+          : -1;
+      }
+
+      return -1;
+    });
+  });
+}
+
+function parseDetails (api: DeriveApi, stashId: AccountId, controllerIdOpt: Option<AccountId> | null, nominatorsOpt: Option<PalletStakingNominations>, rewardDestinationOpts: Option<PalletStakingRewardDestination> | PalletStakingRewardDestination, validatorPrefs: PalletStakingValidatorPrefs, exposure: Option<SpStakingExposurePage>, stakingLedgerOpt: Option<PalletStakingStakingLedger>, exposureMeta: Option<SpStakingPagedExposureMetadata>, claimedRewards: number[], exposureEraStakers: SpStakingExposure): DeriveStakingQuery {
+  return {
+    accountId: stashId,
+    claimedRewardsEras: filterClaimedRewards(api, claimedRewards),
+    controllerId: controllerIdOpt?.unwrapOr(null) || null,
+    exposureEraStakers,
+    exposureMeta,
+    exposurePaged: exposure,
+    nominators: nominatorsOpt.isSome
+      ? nominatorsOpt.unwrap().targets
+      : [],
+    rewardDestination: rewardDestinationCompat(rewardDestinationOpts),
+    stakingLedger: stakingLedgerOpt.unwrapOrDefault(),
+    stashId,
+    validatorPrefs
+  };
+}
+
+function getLedgers (api: DeriveApi, optIds: (Option<AccountId> | null)[], { withLedger = false }: StakingQueryFlags): Observable<Option<PalletStakingStakingLedger>[]> {
+  const ids = optIds
+    .filter((o): o is Option<AccountId> => withLedger && !!o && o.isSome)
+    .map((o) => o.unwrap());
+  const emptyLed = api.registry.createType<Option<PalletStakingStakingLedger>>('Option<StakingLedger>');
+
+  return (
+    ids.length
+      ? combineLatest(ids.map((s) => api.query.staking.ledger(s)))
+      : of([])
+  ).pipe(
+    map((optLedgers): Option<PalletStakingStakingLedger>[] => {
+      let offset = -1;
+
+      return optIds.map((o): Option<PalletStakingStakingLedger> =>
+        o && o.isSome
+          ? optLedgers[++offset] || emptyLed
+          : emptyLed
+      );
+    })
+  );
+}
+
+function getStashInfo (api: DeriveApi, stashIds: AccountId[], activeEra: EraIndex, { withClaimedRewardsEras, withController, withDestination, withExposure, withExposureErasStakersLegacy, withExposureMeta, withLedger, withNominations, withPrefs }: StakingQueryFlags, page: u32 | AnyNumber): Observable<[(Option<AccountId> | null)[], Option<PalletStakingNominations>[], Option<PalletStakingRewardDestination>[], PalletStakingValidatorPrefs[], Option<SpStakingExposurePage>[], Option<SpStakingPagedExposureMetadata>[], number[][], SpStakingExposure[]]> {
+  const emptyNoms = api.registry.createType<Option<PalletStakingNominations>>('Option<Nominations>');
+  const emptyRewa = api.registry.createType<Option<PalletStakingRewardDestination>>('RewardDestination');
+  const emptyExpoEraStakers = api.registry.createType<SpStakingExposure>('Exposure');
+  const emptyPrefs = api.registry.createType<PalletStakingValidatorPrefs>('ValidatorPrefs');
+  // The reason we don't explicitly make the actual types is for compatibility. If the chain doesn't have the noted type it will fail
+  // on construction. Therefore we just make an empty option.
+  const emptyExpo = api.registry.createType<Option<SpStakingExposurePage>>('Option<Null>');
+  const emptyExpoMeta = api.registry.createType<Option<SpStakingPagedExposureMetadata>>('Option<Null>');
+  const emptyClaimedRewards = [-1];
+
+  const depth = Number(api.consts.staking.historyDepth.toNumber());
+  const eras = new Array(depth).fill(0).map((_, idx) => {
+    if (idx === 0) {
+      return activeEra.toNumber() - 1;
+    }
+
+    return activeEra.toNumber() - idx - 1;
+  });
+
+  return combineLatest([
+    withController || withLedger
+      ? combineLatest(stashIds.map((s) => api.query.staking.bonded(s)))
+      : of(stashIds.map(() => null)),
+    withNominations
+      ? combineLatest(stashIds.map((s) => api.query.staking.nominators(s)))
+      : of(stashIds.map(() => emptyNoms)),
+    withDestination
+      ? combineLatest(stashIds.map((s) => api.query.staking.payee(s)))
+      : of(stashIds.map(() => emptyRewa)),
+    withPrefs
+      ? combineLatest(stashIds.map((s) => api.query.staking.validators(s)))
+      : of(stashIds.map(() => emptyPrefs)),
+    withExposure && api.query.staking.erasStakersPaged
+      ? combineLatest(stashIds.map((s) => api.query.staking.erasStakersPaged<Option<SpStakingExposurePage>>(activeEra, s, page)))
+      : of(stashIds.map(() => emptyExpo)),
+    withExposureMeta && api.query.staking.erasStakersOverview
+      ? combineLatest(stashIds.map((s) => api.query.staking.erasStakersOverview(activeEra, s)))
+      : of(stashIds.map(() => emptyExpoMeta)),
+    withClaimedRewardsEras && api.query.staking.claimedRewards
+      ? combineLatest([
+        api.query.staking.claimedRewards.entries<Vec<u32>>(),
+        api.query.staking.erasStakersOverview.entries<Option<SpStakingPagedExposureMetadata>>()
+      ]).pipe(
+        map(([rewardsStorageVec, overviewStorageVec]) => filterRewards(stashIds, eras, rewardsStorageVec, overviewStorageVec))
+      )
+      : of(stashIds.map(() => emptyClaimedRewards)),
+    withExposureErasStakersLegacy && api.query.staking.erasStakers
+      ? combineLatest(stashIds.map((s) => api.query.staking.erasStakers(activeEra, s)))
+      : of(stashIds.map(() => emptyExpoEraStakers))
+  ]);
+}
+
+function getBatch (api: DeriveApi, activeEra: EraIndex, stashIds: AccountId[], flags: StakingQueryFlags, page: u32 | AnyNumber): Observable<DeriveStakingQuery[]> {
+  return getStashInfo(api, stashIds, activeEra, flags, page).pipe(
+    switchMap(([controllerIdOpt, nominatorsOpt, rewardDestination, validatorPrefs, exposure, exposureMeta, claimedRewardsEras, exposureEraStakers]): Observable<DeriveStakingQuery[]> =>
+      getLedgers(api, controllerIdOpt, flags).pipe(
+        map((stakingLedgerOpts) =>
+          stashIds.map((stashId, index) =>
+            parseDetails(api, stashId, controllerIdOpt[index], nominatorsOpt[index], rewardDestination[index], validatorPrefs[index], exposure[index], stakingLedgerOpts[index], exposureMeta[index], claimedRewardsEras[index], exposureEraStakers[index])
+          )
+        )
+      )
+    )
+  );
+}
+
+/**
+ * @name query
+ * @param { Uint8Array | string } accountId The stash account to query.
+ * @param { StakingQueryFlags } flags Flags to customize the query.
+ * @param { u32 } page (Optional) pagination parameter.
+ * @description Retrieves staking details for a given stash account.
+ * @example
+ * ```javascript
+ * const stakingInfo = await api.derive.staking.query(
+ *   ALICE,
+ *   {}
+ * );
+ * ```
+ */
+export const query = /*#__PURE__*/ firstMemo(
+  (api: DeriveApi, accountId: Uint8Array | string, flags: StakingQueryFlags, page?: u32) =>
+    api.derive.staking.queryMulti([accountId], flags, page)
+);
+
+/**
+ * @name queryMulti
+ * @param { (Uint8Array | string)[] } accountIds List of stash accounts to query.
+ * @param { StakingQueryFlags } flags Flags to customize the query.
+ * @param { u32 } page (Optional) pagination parameter.
+ * @description Retrieves staking details for multiple stash accounts.
+ * @example
+ * ```javascript
+ * const stakingInfos = await api.derive.staking.queryMulti([stashId1, stashId2], {});
+ * ```
+ */
+export function queryMulti (instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], flags: StakingQueryFlags, page?: u32 | AnyNumber) => Observable<DeriveStakingQuery[]> {
+  return memo(instanceId, (accountIds: (Uint8Array | string)[], flags: StakingQueryFlags, page?: u32 | AnyNumber): Observable<DeriveStakingQuery[]> =>
+    api.derive.session.indexes().pipe(
+      switchMap(({ activeEra }): Observable<DeriveStakingQuery[]> => {
+        const stashIds = accountIds.map((a) => api.registry.createType('AccountId', a));
+        const p = page || 0;
+
+        return stashIds.length
+          ? getBatch(api, activeEra, stashIds, flags, p)
+          : of([]);
+      })
+    )
+  );
+}

package/src/staking/stakerExposure.ts

@@ -0,0 +1,78 @@
+// 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 } from '../types.js';
+import type { DeriveEraValidatorExposurePaged, DeriveStakerExposure } from './types.js';
+
+import { map, switchMap } from 'rxjs';
+
+import { firstMemo, memo } from '../util/index.js';
+
+export function _stakerExposures (instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive?: boolean) => Observable<DeriveStakerExposure[][]> {
+  return memo(instanceId, (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive = false): Observable<DeriveStakerExposure[][]> => {
+    const stakerIds = accountIds.map((a) => api.registry.createType('AccountId', a).toString());
+
+    return api.derive.staking._erasExposure(eras, withActive).pipe(
+      map((exposures): DeriveStakerExposure[][] =>
+        stakerIds.map((stakerId) =>
+          exposures.map(({ era, nominators: allNominators, validators: allValidators }): DeriveStakerExposure => {
+            const isValidator = !!allValidators[stakerId];
+            const validators: DeriveEraValidatorExposurePaged = {};
+            const nominating = allNominators[stakerId] || [];
+
+            if (isValidator) {
+              validators[stakerId] = allValidators[stakerId];
+            } else if (nominating) {
+              nominating.forEach(({ validatorId }): void => {
+                validators[validatorId] = allValidators[validatorId];
+              });
+            }
+
+            return { era, isEmpty: !Object.keys(validators).length, isValidator, nominating, validators };
+          })
+        )
+      )
+    );
+  });
+}
+
+/**
+ * @name stakerExposures
+ * @param { (Uint8Array | string)[] } accountIds List of validator stash accounts.
+ * @param { boolean } withActive Whether to include the active era.
+ * @description Retrieves staking exposure for multiple accounts across historical eras.
+ * @example
+ * ```javascript
+ * const exposure = await api.derive.staking.stakerExposures(
+ *   [ALICE, BOB],
+ *   true
+ * );
+ * ```
+*/
+export function stakerExposures (instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], withActive?: boolean) => Observable<DeriveStakerExposure[][]> {
+  return memo(instanceId, (accountIds: (Uint8Array | string)[], withActive = false): Observable<DeriveStakerExposure[][]> =>
+    api.derive.staking.erasHistoric(withActive).pipe(
+      switchMap((eras) => api.derive.staking._stakerExposures(accountIds, eras, withActive))
+    )
+  );
+}
+
+/**
+ * @name stakerExposure
+ * @param { Uint8Array | string } accountId The validator stash account.
+ * @param { boolean } withActive Whether to include the active era.
+ * @description Retrieves staking exposure for a single account across historical eras. Exposure refers to the total stake associated with a validator.
+ * @example
+ * ```javascript
+ * const exposure = await api.derive.staking.stakerExposure(
+ *   ALICE,
+ *   true
+ * );
+ * ```
+*/
+export const stakerExposure = /*#__PURE__*/ firstMemo(
+  (api: DeriveApi, accountId: Uint8Array | string, withActive?: boolean) =>
+    api.derive.staking.stakerExposures([accountId], withActive)
+);

package/src/staking/stakerPoints.ts

@@ -0,0 +1,46 @@
+// 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, DeriveStakerPoints } from '../types.js';
+
+import { map } from 'rxjs';
+
+import { memo } from '../util/index.js';
+import { erasHistoricApplyAccount } from './util.js';
+
+export function _stakerPoints (instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerPoints[]> {
+  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean): Observable<DeriveStakerPoints[]> => {
+    const stakerId = api.registry.createType('AccountId', accountId).toString();
+
+    return api.derive.staking._erasPoints(eras, withActive).pipe(
+      map((points): DeriveStakerPoints[] =>
+        points.map(({ era, eraPoints, validators }): DeriveStakerPoints => ({
+          era,
+          eraPoints,
+          points: validators[stakerId] || api.registry.createType('RewardPoint')
+        }))
+      )
+    );
+  });
+}
+
+/**
+ * @name stakerPoints
+ * @param { Uint8Array | string } accountId The stakers AccountId.
+ * @param { boolean } withActive Whether to include the active era.
+ * @description Retrieves the era reward points earned by a given staker across all eras.
+ * @example
+ * ```javascript
+ * const points = await api.derive.staking.stakerPoints(
+ *   ALICE, //Alice accountId
+ *   false
+ * );
+ * console.log(
+ *   'Validator Era Points:',
+ *   points.map(({ era, points }) => `Era ${era}: ${points.toString()} points`)
+ * );
+ * ```
+*/
+export const stakerPoints = /*#__PURE__*/ erasHistoricApplyAccount('_stakerPoints');

package/src/staking/stakerPrefs.ts

@@ -0,0 +1,45 @@
+// 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, DeriveStakerPrefs } from '../types.js';
+
+import { map } from 'rxjs';
+
+import { memo } from '../util/index.js';
+import { erasHistoricApplyAccount } from './util.js';
+
+export function _stakerPrefs (instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerPrefs[]> {
+  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], _withActive: boolean): Observable<DeriveStakerPrefs[]> =>
+    api.query.staking.erasValidatorPrefs.multi(eras.map((e) => [e, accountId])).pipe(
+      map((all): DeriveStakerPrefs[] =>
+        all.map((validatorPrefs, index): DeriveStakerPrefs => ({
+          era: eras[index],
+          validatorPrefs
+        }))
+      )
+    )
+  );
+}
+
+/**
+ * @name stakerPrefs
+ * @param { Uint8Array | string } accountId The stakers AccountId.
+ * @param { boolean } withActive Whether to include the active era.
+ * @description Retrieves the validator preferences for a given staker across historical eras.
+ * @example
+ * ```javascript
+ * const prefs = await api.derive.staking.stakerPrefs(
+ *   ALICE, //Alice accountId
+ *   false
+ * );
+ * console.log(
+ *   'Validator Preferences:',
+ *   prefs.map(
+ *     ({ era, validatorPrefs }) => `Era ${era}: Commission ${validatorPrefs.commission.toString()}`
+ *   )
+ * );
+ * ```
+*/
+export const stakerPrefs = /*#__PURE__*/ erasHistoricApplyAccount('_stakerPrefs');