@pezkuwi/api 16.5.5

package/build/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';
+/**
+ * # @polkadot/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 Polkadot (and Substrate) 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/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/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/promise/index.d.ts

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

package/build/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/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';
+/**
+ * # @polkadot/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 Polkadot (and Substrate) 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/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/rx/index.d.ts

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

package/build/submittable/Result.d.ts

@@ -0,0 +1,31 @@
+import type { BlockNumber, DispatchError, DispatchInfo, EventRecord, ExtrinsicStatus, Hash } from '@pezkuwi/types/interfaces';
+import type { AnyJson, ISubmittableResult } from '@pezkuwi/types/types';
+import type { SubmittableResultValue } from './types.js';
+export declare class SubmittableResult implements ISubmittableResult {
+    readonly dispatchError?: DispatchError | undefined;
+    readonly dispatchInfo?: DispatchInfo | undefined;
+    readonly internalError?: Error | undefined;
+    readonly events: EventRecord[];
+    readonly status: ExtrinsicStatus;
+    readonly txHash: Hash;
+    readonly txIndex?: number | undefined;
+    readonly blockNumber?: BlockNumber | undefined;
+    constructor({ blockNumber, dispatchError, dispatchInfo, events, internalError, status, txHash, txIndex }: SubmittableResultValue);
+    get isCompleted(): boolean;
+    get isError(): boolean;
+    get isFinalized(): boolean;
+    get isInBlock(): boolean;
+    get isWarning(): boolean;
+    /**
+     * @description Filters EventRecords for the specified method & section (there could be multiple)
+     */
+    filterRecords(section: string, method: string | string[]): EventRecord[];
+    /**
+     * @description Finds an EventRecord for the specified method & section
+     */
+    findRecord(section: string, method: string | string[]): EventRecord | undefined;
+    /**
+     * @description Creates a human representation of the output
+     */
+    toHuman(isExtended?: boolean): AnyJson;
+}

package/build/submittable/createClass.d.ts

@@ -0,0 +1,12 @@
+import type { CodecClass } from '@pezkuwi/types/types';
+import type { ApiBase } from '../base/index.js';
+import type { ApiInterfaceRx, ApiTypes } from '../types/index.js';
+import type { SubmittableExtrinsic } from './types.js';
+interface SubmittableOptions<ApiType extends ApiTypes> {
+    api: ApiInterfaceRx;
+    apiType: ApiTypes;
+    blockHash?: Uint8Array | undefined;
+    decorateMethod: ApiBase<ApiType>['_decorateMethod'];
+}
+export declare function createClass<ApiType extends ApiTypes>({ api, apiType, blockHash, decorateMethod }: SubmittableOptions<ApiType>): CodecClass<SubmittableExtrinsic<ApiType>>;
+export {};

package/build/submittable/createSubmittable.d.ts

@@ -0,0 +1,8 @@
+import type { Call } from '@pezkuwi/types/interfaces';
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { ApiBase } from '../base/index.js';
+import type { ApiInterfaceRx, ApiTypes } from '../types/index.js';
+import type { SubmittableExtrinsic } from './types.js';
+type Creator<ApiType extends ApiTypes> = (extrinsic: Call | Uint8Array | string) => SubmittableExtrinsic<ApiType>;
+export declare function createSubmittable<ApiType extends ApiTypes>(apiType: ApiTypes, api: ApiInterfaceRx, decorateMethod: ApiBase<ApiType>['_decorateMethod'], registry?: Registry, blockHash?: Uint8Array): Creator<ApiType>;
+export {};

package/build/submittable/index.d.ts

@@ -0,0 +1,2 @@
+export { createSubmittable } from './createSubmittable.js';
+export { SubmittableResult } from './Result.js';

package/build/submittable/types.d.ts

@@ -0,0 +1 @@
+export type { AddressOrPair, SignerOptions, SubmittableDryRunResult, SubmittableExtrinsic, SubmittablePaymentResult, SubmittableResultResult, SubmittableResultSubscription, SubmittableResultValue } from '@pezkuwi/api-base/types';

package/build/types/calls.d.ts

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/calls';

package/build/types/consts.d.ts

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/consts';

package/build/types/errors.d.ts

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/errors';

package/build/types/events.d.ts

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/events';

package/build/types/index.d.ts

