@pezkuwi/api-derive 16.5.5 → 16.5.6

package/util/cacheImpl.js

@@ -0,0 +1,23 @@
+const mapCache = new Map();
+export const deriveMapCache = {
+    del: (key) => {
+        mapCache.delete(key);
+    },
+    forEach: (cb) => {
+        for (const [k, v] of mapCache.entries()) {
+            cb(k, v);
+        }
+    },
+    get: (key) => {
+        return mapCache.get(key);
+    },
+    set: (key, value) => {
+        mapCache.set(key, value);
+    }
+};
+export const deriveNoopCache = {
+    del: () => undefined,
+    forEach: () => undefined,
+    get: () => undefined,
+    set: (_, value) => value
+};

package/util/first.d.ts

@@ -0,0 +1,4 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi } from '../types.js';
+export declare function firstObservable<T>(obs: Observable<T[]>): Observable<T>;
+export declare function firstMemo<T, A extends any[]>(fn: (api: DeriveApi, ...args: A) => Observable<T[]>): (instanceId: string, api: DeriveApi) => (...args: A) => Observable<T>;

package/util/first.js

@@ -0,0 +1,8 @@
+import { map } from 'rxjs';
+import { memo } from '@pezkuwi/rpc-core';
+export function firstObservable(obs) {
+    return obs.pipe(map(([a]) => a));
+}
+export function firstMemo(fn) {
+    return (instanceId, api) => memo(instanceId, (...args) => firstObservable(fn(api, ...args)));
+}

package/{src/util/index.ts → util/index.d.ts}

@@ -1,10 +1,4 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// all named
 export { drr, memo } from '@pezkuwi/rpc-core';
-
-// all starred
 export * from './approvalFlagsToBools.js';
 export * from './blockNumber.js';
 export * from './cache.js';

package/util/index.js

@@ -0,0 +1,7 @@
+export { drr, memo } from '@pezkuwi/rpc-core';
+export * from './approvalFlagsToBools.js';
+export * from './blockNumber.js';
+export * from './cache.js';
+export * from './cacheImpl.js';
+export * from './first.js';
+export * from './lazy.js';

package/util/lazy.d.ts

@@ -0,0 +1,4 @@
+type LazySection<T> = Record<string, T>;
+type LazyRecord<T> = Record<string, LazySection<T>>;
+export declare function lazyDeriveSection<T>(result: LazyRecord<T>, section: string, getKeys: (s: string) => string[], creator: (s: string, m: string) => T): void;
+export {};

package/util/lazy.js

@@ -0,0 +1,4 @@
+import { lazyMethod, lazyMethods } from '@pezkuwi/util';
+export function lazyDeriveSection(result, section, getKeys, creator) {
+    lazyMethod(result, section, () => lazyMethods({}, getKeys(section), (method) => creator(section, method)));
+}

package/util/types.d.ts

@@ -0,0 +1,6 @@
+export interface DeriveCache {
+    del: (key: string) => void;
+    forEach: (cb: (key: string, value: any) => void) => void;
+    get: <T = any>(key: string) => T | undefined;
+    set: (key: string, value: any) => void;
+}

package/util/types.js

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

package/build/bagsList/listNodes.d.ts

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

package/build/parachains/overview.d.ts

@@ -1,15 +0,0 @@
-import type { Observable } from 'rxjs';
-import type { DeriveApi, DeriveParachain } from '../types.js';
-/**
- * @name overview
- * @description Retrieves an overview of all registered parachains.
- * @example
- * ```javascript
- * await api.derive.parachains.overview((overview) => {
- *   parachains.forEach(parachain => {
- *     console.log(`Parachain ${parachain.id.toString()} is registered.`);
- *   });
- * });
- * ```
- */
-export declare function overview(instanceId: string, api: DeriveApi): () => Observable<DeriveParachain[]>;

package/src/accounts/accountId.ts

