@pezkuwi/api-derive 16.5.5 → 16.5.6

package/cjs/staking/erasPrefs.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.erasPrefs = exports._erasPrefs = exports.eraPrefs = void 0;
+exports._eraPrefs = _eraPrefs;
+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 = 'eraPrefs';
+function mapPrefs(era, all) {
+    const validators = {};
+    all.forEach(([key, prefs]) => {
+        validators[key.args[1].toString()] = prefs;
+    });
+    return { era, validators };
+}
+function _eraPrefs(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (era, withActive) => {
+        const [cacheKey, cached] = (0, cache_js_1.getEraCache)(CACHE_KEY, era, withActive);
+        return cached
+            ? (0, rxjs_1.of)(cached)
+            : api.query.staking.erasValidatorPrefs.entries(era).pipe((0, rxjs_1.map)((r) => (0, cache_js_1.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));
+ * ```
+ */
+exports.eraPrefs = (0, util_js_1.singleEra)('_eraPrefs');
+exports._erasPrefs = (0, util_js_1.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);
+ * ```
+ */
+exports.erasPrefs = (0, util_js_1.erasHistoricApply)('_erasPrefs');

package/cjs/staking/erasRewards.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.erasRewards = void 0;
+exports._erasRewards = _erasRewards;
+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 = 'eraRewards';
+function mapRewards(eras, optRewards) {
+    return eras.map((era, index) => ({
+        era,
+        eraReward: optRewards[index].unwrapOrDefault()
+    }));
+}
+function _erasRewards(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);
+        if (!remaining.length) {
+            return (0, rxjs_1.of)(cached);
+        }
+        return api.query.staking.erasValidatorReward.multi(remaining).pipe((0, rxjs_1.map)((r) => (0, cache_js_1.filterCachedEras)(eras, cached, (0, cache_js_1.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);
+ * ```
+ */
+exports.erasRewards = (0, util_js_1.erasHistoricApply)('_erasRewards');

package/cjs/staking/erasSlashes.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.erasSlashes = exports._erasSlashes = exports.eraSlashes = void 0;
+exports._eraSlashes = _eraSlashes;
+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 = '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 };
+}
+function _eraSlashes(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (era, withActive) => {
+        const [cacheKey, cached] = (0, cache_js_1.getEraCache)(CACHE_KEY, era, withActive);
+        return cached
+            ? (0, rxjs_1.of)(cached)
+            : (0, rxjs_1.combineLatest)([
+                api.query.staking.nominatorSlashInEra.entries(era),
+                api.query.staking.validatorSlashInEra.entries(era)
+            ]).pipe((0, rxjs_1.map)(([n, v]) => (0, cache_js_1.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);
+ * ```
+ */
+exports.eraSlashes = (0, util_js_1.singleEra)('_eraSlashes');
+exports._erasSlashes = (0, util_js_1.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);
+ * ```
+ */
+exports.erasSlashes = (0, util_js_1.erasHistoricApply)('_erasSlashes');

package/cjs/staking/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./account.js"), exports);
+tslib_1.__exportStar(require("./currentPoints.js"), exports);
+tslib_1.__exportStar(require("./electedInfo.js"), exports);
+tslib_1.__exportStar(require("./erasExposure.js"), exports);
+tslib_1.__exportStar(require("./erasHistoric.js"), exports);
+tslib_1.__exportStar(require("./erasPoints.js"), exports);
+tslib_1.__exportStar(require("./erasPrefs.js"), exports);
+tslib_1.__exportStar(require("./erasRewards.js"), exports);
+tslib_1.__exportStar(require("./erasSlashes.js"), exports);
+tslib_1.__exportStar(require("./keys.js"), exports);
+tslib_1.__exportStar(require("./overview.js"), exports);
+tslib_1.__exportStar(require("./ownExposure.js"), exports);
+tslib_1.__exportStar(require("./ownSlashes.js"), exports);
+tslib_1.__exportStar(require("./query.js"), exports);
+tslib_1.__exportStar(require("./stakerExposure.js"), exports);
+tslib_1.__exportStar(require("./stakerPoints.js"), exports);
+tslib_1.__exportStar(require("./stakerPrefs.js"), exports);
+tslib_1.__exportStar(require("./stakerRewards.js"), exports);
+tslib_1.__exportStar(require("./stakerSlashes.js"), exports);
+tslib_1.__exportStar(require("./stashes.js"), exports);
+tslib_1.__exportStar(require("./validators.js"), exports);
+tslib_1.__exportStar(require("./waitingInfo.js"), exports);

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

@@ -16,7 +16,7 @@ import type { DeriveStakingKeys } from './types.js';
  * );
  * ```
  */
-export declare const keys: (instanceId: string, api: DeriveApi) => (stashId: string | Uint8Array<ArrayBufferLike>) => Observable<DeriveStakingKeys>;
+export declare const keys: (instanceId: string, api: DeriveApi) => (stashId: string | Uint8Array) => Observable<DeriveStakingKeys>;
 /**
  * @name keysMulti
  * @description Retrieves session keys for multiple stash accounts.

package/cjs/staking/keys.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keys = void 0;
+exports.keysMulti = keysMulti;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+function extractsIds(stashId, queuedKeys, nextKeys) {
+    const sessionIds = (queuedKeys.find(([currentId]) => currentId.eq(stashId)) || [undefined, []])[1];
+    const nextSessionIds = nextKeys.unwrapOr([]);
+    return {
+        nextSessionIds: Array.isArray(nextSessionIds)
+            ? nextSessionIds
+            : [...nextSessionIds.values()],
+        sessionIds: Array.isArray(sessionIds)
+            ? sessionIds
+            : [...sessionIds.values()]
+    };
+}
+/**
+ * @name keys
+ * @param { Uint8Array | string } stashId The stash account ID whose session keys are to be retrieved.
+ * @description Retrieves the session keys associated with a given stash account.
+ * @example
+ * ```javascript
+ * const keys = await api.derive.staking.keys(
+ *   ALICE
+ * );
+ * console.log(
+ *   "Session keys:",
+ *   keys.sessionIds.map((key) => `Key: ${key}`)
+ * );
+ * ```
+ */
+exports.keys = (0, index_js_1.firstMemo)((api, stashId) => api.derive.staking.keysMulti([stashId]));
+/**
+ * @name keysMulti
+ * @description Retrieves session keys for multiple stash accounts.
+ * @param { (Uint8Array | string)[] } stashIds Array of stash account IDs.
+ * @example
+ * ```javascript
+ * const keysMulti = await api.derive.staking.keysMulti([ ALICE, BOB ]);
+ * keysMulti.forEach((keys) => {
+ *   console.log(
+ *     "Session keys:",
+ *     keys.sessionIds.map((key) => `Key: ${key}`)
+ *   );
+ * });
+ * ```
+ */
+function keysMulti(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (stashIds) => stashIds.length
+        ? api.query.session.queuedKeys().pipe((0, rxjs_1.switchMap)((queuedKeys) => (0, rxjs_1.combineLatest)([
+            (0, rxjs_1.of)(queuedKeys),
+            // eslint-disable-next-line @typescript-eslint/dot-notation
+            api.consts['session']?.['dedupKeyPrefix']
+                // eslint-disable-next-line @typescript-eslint/dot-notation
+                ? api.query.session.nextKeys.multi(stashIds.map((s) => [api.consts['session']['dedupKeyPrefix'], s]))
+                : (0, rxjs_1.combineLatest)(stashIds.map((s) => api.query.session.nextKeys(s)))
+        ])), (0, rxjs_1.map)(([queuedKeys, nextKeys]) => stashIds.map((stashId, index) => extractsIds(stashId, queuedKeys, nextKeys[index]))))
+        : (0, rxjs_1.of)([]));
+}

package/cjs/staking/overview.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overview = overview;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name overview
+ * @description Retrieve the staking overview, including elected validators and points earned.
+ * @example
+ * ```javascript
+ * const {
+ *   activeEra,
+ *   activeEraStart,
+ *   currentEra,
+ *   currentIndex,
+ *   nextElected,
+ *   validatorCount,
+ *   validators,
+ * } = await api.derive.staking.overview();
+ * ```
+ */
+function overview(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => (0, rxjs_1.combineLatest)([
+        api.derive.session.indexes(),
+        api.derive.staking.validators()
+    ]).pipe((0, rxjs_1.map)(([indexes, { nextElected, validators }]) => (0, util_1.objectSpread)({}, indexes, {
+        nextElected,
+        validators
+    }))));
+}

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

@@ -20,7 +20,7 @@ export declare function _ownExposures(instanceId: string, api: DeriveApi): (acco
  * console.log(JSON.stringify(exposure));
  * ```
  */
-export declare const ownExposure: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array<ArrayBufferLike>, era: EraIndex, page?: u32 | AnyNumber) => Observable<DeriveOwnExposure>;
+export declare const ownExposure: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, era: EraIndex, page?: u32 | AnyNumber | undefined) => Observable<DeriveOwnExposure>;
 /**
  * @name ownExposures
  * @description Retrieves staking exposures for a validator across multiple historical eras.

package/cjs/staking/ownExposure.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ownExposures = exports.ownExposure = void 0;
+exports._ownExposures = _ownExposures;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+function _ownExposures(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountId, eras, _withActive, page) => {
+        const emptyStakingExposure = api.registry.createType('Exposure');
+        // The reason we don't explicitly make the actual types is for compatibility. If the chain doesn't have the noted type it will fail
+        // on construction. Therefore we just make an empty option.
+        const emptyOptionPage = api.registry.createType('Option<Null>');
+        const emptyOptionMeta = api.registry.createType('Option<Null>');
+        return eras.length
+            ? (0, rxjs_1.combineLatest)([
+                // Backwards and forward compat for historical integrity when using `erasHistoricApplyAccount`
+                api.query.staking.erasStakersClipped
+                    ? (0, rxjs_1.combineLatest)(eras.map((e) => api.query.staking.erasStakersClipped(e, accountId)))
+                    : (0, rxjs_1.of)(eras.map((_) => emptyStakingExposure)),
+                api.query.staking.erasStakers
+                    ? (0, rxjs_1.combineLatest)(eras.map((e) => api.query.staking.erasStakers(e, accountId)))
+                    : (0, rxjs_1.of)(eras.map((_) => emptyStakingExposure)),
+                api.query.staking.erasStakersPaged
+                    ? (0, rxjs_1.combineLatest)(eras.map((e) => api.query.staking.erasStakersPaged(e, accountId, page)))
+                    : (0, rxjs_1.of)(eras.map((_) => emptyOptionPage)),
+                api.query.staking.erasStakersOverview
+                    ? (0, rxjs_1.combineLatest)(eras.map((e) => api.query.staking.erasStakersOverview(e, accountId)))
+                    : (0, rxjs_1.of)(eras.map((_) => emptyOptionMeta))
+            ]).pipe((0, rxjs_1.map)(([clp, exp, paged, expMeta]) => eras.map((era, index) => ({ clipped: clp[index], era, exposure: exp[index], exposureMeta: expMeta[index], exposurePaged: paged[index] }))))
+            : (0, rxjs_1.of)([]);
+    });
+}
+/**
+ * @name ownExposure
+ * @description Retrieves the staking exposure of a validator for a specific era, including their own stake.
+ * @param { Uint8Array | string } accountId The validator stash account.
+ * @param {EraIndex} era The staking era to query.
+ * @param { u32 | AnyNumber } page? (Optional) The pagination index.
+ * @example
+ * ```javascript
+ * const era = api.createType("EraIndex", 1000);
+ * const exposure = await api.derive.staking.ownExposure(
+ *   "11VR4pF6c7kfBhfmuwwjWY3FodeYBKWx7ix2rsRCU2q6hqJ",
+ *   era
+ * );
+ * console.log(JSON.stringify(exposure));
+ * ```
+ */
+exports.ownExposure = (0, index_js_1.firstMemo)((api, accountId, era, page) => api.derive.staking._ownExposures(accountId, [era], true, page || 0));
+/**
+ * @name ownExposures
+ * @description Retrieves staking exposures for a validator across multiple historical eras.
+ * @param { Uint8Array | string } accountId The validator stash account.
+ * @param { boolean } withActive Whether to include the active era.
+ * @example
+ * ```javascript
+ * const exposures = await api.derive.staking.ownExposures(
+ *   ALICE,
+ *   true
+ * );
+ * ```
+ */
+exports.ownExposures = (0, util_js_1.erasHistoricApplyAccount)('_ownExposures');

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

@@ -17,7 +17,7 @@ export declare function _ownSlashes(instanceId: string, api: DeriveApi): (accoun
  * console.log(`Era: ${slashedAmount.era}, total ${slashedAmount.total}`);
  * ```
  */
-export declare const ownSlash: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array<ArrayBufferLike>, era: EraIndex) => Observable<DeriveStakerSlashes>;
+export declare const ownSlash: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, era: EraIndex) => Observable<DeriveStakerSlashes>;
 /**
  * @name ownSlashes
  * @description Retrieves the slashes for a specific account across all historic eras.

package/cjs/staking/ownSlashes.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ownSlashes = exports.ownSlash = void 0;
+exports._ownSlashes = _ownSlashes;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+function _ownSlashes(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountId, eras, _withActive) => eras.length
+        ? (0, rxjs_1.combineLatest)([
+            (0, rxjs_1.combineLatest)(eras.map((e) => api.query.staking.validatorSlashInEra(e, accountId))),
+            (0, rxjs_1.combineLatest)(eras.map((e) => api.query.staking.nominatorSlashInEra(e, accountId)))
+        ]).pipe((0, rxjs_1.map)(([vals, noms]) => eras.map((era, index) => ({
+            era,
+            total: vals[index].isSome
+                ? vals[index].unwrap()[1]
+                : noms[index].unwrapOrDefault()
+        }))))
+        : (0, rxjs_1.of)([]));
+}
+/**
+ * @name ownSlash
+ * @description Retrieves the slashes applied to a specific account in a given era.
+ * @param { Uint8Array | string } accountId The validator stash account.
+ * @param {EraIndex} era The staking era to query.
+ * @example
+ * ```javascript
+ * const era = api.createType("EraIndex", 1000);
+ * const slashedAmount = await api.derive.staking.ownSlash(
+ *   ALICE,
+ *   era
+ * );
+ * console.log(`Era: ${slashedAmount.era}, total ${slashedAmount.total}`);
+ * ```
+ */
+exports.ownSlash = (0, index_js_1.firstMemo)((api, accountId, era) => api.derive.staking._ownSlashes(accountId, [era], true));
+/**
+ * @name ownSlashes
+ * @description Retrieves the slashes for a specific account across all historic eras.
+ * @param { Uint8Array | string } accountId The validator stash account.
+ * @param { boolean } withActive Whether to include the active era.
+ * @example
+ * ```javascript
+ * const slashes = await api.derive.staking.ownSlashes(
+ *   ALICE,
+ *   true
+ * );
+ * console.log(slashes);
+ * ```
+ */
+exports.ownSlashes = (0, util_js_1.erasHistoricApplyAccount)('_ownSlashes');

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

@@ -16,7 +16,7 @@ import type { DeriveApi, DeriveStakingQuery, StakingQueryFlags } from '../types.
  * );
  * ```
  */
-export declare const query: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array<ArrayBufferLike>, flags: StakingQueryFlags, page?: u32) => Observable<DeriveStakingQuery>;
+export declare const query: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, flags: StakingQueryFlags, page?: u32 | undefined) => Observable<DeriveStakingQuery>;
 /**
  * @name queryMulti
  * @param { (Uint8Array | string)[] } accountIds List of stash accounts to query.

package/cjs/staking/query.js

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

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

@@ -30,4 +30,4 @@ export declare function stakerExposures(instanceId: string, api: DeriveApi): (ac
  * );
  * ```
 */
-export declare const stakerExposure: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array<ArrayBufferLike>, withActive?: boolean) => Observable<DeriveStakerExposure[]>;
+export declare const stakerExposure: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, withActive?: boolean | undefined) => Observable<DeriveStakerExposure[]>;

package/cjs/staking/stakerExposure.js

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