@pezkuwi/api-derive 16.5.6 → 16.5.8

package/build/cjs/alliance/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prime = exports.proposals = exports.proposalHashes = exports.proposalCount = exports.proposal = exports.hasProposals = exports.members = void 0;
+const index_js_1 = require("../collective/index.js");
+/**
+ * @name members
+ * @description Retrieves the list of members in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const members = await api.derive.alliance.members();
+ * console.log(`Members: ${JSON.stringify(members)});
+ * ```
+ */
+exports.members = (0, index_js_1.members)('allianceMotion');
+/**
+ * @name hasProposals
+ * @description Checks if there are any active proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const exists = await api.derive.alliance.hasProposals();
+ * console.log(exists);
+ * ```
+ */
+exports.hasProposals = (0, index_js_1.hasProposals)('allianceMotion');
+/**
+ * @name proposal
+ * @description Retrieves details of a specific proposal in the "allianceMotion" collective by its hash.
+ * @example
+ * ```javascript
+ * const proposalDetails = await api.derive.alliance.proposal(PROPOSAL_HASH);
+ * console.log(proposalDetails);
+ * ```
+ */
+exports.proposal = (0, index_js_1.proposal)('allianceMotion');
+/**
+ * @name proposalCount
+ * @description Retrieves the total number of proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const count = await api.derive.alliance.proposalCount();
+ * console.log(`Amount of proposals: ${count}`);
+ * ```
+ */
+exports.proposalCount = (0, index_js_1.proposalCount)('allianceMotion');
+/**
+ * @name proposalHashes
+ * @description Retrieves an array of hashes for all active proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const hashes = await api.derive.alliance.proposalHashes();
+ * console.log(`Proposals ${JSON.stringify(hashes)}`);
+ * ```
+ */
+exports.proposalHashes = (0, index_js_1.proposalHashes)('allianceMotion');
+/**
+ * @name proposals
+ * @description Retrieves a list of all active proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.alliance.proposals();
+ * console.log(proposals);
+ * ```
+ */
+exports.proposals = (0, index_js_1.proposals)('allianceMotion');
+/**
+ * @name prime
+ * @description Retrieves the prime member of the "allianceMotion" collective, if one exists.
+ * @example
+ * ```javascript
+ * const primeMember = await api.derive.alliance.prime();
+ * console.log(primeMember);
+ * ```
+ */
+exports.prime = (0, index_js_1.prime)('allianceMotion');

package/build/cjs/augment.d.ts

@@ -0,0 +1 @@
+import '@pezkuwi/api-augment';

package/build/cjs/augment.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@pezkuwi/api-augment");

package/build/cjs/bagsList/get.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi } from '../types.js';
+import type { Bag } from './types.js';
+export declare function _getIds(instanceId: string, api: DeriveApi): (ids: (BN | number)[]) => Observable<Bag[]>;
+export declare function all(instanceId: string, api: DeriveApi): () => Observable<Bag[]>;
+/**
+ * @name get
+ * @param {(BN | number)} id The id of the bag to retrieve.
+ * @description Retrieves a specific bag from the BagsList pallet by its id.
+ */
+export declare function get(instanceId: string, api: DeriveApi): (id: BN | number) => Observable<Bag>;

