@pezkuwi/api-derive 16.5.5 → 16.5.8

package/build-deno/teyrchains/overview.ts

@@ -0,0 +1,61 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { ParaId } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi, DeriveTeyrchain, DeriveTeyrchainInfo } from '../types.ts';
+import type { DidUpdate, ParaInfoResult, PendingSwap, RelayDispatchQueueSize } from './types.ts';
+
+import { combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { objectSpread } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+import { didUpdateToBool } from './util.ts';
+
+type Result = [
+  ParaId[],
+  DidUpdate,
+  RelayDispatchQueueSize[],
+  ParaInfoResult[],
+  PendingSwap[]
+];
+
+function parse ([ids, didUpdate, relayDispatchQueueSizes, infos, pendingSwaps]: Result): DeriveTeyrchain[] {
+  return ids.map((id, index): DeriveTeyrchain => ({
+    didUpdate: didUpdateToBool(didUpdate, id),
+    id,
+    info: objectSpread<DeriveTeyrchainInfo>({ 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.`);
+ *   });
+ * });
+ * ```
+ */
+export function overview (instanceId: string, api: DeriveApi): () => Observable<DeriveTeyrchain[]> {
+  return memo(instanceId, (): Observable<DeriveTeyrchain[]> =>
+    api.query['registrar']?.['teyrchains'] && api.query['teyrchains']
+      ? api.query['registrar']['teyrchains']<ParaId[]>().pipe(
+        switchMap((paraIds) =>
+          combineLatest([
+            of(paraIds),
+            api.query['teyrchains']['didUpdate']<DidUpdate>(),
+            api.query['teyrchains']['relayDispatchQueueSize'].multi<RelayDispatchQueueSize>(paraIds),
+            api.query['registrar']['paras'].multi<ParaInfoResult>(paraIds),
+            api.query['registrar']['pendingSwap'].multi<PendingSwap>(paraIds)
+          ])
+        ),
+        map(parse)
+      )
+      : of([] as DeriveTeyrchain[])
+  );
+}

package/build-deno/teyrchains/types.ts

@@ -0,0 +1,44 @@
+
+import type { Bytes, Option, u32, Vec } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { CollatorId, ParaId, ParaInfo, Retriable, UpwardMessage } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { ITuple } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+
+export type ParaInfoResult = Option<ParaInfo>;
+export type PendingSwap = Option<ParaId>;
+export type Active = Vec<ITuple<[ParaId, Option<ITuple<[CollatorId, Retriable]>>]>>;
+export type RetryQueue = Vec<Vec<ITuple<[ParaId, CollatorId]>>>
+export type SelectedThreads = Vec<Vec<ITuple<[ParaId, CollatorId]>>>
+export type Code = Bytes;
+export type Heads = Bytes;
+export type RelayDispatchQueue = Vec<UpwardMessage>
+export type RelayDispatchQueueSize = ITuple<[u32, u32]>;
+export type DidUpdate = Option<Vec<ParaId>>;
+
+export interface DeriveTeyrchainActive {
+  collatorId: CollatorId;
+  isRetriable: boolean;
+  retries: number;
+}
+
+export interface DeriveTeyrchainInfo extends ParaInfo {
+  id: ParaId;
+  icon?: string;
+  name?: string;
+  owner?: string;
+}
+
+export interface DeriveTeyrchain {
+  didUpdate: boolean;
+  pendingSwapId: ParaId | null;
+  id: ParaId;
+  info: DeriveTeyrchainInfo | null;
+  relayDispatchQueueSize?: number;
+}
+
+export interface DeriveTeyrchainFull extends DeriveTeyrchain {
+  active: DeriveTeyrchainActive | null;
+  heads: Bytes | null;
+  relayDispatchQueue: UpwardMessage[];
+  retryCollators: (CollatorId | null)[];
+  selectedCollators: (CollatorId | null)[];
+}

package/build-deno/teyrchains/util.ts

@@ -0,0 +1,9 @@
+
+import type { ParaId } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DidUpdate } from './types.ts';
+
+export function didUpdateToBool (didUpdate: DidUpdate, id: ParaId): boolean {
+  return didUpdate.isSome
+    ? didUpdate.unwrap().some((paraId) => paraId.eq(id))
+    : false;
+}

package/build-deno/treasury/index.ts

@@ -0,0 +1,2 @@
+
+export * from './proposals.ts';

package/build-deno/treasury/proposals.ts

@@ -0,0 +1,107 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { Option } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { ProposalIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezpalletTreasuryProposal } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { DeriveApi, DeriveCollectiveProposal, DeriveTreasuryProposal, DeriveTreasuryProposals } from '../types.ts';
+
+import { combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+interface Result {
+  allIds: ProposalIndex[];
+  allProposals: Option<PezpalletTreasuryProposal>[];
+  approvalIds: ProposalIndex[];
+  councilProposals: DeriveCollectiveProposal[];
+  proposalCount: ProposalIndex;
+}
+
+function parseResult (api: DeriveApi, { allIds, allProposals, approvalIds, councilProposals, proposalCount }: Result): DeriveTreasuryProposals {
+  const approvals: DeriveTreasuryProposal[] = [];
+  const proposals: DeriveTreasuryProposal[] = [];
+  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): void => {
+    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: DeriveApi, proposalCount: ProposalIndex, approvalIds: ProposalIndex[]): Observable<DeriveTreasuryProposals> {
+  const proposalIds: ProposalIndex[] = [];
+  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 combineLatest([
+    api.query.treasury.proposals.multi(allIds),
+    api.derive.council
+      ? api.derive.council.proposals()
+      : of([] as DeriveCollectiveProposal[])
+  ]).pipe(
+    map(([allProposals, councilProposals]): DeriveTreasuryProposals =>
+      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);
+ * ```
+ */
+export function proposals (instanceId: string, api: DeriveApi): () => Observable<DeriveTreasuryProposals> {
+  return memo(instanceId, (): Observable<DeriveTreasuryProposals> =>
+    api.query.treasury
+      ? combineLatest([
+        api.query.treasury.proposalCount(),
+        api.query.treasury.approvals()
+      ]).pipe(
+        switchMap(([proposalCount, approvalIds]) =>
+          retrieveProposals(api, proposalCount, approvalIds)
+        )
+      )
+      : of({
+        approvals: [],
+        proposalCount: api.registry.createType('ProposalIndex'),
+        proposals: []
+      } as DeriveTreasuryProposals)
+  );
+}

package/build-deno/tx/constants.ts

@@ -0,0 +1,10 @@
+
+import { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+export const FALLBACK_MAX_HASH_COUNT = 250;
+
+export const FALLBACK_PERIOD = new BN(6 * 1000);
+
+export const MAX_FINALITY_LAG = new BN(5);
+
+export const MORTAL_PERIOD = new BN(5 * 60 * 1000);

package/build-deno/tx/events.ts

@@ -0,0 +1,41 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { EventRecord, Hash, SignedBlock } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { combineLatest, map, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+interface Result {
+  block: SignedBlock;
+  events: EventRecord[];
+}
+
+/**
+ * @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);
+ * ```
+ */
+export function events (instanceId: string, api: DeriveApi): (at: Hash) => Observable<Result> {
+  return memo(instanceId, (blockHash: Hash) =>
+    combineLatest([
+      api.rpc.chain.getBlock(blockHash),
+      api.queryAt(blockHash).pipe(
+        switchMap((queryAt) =>
+          queryAt.system.events()
+        )
+      )
+    ]).pipe(
+      map(([block, events]) => ({ block, events }))
+    )
+  );
+}

package/build-deno/tx/extrinsicInfo.ts

@@ -0,0 +1,121 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { GenericExtrinsic } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { EventRecord, Hash } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { map } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+interface ExtrinsicInfo {
+  blockHash: Hash | string,
+  blockNumber: number,
+  extrinsic: GenericExtrinsic,
+  events: EventRecord[]
+  success: boolean
+}
+
+interface ExtrinsicsInfo {
+  blockHash: Hash | string,
+  blockNumber: number,
+  extrinsics: {
+    events: EventRecord[]
+    extrinsic: GenericExtrinsic,
+    success: boolean
+  }[],
+}
+
+/**
+ * @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());
+ * ```
+ */
+export function extrinsicInfo (instanceId: string, api: DeriveApi): (at: Hash, transactionHash: Uint8Array | string) => Observable<ExtrinsicInfo | null> {
+  return memo(instanceId, (at: Hash, transactionHash: Uint8Array | string): Observable<ExtrinsicInfo | null> => {
+    return api.derive.tx.events(at).pipe(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();
+ * ```
+ */
+export function accountExtrinsics (instanceId: string, api: DeriveApi): (at: Hash, accountId: Uint8Array | string) => Observable<ExtrinsicsInfo> {
+  return memo(instanceId, (at: Hash, accountId: Uint8Array | string): Observable<ExtrinsicsInfo> => {
+    return api.derive.tx.events(at).pipe(map(({ block, events }) => {
+      const indexes: number[] = [];
+
+      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-deno/tx/index.ts

@@ -0,0 +1,4 @@
+
+export * from './events.ts';
+export * from './extrinsicInfo.ts';
+export * from './signingInfo.ts';

package/build-deno/tx/signingInfo.ts

@@ -0,0 +1,127 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AugmentedConsts } from 'https://deno.land/x/pezkuwi/api-base/types/index.ts';
+import type { u64 } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { Header, Index } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { AnyNumber, Codec, IExtrinsicEra } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { catchError, combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { isNumber, isUndefined } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { unwrapBlockNumber } from '../util/index.ts';
+import { FALLBACK_MAX_HASH_COUNT, FALLBACK_PERIOD, MAX_FINALITY_LAG, MORTAL_PERIOD } from './constants.ts';
+
+interface Result {
+  header: Header | null;
+  mortalLength: number;
+  nonce: Index;
+}
+
+function latestNonce (api: DeriveApi, address: string): Observable<Index> {
+  return api.derive.balances.account(address).pipe(
+    map(({ accountNonce }) => accountNonce)
+  );
+}
+
+function nextNonce (api: DeriveApi, address: string): Observable<Index> {
+  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: DeriveApi): Observable<Header> {
+  return combineLatest([
+    api.rpc.chain.getHeader().pipe(
+      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
+          ? 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(
+            catchError(() => of(header))
+          )
+      )
+    ),
+    api.rpc.chain.getFinalizedHead().pipe(
+      switchMap((hash) =>
+        api.rpc.chain.getHeader(hash).pipe(
+          catchError(() => of(null))
+        )
+      )
+    )
+  ]).pipe(
+    map(([current, finalized]) =>
+      // determine the hash to use, current when lag > max, else finalized
+      !finalized || unwrapBlockNumber(current).sub(unwrapBlockNumber(finalized)).gt(MAX_FINALITY_LAG)
+        ? current
+        : finalized
+    )
+  );
+}
+
+interface Aura {
+  slotDuration: u64 & AugmentedConsts<'rxjs'>;
+}
+
+function babeOrAuraPeriod (api: DeriveApi): BN | undefined {
+  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'] as unknown as 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);
+ * ```
+ */
+export function signingInfo (_instanceId: string, api: DeriveApi): (address: string, nonce?: AnyNumber | Codec, era?: IExtrinsicEra | number) => Observable<Result> {
+  // no memo, we want to do this fresh on each run
+  return (address: string, nonce?: AnyNumber | Codec, era?: IExtrinsicEra | number): Observable<Result> =>
+    combineLatest([
+      // retrieve nonce if none was specified
+      isUndefined(nonce)
+        ? latestNonce(api, address)
+        : nonce === -1
+          ? nextNonce(api, address)
+          : of(api.registry.createType('Index', nonce)),
+      // if no era (create) or era > 0 (mortal), do block retrieval
+      (isUndefined(era) || (isNumber(era) && era > 0))
+        ? signingHeader(api)
+        : of(null)
+    ]).pipe(
+      map(([nonce, header]) => ({
+        header,
+        mortalLength: Math.min(
+          api.consts.system?.blockHashCount?.toNumber() || FALLBACK_MAX_HASH_COUNT,
+          MORTAL_PERIOD
+            .div(babeOrAuraPeriod(api) || FALLBACK_PERIOD)
+            .iadd(MAX_FINALITY_LAG)
+            .toNumber()
+        ),
+        nonce
+      }))
+    );
+}

package/build-deno/type/HeaderExtended.ts

@@ -0,0 +1,31 @@
+
+import type { AccountId, Header } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { Registry } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { HeaderExtended } from './types.ts';
+
+import { extractAuthor } from './util.ts';
+
+export function createHeaderExtended (registry: Registry, header?: Header, validators?: AccountId[] | null, author?: AccountId | null): HeaderExtended {
+  // an instance of the base extrinsic for us to extend
+  const HeaderBase = registry.createClass('Header');
+
+  class Implementation extends HeaderBase implements HeaderExtended {
+    readonly #author?: AccountId | undefined;
+
+    constructor (registry: Registry, header?: Header, validators?: AccountId[] | null, author?: AccountId | null) {
+      super(registry, header);
+
+      this.#author = author || extractAuthor(this.digest, validators || []);
+      this.createdAtHash = header?.createdAtHash;
+    }
+
+    /**
+     * @description Convenience method, returns the author for the block
+     */
+    public get author (): AccountId | undefined {
+      return this.#author;
+    }
+  }
+
+  return new Implementation(registry, header, validators, author);
+}

package/build-deno/type/SignedBlockExtended.ts

@@ -0,0 +1,73 @@
+
+import type { AccountId, DispatchError, DispatchInfo, EventRecord, Extrinsic, SignedBlock } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { Registry } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { SignedBlockExtended, TxWithEvent } from './types.ts';
+
+import { extractAuthor } from './util.ts';
+
+function mapExtrinsics (extrinsics: Extrinsic[], records: EventRecord[]): TxWithEvent[] {
+  return extrinsics.map((extrinsic, index): TxWithEvent => {
+    let dispatchError: DispatchError | undefined;
+    let dispatchInfo: DispatchInfo | undefined;
+
+    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] as DispatchInfo;
+          } else if (event.method === 'ExtrinsicFailed') {
+            dispatchError = event.data[0] as DispatchError;
+            dispatchInfo = event.data[1] as DispatchInfo;
+          }
+        }
+
+        return event;
+      });
+
+    return { dispatchError, dispatchInfo, events, extrinsic };
+  });
+}
+
+export function createSignedBlockExtended (registry: Registry, block?: SignedBlock, events?: EventRecord[], validators?: AccountId[] | null, author?: AccountId | null): SignedBlockExtended {
+  // an instance of the base extrinsic for us to extend
+  const SignedBlockBase = registry.createClass('SignedBlock');
+
+  class Implementation extends SignedBlockBase implements SignedBlockExtended {
+    readonly #author?: AccountId | undefined;
+    readonly #events: EventRecord[];
+    readonly #extrinsics: TxWithEvent[];
+
+    constructor (registry: Registry, block?: SignedBlock, events?: EventRecord[], validators?: AccountId[] | null, author?: AccountId | null) {
+      super(registry, block);
+
+      this.#author = author || extractAuthor(this.block.header.digest, validators || []);
+      this.#events = events || ([] as EventRecord[]);
+      this.#extrinsics = mapExtrinsics(this.block.extrinsics, this.#events);
+      this.createdAtHash = block?.createdAtHash;
+    }
+
+    /**
+     * @description Convenience method, returns the author for the block
+     */
+    public get author (): AccountId | undefined {
+      return this.#author;
+    }
+
+    /**
+     * @description Convenience method, returns the events associated with the block
+     */
+    public get events (): EventRecord[] {
+      return this.#events;
+    }
+
+    /**
+     * @description Returns the extrinsics and their events, mapped
+     */
+    public get extrinsics (): TxWithEvent[] {
+      return this.#extrinsics;
+    }
+  }
+
+  return new Implementation(registry, block, events, validators, author);
+}

package/build-deno/type/index.ts

@@ -0,0 +1,3 @@
+
+export { createHeaderExtended } from './HeaderExtended.ts';
+export { createSignedBlockExtended } from './SignedBlockExtended.ts';

package/build-deno/type/types.ts

@@ -0,0 +1,19 @@
+
+import type { AccountId, DispatchError, DispatchInfo, Event, EventRecord, Extrinsic, Header, SignedBlock } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+
+export interface HeaderExtended extends Header {
+  readonly author: AccountId | undefined;
+}
+
+export interface SignedBlockExtended extends SignedBlock {
+  readonly author: AccountId | undefined;
+  readonly events: EventRecord[];
+  readonly extrinsics: TxWithEvent[];
+}
+
+export interface TxWithEvent {
+  dispatchError?: DispatchError | undefined;
+  dispatchInfo?: DispatchInfo | undefined;
+  events: Event[];
+  extrinsic: Extrinsic;
+}