@pezkuwi/api-derive 16.5.5 → 16.5.6

package/src/bundle.ts

@@ -1,140 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { DeriveCustom } from '@pezkuwi/api-base/types';
-import type { AnyFunction, AnyString } from '@pezkuwi/types/types';
-import type { ExactDerive } from './derive.js';
-import type { DeriveApi } from './types.js';
-
-import { lazyDeriveSection } from './util/index.js';
-import { derive } from './derive.js';
-
-export * from './derive.js';
-export * from './type/index.js';
-
-interface Avail {
-  instances: string[];
-  methods: string[];
-  withDetect?: boolean;
-}
-
-export { lazyDeriveSection };
-
-// Enable derive only if some of these modules are available
-const checks: Record<string, Avail> = {
-  allianceMotion: {
-    instances: ['allianceMotion'],
-    methods: []
-  },
-  bagsList: {
-    instances: ['voterBagsList', 'voterList', 'bagsList'],
-    methods: [],
-    withDetect: true
-  },
-  contracts: {
-    instances: ['contracts'],
-    methods: []
-  },
-  council: {
-    instances: ['council'],
-    methods: [],
-    withDetect: true
-  },
-  crowdloan: {
-    instances: ['crowdloan'],
-    methods: []
-  },
-  democracy: {
-    instances: ['democracy'],
-    methods: []
-  },
-  elections: {
-    instances: ['phragmenElection', 'electionsPhragmen', 'elections', 'council'],
-    methods: [],
-    withDetect: true
-  },
-  imOnline: {
-    instances: ['imOnline'],
-    methods: []
-  },
-  membership: {
-    instances: ['membership'],
-    methods: []
-  },
-  parachains: {
-    instances: ['parachains', 'registrar'],
-    methods: []
-  },
-  session: {
-    instances: ['session'],
-    methods: []
-  },
-  society: {
-    instances: ['society'],
-    methods: []
-  },
-  staking: {
-    instances: ['staking'],
-    methods: ['erasRewardPoints']
-  },
-  technicalCommittee: {
-    instances: ['technicalCommittee'],
-    methods: [],
-    withDetect: true
-  },
-  treasury: {
-    instances: ['treasury'],
-    methods: []
-  }
-};
-
-function getModuleInstances (api: DeriveApi, specName: AnyString, moduleName: string): string[] {
-  return api.registry.getModuleInstances(specName, moduleName) || [];
-}
-
-/**
- * Returns an object that will inject `api` into all the functions inside
- * `allSections`, and keep the object architecture of `allSections`.
- */
-/** @internal */
-function injectFunctions (instanceId: string, api: DeriveApi, derives: DeriveCustom): ExactDerive {
-  const result: Record<string, Record<string, AnyFunction>> = {};
-  const names = Object.keys(derives);
-  const keys = Object.keys(api.query);
-  const specName = api.runtimeVersion.specName;
-
-  const filterKeys = (q: string) => keys.includes(q);
-  const filterInstances = (q: string) => getModuleInstances(api, specName, q).some(filterKeys);
-  const filterMethods = (all: string[]) => (m: string) => all.some((q) => keys.includes(q) && api.query[q][m]);
-  const getKeys = (s: string) => Object.keys(derives[s]);
-  const creator = (s: string, m: string) => derives[s][m](instanceId, api);
-  const isIncluded = (c: string) => (!checks[c] || (
-    (checks[c].instances.some(filterKeys) && (
-      !checks[c].methods.length ||
-      checks[c].methods.every(filterMethods(checks[c].instances))
-    )) ||
-    (
-      checks[c].withDetect &&
-      checks[c].instances.some(filterInstances)
-    )
-  ));
-
-  for (let i = 0, count = names.length; i < count; i++) {
-    const name = names[i];
-
-    isIncluded(name) &&
-      lazyDeriveSection(result, name, getKeys, creator);
-  }
-
-  return result as ExactDerive;
-}
-
-// FIXME The return type of this function should be {...ExactDerive, ...DeriveCustom}
-// For now we just drop the custom derive typings
-/** @internal */
-export function getAvailableDerives (instanceId: string, api: DeriveApi, custom: DeriveCustom = {}): ExactDerive {
-  return {
-    ...injectFunctions(instanceId, api, derive as DeriveCustom),
-    ...injectFunctions(instanceId, api, custom)
-  };
-}

package/src/chain/bestNumberLag.ts

