@pezkuwi/api 16.5.11 → 16.5.13

package/build-deno/types/index.ts

@@ -0,0 +1,124 @@
+
+import type { ApiTypes, DeriveCustom, QueryableStorageMulti } from 'https://deno.land/x/pezkuwi/api-base/types/index.ts';
+import type { ApiInterfaceRx as ApiInterfaceBase } from 'https://deno.land/x/pezkuwi/api-base/types/api.ts';
+import type { QueryableCalls } from 'https://deno.land/x/pezkuwi/api-base/types/calls.ts';
+import type { QueryableConsts } from 'https://deno.land/x/pezkuwi/api-base/types/consts.ts';
+import type { DecoratedErrors } from 'https://deno.land/x/pezkuwi/api-base/types/errors.ts';
+import type { DecoratedEvents } from 'https://deno.land/x/pezkuwi/api-base/types/events.ts';
+import type { QueryableStorage } from 'https://deno.land/x/pezkuwi/api-base/types/storage.ts';
+import type { ProviderInterface, ProviderInterfaceEmitted } from 'https://deno.land/x/pezkuwi/rpc-provider/types.ts';
+import type { ExtDef } from 'https://deno.land/x/pezkuwi/types/extrinsic/signedExtensions/types.ts';
+import type { Call, Extrinsic, Hash, RuntimeVersionPartial } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { CallFunction, DefinitionRpc, DefinitionRpcSub, DefinitionsCall, RegisteredTypes, Registry, RegistryError, SignatureOptions, Signer } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
+import type { ApiBase } from '../base/index.ts';
+import type { SubmittableExtrinsic } from '../types/submittable.ts';
+import type { AllDerives } from '../util/decorate.ts';
+
+export type { Signer, SignerResult } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+
+export { ApiBase } from '../base/index.ts';
+
+export * from 'https://deno.land/x/pezkuwi/api/types/calls.ts';
+export * from 'https://deno.land/x/pezkuwi/api/types/consts.ts';
+export * from 'https://deno.land/x/pezkuwi/api/types/errors.ts';
+export * from 'https://deno.land/x/pezkuwi/api/types/events.ts';
+export * from 'https://deno.land/x/pezkuwi/api/types/storage.ts';
+export * from 'https://deno.land/x/pezkuwi/api/types/submittable.ts';
+export * from 'https://deno.land/x/pezkuwi/api-base/types/index.ts';
+
+export interface ApiInterfaceRx extends ApiInterfaceBase {
+  derive: AllDerives<'rxjs'>;
+}
+
+export interface ApiOptions extends RegisteredTypes {
+  /**
+   * @description Add custom derives to be injected
+   */
+  derives?: DeriveCustom;
+  /**
+   * @description Control the initialization of the wasm libraries. When not specified, it defaults to `true`, initializing the wasm libraries, set to `false` to not initialize wasm. (No sr25519 support)
+   */
+  initWasm?: boolean;
+  /**
+   * @description Controls the checking of storage values once they have been contructed. When not specified this defaults to `true`. Set to `false` to forgo any checking on storage results.
+   */
+  isPedantic?: boolean;
+  /**
+   * @description pre-bundles is a map of 'genesis hash and runtime spec version' as key to a metadata hex string
+   * if genesis hash and runtime spec version matches, then use metadata, else fetch it from chain
+   */
+  metadata?: Record<string, HexString>;
+  /**
+   * @description Don't display any warnings on initialization (missing RPC methods & runtime calls)
+   */
+  noInitWarn?: boolean;
+  /**
+   * @description Transport Provider from rpc-provider. If not specified, it will default to
+   * connecting to a WsProvider connecting localhost with the default port, i.e. `ws://127.0.0.1:9944`
+   */
+  provider?: ProviderInterface;
+  /**
+   * @description A type registry to use along with this instance
+   */
+  registry?: Registry;
+  /**
+   * @description User-defined RPC methods
+   */
+  rpc?: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>;
+  /**
+   * @description Defines the size of the cache for the rpc-core. Defaults to 1024 * 10 * 10.
+   */
+  rpcCacheCapacity?: number;
+  /**
+   * @description Overrides for state_call usage (this will be removed in some future version)
+   */
+  runtime?: DefinitionsCall;
+  /**
+   * @description Any chain-specific signed extensions that are now well-known
+   */
+  signedExtensions?: ExtDef;
+  /**
+   * @description An external signer which will be used to sign extrinsic when account passed in is not KeyringPair
+   */
+  signer?: Signer;
+  /**
+   * @description The source object to use for runtime information (only used when cloning)
+   */
+  source?: ApiBase<any>;
+  /**
+   * @description Throws an error when the initial connection fails (same as isReadyOrError)
+   */
+  throwOnConnect?: boolean;
+  /**
+   * @description Throws an error when some types are unknown (useful with throwOnConnect)
+   */
+  throwOnUnknown?: boolean;
+}
+
+export type ApiInterfaceEvents = ProviderInterfaceEmitted | 'ready' | 'decorated';
+
+export interface SignerOptions extends SignatureOptions {
+  blockNumber: BN;
+  genesisHash: Hash;
+}
+
+export interface ApiDecoration<ApiType extends ApiTypes> {
+  call: QueryableCalls<ApiType>;
+  consts: QueryableConsts<ApiType>;
+  errors: DecoratedErrors<ApiType>;
+  events: DecoratedEvents<ApiType>;
+  query: QueryableStorage<ApiType>;
+  registry: Registry;
+  runtimeVersion: RuntimeVersionPartial;
+  rx: {
+    call: QueryableCalls<'rxjs'>;
+    query: QueryableStorage<'rxjs'>;
+  };
+  tx: (extrinsic: Call | Extrinsic | Uint8Array | string) => SubmittableExtrinsic<ApiType>;
+
+  findCall (callIndex: Uint8Array | string): CallFunction;
+  findError (errorIndex: Uint8Array | string): RegistryError;
+  queryMulti: QueryableStorageMulti<ApiType>;
+}

