@pezkuwi/api-derive 16.5.5 → 16.5.6

package/src/balances/all.ts

@@ -1,246 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { Option, Vec } from '@pezkuwi/types';
-import type { AccountId, Balance, BalanceLockTo212, BlockNumber, VestingSchedule } from '@pezkuwi/types/interfaces';
-import type { PalletBalancesBalanceLock, PalletBalancesReserveData, PalletVestingVestingInfo } from '@pezkuwi/types/lookup';
-import type { DeriveApi, DeriveBalancesAccount, DeriveBalancesAccountData, DeriveBalancesAll, DeriveBalancesAllAccountData, DeriveBalancesAllVesting } from '../types.js';
-
-import { combineLatest, map, of, switchMap } from 'rxjs';
-
-import { BN, BN_ZERO, bnMax, bnMin, isFunction, objectSpread } from '@pezkuwi/util';
-
-import { memo } from '../util/index.js';
-
-type ResultBalance = [PalletVestingVestingInfo[] | null, ((PalletBalancesBalanceLock | BalanceLockTo212)[])[], PalletBalancesReserveData[][]];
-type Result = [DeriveBalancesAccount, ResultBalance, BlockNumber];
-
-interface AllLocked {
-  allLocked: boolean,
-  lockedBalance: Balance,
-  lockedBreakdown: (PalletBalancesBalanceLock | BalanceLockTo212)[],
-  vestingLocked: Balance
-}
-
-type DeriveCustomLocks = DeriveApi['derive'] & Record<string, {
-  customLocks?: DeriveApi['query']['balances']['locks']
-}>
-
-const VESTING_ID = '0x76657374696e6720';
-
-function calcLocked (api: DeriveApi, bestNumber: BlockNumber, locks: (PalletBalancesBalanceLock | BalanceLockTo212)[]): AllLocked {
-  let lockedBalance = api.registry.createType('Balance');
-  let lockedBreakdown: (PalletBalancesBalanceLock | BalanceLockTo212)[] = [];
-  let vestingLocked = api.registry.createType('Balance');
-  let allLocked = false;
-
-  if (Array.isArray(locks)) {
-    // only get the locks that are valid until passed the current block
-    lockedBreakdown = (locks as BalanceLockTo212[]).filter(({ until }): boolean => !until || (bestNumber && until.gt(bestNumber)));
-    allLocked = lockedBreakdown.some(({ amount }) => amount && amount.isMax());
-    vestingLocked = api.registry.createType('Balance', lockedBreakdown.filter(({ id }) => id.eq(VESTING_ID)).reduce((result: BN, { amount }) => result.iadd(amount), new BN(0)));
-
-    // get the maximum of the locks according to https://github.com/paritytech/substrate/blob/master/srml/balances/src/lib.rs#L699
-    const notAll = lockedBreakdown.filter(({ amount }) => amount && !amount.isMax());
-
-    if (notAll.length) {
-      lockedBalance = api.registry.createType('Balance', bnMax(...notAll.map(({ amount }): Balance => amount)));
-    }
-  }
-
-  return { allLocked, lockedBalance, lockedBreakdown, vestingLocked };
-}
-
-function calcShared (api: DeriveApi, bestNumber: BlockNumber, data: DeriveBalancesAccountData, locks: (PalletBalancesBalanceLock | BalanceLockTo212)[]): DeriveBalancesAllAccountData {
-  const { allLocked, lockedBalance, lockedBreakdown, vestingLocked } = calcLocked(api, bestNumber, locks);
-  let transferable = null;
-
-  if (data?.frameSystemAccountInfo?.frozen) {
-    const { frameSystemAccountInfo, freeBalance, reservedBalance } = data;
-    const noFrozenReserved = frameSystemAccountInfo.frozen.isZero() && reservedBalance.isZero();
-    const ED = api.consts.balances.existentialDeposit;
-    const maybeED = noFrozenReserved ? new BN(0) : ED;
-    const frozenReserveDif = frameSystemAccountInfo.frozen.sub(reservedBalance);
-
-    transferable = api.registry.createType(
-      'Balance',
-      allLocked
-        ? 0
-        : bnMax(new BN(0), freeBalance.sub(bnMax(maybeED, frozenReserveDif)))
-    );
-  }
-
-  return objectSpread({}, data, {
-    availableBalance: api.registry.createType('Balance', allLocked ? 0 : bnMax(new BN(0), data?.freeBalance ? data.freeBalance.sub(lockedBalance) : new BN(0))),
-    lockedBalance,
-    lockedBreakdown,
-    transferable,
-    vestingLocked
-  });
-}
-
-function calcVesting (bestNumber: BlockNumber, shared: DeriveBalancesAllAccountData, _vesting: PalletVestingVestingInfo[] | null): DeriveBalancesAllVesting {
-  // Calculate the vesting balances,
-  //  - offset = balance locked at startingBlock
-  //  - perBlock is the unlock amount
-  const vesting = _vesting || [];
-  const isVesting = !shared.vestingLocked.isZero();
-  const vestedBalances = vesting.map(({ locked, perBlock, startingBlock }) =>
-    bestNumber.gt(startingBlock)
-      ? bnMin(locked, perBlock.mul(bestNumber.sub(startingBlock)))
-      : BN_ZERO
-  );
-  const vestedBalance = vestedBalances.reduce<BN>((all, value) => all.iadd(value), new BN(0));
-  const vestingTotal = vesting.reduce<BN>((all, { locked }) => all.iadd(locked), new BN(0));
-
-  return {
-    isVesting,
-    vestedBalance,
-    vestedClaimable: isVesting
-      ? shared.vestingLocked.sub(vestingTotal.sub(vestedBalance))
-      : BN_ZERO,
-    vesting: vesting
-      .map(({ locked, perBlock, startingBlock }, index) => ({
-        endBlock: locked.div(perBlock).iadd(startingBlock),
-        locked,
-        perBlock,
-        startingBlock,
-        vested: vestedBalances[index]
-      }))
-      .filter(({ locked }) => !locked.isZero()),
-    vestingTotal
-  };
-}
-
-function calcBalances (api: DeriveApi, result: Result): DeriveBalancesAll {
-  const [data, [vesting, allLocks, namedReserves], bestNumber] = result;
-  const shared = calcShared(api, bestNumber, data, allLocks[0]);
-
-  return objectSpread(shared, calcVesting(bestNumber, shared, vesting), {
-    accountId: data.accountId,
-    accountNonce: data.accountNonce,
-    additional: allLocks
-      .slice(1)
-      .map((l, index) => calcShared(api, bestNumber, data.additional[index], l)),
-    namedReserves
-  });
-}
-
-// old
-function queryOld (api: DeriveApi, accountId: AccountId | string): Observable<ResultBalance> {
-  return combineLatest([
-    api.query.balances.locks(accountId),
-    api.query.balances['vesting']<Option<VestingSchedule>>(accountId)
-  ]).pipe(
-    map(([locks, optVesting]): ResultBalance => {
-      let vestingNew = null;
-
-      if (optVesting.isSome) {
-        const { offset: locked, perBlock, startingBlock } = optVesting.unwrap();
-
-        vestingNew = api.registry.createType<PalletVestingVestingInfo>('VestingInfo', { locked, perBlock, startingBlock });
-      }
-
-      return [
-        vestingNew
-          ? [vestingNew]
-          : null,
-        [locks],
-        []
-      ];
-    })
-  );
-}
-
-const isNonNullable = <T>(nullable: T): nullable is NonNullable<T> => !!nullable;
-
-function createCalls <T> (calls: (((a: unknown) => Observable<T>) | null | undefined)[]): [boolean[], ((a: unknown) => Observable<T>)[]] {
-  return [
-    calls.map((c) => !c),
-    calls.filter(isNonNullable)
-  ];
-}
-
-// current (balances, vesting)
-function queryCurrent (api: DeriveApi, accountId: AccountId | string, balanceInstances: string[] = ['balances']): Observable<ResultBalance> {
-  const [lockEmpty, lockQueries] = createCalls<Vec<PalletBalancesBalanceLock>>(
-    balanceInstances.map((m) =>
-      (api.derive as DeriveCustomLocks)[m]?.customLocks || api.query[m as 'balances']?.locks
-    )
-  );
-  const [reserveEmpty, reserveQueries] = createCalls<Vec<PalletBalancesReserveData>>(
-    balanceInstances.map((m) =>
-      api.query[m as 'balances']?.reserves
-    )
-  );
-
-  return combineLatest([
-    api.query.vesting?.vesting
-      ? api.query.vesting.vesting(accountId)
-      : of(api.registry.createType('Option<VestingInfo>')),
-    lockQueries.length
-      ? combineLatest(lockQueries.map((c) => c(accountId)))
-      : of([] as Vec<PalletBalancesBalanceLock>[]),
-    reserveQueries.length
-      ? combineLatest(reserveQueries.map((c) => c(accountId)))
-      : of([] as Vec<PalletBalancesReserveData>[])
-  ]).pipe(
-    map(([opt, locks, reserves]): ResultBalance => {
-      let offsetLock = -1;
-      let offsetReserve = -1;
-      const vesting = opt.unwrapOr(null);
-
-      return [
-        vesting
-          ? Array.isArray(vesting)
-            ? vesting
-            : [vesting as PalletVestingVestingInfo]
-          : null,
-        lockEmpty.map((e) =>
-          e ? api.registry.createType<Vec<PalletBalancesBalanceLock>>('Vec<BalanceLock>') : locks[++offsetLock]
-        ),
-        reserveEmpty.map((e) =>
-          e ? api.registry.createType<Vec<PalletBalancesReserveData>>('Vec<PalletBalancesReserveData>') : reserves[++offsetReserve]
-        )
-      ];
-    })
-  );
-}
-
-/**
- * @name all
- * @description Retrieves the complete balance information for an account, including free balance, locked balance, reserved balance, and more.
- * @param {( AccountId | string )} address An accountsId in different formats.
- * @example
- * ```javascript
- * const ALICE = 'F7Hs';
- *
- * api.derive.balances.account(ALICE, (accountInfo) => {
- *   console.log(
- *     `${accountInfo.accountId} info:`,
- *     Object.keys(accountInfo).map((key) => `${key}: ${accountInfo[key]}`)
- *   );
- * });
- * ```
- */
-export function all (instanceId: string, api: DeriveApi): (address: AccountId | string) => Observable<DeriveBalancesAll> {
-  const balanceInstances = api.registry.getModuleInstances(api.runtimeVersion.specName, 'balances');
-
-  return memo(instanceId, (address: AccountId | string): Observable<DeriveBalancesAll> =>
-    combineLatest([
-      api.derive.balances.account(address),
-      isFunction(api.query.system?.account) || isFunction(api.query.balances?.account)
-        ? queryCurrent(api, address, balanceInstances)
-        : queryOld(api, address)
-    ]).pipe(
-      switchMap(([account, locks]) =>
-        combineLatest([
-          of(account),
-          of(locks),
-          api.derive.chain.bestNumber()
-        ])
-      ),
-      map((result) => calcBalances(api, result))
-    ));
-}

