@pezkuwi/api-derive 16.5.6 → 16.5.8

package/build-tsc-cjs/treasury/proposals.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proposals = proposals;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+function parseResult(api, { allIds, allProposals, approvalIds, councilProposals, proposalCount }) {
+    const approvals = [];
+    const proposals = [];
+    const councilTreasury = councilProposals.filter(({ proposal }) => 
+    // FIXME `approveProposal` and `rejectProposal` have been removed in bizinikiwi and released in 1.14
+    // in favor of `spend`. See: https://github.com/pezkuwichain/pezkuwi-sdk/pull/3820
+    proposal && ((api.tx.treasury['approveProposal'] && api.tx.treasury['approveProposal'].is(proposal)) ||
+        (api.tx.treasury['rejectProposal'] && api.tx.treasury['rejectProposal'].is(proposal))));
+    allIds.forEach((id, index) => {
+        if (allProposals[index].isSome) {
+            const council = councilTreasury
+                .filter(({ proposal }) => proposal && id.eq(proposal.args[0]))
+                .sort((a, b) => a.proposal && b.proposal
+                ? a.proposal.method.localeCompare(b.proposal.method)
+                : a.proposal
+                    ? -1
+                    : 1);
+            const isApproval = approvalIds.some((approvalId) => approvalId.eq(id));
+            const derived = { council, id, proposal: allProposals[index].unwrap() };
+            if (isApproval) {
+                approvals.push(derived);
+            }
+            else {
+                proposals.push(derived);
+            }
+        }
+    });
+    return { approvals, proposalCount, proposals };
+}
+function retrieveProposals(api, proposalCount, approvalIds) {
+    const proposalIds = [];
+    const count = proposalCount.toNumber();
+    for (let index = 0; index < count; index++) {
+        if (!approvalIds.some((id) => id.eqn(index))) {
+            proposalIds.push(api.registry.createType('ProposalIndex', index));
+        }
+    }
+    const allIds = [...proposalIds, ...approvalIds];
+    return (0, rxjs_1.combineLatest)([
+        api.query.treasury.proposals.multi(allIds),
+        api.derive.council
+            ? api.derive.council.proposals()
+            : (0, rxjs_1.of)([])
+    ]).pipe((0, rxjs_1.map)(([allProposals, councilProposals]) => parseResult(api, { allIds, allProposals, approvalIds, councilProposals, proposalCount })));
+}
+/**
+ * @name proposals
+ * @description Retrieve all active and approved treasury proposals, along with their info.
+ * @example
+ * ```javascript
+ * const treasuryProposals = await api.derive.treasury.proposals();
+ * console.log(treasuryProposals);
+ * ```
+ */
+function proposals(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.query.treasury
+        ? (0, rxjs_1.combineLatest)([
+            api.query.treasury.proposalCount(),
+            api.query.treasury.approvals()
+        ]).pipe((0, rxjs_1.switchMap)(([proposalCount, approvalIds]) => retrieveProposals(api, proposalCount, approvalIds)))
+        : (0, rxjs_1.of)({
+            approvals: [],
+            proposalCount: api.registry.createType('ProposalIndex'),
+            proposals: []
+        }));
+}

package/build-tsc-cjs/tx/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MORTAL_PERIOD = exports.MAX_FINALITY_LAG = exports.FALLBACK_PERIOD = exports.FALLBACK_MAX_HASH_COUNT = void 0;
+const util_1 = require("@pezkuwi/util");
+exports.FALLBACK_MAX_HASH_COUNT = 250;
+exports.FALLBACK_PERIOD = new util_1.BN(6 * 1000);
+exports.MAX_FINALITY_LAG = new util_1.BN(5);
+exports.MORTAL_PERIOD = new util_1.BN(5 * 60 * 1000);

package/build-tsc-cjs/tx/events.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.events = events;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name events
+ * @param {Hash} at Block hash to query at.
+ * @description Retrieves the block information alongside its events at a given block hash
+ * @example
+ * ```javascript
+ * const blockHash = api.registry.createType(
+ *   "Hash",
+ *   "0xf1dc2efe8265be67deea5e91b05a98a7f9f81f66854e92825cf36f541beb7af6"
+ * );
+ * const { events, block } = await api.derive.tx.events(blockHash);
+ * ```
+ */
+function events(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (blockHash) => (0, rxjs_1.combineLatest)([
+        api.rpc.chain.getBlock(blockHash),
+        api.queryAt(blockHash).pipe((0, rxjs_1.switchMap)((queryAt) => queryAt.system.events()))
+    ]).pipe((0, rxjs_1.map)(([block, events]) => ({ block, events }))));
+}

