@pezkuwi/api-derive 16.5.5 → 16.5.6

package/src/democracy/dispatchQueue.ts

@@ -1,158 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { Bytes, Option, u8, u32, Vec } from '@pezkuwi/types';
-import type { BlockNumber, Call, Hash, ReferendumIndex, Scheduled } from '@pezkuwi/types/interfaces';
-import type { FrameSupportPreimagesBounded, PalletSchedulerScheduled } from '@pezkuwi/types/lookup';
-import type { Codec, ITuple } from '@pezkuwi/types/types';
-import type { HexString } from '@pezkuwi/util/types';
-import type { DeriveApi, DeriveDispatch, DeriveProposalImage } from '../types.js';
-
-import { catchError, combineLatest, map, of, switchMap } from 'rxjs';
-
-import { Enum } from '@pezkuwi/types';
-import { isFunction, objectSpread, stringToHex } from '@pezkuwi/util';
-
-import { memo } from '../util/index.js';
-import { getImageHashBounded } from './util.js';
-
-const DEMOCRACY_ID = stringToHex('democrac');
-
-// included here for backwards compat
-interface PalletSchedulerScheduledV3 extends Codec {
-  maybeId: Option<Bytes>;
-  priority: u8;
-  call: FrameSupportScheduleMaybeHashed;
-  maybePeriodic: Option<ITuple<[u32, u32]>>;
-  origin: Codec;
-}
-
-// included here for backwards compat
-interface FrameSupportScheduleMaybeHashed extends Codec {
-  isHash: boolean;
-  isValue: boolean;
-  asValue: Call;
-  asHash: Hash;
-}
-
-interface SchedulerInfo {
-  at: BlockNumber;
-  imageHash: HexString;
-  index: ReferendumIndex;
-}
-
-function isMaybeHashedOrBounded (call: FrameSupportPreimagesBounded | FrameSupportScheduleMaybeHashed | Call): call is FrameSupportScheduleMaybeHashed | FrameSupportPreimagesBounded {
-  // check for enum
-  return call instanceof Enum;
-}
-
-function isBounded (call: FrameSupportPreimagesBounded | FrameSupportScheduleMaybeHashed): call is FrameSupportPreimagesBounded {
-  // check for type
-  return (call as FrameSupportPreimagesBounded).isInline || (call as FrameSupportPreimagesBounded).isLegacy || (call as FrameSupportPreimagesBounded).isLookup;
-}
-
-function queryQueue (api: DeriveApi): Observable<DeriveDispatch[]> {
-  return api.query.democracy['dispatchQueue']<Vec<ITuple<[BlockNumber, Hash, ReferendumIndex]>>>().pipe(
-    switchMap((dispatches) =>
-      combineLatest([
-        of(dispatches),
-        api.derive.democracy.preimages(
-          dispatches.map(([, hash]) => hash))
-      ])
-    ),
-    map(([dispatches, images]) =>
-      dispatches.map(([at, imageHash, index], dispatchIndex): DeriveDispatch => ({
-        at,
-        image: images[dispatchIndex],
-        imageHash: getImageHashBounded(imageHash),
-        index
-      }))
-    )
-  );
-}
-
-function schedulerEntries (api: DeriveApi): Observable<[BlockNumber[], Option<PalletSchedulerScheduled | PalletSchedulerScheduledV3 | Scheduled>[][]]> {
-  // We don't get entries, but rather we get the keys (triggered via finished referendums) and
-  // the subscribe to those keys - this means we pickup when the schedulers actually executes
-  // at a block, the entry for that block will become empty
-  return api.derive.democracy.referendumsFinished().pipe(
-    switchMap(() =>
-      api.query.scheduler.agenda.keys()
-    ),
-    switchMap((keys) => {
-      const blockNumbers = keys.map(({ args: [blockNumber] }) => blockNumber);
-
-      return blockNumbers.length
-        ? combineLatest([
-          of(blockNumbers),
-          // this should simply be api.query.scheduler.agenda.multi,
-          // however we have had cases on Darwinia where the indices have moved around after an
-          // upgrade, which results in invalid on-chain data
-          api.query.scheduler.agenda.multi(blockNumbers).pipe(
-            catchError(() => of(blockNumbers.map(() => [])))
-          )
-        ])
-        : of<[BlockNumber[], Option<PalletSchedulerScheduledV3 | Scheduled>[][]]>([[], []]);
-    })
-  );
-}
-
-function queryScheduler (api: DeriveApi): Observable<DeriveDispatch[]> {
-  return schedulerEntries(api).pipe(
-    switchMap(([blockNumbers, agendas]): Observable<[SchedulerInfo[], (DeriveProposalImage | undefined)[]]> => {
-      const result: SchedulerInfo[] = [];
-
-      blockNumbers.forEach((at, index): void => {
-        (agendas[index] || []).filter((o) => o.isSome).forEach((o): void => {
-          const scheduled = o.unwrap();
-
-          if (scheduled.maybeId.isSome) {
-            const id = scheduled.maybeId.unwrap().toHex();
-
-            if (id.startsWith(DEMOCRACY_ID)) {
-              const imageHash = isMaybeHashedOrBounded(scheduled.call)
-                ? isBounded(scheduled.call)
-                  ? getImageHashBounded(scheduled.call)
-                  : scheduled.call.isHash
-                    ? scheduled.call.asHash.toHex()
-                    : scheduled.call.asValue.args[0].toHex()
-                : scheduled.call.args[0].toHex();
-
-              result.push({ at, imageHash, index: api.registry.createType('(u64, ReferendumIndex)', id)[1] });
-            }
-          }
-        });
-      });
-
-      return combineLatest([
-        of(result),
-        result.length
-          ? api.derive.democracy.preimages(result.map(({ imageHash }) => imageHash))
-          : of([])
-      ]);
-    }),
-    map(([infos, images]): DeriveDispatch[] =>
-      infos.map((info, index) => objectSpread({ image: images[index] }, info))
-    )
-  );
-}
-
-/**
- * @name dispatchQueue
- * @description Retrieves the list of scheduled or pending dispatches in the governance system.
- * @example
- * ```javascript
- * const queue = await api.derive.democracy.dispatchQueue();
- * console.log("Dispatch Queue:", queue);
- * ```
- */
-export function dispatchQueue (instanceId: string, api: DeriveApi): () => Observable<DeriveDispatch[]> {
-  return memo(instanceId, (): Observable<DeriveDispatch[]> =>
-    isFunction(api.query.scheduler?.agenda)
-      ? queryScheduler(api)
-      : api.query.democracy['dispatchQueue']
-        ? queryQueue(api)
-        : of([])
-  );
-}

