dedot 0.0.1-next.fecbe32d.13 → 0.1.0

package/client/BaseSubstrateClient.d.ts

@@ -1,65 +0,0 @@
-import { BlockHash, Hash, Metadata, PortableRegistry } from '@dedot/codecs';
-import { type IStorage } from '@dedot/storage';
-import { GenericSubstrateApi } from '@dedot/types';
-import type { SubstrateApi } from '../chaintypes/index.js';
-import { JsonRpcClient } from '../json-rpc/index.js';
-import type { ApiEvent, ApiOptions, ISubstrateClient, ISubstrateClientAt, JsonRpcClientOptions, MetadataKey, NetworkEndpoint, SubstrateRuntimeVersion } from '../types.js';
-export declare const KEEP_ALIVE_INTERVAL = 10000;
-export declare const SUPPORTED_METADATA_VERSIONS: number[];
-export declare const MetadataApiHash: `0x${string}`;
-export declare function ensurePresence<T>(value: T): NonNullable<T>;
-/**
- * @name BaseSubstrateClient
- * @description Base & shared abstraction for Substrate API Clients
- */
-export declare abstract class BaseSubstrateClient<ChainApi extends GenericSubstrateApi = SubstrateApi> extends JsonRpcClient<ChainApi, ApiEvent> implements ISubstrateClient<ChainApi> {
-    protected _options: ApiOptions;
-    protected _registry?: PortableRegistry;
-    protected _metadata?: Metadata;
-    protected _genesisHash?: Hash;
-    protected _runtimeVersion?: SubstrateRuntimeVersion;
-    protected _localCache?: IStorage;
-    protected constructor(options: JsonRpcClientOptions | NetworkEndpoint);
-    protected normalizeOptions(options: ApiOptions | NetworkEndpoint): ApiOptions;
-    protected initializeLocalCache(): Promise<void>;
-    protected setupMetadata(preloadMetadata: Metadata | undefined): Promise<void>;
-    protected setMetadata(metadata: Metadata): void;
-    protected getMetadataKey(runtime?: SubstrateRuntimeVersion): MetadataKey;
-    get currentMetadataKey(): string;
-    protected shouldLoadPreloadMetadata(): Promise<boolean>;
-    protected getMetadataFromOptions(runtime?: SubstrateRuntimeVersion): Metadata | undefined;
-    protected fetchMetadata(hash?: BlockHash, runtime?: SubstrateRuntimeVersion): Promise<Metadata>;
-    protected cleanUp(): void;
-    /**
-     * @description Clear local cache
-     */
-    clearCache(): Promise<void>;
-    protected doConnect(): Promise<this>;
-    protected onConnected: () => Promise<void>;
-    protected onDisconnected: () => Promise<void>;
-    protected initialize(): Promise<void>;
-    protected doInitialize(): Promise<void>;
-    protected beforeDisconnect(): Promise<void>;
-    protected afterDisconnect(): Promise<void>;
-    /**
-     * @description Connect to blockchain node
-     */
-    connect(): Promise<this>;
-    /**
-     * @description Disconnect to blockchain node
-     */
-    disconnect(): Promise<void>;
-    get options(): ApiOptions;
-    get metadata(): Metadata;
-    get registry(): PortableRegistry;
-    get genesisHash(): Hash;
-    get runtimeVersion(): SubstrateRuntimeVersion;
-    get consts(): ChainApi['consts'];
-    get errors(): ChainApi['errors'];
-    get events(): ChainApi['events'];
-    get query(): ChainApi['query'];
-    get call(): ChainApi['call'];
-    protected callAt(hash?: BlockHash): ChainApi['call'];
-    get tx(): ChainApi['tx'];
-    at<ChainApiAt extends GenericSubstrateApi = ChainApi>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
-}

package/client/BaseSubstrateClient.js

