@pezkuwi/api-derive 16.5.5

package/src/democracy/referendumsInfo.ts

@@ -0,0 +1,181 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { Option, Vec } from '@pezkuwi/types';
+import type { AccountId, Hash, ReferendumInfoTo239, Vote } from '@pezkuwi/types/interfaces';
+import type { PalletDemocracyReferendumInfo, PalletDemocracyReferendumStatus, PalletDemocracyVoteVoting } from '@pezkuwi/types/lookup';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi, DeriveBalancesAccount, DeriveReferendum, DeriveReferendumVote, DeriveReferendumVotes } from '../types.js';
+
+import { combineLatest, map, of, switchMap } from 'rxjs';
+
+import { isFunction, objectSpread } from '@pezkuwi/util';
+
+import { memo } from '../util/index.js';
+import { calcVotes, getImageHash, getStatus } from './util.js';
+
+type VotingDelegating = PalletDemocracyVoteVoting['asDelegating'];
+type VotingDirect = PalletDemocracyVoteVoting['asDirect'];
+type VotingDirectVote = VotingDirect['votes'][0];
+
+function votesPrev (api: DeriveApi, referendumId: BN): Observable<DeriveReferendumVote[]> {
+  return api.query.democracy['votersFor']<Vec<AccountId>>(referendumId).pipe(
+    switchMap((votersFor): Observable<[Vec<AccountId>, Vote[], DeriveBalancesAccount[]]> =>
+      combineLatest([
+        of(votersFor),
+        votersFor.length
+          ? api.query.democracy['voteOf'].multi<Vote>(
+            votersFor.map((accountId): [BN | number, AccountId] =>
+              [referendumId, accountId]
+            )
+          )
+          : of([]),
+        api.derive.balances.votingBalances(votersFor)
+      ])
+    ),
+    map(([votersFor, votes, balances]): DeriveReferendumVote[] =>
+      votersFor.map((accountId, index): DeriveReferendumVote => ({
+        accountId,
+        balance: balances[index].votingBalance || api.registry.createType('Balance'),
+        isDelegating: false,
+        vote: votes[index] || api.registry.createType('Vote')
+      }))
+    )
+  );
+}
+
+function extractVotes (mapped: [AccountId, PalletDemocracyVoteVoting][], referendumId: BN): DeriveReferendumVote[] {
+  return mapped
+    .filter(([, voting]) => voting.isDirect)
+    .map(([accountId, voting]): [AccountId, VotingDirectVote[]] => [
+      accountId,
+      voting.asDirect.votes.filter(([idx]) => idx.eq(referendumId))
+    ])
+    .filter(([, directVotes]) => !!directVotes.length)
+    .reduce((result: DeriveReferendumVote[], [accountId, votes]) =>
+      // FIXME We are ignoring split votes
+      votes.reduce((result: DeriveReferendumVote[], [, vote]): DeriveReferendumVote[] => {
+        if (vote.isStandard) {
+          result.push(
+            objectSpread({
+              accountId,
+              isDelegating: false
+            }, vote.asStandard)
+          );
+        }
+
+        return result;
+      }, result), []
+    );
+}
+
+function votesCurr (api: DeriveApi, referendumId: BN): Observable<DeriveReferendumVote[]> {
+  return api.query.democracy.votingOf.entries().pipe(
+    map((allVoting): DeriveReferendumVote[] => {
+      const mapped = allVoting.map(([{ args: [accountId] }, voting]): [AccountId, PalletDemocracyVoteVoting] => [accountId, voting]);
+      const votes = extractVotes(mapped, referendumId);
+      const delegations = mapped
+        .filter(([, voting]) => voting.isDelegating)
+        .map(([accountId, voting]): [AccountId, VotingDelegating] => [accountId, voting.asDelegating]);
+
+      // add delegations
+      delegations.forEach(([accountId, { balance, conviction, target }]): void => {
+        // Are we delegating to a delegator
+        const toDelegator = delegations.find(([accountId]) => accountId.eq(target));
+        const to = votes.find(({ accountId }) => accountId.eq(toDelegator ? toDelegator[0] : target));
+
+        // this delegation has a target
+        if (to) {
+          votes.push({
+            accountId,
+            balance,
+            isDelegating: true,
+            vote: api.registry.createType('Vote', { aye: to.vote.isAye, conviction })
+          });
+        }
+      });
+
+      return votes;
+    })
+  );
+}
+
+export function _referendumVotes (instanceId: string, api: DeriveApi): (referendum: DeriveReferendum) => Observable<DeriveReferendumVotes> {
+  return memo(instanceId, (referendum: DeriveReferendum): Observable<DeriveReferendumVotes> =>
+    combineLatest([
+      api.derive.democracy.sqrtElectorate(),
+      isFunction(api.query.democracy.votingOf)
+        ? votesCurr(api, referendum.index)
+        : votesPrev(api, referendum.index)
+    ]).pipe(
+      map(([sqrtElectorate, votes]) =>
+        calcVotes(sqrtElectorate, referendum, votes)
+      )
+    )
+  );
+}
+
+export function _referendumsVotes (instanceId: string, api: DeriveApi): (referendums: DeriveReferendum[]) => Observable<DeriveReferendumVotes[]> {
+  return memo(instanceId, (referendums: DeriveReferendum[]): Observable<DeriveReferendumVotes[]> =>
+    referendums.length
+      ? combineLatest(
+        referendums.map((referendum): Observable<DeriveReferendumVotes> =>
+          api.derive.democracy._referendumVotes(referendum)
+        )
+      )
+      : of([])
+  );
+}
+
+export function _referendumInfo (instanceId: string, api: DeriveApi): (index: BN, info: Option<PalletDemocracyReferendumInfo | ReferendumInfoTo239>) => Observable<DeriveReferendum | null> {
+  return memo(instanceId, (index: BN, info: Option<PalletDemocracyReferendumInfo | ReferendumInfoTo239>): Observable<DeriveReferendum | null> => {
+    const status = getStatus(info);
+
+    return status
+      ? api.derive.democracy.preimage(
+        (status as PalletDemocracyReferendumStatus).proposal ||
+        (status as unknown as { proposalHash: Hash }).proposalHash
+      ).pipe(
+        map((image): DeriveReferendum => ({
+          image,
+          imageHash: getImageHash(status),
+          index: api.registry.createType('ReferendumIndex', index),
+          status
+        }))
+      )
+      : of(null);
+  });
+}
+
+/**
+ * @name referendumsInfo
+ * @description Retrieves information about multiple referendums by their IDs.
+ * @param {BN[]} ids An array of referendum IDs to query.
+ * @example
+ * ```javascript
+ * import { BN } from "@pezkuwi/util";
+ *
+ * const referendumIds = [new BN(1)];
+ * const referendums = await api.derive.democracy.referendumsInfo(referendumIds);
+ * console.log("Referendums Info:", referendums);
+ * ```
+ */
+export function referendumsInfo (instanceId: string, api: DeriveApi): (ids: BN[]) => Observable<DeriveReferendum[]> {
+  return memo(instanceId, (ids: BN[]): Observable<DeriveReferendum[]> =>
+    ids.length
+      ? api.query.democracy.referendumInfoOf.multi(ids).pipe(
+        switchMap((infos): Observable<(DeriveReferendum | null)[]> =>
+          combineLatest(
+            ids.map((id, index): Observable<DeriveReferendum | null> =>
+              api.derive.democracy._referendumInfo(id, infos[index])
+            )
+          )
+        ),
+        map((infos) =>
+          infos.filter((r): r is DeriveReferendum => !!r)
+        )
+      )
+      : of([])
+  );
+}

