@pezkuwi/api-derive 16.5.5

package/src/democracy/locks.ts

@@ -0,0 +1,114 @@
+// 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

@@ -0,0 +1,49 @@
+// 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

@@ -0,0 +1,171 @@
+// 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

@@ -0,0 +1,81 @@
+// 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

@@ -0,0 +1,37 @@
+// 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

@@ -0,0 +1,39 @@
+// 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

@@ -0,0 +1,30 @@
+// 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([])
+      )
+    )
+  );
+}

package/src/democracy/referendumsFinished.ts

@@ -0,0 +1,37 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { PalletDemocracyReferendumInfo } from '@pezkuwi/types/lookup';
+import type { DeriveApi } from '../types.js';
+
+import { map, switchMap } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+type ReferendumInfoFinished = PalletDemocracyReferendumInfo['asFinished'];
+
+/**
+ * @name referendumsFinished
+ * @description Retrieves information about finished referendums.
+ * @example
+ * ```javascript
+ * const referendums = await api.derive.democracy.referendumsFinished();
+ * console.log("Finished Referendums:", referendums);
+ * ```
+ */
+export function referendumsFinished (instanceId: string, api: DeriveApi): () => Observable<ReferendumInfoFinished[]> {
+  return memo(instanceId, (): Observable<ReferendumInfoFinished[]> =>
+    api.derive.democracy.referendumIds().pipe(
+      switchMap((ids) =>
+        api.query.democracy.referendumInfoOf.multi(ids)
+      ),
+      map((infos): ReferendumInfoFinished[] =>
+        infos
+          .map((o) => o.unwrapOr(null))
+          .filter((info): info is PalletDemocracyReferendumInfo => !!info && info.isFinished)
+          .map((info) => info.asFinished)
+      )
+    )
+  );
+}