@pezkuwi/api-derive 16.5.5 → 16.5.8

package/build-deno/democracy/dispatchQueue.ts

@@ -0,0 +1,154 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { Bytes, Option, u8, u32, Vec } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { BlockNumber, Call, Hash, ReferendumIndex, Scheduled } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezframeSupportPreimagesBounded, PezpalletSchedulerScheduled } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { Codec, ITuple } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
+import type { DeriveApi, DeriveDispatch, DeriveProposalImage } from '../types.ts';
+
+import { catchError, combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { Enum } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import { isFunction, objectSpread, stringToHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+import { getImageHashBounded } from './util.ts';
+
+const DEMOCRACY_ID = stringToHex('democrac');
+
+interface PezpalletSchedulerScheduledV3 extends Codec {
+  maybeId: Option<Bytes>;
+  priority: u8;
+  call: PezframeSupportScheduleMaybeHashed;
+  maybePeriodic: Option<ITuple<[u32, u32]>>;
+  origin: Codec;
+}
+
+interface PezframeSupportScheduleMaybeHashed extends Codec {
+  isHash: boolean;
+  isValue: boolean;
+  asValue: Call;
+  asHash: Hash;
+}
+
+interface SchedulerInfo {
+  at: BlockNumber;
+  imageHash: HexString;
+  index: ReferendumIndex;
+}
+
+function isMaybeHashedOrBounded (call: PezframeSupportPreimagesBounded | PezframeSupportScheduleMaybeHashed | Call): call is PezframeSupportScheduleMaybeHashed | PezframeSupportPreimagesBounded {
+  // check for enum
+  return call instanceof Enum;
+}
+
+function isBounded (call: PezframeSupportPreimagesBounded | PezframeSupportScheduleMaybeHashed): call is PezframeSupportPreimagesBounded {
+  // check for type
+  return (call as PezframeSupportPreimagesBounded).isInline || (call as PezframeSupportPreimagesBounded).isLegacy || (call as PezframeSupportPreimagesBounded).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<PezpalletSchedulerScheduled | PezpalletSchedulerScheduledV3 | 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<PezpalletSchedulerScheduledV3 | 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/build-deno/democracy/index.ts

@@ -0,0 +1,12 @@
+
+export * from './dispatchQueue.ts';
+export * from './locks.ts';
+export * from './nextExternal.ts';
+export * from './preimages.ts';
+export * from './proposals.ts';
+export * from './referendumIds.ts';
+export * from './referendums.ts';
+export * from './referendumsActive.ts';
+export * from './referendumsFinished.ts';
+export * from './referendumsInfo.ts';
+export * from './sqrtElectorate.ts';

package/build-deno/democracy/locks.ts

@@ -0,0 +1,112 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AccountId, ReferendumInfoTo239, Vote } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezpalletDemocracyReferendumInfo, PezpalletDemocracyVoteVoting } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import type { DeriveApi, DeriveDemocracyLock } from '../types.ts';
+
+import { map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { BN_ZERO, isUndefined } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+
+type ReferendumInfoFinished = PezpalletDemocracyReferendumInfo['asFinished'];
+type VotingDelegating = PezpalletDemocracyVoteVoting['asDelegating'];
+type VotingDirect = PezpalletDemocracyVoteVoting['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: PezpalletDemocracyReferendumInfo): 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, PezpalletDemocracyReferendumInfo | ReferendumInfoTo239 | null] =>
+          [vote, referendums[index].unwrapOr(null)]
+        )
+        .filter((item): item is [VotingDirectVote, PezpalletDemocracyReferendumInfo] =>
+          !!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/build-deno/democracy/nextExternal.ts

@@ -0,0 +1,47 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { Option } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { H256 } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezframeSupportPreimagesBounded, PezpalletDemocracyVoteThreshold } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { ITuple } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { DeriveApi, DeriveProposalExternal } from '../types.ts';
+
+import { map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+import { getImageHashBounded } from './util.ts';
+
+function withImage (api: DeriveApi, nextOpt: Option<ITuple<[H256 | PezframeSupportPreimagesBounded, PezpalletDemocracyVoteThreshold]>>): 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/build-deno/democracy/preimages.ts

@@ -0,0 +1,169 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { u128 } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { AccountId, AccountId32, Balance, BlockNumber, Call, Hash, PreimageStatus } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezframeSupportPreimagesBounded, PezpalletPreimageOldRequestStatus, PezpalletPreimageRequestStatus } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { Bytes, Option } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
+import type { ITuple } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
+import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
+import type { DeriveApi, DeriveProposalImage } from '../types.ts';
+
+import { map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { BN_ZERO, isFunction } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { firstMemo, memo } from '../util/index.ts';
+import { getImageHashBounded } from './util.ts';
+
+type PreimageInfo = [Bytes, AccountId, Balance, BlockNumber];
+type OldPreimage = ITuple<PreimageInfo>;
+type CompatStatusU = PezpalletPreimageRequestStatus['asUnrequested'] & { deposit: ITuple<[AccountId32, u128]> };
+type CompatStatusR = PezpalletPreimageRequestStatus['asRequested'] & { deposit: Option<ITuple<[AccountId32, u128]>> };
+
+function getUnrequestedTicket (status: PezpalletPreimageRequestStatus['asUnrequested']): [AccountId32, u128] {
+  return status.ticket || (status as CompatStatusU).deposit;
+}
+
+function getRequestedTicket (status: PezpalletPreimageRequestStatus['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, PezpalletPreimageRequestStatus | PezpalletPreimageOldRequestStatus | null, Bytes | null]): DeriveProposalImage | undefined {
+  if (!status) {
+    return undefined;
+  }
+
+  const [proposer, balance] = status.isUnrequested
+    ? getUnrequestedTicket((status as PezpalletPreimageRequestStatus).asUnrequested)
+    : getRequestedTicket((status as PezpalletPreimageRequestStatus).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 | PezframeSupportPreimagesBounded)[]): 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: (PezframeSupportPreimagesBounded | 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, PezpalletPreimageRequestStatus | PezpalletPreimageOldRequestStatus | 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 | PezframeSupportPreimagesBounded)[] } 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 | PezframeSupportPreimagesBounded)[]) => Observable<(DeriveProposalImage | undefined)[]> {
+  return memo(instanceId, (hashes: (Hash | Uint8Array | string | PezframeSupportPreimagesBounded)[]): 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 | PezframeSupportPreimagesBounded } 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 | PezframeSupportPreimagesBounded) =>
+    api.derive.democracy.preimages([hash])
+);

