@pezkuwi/api-derive 16.5.16 → 16.5.18

package/build/collective/proposals.js

@@ -0,0 +1,38 @@
+import { catchError, combineLatest, map, of, switchMap } from 'rxjs';
+import { isFunction } from '@pezkuwi/util';
+import { firstObservable } from '../util/index.js';
+import { callMethod, withSection } from './helpers.js';
+function parse(api, [hashes, proposals, votes]) {
+    return proposals.map((o, index) => ({
+        hash: api.registry.createType('Hash', hashes[index]),
+        proposal: o && o.isSome
+            ? o.unwrap()
+            : null,
+        votes: votes[index].unwrapOr(null)
+    }));
+}
+function _proposalsFrom(api, query, hashes) {
+    return (isFunction(query?.proposals) && hashes.length
+        ? combineLatest([
+            of(hashes),
+            // this should simply be api.query[section].proposalOf.multi<Option<Proposal>>(hashes),
+            // however we have had cases on Edgeware where the indices have moved around after an
+            // upgrade, which results in invalid on-chain data
+            query.proposalOf.multi(hashes).pipe(catchError(() => of(hashes.map(() => null)))),
+            query.voting.multi(hashes)
+        ])
+        : of([[], [], []])).pipe(map((r) => parse(api, r)));
+}
+export function hasProposals(section) {
+    return withSection(section, (query) => () => of(isFunction(query?.proposals)));
+}
+export function proposals(section) {
+    return withSection(section, (query, api) => () => api.derive[section].proposalHashes().pipe(switchMap((all) => _proposalsFrom(api, query, all))));
+}
+export function proposal(section) {
+    return withSection(section, (query, api) => (hash) => isFunction(query?.proposals)
+        ? firstObservable(_proposalsFrom(api, query, [hash]))
+        : of(null));
+}
+export const proposalCount = /*#__PURE__*/ callMethod('proposalCount', null);
+export const proposalHashes = /*#__PURE__*/ callMethod('proposals', []);

package/build/collective/types.d.ts

@@ -0,0 +1,19 @@
+import type { Observable } from 'rxjs';
+import type { u32 } from '@pezkuwi/types';
+import type { AccountId, Hash } from '@pezkuwi/types/interfaces';
+import type { DeriveApi, DeriveCollectiveProposal } from '../types.js';
+export type Collective = 'allianceMotion' | 'council' | 'membership' | 'technicalCommittee';
+export type HasProposalsFnRet = (instanceId: string, api: DeriveApi) => () => Observable<boolean>;
+export type HasProposalsFn = (section: Collective) => HasProposalsFnRet;
+export type MembersFnRet = (instanceId: string, api: DeriveApi) => () => Observable<AccountId[]>;
+export type MembersFn = (section: Collective) => MembersFnRet;
+export type PrimeFnRet = (instanceId: string, api: DeriveApi) => () => Observable<AccountId | null>;
+export type PrimeFn = (section: Collective) => PrimeFnRet;
+export type ProposalFnRet = (instanceId: string, api: DeriveApi) => (hash: Hash | Uint8Array | string) => Observable<DeriveCollectiveProposal | null>;
+export type ProposalFn = (section: Collective) => ProposalFnRet;
+export type ProposalsFnRet = (instanceId: string, api: DeriveApi) => () => Observable<DeriveCollectiveProposal[]>;
+export type ProposalsFn = (section: Collective) => ProposalsFnRet;
+export type ProposalCountFnRet = (instanceId: string, api: DeriveApi) => () => Observable<u32 | null>;
+export type ProposalCountFn = (section: Collective) => ProposalCountFnRet;
+export type ProposalHashesFnRet = (instanceId: string, api: DeriveApi) => () => Observable<Hash[]>;
+export type ProposalHashesFn = (section: Collective) => ProposalHashesFnRet;

package/build/collective/types.js

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