@@ -1,242 +0,0 @@
-import { $Metadata, PortableRegistry } from '@dedot/codecs';
-import { LocalStorage } from '@dedot/storage';
-import { calcRuntimeApiHash, ensurePresence as _ensurePresence, u8aToHex } from '@dedot/utils';
-import { ConstantExecutor, ErrorExecutor, EventExecutor } from '../executor/index.js';
-import { JsonRpcClient } from '../json-rpc/index.js';
-import { newProxyChain } from '../proxychain.js';
-export const KEEP_ALIVE_INTERVAL = 10_000; // in ms
-export const SUPPORTED_METADATA_VERSIONS = [15, 14];
-export const MetadataApiHash = calcRuntimeApiHash('Metadata'); // 0x37e397fc7c91f5e4
-const MESSAGE = 'Make sure to call `.connect()` method first before using the API interfaces.';
-export function ensurePresence(value) {
-    return _ensurePresence(value, MESSAGE);
-}
-/**
- * @name BaseSubstrateClient
- * @description Base & shared abstraction for Substrate API Clients
- */
-export class BaseSubstrateClient extends JsonRpcClient {
-    _options;
-    _registry;
-    _metadata;
-    _genesisHash;
-    _runtimeVersion;
-    _localCache;
-    constructor(options) {
-        super(options);
-        this._options = this.normalizeOptions(options);
-    }
-    /// --- Internal logics
-    normalizeOptions(options) {
-        const defaultOptions = { throwOnUnknownApi: true };
-        if (typeof options === 'string') {
-            return { ...defaultOptions, endpoint: options };
-        }
-        else {
-            return { ...defaultOptions, ...options };
-        }
-    }
-    async initializeLocalCache() {
-        if (!this._options.cacheMetadata)
-            return;
-        // Initialize local cache
-        if (this._options.cacheStorage) {
-            this._localCache = this._options.cacheStorage;
-            return;
-        }
-        try {
-            this._localCache = new LocalStorage();
-        }
-        catch {
-            throw new Error('localStorage is not available for caching, please provide a cacheStorage option');
-        }
-    }
-    async setupMetadata(preloadMetadata) {
-        let metadata = preloadMetadata;
-        let shouldUpdateCache = !!metadata;
-        if (!metadata) {
-            metadata = this.getMetadataFromOptions(this._runtimeVersion);
-        }
-        const metadataKey = this.currentMetadataKey;
-        try {
-            if (this._localCache && this._options.cacheMetadata) {
-                if (!metadata) {
-                    try {
-                        const cachedRawMetadata = await this._localCache.get(metadataKey);
-                        if (cachedRawMetadata) {
-                            metadata = $Metadata.tryDecode(cachedRawMetadata);
-                        }
-                    }
-                    catch (e) {
-                        console.error('Cannot decode raw metadata, try fetching fresh metadata from chain.', e);
-                    }
-                }
-            }
-        }
-        finally {
-            if (!metadata) {
-                metadata = await this.fetchMetadata();
-                if (this._options.cacheMetadata)
-                    shouldUpdateCache = true;
-            }
-        }
-        if (shouldUpdateCache && this._localCache) {
-            await this._localCache.set(metadataKey, u8aToHex($Metadata.tryEncode(metadata)));
-        }
-        if (!metadata) {
-            throw new Error('Cannot load metadata');
-        }
-        this.setMetadata(metadata);
-    }
-    setMetadata(metadata) {
-        this._metadata = metadata;
-        this._registry = new PortableRegistry(metadata.latest, this.options.hasher);
-    }
-    getMetadataKey(runtime) {
-        return `RAW_META/${this._genesisHash || '0x'}/${runtime?.specVersion || '---'}`;
-    }
-    get currentMetadataKey() {
-        return this.getMetadataKey(this._runtimeVersion);
-    }
-    async shouldLoadPreloadMetadata() {
-        if (this._options.metadata && Object.keys(this._options.metadata).length) {
-            return false;
-        }
-        if (!this._options.cacheMetadata || !this._localCache) {
-            return true;
-        }
-        // TODO improve this
-        const keys = await this._localCache.keys();
-        return !keys.some((k) => k.startsWith('RAW_META/'));
-    }
-    getMetadataFromOptions(runtime) {
-        if (!runtime || !this.options.metadata)
-            return;
-        const key = this.getMetadataKey(runtime);
-        if (this.options.metadata[key]) {
-            return $Metadata.tryDecode(this.options.metadata[key]);
-        }
-    }
-    async fetchMetadata(hash, runtime) {
-        // First try finding metadata from the provided option
-        const optionMetadata = this.getMetadataFromOptions(runtime);
-        if (optionMetadata)
-            return optionMetadata;
-        // If there is no runtime, we assume that the node supports Metadata Api V2
-        const supportedV2 = runtime ? runtime.apis[MetadataApiHash] === 2 : true;
-        if (supportedV2) {
-            // It makes sense to call metadata.metadataVersions to fetch the list of supported metadata versions first
-            // But for now, this approach could potentially help save/reduce one rpc call to the server in case the node support v15
-            // Question: Why not having a `metadata.metadataLatest` to fetch the latest version?
-            for (const version of SUPPORTED_METADATA_VERSIONS) {
-                try {
-                    const rawMetadata = await this.callAt(hash).metadata.metadataAtVersion(version);
-                    if (!rawMetadata)
-                        continue;
-                    return $Metadata.tryDecode(rawMetadata);
-                }
-                catch { }
-            }
-        }
-        try {
-            return $Metadata.tryDecode(await this.callAt(hash).metadata.metadata());
-        }
-        catch {
-            return await this.rpc.state_getMetadata();
-        }
-    }
-    cleanUp() {
-        this._registry = undefined;
-        this._metadata = undefined;
-        this._genesisHash = undefined;
-        this._runtimeVersion = undefined;
-        this._localCache = undefined;
-    }
-    /**
-     * @description Clear local cache
-     */
-    async clearCache() {
-        await this._localCache?.clear();
-    }
-    async doConnect() {
-        this.on('connected', this.onConnected);
-        this.on('disconnected', this.onDisconnected);
-        return new Promise((resolve) => {
-            this.once('ready', () => {
-                resolve(this);
-            });
-        });
-    }
-    onConnected = async () => {
-        await this.initialize();
-    };
-    onDisconnected = async () => { };
-    async initialize() {
-        await this.initializeLocalCache();
-        await this.doInitialize();
-        this.emit('ready');
-    }
-    async doInitialize() {
-        throw new Error('Unimplemented!');
-    }
-    async beforeDisconnect() { }
-    async afterDisconnect() {
-        this.cleanUp();
-    }
-    /// --- Public APIs ---
-    /**
-     * @description Connect to blockchain node
-     */
-    async connect() {
-        const [api, _] = await Promise.all([this.doConnect(), super.connect()]);
-        return api;
-    }
-    /**
-     * @description Disconnect to blockchain node
-     */
-    async disconnect() {
-        await this.beforeDisconnect();
-        await super.disconnect();
-        await this.afterDisconnect();
-    }
-    get options() {
-        return this._options;
-    }
-    get metadata() {
-        return ensurePresence(this._metadata);
-    }
-    get registry() {
-        return ensurePresence(this._registry);
-    }
-    get genesisHash() {
-        return ensurePresence(this._genesisHash);
-    }
-    get runtimeVersion() {
-        return ensurePresence(this._runtimeVersion);
-    }
-    get consts() {
-        return newProxyChain({ executor: new ConstantExecutor(this) });
-    }
-    get errors() {
-        return newProxyChain({ executor: new ErrorExecutor(this) });
-    }
-    get events() {
-        return newProxyChain({ executor: new EventExecutor(this) });
-    }
-    get query() {
-        throw new Error('Unimplemented!');
-    }
-    get call() {
-        return this.callAt();
-    }
-    // For internal use with caution
-    callAt(hash) {
-        throw new Error('Unimplemented!');
-    }
-    get tx() {
-        throw new Error('Unimplemented!');
-    }
-    at(hash) {
-        throw new Error('Unimplemented!');
-    }
-}

