@pezkuwi/api-derive 16.5.5 → 16.5.6

package/cjs/staking/stakerPoints.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stakerPoints = void 0;
+exports._stakerPoints = _stakerPoints;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+function _stakerPoints(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountId, eras, withActive) => {
+        const stakerId = api.registry.createType('AccountId', accountId).toString();
+        return api.derive.staking._erasPoints(eras, withActive).pipe((0, rxjs_1.map)((points) => points.map(({ era, eraPoints, validators }) => ({
+            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`)
+ * );
+ * ```
+*/
+exports.stakerPoints = (0, util_js_1.erasHistoricApplyAccount)('_stakerPoints');

package/cjs/staking/stakerPrefs.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stakerPrefs = void 0;
+exports._stakerPrefs = _stakerPrefs;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+function _stakerPrefs(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountId, eras, _withActive) => api.query.staking.erasValidatorPrefs.multi(eras.map((e) => [e, accountId])).pipe((0, rxjs_1.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()}`
+ *   )
+ * );
+ * ```
+*/
+exports.stakerPrefs = (0, util_js_1.erasHistoricApplyAccount)('_stakerPrefs');

package/{build → cjs}/staking/stakerRewards.d.ts

@@ -17,7 +17,7 @@ export declare function _stakerRewards(instanceId: string, api: DeriveApi): (acc
  * );
  * ```
  */
-export declare const stakerRewards: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array<ArrayBufferLike>, withActive?: boolean) => Observable<DeriveStakerReward[]>;
+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.

package/cjs/staking/stakerRewards.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stakerRewards = void 0;
+exports._stakerRewardsEras = _stakerRewardsEras;
+exports._stakerRewards = _stakerRewards;
+exports.stakerRewardsMultiEras = stakerRewardsMultiEras;
+exports.stakerRewardsMulti = stakerRewardsMulti;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../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: util_1.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] || util_1.BN_ZERO;
+            const valComm = allValPrefs[validatorId]?.commission.unwrap() || util_1.BN_ZERO;
+            const expTotal = exposure.total
+                ? exposure.total?.unwrap()
+                : exposure.pageTotal
+                    ? exposure.pageTotal?.unwrap()
+                    : util_1.BN_ZERO;
+            let avail = util_1.BN_ZERO;
+            let value;
+            if (!(expTotal.isZero() || valPoints.isZero() || eraPoints.isZero())) {
+                avail = eraReward.mul(valPoints).div(eraPoints);
+                const valCut = valComm.mul(avail).div(util_1.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()
+                            : util_1.BN_ZERO;
+                    }
+                }
+                else {
+                    const stakerExp = exposure.others.find(({ who }) => who.eq(stakerId));
+                    staked = stakerExp
+                        ? stakerExp.value.unwrap()
+                        : util_1.BN_ZERO;
+                }
+                value = avail.sub(valCut).imul(staked).div(expTotal).iadd(validatorId === stakerId ? valCut : util_1.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 (0, util_1.objectSpread)({}, reward, {
+            isClaimed,
+            nominators: reward.nominating.filter((n) => reward.validators[n.validatorId])
+        });
+    });
+}
+function _stakerRewardsEras(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (eras, withActive = false) => (0, rxjs_1.combineLatest)([
+        api.derive.staking._erasPoints(eras, withActive),
+        api.derive.staking._erasPrefs(eras, withActive),
+        api.derive.staking._erasRewards(eras, withActive)
+    ]));
+}
+function _stakerRewards(instanceId, api) {
+    return (0, index_js_1.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 (0, rxjs_1.combineLatest)([
+            api.derive.staking.queryMulti(accountIds, { withClaimedRewardsEras: true, withLedger: true }),
+            api.derive.staking._stakerExposures(accountIds, sanitizedEras, withActive),
+            api.derive.staking._stakerRewardsEras(sanitizedEras, withActive)
+        ]).pipe((0, rxjs_1.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 (0, rxjs_1.of)(allRewards);
+            }
+            const [allValidators, stashValidators] = allUniqValidators(allRewards);
+            return api.derive.staking.queryMulti(allValidators, { withClaimedRewardsEras: true, withLedger: true }).pipe((0, rxjs_1.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
+ * );
+ * ```
+ */
+exports.stakerRewards = (0, index_js_1.firstMemo)((api, accountId, withActive) => api.derive.staking.erasHistoric(withActive).pipe((0, rxjs_1.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
+ * );
+ * ```
+ */
+function stakerRewardsMultiEras(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountIds, eras) => accountIds.length && eras.length
+        ? api.derive.staking._stakerRewards(accountIds, eras, false)
+        : (0, rxjs_1.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
+ * );
+ * ```
+ */
+function stakerRewardsMulti(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountIds, withActive = false) => api.derive.staking.erasHistoric(withActive).pipe((0, rxjs_1.switchMap)((eras) => api.derive.staking.stakerRewardsMultiEras(accountIds, eras))));
+}

package/cjs/staking/stakerSlashes.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stakerSlashes = void 0;
+exports._stakerSlashes = _stakerSlashes;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+function _stakerSlashes(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountId, eras, withActive) => {
+        const stakerId = api.registry.createType('AccountId', accountId).toString();
+        return api.derive.staking._erasSlashes(eras, withActive).pipe((0, rxjs_1.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()}`)
+ * );
+ * ```
+ */
+exports.stakerSlashes = (0, util_js_1.erasHistoricApplyAccount)('_stakerSlashes');

package/cjs/staking/stashes.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stashes = stashes;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+function onBondedEvent(api) {
+    let current = Date.now();
+    return api.query.system.events().pipe((0, rxjs_1.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;
+    }), (0, rxjs_1.startWith)(current), (0, index_js_1.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())
+ * );
+ * ```
+ */
+function stashes(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => onBondedEvent(api).pipe((0, rxjs_1.switchMap)(() => api.query.staking.validators.keys()), (0, rxjs_1.map)((keys) => keys.map(({ args: [v] }) => v).filter((a) => a))));
+}

package/{build → cjs}/staking/types.d.ts

@@ -1,10 +1,10 @@
 import type { Option, u32, Vec } from '@pezkuwi/types';
 import type { AccountId, Balance, EraIndex, RewardPoint } from '@pezkuwi/types/interfaces';
-import type { PalletStakingRewardDestination, PalletStakingStakingLedger, PalletStakingValidatorPrefs, SpStakingExposure, SpStakingExposurePage, SpStakingPagedExposureMetadata } from '@pezkuwi/types/lookup';
+import type { 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, PalletStakingValidatorPrefs>;
+export type DeriveEraValPrefs = Record<string, PezpalletStakingValidatorPrefs>;
 export type DeriveEraValSlash = Record<string, Balance>;
 export interface DeriveEraPoints {
     era: EraIndex;
@@ -30,19 +30,19 @@ export interface DeriveStakerPoints {
     points: RewardPoint;
 }
 export interface DeriveOwnExposure {
-    clipped: SpStakingExposure;
-    exposurePaged: Option<SpStakingExposurePage>;
+    clipped: PezspStakingExposure;
+    exposurePaged: Option<PezspStakingExposurePage>;
     era: EraIndex;
-    exposure: SpStakingExposure;
-    exposureMeta: Option<SpStakingPagedExposureMetadata>;
+    exposure: PezspStakingExposure;
+    exposureMeta: Option<PezspStakingPagedExposureMetadata>;
 }
 export interface DeriveEraExposureNominating {
     validatorId: string;
     validatorIndex: number;
 }
 export type DeriveEraNominatorExposure = Record<string, DeriveEraExposureNominating[]>;
-export type DeriveEraValidatorExposure = Record<string, SpStakingExposure>;
-export type DeriveEraValidatorExposurePaged = Record<string, SpStakingExposurePage | SpStakingExposure>;
+export type DeriveEraValidatorExposure = Record<string, PezspStakingExposure>;
+export type DeriveEraValidatorExposurePaged = Record<string, PezspStakingExposurePage | PezspStakingExposure>;
 export interface DeriveEraExposure {
     era: EraIndex;
     nominators: DeriveEraNominatorExposure;
@@ -62,7 +62,7 @@ export interface DeriveStakerExposure {
 }
 export interface DeriveStakerPrefs {
     era: EraIndex;
-    validatorPrefs: PalletStakingValidatorPrefs;
+    validatorPrefs: PezpalletStakingValidatorPrefs;
 }
 export interface DeriveStakerRewardValidator {
     total: Balance;
@@ -92,18 +92,18 @@ export interface DeriveStakingValidators {
 }
 export interface DeriveStakingStash {
     controllerId: AccountId | null;
-    exposureEraStakers: SpStakingExposure;
-    exposurePaged: Option<SpStakingExposurePage>;
-    exposureMeta: Option<SpStakingPagedExposureMetadata>;
+    exposureEraStakers: PezspStakingExposure;
+    exposurePaged: Option<PezspStakingExposurePage>;
+    exposureMeta: Option<PezspStakingPagedExposureMetadata>;
     nominators: AccountId[];
-    rewardDestination: PalletStakingRewardDestination | null;
+    rewardDestination: PezpalletStakingRewardDestination | null;
     stashId: AccountId;
-    validatorPrefs: PalletStakingValidatorPrefs;
+    validatorPrefs: PezpalletStakingValidatorPrefs;
     claimedRewardsEras: Vec<u32>;
 }
 export interface DeriveStakingQuery extends DeriveStakingStash {
     accountId: AccountId;
-    stakingLedger: PalletStakingStakingLedger;
+    stakingLedger: PezpalletStakingStakingLedger;
 }
 export interface DeriveStakingElected {
     info: DeriveStakingQuery[];

package/cjs/staking/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/staking/util.js

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

package/cjs/staking/validators.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextElected = nextElected;
+exports.validators = validators;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.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())
+ * );
+ * ```
+ */
+function nextElected(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => 
+    // Compatibility for future generation changes in staking.
+    api.query.staking.erasStakersOverview
+        ? api.derive.session.indexes().pipe(
+        // only populate for next era in the last session, so track both here - entries are not
+        // subscriptions, so we need a trigger - currentIndex acts as that trigger to refresh
+        (0, rxjs_1.switchMap)(({ currentEra }) => api.query.staking.erasStakersOverview.keys(currentEra)), 
+        // Dedupe any duplicates
+        (0, rxjs_1.map)((keys) => [...new Set(keys.map(({ args: [, accountId] }) => accountId.toString()))].map((a) => api.registry.createType('AccountId', a))))
+        : api.query.staking.erasStakers
+            ? api.derive.session.indexes().pipe(
+            // only populate for next era in the last session, so track both here - entries are not
+            // subscriptions, so we need a trigger - currentIndex acts as that trigger to refresh
+            (0, rxjs_1.switchMap)(({ currentEra }) => api.query.staking.erasStakers.keys(currentEra)), 
+            // Dedupe any duplicates
+            (0, rxjs_1.map)((keys) => [...new Set(keys.map(({ args: [, accountId] }) => accountId.toString()))].map((a) => api.registry.createType('AccountId', a))))
+            : api.query.staking['currentElected']());
+}
+/**
+ * @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())
+ * );
+ * ```
+ */
+function validators(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => 
+    // Sadly the node-template is (for some obscure reason) not comprehensive, so while the derive works
+    // in all actual real-world deployed chains, it does create some confusion for limited template chains
+    (0, rxjs_1.combineLatest)([
+        api.query.session
+            ? api.query.session.validators()
+            : (0, rxjs_1.of)([]),
+        api.query.staking
+            ? api.derive.staking.nextElected()
+            : (0, rxjs_1.of)([])
+    ]).pipe((0, rxjs_1.map)(([validators, nextElected]) => ({
+        nextElected: nextElected.length
+            ? nextElected
+            : validators,
+        validators
+    }))));
+}

package/cjs/staking/waitingInfo.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitingInfo = waitingInfo;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+const DEFAULT_FLAGS = { withController: true, withPrefs: true };
+/**
+ * @name waitingInfo
+ * @param {StakingQueryFlags} flags? (Optional) Query flags to filter the staking data.
+ * @description Staking candidates who are waiting to become validators.
+ * @example
+ * ```javascript
+ * const { waiting, info } = await api.derive.staking.waitingInfo();
+ * console.log(
+ *   "Waiting Candidates:",
+ *   waiting.map((acc) => acc.toString())
+ * );
+ * ```
+ */
+function waitingInfo(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (flags = DEFAULT_FLAGS) => (0, rxjs_1.combineLatest)([
+        api.derive.staking.validators(),
+        api.derive.staking.stashes()
+    ]).pipe((0, rxjs_1.switchMap)(([{ nextElected }, stashes]) => {
+        const elected = nextElected.map((a) => a.toString());
+        const waiting = stashes.filter((v) => !elected.includes(v.toString()));
+        return api.derive.staking.queryMulti(waiting, flags).pipe((0, rxjs_1.map)((info) => ({
+            info,
+            waiting
+        })));
+    })));
+}