@pezkuwi/api 16.5.5

package/README.md

@@ -0,0 +1,100 @@
+# @pezkuwi/api
+
+The Pezkuwi-JS API provides easy-to-use wrappers around JSONRPC calls that flow from an application to a node. It handles all the encoding and decoding or parameters, provides access to RPC functions and allows for the query of chain state and the submission of transactions.
+
+The API wrappers provide a standard interface for use -
+
+- A static `.create(<optional ApiOptions>)` that returns an API instance when connected, decorated and ready-to use. ApiOptions can include an optional WsProvider and optional custom type definitions `{ provider: <Optional WsProvider>, types: <Optional RegistryTypes> }`.
+- The above is just a wrapper for `new Api(<optional ApiOptions>) `, exposing the `isReady` getter
+- `api.rpc.<section>.<method>` provides access to actual RPC calls, be it for queries, submission or retrieving chain information
+  - [RPC (node interface)](https://pezkuwi.js.org/docs/substrate/rpc)
+- `api.query.<section>.<method>` provides access to chain state queries. These are dynamically populated based on what the runtime provides
+  - [Storage chain state (runtime node interface)](https://pezkuwi.js.org/docs/substrate/storage)
+- `api.tx.<section>.<method>` provides the ability to create a transaction, like chain state, this list is populated from a runtime query
+  - [Extrinsics (runtime node interface)](https://pezkuwi.js.org/docs/substrate/extrinsics)
+- `api.consts.<section>.<constant>` provides access to the module constants (parameter types).
+  - [Constants (runtime node interface)](https://pezkuwi.js.org/docs/substrate/constants)
+
+## API Selection
+
+There are two flavours of the API provided, one allowing a standard interface via JavaScript Promises and the second provides an Observable wrapper using [RxJS](https://github.com/ReactiveX/rxjs). Depending on your use-case and familiarity, you can choose either (or even both) for your application.
+
+- [[ApiPromise]] All interface calls returns Promises, including the static `.create(...)`. Additionally any subscription method uses `(value) => {}` callbacks, returning the value as the subscription is updated.
+- [[ApiRx]] All interface calls return RxJS Observables, including the static `.create(...)`. In the same fashion subscription-based methods return long-running Observables that update with the latest values.
+
+## Dynamic by default
+
+Substrate (upon which Pezkuwi is built) uses on-chain WASM runtimes, allowing for upgradability. Each runtime defining the actual chain extrinsics (submitted transactions and block intrinsics) as well as available entries in the chain state. Due to this, the API endpoints for queries and transactions are dynamically populated from the running chain.
+
+Due to this dynamic nature, this API departs from traditional APIs which only has fixed endpoints, driving use by what is available by the runtime. As a start, this generic nature has a learning curve, although the provided documentation, examples and linked documentation tries to make that experience as seamless as possible.
+
+## Installation & import
+
+Installation -
+
+```
+npm install --save @pezkuwi/api
+```
+
+Subscribing to blocks via Promise-based API -
+
+```javascript
+import { ApiPromise } from '@pezkuwi/api';
+
+// initialise via static create
+const api = await ApiPromise.create();
+
+// make a call to retrieve the current network head
+api.rpc.chain.subscribeNewHeads((header) => {
+  console.log(`Chain is at #${header.number}`);
+});
+```
+
+Subscribing to blocks via RxJS-based API -
+
+```javascript
+import { ApiRx } from '@pezkuwi/api';
+
+// initialise via static create
+const api = await ApiRx.create().toPromise();
+
+// make a call to retrieve the current network head
+api.rpc.chain.subscribeNewHeads().subscribe((header) => {
+  console.log(`Chain is at #${header.number}`);
+});
+```
+
+## Registering custom types
+
+Additional types used by runtime modules can be added when a new instance of the API is created. This is necessary if the runtime modules use types which are not available in the base Substrate runtime.
+
+```javascript
+import { ApiPromise } from '@pezkuwi/api';
+
+// initialise via static create and register custom types
+const api = await ApiPromise.create({
+  types: {
+    CustomTypesExample: {
+      "id": "u32",
+      "data": "Vec<u8>",
+      "deposit": "Balance",
+      "owner": "AccountId",
+      "application_expiry": "Moment",
+      "whitelisted": "bool",
+      "challenge_id": "u32"
+    }
+  }
+});
+```
+
+## Users
+
+Some of the users of the API (let us know if you are missing from the list), include -
+
+- [Pezkuwi-JS UI](https://github.com/polkadot-js/apps) A user-interface that allows you to make transactions, query the network or participate in actions on the network such as referendums and staking
+- [KodaDot](https://github.com/vue-polkadot/apps) ([twitter](https://twitter.com/KodaDot)) - Vue.js web wallet, governance dashboard and aspiring performance (lightweight) alternative to original apps, mobile-first.
+- [Polkabot](https://gitlab.com/Polkabot) Polkabot is a Matrix chatbot that keeps an eye on the Pezkuwi network. You can see Polkabot in action in https://matrix.to/#/#polkadot-network-status:matrix.org
+- [Polkawallet.io](https://polkawallet.io) and [Polkawallet (Github)](https://github.com/polkawallet-io/polkawallet-RN/) A mobile wallet for the Pezkuwi network to manage funds and make transactions, available on both Androind and iOS
+- [PolkaStats.io](https://polkastats.io), [PolkaStats frontend GitHub repository](https://github.com/Colm3na/polkastats-v2) and [PolkaStats backend GitHub repository](https://github.com/Colm3na/polkastats-backend-v2) Pezkuwi network statistics (currently Kusama and Alexander). Shows network information and staking details from validators and intentions.
+- [Pezkuwi API Server (GitHub)](https://github.com/SimplyVC/polkadot_api_server) A lightweight server for querying Pezkuwi nodes from any language, built primarily as a backend for [PANIC for Pezkuwi (GitHub)](https://github.com/SimplyVC/panic_polkadot/), a validator monitoring and alerting tool.
+- [Identity Registrar #1 from Chevdor on Westend, Kusama and Pezkuwi](https://www.chevdor.com/tags/registrar/)

package/build/augment.d.ts

@@ -0,0 +1 @@
+import '@pezkuwi/api-augment';

package/build/base/Decorate.d.ts

@@ -0,0 +1,143 @@
+import type { Observable } from 'rxjs';
+import type { AugmentedCall, QueryableCalls } from '@pezkuwi/api-base/types';
+import type { RpcInterface } from '@pezkuwi/rpc-core/types';
+import type { Metadata, Text, Vec } from '@pezkuwi/types';
+import type { Hash, RuntimeApiMethodMetadataV16, RuntimeVersion } from '@pezkuwi/types/interfaces';
+import type { DecoratedMeta } from '@pezkuwi/types/metadata/decorate/types';
+import type { AnyFunction, Codec, DefinitionCall, DefinitionCallNamed, DefinitionRpc, DefinitionRpcSub, DefinitionsCall, DefinitionsCallEntry, DetectCodec, Registry, RegistryTypes } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { ApiDecoration, ApiInterfaceRx, ApiOptions, ApiTypes, DecoratedErrors, DecoratedEvents, DecoratedRpc, DecorateMethod, QueryableConsts, QueryableStorage, QueryableStorageMulti, SubmittableExtrinsics } from '../types/index.js';
+import type { AllDerives } from '../util/decorate.js';
+import type { VersionedRegistry } from './types.js';
+import { BehaviorSubject } from 'rxjs';
+import { RpcCore } from '@pezkuwi/rpc-core';
+import { BN } from '@pezkuwi/util';
+import { Events } from './Events.js';
+interface FullDecoration<ApiType extends ApiTypes> {
+    createdAt?: Uint8Array | undefined;
+    decoratedApi: ApiDecoration<ApiType>;
+    decoratedMeta: DecoratedMeta;
+}
+export declare abstract class Decorate<ApiType extends ApiTypes> extends Events {
+    #private;
+    protected __phantom: BN;
+    protected _type: ApiTypes;
+    protected _call: QueryableCalls<ApiType>;
+    protected _consts: QueryableConsts<ApiType>;
+    protected _derive?: ReturnType<Decorate<ApiType>['_decorateDerive']>;
+    protected _errors: DecoratedErrors<ApiType>;
+    protected _events: DecoratedEvents<ApiType>;
+    protected _extrinsics?: SubmittableExtrinsics<ApiType>;
+    protected _extrinsicType: number;
+    protected _genesisHash?: Hash;
+    protected _isConnected: BehaviorSubject<boolean>;
+    protected _isReady: boolean;
+    protected _query: QueryableStorage<ApiType>;
+    protected _queryMulti?: QueryableStorageMulti<ApiType>;
+    protected _rpc?: DecoratedRpc<ApiType, RpcInterface>;
+    protected _rpcCore: RpcCore & RpcInterface;
+    protected _runtimeMap: Record<HexString, string>;
+    protected _runtimeChain?: Text;
+    protected _runtimeMetadata?: Metadata;
+    protected _runtimeVersion?: RuntimeVersion;
+    protected _rx: ApiInterfaceRx;
+    protected readonly _options: ApiOptions;
+    /**
+     * This is the one and only method concrete children classes need to implement.
+     * It's a higher-order function, which takes one argument
+     * `method: Method extends (...args: any[]) => Observable<any>`
+     * (and one optional `options`), and should return the user facing method.
+     * For example:
+     * - For ApiRx, `decorateMethod` should just be identity, because the input
+     * function is already an Observable
+     * - For ApiPromise, `decorateMethod` should return a function that takes all
+     * the parameters from `method`, adds an optional `callback` argument, and
+     * returns a Promise.
+     *
+     * We could easily imagine other user-facing interfaces, which are simply
+     * implemented by transforming the Observable to Stream/Iterator/Kefir/Bacon
+     * via `decorateMethod`.
+     */
+    protected _decorateMethod: DecorateMethod<ApiType>;
+    /**
+     * @description Create an instance of the class
+     *
+     * @param options Options object to create API instance or a Provider instance
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * import Api from '@pezkuwi/api/promise';
+     *
+     * const api = new Api().isReady();
+     *
+     * api.rpc.subscribeNewHeads((header) => {
+     *   console.log(`new block #${header.number.toNumber()}`);
+     * });
+     * ```
+     */
+    constructor(options: ApiOptions, type: ApiTypes, decorateMethod: DecorateMethod<ApiType>);
+    abstract at(blockHash: Uint8Array | string, knownVersion?: RuntimeVersion): Promise<ApiDecoration<ApiType>>;
+    /**
+     * @description Return the current used registry
+     */
+    get registry(): Registry;
+    /**
+     * @description Creates an instance of a type as registered
+     */
+    createType<T extends Codec = Codec, K extends string = string>(type: K, ...params: unknown[]): DetectCodec<T, K>;
+    /**
+     * @description Register additional user-defined of chain-specific types in the type registry
+     */
+    registerTypes(types?: RegistryTypes): void;
+    /**
+     * @returns `true` if the API operates with subscriptions
+     */
+    get hasSubscriptions(): boolean;
+    /**
+     * @returns `true` if the API decorate multi-key queries
+     */
+    get supportMulti(): boolean;
+    protected _emptyDecorated(registry: Registry, blockHash?: Uint8Array): ApiDecoration<ApiType>;
+    protected _createDecorated(registry: VersionedRegistry<ApiType>, fromEmpty: boolean, decoratedApi: ApiDecoration<ApiType> | null, blockHash?: Uint8Array): FullDecoration<ApiType>;
+    protected _injectMetadata(registry: VersionedRegistry<ApiType>, fromEmpty?: boolean): void;
+    /**
+     * @deprecated
+     * backwards compatible endpoint for metadata injection, may be removed in the future (However, it is still useful for testing injection)
+     */
+    injectMetadata(metadata: Metadata, fromEmpty?: boolean, registry?: Registry): void;
+    private _decorateFunctionMeta;
+    protected _filterRpc(methods: string[], additional: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>): void;
+    protected _filterRpcMethods(exposed: string[]): void;
+    private _rpcSubmitter;
+    protected _decorateRpc<ApiType extends ApiTypes>(rpc: RpcCore & RpcInterface, decorateMethod: DecorateMethod<ApiType>, input?: Partial<DecoratedRpc<ApiType, RpcInterface>>): DecoratedRpc<ApiType, RpcInterface>;
+    protected _addRuntimeDef(result: DefinitionsCall, additional?: DefinitionsCall): void;
+    protected _getRuntimeDefs(registry: Registry, specName: Text, chain?: Text | string): [string, DefinitionsCallEntry[]][];
+    protected _getMethods(registry: Registry, methods: Vec<RuntimeApiMethodMetadataV16>): Record<string, DefinitionCall>;
+    protected _getRuntimeDefsViaMetadata(registry: Registry): [string, DefinitionsCallEntry[]][];
+    protected _decorateCalls<ApiType extends ApiTypes>({ registry, runtimeVersion: { apis, specName, specVersion } }: VersionedRegistry<any>, decorateMethod: DecorateMethod<ApiType>, blockHash?: Uint8Array | string | null): QueryableCalls<ApiType>;
+    protected _decorateCall<ApiType extends ApiTypes>(registry: Registry, def: DefinitionCallNamed, stateCall: (method: string, bytes: Uint8Array) => Observable<Codec>, decorateMethod: DecorateMethod<ApiType>): AugmentedCall<ApiType>;
+    protected _decorateMulti<ApiType extends ApiTypes>(decorateMethod: DecorateMethod<ApiType>): QueryableStorageMulti<ApiType>;
+    protected _decorateMultiAt<ApiType extends ApiTypes>(atApi: ApiDecoration<ApiType>, decorateMethod: DecorateMethod<ApiType>, blockHash: Uint8Array | string): QueryableStorageMulti<ApiType>;
+    protected _decorateExtrinsics<ApiType extends ApiTypes>({ tx }: DecoratedMeta, decorateMethod: DecorateMethod<ApiType>): SubmittableExtrinsics<ApiType>;
+    private _decorateExtrinsicEntry;
+    protected _decorateStorage<ApiType extends ApiTypes>({ query, registry }: DecoratedMeta, decorateMethod: DecorateMethod<ApiType>, blockHash?: Uint8Array): QueryableStorage<ApiType>;
+    private _decorateStorageEntry;
+    private _decorateStorageEntryAt;
+    private _queueStorage;
+    private _decorateStorageCall;
+    private _retrieveMulti;
+    private _retrieveMapKeys;
+    private _retrieveMapKeysPaged;
+    private _retrieveMapEntries;
+    private _retrieveMapEntriesPaged;
+    protected _decorateDeriveRx(decorateMethod: DecorateMethod<ApiType>): AllDerives<'rxjs'>;
+    protected _decorateDerive(decorateMethod: DecorateMethod<ApiType>): AllDerives<ApiType>;
+    /**
+     * Put the `this.onCall` function of ApiRx here, because it is needed by
+     * `api._rx`.
+     */
+    protected _rxDecorateMethod: <Method extends AnyFunction>(method: Method) => Method;
+}
+export {};

package/build/base/Events.d.ts

@@ -0,0 +1,67 @@
+import type { ApiInterfaceEvents } from '../types/index.js';
+export declare class Events {
+    #private;
+    protected emit(type: ApiInterfaceEvents, ...args: unknown[]): boolean;
+    /**
+     * @description Attach an eventemitter handler to listen to a specific event
+     *
+     * @param type The type of event to listen to. Available events are `connected`, `disconnected`, `ready` and `error`
+     * @param handler The callback to be called when the event fires. Depending on the event type, it could fire with additional arguments.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * api.on('connected', (): void => {
+     *   console.log('API has been connected to the endpoint');
+     * });
+     *
+     * api.on('disconnected', (): void => {
+     *   console.log('API has been disconnected from the endpoint');
+     * });
+     * ```
+     */
+    on(type: ApiInterfaceEvents, handler: (...args: any[]) => any): this;
+    /**
+     * @description Remove the given eventemitter handler
+     *
+     * @param type The type of event the callback was attached to. Available events are `connected`, `disconnected`, `ready` and `error`
+     * @param handler The callback to unregister.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * const handler = (): void => {
+     *  console.log('Connected !);
+     * };
+     *
+     * // Start listening
+     * api.on('connected', handler);
+     *
+     * // Stop listening
+     * api.off('connected', handler);
+     * ```
+     */
+    off(type: ApiInterfaceEvents, handler: (...args: any[]) => any): this;
+    /**
+     * @description Attach an one-time eventemitter handler to listen to a specific event
+     *
+     * @param type The type of event to listen to. Available events are `connected`, `disconnected`, `ready` and `error`
+     * @param handler The callback to be called when the event fires. Depending on the event type, it could fire with additional arguments.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * api.once('connected', (): void => {
+     *   console.log('API has been connected to the endpoint');
+     * });
+     *
+     * api.once('disconnected', (): void => {
+     *   console.log('API has been disconnected from the endpoint');
+     * });
+     * ```
+     */
+    once(type: ApiInterfaceEvents, handler: (...args: any[]) => any): this;
+}