package/src/democracy/sqrtElectorate.ts

@@ -0,0 +1,29 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi } from '../types.js';
+
+import { map } from 'rxjs';
+
+import { bnSqrt } from '@pezkuwi/util';
+
+import { memo } from '../util/index.js';
+
+/**
+ * @name sqrtElectorate
+ * @description Computes the square root of the total token issuance in the network.
+ * @example
+ * ```javascript
+ * let sqrtElectorate = await api.derive.democracy.sqrtElectorate();
+ * console.log("Square root of token issuance:", sqrtElectorate);
+ * ```
+ */
+export function sqrtElectorate (instanceId: string, api: DeriveApi): () => Observable<BN> {
+  return memo(instanceId, (): Observable<BN> =>
+    api.query.balances.totalIssuance().pipe(
+      map(bnSqrt)
+    )
+  );
+}

package/src/democracy/types.ts

@@ -0,0 +1,84 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Vec } from '@pezkuwi/types';
+import type { AccountId, Balance, Call, Hash, PropIndex, ReferendumIndex, ReferendumInfoTo239, Vote } from '@pezkuwi/types/interfaces';
+import type { PalletDemocracyReferendumStatus, PalletDemocracyVoteThreshold } from '@pezkuwi/types/lookup';
+import type { BN } from '@pezkuwi/util';
+import type { HexString } from '@pezkuwi/util/types';
+
+export interface AtBlock {
+  at: BN;
+}
+
+export interface DeriveDemocracyLock {
+  balance: Balance;
+  isDelegated: boolean;
+  isFinished: boolean;
+  referendumEnd: BN;
+  referendumId: ReferendumIndex;
+  unlockAt: BN;
+  vote: Vote;
+}
+
+export interface DeriveProposalImage extends AtBlock {
+  balance: Balance;
+  proposal?: Call | undefined;
+  proposalHash?: HexString;
+  proposalLen?: number;
+  proposer: AccountId;
+}
+
+export interface DeriveDispatch extends AtBlock {
+  index: ReferendumIndex;
+  imageHash: HexString;
+  image?: DeriveProposalImage | undefined;
+}
+
+export interface DeriveProposal {
+  balance?: Balance;
+  index: PropIndex;
+  image?: DeriveProposalImage | undefined;
+  imageHash: Hash;
+  proposer: AccountId;
+  seconds: Vec<AccountId>;
+}
+
+export interface DeriveProposalExternal {
+  image?: DeriveProposalImage | undefined;
+  imageHash: HexString;
+  threshold: PalletDemocracyVoteThreshold;
+}
+
+export interface DeriveReferendum {
+  index: ReferendumIndex;
+  image?: DeriveProposalImage | undefined;
+  imageHash: HexString;
+  status: PalletDemocracyReferendumStatus | ReferendumInfoTo239;
+}
+
+export interface DeriveReferendumVote {
+  accountId: AccountId;
+  balance: Balance;
+  isDelegating: boolean;
+  vote: Vote;
+}
+
+export interface DeriveReferendumVoteState {
+  allAye: DeriveReferendumVote[];
+  allNay: DeriveReferendumVote[];
+  voteCount: number;
+  voteCountAye: number;
+  voteCountNay: number;
+  votedAye: BN;
+  votedNay: BN;
+  votedTotal: BN;
+}
+
+export interface DeriveReferendumVotes extends DeriveReferendumVoteState {
+  isPassing: boolean;
+  votes: DeriveReferendumVote[];
+}
+
+export interface DeriveReferendumExt extends DeriveReferendum, DeriveReferendumVotes {
+}