package/build/cjs/bagsList/get.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getIds = _getIds;
+exports.all = all;
+exports.get = get;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+function orderBags(ids, bags) {
+    const sorted = ids
+        .map((id, index) => ({
+        bag: bags[index].unwrapOr(null),
+        id,
+        key: id.toString()
+    }))
+        .sort((a, b) => b.id.cmp(a.id));
+    const max = sorted.length - 1;
+    return sorted.map((entry, index) => (0, util_1.objectSpread)(entry, {
+        bagLower: index === max
+            ? util_1.BN_ZERO
+            : sorted[index + 1].id,
+        bagUpper: entry.id,
+        index
+    }));
+}
+function _getIds(instanceId, api) {
+    const query = (0, util_js_1.getQueryInterface)(api);
+    return (0, index_js_1.memo)(instanceId, (_ids) => {
+        const ids = _ids.map((id) => (0, util_1.bnToBn)(id));
+        return ids.length
+            ? query.listBags.multi(ids).pipe((0, rxjs_1.map)((bags) => orderBags(ids, bags)))
+            : (0, rxjs_1.of)([]);
+    });
+}
+function all(instanceId, api) {
+    const query = (0, util_js_1.getQueryInterface)(api);
+    return (0, index_js_1.memo)(instanceId, () => query.listBags.keys().pipe((0, rxjs_1.switchMap)((keys) => api.derive.bagsList._getIds(keys.map(({ args: [id] }) => id))), (0, rxjs_1.map)((list) => list.filter(({ bag }) => bag))));
+}
+/**
+ * @name get
+ * @param {(BN | number)} id The id of the bag to retrieve.
+ * @description Retrieves a specific bag from the BagsList pallet by its id.
+ */
+function get(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (id) => api.derive.bagsList._getIds([(0, util_1.bnToBn)(id)]).pipe((0, rxjs_1.map)((bags) => bags[0])));
+}