package/build/base/Getters.d.ts

@@ -0,0 +1,163 @@
+import type { RpcCoreStats, RpcInterface } from '@pezkuwi/rpc-core/types';
+import type { Text } from '@pezkuwi/types';
+import type { Hash, RuntimeVersion } from '@pezkuwi/types/interfaces';
+import type { Metadata } from '@pezkuwi/types/metadata';
+import type { CallFunction, RegistryError } from '@pezkuwi/types/types';
+import type { ApiDecoration, ApiInterfaceRx, ApiTypes, DecoratedErrors, DecoratedEvents, DecoratedRpc, QueryableCalls, QueryableConsts, QueryableStorage, QueryableStorageMulti, SubmittableExtrinsics } from '../types/index.js';
+import { Init } from './Init.js';
+export declare abstract class Getters<ApiType extends ApiTypes> extends Init<ApiType> implements ApiDecoration<ApiType> {
+    /**
+     * @description Runtime call interfaces (currently untyped, only decorated via API options)
+     */
+    get call(): QueryableCalls<ApiType>;
+    /**
+     * @description Contains the parameter types (constants) of all modules.
+     *
+     * The values are instances of the appropriate type and are accessible using `section`.`constantName`,
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * console.log(api.consts.democracy.enactmentPeriod.toString())
+     * ```
+     */
+    get consts(): QueryableConsts<ApiType>;
+    /**
+     * @description Derived results that are injected into the API, allowing for combinations of various query results.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * api.derive.chain.bestNumber((number) => {
+     *   console.log('best number', number);
+     * });
+     * ```
+     */
+    get derive(): ReturnType<Getters<ApiType>['_decorateDerive']>;
+    /**
+     * @description Errors from metadata
+     */
+    get errors(): DecoratedErrors<ApiType>;
+    /**
+     * @description Events from metadata
+     */
+    get events(): DecoratedEvents<ApiType>;
+    /**
+     * @description  Returns the version of extrinsics in-use on this chain
+     */
+    get extrinsicVersion(): number;
+    /**
+     * @description Contains the genesis Hash of the attached chain. Apart from being useful to determine the actual chain, it can also be used to sign immortal transactions.
+     */
+    get genesisHash(): Hash;
+    /**
+     * @description true is the underlying provider is connected
+     */
+    get isConnected(): boolean;
+    /**
+     * @description The library information name & version (from package.json)
+     */
+    get libraryInfo(): string;
+    /**
+     * @description Contains all the chain state modules and their subsequent methods in the API. These are attached dynamically from the runtime metadata.
+     *
+     * All calls inside the namespace, is denoted by `section`.`method` and may take an optional query parameter. As an example, `api.query.timestamp.now()` (current block timestamp) does not take parameters, while `api.query.system.account(<accountId>)` (retrieving the associated nonce & balances for an account), takes the `AccountId` as a parameter.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * api.query.system.account(<accountId>, ([nonce, balance]) => {
+     *   console.log('new free balance', balance.free, 'new nonce', nonce);
+     * });
+     * ```
+     */
+    get query(): QueryableStorage<ApiType>;
+    /**
+     * @description Allows for the querying of multiple storage entries and the combination thereof into a single result. This is a very optimal way to make multiple queries since it only makes a single connection to the node and retrieves the data over one subscription.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * const unsub = await api.queryMulti(
+     *   [
+     *     // you can include the storage without any parameters
+     *     api.query.balances.totalIssuance,
+     *     // or you can pass parameters to the storage query
+     *     [api.query.system.account, '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY']
+     *   ],
+     *   ([existential, [, { free }]]) => {
+     *     console.log(`You have ${free.sub(existential)} more than the existential deposit`);
+     *
+     *     unsub();
+     *   }
+     * );
+     * ```
+     */
+    get queryMulti(): QueryableStorageMulti<ApiType>;
+    /**
+     * @description Contains all the raw rpc sections and their subsequent methods in the API as defined by the jsonrpc interface definitions. Unlike the dynamic `api.query` and `api.tx` sections, these methods are fixed (although extensible with node upgrades) and not determined by the runtime.
+     *
+     * RPC endpoints available here allow for the query of chain, node and system information, in addition to providing interfaces for the raw queries of state (using known keys) and the submission of transactions.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * api.rpc.chain.subscribeNewHeads((header) => {
+     *   console.log('new header', header);
+     * });
+     * ```
+     */
+    get rpc(): DecoratedRpc<ApiType, RpcInterface>;
+    /**
+     * @description Contains the chain information for the current node.
+     */
+    get runtimeChain(): Text;
+    /**
+     * @description Yields the current attached runtime metadata. Generally this is only used to construct extrinsics & storage, but is useful for current runtime inspection.
+     */
+    get runtimeMetadata(): Metadata;
+    /**
+     * @description Contains the version information for the current runtime.
+     */
+    get runtimeVersion(): RuntimeVersion;
+    /**
+     * @description The underlying Rx API interface
+     */
+    get rx(): Pick<ApiInterfaceRx, 'tx' | 'rpc' | 'query' | 'call'>;
+    /**
+     * @description Returns the underlying provider stats
+     */
+    get stats(): RpcCoreStats | undefined;
+    /**
+     * @description The type of this API instance, either 'rxjs' or 'promise'
+     */
+    get type(): ApiTypes;
+    /**
+     * @description Contains all the extrinsic modules and their subsequent methods in the API. It allows for the construction of transactions and the submission thereof. These are attached dynamically from the runtime metadata.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * api.tx.balances
+     *   .transferAllowDeath(<recipientId>, <balance>)
+     *   .signAndSend(<keyPair>, ({status}) => {
+     *     console.log('tx status', status.asFinalized.toHex());
+     *   });
+     * ```
+     */
+    get tx(): SubmittableExtrinsics<ApiType>;
+    /**
+     * @description Finds the definition for a specific [[CallFunction]] based on the index supplied
+     */
+    findCall(callIndex: Uint8Array | string): CallFunction;
+    /**
+     * @description Finds the definition for a specific [[RegistryError]] based on the index supplied
+     */
+    findError(errorIndex: Uint8Array | string): RegistryError;
+}

