@pezkuwi/api-derive 16.5.8 → 16.5.9

package/src/bagsList/getExpanded.ts

@@ -1,41 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { BN } from '@pezkuwi/util';
-import type { DeriveApi } from '../types.js';
-import type { Bag, BagExpanded } from './types.js';
-
-import { map, switchMap } from 'rxjs';
-
-import { objectSpread } from '@pezkuwi/util';
-
-import { memo } from '../util/index.js';
-
-/**
- * @name expand
- * @description Expands a given bag by retrieving all its nodes (accounts contained within the bag).
- * @param {Bag} bag The bag to be expanded.
- */
-export function expand (instanceId: string, api: DeriveApi): (bag: Bag) => Observable<BagExpanded> {
-  return memo(instanceId, (bag: Bag): Observable<BagExpanded> =>
-    api.derive.bagsList.listNodes(bag.bag).pipe(
-      map((nodes) => objectSpread({ nodes }, bag))
-    )
-  );
-}
-
-/**
- * @name getExpanded
- * @description Retrieves and expands a specific bag from the BagsList pallet.
- * @param {BN | number} id The id of the bag to expand.
- */
-export function getExpanded (instanceId: string, api: DeriveApi): (id: BN | number) => Observable<BagExpanded> {
-  return memo(instanceId, (id: BN | number): Observable<BagExpanded> =>
-    api.derive.bagsList.get(id).pipe(
-      switchMap((bag) =>
-        api.derive.bagsList.expand(bag)
-      )
-    )
-  );
-}

package/src/bagsList/index.ts

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

package/src/bagsList/listNodes.ts

@@ -1,50 +0,0 @@
-// 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 { AccountId32 } from '@pezkuwi/types/interfaces';
-import type { PezpalletBagsListListBag, PezpalletBagsListListNode } from '@pezkuwi/types/lookup';
-import type { DeriveApi } from '../types.js';
-
-import { BehaviorSubject, map, of, switchMap, tap, toArray } from 'rxjs';
-
-import { nextTick } from '@pezkuwi/util';
-
-import { memo } from '../util/index.js';
-import { getQueryInterface } from './util.js';
-
-function traverseLinks (api: DeriveApi, head: AccountId32 | string): Observable<PezpalletBagsListListNode[]> {
-  const subject = new BehaviorSubject<AccountId32 | string>(head);
-  const query = getQueryInterface(api);
-
-  return subject.pipe(
-    switchMap((account) =>
-      query.listNodes<Option<PezpalletBagsListListNode>>(account)
-    ),
-    tap((node: Option<PezpalletBagsListListNode>): void => {
-      nextTick((): void => {
-        node.isSome && node.value.next.isSome
-          ? subject.next(node.unwrap().next.unwrap())
-          : subject.complete();
-      });
-    }),
-    toArray(), // toArray since we want to startSubject to be completed
-    map((all: Option<PezpalletBagsListListNode>[]) =>
-      all.map((o) => o.unwrap())
-    )
-  );
-}
-
-/**
- * @name listNodes
- * @param {(PezpalletBagsListListBag | null)} bag A reference to a specific bag in the BagsList pallet.
- * @description Retrieves the list of nodes (accounts) contained in a specific bag within the BagsList pallet.
- */
-export function listNodes (instanceId: string, api: DeriveApi): (bag: PezpalletBagsListListBag | null) => Observable<PezpalletBagsListListNode[]> {
-  return memo(instanceId, (bag: PezpalletBagsListListBag | null): Observable<PezpalletBagsListListNode[]> =>
-    bag && bag.head.isSome
-      ? traverseLinks(api, bag.head.unwrap())
-      : of([])
-  );
-}

package/src/bagsList/types.ts

@@ -1,18 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { PezpalletBagsListListBag, PezpalletBagsListListNode } from '@pezkuwi/types/lookup';
-import type { BN } from '@pezkuwi/util';
-
-export interface Bag {
-  bag: PezpalletBagsListListBag | null;
-  bagUpper: BN;
-  bagLower: BN;
-  id: BN;
-  index: number;
-  key: string;
-}
-
-export interface BagExpanded extends Bag {
-  nodes: PezpalletBagsListListNode[];
-}

