@pezkuwi/api-derive 16.5.5 → 16.5.6

package/cjs/session/progress.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionProgress = exports.eraProgress = exports.eraLength = void 0;
+exports.progress = progress;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+function withProgressField(field) {
+    return (instanceId, api) => (0, index_js_1.memo)(instanceId, () => api.derive.session.progress().pipe((0, rxjs_1.map)((info) => info[field])));
+}
+function createDerive(api, info, [currentSlot, epochIndex, epochOrGenesisStartSlot, activeEraStartSessionIndex]) {
+    const epochStartSlot = epochIndex.mul(info.sessionLength).iadd(epochOrGenesisStartSlot);
+    const sessionProgress = currentSlot.sub(epochStartSlot);
+    const eraProgress = info.currentIndex.sub(activeEraStartSessionIndex).imul(info.sessionLength).iadd(sessionProgress);
+    return (0, util_1.objectSpread)({
+        eraProgress: api.registry.createType('BlockNumber', eraProgress),
+        sessionProgress: api.registry.createType('BlockNumber', sessionProgress)
+    }, info);
+}
+function queryAura(api) {
+    return api.derive.session.info().pipe((0, rxjs_1.map)((info) => (0, util_1.objectSpread)({
+        eraProgress: api.registry.createType('BlockNumber'),
+        sessionProgress: api.registry.createType('BlockNumber')
+    }, info)));
+}
+function queryBabe(api) {
+    return api.derive.session.info().pipe((0, rxjs_1.switchMap)((info) => (0, rxjs_1.combineLatest)([
+        (0, rxjs_1.of)(info),
+        // we may have no staking, but have babe (permissioned)
+        api.query.staking?.erasStartSessionIndex
+            ? api.queryMulti([
+                api.query.babe.currentSlot,
+                api.query.babe.epochIndex,
+                api.query.babe.genesisSlot,
+                [api.query.staking.erasStartSessionIndex, info.activeEra]
+            ])
+            : api.queryMulti([
+                api.query.babe.currentSlot,
+                api.query.babe.epochIndex,
+                api.query.babe.genesisSlot
+            ])
+    ])), (0, rxjs_1.map)(([info, [currentSlot, epochIndex, genesisSlot, optStartIndex]]) => [
+        info, [currentSlot, epochIndex, genesisSlot, optStartIndex && optStartIndex.isSome ? optStartIndex.unwrap() : api.registry.createType('SessionIndex', 1)]
+    ]));
+}
+/**
+ * @name progress
+ * @description Retrieves session information and progress.
+ * @example
+ * ```javascript
+ * api.derive.session.progress((progress) => {
+ *   console.log(`Session progress ${JSON.stringify(progress)}`);
+ * });
+ * ```
+ */
+function progress(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.query.babe
+        ? queryBabe(api).pipe((0, rxjs_1.map)(([info, slots]) => createDerive(api, info, slots)))
+        : queryAura(api));
+}
+/**
+ * @name eraLenght
+ * @description Retrieves the total length of the current era.
+ * @example
+ * ```javascript
+ * api.derive.session.eraLength((length) => {
+ *   console.log(`Current era length: ${length} sessions`);
+ * });
+ * ```
+ */
+exports.eraLength = withProgressField('eraLength');
+/**
+ * @name eraProgress
+ * @description Retrieves the progress of the current era.
+ * @example
+ * ```javascript
+ * api.derive.session.eraProgress((progress) => {
+ *   console.log(`Current era progress: ${progress} sessions`);
+ * });
+ * ```
+ */
+exports.eraProgress = withProgressField('eraProgress');
+/**
+ * @name sessionProgress
+ * @description Retrieves the progress of the current session.
+ * @example
+ * ```javascript
+ *   api.derive.session.sessionProgress((progress) => {
+ *   console.log(`Current session progress: ${progress} slots`);
+ * });
+ * ```
+ */
+exports.sessionProgress = withProgressField('sessionProgress');

