@pezkuwi/api-derive 16.5.5 → 16.5.6

package/src/staking/erasHistoric.ts

@@ -1,47 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { u32 } from '@pezkuwi/types';
-import type { EraIndex } from '@pezkuwi/types/interfaces';
-import type { BN } from '@pezkuwi/util';
-import type { DeriveApi } from '../types.js';
-
-import { combineLatest, map, of } from 'rxjs';
-
-import { BN_ONE, BN_ZERO } from '@pezkuwi/util';
-
-import { memo } from '../util/index.js';
-
-/**
- * @name erasHistoric
- * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
- */
-export function erasHistoric (instanceId: string, api: DeriveApi): (withActive?: boolean) => Observable<EraIndex[]> {
-  return memo(instanceId, (withActive?: boolean): Observable<EraIndex[]> =>
-    combineLatest([
-      api.query.staking.activeEra(),
-      api.consts.staking.historyDepth
-        ? of(api.consts.staking.historyDepth)
-        : api.query.staking['historyDepth']<u32>()
-    ]).pipe(
-      map(([activeEraOpt, historyDepth]): EraIndex[] => {
-        const result: EraIndex[] = [];
-        const max = historyDepth.toNumber();
-        const activeEra: BN = activeEraOpt.unwrapOrDefault().index;
-        let lastEra = activeEra;
-
-        while (lastEra.gte(BN_ZERO) && (result.length < max)) {
-          if ((lastEra !== activeEra) || (withActive === true)) {
-            result.push(api.registry.createType('EraIndex', lastEra));
-          }
-
-          lastEra = lastEra.sub(BN_ONE);
-        }
-
-        // go from oldest to newest
-        return result.reverse();
-      })
-    )
-  );
-}

package/src/staking/erasPoints.ts

