@pezkuwi/api-derive 16.5.17 → 16.5.18

package/build-deno/chain/getBlock.ts

@@ -0,0 +1,41 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { SignedBlockExtended } from '../type/types.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { createSignedBlockExtended } from '../type/index.ts';
+import { memo } from '../util/index.ts';
+import { getAuthorDetails } from './util.ts';
+
+/**
+ * @name getBlock
+ * @param {( Uint8Array | string )} hash A block hash as U8 array or string.
+ * @description Get a specific block (e.g. rpc.chain.getBlock) and extend it with the author
+ * @example
+ * ```javascript
+ * const { author, block } = await api.derive.chain.getBlock('0x123...456');
+ *
+ * console.log(`block #${block.header.number} was authored by ${author}`);
+ * ```
+ */
+export function getBlock (instanceId: string, api: DeriveApi): (hash: Uint8Array | string) => Observable<SignedBlockExtended> {
+  return memo(instanceId, (blockHash: Uint8Array | string): Observable<SignedBlockExtended> =>
+    combineLatest([
+      api.rpc.chain.getBlock(blockHash),
+      api.queryAt(blockHash)
+    ]).pipe(
+      switchMap(([signedBlock, queryAt]) =>
+        combineLatest([
+          of(signedBlock),
+          queryAt.system.events(),
+          getAuthorDetails(api, signedBlock.block.header, blockHash)
+        ])
+      ),
+      map(([signedBlock, events, [, validators, author]]) =>
+        createSignedBlockExtended(events.registry, signedBlock, events, validators, author)
+      )
+    )
+  );
+}

package/build-deno/chain/getBlockByNumber.ts