package/src/balances/types.ts

@@ -1,79 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { AccountId, Balance, BalanceLockTo212, Index } from '@pezkuwi/types/interfaces';
-import type { PalletBalancesBalanceLock, PalletBalancesReserveData } from '@pezkuwi/types/lookup';
-import type { BN } from '@pezkuwi/util';
-
-export interface DeriveBalancesAccountData {
-  frameSystemAccountInfo?: {
-    frozen: Balance;
-    flags: Balance;
-  }
-  freeBalance: Balance;
-  frozenFee: Balance;
-  frozenMisc: Balance;
-  reservedBalance: Balance;
-  votingBalance: Balance;
-}
-
-export interface DeriveBalancesAccount extends DeriveBalancesAccountData {
-  accountId: AccountId;
-  accountNonce: Index;
-  additional: DeriveBalancesAccountData[];
-}
-
-export interface DeriveBalancesAllAccountData extends DeriveBalancesAccountData {
-  /**
-   * Calculated available balance. This uses the formula: max(0, free - locked)
-   * This is only correct when the return type of `api.query.system.account` is `AccountInfo` which was replaced by `FrameSystemAccountInfo`.
-   * See `transferable` for the correct balance calculation.
-   *
-   * ref: https://github.com/paritytech/substrate/pull/12951
-   */
-  availableBalance: Balance;
-  /**
-   * The amount of balance locked away.
-   */
-  lockedBalance: Balance;
-  /**
-   * The breakdown of locked balances.
-   */
-  lockedBreakdown: (PalletBalancesBalanceLock | BalanceLockTo212)[];
-  /**
-   * Calculated transferable balance. This uses the formula: free - max(maybeEd, frozen - reserve)
-   * Where `maybeEd` means if there is no frozen and reserves it will be zero, else it will be the existential deposit.
-   * This is only correct when the return type of `api.query.system.account` is `FrameSystemAccountInfo`.
-   * Which is the most up to date calulcation for transferrable balances.
-   *
-   * ref: https://github.com/paritytech/polkadot-sdk/issues/1833
-   */
-  transferable: Balance | null;
-  /**
-   * Amount locked in vesting.
-   */
-  vestingLocked: Balance;
-}
-
-export interface DeriveBalancesVesting {
-  startingBlock: BN;
-  endBlock: BN;
-  perBlock: BN;
-  locked: BN;
-  vested: BN;
-}
-
-export interface DeriveBalancesAllVesting {
-  isVesting: boolean;
-  vestedBalance: BN;
-  vestedClaimable: BN;
-  vesting: DeriveBalancesVesting[];
-  vestingTotal: BN;
-}
-
-export interface DeriveBalancesAll extends DeriveBalancesAccount, DeriveBalancesAllAccountData, DeriveBalancesAllVesting {
-  additional: DeriveBalancesAllAccountData[];
-  namedReserves: PalletBalancesReserveData[][];
-}
-
-export type DeriveBalancesMap = Record<string, DeriveBalancesAll>;

