@pezkuwi/api-derive 16.5.6 → 16.5.8

package/build-deno/council/index.ts

@@ -0,0 +1,77 @@
+
+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.ts';
+
+export * from './votes.ts';
+export * from './votesOf.ts';
+
+/**
+ * @name members
+ * @description Retrieves the list of members in the "council" collective.
+ * @example
+ * ```javascript
+ * const members = await api.derive.council.members();
+ * console.log(`Members: ${JSON.stringify(members)});
+ * ```
+ */
+export const members = /*#__PURE__*/ collectiveMembers('council');
+
+/**
+ * @name hasProposals
+ * @description Checks if there are any active proposals in the "council" collective.
+ * @example
+ * ```javascript
+ * const exists = await api.derive.council.hasProposals();
+ * console.log(exists);
+ * ```
+ */
+export const hasProposals = /*#__PURE__*/ collectiveHasProposals('council');
+/**
+ * @name proposal
+ * @description Retrieves details of a specific proposal in the "councilMotion" collective by its hash.
+ * @example
+ * ```javascript
+ * const proposalDetails = await api.derive.council.proposal(PROPOSAL_HASH);
+ * console.log(proposalDetails);
+ * ```
+ */
+export const proposal = /*#__PURE__*/ collectiveProposal('council');
+/**
+ * @name proposalCount
+ * @description Retrieves the total number of proposals in the "council" collective.
+ * @example
+ * ```javascript
+ * const count = await api.derive.council.proposalCount();
+ * console.log(`Amount of proposals: ${count}`);
+ * ```
+ */
+export const proposalCount = /*#__PURE__*/ collectiveProposalCount('council');
+/**
+ * @name proposalHashes
+ * @description Retrieves an array of hashes for all active proposals in the "council" collective.
+ * @example
+ * ```javascript
+ * const hashes = await api.derive.council.proposalHashes();
+ * console.log(`Proposals ${JSON.stringify(hashes)}`);
+ * ```
+ */
+export const proposalHashes = /*#__PURE__*/ collectiveProposalHashes('council');
+/**
+ * @name proposals
+ * @description Retrieves a list of all active proposals in the "council" collective.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.council.proposals();
+ * console.log(proposals);
+ * ```
+ */
+export const proposals = /*#__PURE__*/ collectiveProposals('council');
+/**
+ * @name prime
+ * @description Retrieves the prime member of the "council" collective, if one exists.
+ * @example
+ * ```javascript
+ * const primeMember = await api.derive.council.prime();
+ * console.log(primeMember);
+ * ```
+ */
+export const prime = /*#__PURE__*/ collectivePrime('council');

package/build-deno/council/types.ts

@@ -0,0 +1,9 @@
+
+import type { AccountId, Balance } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+
+export interface DeriveCouncilVote {
+  stake: Balance;
+  votes: AccountId[];
+}
+
+export type DeriveCouncilVotes = [AccountId, DeriveCouncilVote][];

package/build-deno/council/votes.ts

@@ -0,0 +1,94 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { QueryableModuleStorage } from 'https://deno.land/x/pezkuwi/api-base/types/index.ts';
+import type { Vec } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { AccountId, Balance } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezpalletElectionsPhragmenVoter } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { ITuple } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { DeriveApi, DeriveCouncilVote, DeriveCouncilVotes } from '../types.ts';
+
+import { combineLatest, map, of } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+type VoteEntry = PezpalletElectionsPhragmenVoter | ITuple<[Balance, Vec<AccountId>]>;
+
+function isVoter (value: VoteEntry): value is PezpalletElectionsPhragmenVoter {
+  return !Array.isArray(value);
+}
+
+function retrieveStakeOf (elections: QueryableModuleStorage<'rxjs'>): Observable<[AccountId, Balance][]> {
+  return elections['stakeOf'].entries<Balance, [AccountId]>().pipe(
+    map((entries) =>
+      entries.map(([{ args: [accountId] }, stake]) => [accountId, stake])
+    )
+  );
+}
+
+function retrieveVoteOf (elections: DeriveApi['query']['elections']): Observable<[AccountId, AccountId[]][]> {
+  return elections['votesOf'].entries<Vec<AccountId>, [AccountId]>().pipe(
+    map((entries) =>
+      entries.map(([{ args: [accountId] }, votes]) => [accountId, votes])
+    )
+  );
+}
+
+function retrievePrev (api: DeriveApi, elections: DeriveApi['query']['elections']): Observable<DeriveCouncilVotes> {
+  return combineLatest([
+    retrieveStakeOf(elections),
+    retrieveVoteOf(elections)
+  ]).pipe(
+    map(([stakes, votes]): DeriveCouncilVotes => {
+      const result: DeriveCouncilVotes = [];
+
+      votes.forEach(([voter, votes]): void => {
+        result.push([voter, { stake: api.registry.createType('Balance'), votes }]);
+      });
+
+      stakes.forEach(([staker, stake]): void => {
+        const entry = result.find(([voter]) => voter.eq(staker));
+
+        if (entry) {
+          entry[1].stake = stake;
+        } else {
+          result.push([staker, { stake, votes: [] }]);
+        }
+      });
+
+      return result;
+    })
+  );
+}
+
+function retrieveCurrent (elections: DeriveApi['query']['elections']): Observable<DeriveCouncilVotes> {
+  return elections.voting.entries<VoteEntry, [AccountId]>().pipe(
+    map((entries): DeriveCouncilVotes =>
+      entries.map(([{ args: [accountId] }, value]): [AccountId, DeriveCouncilVote] => [
+        accountId,
+        isVoter(value)
+          ? { stake: value.stake, votes: value.votes }
+          : { stake: value[0], votes: value[1] }
+      ])
+    )
+  );
+}
+
+/**
+ * @name votes
+ * @description Retrieves the council election votes for all participants.
+ * @example
+ * ```javascript
+ * const votes = await api.derive.council.votes();
+ * ```
+ */
+export function votes (instanceId: string, api: DeriveApi): () => Observable<DeriveCouncilVotes> {
+  const elections = api.query.elections || api.query['phragmenElection'] || api.query['electionsPhragmen'];
+
+  return memo(instanceId, (): Observable<DeriveCouncilVotes> =>
+    elections
+      ? elections['stakeOf']
+        ? retrievePrev(api, elections)
+        : retrieveCurrent(elections)
+      : of([])
+  );
+}

