@pezkuwi/api-derive 16.5.5 → 16.5.8

package/build-tsc-esm/accounts/idAndIndex.js

@@ -0,0 +1,34 @@
+import { map, of } from 'rxjs';
+import { isU8a } from '@pezkuwi/util';
+import { decodeAddress } from '@pezkuwi/util-crypto';
+import { memo } from '../util/index.js';
+/**
+ * @name idAndIndex
+ * @param {(Address | AccountId | AccountIndex | Uint8Array | string | null)} address An accounts address in various formats.
+ * @description An array containing the [[AccountId]] and [[AccountIndex]] as optional values.
+ * @example
+ * ```javascript
+ * api.derive.accounts.idAndIndex('F7Hs', ([id, ix]) => {
+ *   console.log(`AccountId #${id} with corresponding AccountIndex ${ix}`);
+ * });
+ * ```
+ */
+export function idAndIndex(instanceId, api) {
+    return memo(instanceId, (address) => {
+        try {
+            // yes, this can fail, don't care too much, catch will catch it
+            const decoded = isU8a(address)
+                ? address
+                : decodeAddress((address || '').toString());
+            if (decoded.length > 8) {
+                const accountId = api.registry.createType(decoded.length === 20 ? 'AccountId20' : 'AccountId', decoded);
+                return api.derive.accounts.idToIndex(accountId).pipe(map((accountIndex) => [accountId, accountIndex]));
+            }
+            const accountIndex = api.registry.createType('AccountIndex', decoded);
+            return api.derive.accounts.indexToId(accountIndex.toString()).pipe(map((accountId) => [accountId, accountIndex]));
+        }
+        catch {
+            return of([undefined, undefined]);
+        }
+    });
+}

package/build-tsc-esm/accounts/idToIndex.js

@@ -0,0 +1,17 @@
+import { map } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * @name idToIndex
+ * @description Retrieves the corresponding AccountIndex.
+ * @param {( AccountId | string )} accountId An accounts Id in different formats.
+ * @example
+ * ```javascript
+ * const ALICE = '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY';
+ * api.derive.accounts.idToIndex(ALICE, (accountIndex) => {
+ *   console.log(`The AccountIndex of ${ALICE} is ${accountIndex}`);
+ * });
+ * ```
+ */
+export function idToIndex(instanceId, api) {
+    return memo(instanceId, (accountId) => api.derive.accounts.indexes().pipe(map((indexes) => indexes[accountId.toString()])));
+}

package/build-tsc-esm/accounts/identity.js

