@pezkuwi/api-derive 16.5.5 → 16.5.6

package/packageDetect.d.ts

@@ -0,0 +1 @@
+export {};

package/packageDetect.js

@@ -0,0 +1,3 @@
+import { detectPackage } from '@pezkuwi/util';
+import { packageInfo } from './packageInfo.js';
+detectPackage(packageInfo, null, []);

package/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/packageInfo.js

@@ -0,0 +1 @@
+export const packageInfo = { name: '@pezkuwi/api-derive', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '16.5.4' };

package/session/index.d.ts

@@ -0,0 +1,3 @@
+export * from './indexes.js';
+export * from './info.js';
+export * from './progress.js';

package/session/index.js

@@ -0,0 +1,3 @@
+export * from './indexes.js';
+export * from './info.js';
+export * from './progress.js';

package/session/indexes.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveSessionIndexes } from '../types.js';
+/**
+ * @name indexes
+ * @description Retrieves session-related index data, adapting to whether
+ * the chain has staking enabled.
+ * @example
+ * ```javascript
+ * api.derive.session.indexes((indexes) => {
+ *   console.log(`Current session index: ${indexes.currentIndex}`);
+ *   console.log(`Validator count: ${indexes.validatorCount}`);
+ * });
+ * ```
+ */
+export declare function indexes(instanceId: string, api: DeriveApi): () => Observable<DeriveSessionIndexes>;

package/session/indexes.js

@@ -0,0 +1,65 @@
+import { map, of } from 'rxjs';
+import { memo } from '../util/index.js';
+function parse([currentIndex, activeEra, activeEraStart, currentEra, validatorCount]) {
+    return {
+        activeEra,
+        activeEraStart,
+        currentEra,
+        currentIndex,
+        validatorCount
+    };
+}
+function queryStaking(api) {
+    return api.queryMulti([
+        api.query.session.currentIndex,
+        api.query.staking.activeEra,
+        api.query.staking.currentEra,
+        api.query.staking.validatorCount
+    ]).pipe(map(([currentIndex, activeOpt, currentEra, validatorCount]) => {
+        const { index, start } = activeOpt.unwrapOrDefault();
+        return parse([
+            currentIndex,
+            index,
+            start,
+            currentEra.unwrapOrDefault(),
+            validatorCount
+        ]);
+    }));
+}
+function querySession(api) {
+    return api.query.session.currentIndex().pipe(map((currentIndex) => parse([
+        currentIndex,
+        api.registry.createType('EraIndex'),
+        api.registry.createType('Option<Moment>'),
+        api.registry.createType('EraIndex'),
+        api.registry.createType('u32')
+    ])));
+}
+function empty(api) {
+    return of(parse([
+        api.registry.createType('SessionIndex', 1),
+        api.registry.createType('EraIndex'),
+        api.registry.createType('Option<Moment>'),
+        api.registry.createType('EraIndex'),
+        api.registry.createType('u32')
+    ]));
+}
+/**
+ * @name indexes
+ * @description Retrieves session-related index data, adapting to whether
+ * the chain has staking enabled.
+ * @example
+ * ```javascript
+ * api.derive.session.indexes((indexes) => {
+ *   console.log(`Current session index: ${indexes.currentIndex}`);
+ *   console.log(`Validator count: ${indexes.validatorCount}`);
+ * });
+ * ```
+ */
+export function indexes(instanceId, api) {
+    return memo(instanceId, () => api.query.session
+        ? api.query.staking
+            ? queryStaking(api)
+            : querySession(api)
+        : empty(api));
+}

package/session/info.d.ts

@@ -0,0 +1,13 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveSessionInfo } from '../types.js';
+/**
+ * @name info
+ * @description Retrieves all the session and era query and calculates specific values on it as the length of the session and eras.
+ * @example
+ * ```javascript
+ * api.derive.session.info((info) => {
+ *   console.log(`Session info ${JSON.stringify(info)}`);
+ * });
+ * ```
+ */
+export declare function info(instanceId: string, api: DeriveApi): () => Observable<DeriveSessionInfo>;