package/build-tsc-cjs/tx/extrinsicInfo.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extrinsicInfo = extrinsicInfo;
+exports.accountExtrinsics = accountExtrinsics;
+const rxjs_1 = require("rxjs");
+const index_js_1 = require("../util/index.js");
+/**
+ * @name extrinsicInfo
+ * @param { Hash } at The block hash to query at.
+ * @param { Uint8Array | string } transactionHash A transaction hash as U8 array or string.
+ * @description Retrieves the extrinsic information and its events.
+ * @example
+ * ```javascript
+ * const blockHash = api.registry.createType(
+ *   'Hash',
+ *   '0xb772e4949d2f3eb5ba356aa43f885cc4f9097ee9812c5436543f3846a0491729'
+ * );
+ * const extrinsicInfo = await api.derive.tx.extrinsicInfo(
+ *   blockHash,
+ *   '0xcd96520b05e0c4648ea365f3f063f27c5cdd8be10d41a1c44566428c91f37dcb'
+ * );
+ *
+ * console.log(extrinsicInfo.extrinsic.toHuman());
+ * ```
+ */
+function extrinsicInfo(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (at, transactionHash) => {
+        return api.derive.tx.events(at).pipe((0, rxjs_1.map)(({ block, events }) => {
+            const index = block.block.extrinsics.findIndex((ext) => ext.hash.toString() === transactionHash);
+            if (index === -1) {
+                return null;
+            }
+            const extEvents = events.filter(({ phase }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(index));
+            return {
+                blockHash: block.hash.toHex(),
+                blockNumber: block.block.header.number.toNumber(),
+                events: extEvents,
+                extrinsic: block.block.extrinsics[index],
+                success: (extEvents.findIndex((ev) => ev.event.method === 'ExtrinsicSuccess') !== -1)
+            };
+        }));
+    });
+}
+/**
+ * @name accountExtrinsics
+ * @description Retrieves information about every extrinsic submitted by an account at a given block.
+ * @param { Hash } at The block hash to query at.
+ * @param { Uint8Array | strings } accountId The account identifier to query.
+ * @example
+ * ```javascript
+   const blockHash = api.registry.createType(
+    'Hash',
+    '0xb772e4949d2f3eb5ba356aa43f885cc4f9097ee9812c5436543f3846a0491729'
+  );
+  const extrinsicsInfo = await api.derive.tx.accountExtrinsics(
+    blockHash,
+    '0x21895DdfD4640b4e0aDCa2865b907f2CE6e6B777'
+  );
+
+  console.log(extrinsicsInfo.extrinsics[0]).extrinsic.toHuman();
+ * ```
+ */
+function accountExtrinsics(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (at, accountId) => {
+        return api.derive.tx.events(at).pipe((0, rxjs_1.map)(({ block, events }) => {
+            const indexes = [];
+            return {
+                blockHash: block.hash.toHex(),
+                blockNumber: block.block.header.number.toNumber(),
+                extrinsics: block.block.extrinsics.filter((ext, index) => {
+                    if (ext.signer.toString() === accountId) {
+                        indexes.push(index);
+                        return true;
+                    }
+                    return false;
+                }).map((ext, i) => {
+                    const extEvents = events.filter(({ phase }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(indexes[i]));
+                    return {
+                        events: extEvents,
+                        extrinsic: ext,
+                        success: (extEvents.findIndex((ev) => ev.event.method === 'ExtrinsicSuccess') !== -1)
+                    };
+                })
+            };
+        }));
+    });
+}

package/build-tsc-cjs/tx/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./events.js"), exports);
+tslib_1.__exportStar(require("./extrinsicInfo.js"), exports);
+tslib_1.__exportStar(require("./signingInfo.js"), exports);

