@pezkuwi/api-derive 16.5.11 → 16.5.13

package/build/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/build/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/build/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/build/util/types.js

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

package/build-deno/README.md

@@ -0,0 +1,30 @@
+# @pezkuwi/api-derive
+
+Collection of high-level utility functions built on top of the @pezkuwi/api library. Designed to simplify the process of querying complex on-chain data by combining multiple RPC calls, storage queries, and runtime logic into a single, callable function.
+
+Instead of manually fetching and processing blockchain data, developers can use `api.derive` methods to retrieve information.
+
+## Available Derive Namespaces
+
+The derive functions are categorized into namespaces based on different common Bizinikiwi modules. Accesible by calling `api.derive.NAMESPACE` (e.g. `api.derive.balances`). The available modules are as follows:
+
+- [accounts](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/accounts)
+- [alliance](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/alliance)
+- [bagsList](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/bagsList)
+- [balances](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/balances)
+- [bounties](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/bounties)
+- [chain](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/chain)
+- [contracts](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/contracts)
+- [council](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/council)
+- [crowdloan](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/crowdloan)
+- [democracy](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/democracy)
+- [elections](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/elections)
+- [imOnline](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/imOnline)
+- [membership](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/membership)
+- [teyrchains](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/teyrchains)
+- [session](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/session)
+- [society](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/society)
+- [staking](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/staking)
+- [technicalCommittee](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/technicalCommittee)
+- [treasury](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/treasury)
+- [tx](https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api-derive/src/tx)

package/build-deno/accounts/accountId.ts

@@ -0,0 +1,42 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AccountId, AccountIndex, Address } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { map, of } from 'https://esm.sh/rxjs@7.8.1';
+
+import { assertReturn, isU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import { decodeAddress } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @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/build-deno/accounts/flags.ts

@@ -0,0 +1,88 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AccountId, Address, Balance } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type{ PezpalletElectionsPhragmenSeatHolder } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { Codec } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { Option } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
+import type { DeriveAccountFlags, DeriveApi } from '../types.ts';
+
+import { map, of } from 'https://esm.sh/rxjs@7.8.1';
+
+import { isFunction } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+
+type FlagsIntermediate = [
+  PezpalletElectionsPhragmenSeatHolder[] | [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/build-deno/accounts/idAndIndex.ts

@@ -0,0 +1,49 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AccountId, AccountIndex, Address } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { AccountIdAndIndex, DeriveApi } from '../types.ts';
+
+import { map, of } from 'https://esm.sh/rxjs@7.8.1';
+
+import { isU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import { decodeAddress } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @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/build-deno/accounts/idToIndex.ts

@@ -0,0 +1,29 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AccountId, AccountIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { AccountIndexes, DeriveApi } from '../types.ts';
+
+import { map } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @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/build-deno/accounts/identity.ts

@@ -0,0 +1,230 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { Bytes, Data, Struct } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { AccountId, H160 } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezpalletIdentityLegacyIdentityInfo, PezpalletIdentityRegistration } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { Option } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
+import type { ITuple } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
+import type { DeriveAccountRegistration, DeriveApi, DeriveHasIdentity } from '../types.ts';
+
+import { combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { isHex, u8aToString } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { firstMemo, memo } from '../util/index.ts';
+
+type IdentityInfoAdditional = PezpalletIdentityLegacyIdentityInfo['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;
+  }, {});
+}
+
+function identityCompat (identityOfOpt: Option<ITuple<[PezpalletIdentityRegistration, Option<Bytes>]>> | Option<PezpalletIdentityRegistration>): PezpalletIdentityRegistration {
+  const identity = identityOfOpt.unwrap();
+
+  return Array.isArray(identity)
+    ? identity[0]
+    : identity;
+}
+
+function extractIdentity (identityOfOpt?: Option<ITuple<[PezpalletIdentityRegistration, Option<Bytes>]>> | Option<PezpalletIdentityRegistration>, 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<[PezpalletIdentityRegistration, Option<Bytes>]>> | Option<PezpalletIdentityRegistration> | undefined, superOfOpt: Option<ITuple<[AccountId, Data]>> | undefined): Observable<[Option<ITuple<[PezpalletIdentityRegistration, Option<Bytes>]>> | Option<PezpalletIdentityRegistration> | 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<[PezpalletIdentityRegistration, Option<Bytes>]>> | Option<PezpalletIdentityRegistration> | undefined, Option<ITuple<[AccountId, Data]>> | undefined]> {
+  return memo(instanceId, (accountId?: AccountId | Uint8Array | string): Observable<[Option<ITuple<[PezpalletIdentityRegistration, Option<Bytes>]>> | Option<PezpalletIdentityRegistration> | 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)
+      )
+    )
+  );
+}
+
+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/build-deno/accounts/index.ts

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

package/build-deno/accounts/indexToId.ts

@@ -0,0 +1,31 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AccountId, AccountIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { map, of } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @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/build-deno/accounts/indexes.ts

@@ -0,0 +1,54 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AccountIndexes, DeriveApi } from '../types.ts';
+
+import { map, of, startWith } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+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;
+        })
+      )
+  );
+}

package/build-deno/accounts/info.ts

@@ -0,0 +1,56 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { Bytes, Option, u32 } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { AccountId, AccountIndex, Address, Balance } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { ITuple } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { DeriveAccountInfo, DeriveAccountRegistration, DeriveApi } from '../types.ts';
+
+import { combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { u8aToString } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+
+function retrieveNick (api: DeriveApi, accountId?: AccountId): Observable<string | undefined> {
+  return ((
+    accountId && api.query['nicks']?.['nameOf']
+      ? api.query['nicks']['nameOf'](accountId)
+      : of(undefined)
+  ) as Observable<Option<ITuple<[Bytes, Balance]>> | undefined>).pipe(
+    map((nameOf): string | undefined =>
+      nameOf?.isSome
+        ? u8aToString(nameOf.unwrap()[0]).substring(0, (api.consts['nicks']['maxLength'] as u32).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: string, api: DeriveApi): (address?: AccountIndex | AccountId | Address | Uint8Array | string | null) => Observable<DeriveAccountInfo> {
+  return memo(instanceId, (address?: AccountIndex | AccountId | Address | Uint8Array | string | null): Observable<DeriveAccountInfo> =>
+    api.derive.accounts.idAndIndex(address).pipe(
+      switchMap(([accountId, accountIndex]): Observable<[Partial<DeriveAccountInfo>, DeriveAccountRegistration, string | undefined]> =>
+        combineLatest([
+          of({ accountId, accountIndex }),
+          api.derive.accounts.identity(accountId),
+          retrieveNick(api, accountId)
+        ])
+      ),
+      map(([{ accountId, accountIndex }, identity, nickname]): DeriveAccountInfo => ({
+        accountId, accountIndex, identity, nickname
+      }))
+    ));
+}