package/cjs/session/types.js

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

package/cjs/society/candidates.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.candidates = candidates;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+function getPrev(api) {
+    return api.query.society.candidates().pipe((0, rxjs_1.switchMap)((candidates) => (0, rxjs_1.combineLatest)([
+        (0, rxjs_1.of)(candidates),
+        api.query.society['suspendedCandidates'].multi(candidates.map(({ who }) => who))
+    ])), (0, rxjs_1.map)(([candidates, suspended]) => candidates.map(({ kind, value, who }, index) => ({
+        accountId: who,
+        isSuspended: suspended[index].isSome,
+        kind,
+        value
+    }))));
+}
+function getCurr(api) {
+    return api.query.society.candidates.entries().pipe((0, rxjs_1.map)((entries) => entries
+        .filter(([, opt]) => opt.isSome)
+        .map(([{ args: [accountId] }, opt]) => [accountId, opt.unwrap()])
+        // FIXME We are missing the new fields from the candidate record
+        .map(([accountId, { bid, kind }]) => ({
+        accountId,
+        isSuspended: false,
+        kind,
+        value: bid
+    }))));
+}
+/**
+ * @name candidate
+ * @description Retrieves the list of candidates for the society module.
+ * @example
+ * ```javascript
+ * const societyCandidates = await api.derive.society.candidates();
+ * console.log(societyCandidates);
+ * ```
+ */
+function candidates(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.query.society['suspendedCandidates'] && api.query.society.candidates.creator.meta.type.isPlain
+        ? getPrev(api)
+        : getCurr(api));
+}

package/cjs/society/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./candidates.js"), exports);
+tslib_1.__exportStar(require("./info.js"), exports);
+tslib_1.__exportStar(require("./member.js"), exports);
+tslib_1.__exportStar(require("./members.js"), exports);

package/cjs/society/info.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.info = info;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name info
+ * @description Get the overall info for a society.
+ * @example
+ * ```javascript
+ * const societyInfo = await api.derive.society.candidates();
+ * console.log(societyInfo);
+ * ```
+ */
+function info(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => (0, rxjs_1.combineLatest)([
+        api.query.society.bids(),
+        api.query.society['defender']
+            ? api.query.society['defender']()
+            : (0, rxjs_1.of)(undefined),
+        api.query.society.founder(),
+        api.query.society.head(),
+        api.query.society['maxMembers']
+            ? api.query.society['maxMembers']()
+            : (0, rxjs_1.of)(undefined),
+        api.query.society.pot()
+    ]).pipe((0, rxjs_1.map)(([bids, defender, founder, head, maxMembers, pot]) => ({
+        bids,
+        defender: defender?.unwrapOr(undefined),
+        founder: founder.unwrapOr(undefined),
+        hasDefender: (defender?.isSome && head.isSome && !head.eq(defender)) || false,
+        head: head.unwrapOr(undefined),
+        maxMembers,
+        pot
+    }))));
+}

package/cjs/society/member.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.member = member;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name member
+ * @description Get the member info for a society.
+ * @param { AccountId } accountId
+ * @example
+ * ```javascript
+ * const member = await api.derive.society.member(ALICE);
+ * console.log(member);
+ * ```
+ */
+function member(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountId) => api.derive.society._members([accountId]).pipe((0, rxjs_1.map)(([result]) => result)));
+}