@@ -0,0 +1,114 @@
+import type { ApiTypes, DeriveCustom, QueryableStorageMulti } from '@pezkuwi/api-base/types';
+import type { ApiInterfaceRx as ApiInterfaceBase } from '@pezkuwi/api-base/types/api';
+import type { QueryableCalls } from '@pezkuwi/api-base/types/calls';
+import type { QueryableConsts } from '@pezkuwi/api-base/types/consts';
+import type { DecoratedErrors } from '@pezkuwi/api-base/types/errors';
+import type { DecoratedEvents } from '@pezkuwi/api-base/types/events';
+import type { QueryableStorage } from '@pezkuwi/api-base/types/storage';
+import type { ProviderInterface, ProviderInterfaceEmitted } from '@pezkuwi/rpc-provider/types';
+import type { ExtDef } from '@pezkuwi/types/extrinsic/signedExtensions/types';
+import type { Call, Extrinsic, Hash, RuntimeVersionPartial } from '@pezkuwi/types/interfaces';
+import type { CallFunction, DefinitionRpc, DefinitionRpcSub, DefinitionsCall, RegisteredTypes, Registry, RegistryError, SignatureOptions, Signer } from '@pezkuwi/types/types';
+import type { BN } from '@pezkuwi/util';
+import type { HexString } from '@pezkuwi/util/types';
+import type { ApiBase } from '../base/index.js';
+import type { SubmittableExtrinsic } from '../types/submittable.js';
+import type { AllDerives } from '../util/decorate.js';
+export type { Signer, SignerResult } from '@pezkuwi/types/types';
+export { ApiBase } from '../base/index.js';
+export * from '@pezkuwi/api/types/calls';
+export * from '@pezkuwi/api/types/consts';
+export * from '@pezkuwi/api/types/errors';
+export * from '@pezkuwi/api/types/events';
+export * from '@pezkuwi/api/types/storage';
+export * from '@pezkuwi/api/types/submittable';
+export * from '@pezkuwi/api-base/types';
+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/types/storage.d.ts

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/storage';

package/build/types/submittable.d.ts

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/submittable';

package/build/util/augmentObject.d.ts

@@ -0,0 +1,9 @@
+type Sections<T> = Record<string, Methods<T>>;
+type Methods<T> = Record<string, T>;
+/**
+ * @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 declare function augmentObject<T>(prefix: string | null, src: Sections<T>, dst: Sections<T>, fromEmpty?: boolean): Sections<T>;
+export {};

package/build/util/decorate.d.ts

@@ -0,0 +1,16 @@
+import type { ExactDerive } from '@pezkuwi/api-derive';
+import type { AnyFunction } from '@pezkuwi/types/types';
+import type { ApiTypes, DecorateMethod, MethodResult } from '../types/index.js';
+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 declare function decorateDeriveSections<ApiType extends ApiTypes>(decorateMethod: DecorateMethod<ApiType>, derives: AnyDerive): AllDerives<ApiType>;
+export {};

package/build/util/filterEvents.d.ts

@@ -0,0 +1,6 @@
+import type { BlockNumber, EventRecord, ExtrinsicStatus, H256, SignedBlock } from '@pezkuwi/types/interfaces';
+export declare function filterEvents(txHash: H256, { block: { extrinsics, header } }: SignedBlock, allEvents: EventRecord[], status: ExtrinsicStatus): {
+    events?: EventRecord[];
+    txIndex?: number;
+    blockNumber?: BlockNumber;
+};

package/build/util/index.d.ts

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

package/build/util/isKeyringPair.d.ts

@@ -0,0 +1,3 @@
+import type { AccountId, Address } from '@pezkuwi/types/interfaces';
+import type { IKeyringPair } from '@pezkuwi/types/types';
+export declare function isKeyringPair(account: string | IKeyringPair | AccountId | Address): account is IKeyringPair;

package/build/util/logging.d.ts

@@ -0,0 +1 @@
+export declare const l: import("@pezkuwi/util/types").Logger;

package/build/util/validate.d.ts

@@ -0,0 +1,3 @@
+import type { StorageEntry } from '@pezkuwi/types/primitive/types';
+import type { Registry } from '@pezkuwi/types/types';
+export declare function extractStorageArgs(registry: Registry, creator: StorageEntry, _args: unknown[]): [StorageEntry, unknown[]];

package/package.json

@@ -0,0 +1,46 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues",
+  "description": "Promise and RxJS wrappers around the Polkadot JS RPC",
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/api#readme",
+  "license": "Apache-2.0",
+  "name": "@pezkuwi/api",
+  "repository": {
+    "directory": "packages/api",
+    "type": "git",
+    "url": "https://github.com/pezkuwichain/pezkuwi-api.git"
+  },
+  "sideEffects": [
+    "./packageDetect.js",
+    "./packageDetect.cjs"
+  ],
+  "type": "module",
+  "version": "16.5.5",
+  "main": "index.js",
+  "dependencies": {
+    "@pezkuwi/api-augment": "16.5.5",
+    "@pezkuwi/api-base": "16.5.5",
+    "@pezkuwi/api-derive": "16.5.5",
+    "@pezkuwi/keyring": "14.0.5",
+    "@pezkuwi/rpc-augment": "16.5.5",
+    "@pezkuwi/rpc-core": "16.5.5",
+    "@pezkuwi/rpc-provider": "16.5.5",
+    "@pezkuwi/types": "16.5.5",
+    "@pezkuwi/types-augment": "16.5.5",
+    "@pezkuwi/types-codec": "16.5.5",
+    "@pezkuwi/types-create": "16.5.5",
+    "@pezkuwi/types-known": "16.5.5",
+    "@pezkuwi/util": "14.0.5",
+    "@pezkuwi/util-crypto": "14.0.5",
+    "eventemitter3": "^5.0.1",
+    "rxjs": "^7.8.1",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@pezkuwi/api-augment": "16.5.5",
+    "@pezkuwi/types-support": "16.5.5"
+  }
+}