@pezkuwi/api-derive 16.5.17 → 16.5.19

package/src/staking/validators.ts

@@ -0,0 +1,82 @@
+// Copyright 2017-2025 @pezkuwi/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 @pezkuwi/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 @pezkuwi/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 @pezkuwi/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 @pezkuwi/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 @pezkuwi/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-bizinikiwi';
+
+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 @pezkuwi/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/teyrchains/index.ts

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

package/src/teyrchains/info.ts

@@ -0,0 +1,111 @@
+// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Observable } from 'rxjs';
+import type { CollatorId, ParaId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveTeyrchainActive, DeriveTeyrchainFull, DeriveTeyrchainInfo } from '../types.js';
+import type { Active, DidUpdate, Heads, ParaInfoResult, PendingSwap, RelayDispatchQueue, RetryQueue, SelectedThreads } from './types.js';
+
+import { map, of } from 'rxjs';
+
+import { objectSpread } from '@pezkuwi/util';
+
+import { memo } from '../util/index.js';
+import { didUpdateToBool } from './util.js';
+
+type Result = [
+  Active,
+  RetryQueue,
+  SelectedThreads,
+  DidUpdate,
+  ParaInfoResult,
+  PendingSwap,
+  Heads,
+  RelayDispatchQueue
+];
+
+function parseActive (id: ParaId, active: Active): DeriveTeyrchainActive | null {
+  const found = active.find(([paraId]) => paraId === id);
+
+  if (found && found[1].isSome) {
+    const [collatorId, retriable] = found[1].unwrap();
+
+    return objectSpread<DeriveTeyrchainActive>(
+      { collatorId },
+      retriable.isWithRetries
+        ? {
+          isRetriable: true,
+          retries: retriable.asWithRetries.toNumber()
+        }
+        : {
+          isRetriable: false,
+          retries: 0
+        }
+    );
+  }
+
+  return null;
+}
+
+function parseCollators (id: ParaId, collatorQueue: SelectedThreads | RetryQueue): (CollatorId | null)[] {
+  return collatorQueue.map((queue): CollatorId | null => {
+    const found = queue.find(([paraId]) => paraId === id);
+
+    return found ? found[1] : null;
+  });
+}
+
+function parse (id: ParaId, [active, retryQueue, selectedThreads, didUpdate, info, pendingSwap, heads, relayDispatchQueue]: Result): DeriveTeyrchainFull | null {
+  if (info.isNone) {
+    return null;
+  }
+
+  return {
+    active: parseActive(id, active),
+    didUpdate: didUpdateToBool(didUpdate, id),
+    heads,
+    id,
+    info: objectSpread<DeriveTeyrchainInfo>({ id }, info.unwrap()),
+    pendingSwapId: pendingSwap.unwrapOr(null),
+    relayDispatchQueue,
+    retryCollators: parseCollators(id, retryQueue),
+    selectedCollators: parseCollators(id, selectedThreads)
+  };
+}
+
+/**
+ * @name info
+ * @param {ParaId | number} id A unique numeric (non-negative integer) identifier for a teyrchain.
+ * @description Retrieves detailed information about a specific teyrchain.
+ * @example
+ * ```javascript
+ * await api.derive.teyrchains.info(1000, (info) => {
+ *   if (info) {
+ *     console.log(`Teyrchain ${info.id.toString()} is active: ${info.active}`);
+ *   } else {
+ *     console.log("Teyrchain information not available.");
+ *   }
+ * });
+ * ```
+*/
+export function info (instanceId: string, api: DeriveApi): (id: ParaId | number) => Observable<DeriveTeyrchainFull | null> {
+  return memo(instanceId, (id: ParaId | number): Observable<DeriveTeyrchainFull | null> =>
+    api.query['registrar'] && api.query['teyrchains']
+      ? api.queryMulti<Result>([
+        api.query['registrar']['active'],
+        api.query['registrar']['retryQueue'],
+        api.query['registrar']['selectedThreads'],
+        api.query['teyrchains']['didUpdate'],
+        [api.query['registrar']['paras'], id],
+        [api.query['registrar']['pendingSwap'], id],
+        [api.query['teyrchains']['heads'], id],
+        [api.query['teyrchains']['relayDispatchQueue'], id]
+      ])
+        .pipe(
+          map((result: Result): DeriveTeyrchainFull | null =>
+            parse(api.registry.createType('ParaId', id), result)
+          )
+        )
+      : of(null)
+  );
+}

