@pezkuwi/api-derive 16.5.5 → 16.5.6

package/cjs/accounts/identity.d.ts

@@ -0,0 +1,48 @@
+import type { Observable } from 'rxjs';
+import type { Bytes, Data } from '@pezkuwi/types';
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { PezpalletIdentityRegistration } 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';
+export declare function _identity(instanceId: string, api: DeriveApi): (accountId?: AccountId | Uint8Array | string) => Observable<[Option<ITuple<[PezpalletIdentityRegistration, Option<Bytes>]>> | Option<PezpalletIdentityRegistration> | undefined, Option<ITuple<[AccountId, Data]>> | 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 declare function identity(instanceId: string, api: DeriveApi): (accountId?: AccountId | Uint8Array | string) => Observable<DeriveAccountRegistration>;
+/**
+ * @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 declare const hasIdentity: (instanceId: string, api: DeriveApi) => (accountId: string | AccountId | Uint8Array) => Observable<DeriveHasIdentity>;
+/**
+ * @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 declare function hasIdentityMulti(instanceId: string, api: DeriveApi): (accountIds: (AccountId | Uint8Array | string)[]) => Observable<DeriveHasIdentity[]>;

package/cjs/accounts/identity.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasIdentity = void 0;
+exports._identity = _identity;
+exports.identity = identity;
+exports.hasIdentityMulti = hasIdentityMulti;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const UNDEF_HEX = { toHex: () => undefined };
+function dataAsString(data) {
+    if (!data) {
+        return data;
+    }
+    return data.isRaw
+        ? (0, util_1.u8aToString)(data.asRaw.toU8a(true))
+        : data.isNone
+            ? undefined
+            : data.toHex();
+}
+function extractOther(additional) {
+    return additional.reduce((other, [_key, _value]) => {
+        const key = dataAsString(_key);
+        const value = dataAsString(_value);
+        if (key && value) {
+            other[key] = value;
+        }
+        return other;
+    }, {});
+}
+function identityCompat(identityOfOpt) {
+    const identity = identityOfOpt.unwrap();
+    return Array.isArray(identity)
+        ? identity[0]
+        : identity;
+}
+function extractIdentity(identityOfOpt, superOf) {
+    if (!identityOfOpt?.isSome) {
+        return { judgements: [] };
+    }
+    const { info, judgements } = identityCompat(identityOfOpt);
+    const topDisplay = dataAsString(info.display);
+    return {
+        discord: dataAsString(info.discord),
+        display: (superOf && dataAsString(superOf[1])) || topDisplay,
+        displayParent: superOf && topDisplay,
+        email: dataAsString(info.email),
+        github: dataAsString(info.github),
+        image: dataAsString(info.image),
+        judgements,
+        legal: dataAsString(info.legal),
+        matrix: dataAsString(info.matrix),
+        other: info.additional ? extractOther(info.additional) : {},
+        parent: superOf?.[0],
+        pgp: info.pgpFingerprint.unwrapOr(UNDEF_HEX).toHex(),
+        riot: dataAsString(info.riot),
+        twitter: dataAsString(info.twitter),
+        web: dataAsString(info.web)
+    };
+}
+function getParent(api, identityOfOpt, superOfOpt) {
+    if (identityOfOpt?.isSome) {
+        // this identity has something set
+        return (0, rxjs_1.of)([identityOfOpt, undefined]);
+    }
+    else if (superOfOpt?.isSome) {
+        const superOf = superOfOpt.unwrap();
+        return (0, rxjs_1.combineLatest)([
+            api.derive.accounts._identity(superOf[0]).pipe((0, rxjs_1.map)(([info]) => info)),
+            (0, rxjs_1.of)(superOf)
+        ]);
+    }
+    // nothing of value returned
+    return (0, rxjs_1.of)([undefined, undefined]);
+}
+function _identity(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountId) => accountId && api.query.identity?.identityOf
+        ? (0, rxjs_1.combineLatest)([
+            api.query.identity.identityOf(accountId),
+            api.query.identity.superOf(accountId)
+        ])
+        : (0, rxjs_1.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]}`)
+ *   );
+ * });
+ * ```
+ */
+function identity(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountId) => api.derive.accounts._identity(accountId).pipe((0, rxjs_1.switchMap)(([identityOfOpt, superOfOpt]) => getParent(api, identityOfOpt, superOfOpt)), (0, rxjs_1.map)(([identityOfOpt, superOf]) => extractIdentity(identityOfOpt, superOf)), (0, rxjs_1.switchMap)((identity) => getSubIdentities(identity, api, accountId))));
+}
+function getSubIdentities(identity, api, accountId) {
+    const targetAccount = identity.parent || accountId;
+    if (!targetAccount || !api.query.identity) {
+        // No valid accountId return the identity as-is
+        return (0, rxjs_1.of)(identity);
+    }
+    return api.query.identity.subsOf(targetAccount).pipe((0, rxjs_1.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));
+ * ```
+ */
+exports.hasIdentity = (0, index_js_1.firstMemo)((api, accountId) => api.derive.accounts.hasIdentityMulti([accountId]));
+/**
+ * @name hasIdentityMulti
+ * @description Checks whether multiple accounts have on chain identities registered.
+ * @param {(AccountId | Uint8Array | string)[]} accountIds Array of account identifiers to query.
+ * @example
+ * ```javascript
+ * const ALICE = "13AU";
+ * const BOB = "16WW";
+ * console.log(await api.derive.accounts.hasIdentityMulti([ALICE, BOB]));
+ * ```
+ */
+function hasIdentityMulti(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountIds) => api.query.identity?.identityOf
+        ? (0, rxjs_1.combineLatest)([
+            api.query.identity.identityOf.multi(accountIds),
+            api.query.identity.superOf.multi(accountIds)
+        ]).pipe((0, rxjs_1.map)(([identities, supers]) => identities.map((identityOfOpt, index) => {
+            const superOfOpt = supers[index];
+            const parentId = superOfOpt && superOfOpt.isSome
+                ? superOfOpt.unwrap()[0].toString()
+                : undefined;
+            let display;
+            if (identityOfOpt && identityOfOpt.isSome) {
+                const value = dataAsString(identityCompat(identityOfOpt).info.display);
+                if (value && !(0, util_1.isHex)(value)) {
+                    display = value;
+                }
+            }
+            return { display, hasIdentity: !!(display || parentId), parentId };
+        })))
+        : (0, rxjs_1.of)(accountIds.map(() => ({ hasIdentity: false }))));
+}

package/cjs/accounts/index.d.ts

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

package/cjs/accounts/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./accountId.js"), exports);
+tslib_1.__exportStar(require("./flags.js"), exports);
+tslib_1.__exportStar(require("./idAndIndex.js"), exports);
+tslib_1.__exportStar(require("./identity.js"), exports);
+tslib_1.__exportStar(require("./idToIndex.js"), exports);
+tslib_1.__exportStar(require("./indexes.js"), exports);
+tslib_1.__exportStar(require("./indexToId.js"), exports);
+tslib_1.__exportStar(require("./info.js"), exports);

package/cjs/accounts/indexToId.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { AccountId, AccountIndex } from '@pezkuwi/types/interfaces';
+import type { DeriveApi } from '../types.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 declare function indexToId(instanceId: string, api: DeriveApi): (accountIndex: AccountIndex | string) => Observable<AccountId | undefined>;

package/cjs/accounts/indexToId.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexToId = indexToId;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../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);
+ * ```
+ */
+function indexToId(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (accountIndex) => api.query.indices
+        ? api.query.indices.accounts(accountIndex).pipe((0, rxjs_1.map)((optResult) => optResult.unwrapOr([])[0]))
+        : (0, rxjs_1.of)(undefined));
+}