package/src/bagsList/util.ts

@@ -1,14 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { DeriveApi } from '../types.js';
-
-export function getQueryInterface (api: DeriveApi): DeriveApi['query']['voterList'] {
-  return (
-    // latest bizinikiwi & pezkuwi
-    api.query.voterList ||
-    // previous bizinikiwi
-    api.query['voterBagsList'] ||
-    api.query['bagsList']
-  );
-}

package/src/balances/account.ts

@@ -1,210 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { QueryableStorageEntry } from '@pezkuwi/api-base/types';
-import type { AccountData, AccountId, AccountIndex, AccountInfo, Address, Balance, Index } from '@pezkuwi/types/interfaces';
-import type { PezframeSystemAccountInfo, PezpalletBalancesAccountData } from '@pezkuwi/types/lookup';
-import type { ITuple } from '@pezkuwi/types/types';
-import type { DeriveApi, DeriveBalancesAccount, DeriveBalancesAccountData } from '../types.js';
-
-import { combineLatest, map, of, switchMap } from 'rxjs';
-
-import { isFunction, objectSpread } from '@pezkuwi/util';
-
-import { memo } from '../util/index.js';
-
-type BalanceResult = [Balance, Balance, Balance, Balance];
-
-type Result = [Index, BalanceResult[], AccountType];
-
-interface AccountType { isFrameAccountData: boolean }
-
-type DeriveCustomAccount = DeriveApi['derive'] & Record<string, {
-  customAccount?: DeriveApi['query']['balances']['account']
-}>
-
-function zeroBalance (api: DeriveApi) {
-  return api.registry.createType('Balance');
-}
-
-function getBalance (api: DeriveApi, [freeBalance, reservedBalance, frozenFeeOrFrozen, frozenMiscOrFlags]: BalanceResult, accType: AccountType): DeriveBalancesAccountData {
-  const votingBalance = api.registry.createType('Balance', freeBalance.toBn());
-
-  if (accType.isFrameAccountData) {
-    return {
-      frameSystemAccountInfo: {
-        flags: frozenMiscOrFlags,
-        frozen: frozenFeeOrFrozen
-      },
-      freeBalance,
-      frozenFee: api.registry.createType('Balance', 0),
-      frozenMisc: api.registry.createType('Balance', 0),
-      reservedBalance,
-      votingBalance
-    };
-  }
-
-  return {
-    freeBalance,
-    frozenFee: frozenFeeOrFrozen,
-    frozenMisc: frozenMiscOrFlags,
-    reservedBalance,
-    votingBalance
-  };
-}
-
-function calcBalances (api: DeriveApi, [accountId, [accountNonce, [primary, ...additional], accType]]: [AccountId, Result]): DeriveBalancesAccount {
-  return objectSpread({
-    accountId,
-    accountNonce,
-    additional: additional.map((b) => getBalance(api, b, accType))
-  }, getBalance(api, primary, accType));
-}
-
-// old
-function queryBalancesFree (api: DeriveApi, accountId: AccountId): Observable<Result> {
-  return combineLatest([
-    api.query.balances['freeBalance']<Balance>(accountId),
-    api.query.balances['reservedBalance']<Balance>(accountId),
-    api.query.system['accountNonce']<Index>(accountId)
-  ]).pipe(
-    map(([freeBalance, reservedBalance, accountNonce]): Result => [
-      accountNonce,
-      [[freeBalance, reservedBalance, zeroBalance(api), zeroBalance(api)]],
-      { isFrameAccountData: false }
-    ])
-  );
-}
-
-function queryNonceOnly (api: DeriveApi, accountId: AccountId): Observable<Result> {
-  const fill = (nonce: Index): Result => [
-    nonce,
-    [[zeroBalance(api), zeroBalance(api), zeroBalance(api), zeroBalance(api)]],
-    { isFrameAccountData: false }
-  ];
-
-  return isFunction(api.query.system.account)
-    ? api.query.system.account(accountId).pipe(
-      map(({ nonce }) => fill(nonce))
-    )
-    : isFunction(api.query.system['accountNonce'])
-      ? api.query.system['accountNonce']<Index>(accountId).pipe(
-        map((nonce) => fill(nonce))
-      )
-      : of(fill(api.registry.createType('Index')));
-}
-
-function queryBalancesAccount (api: DeriveApi, accountId: AccountId, modules: string[] = ['balances']): Observable<Result> {
-  const balances = modules
-    .map((m): QueryableStorageEntry<'rxjs'> => (api.derive as DeriveCustomAccount)[m]?.customAccount || api.query[m as 'balances']?.account)
-    .filter((q) => isFunction(q));
-
-  const extract = (nonce: Index, data: AccountData[]): Result => [
-    nonce,
-    data.map(({ feeFrozen, free, miscFrozen, reserved }): BalanceResult => [free, reserved, feeFrozen, miscFrozen]),
-    { isFrameAccountData: false }
-  ];
-
-  // NOTE this is for the first case where we do have instances specified
-  return balances.length
-    ? isFunction(api.query.system.account)
-      ? combineLatest([
-        api.query.system.account(accountId),
-        ...balances.map((c) => c(accountId))
-      ]).pipe(
-        map(([{ nonce }, ...balances]) => extract(nonce, balances as unknown as AccountData[]))
-      )
-      : combineLatest([
-        api.query.system['accountNonce']<Index>(accountId),
-        ...balances.map((c) => c(accountId))
-      ]).pipe(
-        map(([nonce, ...balances]) => extract(nonce, balances as unknown as AccountData[]))
-      )
-    : queryNonceOnly(api, accountId);
-}
-
-function querySystemAccount (api: DeriveApi, accountId: AccountId): Observable<Result> {
-  // AccountInfo is current, support old, eg. Edgeware
-  return api.query.system.account<AccountInfo | PezframeSystemAccountInfo | ITuple<[Index, AccountData]>>(accountId).pipe(
-    map((infoOrTuple): Result => {
-      const data = (infoOrTuple as AccountInfo).nonce
-        ? (infoOrTuple as AccountInfo).data
-        : (infoOrTuple as [Index, AccountData])[1];
-
-      const nonce = (infoOrTuple as AccountInfo).nonce || (infoOrTuple as [Index, AccountData])[0];
-
-      if (!data || data.isEmpty) {
-        return [
-          nonce,
-          [[zeroBalance(api), zeroBalance(api), zeroBalance(api), zeroBalance(api)]],
-          { isFrameAccountData: false }
-        ];
-      }
-
-      const isFrameType = !!(infoOrTuple as PezframeSystemAccountInfo).data.frozen;
-
-      if (isFrameType) {
-        const { flags, free, frozen, reserved } = (data as unknown as PezpalletBalancesAccountData);
-
-        return [
-          nonce,
-          [[free, reserved, frozen, flags]],
-          { isFrameAccountData: true }
-        ];
-      } else {
-        const { feeFrozen, free, miscFrozen, reserved } = data;
-
-        return [
-          nonce,
-          [[free, reserved, feeFrozen, miscFrozen]],
-          { isFrameAccountData: false }
-        ];
-      }
-    })
-  );
-}
-
-/**
- * @name account
- * @description Retrieves the essential balance details for an account, such as free balance and account nonce.
- * @param {( AccountIndex | AccountId | Address | string )} address An accountsId in different formats.
- * @example
- * ```javascript
- * const ALICE = 'F7Hs';
- *
- * api.derive.balances.all(ALICE, ({ accountId, lockedBalance }) => {
- *   console.log(`The account ${accountId} has a locked balance ${lockedBalance} units.`);
- * });
- * ```
- */
-export function account (instanceId: string, api: DeriveApi): (address: AccountIndex | AccountId | Address | string) => Observable<DeriveBalancesAccount> {
-  const balanceInstances = api.registry.getModuleInstances(api.runtimeVersion.specName, 'balances');
-  const nonDefaultBalances = balanceInstances && balanceInstances[0] !== 'balances';
-
-  return memo(instanceId, (address: AccountIndex | AccountId | Address | string): Observable<DeriveBalancesAccount> =>
-    api.derive.accounts.accountId(address).pipe(
-      switchMap((accountId): Observable<[AccountId, Result]> =>
-        (accountId
-          ? combineLatest([
-            of(accountId),
-            nonDefaultBalances
-              ? queryBalancesAccount(api, accountId, balanceInstances)
-              : isFunction(api.query.system?.account)
-                ? querySystemAccount(api, accountId)
-                : isFunction(api.query.balances?.account)
-                  ? queryBalancesAccount(api, accountId)
-                  : isFunction(api.query.balances?.['freeBalance'])
-                    ? queryBalancesFree(api, accountId)
-                    : queryNonceOnly(api, accountId)
-          ])
-          : of([api.registry.createType('AccountId'), [
-            api.registry.createType('Index'),
-            [[zeroBalance(api), zeroBalance(api), zeroBalance(api), zeroBalance(api)]],
-            { isFrameAccountData: false }
-          ]])
-        )
-      ),
-      map((result): DeriveBalancesAccount => calcBalances(api, result))
-    ));
-}