package/{src/session/info.ts → session/info.js}

@@ -1,15 +1,6 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { DeriveApi, DeriveSessionInfo } from '../types.js';
-
 import { map } from 'rxjs';
-
 import { objectSpread } from '@pezkuwi/util';
-
 import { memo } from '../util/index.js';
-
 /**
  * @name info
  * @description Retrieves all the session and era query and calculates specific values on it as the length of the session and eras.
@@ -20,20 +11,15 @@ import { memo } from '../util/index.js';
  * });
  * ```
  */
-export function info (instanceId: string, api: DeriveApi): () => Observable<DeriveSessionInfo> {
-  return memo(instanceId, (): Observable<DeriveSessionInfo> =>
-    api.derive.session.indexes().pipe(
-      map((indexes) => {
+export function info(instanceId, api) {
+    return memo(instanceId, () => api.derive.session.indexes().pipe(map((indexes) => {
         const sessionLength = api.consts?.babe?.epochDuration || api.registry.createType('u64', 1);
         const sessionsPerEra = api.consts?.staking?.sessionsPerEra || api.registry.createType('SessionIndex', 1);
-
         return objectSpread({
-          eraLength: api.registry.createType('BlockNumber', sessionsPerEra.mul(sessionLength)),
-          isEpoch: !!api.query.babe,
-          sessionLength,
-          sessionsPerEra
+            eraLength: api.registry.createType('BlockNumber', sessionsPerEra.mul(sessionLength)),
+            isEpoch: !!api.query.babe,
+            sessionLength,
+            sessionsPerEra
         }, indexes);
-      })
-    )
-  );
+    })));
 }

package/session/progress.d.ts

@@ -0,0 +1,47 @@
+import type { Observable } from 'rxjs';
+import type { BlockNumber } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveSessionProgress } from '../types.js';
+/**
+ * @name progress
+ * @description Retrieves session information and progress.
+ * @example
+ * ```javascript
+ * api.derive.session.progress((progress) => {
+ *   console.log(`Session progress ${JSON.stringify(progress)}`);
+ * });
+ * ```
+ */
+export declare function progress(instanceId: string, api: DeriveApi): () => Observable<DeriveSessionProgress>;
+/**
+ * @name eraLenght
+ * @description Retrieves the total length of the current era.
+ * @example
+ * ```javascript
+ * api.derive.session.eraLength((length) => {
+ *   console.log(`Current era length: ${length} sessions`);
+ * });
+ * ```
+ */
+export declare const eraLength: (instanceId: string, api: DeriveApi) => () => Observable<BlockNumber>;
+/**
+ * @name eraProgress
+ * @description Retrieves the progress of the current era.
+ * @example
+ * ```javascript
+ * api.derive.session.eraProgress((progress) => {
+ *   console.log(`Current era progress: ${progress} sessions`);
+ * });
+ * ```
+ */
+export declare const eraProgress: (instanceId: string, api: DeriveApi) => () => Observable<BlockNumber>;
+/**
+ * @name sessionProgress
+ * @description Retrieves the progress of the current session.
+ * @example
+ * ```javascript
+ *   api.derive.session.sessionProgress((progress) => {
+ *   console.log(`Current session progress: ${progress} slots`);
+ * });
+ * ```
+ */
+export declare const sessionProgress: (instanceId: string, api: DeriveApi) => () => Observable<BlockNumber>;

package/session/progress.js