package/src/balances/votingBalances.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 { AccountId, AccountIndex, Address } from '@pezkuwi/types/interfaces';
-import type { DeriveApi, DeriveBalancesAccount } from '../types.js';
-
-import { combineLatest, of } from 'rxjs';
-
-import { memo } from '../util/index.js';
-
-/**
- * @name votingBalances
- * @description Retrieves the balance information for multiple accounts, typically used in governance-related contexts to check voting power.
- * @param {(AccountId | AccountIndex | Address | string)[]} addresses An array of account identifiers.
- * @example
- * ```javascript
- * const addresses = ["5D4b...Zf1", "5HGj...yrV"];
- * const balances = await api.derive.balances.votingBalances(addresses);
- * console.log("Voting Balances:", balances);
- * ```
- */
-export function votingBalances (instanceId: string, api: DeriveApi): (addresses?: (AccountId | AccountIndex | Address | string)[]) => Observable<DeriveBalancesAccount[]> {
-  return memo(instanceId, (addresses?: (AccountId | AccountIndex | Address | string)[]): Observable<DeriveBalancesAccount[]> =>
-    !addresses?.length
-      ? of([] as DeriveBalancesAccount[])
-      : combineLatest(
-        addresses.map((accountId): Observable<DeriveBalancesAccount> =>
-          api.derive.balances.account(accountId)
-        )
-      )
-  );
-}