@@ -0,0 +1,153 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { isHex, u8aToString } from '@pezkuwi/util';
+import { firstMemo, memo } from '../util/index.js';
+const UNDEF_HEX = { toHex: () => undefined };
+function dataAsString(data) {
+    if (!data) {
+        return data;
+    }
+    return data.isRaw
+        ? u8aToString(data.asRaw.toU8a(true))
+        : data.isNone
+            ? undefined
+            : data.toHex();
+}
+function extractOther(additional) {
+    return additional.reduce((other, [_key, _value]) => {
+        const key = dataAsString(_key);
+        const value = dataAsString(_value);
+        if (key && value) {
+            other[key] = value;
+        }
+        return other;
+    }, {});
+}
+function identityCompat(identityOfOpt) {
+    const identity = identityOfOpt.unwrap();
+    return Array.isArray(identity)
+        ? identity[0]
+        : identity;
+}
+function extractIdentity(identityOfOpt, superOf) {
+    if (!identityOfOpt?.isSome) {
+        return { judgements: [] };
+    }
+    const { info, judgements } = identityCompat(identityOfOpt);
+    const topDisplay = dataAsString(info.display);
+    return {
+        discord: dataAsString(info.discord),
+        display: (superOf && dataAsString(superOf[1])) || topDisplay,
+        displayParent: superOf && topDisplay,
+        email: dataAsString(info.email),
+        github: dataAsString(info.github),
+        image: dataAsString(info.image),
+        judgements,
+        legal: dataAsString(info.legal),
+        matrix: dataAsString(info.matrix),
+        other: info.additional ? extractOther(info.additional) : {},
+        parent: superOf?.[0],
+        pgp: info.pgpFingerprint.unwrapOr(UNDEF_HEX).toHex(),
+        riot: dataAsString(info.riot),
+        twitter: dataAsString(info.twitter),
+        web: dataAsString(info.web)
+    };
+}
+function getParent(api, identityOfOpt, superOfOpt) {
+    if (identityOfOpt?.isSome) {
+        // this identity has something set
+        return of([identityOfOpt, undefined]);
+    }
+    else if (superOfOpt?.isSome) {
+        const superOf = superOfOpt.unwrap();
+        return combineLatest([
+            api.derive.accounts._identity(superOf[0]).pipe(map(([info]) => info)),
+            of(superOf)
+        ]);
+    }
+    // nothing of value returned
+    return of([undefined, undefined]);
+}
+export function _identity(instanceId, api) {
+    return memo(instanceId, (accountId) => accountId && api.query.identity?.identityOf
+        ? combineLatest([
+            api.query.identity.identityOf(accountId),
+            api.query.identity.superOf(accountId)
+        ])
+        : of([undefined, undefined]));
+}
+/**
+ * @name identity
+ * @description Retrieves the on chain identity information for a given account.
+ * @param {(AccountId | Uint8Array | string)} accoutId The account identifier to query the identity for.
+ * @example
+ * ```javascript
+ * const ALICE = "13xAUH";
+ *
+ * api.derive.accounts.identity(ALICE, (identity) => {
+ *   console.log(
+ *     "Account Identity:",
+ *     Object.keys(identity).map((key) => `${key}: ${identity[key]}`)
+ *   );
+ * });
+ * ```
+ */
+export function identity(instanceId, api) {
+    return memo(instanceId, (accountId) => api.derive.accounts._identity(accountId).pipe(switchMap(([identityOfOpt, superOfOpt]) => getParent(api, identityOfOpt, superOfOpt)), map(([identityOfOpt, superOf]) => extractIdentity(identityOfOpt, superOf)), switchMap((identity) => getSubIdentities(identity, api, accountId))));
+}
+function getSubIdentities(identity, api, accountId) {
+    const targetAccount = identity.parent || accountId;
+    if (!targetAccount || !api.query.identity) {
+        // No valid accountId return the identity as-is
+        return of(identity);
+    }
+    return api.query.identity.subsOf(targetAccount).pipe(map((subsResponse) => {
+        const subs = subsResponse[1];
+        return {
+            ...identity,
+            subs
+        };
+    }));
+}
+/**
+ * @name hasIdentity
+ * @description Checks if a specific account has an identity registered on chain.
+ * @param {(AccountId | Uint8Array | string)} accoutId The account identifier to query.
+ * @example
+ * ```javascript
+ * const ALICE = "13AU";
+ * console.log(await api.derive.accounts.hasIdentity(ALICE));
+ * ```
+ */
+export const hasIdentity = /*#__PURE__*/ firstMemo((api, accountId) => api.derive.accounts.hasIdentityMulti([accountId]));
+/**
+ * @name hasIdentityMulti
+ * @description Checks whether multiple accounts have on chain identities registered.
+ * @param {(AccountId | Uint8Array | string)[]} accountIds Array of account identifiers to query.
+ * @example
+ * ```javascript
+ * const ALICE = "13AU";
+ * const BOB = "16WW";
+ * console.log(await api.derive.accounts.hasIdentityMulti([ALICE, BOB]));
+ * ```
+ */
+export function hasIdentityMulti(instanceId, api) {
+    return memo(instanceId, (accountIds) => api.query.identity?.identityOf
+        ? combineLatest([
+            api.query.identity.identityOf.multi(accountIds),
+            api.query.identity.superOf.multi(accountIds)
+        ]).pipe(map(([identities, supers]) => identities.map((identityOfOpt, index) => {
+            const superOfOpt = supers[index];
+            const parentId = superOfOpt && superOfOpt.isSome
+                ? superOfOpt.unwrap()[0].toString()
+                : undefined;
+            let display;
+            if (identityOfOpt && identityOfOpt.isSome) {
+                const value = dataAsString(identityCompat(identityOfOpt).info.display);
+                if (value && !isHex(value)) {
+                    display = value;
+                }
+            }
+            return { display, hasIdentity: !!(display || parentId), parentId };
+        })))
+        : of(accountIds.map(() => ({ hasIdentity: false }))));
+}

package/build-tsc-esm/accounts/index.js

@@ -0,0 +1,8 @@
+export * from './accountId.js';
+export * from './flags.js';
+export * from './idAndIndex.js';
+export * from './identity.js';
+export * from './idToIndex.js';
+export * from './indexes.js';
+export * from './indexToId.js';
+export * from './info.js';

package/build-tsc-esm/accounts/indexToId.js