package/cjs/accounts/indexes.d.ts

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

package/cjs/accounts/indexes.js

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

package/cjs/accounts/info.d.ts

@@ -0,0 +1,18 @@
+import type { Observable } from 'rxjs';
+import type { AccountId, AccountIndex, Address } from '@pezkuwi/types/interfaces';
+import type { DeriveAccountInfo, DeriveApi } from '../types.js';
+/**
+ * @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 declare function info(instanceId: string, api: DeriveApi): (address?: AccountIndex | AccountId | Address | Uint8Array | string | null) => Observable<DeriveAccountInfo>;

package/cjs/accounts/info.js

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

package/cjs/accounts/types.d.ts

@@ -0,0 +1,39 @@
+import type { AccountId, AccountIndex, RegistrationJudgement } from '@pezkuwi/types/interfaces';
+import type { Vec } from '@pezkuwi/types-codec';
+export type AccountIdAndIndex = [AccountId | undefined, AccountIndex | undefined];
+export type AccountIndexes = Record<string, AccountIndex>;
+export interface DeriveAccountRegistration {
+    discord?: string | undefined;
+    display?: string | undefined;
+    displayParent?: string | undefined;
+    email?: string | undefined;
+    github?: string | undefined;
+    image?: string | undefined;
+    legal?: string | undefined;
+    matrix?: string | undefined;
+    other?: Record<string, string> | undefined;
+    parent?: AccountId | undefined;
+    pgp?: string | undefined;
+    riot?: string | undefined;
+    subs?: Vec<AccountId> | undefined;
+    twitter?: string | undefined;
+    web?: string | undefined;
+    judgements: RegistrationJudgement[];
+}
+export interface DeriveAccountFlags {
+    isCouncil: boolean;
+    isSociety: boolean;
+    isSudo: boolean;
+    isTechCommittee: boolean;
+}
+export interface DeriveAccountInfo {
+    accountId?: AccountId | undefined;
+    accountIndex?: AccountIndex | undefined;
+    identity: DeriveAccountRegistration;
+    nickname?: string | undefined;
+}
+export interface DeriveHasIdentity {
+    display?: string | undefined;
+    hasIdentity: boolean;
+    parentId?: string | undefined;
+}

package/cjs/accounts/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/alliance/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @name members
+ * @description Retrieves the list of members in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const members = await api.derive.alliance.members();
+ * console.log(`Members: ${JSON.stringify(members)});
+ * ```
+ */
+export declare const members: import("../collective/types.js").MembersFnRet;
+/**
+ * @name hasProposals
+ * @description Checks if there are any active proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const exists = await api.derive.alliance.hasProposals();
+ * console.log(exists);
+ * ```
+ */
+export declare const hasProposals: import("../collective/types.js").HasProposalsFnRet;
+/**
+ * @name proposal
+ * @description Retrieves details of a specific proposal in the "allianceMotion" collective by its hash.
+ * @example
+ * ```javascript
+ * const proposalDetails = await api.derive.alliance.proposal(PROPOSAL_HASH);
+ * console.log(proposalDetails);
+ * ```
+ */
+export declare const proposal: import("../collective/types.js").ProposalFnRet;
+/**
+ * @name proposalCount
+ * @description Retrieves the total number of proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const count = await api.derive.alliance.proposalCount();
+ * console.log(`Amount of proposals: ${count}`);
+ * ```
+ */
+export declare const proposalCount: import("../collective/types.js").ProposalCountFnRet;
+/**
+ * @name proposalHashes
+ * @description Retrieves an array of hashes for all active proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const hashes = await api.derive.alliance.proposalHashes();
+ * console.log(`Proposals ${JSON.stringify(hashes)}`);
+ * ```
+ */
+export declare const proposalHashes: import("../collective/types.js").ProposalHashesFnRet;
+/**
+ * @name proposals
+ * @description Retrieves a list of all active proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.alliance.proposals();
+ * console.log(proposals);
+ * ```
+ */
+export declare const proposals: import("../collective/types.js").ProposalsFnRet;
+/**
+ * @name prime
+ * @description Retrieves the prime member of the "allianceMotion" collective, if one exists.
+ * @example
+ * ```javascript
+ * const primeMember = await api.derive.alliance.prime();
+ * console.log(primeMember);
+ * ```
+ */
+export declare const prime: import("../collective/types.js").PrimeFnRet;