package/client/Dedot.d.ts

@@ -1,130 +0,0 @@
-import { BlockHash } from '@dedot/codecs';
-import { GenericSubstrateApi } from '@dedot/types';
-import type { SubstrateApi } from '../chaintypes/index.js';
-import type { ApiOptions, ISubstrateClientAt, NetworkEndpoint } from '../types.js';
-import { BaseSubstrateClient } from './BaseSubstrateClient.js';
-/**
- * @name Dedot
- * @description Promised-based API Client for Polkadot & Substrate
- *
- * Initialize API instance and interact with substrate-based network
- * ```typescript
- * import { Dedot } from 'dedot';
- * import type { PolkadotApi } from '@dedot/chaintypes/polkadot';
- *
- * const run = async () => {
- *   const api = await Dedot.new<PolkadotApi>('wss://rpc.polkadot.io');
- *
- *   // Call rpc `state_getMetadata` to fetch raw scale-encoded metadata and decode it.
- *   const metadata = await api.rpc.state.getMetadata();
- *   console.log('Metadata:', metadata);
- *
- *   // Query on-chain storage
- *   const address = '14...';
- *   const balance = await api.query.system.account(address);
- *   console.log('Balance:', balance);
- *
- *
- *   // Subscribe to on-chain storage changes
- *   const unsub = await api.query.system.number((blockNumber) => {
- *     console.log(`Current block number: ${blockNumber}`);
- *   });
- *
- *   // Get pallet constants
- *   const ss58Prefix = api.consts.system.ss58Prefix;
- *   console.log('Polkadot ss58Prefix:', ss58Prefix)
- *
- *   // await unsub();
- *   // await api.disconnect();
- * }
- *
- * run().catch(console.error);
- * ```
- */
-export declare class Dedot<ChainApi extends GenericSubstrateApi = SubstrateApi> extends BaseSubstrateClient<ChainApi> {
-    #private;
-    /**
-     * Use factory methods (`create`, `new`) to create `Dedot` instances.
-     *
-     * @param options
-     */
-    constructor(options: ApiOptions | NetworkEndpoint);
-    /**
-     * Factory method to create a new Dedot instance
-     *
-     * @param options
-     */
-    static create<ChainApi extends GenericSubstrateApi = SubstrateApi>(options: ApiOptions | NetworkEndpoint): Promise<Dedot<ChainApi>>;
-    /**
-     * Alias for __Dedot.create__
-     *
-     * @param options
-     */
-    static new<ChainApi extends GenericSubstrateApi = SubstrateApi>(options: ApiOptions | NetworkEndpoint): Promise<Dedot<ChainApi>>;
-    protected onDisconnected: () => Promise<void>;
-    protected beforeDisconnect(): Promise<void>;
-    /**
-     * Initialize APIs before usage
-     */
-    protected doInitialize(): Promise<void>;
-    protected cleanUp(): void;
-    /**
-     * @description Entry-point for inspecting constants (parameter types) for all pallets (modules).
-     *
-     * ```typescript
-     * const ss58Prefix = api.consts.system.ss58Prefix;
-     * console.log('ss58Prefix:', ss58Prefix)
-     * ```
-     */
-    get consts(): ChainApi['consts'];
-    /**
-     * @description Entry-point for executing query to on-chain storage.
-     *
-     * ```typescript
-     * const balance = await api.query.system.account(<address>);
-     * console.log('Balance:', balance);
-     * ```
-     */
-    get query(): ChainApi['query'];
-    /**
-     * @description Entry-point for inspecting errors from metadata
-     */
-    get errors(): ChainApi['errors'];
-    /**
-     * @description Entry-point for inspecting events from metadata
-     */
-    get events(): ChainApi['events'];
-    /**
-     * @description Entry-point for executing runtime api
-     *
-     * ```typescript
-     * // Get account nonce
-     * const nonce = await api.call.accountNonceApi.accountNonce(<address>);
-     *
-     * // Query transaction payment info
-     * const tx = api.tx.balances.transferKeepAlive(<address>, 2_000_000_000_000n);
-     * const queryInfo = await api.call.transactionPaymentApi.queryInfo(tx.toU8a(), tx.length);
-     * ```
-     */
-    get call(): ChainApi['call'];
-    protected callAt(hash?: BlockHash): ChainApi['call'];
-    /**
-     * @description Entry-point for executing on-chain transactions
-     *
-     * ```typescript
-     * // Make a transfer balance transaction
-     * api.tx.balances.transferKeepAlive(<address>, <amount>)
-     *    .signAndSend(<keyPair|address>, { signer }, ({ status }) => {
-     *      console.log('Transaction status', status.tag);
-     *    });
-     * ```
-     */
-    get tx(): ChainApi['tx'];
-    /**
-     * Create a new API instance at a specific block hash
-     * This is useful when we want to inspect the state of the chain at a specific block hash
-     *
-     * @param hash
-     */
-    at<ChainApiAt extends GenericSubstrateApi = ChainApi>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
-}