@@ -0,0 +1,18 @@
+import { map, of } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * @name indexToId
+ * @description Resolves an AccountIndex (short address) to the full AccountId.
+ * @param {( AccountIndex | string )} accountIndex An accounts index in different formats.
+ * @example
+ * ```javascript
+ * const ALICE = "13AU";
+ * const id = await api.derive.accounts.indexToId(ALICE);
+ * console.log(id);
+ * ```
+ */
+export function indexToId(instanceId, api) {
+    return memo(instanceId, (accountIndex) => api.query.indices
+        ? api.query.indices.accounts(accountIndex).pipe(map((optResult) => optResult.unwrapOr([])[0]))
+        : of(undefined));
+}

package/build-tsc-esm/accounts/indexes.js

@@ -0,0 +1,34 @@
+import { map, of, startWith } from 'rxjs';
+import { memo } from '../util/index.js';
+let indicesCache = null;
+function queryAccounts(api) {
+    return api.query.indices.accounts.entries().pipe(map((entries) => entries.reduce((indexes, [key, idOpt]) => {
+        if (idOpt.isSome) {
+            indexes[idOpt.unwrap()[0].toString()] = api.registry.createType('AccountIndex', key.args[0]);
+        }
+        return indexes;
+    }, {})));
+}
+/**
+ * @name indexes
+ * @returns Returns all the indexes on the system.
+ * @description This is an unwieldly query since it loops through
+ * all of the enumsets and returns all of the values found. This could be up to 32k depending
+ * on the number of active accounts in the system.
+ * @example
+ * ```javascript
+ * api.derive.accounts.indexes((indexes) => {
+ *   console.log('All existing AccountIndexes', indexes);
+ * });
+ * ```
+ */
+export function indexes(instanceId, api) {
+    return memo(instanceId, () => indicesCache
+        ? of(indicesCache)
+        : (api.query.indices
+            ? queryAccounts(api).pipe(startWith({}))
+            : of({})).pipe(map((indices) => {
+            indicesCache = indices;
+            return indices;
+        })));
+}

package/build-tsc-esm/accounts/info.js

@@ -0,0 +1,33 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { u8aToString } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+function retrieveNick(api, accountId) {
+    return (accountId && api.query['nicks']?.['nameOf']
+        ? api.query['nicks']['nameOf'](accountId)
+        : of(undefined)).pipe(map((nameOf) => nameOf?.isSome
+        ? u8aToString(nameOf.unwrap()[0]).substring(0, api.consts['nicks']['maxLength'].toNumber())
+        : undefined));
+}
+/**
+ * @name info
+ * @description Returns aux. info with regards to an account, current that includes the accountId, accountIndex, identity and nickname
+ * @param {(AccountIndex | AccountId | Address | Uint8Array | string | null)} address An accounts in different formats.
+ * @example
+ * ```javascript
+ * const ALICE = "13AU";
+ * const info = await api.derive.accounts.info(ALICE);
+ * console.log(
+ *   "Account Info: ",
+ *   Object.keys(info).map((key) => `${key}: ${info[key]}`)
+ * );
+ * ```
+ */
+export function info(instanceId, api) {
+    return memo(instanceId, (address) => api.derive.accounts.idAndIndex(address).pipe(switchMap(([accountId, accountIndex]) => combineLatest([
+        of({ accountId, accountIndex }),
+        api.derive.accounts.identity(accountId),
+        retrieveNick(api, accountId)
+    ])), map(([{ accountId, accountIndex }, identity, nickname]) => ({
+        accountId, accountIndex, identity, nickname
+    }))));
+}

package/build-tsc-esm/accounts/types.js

@@ -0,0 +1 @@
+export {};

package/build-tsc-esm/alliance/index.js

