@pezkuwi/api-derive 16.5.19 → 16.5.21

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 };

package/src/balances/types.ts

@@ -1,79 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { AccountId, Balance, BalanceLockTo212, Index } from '@pezkuwi/types/interfaces';
-import type { PezpalletBalancesBalanceLock, PezpalletBalancesReserveData } 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 `PezframeSystemAccountInfo`.
-   * See `transferable` for the correct balance calculation.
-   *
-   * ref: https://github.com/pezkuwichain/bizinikiwi/pull/12951
-   */
-  availableBalance: Balance;
-  /**
-   * The amount of balance locked away.
-   */
-  lockedBalance: Balance;
-  /**
-   * The breakdown of locked balances.
-   */
-  lockedBreakdown: (PezpalletBalancesBalanceLock | 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 `PezframeSystemAccountInfo`.
-   * Which is the most up to date calulcation for transferrable balances.
-   *
-   * ref: https://github.com/pezkuwichain/pezkuwi-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: PezpalletBalancesReserveData[][];
-}
-
-export type DeriveBalancesMap = Record<string, DeriveBalancesAll>;

package/src/balances/votingBalances.ts

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