@pezkuwi/api 16.5.5 → 16.5.8

package/build-tsc/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-tsc/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-tsc/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-tsc/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 | undefined, 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-tsc/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-tsc/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-tsc/index.d.ts

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

package/build-tsc/packageDetect.d.ts

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

package/build-tsc/packageInfo.d.ts

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

package/build-tsc/promise/Api.d.ts

@@ -0,0 +1,158 @@
+import type { ApiOptions, UnsubscribePromise } from '../types/index.js';
+import type { CombinatorCallback, CombinatorFunction } from './Combinator.js';
+import { ApiBase } from '../base/index.js';
+/**
+ * # @pezkuwi/api/promise
+ *
+ * ## Overview
+ *
+ * @name ApiPromise
+ * @description
+ * ApiPromise is a standard JavaScript wrapper around the RPC and interfaces on the Pezkuwi network. As a full Promise-based, all interface calls return Promises, including the static `.create(...)`. Subscription calls utilise `(value) => {}` callbacks to pass through the latest values.
+ *
+ * The API is well suited to real-time applications where either the single-shot state is needed or use is to be made of the subscription-based features of Pezkuwi (and Bizinikiwi) clients.
+ *
+ * @see [[ApiRx]]
+ *
+ * ## Usage
+ *
+ * Making rpc calls -
+ * <BR>
+ *
+ * ```javascript
+ * import ApiPromise from '@pezkuwi/api/promise';
+ *
+ * // initialise via static create
+ * const api = await ApiPromise.create();
+ *
+ * // make a subscription to the network head
+ * api.rpc.chain.subscribeNewHeads((header) => {
+ *   console.log(`Chain is at #${header.number}`);
+ * });
+ * ```
+ * <BR>
+ *
+ * Subscribing to chain state -
+ * <BR>
+ *
+ * ```javascript
+ * import { ApiPromise, WsProvider } from '@pezkuwi/api';
+ *
+ * // initialise a provider with a specific endpoint
+ * const provider = new WsProvider('wss://example.com:9944')
+ *
+ * // initialise via isReady & new with specific provider
+ * const api = await new ApiPromise({ provider }).isReady;
+ *
+ * // retrieve the block target time
+ * const blockPeriod = await api.query.timestamp.blockPeriod().toNumber();
+ * let last = 0;
+ *
+ * // subscribe to the current block timestamp, updates automatically (callback provided)
+ * api.query.timestamp.now((timestamp) => {
+ *   const elapsed = last
+ *     ? `, ${timestamp.toNumber() - last}s since last`
+ *     : '';
+ *
+ *   last = timestamp.toNumber();
+ *   console.log(`timestamp ${timestamp}${elapsed} (${blockPeriod}s target)`);
+ * });
+ * ```
+ * <BR>
+ *
+ * Submitting a transaction -
+ * <BR>
+ *
+ * ```javascript
+ * import ApiPromise from '@pezkuwi/api/promise';
+ *
+ * ApiPromise.create().then((api) => {
+ *   const [nonce] = await api.query.system.account(keyring.alice.address);
+ *
+ *   api.tx.balances
+ *     // create transfer
+ *     transfer(keyring.bob.address, 12345)
+ *     // sign the transcation
+ *     .sign(keyring.alice, { nonce })
+ *     // send the transaction (optional status callback)
+ *     .send((status) => {
+ *       console.log(`current status ${status.type}`);
+ *     })
+ *     // retrieve the submitted extrinsic hash
+ *     .then((hash) => {
+ *       console.log(`submitted with hash ${hash}`);
+ *     });
+ * });
+ * ```
+ */
+export declare class ApiPromise extends ApiBase<'promise'> {
+    #private;
+    /**
+     * @description Creates an instance of the ApiPromise class
+     * @param options Options to create an instance. This can be either [[ApiOptions]] or
+     * an [[WsProvider]].
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * import Api from '@pezkuwi/api/promise';
+     *
+     * new Api().isReady.then((api) => {
+     *   api.rpc.subscribeNewHeads((header) => {
+     *     console.log(`new block #${header.number.toNumber()}`);
+     *   });
+     * });
+     * ```
+     */
+    constructor(options?: ApiOptions);
+    /**
+     * @description Creates an ApiPromise instance using the supplied provider. Returns an Promise containing the actual Api instance.
+     * @param options options that is passed to the class contructor. Can be either [[ApiOptions]] or a
+     * provider (see the constructor arguments)
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * import Api from '@pezkuwi/api/promise';
+     *
+     * Api.create().then(async (api) => {
+     *   const timestamp = await api.query.timestamp.now();
+     *
+     *   console.log(`lastest block timestamp ${timestamp}`);
+     * });
+     * ```
+     */
+    static create(options?: ApiOptions): Promise<ApiPromise>;
+    /**
+     * @description Promise that resolves the first time we are connected and loaded
+     */
+    get isReady(): Promise<ApiPromise>;
+    /**
+     * @description Promise that resolves if we can connect, or reject if there is an error
+     */
+    get isReadyOrError(): Promise<ApiPromise>;
+    /**
+     * @description Returns a clone of this ApiPromise instance (new underlying provider connection)
+     */
+    clone(): ApiPromise;
+    /**
+     * @description Creates a combinator that can be used to combine the latest results from multiple subscriptions
+     * @param fns An array of function to combine, each in the form of `(cb: (value: void)) => void`
+     * @param callback A callback that will return an Array of all the values this combinator has been applied to
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * const address = '5DTestUPts3kjeXSTMyerHihn1uwMfLj8vU8sqF7qYrFacT7';
+     *
+     * // combines values from balance & nonce as it updates
+     * api.combineLatest([
+     *   api.rpc.chain.subscribeNewHeads,
+     *   (cb) => api.query.system.account(address, cb)
+     * ], ([head, [balance, nonce]]) => {
+     *   console.log(`#${head.number}: You have ${balance.free} units, with ${nonce} transactions sent`);
+     * });
+     * ```
+     */
+    combineLatest<T extends any[] = any[]>(fns: (CombinatorFunction | [CombinatorFunction, ...any[]])[], callback: CombinatorCallback<T>): UnsubscribePromise;
+}