package/src/teyrchains/overview.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 { ParaId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveTeyrchain, DeriveTeyrchainInfo } from '../types.js';
+import type { DidUpdate, ParaInfoResult, PendingSwap, RelayDispatchQueueSize } from './types.js';
+
+import { combineLatest, map, of, switchMap } from 'rxjs';
+
+import { objectSpread } from '@pezkuwi/util';
+
+import { memo } from '../util/index.js';
+import { didUpdateToBool } from './util.js';
+
+type Result = [
+  ParaId[],
+  DidUpdate,
+  RelayDispatchQueueSize[],
+  ParaInfoResult[],
+  PendingSwap[]
+];
+
+function parse ([ids, didUpdate, relayDispatchQueueSizes, infos, pendingSwaps]: Result): DeriveTeyrchain[] {
+  return ids.map((id, index): DeriveTeyrchain => ({
+    didUpdate: didUpdateToBool(didUpdate, id),
+    id,
+    info: objectSpread<DeriveTeyrchainInfo>({ id }, infos[index].unwrapOr(null)),
+    pendingSwapId: pendingSwaps[index].unwrapOr(null),
+    relayDispatchQueueSize: relayDispatchQueueSizes[index][0].toNumber()
+  }));
+}
+
+/**
+ * @name overview
+ * @description Retrieves an overview of all registered teyrchains.
+ * @example
+ * ```javascript
+ * await api.derive.teyrchains.overview((overview) => {
+ *   teyrchains.forEach(teyrchain => {
+ *     console.log(`Teyrchain ${teyrchain.id.toString()} is registered.`);
+ *   });
+ * });
+ * ```
+ */
+export function overview (instanceId: string, api: DeriveApi): () => Observable<DeriveTeyrchain[]> {
+  return memo(instanceId, (): Observable<DeriveTeyrchain[]> =>
+    api.query['registrar']?.['teyrchains'] && api.query['teyrchains']
+      ? api.query['registrar']['teyrchains']<ParaId[]>().pipe(
+        switchMap((paraIds) =>
+          combineLatest([
+            of(paraIds),
+            api.query['teyrchains']['didUpdate']<DidUpdate>(),
+            api.query['teyrchains']['relayDispatchQueueSize'].multi<RelayDispatchQueueSize>(paraIds),
+            api.query['registrar']['paras'].multi<ParaInfoResult>(paraIds),
+            api.query['registrar']['pendingSwap'].multi<PendingSwap>(paraIds)
+          ])
+        ),
+        map(parse)
+      )
+      : of([] as DeriveTeyrchain[])
+  );
+}

package/src/teyrchains/types.ts

@@ -0,0 +1,46 @@
+// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Bytes, Option, u32, Vec } from '@pezkuwi/types';
+import type { CollatorId, ParaId, ParaInfo, Retriable, UpwardMessage } from '@pezkuwi/types/interfaces';
+import type { ITuple } from '@pezkuwi/types/types';
+
+export type ParaInfoResult = Option<ParaInfo>;
+export type PendingSwap = Option<ParaId>;
+export type Active = Vec<ITuple<[ParaId, Option<ITuple<[CollatorId, Retriable]>>]>>;
+export type RetryQueue = Vec<Vec<ITuple<[ParaId, CollatorId]>>>
+export type SelectedThreads = Vec<Vec<ITuple<[ParaId, CollatorId]>>>
+export type Code = Bytes;
+export type Heads = Bytes;
+export type RelayDispatchQueue = Vec<UpwardMessage>
+export type RelayDispatchQueueSize = ITuple<[u32, u32]>;
+export type DidUpdate = Option<Vec<ParaId>>;
+
+export interface DeriveTeyrchainActive {
+  collatorId: CollatorId;
+  isRetriable: boolean;
+  retries: number;
+}
+
+export interface DeriveTeyrchainInfo extends ParaInfo {
+  id: ParaId;
+  icon?: string;
+  name?: string;
+  owner?: string;
+}
+
+export interface DeriveTeyrchain {
+  didUpdate: boolean;
+  pendingSwapId: ParaId | null;
+  id: ParaId;
+  info: DeriveTeyrchainInfo | null;
+  relayDispatchQueueSize?: number;
+}
+
+export interface DeriveTeyrchainFull extends DeriveTeyrchain {
+  active: DeriveTeyrchainActive | null;
+  heads: Bytes | null;
+  relayDispatchQueue: UpwardMessage[];
+  retryCollators: (CollatorId | null)[];
+  selectedCollators: (CollatorId | null)[];
+}

package/src/teyrchains/util.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ParaId } from '@pezkuwi/types/interfaces';
+import type { DidUpdate } from './types.js';
+
+export function didUpdateToBool (didUpdate: DidUpdate, id: ParaId): boolean {
+  return didUpdate.isSome
+    ? didUpdate.unwrap().some((paraId) => paraId.eq(id))
+    : false;
+}

package/src/treasury/index.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2025 @pezkuwi/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 @pezkuwi/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 { PezpalletTreasuryProposal } 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<PezpalletTreasuryProposal>[];
+  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 bizinikiwi and released in 1.14
+    // in favor of `spend`. See: https://github.com/pezkuwichain/pezkuwi-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 @pezkuwi/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);