package/src/democracy/locks.ts

@@ -1,114 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { AccountId, ReferendumInfoTo239, Vote } from '@pezkuwi/types/interfaces';
-import type { PalletDemocracyReferendumInfo, PalletDemocracyVoteVoting } from '@pezkuwi/types/lookup';
-import type { BN } from '@pezkuwi/util';
-import type { DeriveApi, DeriveDemocracyLock } from '../types.js';
-
-import { map, of, switchMap } from 'rxjs';
-
-import { BN_ZERO, isUndefined } from '@pezkuwi/util';
-
-import { memo } from '../util/index.js';
-
-type ReferendumInfoFinished = PalletDemocracyReferendumInfo['asFinished'];
-type VotingDelegating = PalletDemocracyVoteVoting['asDelegating'];
-type VotingDirect = PalletDemocracyVoteVoting['asDirect'];
-type VotingDirectVote = VotingDirect['votes'][0];
-
-const LOCKUPS = [0, 1, 2, 4, 8, 16, 32];
-
-function parseEnd (api: DeriveApi, vote: Vote, { approved, end }: ReferendumInfoFinished): [BN, BN] {
-  return [
-    end,
-    (approved.isTrue && vote.isAye) || (approved.isFalse && vote.isNay)
-      ? end.add(
-        (
-          api.consts.democracy.voteLockingPeriod ||
-          api.consts.democracy.enactmentPeriod
-        ).muln(LOCKUPS[vote.conviction.index])
-      )
-      : BN_ZERO
-  ];
-}
-
-function parseLock (api: DeriveApi, [referendumId, accountVote]: VotingDirectVote, referendum: PalletDemocracyReferendumInfo): DeriveDemocracyLock {
-  const { balance, vote } = accountVote.asStandard;
-  const [referendumEnd, unlockAt] = referendum.isFinished
-    ? parseEnd(api, vote, referendum.asFinished)
-    : [BN_ZERO, BN_ZERO];
-
-  return { balance, isDelegated: false, isFinished: referendum.isFinished, referendumEnd, referendumId, unlockAt, vote };
-}
-
-function delegateLocks (api: DeriveApi, { balance, conviction, target }: VotingDelegating): Observable<DeriveDemocracyLock[]> {
-  return api.derive.democracy.locks(target).pipe(
-    map((available): DeriveDemocracyLock[] =>
-      available.map(({ isFinished, referendumEnd, referendumId, unlockAt, vote }): DeriveDemocracyLock => ({
-        balance,
-        isDelegated: true,
-        isFinished,
-        referendumEnd,
-        referendumId,
-        unlockAt: unlockAt.isZero()
-          ? unlockAt
-          : referendumEnd.add(
-            (
-              api.consts.democracy.voteLockingPeriod ||
-              api.consts.democracy.enactmentPeriod
-            ).muln(LOCKUPS[conviction.index])
-          ),
-        vote: api.registry.createType('Vote', { aye: vote.isAye, conviction })
-      }))
-    )
-  );
-}
-
-function directLocks (api: DeriveApi, { votes }: VotingDirect): Observable<DeriveDemocracyLock[]> {
-  if (!votes.length) {
-    return of([]);
-  }
-
-  return api.query.democracy.referendumInfoOf.multi(votes.map(([referendumId]) => referendumId)).pipe(
-    map((referendums) =>
-      votes
-        .map((vote, index): [VotingDirectVote, PalletDemocracyReferendumInfo | ReferendumInfoTo239 | null] =>
-          [vote, referendums[index].unwrapOr(null)]
-        )
-        .filter((item): item is [VotingDirectVote, PalletDemocracyReferendumInfo] =>
-          !!item[1] && isUndefined((item[1] as ReferendumInfoTo239).end) && item[0][1].isStandard
-        )
-        .map(([directVote, referendum]) =>
-          parseLock(api, directVote, referendum)
-        )
-    )
-  );
-}
-
-/**
- * @name locks
- * @description Retrieves the democracy voting locks for a given account.
- * @param { string | AccountId } accountId The accountId for which to retrieve democracy voting locks.
- * @example
- * ```javascript
- * const locks = await api.derive.democracy.locks('5FfFjX...'); // Replace with an actual accountId
- * console.log("Democracy Locks:", locks);
- * ```
- */
-export function locks (instanceId: string, api: DeriveApi): (accountId: string | AccountId) => Observable<DeriveDemocracyLock[]> {
-  return memo(instanceId, (accountId: string | AccountId): Observable<DeriveDemocracyLock[]> =>
-    api.query.democracy.votingOf
-      ? api.query.democracy.votingOf(accountId).pipe(
-        switchMap((voting): Observable<DeriveDemocracyLock[]> =>
-          voting.isDirect
-            ? directLocks(api, voting.asDirect)
-            : voting.isDelegating
-              ? delegateLocks(api, voting.asDelegating)
-              : of([])
-        )
-      )
-      : of([])
-  );
-}