package/build-tsc/promise/Combinator.d.ts

@@ -0,0 +1,12 @@
+import type { Callback } from '@pezkuwi/types/types';
+import type { UnsubscribePromise } from '../types/index.js';
+export type CombinatorCallback<T extends unknown[]> = Callback<T>;
+export type CombinatorFunction = (cb: Callback<any>) => UnsubscribePromise;
+export declare class Combinator<T extends unknown[] = unknown[]> {
+    #private;
+    constructor(fns: (CombinatorFunction | [CombinatorFunction, ...unknown[]])[], callback: CombinatorCallback<T>);
+    protected _allHasFired(): boolean;
+    protected _createCallback(index: number): (value: any) => void;
+    protected _triggerUpdate(): void;
+    unsubscribe(): void;
+}

package/build-tsc/promise/decorateMethod.d.ts

@@ -0,0 +1,14 @@
+import type { Observable } from 'rxjs';
+import type { Codec } from '@pezkuwi/types/types';
+import type { DecorateFn, DecorateMethodOptions, ObsInnerType, StorageEntryPromiseOverloads } from '../types/index.js';
+interface Tracker<T> {
+    reject: (value: Error) => Observable<never>;
+    resolve: (value: T) => void;
+}
+type CodecReturnType<T extends (...args: unknown[]) => Observable<Codec>> = T extends (...args: any) => infer R ? R extends Observable<Codec> ? ObsInnerType<R> : never : never;
+export declare function promiseTracker<T>(resolve: (value: T) => void, reject: (value: Error) => void): Tracker<T>;
+/**
+ * @description Decorate method for ApiPromise, where the results are converted to the Promise equivalent
+ */
+export declare function toPromiseMethod<M extends DecorateFn<CodecReturnType<M>>>(method: M, options?: DecorateMethodOptions): StorageEntryPromiseOverloads;
+export {};

package/build-tsc/promise/index.d.ts

@@ -0,0 +1,2 @@
+export { ApiPromise } from './Api.js';
+export { toPromiseMethod } from './decorateMethod.js';

package/build-tsc/promise/types.d.ts

@@ -0,0 +1,5 @@
+import type { SubmittableExtrinsic as SubmittableExtrinsicBase } from '../submittable/types.js';
+import type { QueryableStorageEntry as QueryableStorageEntryBase, SubmittableExtrinsicFunction as SubmittableExtrinsicFunctionBase } from '../types/index.js';
+export type QueryableStorageEntry = QueryableStorageEntryBase<'promise'>;
+export type SubmittableExtrinsic = SubmittableExtrinsicBase<'promise'>;
+export type SubmittableExtrinsicFunction = SubmittableExtrinsicFunctionBase<'promise'>;

package/build-tsc/rx/Api.d.ts

