@pezkuwi/api-derive 16.5.5

package/src/chain/subscribeFinalizedHeads.ts

@@ -0,0 +1,62 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { Hash, Header } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.js';
+
+import { from, mergeMap, of, switchMap } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+/**
+ * Returns a header range from startHash to to (not including) endHash, i.e. lastBlock.parentHash === endHash
+ */
+export function _getHeaderRange (instanceId: string, api: DeriveApi): (startHash: Hash, endHash: Hash, prev?: Header[]) => Observable<Header[]> {
+  return memo(instanceId, (startHash: Hash, endHash: Hash, prev: Header[] = []): Observable<Header[]> =>
+    api.rpc.chain.getHeader(startHash).pipe(
+      switchMap((header) =>
+        header.parentHash.eq(endHash)
+          ? of([header, ...prev])
+          : api.derive.chain._getHeaderRange(header.parentHash, endHash, [header, ...prev])
+      )
+    )
+  );
+}
+
+/**
+ * @name subscribeFinalizedHeads
+ * @description An observable of the finalized block headers. Unlike the base
+ * chain.subscribeFinalizedHeads this does not skip any headers. Since finalization
+ * may skip specific blocks (finalization happens in terms of chains), this version
+ * of the derive tracks missing headers (since last retrieved) and provides them
+ * to the caller.
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeFinalizedHeads((finalizedHead) => {
+ *   console.log(`${finalizedHead.hash}`);
+ * });
+ * ```
+ */
+export function subscribeFinalizedHeads (instanceId: string, api: DeriveApi): () => Observable<Header> {
+  return memo(instanceId, (): Observable<Header> => {
+    let prevHash: Hash | null = null;
+
+    return api.rpc.chain.subscribeFinalizedHeads().pipe(
+      mergeMap((header) => {
+        const endHash = prevHash;
+        const startHash = header.parentHash;
+
+        prevHash = header.createdAtHash = header.hash;
+
+        return endHash === null || startHash.eq(endHash)
+          ? of(header)
+          : api.derive.chain._getHeaderRange(startHash, endHash, [header]).pipe(
+            switchMap((headers) =>
+              from(headers)
+            )
+          );
+      })
+    );
+  });
+}