package/build/contracts/fees.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveContractFees } from '../types.js';
+/**
+ * @name fees
+ * @returns An object containing the combined results of the queries for
+ * all relevant contract fees as declared in the bizinikiwi chain spec.
+ * @example
+ * ```javascript
+ * api.derive.contracts.fees(([creationFee, transferFee]) => {
+ *   console.log(`The fee for creating a new contract on this chain is ${creationFee} units. The fee required to call this contract is ${transferFee} units.`);
+ * });
+ * ```
+ */
+export declare function fees(instanceId: string, api: DeriveApi): () => Observable<DeriveContractFees>;

package/build/contracts/fees.js

@@ -0,0 +1,45 @@
+import { map, of } from 'rxjs';
+import { memo } from '../util/index.js';
+function queryConstants(api) {
+    return of([
+        // deprecated
+        api.consts.contracts['callBaseFee'] || api.registry.createType('Balance'),
+        api.consts.contracts['contractFee'] || api.registry.createType('Balance'),
+        api.consts.contracts['creationFee'] || api.registry.createType('Balance'),
+        api.consts.contracts['transactionBaseFee'] || api.registry.createType('Balance'),
+        api.consts.contracts['transactionByteFee'] || api.registry.createType('Balance'),
+        api.consts.contracts['transferFee'] || api.registry.createType('Balance'),
+        // current
+        api.consts.contracts['rentByteFee'] || api.registry.createType('Balance'),
+        api.consts.contracts['rentDepositOffset'] || api.registry.createType('Balance'),
+        api.consts.contracts['surchargeReward'] || api.registry.createType('Balance'),
+        api.consts.contracts['tombstoneDeposit'] || api.registry.createType('Balance')
+    ]);
+}
+/**
+ * @name fees
+ * @returns An object containing the combined results of the queries for
+ * all relevant contract fees as declared in the bizinikiwi chain spec.
+ * @example
+ * ```javascript
+ * api.derive.contracts.fees(([creationFee, transferFee]) => {
+ *   console.log(`The fee for creating a new contract on this chain is ${creationFee} units. The fee required to call this contract is ${transferFee} units.`);
+ * });
+ * ```
+ */
+export function fees(instanceId, api) {
+    return memo(instanceId, () => {
+        return queryConstants(api).pipe(map(([callBaseFee, contractFee, creationFee, transactionBaseFee, transactionByteFee, transferFee, rentByteFee, rentDepositOffset, surchargeReward, tombstoneDeposit]) => ({
+            callBaseFee,
+            contractFee,
+            creationFee,
+            rentByteFee,
+            rentDepositOffset,
+            surchargeReward,
+            tombstoneDeposit,
+            transactionBaseFee,
+            transactionByteFee,
+            transferFee
+        })));
+    });
+}

package/build/contracts/index.d.ts

@@ -0,0 +1 @@
+export * from './fees.js';

package/build/contracts/index.js

@@ -0,0 +1 @@
+export * from './fees.js';

package/build/council/index.d.ts

@@ -0,0 +1,72 @@
+export * from './votes.js';
+export * from './votesOf.js';
+/**
+ * @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 declare const members: import("../collective/types.js").MembersFnRet;
+/**
+ * @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 declare const hasProposals: import("../collective/types.js").HasProposalsFnRet;
+/**
+ * @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 declare const proposal: import("../collective/types.js").ProposalFnRet;
+/**
+ * @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 declare const proposalCount: import("../collective/types.js").ProposalCountFnRet;
+/**
+ * @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 declare const proposalHashes: import("../collective/types.js").ProposalHashesFnRet;
+/**
+ * @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 declare const proposals: import("../collective/types.js").ProposalsFnRet;
+/**
+ * @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 declare const prime: import("../collective/types.js").PrimeFnRet;

package/build/council/index.js

@@ -0,0 +1,73 @@
+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';
+export * from './votes.js';
+export * from './votesOf.js';
+/**
+ * @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/council/types.d.ts

@@ -0,0 +1,6 @@
+import type { AccountId, Balance } from '@pezkuwi/types/interfaces';
+export interface DeriveCouncilVote {
+    stake: Balance;
+    votes: AccountId[];
+}
+export type DeriveCouncilVotes = [AccountId, DeriveCouncilVote][];

package/build/council/types.js

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

package/build/council/votes.d.ts

@@ -0,0 +1,11 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveCouncilVotes } from '../types.js';
+/**
+ * @name votes
+ * @description Retrieves the council election votes for all participants.
+ * @example
+ * ```javascript
+ * const votes = await api.derive.council.votes();
+ * ```
+ */
+export declare function votes(instanceId: string, api: DeriveApi): () => Observable<DeriveCouncilVotes>;

