@pezkuwi/api-derive 16.5.5 → 16.5.6

package/staking/account.js

@@ -0,0 +1,76 @@
+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) {
+    return list.reduce((map, { era, value }) => {
+        const key = era.toString();
+        map[key] = (map[key] || BN_ZERO).add(value.unwrap());
+        return map;
+    }, {});
+}
+function calculateUnlocking(api, stakingLedger, sessionInfo) {
+    const results = Object
+        .entries(groupByEra((stakingLedger?.unlocking || []).filter(({ era }) => era.unwrap().gt(sessionInfo.activeEra))))
+        .map(([eraString, value]) => ({
+        remainingEras: new BN(eraString).isub(sessionInfo.activeEra),
+        value: api.registry.createType('Balance', value)
+    }));
+    return results.length
+        ? results
+        : undefined;
+}
+function redeemableSum(api, stakingLedger, sessionInfo) {
+    return api.registry.createType('Balance', (stakingLedger?.unlocking || []).reduce((total, { era, value }) => {
+        // aligns with https://github.com/pezkuwichain/bizinikiwi/blob/fdfdc73f9e64dc47934b72eb9af3e1989e4ba699/frame/staking/src/pallet/mod.rs#L973-L975
+        // (ensure currentEra >= era passed, as per https://github.com/pezkuwichain/bizinikiwi/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, sessionInfo, keys, query) {
+    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, api) {
+    return memo(instanceId, (accountIds, opts = QUERY_OPTS) => 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, accountId, opts) => api.derive.staking.accounts([accountId], opts));

package/staking/cache.d.ts

@@ -0,0 +1,12 @@
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+export declare function getEraCache<T>(CACHE_KEY: string, era: EraIndex, withActive?: boolean): [string, T | undefined];
+export declare function getEraMultiCache<T>(CACHE_KEY: string, eras: EraIndex[], withActive?: boolean): T[];
+export declare function setEraCache<T extends {
+    era: EraIndex;
+}>(cacheKey: string, withActive: boolean, value: T): T;
+export declare function setEraMultiCache<T extends {
+    era: EraIndex;
+}>(CACHE_KEY: string, withActive: boolean, values: T[]): T[];
+export declare function filterCachedEras<T extends {
+    era: EraIndex;
+}>(eras: EraIndex[], cached: T[], query: T[]): T[];

package/staking/cache.js

@@ -0,0 +1,32 @@
+import { deriveCache } from '../util/index.js';
+export function getEraCache(CACHE_KEY, era, withActive) {
+    const cacheKey = `${CACHE_KEY}-${era.toString()}`;
+    return [
+        cacheKey,
+        withActive
+            ? undefined
+            : deriveCache.get(cacheKey)
+    ];
+}
+export function getEraMultiCache(CACHE_KEY, eras, withActive) {
+    const cached = withActive
+        ? []
+        : eras
+            .map((e) => deriveCache.get(`${CACHE_KEY}-${e.toString()}`))
+            .filter((v) => !!v);
+    return cached;
+}
+export function setEraCache(cacheKey, withActive, value) {
+    !withActive && deriveCache.set(cacheKey, value);
+    return value;
+}
+export function setEraMultiCache(CACHE_KEY, withActive, values) {
+    !withActive && values.forEach((v) => deriveCache.set(`${CACHE_KEY}-${v.era.toString()}`, v));
+    return values;
+}
+export function filterCachedEras(eras, cached, query) {
+    return eras
+        .map((e) => cached.find(({ era }) => e.eq(era)) ||
+        query.find(({ era }) => e.eq(era)))
+        .filter((e) => !!e);
+}

package/staking/currentPoints.d.ts

@@ -0,0 +1,13 @@
+import type { Observable } from 'rxjs';
+import type { PezpalletStakingEraRewardPoints } from '@pezkuwi/types/lookup';
+import type { DeriveApi } from '../types.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 declare function currentPoints(instanceId: string, api: DeriveApi): () => Observable<PezpalletStakingEraRewardPoints>;

package/staking/currentPoints.js

@@ -0,0 +1,14 @@
+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, api) {
+    return memo(instanceId, () => api.derive.session.indexes().pipe(switchMap(({ activeEra }) => api.query.staking.erasRewardPoints(activeEra))));
+}

package/staking/electedInfo.d.ts

@@ -0,0 +1,23 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveStakingElected, StakingQueryFlags } from '../types.js';
+/**
+ * @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 declare function electedInfo(instanceId: string, api: DeriveApi): (flags?: StakingQueryFlags, page?: number) => Observable<DeriveStakingElected>;

package/staking/electedInfo.js

@@ -0,0 +1,34 @@
+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, validators) {
+    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, api) {
+    return memo(instanceId, (flags = DEFAULT_FLAGS, page = 0) => api.derive.staking.validators().pipe(switchMap(({ nextElected, validators }) => api.derive.staking.queryMulti(combineAccounts(nextElected, validators), flags, page).pipe(map((info) => ({
+        info,
+        nextElected,
+        validators
+    }))))));
+}

package/staking/erasExposure.d.ts

@@ -0,0 +1,30 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraExposurePaged } from '../types.js';
+/**
+ * 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 declare function _eraExposure(instanceId: string, api: DeriveApi): (era: EraIndex, withActive?: boolean) => Observable<DeriveEraExposurePaged>;
+/**
+ * @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 declare const eraExposure: (instanceId: string, api: DeriveApi) => (era: EraIndex) => Observable<DeriveEraExposurePaged>;
+export declare const _erasExposure: (instanceId: string, api: DeriveApi) => (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraExposurePaged[]>;
+/**
+ * @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 declare const erasExposure: (instanceId: string, api: DeriveApi) => (withActive?: boolean) => Observable<DeriveEraExposurePaged[]>;

package/staking/erasExposure.js

@@ -0,0 +1,72 @@
+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 = 'eraExposure';
+function mapStakersClipped(era, stakers) {
+    const nominators = {};
+    const validators = {};
+    stakers.forEach(([key, exposure]) => {
+        const validatorId = key.args[1].toString();
+        validators[validatorId] = exposure;
+        exposure.others.forEach(({ who }, validatorIndex) => {
+            const nominatorId = who.toString();
+            nominators[nominatorId] = nominators[nominatorId] || [];
+            nominators[nominatorId].push({ validatorId, validatorIndex });
+        });
+    });
+    return { era, nominators, validators };
+}
+function mapStakersPaged(era, stakers) {
+    const nominators = {};
+    const validators = {};
+    stakers.forEach(([key, exposureOpt]) => {
+        if (exposureOpt.isSome) {
+            const validatorId = key.args[1].toString();
+            const exposure = exposureOpt.unwrap();
+            validators[validatorId] = exposure;
+            exposure.others.forEach(({ who }, validatorIndex) => {
+                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, api) {
+    return memo(instanceId, (era, withActive = false) => {
+        const [cacheKey, cached] = getEraCache(CACHE_KEY, era, withActive);
+        return cached
+            ? of(cached)
+            : api.query.staking.erasStakersPaged
+                ? api.query.staking.erasStakersPaged.entries(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/staking/erasHistoric.d.ts

@@ -0,0 +1,8 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name erasHistoric
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ */
+export declare function erasHistoric(instanceId: string, api: DeriveApi): (withActive?: boolean) => Observable<EraIndex[]>;

package/staking/erasHistoric.js

@@ -0,0 +1,28 @@
+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, api) {
+    return memo(instanceId, (withActive) => combineLatest([
+        api.query.staking.activeEra(),
+        api.consts.staking.historyDepth
+            ? of(api.consts.staking.historyDepth)
+            : api.query.staking['historyDepth']()
+    ]).pipe(map(([activeEraOpt, historyDepth]) => {
+        const result = [];
+        const max = historyDepth.toNumber();
+        const activeEra = 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/staking/erasPoints.d.ts

@@ -0,0 +1,18 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraPoints } from '../types.js';
+export declare function _erasPoints(instanceId: string, api: DeriveApi): (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraPoints[]>;
+/**
+ * @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 declare const erasPoints: (instanceId: string, api: DeriveApi) => (withActive?: boolean) => Observable<DeriveEraPoints[]>;

package/staking/erasPoints.js

@@ -0,0 +1,47 @@
+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 }) {
+    return [...individual.entries()]
+        .filter(([, points]) => points.gt(BN_ZERO))
+        .reduce((result, [validatorId, points]) => {
+        result[validatorId.toString()] = points;
+        return result;
+    }, {});
+}
+function mapPoints(eras, points) {
+    return eras.map((era, index) => ({
+        era,
+        eraPoints: points[index].total,
+        validators: mapValidators(points[index])
+    }));
+}
+export function _erasPoints(instanceId, api) {
+    return memo(instanceId, (eras, withActive) => {
+        if (!eras.length) {
+            return of([]);
+        }
+        const cached = getEraMultiCache(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/staking/erasPrefs.d.ts

@@ -0,0 +1,27 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraPrefs } from '../types.js';
+export declare function _eraPrefs(instanceId: string, api: DeriveApi): (era: EraIndex, withActive: boolean) => Observable<DeriveEraPrefs>;
+/**
+ * @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 declare const eraPrefs: (instanceId: string, api: DeriveApi) => (era: EraIndex) => Observable<DeriveEraPrefs>;
+export declare const _erasPrefs: (instanceId: string, api: DeriveApi) => (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraPrefs[]>;
+/**
+ * @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 declare const erasPrefs: (instanceId: string, api: DeriveApi) => (withActive?: boolean) => Observable<DeriveEraPrefs[]>;

package/staking/erasPrefs.js

@@ -0,0 +1,43 @@
+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, all) {
+    const validators = {};
+    all.forEach(([key, prefs]) => {
+        validators[key.args[1].toString()] = prefs;
+    });
+    return { era, validators };
+}
+export function _eraPrefs(instanceId, api) {
+    return memo(instanceId, (era, withActive) => {
+        const [cacheKey, cached] = getEraCache(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/staking/erasRewards.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraRewards } from '../types.js';
+export declare function _erasRewards(instanceId: string, api: DeriveApi): (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraRewards[]>;
+/**
+ * @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 declare const erasRewards: (instanceId: string, api: DeriveApi) => (withActive?: boolean) => Observable<DeriveEraRewards[]>;

package/staking/erasRewards.js

@@ -0,0 +1,34 @@
+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, optRewards) {
+    return eras.map((era, index) => ({
+        era,
+        eraReward: optRewards[index].unwrapOrDefault()
+    }));
+}
+export function _erasRewards(instanceId, api) {
+    return memo(instanceId, (eras, withActive) => {
+        if (!eras.length) {
+            return of([]);
+        }
+        const cached = getEraMultiCache(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/staking/erasSlashes.d.ts

@@ -0,0 +1,26 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraSlashes } from '../types.js';
+export declare function _eraSlashes(instanceId: string, api: DeriveApi): (era: EraIndex, withActive: boolean) => Observable<DeriveEraSlashes>;
+/**
+ * @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 declare const eraSlashes: (instanceId: string, api: DeriveApi) => (era: EraIndex) => Observable<DeriveEraSlashes>;
+export declare const _erasSlashes: (instanceId: string, api: DeriveApi) => (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraSlashes[]>;
+/**
+ * @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 declare const erasSlashes: (instanceId: string, api: DeriveApi) => (withActive?: boolean) => Observable<DeriveEraSlashes[]>;

package/staking/erasSlashes.js

@@ -0,0 +1,49 @@
+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, noms, vals) {
+    const nominators = {};
+    const validators = {};
+    noms.forEach(([key, optBalance]) => {
+        nominators[key.args[1].toString()] = optBalance.unwrap();
+    });
+    vals.forEach(([key, optRes]) => {
+        validators[key.args[1].toString()] = optRes.unwrapOrDefault()[1];
+    });
+    return { era, nominators, validators };
+}
+export function _eraSlashes(instanceId, api) {
+    return memo(instanceId, (era, withActive) => {
+        const [cacheKey, cached] = getEraCache(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 → staking/index.d.ts}

@@ -1,6 +1,3 @@
-// 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';

package/staking/index.js

@@ -0,0 +1,22 @@
+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';