package/src/democracy/util.ts

@@ -0,0 +1,166 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Hash, ReferendumInfoTo239, Tally } from '@pezkuwi/types/interfaces';
+import type { FrameSupportPreimagesBounded, PalletDemocracyReferendumInfo, PalletDemocracyReferendumStatus, PalletDemocracyVoteThreshold } from '@pezkuwi/types/lookup';
+import type { Option } from '@pezkuwi/types-codec';
+import type { HexString } from '@pezkuwi/util/types';
+import type { DeriveReferendum, DeriveReferendumVote, DeriveReferendumVotes, DeriveReferendumVoteState } from '../types.js';
+
+import { BN, bnSqrt, isHex, isString, isU8a, objectSpread, stringToHex, u8aToHex } from '@pezkuwi/util';
+
+interface ApproxState {
+  votedAye: BN;
+  votedNay: BN;
+  votedTotal: BN;
+}
+
+function isOldInfo (info: PalletDemocracyReferendumInfo | ReferendumInfoTo239): info is ReferendumInfoTo239 {
+  return !!(info as ReferendumInfoTo239).proposalHash;
+}
+
+function isCurrentStatus (status: PalletDemocracyReferendumStatus | ReferendumInfoTo239): status is PalletDemocracyReferendumStatus {
+  return !!(status as PalletDemocracyReferendumStatus).tally;
+}
+
+export function compareRationals (n1: BN, d1: BN, n2: BN, d2: BN): boolean {
+  while (true) {
+    const q1 = n1.div(d1);
+    const q2 = n2.div(d2);
+
+    if (q1.lt(q2)) {
+      return true;
+    } else if (q2.lt(q1)) {
+      return false;
+    }
+
+    const r1 = n1.mod(d1);
+    const r2 = n2.mod(d2);
+
+    if (r2.isZero()) {
+      return false;
+    } else if (r1.isZero()) {
+      return true;
+    }
+
+    n1 = d2;
+    n2 = d1;
+    d1 = r2;
+    d2 = r1;
+  }
+}
+
+function calcPassingOther (threshold: PalletDemocracyVoteThreshold, sqrtElectorate: BN, { votedAye, votedNay, votedTotal }: ApproxState): boolean {
+  const sqrtVoters = bnSqrt(votedTotal);
+
+  return sqrtVoters.isZero()
+    ? false
+    : threshold.isSuperMajorityApprove
+      ? compareRationals(votedNay, sqrtVoters, votedAye, sqrtElectorate)
+      : compareRationals(votedNay, sqrtElectorate, votedAye, sqrtVoters);
+}
+
+export function calcPassing (threshold: PalletDemocracyVoteThreshold, sqrtElectorate: BN, state: ApproxState): boolean {
+  return threshold.isSimpleMajority
+    ? state.votedAye.gt(state.votedNay)
+    : calcPassingOther(threshold, sqrtElectorate, state);
+}
+
+function calcVotesPrev (votesFor: DeriveReferendumVote[]): DeriveReferendumVoteState {
+  return votesFor.reduce((state: DeriveReferendumVoteState, derived): DeriveReferendumVoteState => {
+    const { balance, vote } = derived;
+    const isDefault = vote.conviction.index === 0;
+    const counted = balance
+      .muln(isDefault ? 1 : vote.conviction.index)
+      .divn(isDefault ? 10 : 1);
+
+    if (vote.isAye) {
+      state.allAye.push(derived);
+      state.voteCountAye++;
+      state.votedAye.iadd(counted);
+    } else {
+      state.allNay.push(derived);
+      state.voteCountNay++;
+      state.votedNay.iadd(counted);
+    }
+
+    state.voteCount++;
+    state.votedTotal.iadd(counted);
+
+    return state;
+  }, { allAye: [], allNay: [], voteCount: 0, voteCountAye: 0, voteCountNay: 0, votedAye: new BN(0), votedNay: new BN(0), votedTotal: new BN(0) });
+}
+
+function calcVotesCurrent (tally: Tally, votes: DeriveReferendumVote[]): DeriveReferendumVoteState {
+  const allAye: DeriveReferendumVote[] = [];
+  const allNay: DeriveReferendumVote[] = [];
+
+  votes.forEach((derived): void => {
+    if (derived.vote.isAye) {
+      allAye.push(derived);
+    } else {
+      allNay.push(derived);
+    }
+  });
+
+  return {
+    allAye,
+    allNay,
+    voteCount: allAye.length + allNay.length,
+    voteCountAye: allAye.length,
+    voteCountNay: allNay.length,
+    votedAye: tally.ayes,
+    votedNay: tally.nays,
+    votedTotal: tally.turnout
+  };
+}
+
+export function calcVotes (sqrtElectorate: BN, referendum: DeriveReferendum, votes: DeriveReferendumVote[]): DeriveReferendumVotes {
+  const state = isCurrentStatus(referendum.status)
+    ? calcVotesCurrent(referendum.status.tally, votes)
+    : calcVotesPrev(votes);
+
+  return objectSpread({}, state, {
+    isPassing: calcPassing(referendum.status.threshold, sqrtElectorate, state),
+    votes
+  });
+}
+
+export function getStatus (info: Option<PalletDemocracyReferendumInfo | ReferendumInfoTo239>): PalletDemocracyReferendumStatus | ReferendumInfoTo239 | null {
+  if (info.isNone) {
+    return null;
+  }
+
+  const unwrapped = info.unwrap();
+
+  return isOldInfo(unwrapped)
+    ? unwrapped
+    : unwrapped.isOngoing
+      ? unwrapped.asOngoing
+      // done, we don't include it here... only currently active
+      : null;
+}
+
+export function getImageHashBounded (hash: Uint8Array | string | Hash | FrameSupportPreimagesBounded): HexString {
+  return (hash as FrameSupportPreimagesBounded).isLegacy
+    ? (hash as FrameSupportPreimagesBounded).asLegacy.hash_.toHex()
+    : (hash as FrameSupportPreimagesBounded).isLookup
+      ? (hash as FrameSupportPreimagesBounded).asLookup.hash_.toHex()
+      // for inline, use the actual Bytes hash
+      : (hash as FrameSupportPreimagesBounded).isInline
+        ? (hash as FrameSupportPreimagesBounded).asInline.hash.toHex()
+        : isString(hash)
+          ? isHex(hash)
+            ? hash
+            : stringToHex(hash)
+          : isU8a(hash)
+            ? u8aToHex(hash)
+            : hash.toHex();
+}
+
+export function getImageHash (status: PalletDemocracyReferendumStatus | ReferendumInfoTo239): HexString {
+  return getImageHashBounded(
+    (status as PalletDemocracyReferendumStatus).proposal ||
+    (status as ReferendumInfoTo239).proposalHash
+  );
+}