@@ -1,44 +0,0 @@
-// 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 } from '../types.js';
-
-import { map, of } from 'rxjs';
-
-import { assertReturn, isU8a } from '@pezkuwi/util';
-import { decodeAddress } from '@pezkuwi/util-crypto';
-
-import { memo } from '../util/index.js';
-
-/**
- * @name accountId
- * @param {(Address | AccountId | AccountIndex | string | null)} address An accounts address in various formats.
- * @description Resolves an address (in different formats) to its corresponding `AccountId`.
- * @example
- * ```javascript
- * const ALICE = "F7Hs";
- *
- * api.derive.accounts.accountId(ALICE, (accountId) => {
- *   console.log(`Resolved AccountId: ${accountId}`);
- * });
- * ```
- */
-export function accountId (instanceId: string, api: DeriveApi): (address?: Address | AccountId | AccountIndex | string | null) => Observable<AccountId> {
-  return memo(instanceId, (address?: Address | AccountId | AccountIndex | string | null): Observable<AccountId> => {
-    const decoded = isU8a(address)
-      ? address
-      : decodeAddress((address || '').toString());
-
-    if (decoded.length > 8) {
-      return of(api.registry.createType(decoded.length === 20 ? 'AccountId20' : 'AccountId', decoded));
-    }
-
-    const accountIndex = api.registry.createType('AccountIndex', decoded);
-
-    return api.derive.accounts.indexToId(accountIndex.toString()).pipe(
-      map((a) => assertReturn(a, 'Unable to retrieve accountId'))
-    );
-  });
-}

package/src/accounts/flags.ts

@@ -1,90 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { AccountId, Address, Balance } from '@pezkuwi/types/interfaces';
-import type{ PalletElectionsPhragmenSeatHolder } from '@pezkuwi/types/lookup';
-import type { Codec } from '@pezkuwi/types/types';
-import type { Option } from '@pezkuwi/types-codec';
-import type { DeriveAccountFlags, DeriveApi } from '../types.js';
-
-import { map, of } from 'rxjs';
-
-import { isFunction } from '@pezkuwi/util';
-
-import { memo } from '../util/index.js';
-
-type FlagsIntermediate = [
-  PalletElectionsPhragmenSeatHolder[] | [AccountId, Balance][] | undefined,
-  AccountId[],
-  AccountId[],
-  AccountId[],
-  Option<AccountId> | AccountId | undefined
-];
-
-function parseFlags (address: AccountId | Address | string | null | undefined, [electionsMembers, councilMembers, technicalCommitteeMembers, societyMembers, sudoKey]: FlagsIntermediate): DeriveAccountFlags {
-  const addrStr = address?.toString();
-  const isIncluded = (id: AccountId | Address | string) =>
-    id.toString() === addrStr;
-
-  return {
-    isCouncil: (electionsMembers?.map((r) => Array.isArray(r) ? r[0] : r.who) || councilMembers || []).some(isIncluded),
-    isSociety: (societyMembers || []).some(isIncluded),
-    isSudo: sudoKey?.toString() === addrStr,
-    isTechCommittee: (technicalCommitteeMembers || []).some(isIncluded)
-  };
-}
-
-export function _flags (instanceId: string, api: DeriveApi): () => Observable<FlagsIntermediate> {
-  return memo(instanceId, (): Observable<FlagsIntermediate> => {
-    const results: unknown[] = [undefined, [], [], [], undefined];
-    const calls = [
-      (api.query.elections || api.query['phragmenElection'] || api.query['electionsPhragmen'])?.members,
-      api.query.council?.members,
-      api.query.technicalCommittee?.members,
-      api.query.society?.members,
-      api.query.sudo?.key
-    ];
-    const filtered = calls.filter((c) => c);
-
-    if (!filtered.length) {
-      return of(results as FlagsIntermediate);
-    }
-
-    return api.queryMulti(filtered).pipe(
-      map((values: Codec[]): FlagsIntermediate => {
-        let resultIndex = -1;
-
-        for (let i = 0, count = calls.length; i < count; i++) {
-          if (isFunction(calls[i])) {
-            results[i] = values[++resultIndex];
-          }
-        }
-
-        return results as FlagsIntermediate;
-      })
-    );
-  });
-}
-
-/**
- * @name flags
- * @param {(AccountId | Address | string | null)} address The account identifier.
- * @description Retrieves the membership flags for a given account.
- * @example
- * const ALICE = "F7Hs";
- *
- * api.derive.accounts.flags(ALICE, (flags) => {
- *   console.log(
- *     `Account Flags:`,
- *     Object.keys(flags).map((flag) => `${flag}: ${flags[flag]}`)
- *   );
- * });
- */
-export function flags (instanceId: string, api: DeriveApi): (address?: AccountId | Address | string | null) => Observable<DeriveAccountFlags> {
-  return memo(instanceId, (address?: AccountId | Address | string | null): Observable<DeriveAccountFlags> =>
-    api.derive.accounts._flags().pipe(
-      map((r) => parseFlags(address, r))
-    )
-  );
-}