package/build/base/Init.d.ts

@@ -0,0 +1,44 @@
+import type { RuntimeVersion } from '@pezkuwi/types/interfaces';
+import type { ApiDecoration, ApiOptions, ApiTypes, DecorateMethod } from '../types/index.js';
+import type { VersionedRegistry } from './types.js';
+import { Decorate } from './Decorate.js';
+export declare abstract class Init<ApiType extends ApiTypes> extends Decorate<ApiType> {
+    #private;
+    constructor(options: ApiOptions, type: ApiTypes, decorateMethod: DecorateMethod<ApiType>);
+    /**
+     * @description Decorates a registry based on the runtime version
+     */
+    private _initRegistry;
+    /**
+     * @description Returns the default versioned registry
+     */
+    private _getDefaultRegistry;
+    /**
+     * @description Returns a decorated API instance at a specific point in time
+     */
+    at(blockHash: Uint8Array | string, knownVersion?: RuntimeVersion): Promise<ApiDecoration<ApiType>>;
+    private _createBlockRegistry;
+    private _cacheBlockRegistryProgress;
+    private _getBlockRegistryViaVersion;
+    private _getBlockRegistryViaHash;
+    /**
+     * @description Sets up a registry based on the block hash defined
+     */
+    getBlockRegistry(blockHash: Uint8Array, knownVersion?: RuntimeVersion): Promise<VersionedRegistry<ApiType>>;
+    protected _loadMeta(): Promise<boolean>;
+    private _metaFromSource;
+    private _subscribeUpdates;
+    private _metaFromChain;
+    private _initFromMeta;
+    /**
+     * @internal
+     *
+     * Tries to use runtime api calls to retrieve metadata. This ensures the api initializes with the latest metadata.
+     * If the runtime call is not there it will use the rpc method.
+     */
+    private _retrieveMetadata;
+    private _subscribeHealth;
+    private _unsubscribeHealth;
+    private _unsubscribeUpdates;
+    protected _unsubscribe(): void;
+}