package/build/council/votes.js

@@ -0,0 +1,56 @@
+import { combineLatest, map, of } from 'rxjs';
+import { memo } from '../util/index.js';
+function isVoter(value) {
+    return !Array.isArray(value);
+}
+function retrieveStakeOf(elections) {
+    return elections['stakeOf'].entries().pipe(map((entries) => entries.map(([{ args: [accountId] }, stake]) => [accountId, stake])));
+}
+function retrieveVoteOf(elections) {
+    return elections['votesOf'].entries().pipe(map((entries) => entries.map(([{ args: [accountId] }, votes]) => [accountId, votes])));
+}
+function retrievePrev(api, elections) {
+    return combineLatest([
+        retrieveStakeOf(elections),
+        retrieveVoteOf(elections)
+    ]).pipe(map(([stakes, votes]) => {
+        const result = [];
+        votes.forEach(([voter, votes]) => {
+            result.push([voter, { stake: api.registry.createType('Balance'), votes }]);
+        });
+        stakes.forEach(([staker, stake]) => {
+            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) {
+    return elections.voting.entries().pipe(map((entries) => entries.map(([{ args: [accountId] }, value]) => [
+        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, api) {
+    const elections = api.query.elections || api.query['phragmenElection'] || api.query['electionsPhragmen'];
+    return memo(instanceId, () => elections
+        ? elections['stakeOf']
+            ? retrievePrev(api, elections)
+            : retrieveCurrent(elections)
+        : of([]));
+}

package/build/council/votesOf.d.ts

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

package/build/council/votesOf.js

@@ -0,0 +1,18 @@
+import { map } from 'rxjs';
+import { memo } from '../util/index.js';
+/**
+ * @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, api) {
+    return memo(instanceId, (accountId) => api.derive.council.votes().pipe(map((votes) => (votes.find(([from]) => from.eq(accountId)) ||
+        [null, { stake: api.registry.createType('Balance'), votes: [] }])[1])));
+}

package/build/crowdloan/childKey.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi } from '../types.js';
+/**
+ * @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 declare function childKey(instanceId: string, api: DeriveApi): (paraId: string | number | BN) => Observable<string | null>;

package/build/crowdloan/childKey.js

@@ -0,0 +1,23 @@
+import { map } from 'rxjs';
+import { u8aConcat, u8aToHex } from '@pezkuwi/util';
+import { blake2AsU8a } from '@pezkuwi/util-crypto';
+import { memo } from '../util/index.js';
+function createChildKey(info) {
+    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, api) {
+    return memo(instanceId, (paraId) => api.query['crowdloan']['funds'](paraId).pipe(map((optInfo) => optInfo.isSome
+        ? createChildKey(optInfo.unwrap())
+        : null)));
+}

package/build/crowdloan/contributions.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi, DeriveContributions } from '../types.js';
+/**
+ * @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 declare function contributions(instanceId: string, api: DeriveApi): (paraId: string | number | BN) => Observable<DeriveContributions>;

package/build/crowdloan/contributions.js

@@ -0,0 +1,80 @@
+import { BehaviorSubject, combineLatest, EMPTY, map, of, startWith, switchMap, tap, toArray } from 'rxjs';
+import { arrayFlatten, isFunction, nextTick } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+import { extractContributed } from './util.js';
+const PAGE_SIZE_K = 1000; // limit aligned with the 1k on the node (trie lookups are heavy)
+function _getUpdates(api, paraId) {
+    let added = [];
+    let removed = [];
+    return api.query.system.events().pipe(switchMap((events) => {
+        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, paraId) {
+    return api.query.system.events().pipe(switchMap((events) => {
+        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, childKey) {
+    const subject = new BehaviorSubject(undefined);
+    return subject.pipe(switchMap((startKey) => api.rpc.childstate.getKeysPaged(childKey, '0x', PAGE_SIZE_K, startKey)), tap((keys) => {
+        nextTick(() => {
+            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) => arrayFlatten(keyArr)));
+}
+function _getAll(api, paraId, childKey) {
+    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, paraId, childKey) {
+    return combineLatest([
+        _getAll(api, paraId, childKey),
+        _getUpdates(api, paraId)
+    ]).pipe(map(([keys, { added, blockHash, removed }]) => {
+        const contributorsMap = {};
+        keys.forEach((k) => {
+            contributorsMap[k] = true;
+        });
+        added.forEach((k) => {
+            contributorsMap[k] = true;
+        });
+        removed.forEach((k) => {
+            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, api) {
+    return memo(instanceId, (paraId) => api.derive.crowdloan.childKey(paraId).pipe(switchMap((childKey) => childKey
+        ? _contributions(api, paraId, childKey)
+        : of({ blockHash: '-', contributorsHex: [] }))));
+}

package/build/crowdloan/index.d.ts

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

package/build/crowdloan/index.js

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

package/build/crowdloan/ownContributions.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi, DeriveOwnContributions } from '../types.js';
+/**
+ * @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 declare function ownContributions(instanceId: string, api: DeriveApi): (paraId: string | number | BN, keys: string[]) => Observable<DeriveOwnContributions>;

package/build/crowdloan/ownContributions.js

@@ -0,0 +1,45 @@
+import { combineLatest, EMPTY, map, of, startWith, switchMap } from 'rxjs';
+import { objectSpread } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+import { extractContributed } from './util.js';
+function _getValues(api, childKey, keys) {
+    // 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, b, index) => objectSpread(all, { [keys[index]]: b }), {})));
+}
+function _watchOwnChanges(api, paraId, childkey, keys) {
+    return api.query.system.events().pipe(switchMap((events) => {
+        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, paraId, childKey, keys) {
+    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, api) {
+    return memo(instanceId, (paraId, keys) => api.derive.crowdloan.childKey(paraId).pipe(switchMap((childKey) => childKey && keys.length
+        ? _contributions(api, paraId, childKey, keys)
+        : of({}))));
+}

package/build/crowdloan/types.d.ts

@@ -0,0 +1,6 @@
+import type { Balance } from '@pezkuwi/types/interfaces';
+export interface DeriveContributions {
+    blockHash: string;
+    contributorsHex: string[];
+}
+export type DeriveOwnContributions = Record<string, Balance>;

package/build/crowdloan/types.js

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

package/build/crowdloan/util.d.ts

@@ -0,0 +1,10 @@
+import type { PezframeSystemEventRecord } from '@pezkuwi/types/lookup';
+import type { Vec } from '@pezkuwi/types-codec';
+import type { BN } from '@pezkuwi/util';
+interface Changes {
+    added: string[];
+    blockHash: string;
+    removed: string[];
+}
+export declare function extractContributed(paraId: string | number | BN, events: Vec<PezframeSystemEventRecord>): Changes;
+export {};

package/build/crowdloan/util.js

@@ -0,0 +1,17 @@
+export function extractContributed(paraId, events) {
+    const added = [];
+    const removed = [];
+    return events
+        .filter(({ event: { data: [, eventParaId], method, section } }) => section === 'crowdloan' &&
+        ['Contributed', 'Withdrew'].includes(method) &&
+        eventParaId.eq(paraId))
+        .reduce((result, { event: { data: [accountId], method } }) => {
+        if (method === 'Contributed') {
+            result.added.push(accountId.toHex());
+        }
+        else {
+            result.removed.push(accountId.toHex());
+        }
+        return result;
+    }, { added, blockHash: events.createdAtHash?.toHex() || '-', removed });
+}