@pezkuwi/api-derive 16.5.17 → 16.5.19

package/src/bundle.ts

@@ -0,0 +1,140 @@
+// Copyright 2017-2025 @pezkuwi/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: []
+  },
+  teyrchains: {
+    instances: ['teyrchains', '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/bestNumber.ts

@@ -0,0 +1,21 @@
+// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DeriveApi } from '../types.js';
+
+import { createBlockNumberDerive } from './util.js';
+
+/**
+ * @name bestNumber
+ * @descrive Retrieves the latest block number.
+ * @example
+ * ```javascript
+ * api.derive.chain.bestNumber((blockNumber) => {
+ *   console.log(`the current best block is #${blockNumber}`);
+ * });
+ * ```
+ */
+export const bestNumber = /*#__PURE__*/ createBlockNumberDerive(
+  (api: DeriveApi) =>
+    api.rpc.chain.subscribeNewHeads()
+);

package/src/chain/bestNumberFinalized.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DeriveApi } from '../types.js';
+
+import { createBlockNumberDerive } from './util.js';
+
+/**
+ * @name bestNumberFinalized
+ * @returns A BlockNumber
+ * @description Get the latest finalized block number.
+ * @example
+ * ```javascript
+ * api.derive.chain.bestNumberFinalized((blockNumber) => {
+ *   console.log(`the current finalized block is #${blockNumber}`);
+ * });
+ * ```
+ */
+export const bestNumberFinalized = /*#__PURE__*/ createBlockNumberDerive(
+  (api: DeriveApi) =>
+    api.rpc.chain.subscribeFinalizedHeads()
+);

package/src/chain/bestNumberLag.ts

@@ -0,0 +1,33 @@
+// Copyright 2017-2025 @pezkuwi/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

@@ -0,0 +1,43 @@
+// Copyright 2017-2025 @pezkuwi/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/getBlockByNumber.ts

@@ -0,0 +1,30 @@
+// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { AnyNumber } from '@pezkuwi/types/types';
+import type { SignedBlockExtended } from '../type/types.js';
+import type { DeriveApi } from '../types.js';
+
+import { switchMap } from 'rxjs';
+
+import { memo } from '../util/index.js';
+
+/**
+ * @name getBlockByNumber
+ * @param {( BN | bigint | Uint8Array | number | string )} blockNumber
+ * @description Get a specific block (e.g. rpc.chain.getBlock) and extend it with the author by block number
+ * @example
+ * ```javascript
+ * const { author, block } = await api.derive.chain.getBlockByNumber(123);
+ *
+ * console.log(`block #${block.header.number} was authored by ${author}`);
+ * ```
+ */
+export function getBlockByNumber (instanceId: string, api: DeriveApi): (blockNumber: AnyNumber) => Observable<SignedBlockExtended> {
+  return memo(instanceId, (blockNumber: AnyNumber): Observable<SignedBlockExtended> =>
+    api.rpc.chain.getBlockHash(blockNumber).pipe(
+      switchMap((h) => api.derive.chain.getBlock(h))
+    )
+  );
+}

package/src/chain/getHeader.ts

@@ -0,0 +1,37 @@
+// Copyright 2017-2025 @pezkuwi/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/index.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './bestNumber.js';
+export * from './bestNumberFinalized.js';
+export * from './bestNumberLag.js';
+export * from './getBlock.js';
+export * from './getBlockByNumber.js';
+export * from './getHeader.js';
+export * from './subscribeFinalizedBlocks.js';
+export * from './subscribeFinalizedHeads.js';
+export * from './subscribeNewBlocks.js';
+export * from './subscribeNewHeads.js';

package/src/chain/subscribeFinalizedBlocks.ts

@@ -0,0 +1,30 @@
+// Copyright 2017-2025 @pezkuwi/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 { switchMap } 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(
+      switchMap((header) =>
+        api.derive.chain.getBlock(header.createdAtHash || header.hash)
+      )
+    )
+  );
+}

package/src/chain/subscribeFinalizedHeads.ts

@@ -0,0 +1,63 @@
+// Copyright 2017-2025 @pezkuwi/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, 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(
+      switchMap((header) => {
+        const endHash = prevHash;
+        const startHash = header.parentHash;
+
+        header.createdAtHash = header.hash as unknown as typeof header.createdAtHash;
+        prevHash = header.hash as unknown as 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 @pezkuwi/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 { switchMap } 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(
+      switchMap((header) =>
+        api.derive.chain.getBlock(header.createdAtHash || header.hash)
+      )
+    )
+  );
+}

package/src/chain/subscribeNewHeads.ts

@@ -0,0 +1,38 @@
+// Copyright 2017-2025 @pezkuwi/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 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(
+      switchMap((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 @pezkuwi/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 { PezpalletImOnlineSr25519AppSr25519Public } 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: PezpalletImOnlineSr25519AppSr25519Public } & 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 teyrchain staking pallets, if available (ie: manta, calamari), to map session (nimbus) key to author (collator) key
+    if (queryAt['teyrchainStaking']?.['selectedCandidates'] && queryAt.session?.nextKeys) {
+      const loggedHex = loggedAuthor.toHex();
+
+      return combineLatest([
+        of(header),
+        validators,
+        queryAt['teyrchainStaking']['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 @pezkuwi/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 @pezkuwi/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 @pezkuwi/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './members.js';
+export * from './prime.js';
+export * from './proposals.js';