@@ -0,0 +1,28 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AnyNumber } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { SignedBlockExtended } from '../type/types.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @name getBlockByNumber
+ * @param {( BN | bigint | Uint8Array | number | string )} blockNumber
+ * @description Get a specific block (e.g. rpc.chain.getBlock) and extend it with the author by block number
+ * @example
+ * ```javascript
+ * const { author, block } = await api.derive.chain.getBlockByNumber(123);
+ *
+ * console.log(`block #${block.header.number} was authored by ${author}`);
+ * ```
+ */
+export function getBlockByNumber (instanceId: string, api: DeriveApi): (blockNumber: AnyNumber) => Observable<SignedBlockExtended> {
+  return memo(instanceId, (blockNumber: AnyNumber): Observable<SignedBlockExtended> =>
+    api.rpc.chain.getBlockHash(blockNumber).pipe(
+      switchMap((h) => api.derive.chain.getBlock(h))
+    )
+  );
+}

package/build-deno/chain/getHeader.ts

@@ -0,0 +1,35 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { HeaderExtended } from '../type/types.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { map, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { createHeaderExtended } from '../type/index.ts';
+import { memo } from '../util/index.ts';
+import { getAuthorDetails } from './util.ts';
+
+/**
+ * @name getHeader
+ * @param {( Uint8Array | string )} hash - A block hash as U8 array or string.
+ * @returns An array containing the block header and the block author
+ * @description Get a specific block header and extend it with the author
+ * @example
+ * ```javascript
+ * const { author, number } = await api.derive.chain.getHeader('0x123...456');
+ *
+ * console.log(`block #${number} was authored by ${author}`);
+ * ```
+ */
+export function getHeader (instanceId: string, api: DeriveApi): (blockHash: Uint8Array | string) => Observable<HeaderExtended> {
+  return memo(instanceId, (blockHash: Uint8Array | string): Observable<HeaderExtended> =>
+    api.rpc.chain.getHeader(blockHash).pipe(
+      switchMap((header) =>
+        getAuthorDetails(api, header, blockHash)
+      ),
+      map(([header, validators, author]) =>
+        createHeaderExtended((validators || header).registry, header, validators, author)
+      )
+    )
+  );
+}

package/build-deno/chain/index.ts

@@ -0,0 +1,11 @@
+
+export * from './bestNumber.ts';
+export * from './bestNumberFinalized.ts';
+export * from './bestNumberLag.ts';
+export * from './getBlock.ts';
+export * from './getBlockByNumber.ts';
+export * from './getHeader.ts';
+export * from './subscribeFinalizedBlocks.ts';
+export * from './subscribeFinalizedHeads.ts';
+export * from './subscribeNewBlocks.ts';
+export * from './subscribeNewHeads.ts';

package/build-deno/chain/subscribeFinalizedBlocks.ts

@@ -0,0 +1,28 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { SignedBlockExtended } from '../type/types.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @name subscribeFinalizedBlocks
+ * @description Retrieves the finalized block & events for that block
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeFinalizedBlocks((finalizedBlock) => {
+ *  console.log(`# Finalized block ${finalizedBlock.block.hash}`);
+ * });
+ * ```
+ */
+export function subscribeFinalizedBlocks (instanceId: string, api: DeriveApi): () => Observable<SignedBlockExtended> {
+  return memo(instanceId, (): Observable<SignedBlockExtended> =>
+    api.derive.chain.subscribeFinalizedHeads().pipe(
+      switchMap((header) =>
+        api.derive.chain.getBlock(header.createdAtHash || header.hash)
+      )
+    )
+  );
+}

package/build-deno/chain/subscribeFinalizedHeads.ts

@@ -0,0 +1,61 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { Hash, Header } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { from, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * Returns a header range from startHash to to (not including) endHash, i.e. lastBlock.parentHash === endHash
+ */
+export function _getHeaderRange (instanceId: string, api: DeriveApi): (startHash: Hash, endHash: Hash, prev?: Header[]) => Observable<Header[]> {
+  return memo(instanceId, (startHash: Hash, endHash: Hash, prev: Header[] = []): Observable<Header[]> =>
+    api.rpc.chain.getHeader(startHash).pipe(
+      switchMap((header) =>
+        header.parentHash.eq(endHash)
+          ? of([header, ...prev])
+          : api.derive.chain._getHeaderRange(header.parentHash, endHash, [header, ...prev])
+      )
+    )
+  );
+}
+
+/**
+ * @name subscribeFinalizedHeads
+ * @description An observable of the finalized block headers. Unlike the base
+ * chain.subscribeFinalizedHeads this does not skip any headers. Since finalization
+ * may skip specific blocks (finalization happens in terms of chains), this version
+ * of the derive tracks missing headers (since last retrieved) and provides them
+ * to the caller.
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeFinalizedHeads((finalizedHead) => {
+ *   console.log(`${finalizedHead.hash}`);
+ * });
+ * ```
+ */
+export function subscribeFinalizedHeads (instanceId: string, api: DeriveApi): () => Observable<Header> {
+  return memo(instanceId, (): Observable<Header> => {
+    let prevHash: Hash | null = null;
+
+    return api.rpc.chain.subscribeFinalizedHeads().pipe(
+      switchMap((header) => {
+        const endHash = prevHash;
+        const startHash = header.parentHash;
+
+        header.createdAtHash = header.hash as unknown as typeof header.createdAtHash;
+        prevHash = header.hash as unknown as Hash;
+
+        return endHash === null || startHash.eq(endHash)
+          ? of(header)
+          : api.derive.chain._getHeaderRange(startHash, endHash, [header]).pipe(
+            switchMap((headers) =>
+              from(headers)
+            )
+          );
+      })
+    );
+  });
+}

package/build-deno/chain/subscribeNewBlocks.ts

@@ -0,0 +1,28 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { SignedBlockExtended } from '../type/types.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @name subscribeNewBlocks
+ * @returns The latest block & events for that block
+ * @example
+ * ```javascript
+ * const unsub = await api.derive.chain.subscribeNewBlocks((newBlock) => {
+ *   console.log(`Block Hash: ${newBlock.hash}`);
+ * });
+ * ```
+ */
+export function subscribeNewBlocks (instanceId: string, api: DeriveApi): () => Observable<SignedBlockExtended> {
+  return memo(instanceId, (): Observable<SignedBlockExtended> =>
+    api.derive.chain.subscribeNewHeads().pipe(
+      switchMap((header) =>
+        api.derive.chain.getBlock(header.createdAtHash || header.hash)
+      )
+    )
+  );
+}