package/cjs/society/members.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._members = _members;
+exports.members = members;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+function _membersPrev(api, accountIds) {
+    return (0, rxjs_1.combineLatest)([
+        (0, rxjs_1.of)(accountIds),
+        api.query.society.payouts.multi(accountIds),
+        api.query.society['strikes'].multi(accountIds),
+        api.query.society.defenderVotes.multi(accountIds),
+        api.query.society.suspendedMembers.multi(accountIds),
+        api.query.society['vouching'].multi(accountIds)
+    ]).pipe((0, rxjs_1.map)(([accountIds, payouts, strikes, defenderVotes, suspended, vouching]) => accountIds.map((accountId, index) => ({
+        accountId,
+        isDefenderVoter: defenderVotes[index].isSome,
+        isSuspended: suspended[index].isTrue,
+        payouts: payouts[index],
+        strikes: strikes[index],
+        vote: defenderVotes[index].unwrapOr(undefined),
+        vouching: vouching[index].unwrapOr(undefined)
+    }))));
+}
+function _membersCurr(api, accountIds) {
+    return (0, rxjs_1.combineLatest)([
+        (0, rxjs_1.of)(accountIds),
+        api.query.society.members.multi(accountIds),
+        api.query.society.payouts.multi(accountIds),
+        api.query.society.challengeRoundCount().pipe((0, rxjs_1.switchMap)((round) => api.query.society.defenderVotes.multi(accountIds.map((accountId) => [round, accountId])))),
+        api.query.society.suspendedMembers.multi(accountIds)
+    ]).pipe((0, rxjs_1.map)(([accountIds, members, payouts, defenderVotes, suspendedMembers]) => accountIds
+        .map((accountId, index) => members[index].isSome
+        ? {
+            accountId,
+            isDefenderVoter: defenderVotes[index].isSome,
+            isSuspended: suspendedMembers[index].isSome,
+            member: members[index].unwrap(),
+            payouts: payouts[index].payouts
+        }
+        : null)
+        .filter((m) => !!m)
+        .map(({ accountId, isDefenderVoter, isSuspended, member, payouts }) => ({
+        accountId,
+        isDefenderVoter,
+        isSuspended,
+        payouts,
+        strikes: member.strikes,
+        vouching: member.vouching.unwrapOr(undefined)
+    }))));
+}
+function _members(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountIds) => api.query.society.members.creator.meta.type.isMap
+        ? _membersCurr(api, accountIds)
+        : _membersPrev(api, accountIds));
+}
+/**
+ * @name members
+ * @description Get the society members.
+ * @example
+ * ```javascript
+ * const members = await api.derive.society.members();
+ * console.log(members);
+ * ```
+ */
+function members(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.query.society.members.creator.meta.type.isMap
+        ? api.query.society.members.keys().pipe((0, rxjs_1.switchMap)((keys) => api.derive.society._members(keys.map(({ args: [accountId] }) => accountId))))
+        : api.query.society.members().pipe((0, rxjs_1.switchMap)((members) => api.derive.society._members(members))));
+}

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

@@ -1,8 +1,8 @@
 import type { u32 } from '@pezkuwi/types';
 import type { AccountId, Balance, BalanceOf, BlockNumber, StrikeCount } from '@pezkuwi/types/interfaces';