package/build-deno/types/storage.ts

@@ -0,0 +1,2 @@
+
+export * from 'https://deno.land/x/pezkuwi/api-base/types/storage.ts';

package/build-deno/types/submittable.ts

@@ -0,0 +1,2 @@
+
+export * from 'https://deno.land/x/pezkuwi/api-base/types/submittable.ts';

package/build-deno/util/augmentObject.ts

@@ -0,0 +1,109 @@
+
+import { lazyMethods, logger, objectClear } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+type Sections <T> = Record<string, Methods<T>>;
+
+type Methods <T> = Record<string, T>;
+
+type StringsStrings = [string[], string[]];
+
+const l = logger('api/augment');
+
+function logLength (type: 'added' | 'removed', values: string[], and: string[] = []): string {
+  return values.length
+    ? ` ${values.length} ${type}${and.length ? ' and' : ''}`
+    : '';
+}
+
+function logValues (type: 'added' | 'removed', values: string[]): string {
+  return values.length
+    ? `\n\t${type.padStart(7)}: ${values.sort().join(', ')}`
+    : '';
+}
+
+function warn (prefix: string, type: 'calls' | 'modules', [added, removed]: StringsStrings): void {
+  if (added.length || removed.length) {
+    l.warn(`api.${prefix}: Found${logLength('added', added, removed)}${logLength('removed', removed)} ${type}:${logValues('added', added)}${logValues('removed', removed)}`);
+  }
+}
+
+function findSectionExcludes (a: string[], b: string[]): string[] {
+  return a.filter((s) => !b.includes(s));
+}
+
+function findSectionIncludes (a: string[], b: string[]): string[] {
+  return a.filter((s) => b.includes(s));
+}
+
+function extractSections <T> (src: Sections<T>, dst: Sections<T>): StringsStrings {
+  const srcSections = Object.keys(src);
+  const dstSections = Object.keys(dst);
+
+  return [
+    findSectionExcludes(srcSections, dstSections),
+    findSectionExcludes(dstSections, srcSections)
+  ];
+}
+
+function findMethodExcludes <T> (src: Sections<T>, dst: Sections<T>): string[] {
+  const srcSections = Object.keys(src);
+  const dstSections = findSectionIncludes(Object.keys(dst), srcSections);
+  const excludes: string[] = [];
+
+  for (let s = 0, scount = dstSections.length; s < scount; s++) {
+    const section = dstSections[s];
+    const srcMethods = Object.keys(src[section]);
+    const dstMethods = Object.keys(dst[section]);
+
+    for (let d = 0, mcount = dstMethods.length; d < mcount; d++) {
+      const method = dstMethods[d];
+
+      if (!srcMethods.includes(method)) {
+        excludes.push(`${section}.${method}`);
+      }
+    }
+  }
+
+  return excludes;
+}
+
+function extractMethods <T> (src: Sections<T>, dst: Sections<T>): StringsStrings {
+  return [
+    findMethodExcludes(dst, src),
+    findMethodExcludes(src, dst)
+  ];
+}
+
+/**
+ * @description Takes a decorated api section (e.g. api.tx) and augment it with the details. It does not override what is
+ * already available, but rather just adds new missing items into the result object.
+ * @internal
+ */
+export function augmentObject <T> (prefix: string | null, src: Sections<T>, dst: Sections<T>, fromEmpty = false): Sections<T> {
+  fromEmpty && objectClear(dst);
+
+  // NOTE: This part is slightly problematic since it will get the
+  // values for at least all the sections and the names of the methods
+  // (Since methods won't be decorated before lazy, this _may_ be ok)
+  if (prefix && Object.keys(dst).length) {
+    warn(prefix, 'modules', extractSections(src, dst));
+    warn(prefix, 'calls', extractMethods(src, dst));
+  }
+
+  const sections = Object.keys(src);
+
+  for (let i = 0, count = sections.length; i < count; i++) {
+    const section = sections[i];
+    const methods = src[section];
+
+    // We don't set here with a lazy interface, we decorate based
+    // on the top-level structure (this bypasses adding lazy onto lazy)
+    if (!dst[section]) {
+      dst[section] = {};
+    }
+
+    lazyMethods(dst[section], Object.keys(methods), (m: string) => methods[m]);
+  }
+
+  return dst;
+}

