@dedot/api 0.0.1-alpha.32

package/client/BaseSubstrateClient.js

@@ -0,0 +1,252 @@
+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 { isJsonRpcProvider, JsonRpcClient } from '../json-rpc/index.js';
+import { newProxyChain } from '../proxychain.js';
+const SUPPORTED_METADATA_VERSIONS = [15, 14];
+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 {
+    rpcVersion;
+    _options;
+    _registry;
+    _metadata;
+    _genesisHash;
+    _runtimeVersion;
+    _localCache;
+    constructor(rpcVersion, options) {
+        super(options);
+        this.rpcVersion = rpcVersion;
+        this._options = this.normalizeOptions(options);
+    }
+    /// --- Internal logics
+    normalizeOptions(options) {
+        const defaultOptions = { throwOnUnknownApi: true };
+        if (isJsonRpcProvider(options)) {
+            return { ...defaultOptions, provider: 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 shouldPreloadMetadata() {
+        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();
+    }
+    toSubstrateRuntimeVersion(runtimeVersion) {
+        return {
+            ...runtimeVersion,
+            apis: runtimeVersion.apis.reduce((o, [name, version]) => {
+                o[name] = version;
+                return o;
+            }, {}),
+        };
+    }
+    /// --- 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

@@ -0,0 +1,131 @@
+import { BlockHash } from '@dedot/codecs';
+import type { JsonRpcProvider } from '@dedot/providers';
+import { GenericSubstrateApi, RpcLegacy, VersionedGenericSubstrateApi } from '@dedot/types';
+import type { SubstrateApi } from '../chaintypes/index.js';
+import type { ApiOptions, ISubstrateClientAt } 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 VersionedGenericSubstrateApi = SubstrateApi> extends BaseSubstrateClient<ChainApi> {
+    #private;
+    /**
+     * Use factory methods (`create`, `new`) to create `Dedot` instances.
+     *
+     * @param options
+     */
+    constructor(options: ApiOptions | JsonRpcProvider);
+    /**
+     * Factory method to create a new Dedot instance
+     *
+     * @param options
+     */
+    static create<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>(options: ApiOptions | JsonRpcProvider): Promise<Dedot<ChainApi>>;
+    /**
+     * Alias for __Dedot.create__
+     *
+     * @param options
+     */
+    static new<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>(options: ApiOptions | JsonRpcProvider): 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[RpcLegacy]['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[RpcLegacy]['query'];
+    /**
+     * @description Entry-point for inspecting errors from metadata
+     */
+    get errors(): ChainApi[RpcLegacy]['errors'];
+    /**
+     * @description Entry-point for inspecting events from metadata
+     */
+    get events(): ChainApi[RpcLegacy]['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[RpcLegacy]['call'];
+    protected callAt(hash?: BlockHash): ChainApi[RpcLegacy]['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[RpcLegacy]['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[RpcLegacy]>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
+}

package/client/Dedot.js

@@ -0,0 +1,246 @@
+import { PortableRegistry } from '@dedot/codecs';
+import { ConstantExecutor, ErrorExecutor, EventExecutor, RuntimeApiExecutor, StorageQueryExecutor, TxExecutor, } from '../executor/index.js';
+import { newProxyChain } from '../proxychain.js';
+import { BaseSubstrateClient } from './BaseSubstrateClient.js';
+const KEEP_ALIVE_INTERVAL = 10_000; // in ms
+/**
+ * @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('legacy', 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.shouldPreloadMetadata()) ? 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));
+    }
+    #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 = {
+            rpcVersion: 'legacy',
+            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/DedotClient.d.ts

@@ -0,0 +1,61 @@
+import { BlockHash } from '@dedot/codecs';
+import type { JsonRpcProvider } from '@dedot/providers';
+import { GenericSubstrateApi, RpcV2, VersionedGenericSubstrateApi } from '@dedot/types';
+import type { SubstrateApi } from '../chaintypes/index.js';
+import { ChainHead, ChainSpec, PinnedBlock } from '../json-rpc/index.js';
+import type { ApiOptions, ISubstrateClientAt, TxBroadcaster } from '../types.js';
+import { BaseSubstrateClient } from './BaseSubstrateClient.js';
+/**
+ * @name DedotClient
+ * @description New promised-based API Client for Polkadot & Substrate based on JSON-RPC V2
+ *
+ * __Unstable, use with caution.__
+ */
+export declare class DedotClient<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends BaseSubstrateClient<ChainApi> {
+    #private;
+    protected _chainHead?: ChainHead;
+    protected _chainSpec?: ChainSpec;
+    protected _txBroadcaster?: TxBroadcaster;
+    /**
+     * Use factory methods (`create`, `new`) to create `DedotClient` instances.
+     *
+     * @param options
+     */
+    constructor(options: ApiOptions | JsonRpcProvider);
+    /**
+     * Factory method to create a new DedotClient instance
+     *
+     * @param options
+     */
+    static create<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>(options: ApiOptions | JsonRpcProvider): Promise<DedotClient<ChainApi>>;
+    /**
+     * Alias for __DedotClient.create__
+     *
+     * @param options
+     */
+    static new<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>(options: ApiOptions | JsonRpcProvider): Promise<DedotClient<ChainApi>>;
+    get chainSpec(): ChainSpec;
+    get chainHead(): ChainHead;
+    get txBroadcaster(): TxBroadcaster;
+    /**
+     * Initialize APIs before usage
+     */
+    protected doInitialize(): Promise<void>;
+    protected subscribeRuntimeUpgrades(): void;
+    protected unsubscribeRuntimeUpgrades(): void;
+    protected onRuntimeUpgrade: (block: PinnedBlock) => Promise<void>;
+    protected beforeDisconnect(): Promise<void>;
+    protected onDisconnected: () => Promise<void>;
+    protected cleanUp(): void;
+    get query(): ChainApi[RpcV2]['query'];
+    get call(): ChainApi[RpcV2]['call'];
+    protected callAt(blockHash?: BlockHash): ChainApi[RpcV2]['call'];
+    get tx(): ChainApi[RpcV2]['tx'];
+    /**
+     * Get a new API instance at a specific block hash
+     * For now, this only supports pinned block hashes from the chain head
+     *
+     * @param hash
+     */
+    at<ChainApiAt extends GenericSubstrateApi = ChainApi[RpcV2]>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
+}