package/src/democracy/nextExternal.ts

@@ -1,49 +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 { H256 } from '@pezkuwi/types/interfaces';
-import type { FrameSupportPreimagesBounded, PalletDemocracyVoteThreshold } from '@pezkuwi/types/lookup';
-import type { ITuple } from '@pezkuwi/types/types';
-import type { DeriveApi, DeriveProposalExternal } from '../types.js';
-
-import { map, of, switchMap } from 'rxjs';
-
-import { memo } from '../util/index.js';
-import { getImageHashBounded } from './util.js';
-
-function withImage (api: DeriveApi, nextOpt: Option<ITuple<[H256 | FrameSupportPreimagesBounded, PalletDemocracyVoteThreshold]>>): Observable<DeriveProposalExternal | null> {
-  if (nextOpt.isNone) {
-    return of(null);
-  }
-
-  const [hash, threshold] = nextOpt.unwrap();
-
-  return api.derive.democracy.preimage(hash).pipe(
-    map((image): DeriveProposalExternal => ({
-      image,
-      imageHash: getImageHashBounded(hash),
-      threshold
-    }))
-  );
-}
-
-/**
- * @name nextExternal
- * @description Retrieves the next external proposal that is scheduled for a referendum.
- * @example
- * ```javascript
- * const nextExternal = await api.derive.democracy.nextExternal();
- * console.log("Next external proposal:", nextExternal);
- * ```
- */
-export function nextExternal (instanceId: string, api: DeriveApi): () => Observable<DeriveProposalExternal | null> {
-  return memo(instanceId, (): Observable<DeriveProposalExternal | null> =>
-    api.query.democracy?.nextExternal
-      ? api.query.democracy.nextExternal().pipe(
-        switchMap((nextOpt) => withImage(api, nextOpt))
-      )
-      : of(null)
-  );
-}

