@pezkuwi/api-derive 16.5.17 → 16.5.19

package/src/crowdloan/ownContributions.ts

@@ -0,0 +1,81 @@
+// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi, DeriveOwnContributions } from '../types.js';
+
+import { combineLatest, EMPTY, map, of, startWith, switchMap } from 'rxjs';
+
+import { objectSpread } from '@pezkuwi/util';
+
+import { memo } from '../util/index.js';
+import { extractContributed } from './util.js';
+
+function _getValues (api: DeriveApi, childKey: string, keys: string[]): Observable<DeriveOwnContributions> {
+  // We actually would love to use multi-keys https://github.com/pezkuwichain/bizinikiwi/issues/9203
+  return combineLatest(keys.map((k) => api.rpc.childstate.getStorage(childKey, k))).pipe(
+    map((values) =>
+      values
+        .map((v) => api.registry.createType('Option<StorageData>', v))
+        .map((o) =>
+          o.isSome
+            ? api.registry.createType('Balance', o.unwrap())
+            : api.registry.createType('Balance')
+        )
+        .reduce((all: DeriveOwnContributions, b, index): DeriveOwnContributions =>
+          objectSpread(all, { [keys[index]]: b }), {})
+    )
+  );
+}
+
+function _watchOwnChanges (api: DeriveApi, paraId: string | number | BN, childkey: string, keys: string[]): Observable<DeriveOwnContributions> {
+  return api.query.system.events().pipe(
+    switchMap((events): Observable<DeriveOwnContributions> => {
+      const changes = extractContributed(paraId, events);
+      const filtered = keys.filter((k) =>
+        changes.added.includes(k) ||
+        changes.removed.includes(k)
+      );
+
+      return filtered.length
+        ? _getValues(api, childkey, filtered)
+        : EMPTY;
+    }),
+    startWith({})
+  );
+}
+
+function _contributions (api: DeriveApi, paraId: string | number | BN, childKey: string, keys: string[]): Observable<DeriveOwnContributions> {
+  return combineLatest([
+    _getValues(api, childKey, keys),
+    _watchOwnChanges(api, paraId, childKey, keys)
+  ]).pipe(
+    map(([all, latest]) =>
+      objectSpread({}, all, latest)
+    )
+  );
+}
+
+/**
+ * @name ownContributions
+ * @description Retrieves the contribution amounts made by specific accounts (`keys`) to a given teyrchain crowdloan (`paraId`).
+ * @param {string | number | BN} paraId The teyrchain ID for which contributions are being queried.
+ * @param {string[]} keys An array of account addresses whose contributions are to be fetched.
+ * @example
+ * ```javascript
+ * const contributions = await api.derive.crowdloan.ownContributions(2000, ['5Ff...PqV', '5Gg...XyZ']);
+ * console.log("Own Contributions:", contributions);
+ * ```
+ */
+export function ownContributions (instanceId: string, api: DeriveApi): (paraId: string | number | BN, keys: string[]) => Observable<DeriveOwnContributions> {
+  return memo(instanceId, (paraId: string | number | BN, keys: string[]): Observable<DeriveOwnContributions> =>
+    api.derive.crowdloan.childKey(paraId).pipe(
+      switchMap((childKey) =>
+        childKey && keys.length
+          ? _contributions(api, paraId, childKey, keys)
+          : of({})
+      )
+    )
+  );
+}

package/src/crowdloan/types.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Balance } from '@pezkuwi/types/interfaces';
+
+export interface DeriveContributions {
+  blockHash: string;
+  contributorsHex: string[];
+}
+
+export type DeriveOwnContributions = Record<string, Balance>;

package/src/crowdloan/util.ts

@@ -0,0 +1,33 @@
+// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { PezframeSystemEventRecord } from '@pezkuwi/types/lookup';
+import type { Vec } from '@pezkuwi/types-codec';
+import type { BN } from '@pezkuwi/util';
+
+interface Changes {
+  added: string[];
+  blockHash: string;
+  removed: string[];
+}
+
+export function extractContributed (paraId: string | number | BN, events: Vec<PezframeSystemEventRecord>): Changes {
+  const added: string[] = [];
+  const removed: string[] = [];
+
+  return events
+    .filter(({ event: { data: [, eventParaId], method, section } }) =>
+      section === 'crowdloan' &&
+      ['Contributed', 'Withdrew'].includes(method) &&
+      eventParaId.eq(paraId)
+    )
+    .reduce((result: Changes, { event: { data: [accountId], method } }): Changes => {
+      if (method === 'Contributed') {
+        result.added.push(accountId.toHex());
+      } else {
+        result.removed.push(accountId.toHex());
+      }
+
+      return result;
+    }, { added, blockHash: events.createdAtHash?.toHex() || '-', removed });
+}

package/src/democracy/dispatchQueue.ts

@@ -0,0 +1,158 @@
+// Copyright 2017-2025 @pezkuwi/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 { PezframeSupportPreimagesBounded, PezpalletSchedulerScheduled } 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 PezpalletSchedulerScheduledV3 extends Codec {
+  maybeId: Option<Bytes>;
+  priority: u8;
+  call: PezframeSupportScheduleMaybeHashed;
+  maybePeriodic: Option<ITuple<[u32, u32]>>;
+  origin: Codec;
+}
+
+// included here for backwards compat
+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/src/democracy/index.ts

@@ -0,0 +1,14 @@
+// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './dispatchQueue.js';
+export * from './locks.js';
+export * from './nextExternal.js';
+export * from './preimages.js';
+export * from './proposals.js';
+export * from './referendumIds.js';
+export * from './referendums.js';
+export * from './referendumsActive.js';
+export * from './referendumsFinished.js';
+export * from './referendumsInfo.js';
+export * from './sqrtElectorate.js';

package/src/democracy/locks.ts

@@ -0,0 +1,114 @@
+// Copyright 2017-2025 @pezkuwi/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 { PezpalletDemocracyReferendumInfo, PezpalletDemocracyVoteVoting } 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 = 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/src/democracy/nextExternal.ts

@@ -0,0 +1,49 @@
+// Copyright 2017-2025 @pezkuwi/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 { PezframeSupportPreimagesBounded, PezpalletDemocracyVoteThreshold } 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 | 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/src/democracy/preimages.ts

@@ -0,0 +1,171 @@
+// Copyright 2017-2025 @pezkuwi/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 { PezframeSupportPreimagesBounded, PezpalletPreimageOldRequestStatus, PezpalletPreimageRequestStatus } 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 = 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])
+);