package/src/accounts/idAndIndex.ts

@@ -1,51 +0,0 @@
-// 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 { AccountIdAndIndex, DeriveApi } from '../types.js';
-
-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: string, api: DeriveApi): (address?: Address | AccountId | AccountIndex | Uint8Array | string | null) => Observable<AccountIdAndIndex> {
-  return memo(instanceId, (address?: Address | AccountId | AccountIndex | Uint8Array | string | null): Observable<AccountIdAndIndex> => {
-    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): AccountIdAndIndex => [accountId, accountIndex])
-        );
-      }
-
-      const accountIndex = api.registry.createType('AccountIndex', decoded);
-
-      return api.derive.accounts.indexToId(accountIndex.toString()).pipe(
-        map((accountId): AccountIdAndIndex => [accountId, accountIndex])
-      );
-    } catch {
-      return of([undefined, undefined]);
-    }
-  });
-}

package/src/accounts/idToIndex.ts

@@ -1,31 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { AccountId, AccountIndex } from '@pezkuwi/types/interfaces';
-import type { AccountIndexes, DeriveApi } from '../types.js';
-
-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: string, api: DeriveApi): (accountId: AccountId | string) => Observable<AccountIndex | undefined> {
-  return memo(instanceId, (accountId: AccountId | string): Observable<AccountIndex | undefined> =>
-    api.derive.accounts.indexes().pipe(
-      map((indexes: AccountIndexes): AccountIndex | undefined =>
-        indexes[accountId.toString()]
-      )
-    ));
-}

package/src/accounts/identity.ts

