@pezkuwi/api-derive 16.5.5

package/src/bagsList/listNodes.ts

@@ -0,0 +1,50 @@
+// Copyright 2017-2025 @polkadot/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 { PalletBagsListListBag, PalletBagsListListNode } 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<PalletBagsListListNode[]> {
+  const subject = new BehaviorSubject<AccountId32 | string>(head);
+  const query = getQueryInterface(api);
+
+  return subject.pipe(
+    switchMap((account) =>
+      query.listNodes<Option<PalletBagsListListNode>>(account)
+    ),
+    tap((node: Option<PalletBagsListListNode>): 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<PalletBagsListListNode>[]) =>
+      all.map((o) => o.unwrap())
+    )
+  );
+}
+
+/**
+ * @name listNodes
+ * @param {(PalletBagsListListBag | 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: PalletBagsListListBag | null) => Observable<PalletBagsListListNode[]> {
+  return memo(instanceId, (bag: PalletBagsListListBag | null): Observable<PalletBagsListListNode[]> =>
+    bag && bag.head.isSome
+      ? traverseLinks(api, bag.head.unwrap())
+      : of([])
+  );
+}

package/src/bagsList/types.ts

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

package/src/bagsList/util.ts

@@ -0,0 +1,14 @@
+// Copyright 2017-2025 @polkadot/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 substrate & polkadot
+    api.query.voterList ||
+    // previous substrate
+    api.query['voterBagsList'] ||
+    api.query['bagsList']
+  );
+}

package/src/balances/account.ts

@@ -0,0 +1,210 @@
+// Copyright 2017-2025 @polkadot/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 { FrameSystemAccountInfo, PalletBalancesAccountData } 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 | FrameSystemAccountInfo | 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 FrameSystemAccountInfo).data.frozen;
+
+      if (isFrameType) {
+        const { flags, free, frozen, reserved } = (data as unknown as PalletBalancesAccountData);
+
+        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

@@ -0,0 +1,246 @@
+// 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/index.ts

@@ -0,0 +1,26 @@
+// Copyright 2017-2025 @polkadot/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 };

package/src/balances/types.ts

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

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