package/src/democracy/preimages.ts

@@ -1,171 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { u128 } from '@pezkuwi/types';
-import type { AccountId, AccountId32, Balance, BlockNumber, Call, Hash, PreimageStatus } from '@pezkuwi/types/interfaces';
-import type { FrameSupportPreimagesBounded, PalletPreimageOldRequestStatus, PalletPreimageRequestStatus } from '@pezkuwi/types/lookup';
-import type { Bytes, Option } from '@pezkuwi/types-codec';
-import type { ITuple } from '@pezkuwi/types-codec/types';
-import type { HexString } from '@pezkuwi/util/types';
-import type { DeriveApi, DeriveProposalImage } from '../types.js';
-
-import { map, of, switchMap } from 'rxjs';
-
-import { BN_ZERO, isFunction } from '@pezkuwi/util';
-
-import { firstMemo, memo } from '../util/index.js';
-import { getImageHashBounded } from './util.js';
-
-type PreimageInfo = [Bytes, AccountId, Balance, BlockNumber];
-type OldPreimage = ITuple<PreimageInfo>;
-type CompatStatusU = PalletPreimageRequestStatus['asUnrequested'] & { deposit: ITuple<[AccountId32, u128]> };
-type CompatStatusR = PalletPreimageRequestStatus['asRequested'] & { deposit: Option<ITuple<[AccountId32, u128]>> };
-
-function getUnrequestedTicket (status: PalletPreimageRequestStatus['asUnrequested']): [AccountId32, u128] {
-  return status.ticket || (status as CompatStatusU).deposit;
-}
-
-function getRequestedTicket (status: PalletPreimageRequestStatus['asRequested']): [AccountId32, u128] {
-  return (status.maybeTicket || (status as CompatStatusR).deposit).unwrapOrDefault();
-}
-
-function isDemocracyPreimage (api: DeriveApi, imageOpt: Option<OldPreimage> | Option<PreimageStatus>): imageOpt is Option<PreimageStatus> {
-  return !!imageOpt && !api.query.democracy['dispatchQueue'];
-}
-
-function constructProposal (api: DeriveApi, [bytes, proposer, balance, at]: PreimageInfo): DeriveProposalImage {
-  let proposal: Call | undefined;
-
-  try {
-    proposal = api.registry.createType('Call', bytes.toU8a(true));
-  } catch (error) {
-    console.error(error);
-  }
-
-  return { at, balance, proposal, proposer };
-}
-
-function parseDemocracy (api: DeriveApi, imageOpt: Option<OldPreimage> | Option<PreimageStatus>): DeriveProposalImage | undefined {
-  if (imageOpt.isNone) {
-    return;
-  }
-
-  if (isDemocracyPreimage(api, imageOpt)) {
-    const status = imageOpt.unwrap();
-
-    if (status.isMissing) {
-      return;
-    }
-
-    const { data, deposit, provider, since } = status.asAvailable;
-
-    return constructProposal(api, [data, provider, deposit, since]);
-  }
-
-  return constructProposal(api, imageOpt.unwrap());
-}
-
-function parseImage (api: DeriveApi, [proposalHash, status, bytes]: [HexString, PalletPreimageRequestStatus | PalletPreimageOldRequestStatus | null, Bytes | null]): DeriveProposalImage | undefined {
-  if (!status) {
-    return undefined;
-  }
-
-  const [proposer, balance] = status.isUnrequested
-    ? getUnrequestedTicket((status as PalletPreimageRequestStatus).asUnrequested)
-    : getRequestedTicket((status as PalletPreimageRequestStatus).asRequested);
-  let proposal: Call | undefined;
-
-  if (bytes) {
-    try {
-      proposal = api.registry.createType('Call', bytes.toU8a(true));
-    } catch (error) {
-      console.error(error);
-    }
-  }
-
-  return { at: BN_ZERO, balance, proposal, proposalHash, proposer };
-}
-
-function getDemocracyImages (api: DeriveApi, bounded: (Hash | Uint8Array | string | FrameSupportPreimagesBounded)[]): Observable<(DeriveProposalImage | undefined)[]> {
-  const hashes = bounded.map((b) => getImageHashBounded(b));
-
-  return api.query.democracy['preimages'].multi<Option<PreimageStatus>>(hashes).pipe(
-    map((images): (DeriveProposalImage | undefined)[] =>
-      images.map((imageOpt) => parseDemocracy(api, imageOpt))
-    )
-  );
-}
-
-function getImages (api: DeriveApi, bounded: (FrameSupportPreimagesBounded | Uint8Array | string)[]): Observable<(DeriveProposalImage | undefined)[]> {
-  const hashes = bounded.map((b) => getImageHashBounded(b));
-  const bytesType = api.registry.lookup.getTypeDef(api.query.preimage.preimageFor.creator.meta.type.asMap.key).type;
-
-  return api.query.preimage.statusFor.multi(hashes).pipe(
-    switchMap((optStatus) => {
-      const statuses = optStatus.map((o) => o.unwrapOr(null));
-      const keys = statuses
-        .map((s, i) =>
-          s
-            ? bytesType === 'H256'
-              // first generation
-              ? hashes[i]
-              // current generation (H256,u32)
-              : s.isRequested
-                ? [hashes[i], s.asRequested.len.unwrapOr(0)]
-                : [hashes[i], s.asUnrequested.len]
-            : null
-        )
-        .filter((p) => !!p);
-
-      return api.query.preimage.preimageFor.multi(keys).pipe(
-        map((optBytes) => {
-          let ptr = -1;
-
-          return statuses
-            .map((s, i): [HexString, PalletPreimageRequestStatus | PalletPreimageOldRequestStatus | null, Bytes | null] =>
-              s
-                ? [hashes[i], s, optBytes[++ptr].unwrapOr(null)]
-                : [hashes[i], null, null]
-            )
-            .map((v) => parseImage(api, v));
-        })
-      );
-    })
-  );
-}
-
-/**
- * @name preimages
- * @description Retrieves the full details (preimages) of governance proposals using their on-chain hashes.
- * @param { (Hash | Uint8Array | string | FrameSupportPreimagesBounded)[] } hashes An array of hashes representing governance proposals.
- * @example
- * ```javascript
- * const preimages = await api.derive.democracy.preimages([HASH1, HASH2]);
- * ```
- */
-export function preimages (instanceId: string, api: DeriveApi): (hashes: (Hash | Uint8Array | string | FrameSupportPreimagesBounded)[]) => Observable<(DeriveProposalImage | undefined)[]> {
-  return memo(instanceId, (hashes: (Hash | Uint8Array | string | FrameSupportPreimagesBounded)[]): Observable<(DeriveProposalImage | undefined)[]> =>
-    hashes.length
-      ? isFunction(api.query.democracy['preimages'])
-        ? getDemocracyImages(api, hashes)
-        : isFunction(api.query.preimage.preimageFor)
-          ? getImages(api, hashes)
-          : of([])
-      : of([])
-  );
-}
-
-/**
- * @name preimage
- * @description Retrieves the full details (preimage) of a governance proposal using its on-chain hash.
- * @param { Hash | Uint8Array | string | FrameSupportPreimagesBounded } hash Hash that represents governance proposals.
- *  * @example
- * ```javascript
- * const preimage = await api.derive.democracy.preimage(HASH);
- * ```
- */
-export const preimage = /*#__PURE__*/ firstMemo(
-  (api: DeriveApi, hash: Hash | Uint8Array | string | FrameSupportPreimagesBounded) =>
-    api.derive.democracy.preimages([hash])
-);