package/src/derive.ts

@@ -0,0 +1,41 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyFunction } from '@pezkuwi/types/types';
+
+import * as accounts from './accounts/index.js';
+import * as alliance from './alliance/index.js';
+import * as bagsList from './bagsList/index.js';
+import * as balances from './balances/index.js';
+import * as bounties from './bounties/index.js';
+import * as chain from './chain/index.js';
+import * as contracts from './contracts/index.js';
+import * as council from './council/index.js';
+import * as crowdloan from './crowdloan/index.js';
+import * as democracy from './democracy/index.js';
+import * as elections from './elections/index.js';
+import * as imOnline from './imOnline/index.js';
+import * as membership from './membership/index.js';
+import * as parachains from './parachains/index.js';
+import * as session from './session/index.js';
+import * as society from './society/index.js';
+import * as staking from './staking/index.js';
+import * as technicalCommittee from './technicalCommittee/index.js';
+import * as treasury from './treasury/index.js';
+import * as tx from './tx/index.js';
+
+export const derive = { accounts, alliance, bagsList, balances, bounties, chain, contracts, council, crowdloan, democracy, elections, imOnline, membership, parachains, session, society, staking, technicalCommittee, treasury, tx };
+
+type DeriveSection<Section> = {
+  [M in keyof Section]: Section[M] extends AnyFunction
+    ? ReturnType<Section[M]> // ReturnType<Section[Method]> will be the inner function, i.e. without (api) argument
+    : never;
+};
+type DeriveAllSections<AllSections> = {
+  [S in keyof AllSections]: DeriveSection<AllSections[S]>
+};
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ExactDerive extends DeriveAllSections<typeof derive> {
+  // keep empty, allows for augmentation
+}