package/src/chain/subscribeNewBlocks.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 { SignedBlockExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+
+import { mergeMap } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+/**
+ * @name subscribeNewBlocks
+ * @returns The latest block & events for that block
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeNewBlocks((newBlock) => {
+ *   console.log(`Block Hash: ${newBlock.hash}`);
+ * });
+ * ```
+ */
+export function subscribeNewBlocks (instanceId: string, api: DeriveApi): () => Observable<SignedBlockExtended> {
+  return memo(instanceId, (): Observable<SignedBlockExtended> =>
+    api.derive.chain.subscribeNewHeads().pipe(
+      mergeMap((header) =>
+        api.derive.chain.getBlock(header.createdAtHash || header.hash)
+      )
+    )
+  );
+}

package/src/chain/subscribeNewHeads.ts

@@ -0,0 +1,38 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { HeaderExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+
+import { map, mergeMap } from 'rxjs';
+
+import { createHeaderExtended } from '../type/index.js';
+import { memo } from '../util/index.js';
+import { getAuthorDetails } from './util.js';
+
+/**
+ * @name subscribeNewHeads
+ * @returns A header with the current header (including extracted author).
+ * @description An observable of the current block header and it's author.
+ * @example
+ * ```javascript
+ * api.derive.chain.subscribeNewHeads((header) => {
+ *   console.log(`block #${header.number} was authored by ${header.author}`);
+ * });
+ * ```
+ */
+export function subscribeNewHeads (instanceId: string, api: DeriveApi): () => Observable<HeaderExtended> {
+  return memo(instanceId, (): Observable<HeaderExtended> =>
+    api.rpc.chain.subscribeNewHeads().pipe(
+      mergeMap((header) =>
+        getAuthorDetails(api, header)
+      ),
+      map(([header, validators, author]): HeaderExtended => {
+        header.createdAtHash = header.hash;
+
+        return createHeaderExtended(header.registry, header, validators, author);
+      })
+    )
+  );
+}

package/src/chain/util.ts

@@ -0,0 +1,112 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { QueryableStorage } from '@pezkuwi/api-base/types';
+import type { Compact, Vec } from '@pezkuwi/types';
+import type { AccountId, BlockNumber, Header } from '@pezkuwi/types/interfaces';
+import type { PalletImOnlineSr25519AppSr25519Public } from '@pezkuwi/types/lookup';
+import type { Codec, IOption } from '@pezkuwi/types/types';
+import type { DeriveApi } from '../types.js';
+
+import { combineLatest, map, mergeMap, of, switchMap } from 'rxjs';
+
+import { memo, unwrapBlockNumber } from '../util/index.js';
+
+export type BlockNumberDerive = (instanceId: string, api: DeriveApi) => () => Observable<BlockNumber>;
+
+type OptionMapping = IOption<{ account: AccountId } & Codec>;
+type OptionNimbus = IOption<{ nimbus: PalletImOnlineSr25519AppSr25519Public } & Codec>;
+
+export function createBlockNumberDerive <T extends { number: Compact<BlockNumber> | BlockNumber }> (fn: (api: DeriveApi) => Observable<T>): BlockNumberDerive {
+  return (instanceId: string, api: DeriveApi) =>
+    memo(instanceId, () =>
+      fn(api).pipe(
+        map(unwrapBlockNumber)
+      )
+    );
+}
+
+/** @internal */
+function getAuthorDetailsWithAt (header: Header, queryAt: QueryableStorage<'rxjs'>): Observable<[Header, Vec<AccountId> | null, AccountId | null]> {
+  const validators = queryAt.session?.validators
+    ? queryAt.session.validators()
+    : of(null);
+
+  // nimbus consensus stores the session key of the block author in header logs
+  const { logs: [log] } = header.digest;
+  const loggedAuthor = (log && (
+    (log.isConsensus && log.asConsensus[0].isNimbus && log.asConsensus[1]) ||
+    (log.isPreRuntime && log.asPreRuntime[0].isNimbus && log.asPreRuntime[1])
+  ));
+
+  if (loggedAuthor) {
+    // use the author mapping pallet, if available (ie: moonbeam, moonriver), to map session (nimbus) key to author (collator/validator) key
+    if (queryAt['authorMapping']?.['mappingWithDeposit']) {
+      return combineLatest([
+        of(header),
+        validators,
+        queryAt['authorMapping']['mappingWithDeposit']<OptionMapping>(loggedAuthor).pipe(
+          map((o) =>
+            o.unwrapOr({ account: null }).account
+          )
+        )
+      ]);
+    }
+
+    // fall back to session and parachain staking pallets, if available (ie: manta, calamari), to map session (nimbus) key to author (collator) key
+    if (queryAt['parachainStaking']?.['selectedCandidates'] && queryAt.session?.nextKeys) {
+      const loggedHex = loggedAuthor.toHex();
+
+      return combineLatest([
+        of(header),
+        validators,
+        queryAt['parachainStaking']['selectedCandidates']<Vec<AccountId>>().pipe(
+          mergeMap((selectedCandidates) =>
+            combineLatest([
+              of(selectedCandidates),
+              queryAt.session.nextKeys.multi<OptionNimbus>(selectedCandidates).pipe(
+                map((nextKeys) =>
+                  nextKeys.findIndex((o) =>
+                    o.unwrapOrDefault().nimbus.toHex() === loggedHex
+                  )
+                )
+              )
+            ])
+          ),
+          map(([selectedCandidates, index]) =>
+            index === -1
+              ? null
+              : selectedCandidates[index]
+          )
+        )
+      ]);
+    }
+  }
+
+  // normal operation, non-mapping
+  return combineLatest([
+    of(header),
+    validators,
+    of(null)
+  ]);
+}
+
+export function getAuthorDetails (api: DeriveApi, header: Header, blockHash?: Uint8Array | string): Observable<[Header, Vec<AccountId> | null, AccountId | null]> {
+  // For on-chain state, we need to retrieve it as per the start
+  // of the block being constructed, i.e. session validators would
+  // be at the point of the block construction, not when all operations
+  // has been supplied.
+  //
+  // However for the first block (no parentHash available), we would
+  // just use the as-is
+  return api.queryAt(
+    header.parentHash.isEmpty
+      ? blockHash || header.hash
+      : header.parentHash
+  ).pipe(
+    switchMap((queryAt) =>
+      getAuthorDetailsWithAt(header, queryAt)
+    )
+  );
+}

package/src/checkTypes.manual.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import '@pezkuwi/api-augment';
+
+import { derive } from './index.js';
+
+console.log(derive.chain.bestNumber);

package/src/collective/helpers.ts

@@ -0,0 +1,36 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { DeriveApi } from '../types.js';
+import type { Collective } from './types.js';
+
+import { of } from 'rxjs';
+
+import { isFunction } from '@pezkuwi/util';
+
+import { memo } from '../util/index.js';
+
+export function getInstance (api: DeriveApi, section: string): DeriveApi['query']['council'] {
+  const instances = api.registry.getModuleInstances(api.runtimeVersion.specName, section);
+  const name = instances?.length
+    ? instances[0]
+    : section;
+
+  return api.query[name as 'council'];
+}
+
+export function withSection <T, F extends (...args: any[]) => Observable<T>> (section: Collective, fn: (query: DeriveApi['query']['council'], api: DeriveApi, instanceId: string) => F): (instanceId: string, api: DeriveApi) => F {
+  return (instanceId: string, api: DeriveApi) =>
+    memo(instanceId, fn(getInstance(api, section), api, instanceId)) as unknown as F;
+}
+
+export function callMethod <T> (method: 'members' | 'proposals' | 'proposalCount', empty: T): (section: Collective) => (instanceId: string, api: DeriveApi) => () => Observable<T> {
+  return (section: Collective) =>
+    withSection(section, (query) =>
+      (): Observable<T> =>
+        isFunction(query?.[method])
+          ? query[method]() as unknown as Observable<T>
+          : of(empty)
+    );
+}

package/src/collective/index.ts

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

package/src/collective/members.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { MembersFn } from './types.js';
+
+import { callMethod } from './helpers.js';
+
+export const members: MembersFn = /*#__PURE__*/ callMethod('members', []);

package/src/collective/prime.ts

@@ -0,0 +1,25 @@
+// 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 { Collective, PrimeFnRet } from './types.js';
+
+import { map, of } from 'rxjs';
+
+import { isFunction } from '@pezkuwi/util';
+
+import { withSection } from './helpers.js';
+
+export function prime (section: Collective): PrimeFnRet {
+  return withSection(section, (query) =>
+    (): Observable<AccountId | null> =>
+      isFunction(query?.prime)
+        ? query.prime().pipe(
+          map((o): AccountId | null =>
+            o.unwrapOr(null)
+          )
+        )
+        : of(null)
+  );
+}

package/src/collective/proposals.ts

@@ -0,0 +1,73 @@
+// 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 { Hash, Proposal, Votes } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveCollectiveProposal } from '../types.js';
+import type { Collective, HasProposalsFnRet, ProposalCountFn, ProposalFnRet, ProposalHashesFn, ProposalsFnRet } from './types.js';
+
+import { catchError, combineLatest, map, of, switchMap } from 'rxjs';
+
+import { isFunction } from '@pezkuwi/util';
+
+import { firstObservable } from '../util/index.js';
+import { callMethod, withSection } from './helpers.js';
+
+type Result = [(Hash | Uint8Array | string)[], (Option<Proposal> | null)[], Option<Votes>[]];
+
+function parse (api: DeriveApi, [hashes, proposals, votes]: Result): DeriveCollectiveProposal[] {
+  return proposals.map((o, index): DeriveCollectiveProposal => ({
+    hash: api.registry.createType('Hash', hashes[index]),
+    proposal: o && o.isSome
+      ? o.unwrap()
+      : null,
+    votes: votes[index].unwrapOr(null)
+  }));
+}
+
+function _proposalsFrom (api: DeriveApi, query: DeriveApi['query']['council'], hashes: (Hash | Uint8Array | string)[]): Observable<DeriveCollectiveProposal[]> {
+  return (isFunction(query?.proposals) && hashes.length
+    ? combineLatest([
+      of(hashes),
+      // this should simply be api.query[section].proposalOf.multi<Option<Proposal>>(hashes),
+      // however we have had cases on Edgeware where the indices have moved around after an
+      // upgrade, which results in invalid on-chain data
+      query.proposalOf.multi<Option<Proposal>>(hashes).pipe(
+        catchError(() => of(hashes.map(() => null)))
+      ),
+      query.voting.multi<Option<Votes>>(hashes)
+    ])
+    : of<Result>([[], [], []])
+  ).pipe(
+    map((r) => parse(api, r))
+  );
+}
+
+export function hasProposals (section: Collective): HasProposalsFnRet {
+  return withSection(section, (query) =>
+    (): Observable<boolean> =>
+      of(isFunction(query?.proposals))
+  );
+}
+
+export function proposals (section: Collective): ProposalsFnRet {
+  return withSection(section, (query, api) =>
+    (): Observable<DeriveCollectiveProposal[]> =>
+      api.derive[section as 'council'].proposalHashes().pipe(
+        switchMap((all) => _proposalsFrom(api, query, all))
+      )
+  );
+}
+
+export function proposal (section: Collective): ProposalFnRet {
+  return withSection(section, (query, api) =>
+    (hash: Hash | Uint8Array | string): Observable<DeriveCollectiveProposal | null> =>
+      isFunction(query?.proposals)
+        ? firstObservable(_proposalsFrom(api, query, [hash]))
+        : of(null)
+  );
+}
+
+export const proposalCount: ProposalCountFn = /*#__PURE__*/ callMethod('proposalCount', null);
+export const proposalHashes: ProposalHashesFn = /*#__PURE__*/ callMethod('proposals', []);

package/src/collective/types.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 { u32 } from '@pezkuwi/types';
+import type { AccountId, Hash } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveCollectiveProposal } from '../types.js';
+
+export type Collective = 'allianceMotion' | 'council' | 'membership' | 'technicalCommittee';
+
+export type HasProposalsFnRet = (instanceId: string, api: DeriveApi) => () => Observable<boolean>;
+export type HasProposalsFn = (section: Collective) => HasProposalsFnRet;
+
+export type MembersFnRet = (instanceId: string, api: DeriveApi) => () => Observable<AccountId[]>;
+export type MembersFn = (section: Collective) => MembersFnRet;
+
+export type PrimeFnRet = (instanceId: string, api: DeriveApi) => () => Observable<AccountId | null>;
+export type PrimeFn = (section: Collective) => PrimeFnRet;
+
+export type ProposalFnRet = (instanceId: string, api: DeriveApi) => (hash: Hash | Uint8Array | string) => Observable<DeriveCollectiveProposal | null>;
+export type ProposalFn = (section: Collective) => ProposalFnRet;
+
+export type ProposalsFnRet = (instanceId: string, api: DeriveApi) => () => Observable<DeriveCollectiveProposal[]>;
+export type ProposalsFn = (section: Collective) => ProposalsFnRet;
+
+export type ProposalCountFnRet = (instanceId: string, api: DeriveApi) => () => Observable<u32 | null>;
+export type ProposalCountFn = (section: Collective) => ProposalCountFnRet;
+
+export type ProposalHashesFnRet = (instanceId: string, api: DeriveApi) => () => Observable<Hash[]>;
+export type ProposalHashesFn = (section: Collective) => ProposalHashesFnRet;

package/src/contracts/fees.ts

@@ -0,0 +1,61 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi, DeriveContractFees } from '../types.js';
+
+import { map, of } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+type ResultV2 = [BN, BN, BN, BN, BN, BN, BN, BN, BN, BN];
+
+// query via constants (current applicable path)
+function queryConstants (api: DeriveApi): Observable<ResultV2> {
+  return of([
+    // deprecated
+    api.consts.contracts['callBaseFee'] || api.registry.createType('Balance'),
+    api.consts.contracts['contractFee'] || api.registry.createType('Balance'),
+    api.consts.contracts['creationFee'] || api.registry.createType('Balance'),
+    api.consts.contracts['transactionBaseFee'] || api.registry.createType('Balance'),
+    api.consts.contracts['transactionByteFee'] || api.registry.createType('Balance'),
+    api.consts.contracts['transferFee'] || api.registry.createType('Balance'),
+
+    // current
+    api.consts.contracts['rentByteFee'] || api.registry.createType('Balance'),
+    api.consts.contracts['rentDepositOffset'] || api.registry.createType('Balance'),
+    api.consts.contracts['surchargeReward'] || api.registry.createType('Balance'),
+    api.consts.contracts['tombstoneDeposit'] || api.registry.createType('Balance')
+  ]) as unknown as Observable<ResultV2>;
+}
+
+/**
+ * @name fees
+ * @returns An object containing the combined results of the queries for
+ * all relevant contract fees as declared in the substrate chain spec.
+ * @example
+ * ```javascript
+ * api.derive.contracts.fees(([creationFee, transferFee]) => {
+ *   console.log(`The fee for creating a new contract on this chain is ${creationFee} units. The fee required to call this contract is ${transferFee} units.`);
+ * });
+ * ```
+ */
+export function fees (instanceId: string, api: DeriveApi): () => Observable<DeriveContractFees> {
+  return memo(instanceId, (): Observable<DeriveContractFees> => {
+    return queryConstants(api).pipe(
+      map(([callBaseFee, contractFee, creationFee, transactionBaseFee, transactionByteFee, transferFee, rentByteFee, rentDepositOffset, surchargeReward, tombstoneDeposit]): DeriveContractFees => ({
+        callBaseFee,
+        contractFee,
+        creationFee,
+        rentByteFee,
+        rentDepositOffset,
+        surchargeReward,
+        tombstoneDeposit,
+        transactionBaseFee,
+        transactionByteFee,
+        transferFee
+      }))
+    );
+  });
+}

