@pezkuwi/api-derive 16.5.8 → 16.5.10

package/build-deno/staking/stakerExposure.ts

@@ -1,76 +0,0 @@
-
-import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
-import type { EraIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
-import type { DeriveApi } from '../types.ts';
-import type { DeriveEraValidatorExposurePaged, DeriveStakerExposure } from './types.ts';
-
-import { map, switchMap } from 'https://esm.sh/rxjs@7.8.1';
-
-import { firstMemo, memo } from '../util/index.ts';
-
-export function _stakerExposures (instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive?: boolean) => Observable<DeriveStakerExposure[][]> {
-  return memo(instanceId, (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive = false): Observable<DeriveStakerExposure[][]> => {
-    const stakerIds = accountIds.map((a) => api.registry.createType('AccountId', a).toString());
-
-    return api.derive.staking._erasExposure(eras, withActive).pipe(
-      map((exposures): DeriveStakerExposure[][] =>
-        stakerIds.map((stakerId) =>
-          exposures.map(({ era, nominators: allNominators, validators: allValidators }): DeriveStakerExposure => {
-            const isValidator = !!allValidators[stakerId];
-            const validators: DeriveEraValidatorExposurePaged = {};
-            const nominating = allNominators[stakerId] || [];
-
-            if (isValidator) {
-              validators[stakerId] = allValidators[stakerId];
-            } else if (nominating) {
-              nominating.forEach(({ validatorId }): void => {
-                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
- * );
- * ```
-*/
-export function stakerExposures (instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], withActive?: boolean) => Observable<DeriveStakerExposure[][]> {
-  return memo(instanceId, (accountIds: (Uint8Array | string)[], withActive = false): Observable<DeriveStakerExposure[][]> =>
-    api.derive.staking.erasHistoric(withActive).pipe(
-      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
- * );
- * ```
-*/
-export const stakerExposure = /*#__PURE__*/ firstMemo(
-  (api: DeriveApi, accountId: Uint8Array | string, withActive?: boolean) =>
-    api.derive.staking.stakerExposures([accountId], withActive)
-);

package/build-deno/staking/stakerPoints.ts

@@ -1,44 +0,0 @@
-
-import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
-import type { EraIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
-import type { DeriveApi, DeriveStakerPoints } from '../types.ts';
-
-import { map } from 'https://esm.sh/rxjs@7.8.1';
-
-import { memo } from '../util/index.ts';
-import { erasHistoricApplyAccount } from './util.ts';
-
-export function _stakerPoints (instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerPoints[]> {
-  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean): Observable<DeriveStakerPoints[]> => {
-    const stakerId = api.registry.createType('AccountId', accountId).toString();
-
-    return api.derive.staking._erasPoints(eras, withActive).pipe(
-      map((points): DeriveStakerPoints[] =>
-        points.map(({ era, eraPoints, validators }): DeriveStakerPoints => ({
-          era,
-          eraPoints,
-          points: validators[stakerId] || api.registry.createType('RewardPoint')
-        }))
-      )
-    );
-  });
-}
-
-/**
- * @name stakerPoints
- * @param { Uint8Array | string } accountId The stakers AccountId.
- * @param { boolean } withActive Whether to include the active era.
- * @description Retrieves the era reward points earned by a given staker across all eras.
- * @example
- * ```javascript
- * const points = await api.derive.staking.stakerPoints(
- *   ALICE, //Alice accountId
- *   false
- * );
- * console.log(
- *   'Validator Era Points:',
- *   points.map(({ era, points }) => `Era ${era}: ${points.toString()} points`)
- * );
- * ```
-*/
-export const stakerPoints = /*#__PURE__*/ erasHistoricApplyAccount('_stakerPoints');

package/build-deno/staking/stakerPrefs.ts

@@ -1,43 +0,0 @@
-
-import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
-import type { EraIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
-import type { DeriveApi, DeriveStakerPrefs } from '../types.ts';
-
-import { map } from 'https://esm.sh/rxjs@7.8.1';
-
-import { memo } from '../util/index.ts';
-import { erasHistoricApplyAccount } from './util.ts';
-
-export function _stakerPrefs (instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerPrefs[]> {
-  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], _withActive: boolean): Observable<DeriveStakerPrefs[]> =>
-    api.query.staking.erasValidatorPrefs.multi(eras.map((e) => [e, accountId])).pipe(
-      map((all): DeriveStakerPrefs[] =>
-        all.map((validatorPrefs, index): DeriveStakerPrefs => ({
-          era: eras[index],
-          validatorPrefs
-        }))
-      )
-    )
-  );
-}
-
-/**
- * @name stakerPrefs
- * @param { Uint8Array | string } accountId The stakers AccountId.
- * @param { boolean } withActive Whether to include the active era.
- * @description Retrieves the validator preferences for a given staker across historical eras.
- * @example
- * ```javascript
- * const prefs = await api.derive.staking.stakerPrefs(
- *   ALICE, //Alice accountId
- *   false
- * );
- * console.log(
- *   'Validator Preferences:',
- *   prefs.map(
- *     ({ era, validatorPrefs }) => `Era ${era}: Commission ${validatorPrefs.commission.toString()}`
- *   )
- * );
- * ```
-*/
-export const stakerPrefs = /*#__PURE__*/ erasHistoricApplyAccount('_stakerPrefs');

package/build-deno/staking/stakerRewards.ts

@@ -1,295 +0,0 @@
-
-import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
-import type { u32, Vec } from 'https://deno.land/x/pezkuwi/types/mod.ts';
-import type { AccountId, EraIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
-import type { PezpalletStakingStakingLedger, PezspStakingExposure, PezspStakingExposurePage } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
-import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import type { DeriveApi, DeriveEraPoints, DeriveEraPrefs, DeriveEraRewards, DeriveEraValPoints, DeriveEraValPrefs, DeriveStakerExposure, DeriveStakerReward, DeriveStakerRewardValidator } from '../types.ts';
-import type { DeriveStakingQuery } from './types.ts';
-
-import { combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
-
-import { BN_BILLION, BN_ZERO, objectSpread } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { firstMemo, memo } from '../util/index.ts';
-
-type ErasResult = [DeriveEraPoints[], DeriveEraPrefs[], DeriveEraRewards[]];
-
-function extractCompatRewards (claimedRewardsEras: Vec<u32>, ledger?: PezpalletStakingStakingLedger): u32[] {
-  const l = ledger
-    ? (
-      ledger.legacyClaimedRewards ||
-    (ledger as PezpalletStakingStakingLedger & { claimedRewards: Vec<u32> }).claimedRewards
-    )?.toArray()
-    : [] as unknown as Vec<u32>;
-
-  return (claimedRewardsEras.toArray() || []).concat(l);
-}
-
-function parseRewards (api: DeriveApi, stashId: AccountId, [erasPoints, erasPrefs, erasRewards]: ErasResult, exposures: DeriveStakerExposure[], claimedRewardsEras: Vec<u32>): DeriveStakerReward[] {
-  return exposures.map(({ era, isEmpty, isValidator, nominating, validators: eraValidators }): DeriveStakerReward => {
-    const { eraPoints, validators: allValPoints } = erasPoints.find((p) => p.era.eq(era)) || { eraPoints: BN_ZERO, validators: {} as DeriveEraValPoints };
-    const { eraReward } = erasRewards.find((r) => r.era.eq(era)) || { eraReward: api.registry.createType('Balance') };
-    const { validators: allValPrefs } = erasPrefs.find((p) => p.era.eq(era)) || { validators: {} as DeriveEraValPrefs };
-    const validators: Record<string, DeriveStakerRewardValidator> = {};
-    const stakerId = stashId.toString();
-
-    Object.entries(eraValidators).forEach(([validatorId, exposure]): void => {
-      const valPoints = allValPoints[validatorId] || BN_ZERO;
-      const valComm = allValPrefs[validatorId]?.commission.unwrap() || BN_ZERO;
-      const expTotal = (exposure as PezspStakingExposure).total
-        ? (exposure as PezspStakingExposure).total?.unwrap()
-        : (exposure as PezspStakingExposurePage).pageTotal
-          ? (exposure as PezspStakingExposurePage).pageTotal?.unwrap()
-          : BN_ZERO;
-      let avail = BN_ZERO;
-      let value: BN | undefined;
-
-      if (!(expTotal.isZero() || valPoints.isZero() || eraPoints.isZero())) {
-        avail = eraReward.mul(valPoints).div(eraPoints);
-
-        const valCut = valComm.mul(avail).div(BN_BILLION);
-        let staked: BN;
-
-        if (validatorId === stakerId) {
-          if ((exposure as PezspStakingExposure).own) {
-            staked = (exposure as PezspStakingExposure).own.unwrap();
-          } else {
-            const expAccount = exposure.others.find(({ who }) => who.eq(validatorId));
-
-            staked = expAccount
-              ? expAccount.value.unwrap()
-              : BN_ZERO;
-          }
-        } else {
-          const stakerExp = exposure.others.find(({ who }) => who.eq(stakerId));
-
-          staked = stakerExp
-            ? stakerExp.value.unwrap()
-            : BN_ZERO;
-        }
-
-        value = avail.sub(valCut).imul(staked).div(expTotal).iadd(validatorId === stakerId ? valCut : BN_ZERO);
-      }
-
-      validators[validatorId] = {
-        total: api.registry.createType('Balance', avail),
-        value: api.registry.createType('Balance', value)
-      };
-    });
-
-    return {
-      era,
-      eraReward,
-      // This might not always be accurate as you need validator account information in order to see if the rewards have been claimed.
-      // This is possibly adjusted in `filterRewards` when need be.
-      isClaimed: claimedRewardsEras.some((c) => c.eq(era)),
-      isEmpty,
-      isValidator,
-      nominating,
-      validators
-    };
-  });
-}
-
-function allUniqValidators (rewards: DeriveStakerReward[][]): [string[], string[][]] {
-  return rewards.reduce(([all, perStash]: [string[], string[][]], rewards) => {
-    const uniq: string[] = [];
-
-    perStash.push(uniq);
-    rewards.forEach(({ validators }) =>
-      Object.keys(validators).forEach((validatorId): void => {
-        if (!uniq.includes(validatorId)) {
-          uniq.push(validatorId);
-
-          if (!all.includes(validatorId)) {
-            all.push(validatorId);
-          }
-        }
-      })
-    );
-
-    return [all, perStash];
-  }, [[], []]);
-}
-
-function removeClaimed (validators: string[], queryValidators: DeriveStakingQuery[], reward: DeriveStakerReward, claimedRewardsEras: Vec<u32>): void {
-  const rm: string[] = [];
-
-  Object.keys(reward.validators).forEach((validatorId): void => {
-    const index = validators.indexOf(validatorId);
-
-    if (index !== -1) {
-      const valLedger = queryValidators[index].stakingLedger;
-
-      if (extractCompatRewards(claimedRewardsEras, valLedger).some((e) => reward.era?.eq(e))) {
-        rm.push(validatorId);
-      }
-    }
-  });
-
-  rm.forEach((validatorId): void => {
-    delete reward.validators[validatorId];
-  });
-}
-
-function filterRewards (eras: EraIndex[], valInfo: [string, DeriveStakingQuery][], { claimedRewardsEras, rewards, stakingLedger }: { rewards: DeriveStakerReward[]; stakingLedger: PezpalletStakingStakingLedger, claimedRewardsEras: Vec<u32> }): DeriveStakerReward[] {
-  const filter = eras.filter((e) => !extractCompatRewards(claimedRewardsEras, stakingLedger).some((s) => s?.eq(e)));
-  const validators = valInfo.map(([v]) => v);
-  const queryValidators = valInfo.map(([, q]) => q);
-
-  return rewards
-    .filter(({ isEmpty }) => !isEmpty)
-    .filter((reward): boolean => {
-      if (!filter.some((e) => reward.era.eq(e))) {
-        return false;
-      }
-
-      removeClaimed(validators, queryValidators, reward, claimedRewardsEras);
-
-      return true;
-    })
-    .filter(({ validators }) => Object.keys(validators).length !== 0)
-    .map((reward) => {
-      let isClaimed = reward.isClaimed;
-      const valKeys = Object.keys(reward.validators);
-
-      if (!reward.isClaimed && valKeys.length) {
-        for (const key of valKeys) {
-          const info = queryValidators.find((i) => i.accountId.toString() === key);
-
-          if (info) {
-            isClaimed = info.claimedRewardsEras?.toArray().some((era) => era.eq(reward.era));
-            break;
-          }
-        }
-      }
-
-      return objectSpread({}, reward, {
-        isClaimed,
-        nominators: reward.nominating.filter((n) => reward.validators[n.validatorId])
-      });
-    });
-}
-
-export function _stakerRewardsEras (instanceId: string, api: DeriveApi): (eras: EraIndex[], withActive?: boolean) => Observable<ErasResult> {
-  return memo(instanceId, (eras: EraIndex[], withActive = false): Observable<ErasResult> =>
-    combineLatest([
-      api.derive.staking._erasPoints(eras, withActive),
-      api.derive.staking._erasPrefs(eras, withActive),
-      api.derive.staking._erasRewards(eras, withActive)
-    ])
-  );
-}
-
-export function _stakerRewards (instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive?: boolean) => Observable<DeriveStakerReward[][]> {
-  return memo(instanceId, (accountIds: (Uint8Array | string)[], eras: EraIndex[], withActive = false): Observable<DeriveStakerReward[][]> => {
-    // Ensures that when number or string types are passed in they are sanitized
-    // Ref: https://github.com/pezkuwichain/pezkuwi-api/issues/5910
-    const sanitizedEras: EraIndex[] = eras.map((e) => typeof e === 'number' || typeof e === 'string' ? api.registry.createType('u32', e) : e);
-
-    return combineLatest([
-      api.derive.staking.queryMulti(accountIds, { withClaimedRewardsEras: true, withLedger: true }),
-      api.derive.staking._stakerExposures(accountIds, sanitizedEras, withActive),
-      api.derive.staking._stakerRewardsEras(sanitizedEras, withActive)
-    ]).pipe(
-      switchMap(([queries, exposures, erasResult]): Observable<DeriveStakerReward[][]> => {
-        const allRewards = queries.map(({ claimedRewardsEras, stakingLedger, stashId }, index): DeriveStakerReward[] =>
-          (!stashId || (!stakingLedger && !claimedRewardsEras))
-            ? []
-            : parseRewards(api, stashId, erasResult, exposures[index], claimedRewardsEras)
-        );
-
-        if (withActive) {
-          return of(allRewards);
-        }
-
-        const [allValidators, stashValidators] = allUniqValidators(allRewards);
-
-        return api.derive.staking.queryMulti(allValidators, { withClaimedRewardsEras: true, withLedger: true }).pipe(
-          map((queriedVals): DeriveStakerReward[][] =>
-            queries.map(({ claimedRewardsEras, stakingLedger }, index): DeriveStakerReward[] =>
-              filterRewards(
-                eras,
-                stashValidators[index]
-                  .map((validatorId): [string, DeriveStakingQuery | undefined] => [
-                    validatorId,
-                    queriedVals.find((q) => q.accountId.eq(validatorId))
-                  ])
-                  .filter((v): v is [string, DeriveStakingQuery] => !!v[1]),
-                {
-                  claimedRewardsEras,
-                  rewards: allRewards[index],
-                  stakingLedger
-                }
-              )
-            )
-          )
-        );
-      })
-    );
-  }
-  );
-}
-
-/**
- * @name stakerRewards
- * @description Staking rewards history for a given staker.
- * @param { Uint8Array | string } accountId The stakers AccountId.
- * @param { boolean } withActive Whether to include the active era.
- * @example
- * ```javascript
- * const rewards = await api.derive.staking.stakerRewards(
- *   ALICE, //Alice accountId
- *   false
- * );
- * ```
- */
-export const stakerRewards = /*#__PURE__*/ firstMemo(
-  (api: DeriveApi, accountId: Uint8Array | string, withActive?: boolean) =>
-    api.derive.staking.erasHistoric(withActive).pipe(
-      switchMap((eras) => api.derive.staking._stakerRewards([accountId], eras, withActive))
-    )
-);
-
-/**
- * @name stakerRewardsMultiEras
- * @description Staking rewards for multiple stakers over specific eras.
- * @param { Uint8Array | string } accountIds List of stakers identified by their AccountId.
- * @param { EraIndex[] } eras Eras for which to retrieve the data.
- * @example
- * ```javascript
- * const rewards = await api.derive.staking.stakerRewardsMultiEras(
- *   [ALICE, BOB, CHARLIER], //accountIds
- *   [100,101]  //eras
- * );
- * ```
- */
-export function stakerRewardsMultiEras (instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], eras: EraIndex[]) => Observable<DeriveStakerReward[][]> {
-  return memo(instanceId, (accountIds: (Uint8Array | string)[], eras: EraIndex[]): Observable<DeriveStakerReward[][]> =>
-    accountIds.length && eras.length
-      ? api.derive.staking._stakerRewards(accountIds, eras, false)
-      : of([])
-  );
-}
-
-/**
- * @name stakerRewardsMulti
- * @description Staking rewards for multiple stakers.
- * @param { Uint8Array | string } accountIds List of stakers identified by their AccountId.
- * @param { boolean } withActive Whether to include the active era.
- * @example
- * ```javascript
- * const rewards = await api.derive.staking.stakerRewardsMulti(
- *   [ALICE, BOB, CHARLIER], //accountIds
- *   true
- * );
- * ```
- */
-export function stakerRewardsMulti (instanceId: string, api: DeriveApi): (accountIds: (Uint8Array | string)[], withActive?: boolean) => Observable<DeriveStakerReward[][]> {
-  return memo(instanceId, (accountIds: (Uint8Array | string)[], withActive = false): Observable<DeriveStakerReward[][]> =>
-    api.derive.staking.erasHistoric(withActive).pipe(
-      switchMap((eras) => api.derive.staking.stakerRewardsMultiEras(accountIds, eras))
-    )
-  );
-}

package/build-deno/staking/stakerSlashes.ts

@@ -1,43 +0,0 @@
-
-import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
-import type { EraIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
-import type { DeriveApi, DeriveStakerSlashes } from '../types.ts';
-
-import { map } from 'https://esm.sh/rxjs@7.8.1';
-
-import { memo } from '../util/index.ts';
-import { erasHistoricApplyAccount } from './util.ts';
-
-export function _stakerSlashes (instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean) => Observable<DeriveStakerSlashes[]> {
-  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean): Observable<DeriveStakerSlashes[]> => {
-    const stakerId = api.registry.createType('AccountId', accountId).toString();
-
-    return api.derive.staking._erasSlashes(eras, withActive).pipe(
-      map((slashes): DeriveStakerSlashes[] =>
-        slashes.map(({ era, nominators, validators }): DeriveStakerSlashes => ({
-          era,
-          total: nominators[stakerId] || validators[stakerId] || api.registry.createType('Balance')
-        }))
-      )
-    );
-  });
-}
-
-/**
- * @name stakerSlashes
- * @param { Uint8Array | string } accountId The stakers AccountId.
- * @param { boolean } withActive Whether to include the active era.
- * @description Retrieve the historical slashes (penalties) for a given staker.
- * @example
- * ```javascript
- *  const stakerSlashes = await api.derive.staking.stakerSlashes(
- *   ALICE, //Alice accountId
- *   true
- * );
- * console.log(
- *   'Staker Slashes:',
- *   stakerSlashes.map(({ era, total }) => `Era ${era}: Slashed ${total.toString()}`)
- * );
- * ```
- */
-export const stakerSlashes = /*#__PURE__*/ erasHistoricApplyAccount('_stakerSlashes');

package/build-deno/staking/stashes.ts

@@ -1,53 +0,0 @@
-
-import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
-import type { AccountId } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
-import type { DeriveApi } from '../types.ts';
-
-import { map, startWith, switchMap } from 'https://esm.sh/rxjs@7.8.1';
-
-import { drr, memo } from '../util/index.ts';
-
-function onBondedEvent (api: DeriveApi): Observable<number> {
-  let current = Date.now();
-
-  return api.query.system.events().pipe(
-    map((events): number => {
-      current = events.filter(({ event, phase }): boolean => {
-        try {
-          return phase.isApplyExtrinsic &&
-            event.section === 'staking' &&
-            event.method === 'Bonded';
-        } catch {
-          return false;
-        }
-      })
-        ? Date.now()
-        : current;
-
-      return current;
-    }),
-    startWith(current),
-    drr({ skipTimeout: true })
-  );
-}
-
-/**
- * @name stashes
- * @description Retrieve the list of all validator stashes.
- * @example
- * ```javascript
- * const stashes = await api.derive.staking.stashes();
- * console.log(
- *   "Validator Stashes:",
- *   stashes.map((s) => s.toString())
- * );
- * ```
- */
-export function stashes (instanceId: string, api: DeriveApi): () => Observable<AccountId[]> {
-  return memo(instanceId, (): Observable<AccountId[]> =>
-    onBondedEvent(api).pipe(
-      switchMap(() => api.query.staking.validators.keys()),
-      map((keys) => keys.map(({ args: [v] }) => v).filter((a) => a))
-    )
-  );
-}