package/build-deno/chain/subscribeNewHeads.ts

@@ -0,0 +1,36 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { HeaderExtended } from '../type/types.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { map, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { createHeaderExtended } from '../type/index.ts';
+import { memo } from '../util/index.ts';
+import { getAuthorDetails } from './util.ts';
+
+/**
+ * @name subscribeNewHeads
+ * @returns A header with the current header (including extracted author).
+ * @description An observable of the current block header and it's author.
+ * @example
+ * ```javascript
+ * api.derive.chain.subscribeNewHeads((header) => {
+ *   console.log(`block #${header.number} was authored by ${header.author}`);
+ * });
+ * ```
+ */
+export function subscribeNewHeads (instanceId: string, api: DeriveApi): () => Observable<HeaderExtended> {
+  return memo(instanceId, (): Observable<HeaderExtended> =>
+    api.rpc.chain.subscribeNewHeads().pipe(
+      switchMap((header) =>
+        getAuthorDetails(api, header)
+      ),
+      map(([header, validators, author]): HeaderExtended => {
+        header.createdAtHash = header.hash;
+
+        return createHeaderExtended(header.registry, header, validators, author);
+      })
+    )
+  );
+}

package/build-deno/chain/util.ts

@@ -0,0 +1,110 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { QueryableStorage } from 'https://deno.land/x/pezkuwi/api-base/types/index.ts';
+import type { Compact, Vec } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { AccountId, BlockNumber, Header } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezpalletImOnlineSr25519AppSr25519Public } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { Codec, IOption } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { combineLatest, map, mergeMap, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo, unwrapBlockNumber } from '../util/index.ts';
+
+export type BlockNumberDerive = (instanceId: string, api: DeriveApi) => () => Observable<BlockNumber>;
+
+type OptionMapping = IOption<{ account: AccountId } & Codec>;
+type OptionNimbus = IOption<{ nimbus: PezpalletImOnlineSr25519AppSr25519Public } & Codec>;
+
+export function createBlockNumberDerive <T extends { number: Compact<BlockNumber> | BlockNumber }> (fn: (api: DeriveApi) => Observable<T>): BlockNumberDerive {
+  return (instanceId: string, api: DeriveApi) =>
+    memo(instanceId, () =>
+      fn(api).pipe(
+        map(unwrapBlockNumber)
+      )
+    );
+}
+
+/** @internal */
+function getAuthorDetailsWithAt (header: Header, queryAt: QueryableStorage<'rxjs'>): Observable<[Header, Vec<AccountId> | null, AccountId | null]> {
+  const validators = queryAt.session?.validators
+    ? queryAt.session.validators()
+    : of(null);
+
+  // nimbus consensus stores the session key of the block author in header logs
+  const { logs: [log] } = header.digest;
+  const loggedAuthor = (log && (
+    (log.isConsensus && log.asConsensus[0].isNimbus && log.asConsensus[1]) ||
+    (log.isPreRuntime && log.asPreRuntime[0].isNimbus && log.asPreRuntime[1])
+  ));
+
+  if (loggedAuthor) {
+    // use the author mapping pallet, if available (ie: moonbeam, moonriver), to map session (nimbus) key to author (collator/validator) key
+    if (queryAt['authorMapping']?.['mappingWithDeposit']) {
+      return combineLatest([
+        of(header),
+        validators,
+        queryAt['authorMapping']['mappingWithDeposit']<OptionMapping>(loggedAuthor).pipe(
+          map((o) =>
+            o.unwrapOr({ account: null }).account
+          )
+        )
+      ]);
+    }
+
+    // fall back to session and teyrchain staking pallets, if available (ie: manta, calamari), to map session (nimbus) key to author (collator) key
+    if (queryAt['teyrchainStaking']?.['selectedCandidates'] && queryAt.session?.nextKeys) {
+      const loggedHex = loggedAuthor.toHex();
+
+      return combineLatest([
+        of(header),
+        validators,
+        queryAt['teyrchainStaking']['selectedCandidates']<Vec<AccountId>>().pipe(
+          mergeMap((selectedCandidates) =>
+            combineLatest([
+              of(selectedCandidates),
+              queryAt.session.nextKeys.multi<OptionNimbus>(selectedCandidates).pipe(
+                map((nextKeys) =>
+                  nextKeys.findIndex((o) =>
+                    o.unwrapOrDefault().nimbus.toHex() === loggedHex
+                  )
+                )
+              )
+            ])
+          ),
+          map(([selectedCandidates, index]) =>
+            index === -1
+              ? null
+              : selectedCandidates[index]
+          )
+        )
+      ]);
+    }
+  }
+
+  // normal operation, non-mapping
+  return combineLatest([
+    of(header),
+    validators,
+    of(null)
+  ]);
+}
+
+export function getAuthorDetails (api: DeriveApi, header: Header, blockHash?: Uint8Array | string): Observable<[Header, Vec<AccountId> | null, AccountId | null]> {
+  // For on-chain state, we need to retrieve it as per the start
+  // of the block being constructed, i.e. session validators would
+  // be at the point of the block construction, not when all operations
+  // has been supplied.
+  //
+  // However for the first block (no parentHash available), we would
+  // just use the as-is
+  return api.queryAt(
+    header.parentHash.isEmpty
+      ? blockHash || header.hash
+      : header.parentHash
+  ).pipe(
+    switchMap((queryAt) =>
+      getAuthorDetailsWithAt(header, queryAt)
+    )
+  );
+}