package/build-deno/council/votesOf.ts

@@ -0,0 +1,33 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AccountId } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi, DeriveCouncilVote } from '../types.ts';
+
+import { map } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @name votesOf
+ * @description Retrieves the council votes associated with a given account.
+ * @returns The stake and the list of candidates the account has voted for.
+ * @param {string | Uint8Array | AccountId} accountId The accountId to retrieve votes for.
+ * @example
+ * ```javascript
+ * const accountId = "5Gw3s7qQ9Z..."; // Replace with a valid account ID
+ * const votes = await api.derive.council.votesOf(accountId);
+ * console.log("Account votes:", votes);
+ * ```
+ */
+export function votesOf (instanceId: string, api: DeriveApi): (accountId: string | Uint8Array | AccountId) => Observable<DeriveCouncilVote> {
+  return memo(instanceId, (accountId: string | Uint8Array | AccountId): Observable<DeriveCouncilVote> =>
+    api.derive.council.votes().pipe(
+      map((votes): DeriveCouncilVote =>
+        (
+          votes.find(([from]) => from.eq(accountId)) ||
+          [null, { stake: api.registry.createType('Balance'), votes: [] as AccountId[] }]
+        )[1]
+      )
+    )
+  );
+}

package/build-deno/crowdloan/childKey.ts