package/build-deno/util/decorate.ts

@@ -0,0 +1,38 @@
+
+import type { ExactDerive } from 'https://deno.land/x/pezkuwi/api-derive/mod.ts';
+import type { AnyFunction } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { ApiTypes, DecorateMethod, MethodResult } from '../types/index.ts';
+
+import { lazyDeriveSection } from 'https://deno.land/x/pezkuwi/api-derive/mod.ts';
+
+type AnyDeriveSection = Record<string, AnyFunction>;
+
+type AnyDerive = Record<string, AnyDeriveSection>;
+
+type DeriveSection<ApiType extends ApiTypes, Section extends AnyDeriveSection> = {
+  [M in keyof Section]: MethodResult<ApiType, Section[M]>
+};
+
+export type AllDerives<ApiType extends ApiTypes> = {
+  [S in keyof ExactDerive]: DeriveSection<ApiType, ExactDerive[S]>
+};
+
+/**
+ * This is a section decorator which keeps all type information.
+ */
+export function decorateDeriveSections<ApiType extends ApiTypes> (decorateMethod: DecorateMethod<ApiType>, derives: AnyDerive): AllDerives<ApiType> {
+  const getKeys = (s: string) =>
+    Object.keys(derives[s]);
+
+  const creator = (s: string, m: string) =>
+    decorateMethod(derives[s][m]) as AnyFunction;
+
+  const result: AnyDerive = {};
+  const names = Object.keys(derives);
+
+  for (let i = 0, count = names.length; i < count; i++) {
+    lazyDeriveSection(result, names[i], getKeys, creator);
+  }
+
+  return result as AllDerives<ApiType>;
+}

package/build-deno/util/filterEvents.ts

@@ -0,0 +1,32 @@
+
+import type { BlockNumber, EventRecord, ExtrinsicStatus, H256, SignedBlock } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+
+import { isCompact } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { l } from './logging.ts';
+
+export function filterEvents (txHash: H256, { block: { extrinsics, header } }: SignedBlock, allEvents: EventRecord[], status: ExtrinsicStatus): { events?: EventRecord[], txIndex?: number, blockNumber?: BlockNumber } {
+  // extrinsics to hashes
+  for (const [txIndex, x] of extrinsics.entries()) {
+    if (x.hash.eq(txHash)) {
+      return {
+        blockNumber: isCompact<BlockNumber>(header.number) ? header.number.unwrap() : header.number,
+        events: allEvents.filter(({ phase }) =>
+          phase.isApplyExtrinsic &&
+          phase.asApplyExtrinsic.eqn(txIndex)
+        ),
+        txIndex
+      };
+    }
+  }
+
+  // if we do get the block after finalized, it _should_ be there
+  // only warn on filtering with isInBlock (finalization finalizes after)
+  if (status.isInBlock) {
+    const allHashes = extrinsics.map((x) => x.hash.toHex());
+
+    l.warn(`block ${header.hash.toHex()}: Unable to find extrinsic ${txHash.toHex()} inside ${allHashes.join(', ')}`);
+  }
+
+  return {};
+}

package/build-deno/util/index.ts

@@ -0,0 +1,6 @@
+
+export { filterEvents } from './filterEvents.ts';
+export { isKeyringPair } from './isKeyringPair.ts';
+export { l } from './logging.ts';
+
+export * from './decorate.ts';

package/build-deno/util/isKeyringPair.ts