package/build-deno/democracy/proposals.ts

@@ -0,0 +1,79 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { Option, Vec } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { AccountId, Balance, Hash, PropIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezframeSupportPreimagesBounded } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { ITuple } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { DeriveApi, DeriveProposal, DeriveProposalImage } from '../types.ts';
+
+import { combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { isFunction, objectSpread } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+import { getImageHashBounded } from './util.ts';
+
+type DepositorsNew = Option<ITuple<[Vec<AccountId>, Balance]>>;
+type DepositorsOld = Option<ITuple<[Balance, Vec<AccountId>]>>;
+type Depositors = DepositorsNew | DepositorsOld;
+type Proposals = ITuple<[PropIndex, Hash | PezframeSupportPreimagesBounded, 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/build-deno/democracy/referendumIds.ts

@@ -0,0 +1,35 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { ReferendumIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { map, of } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @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/build-deno/democracy/referendums.ts

@@ -0,0 +1,37 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { DeriveApi, DeriveReferendumExt } from '../types.ts';
+
+import { combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { objectSpread } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @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/build-deno/democracy/referendumsActive.ts

@@ -0,0 +1,28 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { DeriveApi, DeriveReferendum } from '../types.ts';
+
+import { of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @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([])
+      )
+    )
+  );
+}