@dedot/api 0.18.8 → 1.0.0

package/client/V2Client.js

@@ -0,0 +1,312 @@
+import { $H256, $Header, $RuntimeVersion, PortableRegistry, } from '@dedot/codecs';
+import { u32 } from '@dedot/shape';
+import { assert, concatU8a, DedotError, twox64Concat, u8aToHex, xxhashAsU8a } from '@dedot/utils';
+import { ConstantExecutor, ErrorExecutor, EventExecutor, RuntimeApiExecutorV2, StorageQueryExecutorV2, TxExecutorV2, ViewFunctionExecutorV2, } from '../executor/index.js';
+import { SubmittableExtrinsicV2 } from '../extrinsic/submittable/SubmittableExtrinsicV2.js';
+import { Archive, ChainHead, ChainSpec, Transaction, TransactionWatch } from '../json-rpc/index.js';
+import { newProxyChain } from '../proxychain.js';
+import { NewStorageQuery } from '../storage/index.js';
+import { BaseSubstrateClient, ensurePresence } from './BaseSubstrateClient.js';
+import { V2BlockExplorer } from './explorer/index.js';
+/**
+ * @name V2Client
+ * @description New promised-based API Client for Polkadot & Substrate based on JSON-RPC V2
+ *
+ * __Unstable, use with caution.__
+ */
+export class V2Client// prettier-end-here
+ extends BaseSubstrateClient {
+    _chainHead;
+    _chainSpec;
+    _archive;
+    _txBroadcaster;
+    _blockExplorer;
+    #hasher;
+    /**
+     * Use factory methods (`create`, `new`) to create `V2Client` instances.
+     *
+     * @param options
+     */
+    constructor(options) {
+        super('v2', options);
+    }
+    /**
+     * Factory method to create a new V2Client instance
+     *
+     * @param options
+     */
+    static async create(options) {
+        return new V2Client(options).connect();
+    }
+    /**
+     * Alias for __V2Client.create__
+     *
+     * @param options
+     */
+    static async new(options) {
+        return V2Client.create(options);
+    }
+    get chainSpec() {
+        return ensurePresence(this._chainSpec);
+    }
+    get chainHead() {
+        return ensurePresence(this._chainHead);
+    }
+    get archive() {
+        return this._archive;
+    }
+    get txBroadcaster() {
+        this.chainHead; // Ensure chain head is initialized
+        assert(this._txBroadcaster, 'JSON-RPC method to broadcast transactions is not supported by the server/node.');
+        return this._txBroadcaster;
+    }
+    async #initializeTxBroadcaster(rpcMethods) {
+        const tx = new Transaction(this, { rpcMethods });
+        if (await tx.supported())
+            return tx;
+        const txWatch = new TransactionWatch(this, { rpcMethods });
+        if (await txWatch.supported())
+            return txWatch;
+    }
+    /**
+     * Initialize APIs before usage
+     */
+    async doInitialize() {
+        const shouldInitialize = !this._genesisHash;
+        if (shouldInitialize) {
+            const rpcMethods = (await this.rpc.rpc_methods()).methods;
+            this._chainHead = new ChainHead(this, { rpcMethods });
+            this._chainSpec = new ChainSpec(this, { rpcMethods });
+            // Always initialize Archive, but only set up fallback if supported
+            const archive = new Archive(this, { rpcMethods });
+            // Set up ChainHead with Archive fallback only if Archive is supported
+            if (await archive.supported()) {
+                this._archive = archive;
+                this._chainHead.withArchive(archive);
+            }
+            this._txBroadcaster = await this.#initializeTxBroadcaster(rpcMethods);
+            this._blockExplorer = new V2BlockExplorer(this);
+        }
+        // Fetching node information
+        let [_, genesisHash] = await Promise.all([
+            this.chainHead.follow(true),
+            shouldInitialize ? this.chainSpec.genesisHash().catch(() => undefined) : Promise.resolve(this._genesisHash),
+        ]);
+        this._genesisHash = genesisHash || (await this.#getGenesisHashFallback());
+        const newBestRuntime = await this.chainHead.bestRuntimeVersion();
+        if (!this._runtimeVersion || newBestRuntime.specVersion !== this._runtimeVersion.specVersion) {
+            this._runtimeVersion = newBestRuntime;
+            let metadata;
+            if (await this.shouldPreloadMetadata()) {
+                metadata = await this.fetchMetadata();
+            }
+            await this.setupMetadata(metadata);
+        }
+        if (shouldInitialize) {
+            this.subscribeRuntimeUpgrades();
+            this.chainHead.on('newBlock', (...args) => this.emit('newBlock', ...args));
+            this.chainHead.on('bestBlock', (...args) => this.emit('bestBlock', ...args));
+            this.chainHead.on('finalizedBlock', (...args) => this.emit('finalizedBlock', ...args));
+            this.chainHead.on('bestChainChanged', (...args) => this.emit('bestChainChanged', ...args));
+        }
+    }
+    /**
+     * Ref: https://github.com/paritytech/polkadot-sdk/blob/bbd51ce867967f71657b901f1a956ad4f75d352e/substrate/frame/system/src/lib.rs#L909-L913
+     * @private
+     */
+    async #getGenesisHashFallback() {
+        const pallet = xxhashAsU8a('System', 128);
+        const item = xxhashAsU8a('BlockHash', 128);
+        const blockHeightAt0 = twox64Concat(u32.encode(0));
+        const key = u8aToHex(concatU8a(pallet, item, blockHeightAt0));
+        const storageValue = await this.chainHead.storage([{ type: 'value', key }]);
+        const rawGenesisHash = storageValue.at(0)?.value;
+        assert(rawGenesisHash, 'Genesis hash not found!');
+        // Here we assume that in most case the hash is stored as a H256
+        return $H256.tryDecode(rawGenesisHash);
+    }
+    subscribeRuntimeUpgrades() {
+        this.chainHead.on('bestBlock', this.onRuntimeUpgrade);
+        this.#subscribeStalingDetection();
+    }
+    onRuntimeUpgrade = async (block) => {
+        const runtimeUpgraded = block.runtime && block.runtime.specVersion !== this._runtimeVersion?.specVersion;
+        if (!runtimeUpgraded)
+            return;
+        this.startRuntimeUpgrade();
+        this._runtimeVersion = block.runtime;
+        const newMetadata = await this.fetchMetadata(undefined, this._runtimeVersion);
+        await this.setupMetadata(newMetadata);
+        const blockInfo = {
+            hash: block.hash,
+            number: block.number,
+            parent: block.parent,
+            runtimeUpgraded: block.runtimeUpgraded === true,
+        };
+        this.emit('runtimeUpgraded', this._runtimeVersion, blockInfo);
+        this.doneRuntimeUpgrade();
+    };
+    async setMetadata(metadata) {
+        this._metadata = metadata;
+        // Here we assume that hasher method of a chain is less likely to change via runtime upgrades
+        // So for now, we only need to detect it in initial connection and reuse it later
+        if (!this.#hasher && !this.options.hasher) {
+            this.#hasher = await this.chainHead.hasher();
+        }
+        this._registry = new PortableRegistry(metadata.latest, // --
+        this.#hasher || this.options.hasher);
+    }
+    #subscribeStalingDetection() {
+        const stalingDetectionFn = this.getStalingDetectionFn();
+        if (!stalingDetectionFn)
+            return;
+        this.chainHead.on('bestBlock', stalingDetectionFn);
+    }
+    async beforeDisconnect() {
+        await this.chainHead.unfollow();
+    }
+    cleanUp() {
+        super.cleanUp();
+        this._chainHead = undefined;
+        this._chainSpec = undefined;
+        this._archive = undefined;
+        this._txBroadcaster = undefined;
+        this._blockExplorer = undefined;
+    }
+    /**
+     * @description Clear local cache, API at-block cache, and ChainHead cache
+     * @param keepMetadataCache Keep the metadata cache, only clear other caches.
+     */
+    async clearCache(keepMetadataCache = false) {
+        await super.clearCache(keepMetadataCache);
+        this._chainHead?.clearCache();
+    }
+    get query() {
+        return newProxyChain({
+            executor: new StorageQueryExecutorV2(this, this.chainHead),
+        });
+    }
+    get view() {
+        return newProxyChain({
+            executor: new ViewFunctionExecutorV2(this, this.chainHead),
+        });
+    }
+    get call() {
+        return this.callAt();
+    }
+    callAt(blockHash) {
+        return newProxyChain({
+            executor: new RuntimeApiExecutorV2(this, this.chainHead, blockHash),
+        });
+    }
+    get tx() {
+        return newProxyChain({ executor: new TxExecutorV2(this) });
+    }
+    get block() {
+        return ensurePresence(this._blockExplorer);
+    }
+    /**
+     * Get a new API instance at a specific block hash
+     * Supports both pinned blocks (via ChainHead) and historical blocks (via Archive fallback)
+     *
+     * @param hash
+     */
+    async at(hash) {
+        const cached = this._apiAtCache.get(hash);
+        if (cached)
+            return cached;
+        let parentVersion;
+        let parentHash;
+        // Try to get block info from ChainHead first (for pinned blocks)
+        const targetBlock = this.chainHead.findBlock(hash);
+        if (targetBlock) {
+            if (hash === this.genesisHash) {
+                parentHash = hash;
+                parentVersion = targetBlock.runtime;
+            }
+            else {
+                parentHash = targetBlock.parent;
+                const parentBlock = this.chainHead.findBlock(parentHash);
+                parentVersion = parentBlock?.runtime;
+            }
+            // fallback to fetching on-chain runtime if we can't find it in the block
+            if (!parentVersion) {
+                parentVersion = this.toSubstrateRuntimeVersion(await this.callAt(parentHash).core.version());
+            }
+        }
+        else {
+            // Block not pinned, try via Archive fallback if supported
+            if (this._archive && (await this._archive.supported())) {
+                try {
+                    if (hash === this.genesisHash) {
+                        parentHash = hash;
+                    }
+                    else {
+                        const rawHeader = await this._archive.header(hash);
+                        assert(rawHeader, `Header for block ${hash} not found`);
+                        const header = $Header.tryDecode(rawHeader);
+                        parentHash = header.parentHash;
+                    }
+                    // Fetch runtime version via Archive
+                    const runtimeRaw = await this._archive.call('Core_version', '0x', parentHash);
+                    assert(runtimeRaw, 'Runtime Version Not Found');
+                    parentVersion = this.toSubstrateRuntimeVersion($RuntimeVersion.tryDecode(runtimeRaw));
+                }
+                catch (error) {
+                    throw new DedotError(`Unable to fetch runtime version for block ${hash}: ${error}`);
+                }
+            }
+            else {
+                throw new DedotError('Block is not pinned and Archive JSON-RPC is not supported by the server/node!');
+            }
+        }
+        let metadata = this.metadata;
+        let registry = this.registry;
+        if (parentVersion && parentVersion.specVersion !== this.runtimeVersion.specVersion) {
+            const cachedMetadata = this.findMetadataInCache(parentVersion.specVersion);
+            if (cachedMetadata) {
+                metadata = cachedMetadata[0];
+                registry = cachedMetadata[1];
+            }
+            else {
+                metadata = await this.fetchMetadata(parentHash, parentVersion);
+                registry = new PortableRegistry(metadata.latest, this.#hasher || this.options.hasher);
+            }
+        }
+        const api = {
+            rpcVersion: 'v2',
+            atBlockHash: hash,
+            options: this.options,
+            genesisHash: this.genesisHash,
+            runtimeVersion: parentVersion,
+            metadata,
+            registry,
+            rpc: this.rpc,
+        };
+        api.consts = newProxyChain({ executor: new ConstantExecutor(api) });
+        api.events = newProxyChain({ executor: new EventExecutor(api) });
+        api.errors = newProxyChain({ executor: new ErrorExecutor(api) });
+        api.query = newProxyChain({
+            executor: new StorageQueryExecutorV2(api, this.chainHead),
+        });
+        api.call = newProxyChain({ executor: new RuntimeApiExecutorV2(api, this.chainHead) });
+        api.view = newProxyChain({
+            executor: new ViewFunctionExecutorV2(api, this.chainHead),
+        });
+        // @ts-ignore Add queryMulti implementation for at-block queries
+        api.queryMulti = (queries) => {
+            return this.internalQueryMulti(queries, undefined, hash);
+        };
+        this._apiAtCache.set(hash, api);
+        return api;
+    }
+    getStorageQuery() {
+        return new NewStorageQuery(this);
+    }
+    sendTx(tx, callback) {
+        return SubmittableExtrinsicV2.fromTx(this, tx) // --
+            .send((result) => {
+            callback && callback(result);
+        });
+    }
+}