package/build/cjs/bagsList/getExpanded.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi } from '../types.js';
+import type { Bag, BagExpanded } from './types.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 declare function expand(instanceId: string, api: DeriveApi): (bag: Bag) => Observable<BagExpanded>;
+/**
+ * @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 declare function getExpanded(instanceId: string, api: DeriveApi): (id: BN | number) => Observable<BagExpanded>;

package/build/cjs/bagsList/getExpanded.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expand = expand;
+exports.getExpanded = getExpanded;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../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.
+ */
+function expand(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (bag) => api.derive.bagsList.listNodes(bag.bag).pipe((0, rxjs_1.map)((nodes) => (0, util_1.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.
+ */
+function getExpanded(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (id) => api.derive.bagsList.get(id).pipe((0, rxjs_1.switchMap)((bag) => api.derive.bagsList.expand(bag))));
+}

package/build/cjs/bagsList/index.d.ts

@@ -0,0 +1,3 @@
+export * from './get.js';
+export * from './getExpanded.js';
+export * from './listNodes.js';

package/build/cjs/bagsList/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./get.js"), exports);
+tslib_1.__exportStar(require("./getExpanded.js"), exports);
+tslib_1.__exportStar(require("./listNodes.js"), exports);

package/build/cjs/bagsList/listNodes.d.ts

@@ -0,0 +1,9 @@
+import type { Observable } from 'rxjs';
+import type { PezpalletBagsListListBag, PezpalletBagsListListNode } from '@pezkuwi/types/lookup';
+import type { DeriveApi } from '../types.js';
+/**
+ * @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 declare function listNodes(instanceId: string, api: DeriveApi): (bag: PezpalletBagsListListBag | null) => Observable<PezpalletBagsListListNode[]>;

package/build/cjs/bagsList/listNodes.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listNodes = listNodes;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+function traverseLinks(api, head) {
+    const subject = new rxjs_1.BehaviorSubject(head);
+    const query = (0, util_js_1.getQueryInterface)(api);
+    return subject.pipe((0, rxjs_1.switchMap)((account) => query.listNodes(account)), (0, rxjs_1.tap)((node) => {
+        (0, util_1.nextTick)(() => {
+            node.isSome && node.value.next.isSome
+                ? subject.next(node.unwrap().next.unwrap())
+                : subject.complete();
+        });
+    }), (0, rxjs_1.toArray)(), // toArray since we want to startSubject to be completed
+    (0, rxjs_1.map)((all) => 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.
+ */
+function listNodes(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (bag) => bag && bag.head.isSome
+        ? traverseLinks(api, bag.head.unwrap())
+        : (0, rxjs_1.of)([]));
+}

package/build/cjs/bagsList/types.d.ts

@@ -0,0 +1,13 @@
+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/build/cjs/bagsList/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/bagsList/util.d.ts

@@ -0,0 +1,2 @@
+import type { DeriveApi } from '../types.js';
+export declare function getQueryInterface(api: DeriveApi): DeriveApi['query']['voterList'];

package/build/cjs/bagsList/util.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQueryInterface = getQueryInterface;
+function getQueryInterface(api) {
+    return (
+    // latest bizinikiwi & pezkuwi
+    api.query.voterList ||
+        // previous bizinikiwi
+        api.query['voterBagsList'] ||
+        api.query['bagsList']);
+}

package/build/cjs/balances/account.d.ts

@@ -0,0 +1,17 @@
+import type { Observable } from 'rxjs';
+import type { AccountId, AccountIndex, Address } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveBalancesAccount } from '../types.js';
+/**
+ * @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 declare function account(instanceId: string, api: DeriveApi): (address: AccountIndex | AccountId | Address | string) => Observable<DeriveBalancesAccount>;

package/build/cjs/balances/account.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.account = account;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+function zeroBalance(api) {
+    return api.registry.createType('Balance');
+}
+function getBalance(api, [freeBalance, reservedBalance, frozenFeeOrFrozen, frozenMiscOrFlags], accType) {
+    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, [accountId, [accountNonce, [primary, ...additional], accType]]) {
+    return (0, util_1.objectSpread)({
+        accountId,
+        accountNonce,
+        additional: additional.map((b) => getBalance(api, b, accType))
+    }, getBalance(api, primary, accType));
+}
+function queryBalancesFree(api, accountId) {
+    return (0, rxjs_1.combineLatest)([
+        api.query.balances['freeBalance'](accountId),
+        api.query.balances['reservedBalance'](accountId),
+        api.query.system['accountNonce'](accountId)
+    ]).pipe((0, rxjs_1.map)(([freeBalance, reservedBalance, accountNonce]) => [
+        accountNonce,
+        [[freeBalance, reservedBalance, zeroBalance(api), zeroBalance(api)]],
+        { isFrameAccountData: false }
+    ]));
+}
+function queryNonceOnly(api, accountId) {
+    const fill = (nonce) => [
+        nonce,
+        [[zeroBalance(api), zeroBalance(api), zeroBalance(api), zeroBalance(api)]],
+        { isFrameAccountData: false }
+    ];
+    return (0, util_1.isFunction)(api.query.system.account)
+        ? api.query.system.account(accountId).pipe((0, rxjs_1.map)(({ nonce }) => fill(nonce)))
+        : (0, util_1.isFunction)(api.query.system['accountNonce'])
+            ? api.query.system['accountNonce'](accountId).pipe((0, rxjs_1.map)((nonce) => fill(nonce)))
+            : (0, rxjs_1.of)(fill(api.registry.createType('Index')));
+}
+function queryBalancesAccount(api, accountId, modules = ['balances']) {
+    const balances = modules
+        .map((m) => api.derive[m]?.customAccount || api.query[m]?.account)
+        .filter((q) => (0, util_1.isFunction)(q));
+    const extract = (nonce, data) => [
+        nonce,
+        data.map(({ feeFrozen, free, miscFrozen, reserved }) => [free, reserved, feeFrozen, miscFrozen]),
+        { isFrameAccountData: false }
+    ];
+    // NOTE this is for the first case where we do have instances specified
+    return balances.length
+        ? (0, util_1.isFunction)(api.query.system.account)
+            ? (0, rxjs_1.combineLatest)([
+                api.query.system.account(accountId),
+                ...balances.map((c) => c(accountId))
+            ]).pipe((0, rxjs_1.map)(([{ nonce }, ...balances]) => extract(nonce, balances)))
+            : (0, rxjs_1.combineLatest)([
+                api.query.system['accountNonce'](accountId),
+                ...balances.map((c) => c(accountId))
+            ]).pipe((0, rxjs_1.map)(([nonce, ...balances]) => extract(nonce, balances)))
+        : queryNonceOnly(api, accountId);
+}
+function querySystemAccount(api, accountId) {
+    // AccountInfo is current, support old, eg. Edgeware
+    return api.query.system.account(accountId).pipe((0, rxjs_1.map)((infoOrTuple) => {
+        const data = infoOrTuple.nonce
+            ? infoOrTuple.data
+            : infoOrTuple[1];
+        const nonce = infoOrTuple.nonce || infoOrTuple[0];
+        if (!data || data.isEmpty) {
+            return [
+                nonce,
+                [[zeroBalance(api), zeroBalance(api), zeroBalance(api), zeroBalance(api)]],
+                { isFrameAccountData: false }
+            ];
+        }
+        const isFrameType = !!infoOrTuple.data.frozen;
+        if (isFrameType) {
+            const { flags, free, frozen, reserved } = data;
+            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.`);
+ * });
+ * ```
+ */
+function account(instanceId, api) {
+    const balanceInstances = api.registry.getModuleInstances(api.runtimeVersion.specName, 'balances');
+    const nonDefaultBalances = balanceInstances && balanceInstances[0] !== 'balances';
+    return (0, index_js_1.memo)(instanceId, (address) => api.derive.accounts.accountId(address).pipe((0, rxjs_1.switchMap)((accountId) => (accountId
+        ? (0, rxjs_1.combineLatest)([
+            (0, rxjs_1.of)(accountId),
+            nonDefaultBalances
+                ? queryBalancesAccount(api, accountId, balanceInstances)
+                : (0, util_1.isFunction)(api.query.system?.account)
+                    ? querySystemAccount(api, accountId)
+                    : (0, util_1.isFunction)(api.query.balances?.account)
+                        ? queryBalancesAccount(api, accountId)
+                        : (0, util_1.isFunction)(api.query.balances?.['freeBalance'])
+                            ? queryBalancesFree(api, accountId)
+                            : queryNonceOnly(api, accountId)
+        ])
+        : (0, rxjs_1.of)([api.registry.createType('AccountId'), [
+                api.registry.createType('Index'),
+                [[zeroBalance(api), zeroBalance(api), zeroBalance(api), zeroBalance(api)]],
+                { isFrameAccountData: false }
+            ]]))), (0, rxjs_1.map)((result) => calcBalances(api, result))));
+}

package/build/cjs/balances/all.d.ts

@@ -0,0 +1,20 @@
+import type { Observable } from 'rxjs';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveBalancesAll } from '../types.js';
+/**
+ * @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 declare function all(instanceId: string, api: DeriveApi): (address: AccountId | string) => Observable<DeriveBalancesAll>;

package/build/cjs/balances/all.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.all = all;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const VESTING_ID = '0x76657374696e6720';
+function calcLocked(api, bestNumber, locks) {
+    let lockedBalance = api.registry.createType('Balance');
+    let lockedBreakdown = [];
+    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.filter(({ until }) => !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, { amount }) => result.iadd(amount), new util_1.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', (0, util_1.bnMax)(...notAll.map(({ amount }) => amount)));
+        }
+    }
+    return { allLocked, lockedBalance, lockedBreakdown, vestingLocked };
+}
+function calcShared(api, bestNumber, data, locks) {
+    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 util_1.BN(0) : ED;
+        const frozenReserveDif = frameSystemAccountInfo.frozen.sub(reservedBalance);
+        transferable = api.registry.createType('Balance', allLocked
+            ? 0
+            : (0, util_1.bnMax)(new util_1.BN(0), freeBalance.sub((0, util_1.bnMax)(maybeED, frozenReserveDif))));
+    }
+    return (0, util_1.objectSpread)({}, data, {
+        availableBalance: api.registry.createType('Balance', allLocked ? 0 : (0, util_1.bnMax)(new util_1.BN(0), data?.freeBalance ? data.freeBalance.sub(lockedBalance) : new util_1.BN(0))),
+        lockedBalance,
+        lockedBreakdown,
+        transferable,
+        vestingLocked
+    });
+}
+function calcVesting(bestNumber, shared, _vesting) {
+    // 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)
+        ? (0, util_1.bnMin)(locked, perBlock.mul(bestNumber.sub(startingBlock)))
+        : util_1.BN_ZERO);
+    const vestedBalance = vestedBalances.reduce((all, value) => all.iadd(value), new util_1.BN(0));
+    const vestingTotal = vesting.reduce((all, { locked }) => all.iadd(locked), new util_1.BN(0));
+    return {
+        isVesting,
+        vestedBalance,
+        vestedClaimable: isVesting
+            ? shared.vestingLocked.sub(vestingTotal.sub(vestedBalance))
+            : util_1.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, result) {
+    const [data, [vesting, allLocks, namedReserves], bestNumber] = result;
+    const shared = calcShared(api, bestNumber, data, allLocks[0]);
+    return (0, util_1.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
+    });
+}
+function queryOld(api, accountId) {
+    return (0, rxjs_1.combineLatest)([
+        api.query.balances.locks(accountId),
+        api.query.balances['vesting'](accountId)
+    ]).pipe((0, rxjs_1.map)(([locks, optVesting]) => {
+        let vestingNew = null;
+        if (optVesting.isSome) {
+            const { offset: locked, perBlock, startingBlock } = optVesting.unwrap();
+            vestingNew = api.registry.createType('VestingInfo', { locked, perBlock, startingBlock });
+        }
+        return [
+            vestingNew
+                ? [vestingNew]
+                : null,
+            [locks],
+            []
+        ];
+    }));
+}
+const isNonNullable = (nullable) => !!nullable;
+function createCalls(calls) {
+    return [
+        calls.map((c) => !c),
+        calls.filter(isNonNullable)
+    ];
+}
+function queryCurrent(api, accountId, balanceInstances = ['balances']) {
+    const [lockEmpty, lockQueries] = createCalls(balanceInstances.map((m) => api.derive[m]?.customLocks || api.query[m]?.locks));
+    const [reserveEmpty, reserveQueries] = createCalls(balanceInstances.map((m) => api.query[m]?.reserves));
+    return (0, rxjs_1.combineLatest)([
+        api.query.vesting?.vesting
+            ? api.query.vesting.vesting(accountId)
+            : (0, rxjs_1.of)(api.registry.createType('Option<VestingInfo>')),
+        lockQueries.length
+            ? (0, rxjs_1.combineLatest)(lockQueries.map((c) => c(accountId)))
+            : (0, rxjs_1.of)([]),
+        reserveQueries.length
+            ? (0, rxjs_1.combineLatest)(reserveQueries.map((c) => c(accountId)))
+            : (0, rxjs_1.of)([])
+    ]).pipe((0, rxjs_1.map)(([opt, locks, reserves]) => {
+        let offsetLock = -1;
+        let offsetReserve = -1;
+        const vesting = opt.unwrapOr(null);
+        return [
+            vesting
+                ? Array.isArray(vesting)
+                    ? vesting
+                    : [vesting]
+                : null,
+            lockEmpty.map((e) => e ? api.registry.createType('Vec<BalanceLock>') : locks[++offsetLock]),
+            reserveEmpty.map((e) => e ? api.registry.createType('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]}`)
+ *   );
+ * });
+ * ```
+ */
+function all(instanceId, api) {
+    const balanceInstances = api.registry.getModuleInstances(api.runtimeVersion.specName, 'balances');
+    return (0, index_js_1.memo)(instanceId, (address) => (0, rxjs_1.combineLatest)([
+        api.derive.balances.account(address),
+        (0, util_1.isFunction)(api.query.system?.account) || (0, util_1.isFunction)(api.query.balances?.account)
+            ? queryCurrent(api, address, balanceInstances)
+            : queryOld(api, address)
+    ]).pipe((0, rxjs_1.switchMap)(([account, locks]) => (0, rxjs_1.combineLatest)([
+        (0, rxjs_1.of)(account),
+        (0, rxjs_1.of)(locks),
+        api.derive.chain.bestNumber()
+    ])), (0, rxjs_1.map)((result) => calcBalances(api, result))));
+}

package/build/cjs/balances/index.d.ts

@@ -0,0 +1,20 @@
+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.`);
+ * });
+ * ```
+ */
+declare const votingBalance: typeof all;
+export { all, votingBalance };