package/build-deno/checkTypes.manual.ts

@@ -0,0 +1,6 @@
+
+import 'https://deno.land/x/pezkuwi/api-augment/mod.ts';
+
+import { derive } from './index.ts';
+
+console.log(derive.chain.bestNumber);

package/build-deno/collective/helpers.ts

@@ -0,0 +1,34 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { DeriveApi } from '../types.ts';
+import type { Collective } from './types.ts';
+
+import { of } from 'https://esm.sh/rxjs@7.8.1';
+
+import { isFunction } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+
+export function getInstance (api: DeriveApi, section: string): DeriveApi['query']['council'] {
+  const instances = api.registry.getModuleInstances(api.runtimeVersion.specName, section);
+  const name = instances?.length
+    ? instances[0]
+    : section;
+
+  return api.query[name as 'council'];
+}
+
+export function withSection <T, F extends (...args: any[]) => Observable<T>> (section: Collective, fn: (query: DeriveApi['query']['council'], api: DeriveApi, instanceId: string) => F): (instanceId: string, api: DeriveApi) => F {
+  return (instanceId: string, api: DeriveApi) =>
+    memo(instanceId, fn(getInstance(api, section), api, instanceId)) as unknown as F;
+}
+
+export function callMethod <T> (method: 'members' | 'proposals' | 'proposalCount', empty: T): (section: Collective) => (instanceId: string, api: DeriveApi) => () => Observable<T> {
+  return (section: Collective) =>
+    withSection(section, (query) =>
+      (): Observable<T> =>
+        isFunction(query?.[method])
+          ? query[method]() as unknown as Observable<T>
+          : of(empty)
+    );
+}

package/build-deno/collective/index.ts

@@ -0,0 +1,4 @@
+
+export * from './members.ts';
+export * from './prime.ts';
+export * from './proposals.ts';

package/build-deno/collective/members.ts

@@ -0,0 +1,6 @@
+
+import type { MembersFn } from './types.ts';
+
+import { callMethod } from './helpers.ts';
+
+export const members: MembersFn = /*#__PURE__*/ callMethod('members', []);

