@pezkuwi/api 16.5.13 → 16.5.15

package/build/base/find.js

@@ -1,7 +0,0 @@
-import { u8aToU8a } from '@pezkuwi/util';
-export function findCall(registry, callIndex) {
-    return registry.findMetaCall(u8aToU8a(callIndex));
-}
-export function findError(registry, errorIndex) {
-    return registry.findMetaError(u8aToU8a(errorIndex));
-}

package/build/base/index.js

@@ -1,57 +0,0 @@
-import { isString, objectSpread, u8aToHex, u8aToU8a } from '@pezkuwi/util';
-import { Getters } from './Getters.js';
-export class ApiBase extends Getters {
-    /**
-     * @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 = {}, type, decorateMethod) {
-        super(options, type, decorateMethod);
-    }
-    /**
-     * @description Connect from the underlying provider, halting all network traffic
-     */
-    connect() {
-        return this._rpcCore.connect();
-    }
-    /**
-     * @description Disconnect from the underlying provider, halting all network traffic
-     */
-    disconnect() {
-        this._unsubscribe();
-        return this._rpcCore.disconnect();
-    }
-    /**
-     * @description Set an external signer which will be used to sign extrinsic when account passed in is not KeyringPair
-     */
-    setSigner(signer) {
-        this._rx.signer = signer;
-    }
-    /**
-     * @description Signs a raw signer payload, string or Uint8Array
-     */
-    async sign(address, data, { signer } = {}) {
-        if (isString(address)) {
-            const _signer = signer || this._rx.signer;
-            if (!_signer?.signRaw) {
-                throw new Error('No signer exists with a signRaw interface. You possibly need to pass through an explicit keypair for the origin so it can be used for signing.');
-            }
-            return (await _signer.signRaw(objectSpread({ type: 'bytes' }, data, { address }))).signature;
-        }
-        return u8aToHex(address.sign(u8aToU8a(data.data)));
-    }
-}

package/build/base/types.js

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

package/build/bundle.js

@@ -1,7 +0,0 @@
-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/cjs/augment.d.ts

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

package/build/cjs/augment.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("@pezkuwi/api-augment");

package/build/cjs/base/Decorate.d.ts

@@ -1,143 +0,0 @@
-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 {};