@pezkuwi/api-derive 16.5.5 → 16.5.6

package/cjs/technicalCommittee/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 "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const members = await api.derive.technicalCommittee.members();
+ * console.log(`Members: ${JSON.stringify(members)});
+ * ```
+ */
+exports.members = (0, index_js_1.members)('technicalCommittee');
+/**
+ * @name hasProposals
+ * @description Checks if there are any active proposals in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const exists = await api.derive.technicalCommittee.hasProposals();
+ * console.log(exists);
+ * ```
+ */
+exports.hasProposals = (0, index_js_1.hasProposals)('technicalCommittee');
+/**
+ * @name proposal
+ * @description Retrieves details of a specific proposal in the "technicalCommitteeMotion" collective by its hash.
+ * @example
+ * ```javascript
+ * const proposalDetails = await api.derive.technicalCommittee.proposal(PROPOSAL_HASH);
+ * console.log(proposalDetails);
+ * ```
+ */
+exports.proposal = (0, index_js_1.proposal)('technicalCommittee');
+/**
+ * @name proposalCount
+ * @description Retrieves the total number of proposals in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const count = await api.derive.technicalCommittee.proposalCount();
+ * console.log(`Amount of proposals: ${count}`);
+ * ```
+ */
+exports.proposalCount = (0, index_js_1.proposalCount)('technicalCommittee');
+/**
+ * @name proposalHashes
+ * @description Retrieves an array of hashes for all active proposals in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const hashes = await api.derive.technicalCommittee.proposalHashes();
+ * console.log(`Proposals ${JSON.stringify(hashes)}`);
+ * ```
+ */
+exports.proposalHashes = (0, index_js_1.proposalHashes)('technicalCommittee');
+/**
+ * @name proposals
+ * @description Retrieves a list of all active proposals in the "technicalCommittee" collective.
+ * @example
+ * ```javascript
+ * const proposals = await api.derive.technicalCommittee.proposals();
+ * console.log(proposals);
+ * ```
+ */
+exports.proposals = (0, index_js_1.proposals)('technicalCommittee');
+/**
+ * @name prime
+ * @description Retrieves the prime member of the "technicalCommittee" collective, if one exists.
+ * @example
+ * ```javascript
+ * const primeMember = await api.derive.technicalCommittee.prime();
+ * console.log(primeMember);
+ * ```
+ */
+exports.prime = (0, index_js_1.prime)('technicalCommittee');

package/cjs/teyrchains/index.js

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

package/{build/parachains → cjs/teyrchains}/info.d.ts

@@ -1,19 +1,19 @@
 import type { Observable } from 'rxjs';
 import type { ParaId } from '@pezkuwi/types/interfaces';
-import type { DeriveApi, DeriveParachainFull } from '../types.js';
+import type { DeriveApi, DeriveTeyrchainFull } from '../types.js';
 /**
  * @name info
- * @param {ParaId | number} id A unique numeric (non-negative integer) identifier for a parachain.
- * @description Retrieves detailed information about a specific parachain.
+ * @param {ParaId | number} id A unique numeric (non-negative integer) identifier for a teyrchain.
+ * @description Retrieves detailed information about a specific teyrchain.
  * @example
  * ```javascript
- * await api.derive.parachains.info(1000, (info) => {
+ * await api.derive.teyrchains.info(1000, (info) => {
  *   if (info) {
- *     console.log(`Parachain ${info.id.toString()} is active: ${info.active}`);
+ *     console.log(`Teyrchain ${info.id.toString()} is active: ${info.active}`);
  *   } else {
- *     console.log("Parachain information not available.");
+ *     console.log("Teyrchain information not available.");
  *   }
  * });
  * ```
 */
-export declare function info(instanceId: string, api: DeriveApi): (id: ParaId | number) => Observable<DeriveParachainFull | null>;
+export declare function info(instanceId: string, api: DeriveApi): (id: ParaId | number) => Observable<DeriveTeyrchainFull | null>;

package/cjs/teyrchains/info.js

@@ -0,0 +1,75 @@
+"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");
+const util_js_1 = require("./util.js");
+function parseActive(id, active) {
+    const found = active.find(([paraId]) => paraId === id);
+    if (found && found[1].isSome) {
+        const [collatorId, retriable] = found[1].unwrap();
+        return (0, util_1.objectSpread)({ collatorId }, retriable.isWithRetries
+            ? {
+                isRetriable: true,
+                retries: retriable.asWithRetries.toNumber()
+            }
+            : {
+                isRetriable: false,
+                retries: 0
+            });
+    }
+    return null;
+}
+function parseCollators(id, collatorQueue) {
+    return collatorQueue.map((queue) => {
+        const found = queue.find(([paraId]) => paraId === id);
+        return found ? found[1] : null;
+    });
+}
+function parse(id, [active, retryQueue, selectedThreads, didUpdate, info, pendingSwap, heads, relayDispatchQueue]) {
+    if (info.isNone) {
+        return null;
+    }
+    return {
+        active: parseActive(id, active),
+        didUpdate: (0, util_js_1.didUpdateToBool)(didUpdate, id),
+        heads,
+        id,
+        info: (0, util_1.objectSpread)({ id }, info.unwrap()),
+        pendingSwapId: pendingSwap.unwrapOr(null),
+        relayDispatchQueue,
+        retryCollators: parseCollators(id, retryQueue),
+        selectedCollators: parseCollators(id, selectedThreads)
+    };
+}
+/**
+ * @name info
+ * @param {ParaId | number} id A unique numeric (non-negative integer) identifier for a teyrchain.
+ * @description Retrieves detailed information about a specific teyrchain.
+ * @example
+ * ```javascript
+ * await api.derive.teyrchains.info(1000, (info) => {
+ *   if (info) {
+ *     console.log(`Teyrchain ${info.id.toString()} is active: ${info.active}`);
+ *   } else {
+ *     console.log("Teyrchain information not available.");
+ *   }
+ * });
+ * ```
+*/
+function info(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, (id) => api.query['registrar'] && api.query['teyrchains']
+        ? api.queryMulti([
+            api.query['registrar']['active'],
+            api.query['registrar']['retryQueue'],
+            api.query['registrar']['selectedThreads'],
+            api.query['teyrchains']['didUpdate'],
+            [api.query['registrar']['paras'], id],
+            [api.query['registrar']['pendingSwap'], id],
+            [api.query['teyrchains']['heads'], id],
+            [api.query['teyrchains']['relayDispatchQueue'], id]
+        ])
+            .pipe((0, rxjs_1.map)((result) => parse(api.registry.createType('ParaId', id), result)))
+        : (0, rxjs_1.of)(null));
+}