package/build-deno/collective/prime.ts

@@ -0,0 +1,23 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AccountId } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { Collective, PrimeFnRet } from './types.ts';
+
+import { map, of } from 'https://esm.sh/rxjs@7.8.1';
+
+import { isFunction } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { withSection } from './helpers.ts';
+
+export function prime (section: Collective): PrimeFnRet {
+  return withSection(section, (query) =>
+    (): Observable<AccountId | null> =>
+      isFunction(query?.prime)
+        ? query.prime().pipe(
+          map((o): AccountId | null =>
+            o.unwrapOr(null)
+          )
+        )
+        : of(null)
+  );
+}

package/build-deno/collective/proposals.ts

@@ -0,0 +1,71 @@
+
+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 { Hash, Proposal, Votes } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi, DeriveCollectiveProposal } from '../types.ts';
+import type { Collective, HasProposalsFnRet, ProposalCountFn, ProposalFnRet, ProposalHashesFn, ProposalsFnRet } from './types.ts';
+
+import { catchError, combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { isFunction } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { firstObservable } from '../util/index.ts';
+import { callMethod, withSection } from './helpers.ts';
+
+type Result = [(Hash | Uint8Array | string)[], (Option<Proposal> | null)[], Option<Votes>[]];
+
+function parse (api: DeriveApi, [hashes, proposals, votes]: Result): DeriveCollectiveProposal[] {
+  return proposals.map((o, index): DeriveCollectiveProposal => ({
+    hash: api.registry.createType('Hash', hashes[index]),
+    proposal: o && o.isSome
+      ? o.unwrap()
+      : null,
+    votes: votes[index].unwrapOr(null)
+  }));
+}
+
+function _proposalsFrom (api: DeriveApi, query: DeriveApi['query']['council'], hashes: (Hash | Uint8Array | string)[]): Observable<DeriveCollectiveProposal[]> {
+  return (isFunction(query?.proposals) && hashes.length
+    ? combineLatest([
+      of(hashes),
+      // this should simply be api.query[section].proposalOf.multi<Option<Proposal>>(hashes),
+      // however we have had cases on Edgeware where the indices have moved around after an
+      // upgrade, which results in invalid on-chain data
+      query.proposalOf.multi<Option<Proposal>>(hashes).pipe(
+        catchError(() => of(hashes.map(() => null)))
+      ),
+      query.voting.multi<Option<Votes>>(hashes)
+    ])
+    : of<Result>([[], [], []])
+  ).pipe(
+    map((r) => parse(api, r))
+  );
+}
+
+export function hasProposals (section: Collective): HasProposalsFnRet {
+  return withSection(section, (query) =>
+    (): Observable<boolean> =>
+      of(isFunction(query?.proposals))
+  );
+}
+
+export function proposals (section: Collective): ProposalsFnRet {
+  return withSection(section, (query, api) =>
+    (): Observable<DeriveCollectiveProposal[]> =>
+      api.derive[section as 'council'].proposalHashes().pipe(
+        switchMap((all) => _proposalsFrom(api, query, all))
+      )
+  );
+}
+
+export function proposal (section: Collective): ProposalFnRet {
+  return withSection(section, (query, api) =>
+    (hash: Hash | Uint8Array | string): Observable<DeriveCollectiveProposal | null> =>
+      isFunction(query?.proposals)
+        ? firstObservable(_proposalsFrom(api, query, [hash]))
+        : of(null)
+  );
+}
+
+export const proposalCount: ProposalCountFn = /*#__PURE__*/ callMethod('proposalCount', null);
+export const proposalHashes: ProposalHashesFn = /*#__PURE__*/ callMethod('proposals', []);

package/build-deno/collective/types.ts

@@ -0,0 +1,28 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { u32 } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { AccountId, Hash } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi, DeriveCollectiveProposal } from '../types.ts';
+
+export type Collective = 'allianceMotion' | 'council' | 'membership' | 'technicalCommittee';
+
+export type HasProposalsFnRet = (instanceId: string, api: DeriveApi) => () => Observable<boolean>;
+export type HasProposalsFn = (section: Collective) => HasProposalsFnRet;
+
+export type MembersFnRet = (instanceId: string, api: DeriveApi) => () => Observable<AccountId[]>;
+export type MembersFn = (section: Collective) => MembersFnRet;
+
+export type PrimeFnRet = (instanceId: string, api: DeriveApi) => () => Observable<AccountId | null>;
+export type PrimeFn = (section: Collective) => PrimeFnRet;
+
+export type ProposalFnRet = (instanceId: string, api: DeriveApi) => (hash: Hash | Uint8Array | string) => Observable<DeriveCollectiveProposal | null>;
+export type ProposalFn = (section: Collective) => ProposalFnRet;
+
+export type ProposalsFnRet = (instanceId: string, api: DeriveApi) => () => Observable<DeriveCollectiveProposal[]>;
+export type ProposalsFn = (section: Collective) => ProposalsFnRet;
+
+export type ProposalCountFnRet = (instanceId: string, api: DeriveApi) => () => Observable<u32 | null>;
+export type ProposalCountFn = (section: Collective) => ProposalCountFnRet;
+
+export type ProposalHashesFnRet = (instanceId: string, api: DeriveApi) => () => Observable<Hash[]>;
+export type ProposalHashesFn = (section: Collective) => ProposalHashesFnRet;

