@pezkuwi/api-derive 16.5.5 → 16.5.6

package/staking/stakerPrefs.d.ts

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

package/staking/stakerPrefs.js

@@ -0,0 +1,29 @@
+import { map } from 'rxjs';
+import { memo } from '../util/index.js';
+import { erasHistoricApplyAccount } from './util.js';
+export function _stakerPrefs(instanceId, api) {
+    return memo(instanceId, (accountId, eras, _withActive) => api.query.staking.erasValidatorPrefs.multi(eras.map((e) => [e, accountId])).pipe(map((all) => all.map((validatorPrefs, index) => ({
+        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');

package/staking/stakerRewards.d.ts

@@ -0,0 +1,49 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraPoints, DeriveEraPrefs, DeriveEraRewards, DeriveStakerReward } from '../types.js';
+type ErasResult = [DeriveEraPoints[], DeriveEraPrefs[], DeriveEraRewards[]];
+export declare function _stakerRewardsEras(instanceId: string, api: DeriveApi): (eras: EraIndex[], withActive?: boolean) => Observable<ErasResult>;
+export declare function _stakerRewards(instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive?: boolean) => Observable<DeriveStakerReward[][]>;
+/**
+ * @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 declare const stakerRewards: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, withActive?: boolean | undefined) => Observable<DeriveStakerReward[]>;
+/**
+ * @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 declare function stakerRewardsMultiEras(instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], eras: EraIndex[]) => Observable<DeriveStakerReward[][]>;
+/**
+ * @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 declare function stakerRewardsMulti(instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], withActive?: boolean) => Observable<DeriveStakerReward[][]>;
+export {};

package/staking/stakerRewards.js

@@ -0,0 +1,215 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { BN_BILLION, BN_ZERO, objectSpread } from '@pezkuwi/util';
+import { firstMemo, memo } from '../util/index.js';
+function extractCompatRewards(claimedRewardsEras, ledger) {
+    const l = ledger
+        ? (ledger.legacyClaimedRewards ||
+            ledger.claimedRewards)?.toArray()
+        : [];
+    return (claimedRewardsEras.toArray() || []).concat(l);
+}
+function parseRewards(api, stashId, [erasPoints, erasPrefs, erasRewards], exposures, claimedRewardsEras) {
+    return exposures.map(({ era, isEmpty, isValidator, nominating, validators: eraValidators }) => {
+        const { eraPoints, validators: allValPoints } = erasPoints.find((p) => p.era.eq(era)) || { eraPoints: BN_ZERO, validators: {} };
+        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: {} };
+        const validators = {};
+        const stakerId = stashId.toString();
+        Object.entries(eraValidators).forEach(([validatorId, exposure]) => {
+            const valPoints = allValPoints[validatorId] || BN_ZERO;
+            const valComm = allValPrefs[validatorId]?.commission.unwrap() || BN_ZERO;
+            const expTotal = exposure.total
+                ? exposure.total?.unwrap()
+                : exposure.pageTotal
+                    ? exposure.pageTotal?.unwrap()
+                    : BN_ZERO;
+            let avail = BN_ZERO;
+            let value;
+            if (!(expTotal.isZero() || valPoints.isZero() || eraPoints.isZero())) {
+                avail = eraReward.mul(valPoints).div(eraPoints);
+                const valCut = valComm.mul(avail).div(BN_BILLION);
+                let staked;
+                if (validatorId === stakerId) {
+                    if (exposure.own) {
+                        staked = exposure.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) {
+    return rewards.reduce(([all, perStash], rewards) => {
+        const uniq = [];
+        perStash.push(uniq);
+        rewards.forEach(({ validators }) => Object.keys(validators).forEach((validatorId) => {
+            if (!uniq.includes(validatorId)) {
+                uniq.push(validatorId);
+                if (!all.includes(validatorId)) {
+                    all.push(validatorId);
+                }
+            }
+        }));
+        return [all, perStash];
+    }, [[], []]);
+}
+function removeClaimed(validators, queryValidators, reward, claimedRewardsEras) {
+    const rm = [];
+    Object.keys(reward.validators).forEach((validatorId) => {
+        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) => {
+        delete reward.validators[validatorId];
+    });
+}
+function filterRewards(eras, valInfo, { claimedRewardsEras, rewards, stakingLedger }) {
+    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) => {
+        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, api) {
+    return memo(instanceId, (eras, withActive = false) => combineLatest([
+        api.derive.staking._erasPoints(eras, withActive),
+        api.derive.staking._erasPrefs(eras, withActive),
+        api.derive.staking._erasRewards(eras, withActive)
+    ]));
+}
+export function _stakerRewards(instanceId, api) {
+    return memo(instanceId, (accountIds, eras, withActive = false) => {
+        // Ensures that when number or string types are passed in they are sanitized
+        // Ref: https://github.com/pezkuwichain/pezkuwi-api/issues/5910
+        const sanitizedEras = 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]) => {
+            const allRewards = queries.map(({ claimedRewardsEras, stakingLedger, stashId }, index) => (!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) => queries.map(({ claimedRewardsEras, stakingLedger }, index) => filterRewards(eras, stashValidators[index]
+                .map((validatorId) => [
+                validatorId,
+                queriedVals.find((q) => q.accountId.eq(validatorId))
+            ])
+                .filter((v) => !!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, accountId, withActive) => 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, api) {
+    return memo(instanceId, (accountIds, eras) => 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, api) {
+    return memo(instanceId, (accountIds, withActive = false) => api.derive.staking.erasHistoric(withActive).pipe(switchMap((eras) => api.derive.staking.stakerRewardsMultiEras(accountIds, eras))));
+}

package/staking/stakerSlashes.d.ts

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

package/staking/stakerSlashes.js

@@ -0,0 +1,30 @@
+import { map } from 'rxjs';
+import { memo } from '../util/index.js';
+import { erasHistoricApplyAccount } from './util.js';
+export function _stakerSlashes(instanceId, api) {
+    return memo(instanceId, (accountId, eras, withActive) => {
+        const stakerId = api.registry.createType('AccountId', accountId).toString();
+        return api.derive.staking._erasSlashes(eras, withActive).pipe(map((slashes) => slashes.map(({ era, nominators, validators }) => ({
+            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/staking/stashes.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+/**
+ * @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 declare function stashes(instanceId: string, api: DeriveApi): () => Observable<AccountId[]>;

package/staking/stashes.js

@@ -0,0 +1,35 @@
+import { map, startWith, switchMap } from 'rxjs';
+import { drr, memo } from '../util/index.js';
+function onBondedEvent(api) {
+    let current = Date.now();
+    return api.query.system.events().pipe(map((events) => {
+        current = events.filter(({ event, phase }) => {
+            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, api) {
+    return memo(instanceId, () => onBondedEvent(api).pipe(switchMap(() => api.query.staking.validators.keys()), map((keys) => keys.map(({ args: [v] }) => v).filter((a) => a))));
+}

package/staking/types.d.ts

@@ -0,0 +1,139 @@
+import type { Option, u32, Vec } from '@pezkuwi/types';
+import type { AccountId, Balance, EraIndex, RewardPoint } from '@pezkuwi/types/interfaces';
+import type { PezpalletStakingRewardDestination, PezpalletStakingStakingLedger, PezpalletStakingValidatorPrefs, PezspStakingExposure, PezspStakingExposurePage, PezspStakingPagedExposureMetadata } 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, PezpalletStakingValidatorPrefs>;
+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: PezspStakingExposure;
+    exposurePaged: Option<PezspStakingExposurePage>;
+    era: EraIndex;
+    exposure: PezspStakingExposure;
+    exposureMeta: Option<PezspStakingPagedExposureMetadata>;
+}
+export interface DeriveEraExposureNominating {
+    validatorId: string;
+    validatorIndex: number;
+}
+export type DeriveEraNominatorExposure = Record<string, DeriveEraExposureNominating[]>;
+export type DeriveEraValidatorExposure = Record<string, PezspStakingExposure>;
+export type DeriveEraValidatorExposurePaged = Record<string, PezspStakingExposurePage | PezspStakingExposure>;
+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: PezpalletStakingValidatorPrefs;
+}
+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;
+    exposureEraStakers: PezspStakingExposure;
+    exposurePaged: Option<PezspStakingExposurePage>;
+    exposureMeta: Option<PezspStakingPagedExposureMetadata>;
+    nominators: AccountId[];
+    rewardDestination: PezpalletStakingRewardDestination | null;
+    stashId: AccountId;
+    validatorPrefs: PezpalletStakingValidatorPrefs;
+    claimedRewardsEras: Vec<u32>;
+}
+export interface DeriveStakingQuery extends DeriveStakingStash {
+    accountId: AccountId;
+    stakingLedger: PezpalletStakingStakingLedger;
+}
+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/staking/types.js

@@ -0,0 +1 @@
+export {};

package/staking/util.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { ObsInnerType } from '@pezkuwi/api-base/types';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { ExactDerive } from '../derive.js';
+import type { DeriveApi } from '../types.js';
+type ApplyReturn<T extends keyof ExactDerive['staking']> = ReturnType<ExactDerive['staking'][T]>;
+export declare function filterEras<T extends {
+    era: EraIndex;
+}>(eras: EraIndex[], list: T[]): EraIndex[];
+export declare function erasHistoricApply<F extends '_erasExposure' | '_erasPoints' | '_erasPrefs' | '_erasRewards' | '_erasSlashes'>(fn: F): (instanceId: string, api: DeriveApi) => (withActive?: boolean) => ApplyReturn<F>;
+export declare function erasHistoricApplyAccount<F extends '_ownExposures' | '_ownSlashes' | '_stakerPoints' | '_stakerPrefs' | '_stakerSlashes'>(fn: F): (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, withActive?: boolean) => ApplyReturn<F>;
+export declare function singleEra<F extends '_eraExposure' | '_eraPrefs' | '_eraSlashes'>(fn: F): (instanceId: string, api: DeriveApi) => (era: EraIndex) => ApplyReturn<F>;
+export declare function combineEras<F extends '_eraExposure' | '_eraPrefs' | '_eraSlashes'>(fn: F): (instanceId: string, api: DeriveApi) => (eras: EraIndex[], withActive: boolean) => Observable<ObsInnerType<ApplyReturn<F>>[]>;
+export {};

package/staking/util.js

@@ -0,0 +1,46 @@
+import { BehaviorSubject, combineLatest, map, of, switchMap, tap, toArray } from 'rxjs';
+import { arrayChunk, arrayFlatten, nextTick } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+const ERA_CHUNK_SIZE = 14;
+function chunkEras(eras, fn) {
+    const chunked = arrayChunk(eras, ERA_CHUNK_SIZE);
+    let index = 0;
+    const subject = new BehaviorSubject(chunked[index]);
+    return subject.pipe(switchMap(fn), tap(() => {
+        nextTick(() => {
+            index++;
+            index === chunked.length
+                ? subject.complete()
+                : subject.next(chunked[index]);
+        });
+    }), toArray(), map(arrayFlatten));
+}
+export function filterEras(eras, list) {
+    return eras.filter((e) => !list.some(({ era }) => e.eq(era)));
+}
+export function erasHistoricApply(fn) {
+    return (instanceId, api) => 
+    // 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))));
+}
+export function erasHistoricApplyAccount(fn) {
+    return (instanceId, api) => 
+    // 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, withActive = false, page) => api.derive.staking.erasHistoric(withActive).pipe(switchMap((e) => api.derive.staking[fn](accountId, e, withActive, page || 0))));
+}
+export function singleEra(fn) {
+    return (instanceId, api) => 
+    // 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) => api.derive.staking[fn](era, true));
+}
+export function combineEras(fn) {
+    return (instanceId, api) => 
+    // 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, withActive) => !eras.length
+        ? of([])
+        : chunkEras(eras, (eras) => combineLatest(eras.map((e) => api.derive.staking[fn](e, withActive)))));
+}

package/staking/validators.d.ts

@@ -0,0 +1,33 @@
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveStakingValidators } from '../types.js';
+/**
+ * @name nextElected
+ * @description Retrieves the list of accounts that are set to be the next elected validators in the staking system. It provides a preview of who will be validators in the next staking era.
+ * @example
+ * ```javascript
+ * const nextElected = await api.derive.staking.nextElected();
+ * console.log(
+ *   "Next Elected Validators:",
+ *   nextElected.map((acc) => acc.toString())
+ * );
+ * ```
+ */
+export declare function nextElected(instanceId: string, api: DeriveApi): () => Observable<AccountId[]>;
+/**
+ * @name validators
+ * @description Retrieve latest list of validators.
+ * @example
+ * ```javascript
+ * const { validators, nextElected } = await api.derive.staking.validators();
+ * console.log(
+ *   "Current Validators:",
+ *   validators.map((v) => v.toString())
+ * );
+ * console.log(
+ *   "Next Elected Validators:",
+ *   nextElected.map((v) => v.toString())
+ * );
+ * ```
+ */
+export declare function validators(instanceId: string, api: DeriveApi): () => Observable<DeriveStakingValidators>;