package/src/bounties/bounties.spec.ts

@@ -1,162 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import type { ApiPromise } from '@pezkuwi/api';
-import type { SubmittableExtrinsic } from '@pezkuwi/api-base/types';
-import type { Bytes, Option, StorageKey } from '@pezkuwi/types';
-import type { Bounty, BountyIndex, Proposal, ProposalIndex } from '@pezkuwi/types/interfaces';
-import type { Codec, InterfaceTypes } from '@pezkuwi/types/types';
-import type { DeriveApi, DeriveCollectiveProposal } from '../types.js';
-
-import { firstValueFrom, of } from 'rxjs';
-
-import { BountyFactory } from '../test/bountyFactory.js';
-import { BytesFactory } from '../test/bytesFactory.js';
-import { createApiWithAugmentations } from '../test/helpers.js';
-import { ProposalFactory } from '../test/proposalFactory.js';
-import { bounties } from './index.js';
-
-const DEFAULT_PROPOSER = '5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM';
-
-describe('bounties derive', () => {
-  let storageKey: (index: number) => StorageKey;
-  let defaultBounty: () => Bounty;
-  let emptyOption: <T extends Codec> (typeName: keyof InterfaceTypes) => Option<T>;
-  let optionOf: <T extends Codec> (value: T) => Option<T>;
-  let bountyIndex: (index: number) => BountyIndex;
-  let proposalIndex: (index: number) => ProposalIndex;
-  let bytes: (value: string) => Bytes;
-  let api: ApiPromise;
-  let createProposal: (method: SubmittableExtrinsic<'promise'>) => Proposal;
-  let defaultMockApi: DeriveApi;
-
-  beforeAll(() => {
-    api = createApiWithAugmentations();
-
-    ({ bountyIndex, defaultBounty, emptyOption, optionOf, storageKey } = new BountyFactory(api));
-    ({ bytes } = new BytesFactory(api.registry));
-    ({ createProposal, proposalIndex } = new ProposalFactory(api));
-  });
-
-  beforeEach(() => {
-    defaultMockApi = {
-      derive: {
-        council: {
-          proposals: () => of([] as DeriveCollectiveProposal[])
-        }
-      },
-      query: {
-        council: {
-          proposalCount: () => of(proposalIndex(2))
-        },
-        treasury: {
-          bounties: {
-            keys: () => of([storageKey(0), storageKey(1)]),
-            multi: () => of([optionOf(defaultBounty()), optionOf(defaultBounty())])
-          },
-          bountyCount: () => of(bountyIndex(2)),
-          bountyDescriptions: {
-            multi: () => of([
-              optionOf(bytes('make polkadot even better')),
-              optionOf(bytes('some other bounty'))
-            ])
-          }
-        }
-      },
-      tx: api.tx
-    } as unknown as DeriveApi;
-  });
-
-  it('creates storage key', function () {
-    expect(storageKey(194).args[0].eq(194)).toBe(true);
-  });
-
-  it('creates proposal', function () {
-    expect(createProposal(api.tx.balances.transferAllowDeath('5EYCAe5ijiYfyeZ2JJCGq56LmPyNRAKzpG4QkoQkkQNB5e6Z', 1))).toBeTruthy();
-  });
-
-  it('combines bounties with descriptions', async () => {
-    const mockApi = {
-      ...defaultMockApi,
-      query: {
-        ...defaultMockApi.query,
-        treasury: {
-          bounties: {
-            keys: () => of([storageKey(0), storageKey(2), storageKey(3)]),
-            multi: () => of([optionOf(defaultBounty()), emptyOption('Bounty'), optionOf(defaultBounty())])
-          },
-          bountyCount: () => of(bountyIndex(3)),
-          bountyDescriptions: {
-            multi: () => of([
-              optionOf(bytes('make polkadot even better')),
-              optionOf(bytes('this will be totally ignored')),
-              emptyOption('Bytes')
-            ])
-          }
-        }
-      }
-    } as unknown as DeriveApi;
-
-    const result = await firstValueFrom(bounties('', mockApi)());
-
-    expect(result).toHaveLength(2);
-    expect(result[0].bounty.proposer.toString()).toEqual(DEFAULT_PROPOSER);
-    expect(result[0].description).toEqual('make polkadot even better');
-    expect(result[0].index.eq(0)).toBe(true);
-    expect(result[1].bounty.proposer.toString()).toEqual(DEFAULT_PROPOSER);
-    expect(result[1].description).toEqual('');
-    expect(result[1].index.eq(3)).toBe(true);
-  });
-
-  it('returns motions', async () => {
-    const result = await firstValueFrom(bounties('', defaultMockApi)());
-
-    expect(result).toHaveLength(2);
-    expect(result[0].proposals).toHaveLength(0);
-    expect(result[1].proposals).toHaveLength(0);
-  });
-
-  it('when no council, returns bounties without motions', async () => {
-    const mockApi = {
-      ...defaultMockApi,
-      query: {
-        ...defaultMockApi.query,
-        council: null
-      }
-    } as unknown as DeriveApi;
-
-    const result = await firstValueFrom(bounties('', mockApi)());
-
-    expect(result).toHaveLength(2);
-    expect(result[0].bounty.proposer.toString()).toEqual(DEFAULT_PROPOSER);
-    expect(result[0].description).toEqual('make polkadot even better');
-    expect(result[0].index.eq(0)).toBe(true);
-    expect(result[0].proposals).toHaveLength(0);
-    expect(result[1].bounty.proposer.toString()).toEqual(DEFAULT_PROPOSER);
-    expect(result[1].description).toEqual('some other bounty');
-    expect(result[1].index.eq(1)).toBe(true);
-    expect(result[1].proposals).toHaveLength(0);
-  });
-
-  it('combines bounties with motions', async () => {
-    const mockApi = {
-      ...defaultMockApi,
-      derive: {
-        council: {
-          proposals: () => of([
-            { proposal: createProposal(api.tx.bounties.approveBounty(1)) },
-            { proposal: api.tx.treasury['approveProposal'] && createProposal(api.tx.treasury['approveProposal'](1)) }] as DeriveCollectiveProposal[])
-        }
-      }
-    } as unknown as DeriveApi;
-
-    const result = await firstValueFrom(bounties('', mockApi)());
-
-    expect(result).toHaveLength(2);
-    expect(result[0].proposals).toHaveLength(0);
-    expect(result[1].proposals).toHaveLength(1);
-    expect(result[1].proposals[0].proposal?.method).toEqual('approveBounty');
-  });
-});