@@ -0,0 +1,89 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { objectSpread } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+function withProgressField(field) {
+    return (instanceId, api) => memo(instanceId, () => api.derive.session.progress().pipe(map((info) => info[field])));
+}
+function createDerive(api, info, [currentSlot, epochIndex, epochOrGenesisStartSlot, activeEraStartSessionIndex]) {
+    const epochStartSlot = epochIndex.mul(info.sessionLength).iadd(epochOrGenesisStartSlot);
+    const sessionProgress = currentSlot.sub(epochStartSlot);
+    const eraProgress = info.currentIndex.sub(activeEraStartSessionIndex).imul(info.sessionLength).iadd(sessionProgress);
+    return objectSpread({
+        eraProgress: api.registry.createType('BlockNumber', eraProgress),
+        sessionProgress: api.registry.createType('BlockNumber', sessionProgress)
+    }, info);
+}
+function queryAura(api) {
+    return api.derive.session.info().pipe(map((info) => objectSpread({
+        eraProgress: api.registry.createType('BlockNumber'),
+        sessionProgress: api.registry.createType('BlockNumber')
+    }, info)));
+}
+function queryBabe(api) {
+    return api.derive.session.info().pipe(switchMap((info) => combineLatest([
+        of(info),
+        // we may have no staking, but have babe (permissioned)
+        api.query.staking?.erasStartSessionIndex
+            ? api.queryMulti([
+                api.query.babe.currentSlot,
+                api.query.babe.epochIndex,
+                api.query.babe.genesisSlot,
+                [api.query.staking.erasStartSessionIndex, info.activeEra]
+            ])
+            : api.queryMulti([
+                api.query.babe.currentSlot,
+                api.query.babe.epochIndex,
+                api.query.babe.genesisSlot
+            ])
+    ])), map(([info, [currentSlot, epochIndex, genesisSlot, optStartIndex]]) => [
+        info, [currentSlot, epochIndex, genesisSlot, optStartIndex && optStartIndex.isSome ? optStartIndex.unwrap() : api.registry.createType('SessionIndex', 1)]
+    ]));
+}
+/**
+ * @name progress
+ * @description Retrieves session information and progress.
+ * @example
+ * ```javascript
+ * api.derive.session.progress((progress) => {
+ *   console.log(`Session progress ${JSON.stringify(progress)}`);
+ * });
+ * ```
+ */
+export function progress(instanceId, api) {
+    return memo(instanceId, () => api.query.babe
+        ? queryBabe(api).pipe(map(([info, slots]) => createDerive(api, info, slots)))
+        : queryAura(api));
+}
+/**
+ * @name eraLenght
+ * @description Retrieves the total length of the current era.
+ * @example
+ * ```javascript
+ * api.derive.session.eraLength((length) => {
+ *   console.log(`Current era length: ${length} sessions`);
+ * });
+ * ```
+ */
+export const eraLength = /*#__PURE__*/ withProgressField('eraLength');
+/**
+ * @name eraProgress
+ * @description Retrieves the progress of the current era.
+ * @example
+ * ```javascript
+ * api.derive.session.eraProgress((progress) => {
+ *   console.log(`Current era progress: ${progress} sessions`);
+ * });
+ * ```
+ */
+export const eraProgress = /*#__PURE__*/ withProgressField('eraProgress');
+/**
+ * @name sessionProgress
+ * @description Retrieves the progress of the current session.
+ * @example
+ * ```javascript
+ *   api.derive.session.sessionProgress((progress) => {
+ *   console.log(`Current session progress: ${progress} slots`);
+ * });
+ * ```
+ */
+export const sessionProgress = /*#__PURE__*/ withProgressField('sessionProgress');

package/session/types.d.ts

@@ -0,0 +1,19 @@
+import type { Option, u32, u64 } from '@pezkuwi/types';
+import type { BlockNumber, EraIndex, Moment, SessionIndex } from '@pezkuwi/types/interfaces';
+export interface DeriveSessionIndexes {
+    activeEra: EraIndex;
+    activeEraStart: Option<Moment>;
+    currentEra: EraIndex;
+    currentIndex: SessionIndex;
+    validatorCount: u32;
+}
+export interface DeriveSessionInfo extends DeriveSessionIndexes {
+    eraLength: BlockNumber;
+    isEpoch: boolean;
+    sessionLength: u64;
+    sessionsPerEra: SessionIndex;
+}
+export interface DeriveSessionProgress extends DeriveSessionInfo {
+    eraProgress: BlockNumber;
+    sessionProgress: BlockNumber;
+}