@@ -1,67 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { EraIndex } from '@pezkuwi/types/interfaces';
-import type { PalletStakingEraRewardPoints } from '@pezkuwi/types/lookup';
-import type { DeriveApi, DeriveEraPoints, DeriveEraValPoints } from '../types.js';
-
-import { map, of } from 'rxjs';
-
-import { BN_ZERO } from '@pezkuwi/util';
-
-import { memo } from '../util/index.js';
-import { filterCachedEras, getEraMultiCache, setEraMultiCache } from './cache.js';
-import { erasHistoricApply, filterEras } from './util.js';
-
-const CACHE_KEY = 'eraPoints';
-
-function mapValidators ({ individual }: PalletStakingEraRewardPoints): DeriveEraValPoints {
-  return [...individual.entries()]
-    .filter(([, points]) => points.gt(BN_ZERO))
-    .reduce((result: DeriveEraValPoints, [validatorId, points]): DeriveEraValPoints => {
-      result[validatorId.toString()] = points;
-
-      return result;
-    }, {});
-}
-
-function mapPoints (eras: EraIndex[], points: PalletStakingEraRewardPoints[]): DeriveEraPoints[] {
-  return eras.map((era, index): DeriveEraPoints => ({
-    era,
-    eraPoints: points[index].total,
-    validators: mapValidators(points[index])
-  }));
-}
-
-export function _erasPoints (instanceId: string, api: DeriveApi): (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraPoints[]> {
-  return memo(instanceId, (eras: EraIndex[], withActive: boolean): Observable<DeriveEraPoints[]> => {
-    if (!eras.length) {
-      return of([]);
-    }
-
-    const cached = getEraMultiCache<DeriveEraPoints>(CACHE_KEY, eras, withActive);
-    const remaining = filterEras(eras, cached);
-
-    return !remaining.length
-      ? of(cached)
-      : api.query.staking.erasRewardPoints.multi(remaining).pipe(
-        map((p) => filterCachedEras(eras, cached, setEraMultiCache(CACHE_KEY, withActive, mapPoints(remaining, p))))
-      );
-  });
-}
-
-/**
- * @name erasPoints
- * @description Retrieves historical era points with its validators.
- * @param {boolean} withActive? (Optional) Whether to include the active era in the result.
- * @example
- * ```javascript
- * const points = await api.derive.staking.erasPoints(true);
- * console.log(
- *   "Validator points:",
- *   points.map(({ era, eraPoints }) => `Era: ${era}, points ${eraPoints}`)
- * );
- * ```
- */
-export const erasPoints = /*#__PURE__*/ erasHistoricApply('_erasPoints');

package/src/staking/erasPrefs.ts

@@ -1,63 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { StorageKey } from '@pezkuwi/types';
-import type { EraIndex } from '@pezkuwi/types/interfaces';
-import type { PalletStakingValidatorPrefs } from '@pezkuwi/types/lookup';
-import type { DeriveApi, DeriveEraPrefs, DeriveEraValPrefs } from '../types.js';
-
-import { map, of } from 'rxjs';
-
-import { memo } from '../util/index.js';
-import { getEraCache, setEraCache } from './cache.js';
-import { combineEras, erasHistoricApply, singleEra } from './util.js';
-
-const CACHE_KEY = 'eraPrefs';
-
-function mapPrefs (era: EraIndex, all: [StorageKey, PalletStakingValidatorPrefs][]): DeriveEraPrefs {
-  const validators: DeriveEraValPrefs = {};
-
-  all.forEach(([key, prefs]): void => {
-    validators[key.args[1].toString()] = prefs;
-  });
-
-  return { era, validators };
-}
-
-export function _eraPrefs (instanceId: string, api: DeriveApi): (era: EraIndex, withActive: boolean) => Observable<DeriveEraPrefs> {
-  return memo(instanceId, (era: EraIndex, withActive: boolean): Observable<DeriveEraPrefs> => {
-    const [cacheKey, cached] = getEraCache<DeriveEraPrefs>(CACHE_KEY, era, withActive);
-
-    return cached
-      ? of(cached)
-      : api.query.staking.erasValidatorPrefs.entries(era).pipe(
-        map((r) => 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));
- * ```
- */
-export const eraPrefs = /*#__PURE__*/ singleEra('_eraPrefs');
-export const _erasPrefs = /*#__PURE__*/ 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);
- * ```
- */
-export const erasPrefs = /*#__PURE__*/ erasHistoricApply('_erasPrefs');

package/src/staking/erasRewards.ts

@@ -1,52 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { Option } from '@pezkuwi/types';
-import type { Balance, EraIndex } from '@pezkuwi/types/interfaces';
-import type { DeriveApi, DeriveEraRewards } from '../types.js';
-
-import { map, of } from 'rxjs';
-
-import { memo } from '../util/index.js';
-import { filterCachedEras, getEraMultiCache, setEraMultiCache } from './cache.js';
-import { erasHistoricApply, filterEras } from './util.js';
-
-const CACHE_KEY = 'eraRewards';
-
-function mapRewards (eras: EraIndex[], optRewards: Option<Balance>[]): DeriveEraRewards[] {
-  return eras.map((era, index): DeriveEraRewards => ({
-    era,
-    eraReward: optRewards[index].unwrapOrDefault()
-  }));
-}
-
-export function _erasRewards (instanceId: string, api: DeriveApi): (eras: EraIndex[], withActive: boolean) => Observable<DeriveEraRewards[]> {
-  return memo(instanceId, (eras: EraIndex[], withActive: boolean): Observable<DeriveEraRewards[]> => {
-    if (!eras.length) {
-      return of([]);
-    }
-
-    const cached = getEraMultiCache<DeriveEraRewards>(CACHE_KEY, eras, withActive);
-    const remaining = filterEras(eras, cached);
-
-    if (!remaining.length) {
-      return of(cached);
-    }
-
-    return api.query.staking.erasValidatorReward.multi(remaining).pipe(
-      map((r) => filterCachedEras(eras, cached, 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);
- * ```
- */
-export const erasRewards = /*#__PURE__*/ erasHistoricApply('_erasRewards');

package/src/staking/erasSlashes.ts

@@ -1,69 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { Option, StorageKey } from '@pezkuwi/types';
-import type { BalanceOf, EraIndex, Perbill } from '@pezkuwi/types/interfaces';
-import type { ITuple } from '@pezkuwi/types/types';
-import type { DeriveApi, DeriveEraSlashes, DeriveEraValSlash } from '../types.js';
-
-import { combineLatest, map, of } from 'rxjs';
-
-import { memo } from '../util/index.js';
-import { getEraCache, setEraCache } from './cache.js';
-import { combineEras, erasHistoricApply, singleEra } from './util.js';
-
-const CACHE_KEY = 'eraSlashes';
-
-function mapSlashes (era: EraIndex, noms: [StorageKey, Option<BalanceOf>][], vals: [StorageKey, Option<ITuple<[Perbill, BalanceOf]>>][]): DeriveEraSlashes {
-  const nominators: DeriveEraValSlash = {};
-  const validators: DeriveEraValSlash = {};
-
-  noms.forEach(([key, optBalance]): void => {
-    nominators[key.args[1].toString()] = optBalance.unwrap();
-  });
-
-  vals.forEach(([key, optRes]): void => {
-    validators[key.args[1].toString()] = optRes.unwrapOrDefault()[1];
-  });
-
-  return { era, nominators, validators };
-}
-
-export function _eraSlashes (instanceId: string, api: DeriveApi): (era: EraIndex, withActive: boolean) => Observable<DeriveEraSlashes> {
-  return memo(instanceId, (era: EraIndex, withActive: boolean): Observable<DeriveEraSlashes> => {
-    const [cacheKey, cached] = getEraCache<DeriveEraSlashes>(CACHE_KEY, era, withActive);
-
-    return cached
-      ? of(cached)
-      : combineLatest([
-        api.query.staking.nominatorSlashInEra.entries(era),
-        api.query.staking.validatorSlashInEra.entries(era)
-      ]).pipe(
-        map(([n, v]) => 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);
- * ```
- */
-export const eraSlashes = /*#__PURE__*/ singleEra('_eraSlashes');
-export const _erasSlashes = /*#__PURE__*/ 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);
- * ```
- */
-export const erasSlashes = /*#__PURE__*/ erasHistoricApply('_erasSlashes');

package/src/staking/keys.ts

@@ -1,86 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { Option } from '@pezkuwi/types';
-import type { AccountId } from '@pezkuwi/types/interfaces';
-import type { KitchensinkRuntimeSessionKeys } from '@pezkuwi/types/lookup';
-import type { DeriveApi } from '../types.js';
-import type { DeriveStakingKeys } from './types.js';
-
-import { combineLatest, map, of, switchMap } from 'rxjs';
-
-import { firstMemo, memo } from '../util/index.js';
-
-function extractsIds (stashId: Uint8Array | string, queuedKeys: [AccountId, KitchensinkRuntimeSessionKeys | AccountId[]][], nextKeys: Option<KitchensinkRuntimeSessionKeys>): DeriveStakingKeys {
-  const sessionIds = (queuedKeys.find(([currentId]) => currentId.eq(stashId)) || [undefined, [] as AccountId[]])[1];
-  const nextSessionIds = nextKeys.unwrapOr([] as AccountId[]);
-
-  return {
-    nextSessionIds: Array.isArray(nextSessionIds)
-      ? nextSessionIds
-      : [...nextSessionIds.values()] as AccountId[],
-    sessionIds: Array.isArray(sessionIds)
-      ? sessionIds
-      : [...sessionIds.values()] as AccountId[]
-  };
-}
-
-/**
- * @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 const keys = /*#__PURE__*/ firstMemo(
-  (api: DeriveApi, stashId: Uint8Array | string) =>
-    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}`)
- *   );
- * });
- * ```
- */
-export function keysMulti (instanceId: string, api: DeriveApi): (stashIds: (Uint8Array | string)[]) => Observable<DeriveStakingKeys[]> {
-  return memo(instanceId, (stashIds: (Uint8Array | string)[]): Observable<DeriveStakingKeys[]> =>
-    stashIds.length
-      ? api.query.session.queuedKeys().pipe(
-        switchMap((queuedKeys) =>
-          combineLatest([
-            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]))
-              : combineLatest(stashIds.map((s) => api.query.session.nextKeys(s)))
-          ])
-        ),
-        map(([queuedKeys, nextKeys]) =>
-          stashIds.map((stashId, index) =>
-            extractsIds(stashId, queuedKeys, nextKeys[index])
-          )
-        )
-      )
-      : of([])
-  );
-}

package/src/staking/overview.ts

@@ -1,42 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { DeriveApi, DeriveStakingOverview } from '../types.js';
-
-import { combineLatest, map } from 'rxjs';
-
-import { objectSpread } from '@pezkuwi/util';
-
-import { memo } from '../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();
- * ```
- */
-export function overview (instanceId: string, api: DeriveApi): () => Observable<DeriveStakingOverview> {
-  return memo(instanceId, (): Observable<DeriveStakingOverview> =>
-    combineLatest([
-      api.derive.session.indexes(),
-      api.derive.staking.validators()
-    ]).pipe(
-      map(([indexes, { nextElected, validators }]): DeriveStakingOverview =>
-        objectSpread({}, indexes, {
-          nextElected,
-          validators
-        })
-      )
-    ));
-}

package/src/staking/ownExposure.ts

@@ -1,83 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { Option, u32 } from '@pezkuwi/types';
-import type { EraIndex } from '@pezkuwi/types/interfaces';
-import type { SpStakingExposure, SpStakingExposurePage, SpStakingPagedExposureMetadata } from '@pezkuwi/types/lookup';
-import type { AnyNumber } from '@pezkuwi/types-codec/types';
-import type { DeriveApi, DeriveOwnExposure } from '../types.js';
-
-import { combineLatest, map, of } from 'rxjs';
-
-import { firstMemo, memo } from '../util/index.js';
-import { erasHistoricApplyAccount } from './util.js';
-
-export function _ownExposures (instanceId: string, api: DeriveApi): (accountId: Uint8Array | string, eras: EraIndex[], withActive: boolean, page: u32 | AnyNumber) => Observable<DeriveOwnExposure[]> {
-  return memo(instanceId, (accountId: Uint8Array | string, eras: EraIndex[], _withActive: boolean, page: u32 | AnyNumber): Observable<DeriveOwnExposure[]> => {
-    const emptyStakingExposure = api.registry.createType<SpStakingExposure>('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<SpStakingExposurePage>>('Option<Null>');
-    const emptyOptionMeta = api.registry.createType<Option<SpStakingPagedExposureMetadata>>('Option<Null>');
-
-    return eras.length
-      ? combineLatest([
-        // Backwards and forward compat for historical integrity when using `erasHistoricApplyAccount`
-        api.query.staking.erasStakersClipped
-          ? combineLatest(eras.map((e) => api.query.staking.erasStakersClipped(e, accountId)))
-          : of(eras.map((_) => emptyStakingExposure)),
-        api.query.staking.erasStakers
-          ? combineLatest(eras.map((e) => api.query.staking.erasStakers(e, accountId)))
-          : of(eras.map((_) => emptyStakingExposure)),
-        api.query.staking.erasStakersPaged
-          ? combineLatest(eras.map((e) => api.query.staking.erasStakersPaged<Option<SpStakingExposurePage>>(e, accountId, page)))
-          : of(eras.map((_) => emptyOptionPage)),
-        api.query.staking.erasStakersOverview
-          ? combineLatest(eras.map((e) => api.query.staking.erasStakersOverview(e, accountId)))
-          : of(eras.map((_) => emptyOptionMeta))
-      ]).pipe(
-        map(([clp, exp, paged, expMeta]): DeriveOwnExposure[] =>
-          eras.map((era, index) => ({ clipped: clp[index], era, exposure: exp[index], exposureMeta: expMeta[index], exposurePaged: paged[index] }))
-        )
-      )
-      : 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));
- * ```
- */
-export const ownExposure = /*#__PURE__*/ firstMemo(
-  (api: DeriveApi, accountId: Uint8Array | string, era: EraIndex, page?: u32 | AnyNumber) =>
-    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
- * );
- * ```
- */
-export const ownExposures = /*#__PURE__*/ erasHistoricApplyAccount('_ownExposures');

package/src/staking/ownSlashes.ts

@@ -1,68 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { BalanceOf, EraIndex, Perbill } from '@pezkuwi/types/interfaces';
-import type { ITuple } from '@pezkuwi/types/types';
-import type { DeriveApi, DeriveStakerSlashes } from '../types.js';
-
-import { combineLatest, map, of } from 'rxjs';
-
-import { firstMemo, memo } from '../util/index.js';
-import { erasHistoricApplyAccount } from './util.js';
-
-export function _ownSlashes (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[]> =>
-    eras.length
-      ? combineLatest([
-        combineLatest(eras.map((e) => api.query.staking.validatorSlashInEra(e, accountId))),
-        combineLatest(eras.map((e) => api.query.staking.nominatorSlashInEra(e, accountId)))
-      ]).pipe(
-        map(([vals, noms]): DeriveStakerSlashes[] =>
-          eras.map((era, index) => ({
-            era,
-            total: vals[index].isSome
-              ? (vals[index].unwrap() as ITuple<[Perbill, BalanceOf]>)[1]
-              : (noms[index].unwrapOrDefault() as BalanceOf)
-          }))
-        )
-      )
-      : 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}`);
- * ```
- */
-export const ownSlash = /*#__PURE__*/ firstMemo(
-  (api: DeriveApi, accountId: Uint8Array | string, era: EraIndex) =>
-    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);
- * ```
- */
-export const ownSlashes = /*#__PURE__*/ erasHistoricApplyAccount('_ownSlashes');