package/build-deno/contracts/fees.ts

@@ -0,0 +1,58 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import type { DeriveApi, DeriveContractFees } from '../types.ts';
+
+import { map, of } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+type ResultV2 = [BN, BN, BN, BN, BN, BN, BN, BN, BN, BN];
+
+function queryConstants (api: DeriveApi): Observable<ResultV2> {
+  return of([
+    // deprecated
+    api.consts.contracts['callBaseFee'] || api.registry.createType('Balance'),
+    api.consts.contracts['contractFee'] || api.registry.createType('Balance'),
+    api.consts.contracts['creationFee'] || api.registry.createType('Balance'),
+    api.consts.contracts['transactionBaseFee'] || api.registry.createType('Balance'),
+    api.consts.contracts['transactionByteFee'] || api.registry.createType('Balance'),
+    api.consts.contracts['transferFee'] || api.registry.createType('Balance'),
+
+    // current
+    api.consts.contracts['rentByteFee'] || api.registry.createType('Balance'),
+    api.consts.contracts['rentDepositOffset'] || api.registry.createType('Balance'),
+    api.consts.contracts['surchargeReward'] || api.registry.createType('Balance'),
+    api.consts.contracts['tombstoneDeposit'] || api.registry.createType('Balance')
+  ]) as unknown as Observable<ResultV2>;
+}
+
+/**
+ * @name fees
+ * @returns An object containing the combined results of the queries for
+ * all relevant contract fees as declared in the bizinikiwi chain spec.
+ * @example
+ * ```javascript
+ * api.derive.contracts.fees(([creationFee, transferFee]) => {
+ *   console.log(`The fee for creating a new contract on this chain is ${creationFee} units. The fee required to call this contract is ${transferFee} units.`);
+ * });
+ * ```
+ */
+export function fees (instanceId: string, api: DeriveApi): () => Observable<DeriveContractFees> {
+  return memo(instanceId, (): Observable<DeriveContractFees> => {
+    return queryConstants(api).pipe(
+      map(([callBaseFee, contractFee, creationFee, transactionBaseFee, transactionByteFee, transferFee, rentByteFee, rentDepositOffset, surchargeReward, tombstoneDeposit]): DeriveContractFees => ({
+        callBaseFee,
+        contractFee,
+        creationFee,
+        rentByteFee,
+        rentDepositOffset,
+        surchargeReward,
+        tombstoneDeposit,
+        transactionBaseFee,
+        transactionByteFee,
+        transferFee
+      }))
+    );
+  });
+}

package/build-deno/contracts/index.ts

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