-import type { PalletSocietyBid, PalletSocietyBidKind, PalletSocietyVote, PalletSocietyVouchingStatus } from '@pezkuwi/types/lookup';
+import type { PezpalletSocietyBid, PezpalletSocietyBidKind, PezpalletSocietyVote, PezpalletSocietyVouchingStatus } from '@pezkuwi/types/lookup';
 export interface DeriveSociety {
-    bids: PalletSocietyBid[];
+    bids: PezpalletSocietyBid[];
     defender?: AccountId | undefined;
     hasDefender: boolean;
     head?: AccountId | undefined;
@@ -12,7 +12,7 @@ export interface DeriveSociety {
 }
 export interface DeriveSocietyCandidate {
     accountId: AccountId;
-    kind: PalletSocietyBidKind;
+    kind: PezpalletSocietyBidKind;
     value: Balance;
     isSuspended: boolean;
 }
@@ -22,6 +22,6 @@ export interface DeriveSocietyMember {
     isSuspended: boolean;
     payouts: [BlockNumber, Balance][];
     strikes: StrikeCount;
-    vote?: PalletSocietyVote | undefined;
-    vouching?: PalletSocietyVouchingStatus | undefined;
+    vote?: PezpalletSocietyVote | undefined;
+    vouching?: PezpalletSocietyVouchingStatus | undefined;
 }

package/cjs/society/types.js

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

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

@@ -28,4 +28,4 @@ export declare function accounts(instanceId: string, api: DeriveApi): (accountId
  * console.log(accountStakingData);
  * ```
  */
-export declare const account: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array<ArrayBufferLike>, opts?: StakingQueryFlags) => Observable<DeriveStakingAccount>;
+export declare const account: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, opts?: StakingQueryFlags | undefined) => Observable<DeriveStakingAccount>;

package/cjs/staking/account.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.account = void 0;
+exports.accounts = accounts;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../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] || util_1.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 util_1.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 util_1.BN(0)));
+}
+function parseResult(api, sessionInfo, keys, query) {
+    return (0, util_1.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]);
+ * ```
+ */
+function accounts(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountIds, opts = QUERY_OPTS) => api.derive.session.info().pipe((0, rxjs_1.switchMap)((sessionInfo) => (0, rxjs_1.combineLatest)([
+        api.derive.staking.keysMulti(accountIds),
+        api.derive.staking.queryMulti(accountIds, opts)
+    ]).pipe((0, rxjs_1.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);
+ * ```
+ */
+exports.account = (0, index_js_1.firstMemo)((api, accountId, opts) => api.derive.staking.accounts([accountId], opts));

package/cjs/staking/cache.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEraCache = getEraCache;
+exports.getEraMultiCache = getEraMultiCache;
+exports.setEraCache = setEraCache;
+exports.setEraMultiCache = setEraMultiCache;
+exports.filterCachedEras = filterCachedEras;
+const index_js_1 = require("../util/index.js");
+function getEraCache(CACHE_KEY, era, withActive) {
+    const cacheKey = `${CACHE_KEY}-${era.toString()}`;
+    return [
+        cacheKey,
+        withActive
+            ? undefined
+            : index_js_1.deriveCache.get(cacheKey)
+    ];
+}
+function getEraMultiCache(CACHE_KEY, eras, withActive) {
+    const cached = withActive
+        ? []
+        : eras
+            .map((e) => index_js_1.deriveCache.get(`${CACHE_KEY}-${e.toString()}`))
+            .filter((v) => !!v);
+    return cached;
+}
+function setEraCache(cacheKey, withActive, value) {
+    !withActive && index_js_1.deriveCache.set(cacheKey, value);
+    return value;
+}
+function setEraMultiCache(CACHE_KEY, withActive, values) {
+    !withActive && values.forEach((v) => index_js_1.deriveCache.set(`${CACHE_KEY}-${v.era.toString()}`, v));
+    return values;
+}
+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/{build → cjs}/staking/currentPoints.d.ts

@@ -1,5 +1,5 @@
 import type { Observable } from 'rxjs';
-import type { PalletStakingEraRewardPoints } from '@pezkuwi/types/lookup';
+import type { PezpalletStakingEraRewardPoints } from '@pezkuwi/types/lookup';
 import type { DeriveApi } from '../types.js';
 /**
  * @name currentPoints
@@ -10,4 +10,4 @@ import type { DeriveApi } from '../types.js';
  * console.log(currentPoints.toHuman());
  * ```
  */
-export declare function currentPoints(instanceId: string, api: DeriveApi): () => Observable<PalletStakingEraRewardPoints>;
+export declare function currentPoints(instanceId: string, api: DeriveApi): () => Observable<PezpalletStakingEraRewardPoints>;

package/cjs/staking/currentPoints.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentPoints = currentPoints;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../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());
+ * ```
+ */
+function currentPoints(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.derive.session.indexes().pipe((0, rxjs_1.switchMap)(({ activeEra }) => api.query.staking.erasRewardPoints(activeEra))));
+}

package/cjs/staking/electedInfo.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.electedInfo = electedInfo;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const DEFAULT_FLAGS = { withController: true, withExposure: true, withPrefs: true };
+function combineAccounts(nextElected, validators) {
+    return (0, util_1.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);
+ * ```
+ */
+function electedInfo(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (flags = DEFAULT_FLAGS, page = 0) => api.derive.staking.validators().pipe((0, rxjs_1.switchMap)(({ nextElected, validators }) => api.derive.staking.queryMulti(combineAccounts(nextElected, validators), flags, page).pipe((0, rxjs_1.map)((info) => ({
+        info,
+        nextElected,
+        validators
+    }))))));
+}

package/cjs/staking/erasExposure.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.erasExposure = exports._erasExposure = exports.eraExposure = void 0;
+exports._eraExposure = _eraExposure;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+const cache_js_1 = require("./cache.js");
+const util_js_1 = require("./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.
+ */
+function _eraExposure(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (era, withActive = false) => {
+        const [cacheKey, cached] = (0, cache_js_1.getEraCache)(CACHE_KEY, era, withActive);
+        return cached
+            ? (0, rxjs_1.of)(cached)
+            : api.query.staking.erasStakersPaged
+                ? api.query.staking.erasStakersPaged.entries(era).pipe((0, rxjs_1.map)((r) => (0, cache_js_1.setEraCache)(cacheKey, withActive, mapStakersPaged(era, r))))
+                : api.query.staking.erasStakersClipped.entries(era).pipe((0, rxjs_1.map)((r) => (0, cache_js_1.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);
+ * ```
+ */
+exports.eraExposure = (0, util_js_1.singleEra)('_eraExposure');
+exports._erasExposure = (0, util_js_1.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);
+ * ```
+ */
+exports.erasExposure = (0, util_js_1.erasHistoricApply)('_erasExposure');

package/cjs/staking/erasHistoric.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.erasHistoric = erasHistoric;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name erasHistoric
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ */
+function erasHistoric(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (withActive) => (0, rxjs_1.combineLatest)([
+        api.query.staking.activeEra(),
+        api.consts.staking.historyDepth
+            ? (0, rxjs_1.of)(api.consts.staking.historyDepth)
+            : api.query.staking['historyDepth']()
+    ]).pipe((0, rxjs_1.map)(([activeEraOpt, historyDepth]) => {
+        const result = [];
+        const max = historyDepth.toNumber();
+        const activeEra = activeEraOpt.unwrapOrDefault().index;
+        let lastEra = activeEra;
+        while (lastEra.gte(util_1.BN_ZERO) && (result.length < max)) {
+            if ((lastEra !== activeEra) || (withActive === true)) {
+                result.push(api.registry.createType('EraIndex', lastEra));
+            }
+            lastEra = lastEra.sub(util_1.BN_ONE);
+        }
+        // go from oldest to newest
+        return result.reverse();
+    })));
+}

package/cjs/staking/erasPoints.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.erasPoints = void 0;
+exports._erasPoints = _erasPoints;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const cache_js_1 = require("./cache.js");
+const util_js_1 = require("./util.js");
+const CACHE_KEY = 'eraPoints';
+function mapValidators({ individual }) {
+    return [...individual.entries()]
+        .filter(([, points]) => points.gt(util_1.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])
+    }));
+}
+function _erasPoints(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (eras, withActive) => {
+        if (!eras.length) {
+            return (0, rxjs_1.of)([]);
+        }
+        const cached = (0, cache_js_1.getEraMultiCache)(CACHE_KEY, eras, withActive);
+        const remaining = (0, util_js_1.filterEras)(eras, cached);
+        return !remaining.length
+            ? (0, rxjs_1.of)(cached)
+            : api.query.staking.erasRewardPoints.multi(remaining).pipe((0, rxjs_1.map)((p) => (0, cache_js_1.filterCachedEras)(eras, cached, (0, cache_js_1.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}`)
+ * );
+ * ```
+ */
+exports.erasPoints = (0, util_js_1.erasHistoricApply)('_erasPoints');