package/src/democracy/proposals.ts

@@ -1,81 +0,0 @@
-// 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, Balance, Hash, PropIndex } from '@pezkuwi/types/interfaces';
-import type { FrameSupportPreimagesBounded } from '@pezkuwi/types/lookup';
-import type { ITuple } from '@pezkuwi/types/types';
-import type { DeriveApi, DeriveProposal, DeriveProposalImage } from '../types.js';
-
-import { combineLatest, map, of, switchMap } from 'rxjs';
-
-import { isFunction, objectSpread } from '@pezkuwi/util';
-
-import { memo } from '../util/index.js';
-import { getImageHashBounded } from './util.js';
-
-type DepositorsNew = Option<ITuple<[Vec<AccountId>, Balance]>>;
-type DepositorsOld = Option<ITuple<[Balance, Vec<AccountId>]>>;
-type Depositors = DepositorsNew | DepositorsOld;
-type Proposals = ITuple<[PropIndex, Hash | FrameSupportPreimagesBounded, AccountId]>[];
-type Result = [Proposals, (DeriveProposalImage | undefined)[], Depositors[]];
-
-function isNewDepositors (depositors: ITuple<[Vec<AccountId>, Balance]> | ITuple<[Balance, Vec<AccountId>]>): depositors is ITuple<[Vec<AccountId>, Balance]> {
-  // Detect balance...
-  return isFunction((depositors[1] as Balance).mul);
-}
-
-function parse ([proposals, images, optDepositors]: Result): DeriveProposal[] {
-  return proposals
-    .filter(([, , proposer], index): boolean =>
-      !!(optDepositors[index]?.isSome) && !proposer.isEmpty
-    )
-    .map(([index, hash, proposer], proposalIndex): DeriveProposal => {
-      const depositors = optDepositors[proposalIndex].unwrap();
-
-      return objectSpread(
-        {
-          image: images[proposalIndex],
-          imageHash: getImageHashBounded(hash),
-          index,
-          proposer
-        },
-        isNewDepositors(depositors)
-          ? { balance: depositors[1], seconds: depositors[0] }
-          : { balance: depositors[0], seconds: depositors[1] }
-      );
-    });
-}
-
-/**
- * @name proposals
- * @description Retrieves the list of active public proposals in the democracy module, along with their associated preimage data and deposit information.
- * @example
- * ```javascript
- * const proposals = await api.derive.democracy.proposals();
- * console.log("proposals:", proposals);
- * ```
- */
-export function proposals (instanceId: string, api: DeriveApi): () => Observable<DeriveProposal[]> {
-  return memo(instanceId, (): Observable<DeriveProposal[]> =>
-    isFunction(api.query.democracy?.publicProps)
-      ? api.query.democracy.publicProps().pipe(
-        switchMap((proposals) =>
-          proposals.length
-            ? combineLatest([
-              of(proposals),
-              api.derive.democracy.preimages(
-                proposals.map(([, hash]) => hash)
-              ),
-              api.query.democracy.depositOf.multi(
-                proposals.map(([index]) => index)
-              )
-            ])
-            : of<Result>([[], [], []])
-        ),
-        map(parse)
-      )
-      : of([])
-  );
-}