package/build/base/find.d.ts

@@ -0,0 +1,3 @@
+import type { CallFunction, Registry, RegistryError } from '@pezkuwi/types/types';
+export declare function findCall(registry: Registry, callIndex: Uint8Array | string): CallFunction;
+export declare function findError(registry: Registry, errorIndex: Uint8Array | string): RegistryError;

package/build/base/index.d.ts

@@ -0,0 +1,47 @@
+import type { SignerPayloadRawBase } from '@pezkuwi/types/types';
+import type { ApiOptions, ApiTypes, DecorateMethod, Signer } from '../types/index.js';
+import { Getters } from './Getters.js';
+interface KeyringSigner {
+    sign(message: Uint8Array): Uint8Array;
+}
+interface SignerRawOptions {
+    signer?: Signer;
+}
+export declare abstract class ApiBase<ApiType extends ApiTypes> extends Getters<ApiType> {
+    /**
+     * @description Create an instance of the class
+     *
+     * @param options Options object to create API instance or a Provider instance
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * import Api from '@pezkuwi/api/promise';
+     *
+     * const api = new Api().isReady();
+     *
+     * api.rpc.subscribeNewHeads((header) => {
+     *   console.log(`new block #${header.number.toNumber()}`);
+     * });
+     * ```
+     */
+    constructor(options: ApiOptions, type: ApiTypes, decorateMethod: DecorateMethod<ApiType>);
+    /**
+     * @description Connect from the underlying provider, halting all network traffic
+     */
+    connect(): Promise<void>;
+    /**
+     * @description Disconnect from the underlying provider, halting all network traffic
+     */
+    disconnect(): Promise<void>;
+    /**
+     * @description Set an external signer which will be used to sign extrinsic when account passed in is not KeyringPair
+     */
+    setSigner(signer: Signer | undefined): void;
+    /**
+     * @description Signs a raw signer payload, string or Uint8Array
+     */
+    sign(address: KeyringSigner | string, data: SignerPayloadRawBase, { signer }?: SignerRawOptions): Promise<string>;
+}
+export {};