package/src/contracts/index.ts

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

package/src/council/index.ts

@@ -0,0 +1,79 @@
+// 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';
+
+export * from './votes.js';
+export * from './votesOf.js';
+
+/**
+ * @name members
+ * @description Retrieves the list of members in the "council" collective.
+ * @example
+ * ```javascript
+ * const members = await api.derive.council.members();
+ * console.log(`Members: ${JSON.stringify(members)});
+ * ```
+ */
+export const members = /*#__PURE__*/ collectiveMembers('council');
+
+/**
+ * @name hasProposals
+ * @description Checks if there are any active proposals in the "council" collective.
+ * @example
+ * ```javascript
+ * const exists = await api.derive.council.hasProposals();
+ * console.log(exists);
+ * ```
+ */
+export const hasProposals = /*#__PURE__*/ collectiveHasProposals('council');
+/**
+ * @name proposal
+ * @description Retrieves details of a specific proposal in the "councilMotion" collective by its hash.
+ * @example
+ * ```javascript
+ * const proposalDetails = await api.derive.council.proposal(PROPOSAL_HASH);
+ * console.log(proposalDetails);
+ * ```
+ */
+export const proposal = /*#__PURE__*/ collectiveProposal('council');
+/**
+ * @name proposalCount
+ * @description Retrieves the total number of proposals in the "council" collective.
+ * @example
+ * ```javascript
+ * const count = await api.derive.council.proposalCount();
+ * console.log(`Amount of proposals: ${count}`);
+ * ```
+ */
+export const proposalCount = /*#__PURE__*/ collectiveProposalCount('council');
+/**
+ * @name proposalHashes
+ * @description Retrieves an array of hashes for all active proposals in the "council" collective.
+ * @example
+ * ```javascript
+ * const hashes = await api.derive.council.proposalHashes();
+ * console.log(`Proposals ${JSON.stringify(hashes)}`);
+ * ```
+ */
+export const proposalHashes = /*#__PURE__*/ collectiveProposalHashes('council');
+/**
+ * @name proposals
+ * @description Retrieves a list of all active proposals in the "council" collective.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.council.proposals();
+ * console.log(proposals);
+ * ```
+ */
+export const proposals = /*#__PURE__*/ collectiveProposals('council');
+/**
+ * @name prime
+ * @description Retrieves the prime member of the "council" collective, if one exists.
+ * @example
+ * ```javascript
+ * const primeMember = await api.derive.council.prime();
+ * console.log(primeMember);
+ * ```
+ */
+export const prime = /*#__PURE__*/ collectivePrime('council');

package/src/council/types.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2025 @polkadot/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AccountId, Balance } from '@pezkuwi/types/interfaces';
+
+export interface DeriveCouncilVote {
+  stake: Balance;
+  votes: AccountId[];
+}
+
+export type DeriveCouncilVotes = [AccountId, DeriveCouncilVote][];