package/src/elections/index.ts

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

package/src/elections/info.ts

@@ -0,0 +1,126 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { u32, Vec } from '@pezkuwi/types';
+import type { AccountId32, Balance, BlockNumber } from '@pezkuwi/types/interfaces';
+import type { PalletElectionsPhragmenSeatHolder } from '@pezkuwi/types/lookup';
+import type { ITuple } from '@pezkuwi/types/types';
+import type { DeriveApi } from '../types.js';
+import type { DeriveElectionsInfo } from './types.js';
+
+import { combineLatest, map, of } from 'rxjs';
+
+import { objectSpread } from '@pezkuwi/util';
+
+import { memo } from '../util/index.js';
+
+// SeatHolder is current tuple is 2.x-era Substrate
+type Member = PalletElectionsPhragmenSeatHolder | ITuple<[AccountId32, Balance]>;
+
+type Candidate = AccountId32 | ITuple<[AccountId32, Balance]>;
+
+function isSeatHolder (value: Member): value is PalletElectionsPhragmenSeatHolder {
+  return !Array.isArray(value);
+}
+
+function isCandidateTuple (value: Candidate): value is ITuple<[AccountId32, Balance]> {
+  return Array.isArray(value);
+}
+
+function getAccountTuple (value: Member): [AccountId32, Balance] {
+  return isSeatHolder(value)
+    ? [value.who, value.stake]
+    : value;
+}
+
+function getCandidate (value: Candidate): AccountId32 {
+  return isCandidateTuple(value)
+    ? value[0]
+    : value;
+}
+
+function sortAccounts ([, balanceA]: [AccountId32, Balance], [, balanceB]: [AccountId32, Balance]): number {
+  return balanceB.cmp(balanceA);
+}
+
+function getConstants (api: DeriveApi, elections: string | null): Partial<DeriveElectionsInfo> {
+  return elections
+    ? {
+      candidacyBond: api.consts[elections as 'elections'].candidacyBond as Balance,
+      desiredRunnersUp: api.consts[elections as 'elections'].desiredRunnersUp as u32,
+      desiredSeats: api.consts[elections as 'elections'].desiredMembers as u32,
+      termDuration: api.consts[elections as 'elections'].termDuration as BlockNumber,
+      votingBond: api.consts[elections as 'elections']['votingBond'] as Balance,
+      votingBondBase: api.consts[elections as 'elections'].votingBondBase as Balance,
+      votingBondFactor: api.consts[elections as 'elections'].votingBondFactor as Balance
+    }
+    : {};
+}
+
+function getModules (api: DeriveApi): [string, string | null] {
+  const [council] = api.registry.getModuleInstances(api.runtimeVersion.specName, 'council') || ['council'];
+  const elections = api.query['phragmenElection']
+    ? 'phragmenElection'
+    : api.query['electionsPhragmen']
+      ? 'electionsPhragmen'
+      : api.query.elections
+        ? 'elections'
+        : null;
+  // In some cases council here can refer to `generalCouncil` depending on what the chain specific override is.
+  // Therefore, we check to see if it exists in the query field. If it does not we default to `council`.
+  const resolvedCouncil = api.query[council] ? council : 'council';
+
+  return [resolvedCouncil, elections];
+}
+
+function queryAll (api: DeriveApi, council: string, elections: string): Observable<[AccountId32[], Candidate[], Member[], Member[]]> {
+  return api.queryMulti<[Vec<AccountId32>, Vec<Candidate>, Vec<Member>, Vec<Member>]>([
+    api.query[council as 'council'].members,
+    api.query[elections as 'elections'].candidates,
+    api.query[elections as 'elections'].members,
+    api.query[elections as 'elections'].runnersUp
+  ]);
+}
+
+function queryCouncil (api: DeriveApi, council: string): Observable<[AccountId32[], Candidate[], Member[], Member[]]> {
+  return combineLatest([
+    api.query[council as 'council'].members(),
+    of<Candidate[]>([]),
+    of<Member[]>([]),
+    of<Member[]>([])
+  ]);
+}
+
+/**
+ * @name info
+ * @description An object containing the combined results of the storage queries for all relevant election module properties.
+ * @example
+ * ```javascript
+ * api.derive.elections.info(({ members, candidates }) => {
+ *   console.log(`There are currently ${members.length} council members and ${candidates.length} prospective council candidates.`);
+ * });
+ * ```
+ */
+export function info (instanceId: string, api: DeriveApi): () => Observable<DeriveElectionsInfo> {
+  return memo(instanceId, (): Observable<DeriveElectionsInfo> => {
+    const [council, elections] = getModules(api);
+
+    return (
+      elections
+        ? queryAll(api, council, elections)
+        : queryCouncil(api, council)
+    ).pipe(
+      map(([councilMembers, candidates, members, runnersUp]): DeriveElectionsInfo =>
+        objectSpread({}, getConstants(api, elections), {
+          candidateCount: api.registry.createType('u32', candidates.length),
+          candidates: candidates.map(getCandidate),
+          members: members.length
+            ? members.map(getAccountTuple).sort(sortAccounts)
+            : councilMembers.map((a): [AccountId32, Balance] => [a, api.registry.createType('Balance')]),
+          runnersUp: runnersUp.map(getAccountTuple).sort(sortAccounts)
+        })
+      )
+    );
+  });
+}

package/src/elections/types.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { u32 } from '@pezkuwi/types';
+import type { AccountId, Balance, BlockNumber, SetIndex, VoteIndex } from '@pezkuwi/types/interfaces';
+
+export interface DeriveElectionsInfo {
+  candidates: AccountId[];
+  candidateCount: u32;
+  candidacyBond?: Balance;
+  desiredRunnersUp?: u32;
+  desiredSeats?: u32;
+  members: [AccountId, Balance][];
+  nextVoterSet?: SetIndex;
+  runnersUp: [AccountId, Balance][];
+  termDuration?: BlockNumber;
+  voteCount?: VoteIndex;
+  voterCount?: SetIndex;
+  votingBond?: Balance;
+  votingBondBase?: Balance;
+  votingBondFactor?: Balance;
+}

package/src/imOnline/index.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './receivedHeartbeats.js';