@pezkuwi/api-derive 16.5.5

package/src/staking/validators.ts

@@ -0,0 +1,82 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveStakingValidators } from '../types.js';
+
+import { combineLatest, map, of, switchMap } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+/**
+ * @name nextElected
+ * @description Retrieves the list of accounts that are set to be the next elected validators in the staking system. It provides a preview of who will be validators in the next staking era.
+ * @example
+ * ```javascript
+ * const nextElected = await api.derive.staking.nextElected();
+ * console.log(
+ *   "Next Elected Validators:",
+ *   nextElected.map((acc) => acc.toString())
+ * );
+ * ```
+ */
+export function nextElected (instanceId: string, api: DeriveApi): () => Observable<AccountId[]> {
+  return memo(instanceId, (): Observable<AccountId[]> =>
+    // Compatibility for future generation changes in staking.
+    api.query.staking.erasStakersOverview
+      ? api.derive.session.indexes().pipe(
+        // only populate for next era in the last session, so track both here - entries are not
+        // subscriptions, so we need a trigger - currentIndex acts as that trigger to refresh
+        switchMap(({ currentEra }) => api.query.staking.erasStakersOverview.keys(currentEra)),
+        // Dedupe any duplicates
+        map((keys) => [...new Set(keys.map(({ args: [, accountId] }) => accountId.toString()))].map((a) => api.registry.createType('AccountId', a)))
+      )
+      : api.query.staking.erasStakers
+        ? api.derive.session.indexes().pipe(
+          // only populate for next era in the last session, so track both here - entries are not
+          // subscriptions, so we need a trigger - currentIndex acts as that trigger to refresh
+          switchMap(({ currentEra }) => api.query.staking.erasStakers.keys(currentEra)),
+          // Dedupe any duplicates
+          map((keys) => [...new Set(keys.map(({ args: [, accountId] }) => accountId.toString()))].map((a) => api.registry.createType('AccountId', a)))
+        )
+        : api.query.staking['currentElected']<AccountId[]>()
+  );
+}
+
+/**
+ * @name validators
+ * @description Retrieve latest list of validators.
+ * @example
+ * ```javascript
+ * const { validators, nextElected } = await api.derive.staking.validators();
+ * console.log(
+ *   "Current Validators:",
+ *   validators.map((v) => v.toString())
+ * );
+ * console.log(
+ *   "Next Elected Validators:",
+ *   nextElected.map((v) => v.toString())
+ * );
+ * ```
+ */
+export function validators (instanceId: string, api: DeriveApi): () => Observable<DeriveStakingValidators> {
+  return memo(instanceId, (): Observable<DeriveStakingValidators> =>
+    // Sadly the node-template is (for some obscure reason) not comprehensive, so while the derive works
+    // in all actual real-world deployed chains, it does create some confusion for limited template chains
+    combineLatest([
+      api.query.session
+        ? api.query.session.validators()
+        : of([]),
+      api.query.staking
+        ? api.derive.staking.nextElected()
+        : of([])
+    ]).pipe(
+      map(([validators, nextElected]): DeriveStakingValidators => ({
+        nextElected: nextElected.length
+          ? nextElected
+          : validators,
+        validators
+      }))
+    ));
+}

package/src/staking/waitingInfo.ts

@@ -0,0 +1,45 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveStakingWaiting, StakingQueryFlags } from '../types.js';
+
+import { combineLatest, map, switchMap } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+const DEFAULT_FLAGS = { withController: true, withPrefs: true };
+
+/**
+ * @name waitingInfo
+ * @param {StakingQueryFlags} flags? (Optional) Query flags to filter the staking data.
+ * @description Staking candidates who are waiting to become validators.
+ * @example
+ * ```javascript
+ * const { waiting, info } = await api.derive.staking.waitingInfo();
+ * console.log(
+ *   "Waiting Candidates:",
+ *   waiting.map((acc) => acc.toString())
+ * );
+ * ```
+ */
+export function waitingInfo (instanceId: string, api: DeriveApi): (flags?: StakingQueryFlags) => Observable<DeriveStakingWaiting> {
+  return memo(instanceId, (flags: StakingQueryFlags = DEFAULT_FLAGS): Observable<DeriveStakingWaiting> =>
+    combineLatest([
+      api.derive.staking.validators(),
+      api.derive.staking.stashes()
+    ]).pipe(
+      switchMap(([{ nextElected }, stashes]): Observable<DeriveStakingWaiting> => {
+        const elected = nextElected.map((a) => a.toString());
+        const waiting = stashes.filter((v) => !elected.includes(v.toString()));
+
+        return api.derive.staking.queryMulti(waiting, flags).pipe(
+          map((info): DeriveStakingWaiting => ({
+            info,
+            waiting
+          }))
+        );
+      })
+    )
+  );
+}