@@ -0,0 +1,57 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { Option, u32 } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { PezkuwiRuntimeCommonCrowdloanFundInfo } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { map } from 'https://esm.sh/rxjs@7.8.1';
+
+import { u8aConcat, u8aToHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import { blake2AsU8a } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
+
+import { memo } from '../util/index.ts';
+
+interface AllInfo extends PezkuwiRuntimeCommonCrowdloanFundInfo {
+  // previously it was named trieIndex
+  trieIndex?: u32;
+}
+
+function createChildKey (info: AllInfo): string {
+  return u8aToHex(
+    u8aConcat(
+      ':child_storage:default:',
+      blake2AsU8a(
+        u8aConcat(
+          'crowdloan',
+          (info.fundIndex || info.trieIndex).toU8a()
+        )
+      )
+    )
+  );
+}
+
+/**
+ * @name childKey
+ * @description Retrieves the child storage key for a given teyrchain’s crowdloan contributions.
+ * This key is used to access contribution data stored in a separate child trie of the blockchain’s state.
+ * @param {string | number | BN} paraId The teyrchain ID for which contributions are being queried.
+ * @example
+ * ```javascript
+ * const childKey = await api.derive.crowdloan.childKey(3369);
+ * console.log("Child Key:", childKey);
+ * ```
+ */
+export function childKey (instanceId: string, api: DeriveApi): (paraId: string | number | BN) => Observable<string | null> {
+  return memo(instanceId, (paraId: string | number | BN): Observable<string | null> =>
+    api.query['crowdloan']['funds']<Option<PezkuwiRuntimeCommonCrowdloanFundInfo>>(paraId).pipe(
+      map((optInfo) => {
+        if (optInfo.isSome) {
+          return createChildKey(optInfo.unwrap() as AllInfo);
+        }
+
+        return null;
+      })
+    )
+  );
+}

package/build-deno/crowdloan/contributions.ts

@@ -0,0 +1,140 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { StorageKey } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import type { DeriveApi, DeriveContributions } from '../types.ts';
+
+import { BehaviorSubject, combineLatest, EMPTY, map, of, startWith, switchMap, tap, toArray } from 'https://esm.sh/rxjs@7.8.1';
+
+import { arrayFlatten, isFunction, nextTick } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+import { extractContributed } from './util.ts';
+
+interface Changes {
+  added: string[];
+  blockHash: string;
+  removed: string[];
+}
+
+const PAGE_SIZE_K = 1000; // limit aligned with the 1k on the node (trie lookups are heavy)
+
+function _getUpdates (api: DeriveApi, paraId: string | number | BN): Observable<Changes> {
+  let added: string[] = [];
+  let removed: string[] = [];
+
+  return api.query.system.events().pipe(
+    switchMap((events): Observable<Changes> => {
+      const changes = extractContributed(paraId, events);
+
+      if (changes.added.length || changes.removed.length) {
+        added = added.concat(...changes.added);
+        removed = removed.concat(...changes.removed);
+
+        return of({ added, addedDelta: changes.added, blockHash: events.createdAtHash?.toHex() || '-', removed, removedDelta: changes.removed });
+      }
+
+      return EMPTY;
+    }),
+    startWith({ added, addedDelta: [], blockHash: '-', removed, removedDelta: [] })
+  );
+}
+
+function _eventTriggerAll (api: DeriveApi, paraId: string | number | BN): Observable<string> {
+  return api.query.system.events().pipe(
+    switchMap((events): Observable<string> => {
+      const items = events.filter(({ event: { data: [eventParaId], method, section } }) =>
+        section === 'crowdloan' &&
+        ['AllRefunded', 'Dissolved', 'PartiallyRefunded'].includes(method) &&
+        eventParaId.eq(paraId)
+      );
+
+      return items.length
+        ? of(events.createdAtHash?.toHex() || '-')
+        : EMPTY;
+    }),
+    startWith('-')
+  );
+}
+
+function _getKeysPaged (api: DeriveApi, childKey: string): Observable<StorageKey[]> {
+  const subject = new BehaviorSubject<string | undefined>(undefined);
+
+  return subject.pipe(
+    switchMap((startKey) =>
+      api.rpc.childstate.getKeysPaged(childKey, '0x', PAGE_SIZE_K, startKey)
+    ),
+    tap((keys): void => {
+      nextTick((): void => {
+        keys.length === PAGE_SIZE_K
+          ? subject.next(keys[PAGE_SIZE_K - 1].toHex())
+          : subject.complete();
+      });
+    }),
+    toArray(), // toArray since we want to startSubject to be completed
+    map((keyArr: StorageKey[][]) => arrayFlatten(keyArr))
+  );
+}
+
+function _getAll (api: DeriveApi, paraId: string | number | BN, childKey: string): Observable<string[]> {
+  return _eventTriggerAll(api, paraId).pipe(
+    switchMap(() =>
+      isFunction(api.rpc.childstate.getKeysPaged)
+        ? _getKeysPaged(api, childKey)
+        : api.rpc.childstate.getKeys(childKey, '0x')
+    ),
+    map((keys) =>
+      keys.map((k) => k.toHex())
+    )
+  );
+}
+
+function _contributions (api: DeriveApi, paraId: string | number | BN, childKey: string): Observable<DeriveContributions> {
+  return combineLatest([
+    _getAll(api, paraId, childKey),
+    _getUpdates(api, paraId)
+  ]).pipe(
+    map(([keys, { added, blockHash, removed }]): DeriveContributions => {
+      const contributorsMap: Record<string, boolean> = {};
+
+      keys.forEach((k): void => {
+        contributorsMap[k] = true;
+      });
+
+      added.forEach((k): void => {
+        contributorsMap[k] = true;
+      });
+
+      removed.forEach((k): void => {
+        delete contributorsMap[k];
+      });
+
+      return {
+        blockHash,
+        contributorsHex: Object.keys(contributorsMap)
+      };
+    })
+  );
+}
+
+/**
+ * @name contributions
+ * @description Retrieves all contributions for a given teyrchain crowdloan.
+ * @param {string | number | BN} paraId The teyrchain ID for which contributions are being queried.
+ * @example
+ * ```javascript
+ * const contributions = await api.derive.crowdloan.contributions(3369);
+ * console.log("Contributions:", contributions);
+ * ```
+ */
+export function contributions (instanceId: string, api: DeriveApi): (paraId: string | number | BN) => Observable<DeriveContributions> {
+  return memo(instanceId, (paraId: string | number | BN): Observable<DeriveContributions> =>
+    api.derive.crowdloan.childKey(paraId).pipe(
+      switchMap((childKey) =>
+        childKey
+          ? _contributions(api, paraId, childKey)
+          : of({ blockHash: '-', contributorsHex: [] })
+      )
+    )
+  );
+}

package/build-deno/crowdloan/index.ts

@@ -0,0 +1,4 @@
+
+export * from './childKey.ts';
+export * from './contributions.ts';
+export * from './ownContributions.ts';

package/build-deno/crowdloan/ownContributions.ts

@@ -0,0 +1,79 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import type { DeriveApi, DeriveOwnContributions } from '../types.ts';
+
+import { combineLatest, EMPTY, map, of, startWith, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { objectSpread } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+import { extractContributed } from './util.ts';
+
+function _getValues (api: DeriveApi, childKey: string, keys: string[]): Observable<DeriveOwnContributions> {
+  // We actually would love to use multi-keys https://github.com/pezkuwichain/bizinikiwi/issues/9203
+  return combineLatest(keys.map((k) => api.rpc.childstate.getStorage(childKey, k))).pipe(
+    map((values) =>
+      values
+        .map((v) => api.registry.createType('Option<StorageData>', v))
+        .map((o) =>
+          o.isSome
+            ? api.registry.createType('Balance', o.unwrap())
+            : api.registry.createType('Balance')
+        )
+        .reduce((all: DeriveOwnContributions, b, index): DeriveOwnContributions =>
+          objectSpread(all, { [keys[index]]: b }), {})
+    )
+  );
+}
+
+function _watchOwnChanges (api: DeriveApi, paraId: string | number | BN, childkey: string, keys: string[]): Observable<DeriveOwnContributions> {
+  return api.query.system.events().pipe(
+    switchMap((events): Observable<DeriveOwnContributions> => {
+      const changes = extractContributed(paraId, events);
+      const filtered = keys.filter((k) =>
+        changes.added.includes(k) ||
+        changes.removed.includes(k)
+      );
+
+      return filtered.length
+        ? _getValues(api, childkey, filtered)
+        : EMPTY;
+    }),
+    startWith({})
+  );
+}
+
+function _contributions (api: DeriveApi, paraId: string | number | BN, childKey: string, keys: string[]): Observable<DeriveOwnContributions> {
+  return combineLatest([
+    _getValues(api, childKey, keys),
+    _watchOwnChanges(api, paraId, childKey, keys)
+  ]).pipe(
+    map(([all, latest]) =>
+      objectSpread({}, all, latest)
+    )
+  );
+}
+
+/**
+ * @name ownContributions
+ * @description Retrieves the contribution amounts made by specific accounts (`keys`) to a given teyrchain crowdloan (`paraId`).
+ * @param {string | number | BN} paraId The teyrchain ID for which contributions are being queried.
+ * @param {string[]} keys An array of account addresses whose contributions are to be fetched.
+ * @example
+ * ```javascript
+ * const contributions = await api.derive.crowdloan.ownContributions(2000, ['5Ff...PqV', '5Gg...XyZ']);
+ * console.log("Own Contributions:", contributions);
+ * ```
+ */
+export function ownContributions (instanceId: string, api: DeriveApi): (paraId: string | number | BN, keys: string[]) => Observable<DeriveOwnContributions> {
+  return memo(instanceId, (paraId: string | number | BN, keys: string[]): Observable<DeriveOwnContributions> =>
+    api.derive.crowdloan.childKey(paraId).pipe(
+      switchMap((childKey) =>
+        childKey && keys.length
+          ? _contributions(api, paraId, childKey, keys)
+          : of({})
+      )
+    )
+  );
+}

package/build-deno/crowdloan/types.ts

@@ -0,0 +1,9 @@
+
+import type { Balance } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+
+export interface DeriveContributions {
+  blockHash: string;
+  contributorsHex: string[];
+}
+
+export type DeriveOwnContributions = Record<string, Balance>;

package/build-deno/crowdloan/util.ts

@@ -0,0 +1,31 @@
+
+import type { PezframeSystemEventRecord } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { Vec } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+interface Changes {
+  added: string[];
+  blockHash: string;
+  removed: string[];
+}
+
+export function extractContributed (paraId: string | number | BN, events: Vec<PezframeSystemEventRecord>): Changes {
+  const added: string[] = [];
+  const removed: string[] = [];
+
+  return events
+    .filter(({ event: { data: [, eventParaId], method, section } }) =>
+      section === 'crowdloan' &&
+      ['Contributed', 'Withdrew'].includes(method) &&
+      eventParaId.eq(paraId)
+    )
+    .reduce((result: Changes, { event: { data: [accountId], method } }): Changes => {
+      if (method === 'Contributed') {
+        result.added.push(accountId.toHex());
+      } else {
+        result.removed.push(accountId.toHex());
+      }
+
+      return result;
+    }, { added, blockHash: events.createdAtHash?.toHex() || '-', removed });
+}