package/build/base/types.d.ts

@@ -0,0 +1,15 @@
+import type { Metadata } from '@pezkuwi/types';
+import type { RuntimeVersionPartial } from '@pezkuwi/types/interfaces';
+import type { DecoratedMeta } from '@pezkuwi/types/metadata/decorate/types';
+import type { Registry } from '@pezkuwi/types/types';
+import type { ApiDecoration, ApiTypes } from '../types/index.js';
+export interface VersionedRegistry<ApiType extends ApiTypes> {
+    counter: number;
+    decoratedApi?: ApiDecoration<ApiType>;
+    decoratedMeta?: DecoratedMeta;
+    isDefault?: boolean;
+    lastBlockHash?: Uint8Array | null;
+    metadata: Metadata;
+    registry: Registry;
+    runtimeVersion: RuntimeVersionPartial;
+}

package/build/bundle.d.ts

@@ -0,0 +1,7 @@
+import '@pezkuwi/rpc-augment';
+export { Keyring } from '@pezkuwi/keyring';
+export { HttpProvider, ScProvider, WsProvider } from '@pezkuwi/rpc-provider';
+export { packageInfo } from './packageInfo.js';
+export { SubmittableResult } from './submittable/index.js';
+export * from './promise/index.js';
+export * from './rx/index.js';

package/build/index.d.ts

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/build/packageDetect.d.ts

@@ -0,0 +1 @@
+export {};

package/build/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};