package/src/balances/all.ts

@@ -1,246 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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 { PezpalletBalancesBalanceLock, PezpalletBalancesReserveData, PezpalletVestingVestingInfo } 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 = [PezpalletVestingVestingInfo[] | null, ((PezpalletBalancesBalanceLock | BalanceLockTo212)[])[], PezpalletBalancesReserveData[][]];
-type Result = [DeriveBalancesAccount, ResultBalance, BlockNumber];
-
-interface AllLocked {
-  allLocked: boolean,
-  lockedBalance: Balance,
-  lockedBreakdown: (PezpalletBalancesBalanceLock | 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: (PezpalletBalancesBalanceLock | BalanceLockTo212)[]): AllLocked {
-  let lockedBalance = api.registry.createType('Balance');
-  let lockedBreakdown: (PezpalletBalancesBalanceLock | 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/pezkuwichain/bizinikiwi/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: (PezpalletBalancesBalanceLock | 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: PezpalletVestingVestingInfo[] | 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<PezpalletVestingVestingInfo>('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<PezpalletBalancesBalanceLock>>(
-    balanceInstances.map((m) =>
-      (api.derive as DeriveCustomLocks)[m]?.customLocks || api.query[m as 'balances']?.locks
-    )
-  );
-  const [reserveEmpty, reserveQueries] = createCalls<Vec<PezpalletBalancesReserveData>>(
-    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<PezpalletBalancesBalanceLock>[]),
-    reserveQueries.length
-      ? combineLatest(reserveQueries.map((c) => c(accountId)))
-      : of([] as Vec<PezpalletBalancesReserveData>[])
-  ]).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 PezpalletVestingVestingInfo]
-          : null,
-        lockEmpty.map((e) =>
-          e ? api.registry.createType<Vec<PezpalletBalancesBalanceLock>>('Vec<BalanceLock>') : locks[++offsetLock]
-        ),
-        reserveEmpty.map((e) =>
-          e ? api.registry.createType<Vec<PezpalletBalancesReserveData>>('Vec<PezpalletBalancesReserveData>') : 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/index.ts

@@ -1,26 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { all } from './all.js';
-
-export * from './account.js';
-export * from './votingBalances.js';
-
-/**
- * @name votingBalance
- * @param {( AccountId | string )} address An accounts Id in different formats.
- * @returns An object containing the results of various balance queries
- * @example
- * <BR>
- *
- * ```javascript
- * const ALICE = 'F7Hs';
- *
- * api.derive.balances.votingBalance(ALICE, ({ accountId, lockedBalance }) => {
- *   console.log(`The account ${accountId} has a locked balance ${lockedBalance} units.`);
- * });
- * ```
- */
-const votingBalance = all;
-
-export { all, votingBalance };