package/cjs/teyrchains/overview.d.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { DeriveApi, DeriveTeyrchain } from '../types.js';
+/**
+ * @name overview
+ * @description Retrieves an overview of all registered teyrchains.
+ * @example
+ * ```javascript
+ * await api.derive.teyrchains.overview((overview) => {
+ *   teyrchains.forEach(teyrchain => {
+ *     console.log(`Teyrchain ${teyrchain.id.toString()} is registered.`);
+ *   });
+ * });
+ * ```
+ */
+export declare function overview(instanceId: string, api: DeriveApi): () => Observable<DeriveTeyrchain[]>;

package/cjs/teyrchains/overview.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overview = overview;
+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 parse([ids, didUpdate, relayDispatchQueueSizes, infos, pendingSwaps]) {
+    return ids.map((id, index) => ({
+        didUpdate: (0, util_js_1.didUpdateToBool)(didUpdate, id),
+        id,
+        info: (0, util_1.objectSpread)({ id }, infos[index].unwrapOr(null)),
+        pendingSwapId: pendingSwaps[index].unwrapOr(null),
+        relayDispatchQueueSize: relayDispatchQueueSizes[index][0].toNumber()
+    }));
+}
+/**
+ * @name overview
+ * @description Retrieves an overview of all registered teyrchains.
+ * @example
+ * ```javascript
+ * await api.derive.teyrchains.overview((overview) => {
+ *   teyrchains.forEach(teyrchain => {
+ *     console.log(`Teyrchain ${teyrchain.id.toString()} is registered.`);
+ *   });
+ * });
+ * ```
+ */
+function overview(instanceId, api) {
+    return (0, index_js_1.memo)(instanceId, () => api.query['registrar']?.['teyrchains'] && api.query['teyrchains']
+        ? api.query['registrar']['teyrchains']().pipe((0, rxjs_1.switchMap)((paraIds) => (0, rxjs_1.combineLatest)([
+            (0, rxjs_1.of)(paraIds),
+            api.query['teyrchains']['didUpdate'](),
+            api.query['teyrchains']['relayDispatchQueueSize'].multi(paraIds),
+            api.query['registrar']['paras'].multi(paraIds),
+            api.query['registrar']['pendingSwap'].multi(paraIds)
+        ])), (0, rxjs_1.map)(parse))
+        : (0, rxjs_1.of)([]));
+}

package/{build/parachains → cjs/teyrchains}/types.d.ts

@@ -11,26 +11,26 @@ export type Heads = Bytes;
 export type RelayDispatchQueue = Vec<UpwardMessage>;
 export type RelayDispatchQueueSize = ITuple<[u32, u32]>;
 export type DidUpdate = Option<Vec<ParaId>>;
-export interface DeriveParachainActive {
+export interface DeriveTeyrchainActive {
     collatorId: CollatorId;
     isRetriable: boolean;
     retries: number;
 }
-export interface DeriveParachainInfo extends ParaInfo {
+export interface DeriveTeyrchainInfo extends ParaInfo {
     id: ParaId;
     icon?: string;
     name?: string;
     owner?: string;
 }
-export interface DeriveParachain {
+export interface DeriveTeyrchain {
     didUpdate: boolean;
     pendingSwapId: ParaId | null;
     id: ParaId;
-    info: DeriveParachainInfo | null;
+    info: DeriveTeyrchainInfo | null;
     relayDispatchQueueSize?: number;
 }
-export interface DeriveParachainFull extends DeriveParachain {
-    active: DeriveParachainActive | null;
+export interface DeriveTeyrchainFull extends DeriveTeyrchain {
+    active: DeriveTeyrchainActive | null;
     heads: Bytes | null;
     relayDispatchQueue: UpwardMessage[];
     retryCollators: (CollatorId | null)[];

package/cjs/teyrchains/types.js

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

package/cjs/teyrchains/util.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.didUpdateToBool = didUpdateToBool;
+function didUpdateToBool(didUpdate, id) {
+    return didUpdate.isSome
+        ? didUpdate.unwrap().some((paraId) => paraId.eq(id))
+        : false;
+}

package/cjs/treasury/index.js

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

package/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/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/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/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/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/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/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/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);
+}