package/session/types.js

@@ -0,0 +1 @@
+export {};

package/society/candidates.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveSocietyCandidate } from '../types.js';
+/**
+ * @name candidate
+ * @description Retrieves the list of candidates for the society module.
+ * @example
+ * ```javascript
+ * const societyCandidates = await api.derive.society.candidates();
+ * console.log(societyCandidates);
+ * ```
+ */
+export declare function candidates(instanceId: string, api: DeriveApi): () => Observable<DeriveSocietyCandidate[]>;

package/society/candidates.js

@@ -0,0 +1,39 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { memo } from '../util/index.js';
+function getPrev(api) {
+    return api.query.society.candidates().pipe(switchMap((candidates) => combineLatest([
+        of(candidates),
+        api.query.society['suspendedCandidates'].multi(candidates.map(({ who }) => who))
+    ])), map(([candidates, suspended]) => candidates.map(({ kind, value, who }, index) => ({
+        accountId: who,
+        isSuspended: suspended[index].isSome,
+        kind,
+        value
+    }))));
+}
+function getCurr(api) {
+    return api.query.society.candidates.entries().pipe(map((entries) => entries
+        .filter(([, opt]) => opt.isSome)
+        .map(([{ args: [accountId] }, opt]) => [accountId, opt.unwrap()])
+        // FIXME We are missing the new fields from the candidate record
+        .map(([accountId, { bid, kind }]) => ({
+        accountId,
+        isSuspended: false,
+        kind,
+        value: bid
+    }))));
+}
+/**
+ * @name candidate
+ * @description Retrieves the list of candidates for the society module.
+ * @example
+ * ```javascript
+ * const societyCandidates = await api.derive.society.candidates();
+ * console.log(societyCandidates);
+ * ```
+ */
+export function candidates(instanceId, api) {
+    return memo(instanceId, () => api.query.society['suspendedCandidates'] && api.query.society.candidates.creator.meta.type.isPlain
+        ? getPrev(api)
+        : getCurr(api));
+}

package/{src/society/index.ts → society/index.d.ts}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export * from './candidates.js';
 export * from './info.js';
 export * from './member.js';

package/society/index.js

@@ -0,0 +1,4 @@
+export * from './candidates.js';
+export * from './info.js';
+export * from './member.js';
+export * from './members.js';

package/society/info.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveSociety } from '../types.js';
+/**
+ * @name info
+ * @description Get the overall info for a society.
+ * @example
+ * ```javascript
+ * const societyInfo = await api.derive.society.candidates();
+ * console.log(societyInfo);
+ * ```
+ */
+export declare function info(instanceId: string, api: DeriveApi): () => Observable<DeriveSociety>;

package/society/info.js

@@ -0,0 +1,33 @@
+import { combineLatest, map, of } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * @name info
+ * @description Get the overall info for a society.
+ * @example
+ * ```javascript
+ * const societyInfo = await api.derive.society.candidates();
+ * console.log(societyInfo);
+ * ```
+ */
+export function info(instanceId, api) {
+    return memo(instanceId, () => combineLatest([
+        api.query.society.bids(),
+        api.query.society['defender']
+            ? api.query.society['defender']()
+            : of(undefined),
+        api.query.society.founder(),
+        api.query.society.head(),
+        api.query.society['maxMembers']
+            ? api.query.society['maxMembers']()
+            : of(undefined),
+        api.query.society.pot()
+    ]).pipe(map(([bids, defender, founder, head, maxMembers, pot]) => ({
+        bids,
+        defender: defender?.unwrapOr(undefined),
+        founder: founder.unwrapOr(undefined),
+        hasDefender: (defender?.isSome && head.isSome && !head.eq(defender)) || false,
+        head: head.unwrapOr(undefined),
+        maxMembers,
+        pot
+    }))));
+}

