@pezkuwi/api-derive 16.5.8 → 16.5.9

package/build-deno/teyrchains/overview.ts

@@ -1,61 +0,0 @@
-
-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

@@ -1,44 +0,0 @@
-
-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

@@ -1,9 +0,0 @@
-
-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

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

package/build-deno/treasury/proposals.ts

@@ -1,107 +0,0 @@
-
-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

@@ -1,10 +0,0 @@
-
-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

@@ -1,41 +0,0 @@
-
-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

@@ -1,121 +0,0 @@
-
-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

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

package/build-deno/tx/signingInfo.ts

@@ -1,127 +0,0 @@
-
-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

@@ -1,31 +0,0 @@
-
-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

@@ -1,73 +0,0 @@
-
-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

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

package/build-deno/type/types.ts

@@ -1,19 +0,0 @@
-
-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;
-}