@@ -0,0 +1,155 @@
+import type { Observable } from 'rxjs';
+import type { ApiOptions } from '../types/index.js';
+import { ApiBase } from '../base/index.js';
+/**
+ * # @pezkuwi/api/rx
+ *
+ * ## Overview
+ *
+ * @name ApiRx
+ *
+ * @description
+ * ApiRx is a powerful RxJS Observable wrapper around the RPC and interfaces on the Pezkuwi network. As a full Observable API, all interface calls return RxJS Observables, including the static `.create(...)`. In the same fashion and subscription-based methods return long-running Observables that update with the latest values.
+ *
+ * The API is well suited to real-time applications where the latest state is needed, unlocking the subscription-based features of Pezkuwi (and Bizinikiwi) clients. Some familiarity with RxJS is a requirement to use the API, however just understanding `.subscribe` and `.pipe` on Observables will unlock full-scale use thereof.
+ *
+ * @see [[ApiPromise]]
+ *
+ * ## Usage
+ *
+ * Making rpc calls -
+ * <BR>
+ *
+ * ```javascript
+ * import ApiRx from '@pezkuwi/api/rx';
+ *
+ * // initialize via Promise & 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}`);
+ * });
+ * ```
+ * <BR>
+ *
+ * Subscribing to chain state -
+ * <BR>
+ *
+ * ```javascript
+ * import { combineLatest, pairwise, switchMap } from 'rxjs';
+ * import { ApiRx, WsProvider } from '@pezkuwi/api';
+ *
+ *
+ * // initialize a provider with a specific endpoint
+ * const provider = new WsProvider('wss://example.com:9944')
+ *
+ * // initialize via isReady & new with specific provider
+ * new ApiRx({ provider })
+ *   .isReady
+ *   .pipe(
+ *     switchMap((api) =>
+ *       combineLatest([
+ *         api.query.timestamp.blockPeriod(),
+ *         api.query.timestamp.now().pipe(pairwise())
+ *       ])
+ *     )
+ *   )
+ *   .subscribe(([blockPeriod, timestamp]) => {
+ *      const elapsed = timestamp[1].toNumber() - timestamp[0].toNumber();
+ *      console.log(`timestamp ${timestamp[1]} \nelapsed ${elapsed} \n(${blockPeriod}s target)`);
+ *   });
+ * ```
+ * <BR>
+ *
+ * Submitting a transaction -
+ * <BR>
+ *
+ * ```javascript
+ * import { first, switchMap } from 'rxjs';
+ * import ApiRx from '@pezkuwi/api/rx';
+ *
+ * // import the test keyring (already has dev keys for Alice, Bob, Charlie, Eve & Ferdie)
+ * import testingPairs from '@pezkuwi/keyring/testingPairs';
+ * const keyring = testingPairs();
+ *
+ * // get api via Promise
+ * const api = await ApiRx.create().toPromise();
+ *
+ * // retrieve nonce for the account
+ * api.query.system
+ *   .account(keyring.alice.address)
+ *   .pipe(
+ *      first(),
+ *      // pipe nonce into transfer
+ *      switchMap(([nonce]) =>
+ *        api.tx.balances
+ *          // create transfer
+ *          .transferAllowDeath(keyring.bob.address, 12345)
+ *          // sign the transaction
+ *          .sign(keyring.alice, { nonce })
+ *          // send the transaction
+ *          .send()
+ *      )
+ *   )
+ *   // subscribe to overall result
+ *   .subscribe(({ status }) => {
+ *     if (status.isInBlock) {
+ *       console.log('Completed at block hash', status.asFinalized.toHex());
+ *     }
+ *   });
+ * ```
+ */
+export declare class ApiRx extends ApiBase<'rxjs'> {
+    #private;
+    /**
+     * @description Create an instance of the ApiRx class
+     * @param options Options to create an instance. Can be either [[ApiOptions]] or [[WsProvider]]
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * import { switchMap } from 'rxjs';
+     * import Api from '@pezkuwi/api/rx';
+     *
+     * new Api().isReady
+     *   .pipe(
+     *     switchMap((api) =>
+     *       api.rpc.chain.subscribeNewHeads()
+     *   ))
+     *   .subscribe((header) => {
+     *     console.log(`new block #${header.number.toNumber()}`);
+     *   });
+     * ```
+     */
+    constructor(options?: ApiOptions);
+    /**
+     * @description Creates an ApiRx instance using the supplied provider. Returns an Observable containing the actual Api instance.
+     * @param options options that is passed to the class constructor. Can be either [[ApiOptions]] or [[WsProvider]]
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * import { switchMap } from 'rxjs';
+     * import Api from '@pezkuwi/api/rx';
+     *
+     * Api.create()
+     *   .pipe(
+     *     switchMap((api) =>
+     *       api.rpc.chain.subscribeNewHeads()
+     *   ))
+     *   .subscribe((header) => {
+     *     console.log(`new block #${header.number.toNumber()}`);
+     *   });
+     * ```
+     */
+    static create(options?: ApiOptions): Observable<ApiRx>;
+    /**
+     * @description Observable that returns the first time we are connected and loaded
+     */
+    get isReady(): Observable<ApiRx>;
+    /**
+     * @description Returns a clone of this ApiRx instance (new underlying provider connection)
+     */
+    clone(): ApiRx;
+}

package/build-tsc/rx/decorateMethod.d.ts

@@ -0,0 +1,3 @@
+import type { Codec } from '@pezkuwi/types/types';
+import type { DecorateFn } from '../types/index.js';
+export declare function toRxMethod<M extends DecorateFn<Codec>>(method: M): M;

package/build-tsc/rx/index.d.ts

@@ -0,0 +1,2 @@
+export { ApiRx } from './Api.js';
+export { toRxMethod } from './decorateMethod.js';