@pezkuwi/api-derive 16.5.5

package/build/staking/erasPrefs.d.ts

@@ -0,0 +1,27 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraPrefs } from '../types.js';
+export declare function _eraPrefs(instanceId: string, api: DeriveApi): (era: EraIndex, withActive: boolean) => Observable<DeriveEraPrefs>;
+/**
+ * @name eraPrefs
+ * @description Retrieves the validators commission preferences for a given staking era.
+ * @param {EraIndex} era The staking era to query.
+ * @example
+ * ```javascript
+ * const era = api.createType("EraIndex", 1000);
+ * const prefs = await api.derive.staking.eraPrefs(era);
+ * console.log(JSON.stringify(prefs));
+ * ```
+ */
+export declare const eraPrefs: (instanceId: string, api: DeriveApi) => (era: EraIndex) => Observable<DeriveEraPrefs>;
+export declare const _erasPrefs: (instanceId: string, api: DeriveApi) => (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraPrefs[]>;
+/**
+ * @name erasPrefs
+ * @description Retrieves validators commission preferences for multiple past staking eras
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ * @example
+ * ```javascript
+ * const prefs = await api.derive.staking.erasPrefs(true);
+ * ```
+ */
+export declare const erasPrefs: (instanceId: string, api: DeriveApi) => (withActive?: boolean) => Observable<DeriveEraPrefs[]>;

package/build/staking/erasRewards.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraRewards } from '../types.js';
+export declare function _erasRewards(instanceId: string, api: DeriveApi): (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraRewards[]>;
+/**
+ * @name erasRewards
+ * @description Retrieves rewards for historical eras.
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ * @example
+ * ```javascript
+ * const rewards = await api.derive.staking.erasRewards(true);
+ * ```
+ */
+export declare const erasRewards: (instanceId: string, api: DeriveApi) => (withActive?: boolean) => Observable<DeriveEraRewards[]>;

package/build/staking/erasSlashes.d.ts

@@ -0,0 +1,26 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraSlashes } from '../types.js';
+export declare function _eraSlashes(instanceId: string, api: DeriveApi): (era: EraIndex, withActive: boolean) => Observable<DeriveEraSlashes>;
+/**
+ * @name eraSlashes
+ * @description Retrieves the slashes for a specific staking era.
+ * @param {EraIndex} eras The staking era to query.
+ * @example
+ * ```javascript
+ * const era = api.createType("EraIndex", 1000);
+ * const slashes = await api.derive.staking.eraSlashes(era);
+ * ```
+ */
+export declare const eraSlashes: (instanceId: string, api: DeriveApi) => (era: EraIndex) => Observable<DeriveEraSlashes>;
+export declare const _erasSlashes: (instanceId: string, api: DeriveApi) => (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraSlashes[]>;
+/**
+ * @name erasSlashes
+ * @description Retrieves slashes for historical eras.
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ * @example
+ * ```javascript
+ * const slashes = await api.derive.staking.erasSlashes(true);
+ * ```
+ */
+export declare const erasSlashes: (instanceId: string, api: DeriveApi) => (withActive?: boolean) => Observable<DeriveEraSlashes[]>;

package/build/staking/index.d.ts

@@ -0,0 +1,22 @@
+export * from './account.js';
+export * from './currentPoints.js';
+export * from './electedInfo.js';
+export * from './erasExposure.js';
+export * from './erasHistoric.js';
+export * from './erasPoints.js';
+export * from './erasPrefs.js';
+export * from './erasRewards.js';
+export * from './erasSlashes.js';
+export * from './keys.js';
+export * from './overview.js';
+export * from './ownExposure.js';
+export * from './ownSlashes.js';
+export * from './query.js';
+export * from './stakerExposure.js';
+export * from './stakerPoints.js';
+export * from './stakerPrefs.js';
+export * from './stakerRewards.js';
+export * from './stakerSlashes.js';
+export * from './stashes.js';
+export * from './validators.js';
+export * from './waitingInfo.js';

package/build/staking/keys.d.ts

@@ -0,0 +1,35 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi } from '../types.js';
+import type { DeriveStakingKeys } from './types.js';
+/**
+ * @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}`)
+ * );
+ * ```
+ */
+export declare const keys: (instanceId: string, api: DeriveApi) => (stashId: string | Uint8Array<ArrayBufferLike>) => Observable<DeriveStakingKeys>;
+/**
+ * @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}`)
+ *   );
+ * });
+ * ```
+ */
+export declare function keysMulti(instanceId: string, api: DeriveApi): (stashIds: (Uint8Array | string)[]) => Observable<DeriveStakingKeys[]>;