package/society/member.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';
+/**
+ * @name member
+ * @description Get the member info for a society.
+ * @param { AccountId } accountId
+ * @example
+ * ```javascript
+ * const member = await api.derive.society.member(ALICE);
+ * console.log(member);
+ * ```
+ */
+export declare function member(instanceId: string, api: DeriveApi): (accountId: AccountId) => Observable<DeriveSocietyMember>;

package/society/member.js

@@ -0,0 +1,15 @@
+import { map } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * @name member
+ * @description Get the member info for a society.
+ * @param { AccountId } accountId
+ * @example
+ * ```javascript
+ * const member = await api.derive.society.member(ALICE);
+ * console.log(member);
+ * ```
+ */
+export function member(instanceId, api) {
+    return memo(instanceId, (accountId) => api.derive.society._members([accountId]).pipe(map(([result]) => result)));
+}

package/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/society/members.js

@@ -0,0 +1,66 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { memo } from '../util/index.js';
+function _membersPrev(api, accountIds) {
+    return combineLatest([
+        of(accountIds),
+        api.query.society.payouts.multi(accountIds),
+        api.query.society['strikes'].multi(accountIds),
+        api.query.society.defenderVotes.multi(accountIds),
+        api.query.society.suspendedMembers.multi(accountIds),
+        api.query.society['vouching'].multi(accountIds)
+    ]).pipe(map(([accountIds, payouts, strikes, defenderVotes, suspended, vouching]) => accountIds.map((accountId, index) => ({
+        accountId,
+        isDefenderVoter: defenderVotes[index].isSome,
+        isSuspended: suspended[index].isTrue,
+        payouts: payouts[index],
+        strikes: strikes[index],
+        vote: defenderVotes[index].unwrapOr(undefined),
+        vouching: vouching[index].unwrapOr(undefined)
+    }))));
+}
+function _membersCurr(api, accountIds) {
+    return combineLatest([
+        of(accountIds),
+        api.query.society.members.multi(accountIds),
+        api.query.society.payouts.multi(accountIds),
+        api.query.society.challengeRoundCount().pipe(switchMap((round) => api.query.society.defenderVotes.multi(accountIds.map((accountId) => [round, accountId])))),
+        api.query.society.suspendedMembers.multi(accountIds)
+    ]).pipe(map(([accountIds, members, payouts, defenderVotes, suspendedMembers]) => accountIds
+        .map((accountId, index) => members[index].isSome
+        ? {
+            accountId,
+            isDefenderVoter: defenderVotes[index].isSome,
+            isSuspended: suspendedMembers[index].isSome,
+            member: members[index].unwrap(),
+            payouts: payouts[index].payouts
+        }
+        : null)
+        .filter((m) => !!m)
+        .map(({ accountId, isDefenderVoter, isSuspended, member, payouts }) => ({
+        accountId,
+        isDefenderVoter,
+        isSuspended,
+        payouts,
+        strikes: member.strikes,
+        vouching: member.vouching.unwrapOr(undefined)
+    }))));
+}
+export function _members(instanceId, api) {
+    return memo(instanceId, (accountIds) => api.query.society.members.creator.meta.type.isMap
+        ? _membersCurr(api, accountIds)
+        : _membersPrev(api, accountIds));
+}
+/**
+ * @name members
+ * @description Get the society members.
+ * @example
+ * ```javascript
+ * const members = await api.derive.society.members();
+ * console.log(members);
+ * ```
+ */
+export function members(instanceId, api) {
+    return memo(instanceId, () => api.query.society.members.creator.meta.type.isMap
+        ? api.query.society.members.keys().pipe(switchMap((keys) => api.derive.society._members(keys.map(({ args: [accountId] }) => accountId))))
+        : api.query.society.members().pipe(switchMap((members) => api.derive.society._members(members))));
+}

package/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/society/types.js

@@ -0,0 +1 @@
+export {};

package/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>;