@@ -0,0 +1,71 @@
+import { hasProposals as collectiveHasProposals, members as collectiveMembers, prime as collectivePrime, proposal as collectiveProposal, proposalCount as collectiveProposalCount, proposalHashes as collectiveProposalHashes, proposals as collectiveProposals } from '../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)});
+ * ```
+ */
+export const members = /*#__PURE__*/ collectiveMembers('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);
+ * ```
+ */
+export const hasProposals = /*#__PURE__*/ collectiveHasProposals('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);
+ * ```
+ */
+export const proposal = /*#__PURE__*/ collectiveProposal('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}`);
+ * ```
+ */
+export const proposalCount = /*#__PURE__*/ collectiveProposalCount('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)}`);
+ * ```
+ */
+export const proposalHashes = /*#__PURE__*/ collectiveProposalHashes('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);
+ * ```
+ */
+export const proposals = /*#__PURE__*/ collectiveProposals('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);
+ * ```
+ */
+export const prime = /*#__PURE__*/ collectivePrime('allianceMotion');

package/build-tsc-esm/augment.js

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

package/build-tsc-esm/bagsList/get.js

@@ -0,0 +1,42 @@
+import { map, of, switchMap } from 'rxjs';
+import { BN_ZERO, bnToBn, objectSpread } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+import { getQueryInterface } from './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) => objectSpread(entry, {
+        bagLower: index === max
+            ? BN_ZERO
+            : sorted[index + 1].id,
+        bagUpper: entry.id,
+        index
+    }));
+}
+export function _getIds(instanceId, api) {
+    const query = getQueryInterface(api);
+    return memo(instanceId, (_ids) => {
+        const ids = _ids.map((id) => bnToBn(id));
+        return ids.length
+            ? query.listBags.multi(ids).pipe(map((bags) => orderBags(ids, bags)))
+            : of([]);
+    });
+}
+export function all(instanceId, api) {
+    const query = getQueryInterface(api);
+    return memo(instanceId, () => query.listBags.keys().pipe(switchMap((keys) => api.derive.bagsList._getIds(keys.map(({ args: [id] }) => id))), 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.
+ */
+export function get(instanceId, api) {
+    return memo(instanceId, (id) => api.derive.bagsList._getIds([bnToBn(id)]).pipe(map((bags) => bags[0])));
+}

package/build-tsc-esm/bagsList/getExpanded.js

@@ -0,0 +1,19 @@
+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, api) {
+    return memo(instanceId, (bag) => 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, api) {
+    return memo(instanceId, (id) => api.derive.bagsList.get(id).pipe(switchMap((bag) => api.derive.bagsList.expand(bag))));
+}

package/build-tsc-esm/bagsList/index.js

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

package/build-tsc-esm/bagsList/listNodes.js

@@ -0,0 +1,26 @@
+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, head) {
+    const subject = new BehaviorSubject(head);
+    const query = getQueryInterface(api);
+    return subject.pipe(switchMap((account) => query.listNodes(account)), tap((node) => {
+        nextTick(() => {
+            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) => 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, api) {
+    return memo(instanceId, (bag) => bag && bag.head.isSome
+        ? traverseLinks(api, bag.head.unwrap())
+        : of([]));
+}

package/build-tsc-esm/bagsList/types.js

@@ -0,0 +1 @@
+export {};

package/build-tsc-esm/bagsList/util.js

@@ -0,0 +1,8 @@
+export function getQueryInterface(api) {
+    return (
+    // latest bizinikiwi & pezkuwi
+    api.query.voterList ||
+        // previous bizinikiwi
+        api.query['voterBagsList'] ||
+        api.query['bagsList']);
+}

package/build-tsc-esm/balances/account.js

@@ -0,0 +1,149 @@
+import { combineLatest, map, of, switchMap } from 'rxjs';
+import { isFunction, objectSpread } from '@pezkuwi/util';
+import { memo } from '../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 objectSpread({
+        accountId,
+        accountNonce,
+        additional: additional.map((b) => getBalance(api, b, accType))
+    }, getBalance(api, primary, accType));
+}
+function queryBalancesFree(api, accountId) {
+    return combineLatest([
+        api.query.balances['freeBalance'](accountId),
+        api.query.balances['reservedBalance'](accountId),
+        api.query.system['accountNonce'](accountId)
+    ]).pipe(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 isFunction(api.query.system.account)
+        ? api.query.system.account(accountId).pipe(map(({ nonce }) => fill(nonce)))
+        : isFunction(api.query.system['accountNonce'])
+            ? api.query.system['accountNonce'](accountId).pipe(map((nonce) => fill(nonce)))
+            : 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) => 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
+        ? isFunction(api.query.system.account)
+            ? combineLatest([
+                api.query.system.account(accountId),
+                ...balances.map((c) => c(accountId))
+            ]).pipe(map(([{ nonce }, ...balances]) => extract(nonce, balances)))
+            : combineLatest([
+                api.query.system['accountNonce'](accountId),
+                ...balances.map((c) => c(accountId))
+            ]).pipe(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(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.`);
+ * });
+ * ```
+ */
+export function account(instanceId, api) {
+    const balanceInstances = api.registry.getModuleInstances(api.runtimeVersion.specName, 'balances');
+    const nonDefaultBalances = balanceInstances && balanceInstances[0] !== 'balances';
+    return memo(instanceId, (address) => api.derive.accounts.accountId(address).pipe(switchMap((accountId) => (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) => calcBalances(api, result))));
+}