package/build/staking/overview.d.ts

@@ -0,0 +1,19 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveStakingOverview } from '../types.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();
+ * ```
+ */
+export declare function overview(instanceId: string, api: DeriveApi): () => Observable<DeriveStakingOverview>;

package/build/staking/ownExposure.d.ts

@@ -0,0 +1,37 @@
+import type { Observable } from 'rxjs';
+import type { u32 } from '@pezkuwi/types';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { AnyNumber } from '@pezkuwi/types-codec/types';
+import type { DeriveApi, DeriveOwnExposure } from '../types.js';
+export declare function _ownExposures(instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean, page: u32 | AnyNumber) => Observable<DeriveOwnExposure[]>;
+/**
+ * @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));
+ * ```
+ */
+export declare const ownExposure: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array<ArrayBufferLike>, era: EraIndex, page?: u32 | AnyNumber) => Observable<DeriveOwnExposure>;
+/**
+ * @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
+ * );
+ * ```
+ */
+export declare const ownExposures: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, withActive?: boolean) => Observable<DeriveOwnExposure[]>;

package/build/staking/ownSlashes.d.ts

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

package/build/staking/query.d.ts

@@ -0,0 +1,31 @@
+import type { Observable } from 'rxjs';
+import type { u32 } from '@pezkuwi/types';
+import type { AnyNumber } from '@pezkuwi/types-codec/types';
+import type { DeriveApi, DeriveStakingQuery, StakingQueryFlags } from '../types.js';
+/**
+ * @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,
+ *   {}
+ * );
+ * ```
+ */
+export declare const query: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array<ArrayBufferLike>, flags: StakingQueryFlags, page?: u32) => Observable<DeriveStakingQuery>;
+/**
+ * @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], {});
+ * ```
+ */
+export declare function queryMulti(instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], flags: StakingQueryFlags, page?: u32 | AnyNumber) => Observable<DeriveStakingQuery[]>;

package/build/staking/stakerExposure.d.ts

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

package/build/staking/stakerPoints.d.ts

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

package/build/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/build/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<ArrayBufferLike>, withActive?: boolean) => 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/build/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/build/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/build/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 { PalletStakingRewardDestination, PalletStakingStakingLedger, PalletStakingValidatorPrefs, SpStakingExposure, SpStakingExposurePage, SpStakingPagedExposureMetadata } 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 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: SpStakingExposure;
+    exposurePaged: Option<SpStakingExposurePage>;
+    era: EraIndex;
+    exposure: SpStakingExposure;
+    exposureMeta: Option<SpStakingPagedExposureMetadata>;
+}
+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 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: PalletStakingValidatorPrefs;
+}
+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: SpStakingExposure;
+    exposurePaged: Option<SpStakingExposurePage>;
+    exposureMeta: Option<SpStakingPagedExposureMetadata>;
+    nominators: AccountId[];
+    rewardDestination: PalletStakingRewardDestination | null;
+    stashId: AccountId;
+    validatorPrefs: PalletStakingValidatorPrefs;
+    claimedRewardsEras: Vec<u32>;
+}
+export interface DeriveStakingQuery extends DeriveStakingStash {
+    accountId: AccountId;
+    stakingLedger: PalletStakingStakingLedger;
+}
+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/build/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/build/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>;

package/build/staking/waitingInfo.d.ts

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