package/client/Dedot.js

@@ -1,253 +0,0 @@
-import { PortableRegistry } from '@dedot/codecs';
-import { ConstantExecutor, ErrorExecutor, EventExecutor, RuntimeApiExecutor, StorageQueryExecutor, TxExecutor, } from '../executor/index.js';
-import { newProxyChain } from '../proxychain.js';
-import { BaseSubstrateClient, KEEP_ALIVE_INTERVAL } from './BaseSubstrateClient.js';
-/**
- * @name Dedot
- * @description Promised-based API Client for Polkadot & Substrate
- *
- * Initialize API instance and interact with substrate-based network
- * ```typescript
- * import { Dedot } from 'dedot';
- * import type { PolkadotApi } from '@dedot/chaintypes/polkadot';
- *
- * const run = async () => {
- *   const api = await Dedot.new<PolkadotApi>('wss://rpc.polkadot.io');
- *
- *   // Call rpc `state_getMetadata` to fetch raw scale-encoded metadata and decode it.
- *   const metadata = await api.rpc.state.getMetadata();
- *   console.log('Metadata:', metadata);
- *
- *   // Query on-chain storage
- *   const address = '14...';
- *   const balance = await api.query.system.account(address);
- *   console.log('Balance:', balance);
- *
- *
- *   // Subscribe to on-chain storage changes
- *   const unsub = await api.query.system.number((blockNumber) => {
- *     console.log(`Current block number: ${blockNumber}`);
- *   });
- *
- *   // Get pallet constants
- *   const ss58Prefix = api.consts.system.ss58Prefix;
- *   console.log('Polkadot ss58Prefix:', ss58Prefix)
- *
- *   // await unsub();
- *   // await api.disconnect();
- * }
- *
- * run().catch(console.error);
- * ```
- */
-export class Dedot extends BaseSubstrateClient {
-    #runtimeSubscriptionUnsub;
-    #healthTimer;
-    #apiAtCache = {};
-    /**
-     * Use factory methods (`create`, `new`) to create `Dedot` instances.
-     *
-     * @param options
-     */
-    constructor(options) {
-        super(options);
-    }
-    /**
-     * Factory method to create a new Dedot instance
-     *
-     * @param options
-     */
-    static async create(options) {
-        return new Dedot(options).connect();
-    }
-    /**
-     * Alias for __Dedot.create__
-     *
-     * @param options
-     */
-    static async new(options) {
-        return Dedot.create(options);
-    }
-    onDisconnected = async () => {
-        await this.#unsubscribeUpdates();
-    };
-    async beforeDisconnect() {
-        await this.#unsubscribeUpdates();
-    }
-    /**
-     * Initialize APIs before usage
-     */
-    async doInitialize() {
-        let [genesisHash, runtimeVersion, metadata] = await Promise.all([
-            this.rpc.chain_getBlockHash(0),
-            this.#getRuntimeVersion(),
-            (await this.shouldLoadPreloadMetadata()) ? this.fetchMetadata() : Promise.resolve(undefined),
-        ]);
-        this._genesisHash = genesisHash;
-        this._runtimeVersion = runtimeVersion;
-        await this.setupMetadata(metadata);
-        this.#subscribeUpdates();
-    }
-    cleanUp() {
-        super.cleanUp();
-        this.#apiAtCache = {};
-        this.#healthTimer = undefined;
-        this.#runtimeSubscriptionUnsub = undefined;
-    }
-    #subscribeRuntimeUpgrades() {
-        if (this.#runtimeSubscriptionUnsub)
-            return;
-        this.rpc
-            .state_subscribeRuntimeVersion(async (runtimeVersion) => {
-            if (runtimeVersion.specVersion !== this.runtimeVersion?.specVersion) {
-                this._runtimeVersion = this.#toSubstrateRuntimeVersion(runtimeVersion);
-                const newMetadata = await this.fetchMetadata(undefined, this._runtimeVersion);
-                await this.setupMetadata(newMetadata);
-            }
-        })
-            .then((unsub) => {
-            this.#runtimeSubscriptionUnsub = unsub;
-        });
-    }
-    async #getRuntimeVersion(at) {
-        return this.#toSubstrateRuntimeVersion(await this.rpc.state_getRuntimeVersion(at));
-    }
-    #toSubstrateRuntimeVersion(runtimeVersion) {
-        return {
-            ...runtimeVersion,
-            apis: runtimeVersion.apis.reduce((o, [name, version]) => {
-                o[name] = version;
-                return o;
-            }, {}),
-        };
-    }
-    #subscribeHealth() {
-        this.#unsubscribeHealth();
-        this.#healthTimer = setInterval(() => {
-            this.rpc.system_health().catch(console.error);
-        }, KEEP_ALIVE_INTERVAL);
-    }
-    #unsubscribeHealth() {
-        if (!this.#healthTimer) {
-            return;
-        }
-        clearInterval(this.#healthTimer);
-        this.#healthTimer = undefined;
-    }
-    async #unsubscribeRuntimeUpdates() {
-        if (!this.#runtimeSubscriptionUnsub) {
-            return;
-        }
-        await this.#runtimeSubscriptionUnsub();
-        this.#runtimeSubscriptionUnsub = undefined;
-    }
-    #subscribeUpdates() {
-        this.#subscribeRuntimeUpgrades();
-        this.#subscribeHealth();
-    }
-    async #unsubscribeUpdates() {
-        await this.#unsubscribeRuntimeUpdates();
-        this.#unsubscribeHealth();
-    }
-    /// --- Public APIs ---
-    /**
-     * @description Entry-point for inspecting constants (parameter types) for all pallets (modules).
-     *
-     * ```typescript
-     * const ss58Prefix = api.consts.system.ss58Prefix;
-     * console.log('ss58Prefix:', ss58Prefix)
-     * ```
-     */
-    get consts() {
-        return newProxyChain({ executor: new ConstantExecutor(this) });
-    }
-    /**
-     * @description Entry-point for executing query to on-chain storage.
-     *
-     * ```typescript
-     * const balance = await api.query.system.account(<address>);
-     * console.log('Balance:', balance);
-     * ```
-     */
-    get query() {
-        return newProxyChain({ executor: new StorageQueryExecutor(this) });
-    }
-    /**
-     * @description Entry-point for inspecting errors from metadata
-     */
-    get errors() {
-        return newProxyChain({ executor: new ErrorExecutor(this) });
-    }
-    /**
-     * @description Entry-point for inspecting events from metadata
-     */
-    get events() {
-        return newProxyChain({ executor: new EventExecutor(this) });
-    }
-    /**
-     * @description Entry-point for executing runtime api
-     *
-     * ```typescript
-     * // Get account nonce
-     * const nonce = await api.call.accountNonceApi.accountNonce(<address>);
-     *
-     * // Query transaction payment info
-     * const tx = api.tx.balances.transferKeepAlive(<address>, 2_000_000_000_000n);
-     * const queryInfo = await api.call.transactionPaymentApi.queryInfo(tx.toU8a(), tx.length);
-     * ```
-     */
-    get call() {
-        return this.callAt();
-    }
-    // For internal use with caution
-    callAt(hash) {
-        return newProxyChain({ executor: new RuntimeApiExecutor(this, hash) });
-    }
-    /**
-     * @description Entry-point for executing on-chain transactions
-     *
-     * ```typescript
-     * // Make a transfer balance transaction
-     * api.tx.balances.transferKeepAlive(<address>, <amount>)
-     *    .signAndSend(<keyPair|address>, { signer }, ({ status }) => {
-     *      console.log('Transaction status', status.tag);
-     *    });
-     * ```
-     */
-    get tx() {
-        return newProxyChain({ executor: new TxExecutor(this) });
-    }
-    /**
-     * Create a new API instance at a specific block hash
-     * This is useful when we want to inspect the state of the chain at a specific block hash
-     *
-     * @param hash
-     */
-    async at(hash) {
-        if (this.#apiAtCache[hash])
-            return this.#apiAtCache[hash];
-        const targetVersion = await this.#getRuntimeVersion(hash);
-        let metadata = this.metadata;
-        let registry = this.registry;
-        if (targetVersion.specVersion !== this.runtimeVersion.specVersion) {
-            metadata = await this.fetchMetadata(hash, targetVersion);
-            registry = new PortableRegistry(metadata.latest, this.options.hasher);
-        }
-        const api = {
-            atBlockHash: hash,
-            options: this.options,
-            genesisHash: this.genesisHash,
-            runtimeVersion: targetVersion,
-            metadata,
-            registry,
-            rpc: this.rpc,
-        };
-        api.consts = newProxyChain({ executor: new ConstantExecutor(api) });
-        api.query = newProxyChain({ executor: new StorageQueryExecutor(api) });
-        api.call = newProxyChain({ executor: new RuntimeApiExecutor(api) });
-        api.events = newProxyChain({ executor: new EventExecutor(api) });
-        api.errors = newProxyChain({ executor: new ErrorExecutor(api) });
-        this.#apiAtCache[hash] = api;
-        return api;
-    }
-}

package/client/index.d.ts

@@ -1 +0,0 @@
-export * from './Dedot.js';

package/client/index.js

@@ -1 +0,0 @@
-export * from './Dedot.js';