package/src/technicalCommittee/index.ts

@@ -0,0 +1,76 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { hasProposals as collectiveHasProposals, members as collectiveMembers, prime as collectivePrime, proposal as collectiveProposal, proposalCount as collectiveProposalCount, proposalHashes as collectiveProposalHashes, proposals as collectiveProposals } from '../collective/index.js';
+
+/**
+ * @name members
+ * @description Retrieves the list of members in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const members = await api.derive.technicalCommittee.members();
+ * console.log(`Members: ${JSON.stringify(members)});
+ * ```
+ */
+export const members = /*#__PURE__*/ collectiveMembers('technicalCommittee');
+
+/**
+ * @name hasProposals
+ * @description Checks if there are any active proposals in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const exists = await api.derive.technicalCommittee.hasProposals();
+ * console.log(exists);
+ * ```
+ */
+export const hasProposals = /*#__PURE__*/ collectiveHasProposals('technicalCommittee');
+/**
+ * @name proposal
+ * @description Retrieves details of a specific proposal in the "technicalCommitteeMotion" collective by its hash.
+ * @example
+ * ```javascript
+ * const proposalDetails = await api.derive.technicalCommittee.proposal(PROPOSAL_HASH);
+ * console.log(proposalDetails);
+ * ```
+ */
+export const proposal = /*#__PURE__*/ collectiveProposal('technicalCommittee');
+/**
+ * @name proposalCount
+ * @description Retrieves the total number of proposals in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const count = await api.derive.technicalCommittee.proposalCount();
+ * console.log(`Amount of proposals: ${count}`);
+ * ```
+ */
+export const proposalCount = /*#__PURE__*/ collectiveProposalCount('technicalCommittee');
+/**
+ * @name proposalHashes
+ * @description Retrieves an array of hashes for all active proposals in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const hashes = await api.derive.technicalCommittee.proposalHashes();
+ * console.log(`Proposals ${JSON.stringify(hashes)}`);
+ * ```
+ */
+export const proposalHashes = /*#__PURE__*/ collectiveProposalHashes('technicalCommittee');
+/**
+ * @name proposals
+ * @description Retrieves a list of all active proposals in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.technicalCommittee.proposals();
+ * console.log(proposals);
+ * ```
+ */
+export const proposals = /*#__PURE__*/ collectiveProposals('technicalCommittee');
+/**
+ * @name prime
+ * @description Retrieves the prime member of the "technicalCommittee" collective, if one exists.
+ * @example
+ * ```javascript
+ * const primeMember = await api.derive.technicalCommittee.prime();
+ * console.log(primeMember);
+ * ```
+ */
+export const prime = /*#__PURE__*/ collectivePrime('technicalCommittee');

package/src/test/bountyFactory.ts