@@ -0,0 +1,9 @@
+
+import type { AccountId, Address } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { IKeyringPair } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+
+import { isFunction } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+export function isKeyringPair (account: string | IKeyringPair | AccountId | Address): account is IKeyringPair {
+  return isFunction((account as IKeyringPair).sign);
+}

package/build-deno/util/logging.ts

@@ -0,0 +1,4 @@
+
+import { logger } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+export const l = /*#__PURE__*/ logger('api/util');

package/build-deno/util/validate.ts

@@ -0,0 +1,32 @@
+
+import type { SiLookupTypeId } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { StorageEntry } from 'https://deno.land/x/pezkuwi/types/primitive/types.ts';
+import type { Registry } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+
+import { isUndefined } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+function sig ({ lookup }: Registry, { method, section }: StorageEntry, args: SiLookupTypeId[]): string {
+  return `${section}.${method}(${args.map((a) => lookup.getTypeDef(a).type).join(', ')})`;
+}
+
+export function extractStorageArgs (registry: Registry, creator: StorageEntry, _args: unknown[]): [StorageEntry, unknown[]] {
+  const args = _args.filter((a) => !isUndefined(a));
+
+  if (creator.meta.type.isPlain) {
+    if (args.length !== 0) {
+      throw new Error(`${sig(registry, creator, [])} does not take any arguments, ${args.length} found`);
+    }
+  } else {
+    const { hashers, key } = creator.meta.type.asMap;
+    const keys = hashers.length === 1
+      ? [key]
+      : registry.lookup.getSiType(key).def.asTuple.map((t) => t);
+
+    if (args.length !== keys.length) {
+      throw new Error(`${sig(registry, creator, keys)} is a map, requiring ${keys.length} arguments, ${args.length} found`);
+    }
+  }
+
+  // pass as tuple
+  return [creator, args];
+}

package/build-tsc-cjs/packageDetect.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const packageInfo_1 = require("@pezkuwi/api-derive/packageInfo");
+const packageInfo_2 = require("@pezkuwi/rpc-core/packageInfo");
+const packageInfo_3 = require("@pezkuwi/rpc-provider/packageInfo");
+const packageInfo_4 = require("@pezkuwi/types/packageInfo");
+const packageInfo_5 = require("@pezkuwi/types-known/packageInfo");
+const util_1 = require("@pezkuwi/util");
+const packageInfo_js_1 = require("./packageInfo.js");
+(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, [packageInfo_2.packageInfo, packageInfo_1.packageInfo, packageInfo_5.packageInfo, packageInfo_3.packageInfo, packageInfo_4.packageInfo]);

package/{cjs → build-tsc-cjs}/packageInfo.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.packageInfo = void 0;
-exports.packageInfo = { name: '@pezkuwi/api', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '16.5.11' };
+exports.packageInfo = { name: '@pezkuwi/api', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '16.5.13' };

package/{packageInfo.js → build-tsc-esm/packageInfo.js}

@@ -1 +1 @@
-export const packageInfo = { name: '@pezkuwi/api', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '16.5.11' };
+export const packageInfo = { name: '@pezkuwi/api', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '16.5.13' };

package/package.json

@@ -18,13 +18,11 @@
     "./cjs/packageDetect.js"
   ],
   "type": "module",
-  "version": "16.5.11",
+  "types": "./index.d.ts",
+  "version": "16.5.13",
   "main": "./cjs/index.js",
-  "module": "./cjs/index.js",
-  "types": "./cjs/index.d.ts",
+  "module": "./index.js",
   "exports": {
-    "./cjs/package.json": "./cjs/package.json",
-    "./cjs/*": "./cjs/*.js",
     ".": {
       "module": {
         "types": "./index.d.ts",
@@ -165,6 +163,8 @@
         "default": "./bundle.js"
       }
     },
+    "./cjs/*": "./cjs/*.js",
+    "./cjs/package.json": "./cjs/package.json",
     "./package.json": {
       "require": "./cjs/package.json",
       "default": "./package.json"
@@ -183,7 +183,7 @@
         "default": "./packageDetect.js"
       }
     },
-    "./packageInfo.js": {
+    "./packageInfo": {
       "module": {
         "types": "./packageInfo.d.ts",
         "default": "./packageInfo.js"
@@ -197,7 +197,7 @@
         "default": "./packageInfo.js"
       }
     },
-    "./packageInfo": {
+    "./packageInfo.js": {
       "module": {
         "types": "./packageInfo.d.ts",
         "default": "./packageInfo.js"

package/src/augment.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2025 @pezkuwi/api authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import '@pezkuwi/api-augment';