package/src/democracy/referendumIds.ts

@@ -1,37 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { ReferendumIndex } from '@pezkuwi/types/interfaces';
-import type { BN } from '@pezkuwi/util';
-import type { DeriveApi } from '../types.js';
-
-import { map, of } from 'rxjs';
-
-import { memo } from '../util/index.js';
-
-/**
- * @name referendumIds
- * @description Retrieves an array of active referendum IDs.
- * @example
- * ```javascript
- * const referendums = await api.derive.democracy.referendumIds();
- * ```
- */
-export function referendumIds (instanceId: string, api: DeriveApi): () => Observable<BN[]> {
-  return memo(instanceId, (): Observable<BN[]> =>
-    api.query.democracy?.lowestUnbaked
-      ? api.queryMulti<[ReferendumIndex, ReferendumIndex]>([
-        api.query.democracy.lowestUnbaked,
-        api.query.democracy.referendumCount
-      ]).pipe(
-        map(([first, total]): BN[] =>
-          total.gt(first)
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            ? [...Array(total.sub(first).toNumber())].map((_, i): BN => first.addn(i))
-            : []
-        )
-      )
-      : of([])
-  );
-}

package/src/democracy/referendums.ts

@@ -1,39 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { DeriveApi, DeriveReferendumExt } from '../types.js';
-
-import { combineLatest, map, of, switchMap } from 'rxjs';
-
-import { objectSpread } from '@pezkuwi/util';
-
-import { memo } from '../util/index.js';
-
-/**
- * @name referendums
- * @description Retrieves information about all active referendums, including their details and associated votes.
- * @example
- * ```javascript
- * const referendums = await api.derive.democracy.referendums();
- * ```
- */
-export function referendums (instanceId: string, api: DeriveApi): () => Observable<DeriveReferendumExt[]> {
-  return memo(instanceId, (): Observable<DeriveReferendumExt[]> =>
-    api.derive.democracy.referendumsActive().pipe(
-      switchMap((referendums) =>
-        referendums.length
-          ? combineLatest([
-            of(referendums),
-            api.derive.democracy._referendumsVotes(referendums)
-          ])
-          : of([[], []])
-      ),
-      map(([referendums, votes]) =>
-        referendums.map((referendum, index): DeriveReferendumExt =>
-          objectSpread({}, referendum, votes[index])
-        )
-      )
-    )
-  );
-}

package/src/democracy/referendumsActive.ts

@@ -1,30 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { DeriveApi, DeriveReferendum } from '../types.js';
-
-import { of, switchMap } from 'rxjs';
-
-import { memo } from '../util/index.js';
-
-/**
- * @name referendumsActive
- * @description Retrieves information about active referendums.
- * @example
- * ```javascript
- * const referendums = await api.derive.democracy.referendumsActive();
- * console.log("Active Referendums:", referendums);
- * ```
- */
-export function referendumsActive (instanceId: string, api: DeriveApi): () => Observable<DeriveReferendum[]> {
-  return memo(instanceId, (): Observable<DeriveReferendum[]> =>
-    api.derive.democracy.referendumIds().pipe(
-      switchMap((ids): Observable<DeriveReferendum[]> =>
-        ids.length
-          ? api.derive.democracy.referendumsInfo(ids)
-          : of([])
-      )
-    )
-  );
-}