package/client/explorer/LegacyBlockExplorer.d.ts

@@ -0,0 +1,68 @@
+import { BlockHash, Header } from '@dedot/codecs';
+import { HexString } from '@dedot/utils';
+import type { BlockExplorer, BlockInfo } from '../../types.js';
+import type { LegacyClient } from '../LegacyClient.js';
+/**
+ * @name LegacyBlockExplorer
+ * @description Block explorer implementation for LegacyClient using legacy JSON-RPC methods
+ * Optimized to share RPC subscriptions across multiple subscribers using Signal pattern
+ */
+export declare class LegacyBlockExplorer implements BlockExplorer {
+    #private;
+    constructor(client: LegacyClient<any>);
+    /**
+     * Convert PinnedBlock to BlockInfo format
+     */
+    private toBlockInfo;
+    /**
+     * Fill missing blocks when a gap is detected
+     * Fetches and emits all missing blocks between lastNumber and currentNumber
+     */
+    private fillMissingBlocks;
+    /**
+     * Start the shared best block subscription if not already active
+     */
+    private ensureBestBlockSubscription;
+    private hasNewRuntime;
+    /**
+     * Start the shared finalized block subscription if not already active
+     */
+    private ensureFinalizedBlockSubscription;
+    /**
+     * Clean up best block subscription when no more listeners
+     */
+    private cleanupBestBlockSubscription;
+    /**
+     * Clean up finalized block subscription when no more listeners
+     */
+    private cleanupFinalizedBlockSubscription;
+    private calculateBlockHash;
+    /**
+     * Get the best block
+     */
+    best(): Promise<BlockInfo>;
+    /**
+     * Subscribe to the best block
+     * Multiple subscribers will share a single RPC subscription
+     * New subscribers immediately receive the current best block if available
+     */
+    best(callback: (block: BlockInfo) => void): () => void;
+    /**
+     * Get the finalized block
+     */
+    finalized(): Promise<BlockInfo>;
+    /**
+     * Subscribe to the finalized block
+     * Multiple subscribers will share a single RPC subscription
+     * New subscribers immediately receive the current finalized block if available
+     */
+    finalized(callback: (block: BlockInfo) => void): () => void;
+    /**
+     * Get the header of a block by number or hash
+     */
+    header(hash: BlockHash): Promise<Header>;
+    /**
+     * Get the body (transactions) of a block by number or hash
+     */
+    body(hash: BlockHash): Promise<HexString[]>;
+}

