@pezkuwi/api-derive 16.5.6 → 16.5.8

package/build-tsc/society/members.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveSocietyMember } from '../types.js';
+export declare function _members(instanceId: string, api: DeriveApi): (accountIds: AccountId[]) => Observable<DeriveSocietyMember[]>;
+/**
+ * @name members
+ * @description Get the society members.
+ * @example
+ * ```javascript
+ * const members = await api.derive.society.members();
+ * console.log(members);
+ * ```
+ */
+export declare function members(instanceId: string, api: DeriveApi): () => Observable<DeriveSocietyMember[]>;

package/build-tsc/society/types.d.ts

@@ -0,0 +1,27 @@
+import type { u32 } from '@pezkuwi/types';
+import type { AccountId, Balance, BalanceOf, BlockNumber, StrikeCount } from '@pezkuwi/types/interfaces';
+import type { PezpalletSocietyBid, PezpalletSocietyBidKind, PezpalletSocietyVote, PezpalletSocietyVouchingStatus } from '@pezkuwi/types/lookup';
+export interface DeriveSociety {
+    bids: PezpalletSocietyBid[];
+    defender?: AccountId | undefined;
+    hasDefender: boolean;
+    head?: AccountId | undefined;
+    founder?: AccountId | undefined;
+    maxMembers?: u32 | undefined;
+    pot: BalanceOf;
+}
+export interface DeriveSocietyCandidate {
+    accountId: AccountId;
+    kind: PezpalletSocietyBidKind;
+    value: Balance;
+    isSuspended: boolean;
+}
+export interface DeriveSocietyMember {
+    accountId: AccountId;
+    isDefenderVoter: boolean;
+    isSuspended: boolean;
+    payouts: [BlockNumber, Balance][];
+    strikes: StrikeCount;
+    vote?: PezpalletSocietyVote | undefined;
+    vouching?: PezpalletSocietyVouchingStatus | undefined;
+}

package/build-tsc/staking/account.d.ts

@@ -0,0 +1,31 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveStakingAccount } from '../types.js';
+import type { StakingQueryFlags } from './types.js';
+/**
+ * @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]);
+ * ```
+ */
+export declare function accounts(instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], opts?: StakingQueryFlags) => Observable<DeriveStakingAccount[]>;
+/**
+ * @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);
+ * ```
+ */
+export declare const account: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, opts?: StakingQueryFlags | undefined) => Observable<DeriveStakingAccount>;

package/build-tsc/staking/cache.d.ts

@@ -0,0 +1,12 @@
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+export declare function getEraCache<T>(CACHE_KEY: string, era: EraIndex, withActive?: boolean): [string, T | undefined];
+export declare function getEraMultiCache<T>(CACHE_KEY: string, eras: EraIndex[], withActive?: boolean): T[];
+export declare function setEraCache<T extends {
+    era: EraIndex;
+}>(cacheKey: string, withActive: boolean, value: T): T;
+export declare function setEraMultiCache<T extends {
+    era: EraIndex;
+}>(CACHE_KEY: string, withActive: boolean, values: T[]): T[];
+export declare function filterCachedEras<T extends {
+    era: EraIndex;
+}>(eras: EraIndex[], cached: T[], query: T[]): T[];

package/build-tsc/staking/currentPoints.d.ts

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

package/build-tsc/staking/electedInfo.d.ts

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

package/build-tsc/staking/erasExposure.d.ts

@@ -0,0 +1,30 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraExposurePaged } from '../types.js';
+/**
+ * erasStakersClipped will be deprecated and replaced with erasStakersPaged. Therefore support is given for both
+ * storage queries until erasStakersClipped has been completely out of use.
+ */
+export declare function _eraExposure(instanceId: string, api: DeriveApi): (era: EraIndex, withActive?: boolean) => Observable<DeriveEraExposurePaged>;
+/**
+ * @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);
+ * ```
+ */
+export declare const eraExposure: (instanceId: string, api: DeriveApi) => (era: EraIndex) => Observable<DeriveEraExposurePaged>;
+export declare const _erasExposure: (instanceId: string, api: DeriveApi) => (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraExposurePaged[]>;
+/**
+ * @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);
+ * ```
+ */
+export declare const erasExposure: (instanceId: string, api: DeriveApi) => (withActive?: boolean) => Observable<DeriveEraExposurePaged[]>;

package/build-tsc/staking/erasHistoric.d.ts

@@ -0,0 +1,8 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+/**
+ * @name erasHistoric
+ * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
+ */
+export declare function erasHistoric(instanceId: string, api: DeriveApi): (withActive?: boolean) => Observable<EraIndex[]>;

package/build-tsc/staking/erasPoints.d.ts

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

package/build-tsc/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-tsc/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-tsc/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-tsc/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-tsc/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) => 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-tsc/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-tsc/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, era: EraIndex, page?: u32 | AnyNumber | undefined) => 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-tsc/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, 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-tsc/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, flags: StakingQueryFlags, page?: u32 | undefined) => 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-tsc/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, withActive?: boolean | undefined) => Observable<DeriveStakerExposure[]>;

package/build-tsc/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-tsc/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-tsc/staking/stakerRewards.d.ts

@@ -0,0 +1,49 @@
+import type { Observable } from 'rxjs';
+import type { EraIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveEraPoints, DeriveEraPrefs, DeriveEraRewards, DeriveStakerReward } from '../types.js';
+type ErasResult = [DeriveEraPoints[], DeriveEraPrefs[], DeriveEraRewards[]];
+export declare function _stakerRewardsEras(instanceId: string, api: DeriveApi): (eras: EraIndex[], withActive?: boolean) => Observable<ErasResult>;
+export declare function _stakerRewards(instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive?: boolean) => Observable<DeriveStakerReward[][]>;
+/**
+ * @name stakerRewards
+ * @description Staking rewards history for a given staker.
+ * @param { Uint8Array | string } accountId The stakers AccountId.
+ * @param { boolean } withActive Whether to include the active era.
+ * @example
+ * ```javascript
+ * const rewards = await api.derive.staking.stakerRewards(
+ *   ALICE, //Alice accountId
+ *   false
+ * );
+ * ```
+ */
+export declare const stakerRewards: (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, withActive?: boolean | undefined) => Observable<DeriveStakerReward[]>;
+/**
+ * @name stakerRewardsMultiEras
+ * @description Staking rewards for multiple stakers over specific eras.
+ * @param { Uint8Array | string } accountIds List of stakers identified by their AccountId.
+ * @param { EraIndex[] } eras Eras for which to retrieve the data.
+ * @example
+ * ```javascript
+ * const rewards = await api.derive.staking.stakerRewardsMultiEras(
+ *   [ALICE, BOB, CHARLIER], //accountIds
+ *   [100,101]  //eras
+ * );
+ * ```
+ */
+export declare function stakerRewardsMultiEras(instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], eras: EraIndex[]) => Observable<DeriveStakerReward[][]>;
+/**
+ * @name stakerRewardsMulti
+ * @description Staking rewards for multiple stakers.
+ * @param { Uint8Array | string } accountIds List of stakers identified by their AccountId.
+ * @param { boolean } withActive Whether to include the active era.
+ * @example
+ * ```javascript
+ * const rewards = await api.derive.staking.stakerRewardsMulti(
+ *   [ALICE, BOB, CHARLIER], //accountIds
+ *   true
+ * );
+ * ```
+ */
+export declare function stakerRewardsMulti(instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], withActive?: boolean) => Observable<DeriveStakerReward[][]>;
+export {};

package/build-tsc/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-tsc/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[]>;