@@ -1,235 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { Bytes, Data, Struct } from '@pezkuwi/types';
-import type { AccountId, H160 } from '@pezkuwi/types/interfaces';
-import type { PalletIdentityLegacyIdentityInfo, PalletIdentityRegistration } from '@pezkuwi/types/lookup';
-import type { Option } from '@pezkuwi/types-codec';
-import type { ITuple } from '@pezkuwi/types-codec/types';
-import type { DeriveAccountRegistration, DeriveApi, DeriveHasIdentity } from '../types.js';
-
-import { combineLatest, map, of, switchMap } from 'rxjs';
-
-import { isHex, u8aToString } from '@pezkuwi/util';
-
-import { firstMemo, memo } from '../util/index.js';
-
-type IdentityInfoAdditional = PalletIdentityLegacyIdentityInfo['additional'][0];
-
-interface PeopleIdentityInfo extends Struct {
-  display: Data;
-  legal: Data;
-  web: Data;
-  matrix: Data;
-  email: Data;
-  pgpFingerprint: Option<H160>;
-  image: Data;
-  twitter: Data;
-  github: Data;
-  discord: Data;
-}
-
-const UNDEF_HEX = { toHex: () => undefined };
-
-function dataAsString (data: Data): string | undefined {
-  if (!data) {
-    return data;
-  }
-
-  return data.isRaw
-    ? u8aToString(data.asRaw.toU8a(true))
-    : data.isNone
-      ? undefined
-      : data.toHex();
-}
-
-function extractOther (additional: IdentityInfoAdditional[]): Record<string, string> {
-  return additional.reduce((other: Record<string, string>, [_key, _value]): Record<string, string> => {
-    const key = dataAsString(_key);
-    const value = dataAsString(_value);
-
-    if (key && value) {
-      other[key] = value;
-    }
-
-    return other;
-  }, {});
-}
-
-// handle compatibility between generations of structures
-function identityCompat (identityOfOpt: Option<ITuple<[PalletIdentityRegistration, Option<Bytes>]>> | Option<PalletIdentityRegistration>): PalletIdentityRegistration {
-  const identity = identityOfOpt.unwrap();
-
-  return Array.isArray(identity)
-    ? identity[0]
-    : identity;
-}
-
-function extractIdentity (identityOfOpt?: Option<ITuple<[PalletIdentityRegistration, Option<Bytes>]>> | Option<PalletIdentityRegistration>, superOf?: [AccountId, Data]): DeriveAccountRegistration {
-  if (!identityOfOpt?.isSome) {
-    return { judgements: [] };
-  }
-
-  const { info, judgements } = identityCompat(identityOfOpt);
-  const topDisplay = dataAsString(info.display);
-
-  return {
-    discord: dataAsString((info as unknown as PeopleIdentityInfo).discord),
-    display: (superOf && dataAsString(superOf[1])) || topDisplay,
-    displayParent: superOf && topDisplay,
-    email: dataAsString(info.email),
-    github: dataAsString((info as unknown as PeopleIdentityInfo).github),
-    image: dataAsString(info.image),
-    judgements,
-    legal: dataAsString(info.legal),
-    matrix: dataAsString((info as unknown as PeopleIdentityInfo).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: DeriveApi, identityOfOpt: Option<ITuple<[PalletIdentityRegistration, Option<Bytes>]>> | Option<PalletIdentityRegistration> | undefined, superOfOpt: Option<ITuple<[AccountId, Data]>> | undefined): Observable<[Option<ITuple<[PalletIdentityRegistration, Option<Bytes>]>> | Option<PalletIdentityRegistration> | undefined, [AccountId, Data] | undefined]> {
-  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: string, api: DeriveApi): (accountId?: AccountId | Uint8Array | string) => Observable<[Option<ITuple<[PalletIdentityRegistration, Option<Bytes>]>> | Option<PalletIdentityRegistration> | undefined, Option<ITuple<[AccountId, Data]>> | undefined]> {
-  return memo(instanceId, (accountId?: AccountId | Uint8Array | string): Observable<[Option<ITuple<[PalletIdentityRegistration, Option<Bytes>]>> | Option<PalletIdentityRegistration> | undefined, Option<ITuple<[AccountId, Data]>> | undefined]> =>
-    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: string, api: DeriveApi): (accountId?: AccountId | Uint8Array | string) => Observable<DeriveAccountRegistration> {
-  return memo(instanceId, (accountId?: AccountId | Uint8Array | string): Observable<DeriveAccountRegistration> =>
-    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)
-      )
-    )
-  );
-}
-
-// if an account has no parents it will extract its subidentities
-// otherwise if the account is a subidentity, obtain all subidentities of its parent.
-function getSubIdentities (identity: DeriveAccountRegistration, api: DeriveApi, accountId?: AccountId | Uint8Array | string): Observable<DeriveAccountRegistration> {
-  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: DeriveApi, accountId: AccountId | Uint8Array | string) =>
-    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: string, api: DeriveApi): (accountIds: (AccountId | Uint8Array | string)[]) => Observable<DeriveHasIdentity[]> {
-  return memo(instanceId, (accountIds: (AccountId | Uint8Array | string)[]): Observable<DeriveHasIdentity[]> =>
-    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): DeriveHasIdentity => {
-            const superOfOpt = supers[index];
-            const parentId = superOfOpt && superOfOpt.isSome
-              ? superOfOpt.unwrap()[0].toString()
-              : undefined;
-            let display: string | undefined;
-
-            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/src/accounts/indexToId.ts

@@ -1,33 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { AccountId, AccountIndex } from '@pezkuwi/types/interfaces';
-import type { DeriveApi } from '../types.js';
-
-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: string, api: DeriveApi): (accountIndex: AccountIndex | string) => Observable<AccountId | undefined> {
-  return memo(instanceId, (accountIndex: AccountIndex | string): Observable<AccountId | undefined> =>
-    api.query.indices
-      ? api.query.indices.accounts(accountIndex).pipe(
-        map((optResult): AccountId | undefined =>
-          optResult.unwrapOr([])[0]
-        )
-      )
-      : of(undefined)
-  );
-}

package/src/accounts/indexes.ts

@@ -1,56 +0,0 @@
-// Copyright 2017-2025 @polkadot/api-derive authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Observable } from 'rxjs';
-import type { AccountIndexes, DeriveApi } from '../types.js';
-
-import { map, of, startWith } from 'rxjs';
-
-import { memo } from '../util/index.js';
-
-let indicesCache: AccountIndexes | null = null;
-
-function queryAccounts (api: DeriveApi): Observable<AccountIndexes> {
-  return api.query.indices.accounts.entries().pipe(
-    map((entries): AccountIndexes =>
-      entries.reduce((indexes: AccountIndexes, [key, idOpt]): AccountIndexes => {
-        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: string, api: DeriveApi): () => Observable<AccountIndexes> {
-  return memo(instanceId, (): Observable<AccountIndexes> =>
-    indicesCache
-      ? of(indicesCache)
-      : (
-        api.query.indices
-          ? queryAccounts(api).pipe(startWith({}))
-          : of({} as AccountIndexes)
-      ).pipe(
-        map((indices): AccountIndexes => {
-          indicesCache = indices;
-
-          return indices;
-        })
-      )
-  );
-}