package/build-tsc-cjs/tx/signingInfo.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signingInfo = signingInfo;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const constants_js_1 = require("./constants.js");
+function latestNonce(api, address) {
+    return api.derive.balances.account(address).pipe((0, rxjs_1.map)(({ accountNonce }) => accountNonce));
+}
+function nextNonce(api, address) {
+    if (api.call.accountNonceApi) {
+        return api.call.accountNonceApi.accountNonce(address);
+    }
+    else {
+        return api.rpc.system?.accountNextIndex
+            ? api.rpc.system.accountNextIndex(address)
+            : latestNonce(api, address);
+    }
+}
+function signingHeader(api) {
+    return (0, rxjs_1.combineLatest)([
+        api.rpc.chain.getHeader().pipe((0, rxjs_1.switchMap)((header) => 
+        // check for chains at genesis (until block 1 is produced, e.g. 6s), since
+        // we do need to allow transactions at chain start (also dev/seal chains)
+        header.parentHash.isEmpty
+            ? (0, rxjs_1.of)(header)
+            // in the case of the current block, we use the parent to minimize the
+            // impact of forks on the system, but not completely remove it
+            : api.rpc.chain.getHeader(header.parentHash).pipe((0, rxjs_1.catchError)(() => (0, rxjs_1.of)(header))))),
+        api.rpc.chain.getFinalizedHead().pipe((0, rxjs_1.switchMap)((hash) => api.rpc.chain.getHeader(hash).pipe((0, rxjs_1.catchError)(() => (0, rxjs_1.of)(null)))))
+    ]).pipe((0, rxjs_1.map)(([current, finalized]) => 
+    // determine the hash to use, current when lag > max, else finalized
+    !finalized || (0, index_js_1.unwrapBlockNumber)(current).sub((0, index_js_1.unwrapBlockNumber)(finalized)).gt(constants_js_1.MAX_FINALITY_LAG)
+        ? current
+        : finalized));
+}
+function babeOrAuraPeriod(api) {
+    const period = api.consts.babe?.expectedBlockTime ||
+        // this will be present ones https://github.com/pezkuwichain/pezkuwi-sdk/pull/3732 is merged
+        // eslint-disable-next-line
+        api.consts['aura']?.['slotDuration'] ||
+        api.consts.timestamp?.minimumPeriod.muln(2);
+    return period && period.isZero && !period.isZero() ? period : undefined;
+}
+/**
+ * @name signingInfo
+ * @description Retrieves signing-related information for an account, including the nonce, block header, and mortal length.
+ * @param {string} address The account address for which signing information is needed.
+ * @param { BN | bigint | Uint8Array | number | string } nonce? (Optional) The nonce to use. If `undefined`, the latest nonce is retrieved.
+ * @param { IExtrinsicEra | number } era? (Optional) The transaction era.
+ * @example
+ * ```javascript
+ * const info = await api.derive.tx.signingInfo(
+ *   "14mM9FRDDtwSYicjNxSvMfQkap8o4m9zHq7hNW4JpbSL4PPU"
+ * );
+ * console.log(info);
+ * ```
+ */
+function signingInfo(_instanceId, api) {
+    // no memo, we want to do this fresh on each run
+    return (address, nonce, era) => (0, rxjs_1.combineLatest)([
+        // retrieve nonce if none was specified
+        (0, util_1.isUndefined)(nonce)
+            ? latestNonce(api, address)
+            : nonce === -1
+                ? nextNonce(api, address)
+                : (0, rxjs_1.of)(api.registry.createType('Index', nonce)),
+        // if no era (create) or era > 0 (mortal), do block retrieval
+        ((0, util_1.isUndefined)(era) || ((0, util_1.isNumber)(era) && era > 0))
+            ? signingHeader(api)
+            : (0, rxjs_1.of)(null)
+    ]).pipe((0, rxjs_1.map)(([nonce, header]) => ({
+        header,
+        mortalLength: Math.min(api.consts.system?.blockHashCount?.toNumber() || constants_js_1.FALLBACK_MAX_HASH_COUNT, constants_js_1.MORTAL_PERIOD
+            .div(babeOrAuraPeriod(api) || constants_js_1.FALLBACK_PERIOD)
+            .iadd(constants_js_1.MAX_FINALITY_LAG)
+            .toNumber()),
+        nonce
+    })));
+}