@@ -0,0 +1,39 @@
+// Copyright 2017-2025 @polkadot/api authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ApiPromise } from '@pezkuwi/api';
+import type { Bounty, BountyIndex } from '@pezkuwi/types/interfaces';
+import type { Codec, CodecClass, InterfaceTypes, Registry } from '@pezkuwi/types/types';
+
+import { Option, StorageKey } from '@pezkuwi/types';
+
+export class BountyFactory {
+  readonly #api: ApiPromise;
+  readonly #registry: Registry;
+
+  constructor (api: ApiPromise) {
+    this.#api = api;
+    this.#registry = this.#api.registry;
+  }
+
+  public storageKey = (index: number): StorageKey => {
+    const key = new StorageKey(this.#registry, this.#api.query.bounties.bounties.key(this.bountyIndex(index)));
+
+    return key.setMeta(this.#api.query.bounties.bounties.creator.meta);
+  };
+
+  public bountyIndex = (index: number): BountyIndex =>
+    this.#registry.createType('BountyIndex', index);
+
+  public defaultBounty = (): Bounty =>
+    this.#registry.createType('Bounty');
+
+  public optionOf = <T extends Codec>(value: T): Option<T> => {
+    const typeName = this.#registry.getClassName(value.constructor as CodecClass<T>);
+
+    return new Option<T>(this.#registry, typeName as keyof InterfaceTypes, value);
+  };
+
+  public emptyOption = <T extends Codec>(typeName: keyof InterfaceTypes): Option<T> =>
+    new Option<T>(this.#registry, typeName);
+}

package/src/test/bytesFactory.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2025 @polkadot/api authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Bytes } from '@pezkuwi/types';
+import type { Registry } from '@pezkuwi/types/types';
+
+export class BytesFactory {
+  #registry: Registry;
+
+  constructor (registry: Registry) {
+    this.#registry = registry;
+  }
+
+  public bytes = (value: string): Bytes => this.#registry.createType('Bytes', value);
+}

package/src/test/helpers.ts

@@ -0,0 +1,23 @@
+// Copyright 2017-2025 @polkadot/api authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ApiPromise, WsProvider } from '@pezkuwi/api';
+import { Metadata, TypeRegistry } from '@pezkuwi/types';
+import metaStatic from '@pezkuwi/types-support/metadata/static-substrate';
+
+export function createApiWithAugmentations (): ApiPromise {
+  const registry = new TypeRegistry();
+  const metadata = new Metadata(registry, metaStatic);
+
+  registry.setMetadata(metadata);
+
+  const api = new ApiPromise({
+    provider: new WsProvider('ws://', false),
+    registry
+  });
+
+  // eslint-disable-next-line deprecation/deprecation
+  api.injectMetadata(metadata, true, registry);
+
+  return api;
+}

package/src/test/proposalFactory.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2025 @polkadot/api authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ApiPromise } from '@pezkuwi/api';
+import type { SubmittableExtrinsic } from '@pezkuwi/api-base/types';
+import type { Proposal, ProposalIndex } from '@pezkuwi/types/interfaces';
+import type { Registry } from '@pezkuwi/types/types';
+
+export class ProposalFactory {
+  readonly #api: ApiPromise;
+  readonly #registry: Registry;
+
+  constructor (api: ApiPromise) {
+    this.#api = api;
+    this.#registry = this.#api.registry;
+  }
+
+  public createProposal = (method: SubmittableExtrinsic<'promise'>): Proposal => {
+    return this.#registry.createType('Proposal', method);
+  };
+
+  public proposalIndex = (index: number): ProposalIndex => {
+    return this.#registry.createType('ProposalIndex', index);
+  };
+}

package/src/treasury/index.ts

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

package/src/treasury/proposals.ts

@@ -0,0 +1,109 @@
+// 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 { ProposalIndex } from '@pezkuwi/types/interfaces';
+import type { PalletTreasuryProposal } from '@pezkuwi/types/lookup';
+import type { DeriveApi, DeriveCollectiveProposal, DeriveTreasuryProposal, DeriveTreasuryProposals } from '../types.js';
+
+import { combineLatest, map, of, switchMap } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+interface Result {
+  allIds: ProposalIndex[];
+  allProposals: Option<PalletTreasuryProposal>[];
+  approvalIds: ProposalIndex[];
+  councilProposals: DeriveCollectiveProposal[];
+  proposalCount: ProposalIndex;
+}
+
+function parseResult (api: DeriveApi, { allIds, allProposals, approvalIds, councilProposals, proposalCount }: Result): DeriveTreasuryProposals {
+  const approvals: DeriveTreasuryProposal[] = [];
+  const proposals: DeriveTreasuryProposal[] = [];
+  const councilTreasury = councilProposals.filter(({ proposal }) =>
+    // FIXME `approveProposal` and `rejectProposal` have been removed in substrate and released in 1.14
+    // in favor of `spend`. See: https://github.com/paritytech/polkadot-sdk/pull/3820
+    proposal && (
+      (api.tx.treasury['approveProposal'] && api.tx.treasury['approveProposal'].is(proposal)) ||
+      (api.tx.treasury['rejectProposal'] && api.tx.treasury['rejectProposal'].is(proposal))
+    )
+  );
+
+  allIds.forEach((id, index): void => {
+    if (allProposals[index].isSome) {
+      const council = councilTreasury
+        .filter(({ proposal }) => proposal && id.eq(proposal.args[0]))
+        .sort((a, b) =>
+          a.proposal && b.proposal
+            ? a.proposal.method.localeCompare(b.proposal.method)
+            : a.proposal
+              ? -1
+              : 1
+        );
+      const isApproval = approvalIds.some((approvalId) => approvalId.eq(id));
+      const derived = { council, id, proposal: allProposals[index].unwrap() };
+
+      if (isApproval) {
+        approvals.push(derived);
+      } else {
+        proposals.push(derived);
+      }
+    }
+  });
+
+  return { approvals, proposalCount, proposals };
+}
+
+function retrieveProposals (api: DeriveApi, proposalCount: ProposalIndex, approvalIds: ProposalIndex[]): Observable<DeriveTreasuryProposals> {
+  const proposalIds: ProposalIndex[] = [];
+  const count = proposalCount.toNumber();
+
+  for (let index = 0; index < count; index++) {
+    if (!approvalIds.some((id) => id.eqn(index))) {
+      proposalIds.push(api.registry.createType('ProposalIndex', index));
+    }
+  }
+
+  const allIds = [...proposalIds, ...approvalIds];
+
+  return combineLatest([
+    api.query.treasury.proposals.multi(allIds),
+    api.derive.council
+      ? api.derive.council.proposals()
+      : of([] as DeriveCollectiveProposal[])
+  ]).pipe(
+    map(([allProposals, councilProposals]): DeriveTreasuryProposals =>
+      parseResult(api, { allIds, allProposals, approvalIds, councilProposals, proposalCount })
+    )
+  );
+}
+
+/**
+ * @name proposals
+ * @description Retrieve all active and approved treasury proposals, along with their info.
+ * @example
+ * ```javascript
+ * const treasuryProposals = await api.derive.treasury.proposals();
+ * console.log(treasuryProposals);
+ * ```
+ */
+export function proposals (instanceId: string, api: DeriveApi): () => Observable<DeriveTreasuryProposals> {
+  return memo(instanceId, (): Observable<DeriveTreasuryProposals> =>
+    api.query.treasury
+      ? combineLatest([
+        api.query.treasury.proposalCount(),
+        api.query.treasury.approvals()
+      ]).pipe(
+        switchMap(([proposalCount, approvalIds]) =>
+          retrieveProposals(api, proposalCount, approvalIds)
+        )
+      )
+      : of({
+        approvals: [],
+        proposalCount: api.registry.createType('ProposalIndex'),
+        proposals: []
+      } as DeriveTreasuryProposals)
+  );
+}

package/src/tx/constants.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BN } from '@pezkuwi/util';
+
+export const FALLBACK_MAX_HASH_COUNT = 250;
+
+// default here to 5 min eras, adjusted based on the actual blocktime
+export const FALLBACK_PERIOD = new BN(6 * 1000);
+
+export const MAX_FINALITY_LAG = new BN(5);
+
+export const MORTAL_PERIOD = new BN(5 * 60 * 1000);

package/src/tx/events.ts

@@ -0,0 +1,43 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { EventRecord, Hash, SignedBlock } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+
+import { combineLatest, map, switchMap } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+interface Result {
+  block: SignedBlock;
+  events: EventRecord[];
+}
+
+/**
+ * @name events
+ * @param {Hash} at Block hash to query at.
+ * @description Retrieves the block information alongside its events at a given block hash
+ * @example
+ * ```javascript
+ * const blockHash = api.registry.createType(
+ *   "Hash",
+ *   "0xf1dc2efe8265be67deea5e91b05a98a7f9f81f66854e92825cf36f541beb7af6"
+ * );
+ * const { events, block } = await api.derive.tx.events(blockHash);
+ * ```
+ */
+export function events (instanceId: string, api: DeriveApi): (at: Hash) => Observable<Result> {
+  return memo(instanceId, (blockHash: Hash) =>
+    combineLatest([
+      api.rpc.chain.getBlock(blockHash),
+      api.queryAt(blockHash).pipe(
+        switchMap((queryAt) =>
+          queryAt.system.events()
+        )
+      )
+    ]).pipe(
+      map(([block, events]) => ({ block, events }))
+    )
+  );
+}

package/src/tx/extrinsicInfo.ts

@@ -0,0 +1,123 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { GenericExtrinsic } from '@pezkuwi/types';
+import type { EventRecord, Hash } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+
+import { map } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+interface ExtrinsicInfo {
+  blockHash: Hash | string,
+  blockNumber: number,
+  extrinsic: GenericExtrinsic,
+  events: EventRecord[]
+  success: boolean
+}
+
+interface ExtrinsicsInfo {
+  blockHash: Hash | string,
+  blockNumber: number,
+  extrinsics: {
+    events: EventRecord[]
+    extrinsic: GenericExtrinsic,
+    success: boolean
+  }[],
+}
+
+/**
+ * @name extrinsicInfo
+ * @param { Hash } at The block hash to query at.
+ * @param { Uint8Array | string } transactionHash A transaction hash as U8 array or string.
+ * @description Retrieves the extrinsic information and its events.
+ * @example
+ * ```javascript
+ * const blockHash = api.registry.createType(
+ *   'Hash',
+ *   '0xb772e4949d2f3eb5ba356aa43f885cc4f9097ee9812c5436543f3846a0491729'
+ * );
+ * const extrinsicInfo = await api.derive.tx.extrinsicInfo(
+ *   blockHash,
+ *   '0xcd96520b05e0c4648ea365f3f063f27c5cdd8be10d41a1c44566428c91f37dcb'
+ * );
+ *
+ * console.log(extrinsicInfo.extrinsic.toHuman());
+ * ```
+ */
+export function extrinsicInfo (instanceId: string, api: DeriveApi): (at: Hash, transactionHash: Uint8Array | string) => Observable<ExtrinsicInfo | null> {
+  return memo(instanceId, (at: Hash, transactionHash: Uint8Array | string): Observable<ExtrinsicInfo | null> => {
+    return api.derive.tx.events(at).pipe(map(({ block, events }) => {
+      const index = block.block.extrinsics.findIndex((ext) => ext.hash.toString() === transactionHash);
+
+      if (index === -1) {
+        return null;
+      }
+
+      const extEvents = events.filter(
+        ({ phase }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(index)
+      );
+
+      return {
+        blockHash: block.hash.toHex(),
+        blockNumber: block.block.header.number.toNumber(),
+        events: extEvents,
+        extrinsic: block.block.extrinsics[index],
+        success: (extEvents.findIndex((ev) => ev.event.method === 'ExtrinsicSuccess') !== -1)
+      };
+    }));
+  });
+}
+
+/**
+ * @name accountExtrinsics
+ * @description Retrieves information about every extrinsic submitted by an account at a given block.
+ * @param { Hash } at The block hash to query at.
+ * @param { Uint8Array | strings } accountId The account identifier to query.
+ * @example
+ * ```javascript
+   const blockHash = api.registry.createType(
+    'Hash',
+    '0xb772e4949d2f3eb5ba356aa43f885cc4f9097ee9812c5436543f3846a0491729'
+  );
+  const extrinsicsInfo = await api.derive.tx.accountExtrinsics(
+    blockHash,
+    '0x21895DdfD4640b4e0aDCa2865b907f2CE6e6B777'
+  );
+
+  console.log(extrinsicsInfo.extrinsics[0]).extrinsic.toHuman();
+ * ```
+ */
+export function accountExtrinsics (instanceId: string, api: DeriveApi): (at: Hash, accountId: Uint8Array | string) => Observable<ExtrinsicsInfo> {
+  return memo(instanceId, (at: Hash, accountId: Uint8Array | string): Observable<ExtrinsicsInfo> => {
+    return api.derive.tx.events(at).pipe(map(({ block, events }) => {
+      const indexes: number[] = [];
+
+      return {
+        blockHash: block.hash.toHex(),
+        blockNumber: block.block.header.number.toNumber(),
+        extrinsics: block.block.extrinsics.filter((ext, index) => {
+          if (ext.signer.toString() === accountId) {
+            indexes.push(index);
+
+            return true;
+          }
+
+          return false;
+        }).map((ext, i) => {
+          const extEvents = events.filter(
+            ({ phase }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(indexes[i])
+          );
+
+          return {
+            events: extEvents,
+            extrinsic: ext,
+            success: (extEvents.findIndex((ev) => ev.event.method === 'ExtrinsicSuccess') !== -1)
+          };
+        })
+      };
+    }));
+  });
+}

package/src/tx/index.ts

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