package/cjs/alliance/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prime = exports.proposals = exports.proposalHashes = exports.proposalCount = exports.proposal = exports.hasProposals = exports.members = void 0;
+const index_js_1 = require("../collective/index.js");
+/**
+ * @name members
+ * @description Retrieves the list of members in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const members = await api.derive.alliance.members();
+ * console.log(`Members: ${JSON.stringify(members)});
+ * ```
+ */
+exports.members = (0, index_js_1.members)('allianceMotion');
+/**
+ * @name hasProposals
+ * @description Checks if there are any active proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const exists = await api.derive.alliance.hasProposals();
+ * console.log(exists);
+ * ```
+ */
+exports.hasProposals = (0, index_js_1.hasProposals)('allianceMotion');
+/**
+ * @name proposal
+ * @description Retrieves details of a specific proposal in the "allianceMotion" collective by its hash.
+ * @example
+ * ```javascript
+ * const proposalDetails = await api.derive.alliance.proposal(PROPOSAL_HASH);
+ * console.log(proposalDetails);
+ * ```
+ */
+exports.proposal = (0, index_js_1.proposal)('allianceMotion');
+/**
+ * @name proposalCount
+ * @description Retrieves the total number of proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const count = await api.derive.alliance.proposalCount();
+ * console.log(`Amount of proposals: ${count}`);
+ * ```
+ */
+exports.proposalCount = (0, index_js_1.proposalCount)('allianceMotion');
+/**
+ * @name proposalHashes
+ * @description Retrieves an array of hashes for all active proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const hashes = await api.derive.alliance.proposalHashes();
+ * console.log(`Proposals ${JSON.stringify(hashes)}`);
+ * ```
+ */
+exports.proposalHashes = (0, index_js_1.proposalHashes)('allianceMotion');
+/**
+ * @name proposals
+ * @description Retrieves a list of all active proposals in the "allianceMotion" collective.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.alliance.proposals();
+ * console.log(proposals);
+ * ```
+ */
+exports.proposals = (0, index_js_1.proposals)('allianceMotion');
+/**
+ * @name prime
+ * @description Retrieves the prime member of the "allianceMotion" collective, if one exists.
+ * @example
+ * ```javascript
+ * const primeMember = await api.derive.alliance.prime();
+ * console.log(primeMember);
+ * ```
+ */
+exports.prime = (0, index_js_1.prime)('allianceMotion');