@@ -1,33 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { BlockNumber } from '@pezkuwi/types/interfaces';
-import type { DeriveApi } from '../types.js';
-
-import { combineLatest, map } from 'rxjs';
-
-import { memo } from '../util/index.js';
-
-/**
- * @name bestNumberLag
- * @returns A number of blocks
- * @description Calculates the lag between finalized head and best head
- * @examplew
- * ```javascript
- * api.derive.chain.bestNumberLag((lag) => {
- *   console.log(`finalized is ${lag} blocks behind head`);
- * });
- * ```
- */
-export function bestNumberLag (instanceId: string, api: DeriveApi): () => Observable<BlockNumber> {
-  return memo(instanceId, (): Observable<BlockNumber> =>
-    combineLatest([
-      api.derive.chain.bestNumber(),
-      api.derive.chain.bestNumberFinalized()
-    ]).pipe(
-      map(([bestNumber, bestNumberFinalized]): BlockNumber =>
-        api.registry.createType('BlockNumber', bestNumber.sub(bestNumberFinalized))
-      )
-    ));
-}

package/src/chain/getBlock.ts

@@ -1,43 +0,0 @@
-// 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 { combineLatest, map, of, switchMap } from 'rxjs';
-
-import { createSignedBlockExtended } from '../type/index.js';
-import { memo } from '../util/index.js';
-import { getAuthorDetails } from './util.js';
-
-/**
- * @name getBlock
- * @param {( Uint8Array | string )} hash A block hash as U8 array or string.
- * @description Get a specific block (e.g. rpc.chain.getBlock) and extend it with the author
- * @example
- * ```javascript
- * const { author, block } = await api.derive.chain.getBlock('0x123...456');
- *
- * console.log(`block #${block.header.number} was authored by ${author}`);
- * ```
- */
-export function getBlock (instanceId: string, api: DeriveApi): (hash: Uint8Array | string) => Observable<SignedBlockExtended> {
-  return memo(instanceId, (blockHash: Uint8Array | string): Observable<SignedBlockExtended> =>
-    combineLatest([
-      api.rpc.chain.getBlock(blockHash),
-      api.queryAt(blockHash)
-    ]).pipe(
-      switchMap(([signedBlock, queryAt]) =>
-        combineLatest([
-          of(signedBlock),
-          queryAt.system.events(),
-          getAuthorDetails(api, signedBlock.block.header, blockHash)
-        ])
-      ),
-      map(([signedBlock, events, [, validators, author]]) =>
-        createSignedBlockExtended(events.registry, signedBlock, events, validators, author)
-      )
-    )
-  );
-}

package/src/chain/getHeader.ts

@@ -1,37 +0,0 @@
-// 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, switchMap } from 'rxjs';
-
-import { createHeaderExtended } from '../type/index.js';
-import { memo } from '../util/index.js';
-import { getAuthorDetails } from './util.js';
-
-/**
- * @name getHeader
- * @param {( Uint8Array | string )} hash - A block hash as U8 array or string.
- * @returns An array containing the block header and the block author
- * @description Get a specific block header and extend it with the author
- * @example
- * ```javascript
- * const { author, number } = await api.derive.chain.getHeader('0x123...456');
- *
- * console.log(`block #${number} was authored by ${author}`);
- * ```
- */
-export function getHeader (instanceId: string, api: DeriveApi): (blockHash: Uint8Array | string) => Observable<HeaderExtended> {
-  return memo(instanceId, (blockHash: Uint8Array | string): Observable<HeaderExtended> =>
-    api.rpc.chain.getHeader(blockHash).pipe(
-      switchMap((header) =>
-        getAuthorDetails(api, header, blockHash)
-      ),
-      map(([header, validators, author]) =>
-        createHeaderExtended((validators || header).registry, header, validators, author)
-      )
-    )
-  );
-}

package/src/chain/subscribeFinalizedBlocks.ts

@@ -1,30 +0,0 @@
-// 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 subscribeFinalizedBlocks
- * @description Retrieves the finalized block & events for that block
- * @example
- * ```javascript
- * const unsub = await api.derive.chain.subscribeFinalizedBlocks((finalizedBlock) => {
- *  console.log(`# Finalized block ${finalizedBlock.block.hash}`);
- * });
- * ```
- */
-export function subscribeFinalizedBlocks (instanceId: string, api: DeriveApi): () => Observable<SignedBlockExtended> {
-  return memo(instanceId, (): Observable<SignedBlockExtended> =>
-    api.derive.chain.subscribeFinalizedHeads().pipe(
-      mergeMap((header) =>
-        api.derive.chain.getBlock(header.createdAtHash || header.hash)
-      )
-    )
-  );
-}

package/src/chain/subscribeFinalizedHeads.ts

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

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

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

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

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

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

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

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

@@ -1,25 +0,0 @@
-// 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)
-  );
-}