package/client/explorer/LegacyBlockExplorer.js

@@ -0,0 +1,259 @@
+import { $Header } from '@dedot/codecs';
+import { assert, AsyncQueue, noop, Signal } from '@dedot/utils';
+/**
+ * @name LegacyBlockExplorer
+ * @description Block explorer implementation for LegacyClient using legacy JSON-RPC methods
+ * Optimized to share RPC subscriptions across multiple subscribers using Signal pattern
+ */
+export class LegacyBlockExplorer {
+    #client;
+    // Signals for block subscriptions
+    #bestBlockSignal;
+    #finalizedBlockSignal;
+    // Track RPC subscription cleanup functions
+    #bestBlockUnsub;
+    #finalizedBlockUnsub;
+    constructor(client) {
+        this.#client = client;
+        this.#bestBlockSignal = new Signal();
+        this.#finalizedBlockSignal = new Signal();
+    }
+    /**
+     * Convert PinnedBlock to BlockInfo format
+     */
+    toBlockInfo(header) {
+        return {
+            hash: header.hash || this.calculateBlockHash(header),
+            number: header.number,
+            parent: header.parentHash,
+            runtimeUpgraded: this.hasNewRuntime(header),
+        };
+    }
+    /**
+     * Fill missing blocks when a gap is detected
+     * Fetches and emits all missing blocks between lastNumber and currentNumber
+     */
+    async fillMissingBlocks(lastNumber, currentNumber, subject, blockType) {
+        // No gap if no previous block or current is next sequential block
+        if (lastNumber === undefined || currentNumber <= lastNumber + 1) {
+            return;
+        }
+        // Gap detected - backfill missing blocks
+        const gapSize = currentNumber - lastNumber - 1;
+        // Create list of missing block numbers
+        const missingNums = Array.from({ length: gapSize }, (_, i) => lastNumber + 1 + i);
+        try {
+            // Fetch all hashes in parallel
+            const hashes = await Promise.all(missingNums.map((num) => this.#client.rpc.chain_getBlockHash(num)));
+            // Fetch all headers in parallel
+            const headers = await Promise.all(hashes.map((hash) => this.#client.rpc.chain_getHeader(hash)));
+            // Emit blocks in order
+            for (let i = 0; i < missingNums.length; i++) {
+                const hash = hashes[i];
+                const header = headers[i];
+                if (hash && header) {
+                    subject.next(this.toBlockInfo({ ...header, hash }));
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Failed to backfill missing ${blockType} blocks:`, error);
+            // Continue despite backfill failure
+        }
+    }
+    /**
+     * Start the shared best block subscription if not already active
+     */
+    ensureBestBlockSubscription() {
+        if (this.#bestBlockUnsub) {
+            // Subscription already active
+            return;
+        }
+        // Use closure pattern to handle async subscription without race conditions
+        let done = false;
+        let unsub;
+        const blockQueue = new AsyncQueue();
+        // Start RPC subscription (non-blocking)
+        this.#client.rpc
+            .chain_subscribeNewHeads((header) => {
+            if (done) {
+                // Unsubscribe was called before subscription completed
+                unsub && unsub();
+                return;
+            }
+            // Enqueue block processing to ensure sequential handling
+            blockQueue
+                .enqueue(async () => {
+                const currentHash = this.calculateBlockHash(header);
+                // Detect gaps in best block stream (due to reconnection)
+                const { number: lastNumber, hash: lastHash } = this.#bestBlockSignal.value || {};
+                if (lastHash === currentHash) {
+                    return;
+                }
+                // Fill missing blocks if gap detected
+                await this.fillMissingBlocks(lastNumber, header.number, this.#bestBlockSignal, 'best');
+                // Emit current block
+                const blockInfo = this.toBlockInfo({ ...header, hash: currentHash });
+                this.#bestBlockSignal.next(blockInfo);
+            })
+                .catch((error) => {
+                console.error('Error processing best block:', error);
+            });
+        })
+            .then((rpcUnsub) => {
+            unsub = rpcUnsub;
+        });
+        // Immediately set unsub wrapper to prevent race conditions
+        this.#bestBlockUnsub = () => {
+            done = true;
+            blockQueue.cancel();
+            unsub && unsub().catch(noop);
+        };
+    }
+    hasNewRuntime(header) {
+        return header.digest.logs.some((log) => log.type === 'RuntimeEnvironmentUpdated');
+    }
+    /**
+     * Start the shared finalized block subscription if not already active
+     */
+    ensureFinalizedBlockSubscription() {
+        if (this.#finalizedBlockUnsub) {
+            // Subscription already active
+            return;
+        }
+        // Use closure pattern to handle async subscription without race conditions
+        let done = false;
+        let unsub;
+        const blockQueue = new AsyncQueue();
+        // Start RPC subscription (non-blocking)
+        this.#client.rpc
+            .chain_subscribeFinalizedHeads((header) => {
+            if (done) {
+                // Unsubscribe was called before subscription completed
+                unsub && unsub();
+                return;
+            }
+            // Enqueue block processing to ensure sequential handling
+            blockQueue
+                .enqueue(async () => {
+                // Detect gaps in finalized block stream (due to reconnection)
+                const lastNumber = this.#finalizedBlockSignal.value?.number;
+                if (lastNumber === header.number) {
+                    return;
+                }
+                // Fill missing blocks if gap detected
+                await this.fillMissingBlocks(lastNumber, header.number, this.#finalizedBlockSignal, 'finalized');
+                // Emit current block
+                const blockInfo = this.toBlockInfo(header);
+                this.#finalizedBlockSignal.next(blockInfo);
+            })
+                .catch((error) => {
+                console.error('Error processing finalized block:', error);
+            });
+        })
+            .then((rpcUnsub) => {
+            unsub = rpcUnsub;
+        });
+        // Immediately set unsub wrapper to prevent race conditions
+        this.#finalizedBlockUnsub = () => {
+            done = true;
+            blockQueue.cancel();
+            unsub && unsub().catch(noop);
+        };
+    }
+    /**
+     * Clean up best block subscription when no more listeners
+     */
+    cleanupBestBlockSubscription() {
+        if (this.#bestBlockSignal.listenerCount === 0 && this.#bestBlockUnsub) {
+            this.#bestBlockUnsub();
+            this.#bestBlockUnsub = undefined;
+        }
+    }
+    /**
+     * Clean up finalized block subscription when no more listeners
+     */
+    cleanupFinalizedBlockSubscription() {
+        if (this.#finalizedBlockSignal.listenerCount === 0 && this.#finalizedBlockUnsub) {
+            this.#finalizedBlockUnsub();
+            this.#finalizedBlockUnsub = undefined;
+        }
+    }
+    calculateBlockHash(header) {
+        return this.#client.registry.hashAsHex($Header.tryEncode(header));
+    }
+    best(callback) {
+        if (callback) {
+            // Subscribe mode - use shared subscription
+            // Ensure RPC subscription is active (creates on first listener)
+            this.ensureBestBlockSubscription();
+            // Subscribe to subject (automatically emits current value if available)
+            const unsub = this.#bestBlockSignal.subscribe(callback);
+            // Return cleanup function
+            return () => {
+                unsub();
+                this.cleanupBestBlockSubscription();
+            };
+        }
+        else {
+            // One-time query - return cached value if available
+            if (this.#bestBlockSignal.value) {
+                return Promise.resolve(this.#bestBlockSignal.value);
+            }
+            // Fallback to RPC call if no cached value
+            return this.#client.rpc.chain_getHeader().then(async (header) => {
+                assert(header, 'Header not found');
+                return {
+                    hash: this.calculateBlockHash(header),
+                    number: header.number,
+                    parent: header.parentHash,
+                };
+            });
+        }
+    }
+    finalized(callback) {
+        if (callback) {
+            // Subscribe mode - use shared subscription
+            // Ensure RPC subscription is active (creates on first listener)
+            this.ensureFinalizedBlockSubscription();
+            // Subscribe to subject (automatically emits current value if available)
+            const unsub = this.#finalizedBlockSignal.subscribe(callback);
+            // Return cleanup function
+            return () => {
+                unsub();
+                this.cleanupFinalizedBlockSubscription();
+            };
+        }
+        else {
+            // One-time query - return cached value if available
+            if (this.#finalizedBlockSignal.value) {
+                return Promise.resolve(this.#finalizedBlockSignal.value);
+            }
+            // Fallback to RPC call if no cached value
+            return this.#client.rpc.chain_getFinalizedHead().then(async (hash) => {
+                const header = await this.header(hash);
+                return {
+                    hash,
+                    number: header.number,
+                    parent: header.parentHash,
+                };
+            });
+        }
+    }
+    /**
+     * Get the header of a block by number or hash
+     */
+    async header(hash) {
+        const header = await this.#client.rpc.chain_getHeader(hash);
+        assert(header, `Header not found for block ${hash}`);
+        return header;
+    }
+    /**
+     * Get the body (transactions) of a block by number or hash
+     */
+    async body(hash) {
+        const block = await this.#client.rpc.chain_getBlock(hash);
+        assert(block, `Block not found for ${hash}`);
+        return block.block.extrinsics;
+    }
+}

package/client/explorer/V2BlockExplorer.d.ts

@@ -0,0 +1,40 @@
+import { BlockHash, Header } from '@dedot/codecs';
+import { HexString } from '@dedot/utils';
+import type { BlockExplorer, BlockInfo } from '../../types.js';
+import type { V2Client } from '../V2Client.js';
+/**
+ * @name V2BlockExplorer
+ * @description Block explorer implementation for V2Client using JSON-RPC v2 (ChainHead API)
+ */
+export declare class V2BlockExplorer implements BlockExplorer {
+    #private;
+    constructor(client: V2Client<any>);
+    /**
+     * Convert PinnedBlock to BlockInfo format
+     */
+    private toBlockInfo;
+    /**
+     * Get the best block
+     */
+    best(): Promise<BlockInfo>;
+    /**
+     * Subscribe to the best block
+     */
+    best(callback: (block: BlockInfo) => void): () => void;
+    /**
+     * Get the finalized block
+     */
+    finalized(): Promise<BlockInfo>;
+    /**
+     * Subscribe to the finalized block
+     */
+    finalized(callback: (block: BlockInfo) => void): () => void;
+    /**
+     * Get the header of a block by number or hash
+     */
+    header(hash: BlockHash): Promise<Header>;
+    /**
+     * Get the body (transactions) of a block by number or hash
+     */
+    body(hash: BlockHash): Promise<HexString[]>;
+}