package/cjs/augment.d.ts

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

package/cjs/augment.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@pezkuwi/api-augment");

package/cjs/bagsList/get.d.ts

@@ -0,0 +1,12 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi } from '../types.js';
+import type { Bag } from './types.js';
+export declare function _getIds(instanceId: string, api: DeriveApi): (ids: (BN | number)[]) => Observable<Bag[]>;
+export declare function all(instanceId: string, api: DeriveApi): () => Observable<Bag[]>;
+/**
+ * @name get
+ * @param {(BN | number)} id The id of the bag to retrieve.
+ * @description Retrieves a specific bag from the BagsList pallet by its id.
+ */
+export declare function get(instanceId: string, api: DeriveApi): (id: BN | number) => Observable<Bag>;

package/cjs/bagsList/get.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getIds = _getIds;
+exports.all = all;
+exports.get = get;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const util_js_1 = require("./util.js");
+function orderBags(ids, bags) {
+    const sorted = ids
+        .map((id, index) => ({
+        bag: bags[index].unwrapOr(null),
+        id,
+        key: id.toString()
+    }))
+        .sort((a, b) => b.id.cmp(a.id));
+    const max = sorted.length - 1;
+    return sorted.map((entry, index) => (0, util_1.objectSpread)(entry, {
+        bagLower: index === max
+            ? util_1.BN_ZERO
+            : sorted[index + 1].id,
+        bagUpper: entry.id,
+        index
+    }));
+}
+function _getIds(instanceId, api) {
+    const query = (0, util_js_1.getQueryInterface)(api);
+    return (0, index_js_1.memo)(instanceId, (_ids) => {
+        const ids = _ids.map((id) => (0, util_1.bnToBn)(id));
+        return ids.length
+            ? query.listBags.multi(ids).pipe((0, rxjs_1.map)((bags) => orderBags(ids, bags)))
+            : (0, rxjs_1.of)([]);
+    });
+}
+function all(instanceId, api) {
+    const query = (0, util_js_1.getQueryInterface)(api);
+    return (0, index_js_1.memo)(instanceId, () => query.listBags.keys().pipe((0, rxjs_1.switchMap)((keys) => api.derive.bagsList._getIds(keys.map(({ args: [id] }) => id))), (0, rxjs_1.map)((list) => list.filter(({ bag }) => bag))));
+}
+/**
+ * @name get
+ * @param {(BN | number)} id The id of the bag to retrieve.
+ * @description Retrieves a specific bag from the BagsList pallet by its id.
+ */
+function get(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (id) => api.derive.bagsList._getIds([(0, util_1.bnToBn)(id)]).pipe((0, rxjs_1.map)((bags) => bags[0])));
+}

package/cjs/bagsList/getExpanded.d.ts

@@ -0,0 +1,16 @@
+import type { Observable } from 'rxjs';
+import type { BN } from '@pezkuwi/util';
+import type { DeriveApi } from '../types.js';
+import type { Bag, BagExpanded } from './types.js';
+/**
+ * @name expand
+ * @description Expands a given bag by retrieving all its nodes (accounts contained within the bag).
+ * @param {Bag} bag The bag to be expanded.
+ */
+export declare function expand(instanceId: string, api: DeriveApi): (bag: Bag) => Observable<BagExpanded>;
+/**
+ * @name getExpanded
+ * @description Retrieves and expands a specific bag from the BagsList pallet.
+ * @param {BN | number} id The id of the bag to expand.
+ */
+export declare function getExpanded(instanceId: string, api: DeriveApi): (id: BN | number) => Observable<BagExpanded>;