package/build-tsc-cjs/type/HeaderExtended.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHeaderExtended = createHeaderExtended;
+const util_js_1 = require("./util.js");
+function createHeaderExtended(registry, header, validators, author) {
+    // an instance of the base extrinsic for us to extend
+    const HeaderBase = registry.createClass('Header');
+    class Implementation extends HeaderBase {
+        #author;
+        constructor(registry, header, validators, author) {
+            super(registry, header);
+            this.#author = author || (0, util_js_1.extractAuthor)(this.digest, validators || []);
+            this.createdAtHash = header?.createdAtHash;
+        }
+        /**
+         * @description Convenience method, returns the author for the block
+         */
+        get author() {
+            return this.#author;
+        }
+    }
+    return new Implementation(registry, header, validators, author);
+}

package/build-tsc-cjs/type/SignedBlockExtended.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSignedBlockExtended = createSignedBlockExtended;
+const util_js_1 = require("./util.js");
+function mapExtrinsics(extrinsics, records) {
+    return extrinsics.map((extrinsic, index) => {
+        let dispatchError;
+        let dispatchInfo;
+        const events = records
+            .filter(({ phase }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(index))
+            .map(({ event }) => {
+            if (event.section === 'system') {
+                if (event.method === 'ExtrinsicSuccess') {
+                    dispatchInfo = event.data[0];
+                }
+                else if (event.method === 'ExtrinsicFailed') {
+                    dispatchError = event.data[0];
+                    dispatchInfo = event.data[1];
+                }
+            }
+            return event;
+        });
+        return { dispatchError, dispatchInfo, events, extrinsic };
+    });
+}
+function createSignedBlockExtended(registry, block, events, validators, author) {
+    // an instance of the base extrinsic for us to extend
+    const SignedBlockBase = registry.createClass('SignedBlock');
+    class Implementation extends SignedBlockBase {
+        #author;
+        #events;
+        #extrinsics;
+        constructor(registry, block, events, validators, author) {
+            super(registry, block);
+            this.#author = author || (0, util_js_1.extractAuthor)(this.block.header.digest, validators || []);
+            this.#events = events || [];
+            this.#extrinsics = mapExtrinsics(this.block.extrinsics, this.#events);
+            this.createdAtHash = block?.createdAtHash;
+        }
+        /**
+         * @description Convenience method, returns the author for the block
+         */
+        get author() {
+            return this.#author;
+        }
+        /**
+         * @description Convenience method, returns the events associated with the block
+         */
+        get events() {
+            return this.#events;
+        }
+        /**
+         * @description Returns the extrinsics and their events, mapped
+         */
+        get extrinsics() {
+            return this.#extrinsics;
+        }
+    }
+    return new Implementation(registry, block, events, validators, author);
+}

package/build-tsc-cjs/type/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSignedBlockExtended = exports.createHeaderExtended = void 0;
+var HeaderExtended_js_1 = require("./HeaderExtended.js");
+Object.defineProperty(exports, "createHeaderExtended", { enumerable: true, get: function () { return HeaderExtended_js_1.createHeaderExtended; } });
+var SignedBlockExtended_js_1 = require("./SignedBlockExtended.js");
+Object.defineProperty(exports, "createSignedBlockExtended", { enumerable: true, get: function () { return SignedBlockExtended_js_1.createSignedBlockExtended; } });

package/build-tsc-cjs/type/types.js

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

package/build-tsc-cjs/type/util.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAuthor = extractAuthor;
+function extractAuthor(digest, sessionValidators) {
+    const [citem] = digest.logs.filter((e) => e.isConsensus);
+    const preRuntimeItems = digest.logs.filter((e) => e.isPreRuntime);
+    const [sitem] = digest.logs.filter((e) => e.isSeal);
+    let accountId;
+    try {
+        // This is critical to be first for BABE (before Consensus)
+        // If not first, we end up dropping the author at session-end
+        // Iterate through ALL preRuntime logs to find a recognized engine
+        // (teyrchains may have multiple preRuntime logs, e.g., CMLS + aura)
+        for (const pitem of preRuntimeItems) {
+            const [engine, data] = pitem.asPreRuntime;
+            accountId = engine.extractAuthor(data, sessionValidators);
+            // Stop at first recognized engine that returns an author
+            if (accountId) {
+                return accountId;
+            }
+        }
+        if (!accountId && citem) {
+            const [engine, data] = citem.asConsensus;
+            accountId = engine.extractAuthor(data, sessionValidators);
+        }
+        // SEAL, still used in e.g. Kulupu for pow
+        if (!accountId && sitem) {
+            const [engine, data] = sitem.asSeal;
+            accountId = engine.extractAuthor(data, sessionValidators);
+        }
+    }
+    catch {
+        // ignore
+    }
+    return accountId;
+}

package/build-tsc-cjs/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./accounts/types.js"), exports);
+tslib_1.__exportStar(require("./bagsList/types.js"), exports);
+tslib_1.__exportStar(require("./balances/types.js"), exports);
+tslib_1.__exportStar(require("./council/types.js"), exports);
+tslib_1.__exportStar(require("./crowdloan/types.js"), exports);
+tslib_1.__exportStar(require("./democracy/types.js"), exports);
+tslib_1.__exportStar(require("./elections/types.js"), exports);
+tslib_1.__exportStar(require("./session/types.js"), exports);
+tslib_1.__exportStar(require("./society/types.js"), exports);
+tslib_1.__exportStar(require("./staking/types.js"), exports);
+tslib_1.__exportStar(require("./teyrchains/types.js"), exports);
+tslib_1.__exportStar(require("./type/types.js"), exports);

package/build-tsc-cjs/util/approvalFlagsToBools.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approvalFlagsToBools = approvalFlagsToBools;
+/** @internal */
+function approvalFlagsToBools(flags) {
+    const bools = [];
+    for (let i = 0, count = flags.length; i < count; i++) {
+        const str = flags[i].toString(2);
+        // read from lowest bit to highest
+        for (const bit of str.split('').reverse()) {
+            bools.push(!!parseInt(bit, 10));
+        }
+    }
+    // slice off trailing "false" values, as in bizinikiwi
+    const lastApproval = bools.lastIndexOf(true);
+    return lastApproval >= 0
+        ? bools.slice(0, lastApproval + 1)
+        : [];
+}

package/build-tsc-cjs/util/blockNumber.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapBlockNumber = unwrapBlockNumber;
+const util_1 = require("@pezkuwi/util");
+function unwrapBlockNumber(hdr) {
+    return (0, util_1.isCompact)(hdr.number)
+        ? hdr.number.unwrap()
+        : hdr.number;
+}

package/build-tsc-cjs/util/cache.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveCache = void 0;
+exports.setDeriveCache = setDeriveCache;
+const cacheImpl_js_1 = require("./cacheImpl.js");
+const CACHE_EXPIRY = 7 * (24 * 60) * (60 * 1000);
+let deriveCache;
+function wrapCache(keyStart, cache) {
+    return {
+        del: (partial) => cache.del(`${keyStart}${partial}`),
+        forEach: cache.forEach,
+        get: (partial) => {
+            const key = `${keyStart}${partial}`;
+            const cached = cache.get(key);
+            if (cached) {
+                cached.x = Date.now();
+                cache.set(key, cached);
+                return cached.v;
+            }
+            return undefined;
+        },
+        set: (partial, v) => {
+            cache.set(`${keyStart}${partial}`, { v, x: Date.now() });
+        }
+    };
+}
+function clearCache(cache) {
+    // clear all expired values
+    const now = Date.now();
+    const all = [];
+    cache.forEach((key, { x }) => {
+        ((now - x) > CACHE_EXPIRY) && all.push(key);
+    });
+    // don't do delete inside loop, just in-case
+    all.forEach((key) => cache.del(key));
+}
+function setDeriveCache(prefix = '', cache) {
+    exports.deriveCache = deriveCache = cache
+        ? wrapCache(`derive:${prefix}:`, cache)
+        : cacheImpl_js_1.deriveNoopCache;
+    if (cache) {
+        clearCache(cache);
+    }
+}
+setDeriveCache();

package/build-tsc-cjs/util/cacheImpl.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveNoopCache = exports.deriveMapCache = void 0;
+const mapCache = new Map();
+exports.deriveMapCache = {
+    del: (key) => {
+        mapCache.delete(key);
+    },
+    forEach: (cb) => {
+        for (const [k, v] of mapCache.entries()) {
+            cb(k, v);
+        }
+    },
+    get: (key) => {
+        return mapCache.get(key);
+    },
+    set: (key, value) => {
+        mapCache.set(key, value);
+    }
+};
+exports.deriveNoopCache = {
+    del: () => undefined,
+    forEach: () => undefined,
+    get: () => undefined,
+    set: (_, value) => value
+};

package/build-tsc-cjs/util/first.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstObservable = firstObservable;
+exports.firstMemo = firstMemo;
+const rxjs_1 = require("rxjs");
+const rpc_core_1 = require("@pezkuwi/rpc-core");
+function firstObservable(obs) {
+    return obs.pipe((0, rxjs_1.map)(([a]) => a));
+}
+function firstMemo(fn) {
+    return (instanceId, api) => (0, rpc_core_1.memo)(instanceId, (...args) => firstObservable(fn(api, ...args)));
+}

package/build-tsc-cjs/util/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memo = exports.drr = void 0;
+const tslib_1 = require("tslib");
+var rpc_core_1 = require("@pezkuwi/rpc-core");
+Object.defineProperty(exports, "drr", { enumerable: true, get: function () { return rpc_core_1.drr; } });
+Object.defineProperty(exports, "memo", { enumerable: true, get: function () { return rpc_core_1.memo; } });
+tslib_1.__exportStar(require("./approvalFlagsToBools.js"), exports);
+tslib_1.__exportStar(require("./blockNumber.js"), exports);
+tslib_1.__exportStar(require("./cache.js"), exports);
+tslib_1.__exportStar(require("./cacheImpl.js"), exports);
+tslib_1.__exportStar(require("./first.js"), exports);
+tslib_1.__exportStar(require("./lazy.js"), exports);

package/build-tsc-cjs/util/lazy.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyDeriveSection = lazyDeriveSection;
+const util_1 = require("@pezkuwi/util");
+function lazyDeriveSection(result, section, getKeys, creator) {
+    (0, util_1.lazyMethod)(result, section, () => (0, util_1.lazyMethods)({}, getKeys(section), (method) => creator(section, method)));
+}

package/build-tsc-cjs/util/types.js

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

package/build-tsc-esm/accounts/accountId.js

@@ -0,0 +1,29 @@
+import { map, of } from 'rxjs';
+import { assertReturn, isU8a } from '@pezkuwi/util';
+import { decodeAddress } from '@pezkuwi/util-crypto';
+import { memo } from '../util/index.js';
+/**
+ * @name accountId
+ * @param {(Address | AccountId | AccountIndex | string | null)} address An accounts address in various formats.
+ * @description Resolves an address (in different formats) to its corresponding `AccountId`.
+ * @example
+ * ```javascript
+ * const ALICE = "F7Hs";
+ *
+ * api.derive.accounts.accountId(ALICE, (accountId) => {
+ *   console.log(`Resolved AccountId: ${accountId}`);
+ * });
+ * ```
+ */
+export function accountId(instanceId, api) {
+    return memo(instanceId, (address) => {
+        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-tsc-esm/accounts/flags.js

@@ -0,0 +1,55 @@
+import { map, of } from 'rxjs';
+import { isFunction } from '@pezkuwi/util';
+import { memo } from '../util/index.js';
+function parseFlags(address, [electionsMembers, councilMembers, technicalCommitteeMembers, societyMembers, sudoKey]) {
+    const addrStr = address?.toString();
+    const isIncluded = (id) => 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, api) {
+    return memo(instanceId, () => {
+        const results = [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);
+        }
+        return api.queryMulti(filtered).pipe(map((values) => {
+            let resultIndex = -1;
+            for (let i = 0, count = calls.length; i < count; i++) {
+                if (isFunction(calls[i])) {
+                    results[i] = values[++resultIndex];
+                }
+            }
+            return results;
+        }));
+    });
+}
+/**
+ * @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, api) {
+    return memo(instanceId, (address) => api.derive.accounts._flags().pipe(map((r) => parseFlags(address, r))));
+}