package/src/bounties/bounties.ts

@@ -1,76 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { Bytes, Option } from '@pezkuwi/types';
-import type { BountyIndex } from '@pezkuwi/types/interfaces';
-import type { PalletBountiesBounty } from '@pezkuwi/types/lookup';
-import type { DeriveApi, DeriveBounties, DeriveCollectiveProposal } from '../types.js';
-
-import { combineLatest, map, of, switchMap } from 'rxjs';
-
-import { memo } from '../util/index.js';
-import { filterBountiesProposals } from './helpers/filterBountyProposals.js';
-
-type Result = [Option<PalletBountiesBounty>[], Option<Bytes>[], BountyIndex[], DeriveCollectiveProposal[]];
-
-function parseResult ([maybeBounties, maybeDescriptions, ids, bountyProposals]: Result): DeriveBounties {
-  const bounties: DeriveBounties = [];
-
-  maybeBounties.forEach((bounty, index) => {
-    if (bounty.isSome) {
-      bounties.push({
-        bounty: bounty.unwrap(),
-        description: maybeDescriptions[index].unwrapOrDefault().toUtf8(),
-        index: ids[index],
-        proposals: bountyProposals.filter((bountyProposal) =>
-          bountyProposal.proposal && ids[index].eq(bountyProposal.proposal.args[0])
-        )
-      });
-    }
-  });
-
-  return bounties;
-}
-
-/**
- * @name bounties
- * @descrive Retrieves all active bounties, their descriptions, and associated proposals.
- * @example
- * ```javascript
- * const bounties = await api.derive.bounties();
- * console.log("Active bounties:", bounties);
- * ```
- */
-export function bounties (instanceId: string, api: DeriveApi): () => Observable<DeriveBounties> {
-  const bountyBase = api.query.bounties || api.query.treasury;
-
-  return memo(instanceId, (): Observable<DeriveBounties> =>
-    bountyBase.bounties
-      ? combineLatest([
-        bountyBase.bountyCount(),
-        api.query.council
-          ? api.query.council.proposalCount()
-          : of(0)
-      ]).pipe(
-        switchMap(() => combineLatest([
-          bountyBase.bounties.keys(),
-          api.derive.council
-            ? api.derive.council.proposals()
-            : of([])
-        ])),
-        switchMap(([keys, proposals]): Observable<Result> => {
-          const ids = keys.map(({ args: [id] }) => id);
-
-          return combineLatest([
-            bountyBase.bounties.multi(ids),
-            bountyBase.bountyDescriptions.multi(ids),
-            of(ids),
-            of(filterBountiesProposals(api, proposals))
-          ]);
-        }),
-        map(parseResult)
-      )
-      : of(parseResult([[], [], [], []]))
-  );
-}

package/src/bounties/helpers/filterBountyProposals.ts

@@ -1,13 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { DeriveApi, DeriveCollectiveProposal } from '../../types.js';
-
-export function filterBountiesProposals (api: DeriveApi, allProposals: DeriveCollectiveProposal[]): DeriveCollectiveProposal[] {
-  const bountyTxBase = api.tx.bounties ? api.tx.bounties : api.tx.treasury;
-  const bountyProposalCalls = [bountyTxBase.approveBounty, bountyTxBase.closeBounty, bountyTxBase.proposeCurator, bountyTxBase.unassignCurator];
-
-  return allProposals.filter((proposal) => bountyProposalCalls.find((bountyCall) =>
-    proposal.proposal && bountyCall.is(proposal.proposal))
-  );
-}

package/src/bounties/index.ts

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