@acala-network/chopsticks-core 0.8.5-5 → 0.9.0

package/dist/esm/chopsticks-provider.js

@@ -0,0 +1,156 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _ChopsticksProvider_isConnected, _ChopsticksProvider_eventemitter, _ChopsticksProvider_isReadyPromise, _ChopsticksProvider_subscriptions;
+import { EventEmitter } from 'eventemitter3';
+import { allHandlers } from './rpc';
+import { defaultLogger } from './logger';
+import { setup } from './setup';
+const providerHandlers = {
+    ...allHandlers,
+    dev_newBlock: async (context, _params, _subscriptionManager) => {
+        const block = await context.chain.newBlock();
+        return block.hash;
+    },
+};
+const logger = defaultLogger.child({ name: '[Chopsticks provider]' });
+/**
+ * Provider for local chopsticks chain
+ */
+export class ChopsticksProvider {
+    constructor(chain) {
+        this.chain = chain;
+        _ChopsticksProvider_isConnected.set(this, false);
+        _ChopsticksProvider_eventemitter.set(this, void 0);
+        _ChopsticksProvider_isReadyPromise.set(this, void 0);
+        _ChopsticksProvider_subscriptions.set(this, {});
+        this.clone = () => {
+            return new ChopsticksProvider(this.chain);
+        };
+        this.connect = async () => {
+            __classPrivateFieldSet(this, _ChopsticksProvider_isConnected, true, "f");
+            __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").emit('connected');
+        };
+        this.disconnect = async () => {
+            __classPrivateFieldSet(this, _ChopsticksProvider_isConnected, false, "f");
+            __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").emit('disconnected');
+        };
+        this.on = (type, sub) => {
+            __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").on(type, sub);
+            return () => {
+                __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").removeListener(type, sub);
+            };
+        };
+        this.subscriptionManager = {
+            subscribe: (method, subid, onCancel = () => { }) => {
+                const sub = __classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[subid];
+                if (sub) {
+                    sub.onCancel = onCancel;
+                }
+                return (data) => {
+                    logger.debug('subscribe-callback', method, subid, data);
+                    const sub = __classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[subid];
+                    if (sub) {
+                        sub.callback(null, data);
+                    }
+                    else {
+                        logger.trace(`Unable to find active subscription=${subid}`);
+                    }
+                };
+            },
+            unsubscribe: (subid) => {
+                logger.debug('unsubscribe-callback', subid);
+                const sub = __classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[subid];
+                if (sub) {
+                    sub.onCancel?.();
+                    delete __classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[subid];
+                }
+                else {
+                    logger.trace(`Unable to find active subscription=${subid}`);
+                }
+            },
+        };
+        this.send = async (method, params, _isCacheable, subscription) => {
+            try {
+                logger.debug('send', { method, params });
+                const rpcHandler = providerHandlers[method];
+                if (!rpcHandler) {
+                    logger.error(`Unable to find rpc handler=${method}`);
+                    throw new Error(`Unable to find rpc handler=${method}`);
+                }
+                if (subscription) {
+                    logger.debug('subscribe', { method, params });
+                    const subid = await rpcHandler({ chain: this.chain }, params, this.subscriptionManager);
+                    if (!subid) {
+                        throw new Error(`Unable to subscribe=${method}`);
+                    }
+                    __classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[subid] = {
+                        callback: subscription.callback,
+                        method,
+                        params,
+                        type: subscription.type,
+                    };
+                    return subid;
+                }
+                else {
+                    logger.debug('call', { method, params });
+                    return rpcHandler({ chain: this.chain }, params, this.subscriptionManager);
+                }
+            }
+            catch (e) {
+                logger.error('send error.', e);
+                throw e;
+            }
+        };
+        __classPrivateFieldSet(this, _ChopsticksProvider_eventemitter, new EventEmitter(), "f");
+        __classPrivateFieldSet(this, _ChopsticksProvider_isReadyPromise, new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").once('connected', resolve);
+            __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").once('error', reject);
+            this.connect();
+        }), "f");
+    }
+    get hasSubscriptions() {
+        return true;
+    }
+    get isClonable() {
+        return true;
+    }
+    get isConnected() {
+        return __classPrivateFieldGet(this, _ChopsticksProvider_isConnected, "f");
+    }
+    get isReady() {
+        return __classPrivateFieldGet(this, _ChopsticksProvider_isReadyPromise, "f");
+    }
+    subscribe(type, method, params, callback) {
+        return this.send(method, params, false, { callback, type });
+    }
+    async unsubscribe(_type, method, id) {
+        if (!__classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[id]) {
+            logger.trace(`Unable to find active subscription=${id}`);
+            return false;
+        }
+        try {
+            return this.send(method, [id]);
+        }
+        catch {
+            return false;
+        }
+    }
+}
+_a = ChopsticksProvider, _ChopsticksProvider_isConnected = new WeakMap(), _ChopsticksProvider_eventemitter = new WeakMap(), _ChopsticksProvider_isReadyPromise = new WeakMap(), _ChopsticksProvider_subscriptions = new WeakMap();
+ChopsticksProvider.fromEndpoint = async (endpoint, block, db) => {
+    return new ChopsticksProvider(await setup({
+        endpoint,
+        mockSignatureHost: true,
+        block,
+        db,
+    }));
+};

package/dist/esm/database.js

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

package/dist/esm/genesis-provider.js

@@ -0,0 +1,144 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _GenesisProvider_isConnected, _GenesisProvider_eventemitter, _GenesisProvider_isReadyPromise, _GenesisProvider_genesis, _GenesisProvider_stateRoot;
+import { EventEmitter } from 'eventemitter3';
+import { genesisSchema } from './schema';
+import { calculateStateRoot, emptyTaskHandler } from './wasm-executor';
+/**
+ * Provider to start a chain from genesis
+ */
+export class GenesisProvider {
+    /**
+     * @ignore
+     * Create a genesis provider
+     *
+     * @param genesis - genesis file
+     * @requires genesis provider
+     */
+    constructor(genesis) {
+        _GenesisProvider_isConnected.set(this, false);
+        _GenesisProvider_eventemitter.set(this, void 0);
+        _GenesisProvider_isReadyPromise.set(this, void 0);
+        _GenesisProvider_genesis.set(this, void 0);
+        _GenesisProvider_stateRoot.set(this, void 0);
+        this.clone = () => {
+            return new GenesisProvider(__classPrivateFieldGet(this, _GenesisProvider_genesis, "f"));
+        };
+        this.connect = async () => {
+            __classPrivateFieldSet(this, _GenesisProvider_isConnected, true, "f");
+            __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").emit('connected');
+        };
+        this.disconnect = async () => {
+            __classPrivateFieldSet(this, _GenesisProvider_isConnected, false, "f");
+            __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").emit('disconnected');
+        };
+        this.on = (type, sub) => {
+            __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").on(type, sub);
+            return () => {
+                __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").removeListener(type, sub);
+            };
+        };
+        this.getHeader = async () => {
+            return {
+                blockHash: this.blockHash,
+                number: '0x0',
+                stateRoot: await __classPrivateFieldGet(this, _GenesisProvider_stateRoot, "f"),
+                digest: {
+                    logs: [],
+                },
+            };
+        };
+        this.getBlock = async () => {
+            return {
+                block: {
+                    header: await this.getHeader(),
+                    extrinsics: [],
+                },
+            };
+        };
+        this.send = async (method, params, _isCacheable) => {
+            await this.isReady;
+            switch (method) {
+                case 'system_properties':
+                    return __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").properties;
+                case 'system_chain':
+                    return __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").id;
+                case 'system_name':
+                    return __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").name;
+                case 'chain_getHeader':
+                    return this.getHeader();
+                case 'chain_getBlock':
+                    return this.getBlock();
+                case 'chain_getBlockHash':
+                    return this.blockHash;
+                case 'state_getKeysPaged':
+                case 'state_getKeysPagedAt':
+                    return [];
+                case 'state_getStorage':
+                case 'state_getStorageAt':
+                    return __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top[params[0]];
+                default:
+                    throw Error(`${method} not implemented`);
+            }
+        };
+        this.subscribe = async (_type, _method, _params, _cb) => {
+            throw Error('unimplemented');
+        };
+        this.unsubscribe = async (_type, _method, _id) => {
+            throw Error('unimplemented');
+        };
+        __classPrivateFieldSet(this, _GenesisProvider_genesis, genesisSchema.parse(genesis), "f");
+        __classPrivateFieldSet(this, _GenesisProvider_stateRoot, calculateStateRoot(Object.entries(__classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top).reduce((accu, item) => {
+            accu.push(item);
+            return accu;
+        }, []), 1), "f");
+        __classPrivateFieldSet(this, _GenesisProvider_eventemitter, new EventEmitter(), "f");
+        __classPrivateFieldSet(this, _GenesisProvider_isReadyPromise, new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").once('connected', () => {
+                resolve();
+            });
+            __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").once('error', reject);
+            this.connect();
+        }), "f");
+    }
+    get isClonable() {
+        return true;
+    }
+    get hasSubscriptions() {
+        return false;
+    }
+    get isConnected() {
+        return __classPrivateFieldGet(this, _GenesisProvider_isConnected, "f");
+    }
+    get isReady() {
+        return __classPrivateFieldGet(this, _GenesisProvider_isReadyPromise, "f");
+    }
+    get blockHash() {
+        return '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3';
+    }
+    get _jsCallback() {
+        const storage = __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top;
+        return {
+            ...emptyTaskHandler,
+            getStorage: async function (key) {
+                return storage[key];
+            },
+            getStateRoot: async function () {
+                return '0x49416764844ff0d8bad851e8abe686dff9dd2de78621180ef8e9f99bb7a480f1';
+            },
+            getNextKey: async function (_prefix, _key) {
+                return undefined;
+            },
+        };
+    }
+}
+_GenesisProvider_isConnected = new WeakMap(), _GenesisProvider_eventemitter = new WeakMap(), _GenesisProvider_isReadyPromise = new WeakMap(), _GenesisProvider_genesis = new WeakMap(), _GenesisProvider_stateRoot = new WeakMap();

package/dist/esm/logger.js

@@ -0,0 +1,34 @@
+import createLogger from 'pino';
+export const defaultLogger = createLogger({
+    level: (typeof process === 'object' && process.env.LOG_LEVEL) || 'info',
+    transport: {
+        target: 'pino-pretty',
+    },
+});
+const innerTruncate = (level = 0) => (val) => {
+    const verboseLog = typeof process === 'object' ? !!process.env.VERBOSE_LOG : false;
+    const levelLimit = verboseLog ? 10 : 5;
+    if (val == null) {
+        return val;
+    }
+    if (level > levelLimit) {
+        return '( Too Deep )';
+    }
+    switch (typeof val) {
+        case 'string':
+            if (val.length > 66 && !verboseLog) {
+                return val.slice(0, 34) + '…' + val.slice(-32);
+            }
+            else {
+                return val;
+            }
+        case 'object':
+            if (Array.isArray(val)) {
+                return val.map(innerTruncate(level + 1));
+            }
+            return Object.fromEntries(Object.entries(val.toJSON ? val.toJSON() : val).map(([k, v]) => [k, innerTruncate(level + 1)(v)]));
+        default:
+            return val;
+    }
+};
+export const truncate = (val) => innerTruncate(0)(val);

package/dist/esm/offchain.js

@@ -0,0 +1,36 @@
+import { blake2AsHex } from '@polkadot/util-crypto';
+import { defaultLogger } from './logger';
+import { queueScheduler } from 'rxjs';
+const logger = defaultLogger.child({ name: 'offchain' });
+export class OffchainWorker {
+    constructor() {
+        this.pendingExtrinsics = [];
+        this.offchainStorage = new Map();
+    }
+    get(key) {
+        return this.offchainStorage.get(key);
+    }
+    set(key, value) {
+        this.offchainStorage.set(key, value);
+    }
+    async run(block) {
+        logger.info({ number: block.number, hash: block.hash }, `Run Offchain Worker for block #${block.number.toLocaleString()}`);
+        const header = await block.header;
+        await block.call('OffchainWorkerApi_offchain_worker', [header.toHex()]);
+        logger.info(`Offchain Worker complete for block #${block.number.toLocaleString()}`);
+        const txs = this.pendingExtrinsics.splice(0);
+        if (txs.length > 0) {
+            queueScheduler.schedule(async (transactions) => {
+                await block.chain.txPool.buildBlock({ transactions });
+            }, 100, txs);
+        }
+    }
+    async pushExtrinsic(block, extrinsic) {
+        const validity = await block.chain.validateExtrinsic(extrinsic, '0x01');
+        if (validity.isOk) {
+            this.pendingExtrinsics.push(extrinsic);
+            return blake2AsHex(extrinsic, 256);
+        }
+        throw validity.asErr;
+    }
+}

package/dist/esm/rpc/index.js

@@ -0,0 +1,10 @@
+import substrate from './substrate';
+export const allHandlers = {
+    ...substrate,
+    rpc_methods: async () => Promise.resolve({
+        version: 1,
+        methods: [...Object.keys(allHandlers)],
+    }),
+};
+export { default as substrate } from './substrate';
+export { ResponseError } from './shared';

package/dist/esm/rpc/shared.js

@@ -0,0 +1,15 @@
+import { defaultLogger } from '../logger';
+export const logger = defaultLogger.child({ name: 'rpc' });
+export class ResponseError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = 'ResponseError';
+        this.code = code;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            message: this.message,
+        };
+    }
+}

package/dist/esm/rpc/substrate/author.js

@@ -0,0 +1,85 @@
+import { APPLY_EXTRINSIC_ERROR } from '../../blockchain/txpool';
+import { ResponseError } from '../shared';
+import { defaultLogger } from '../../logger';
+const logger = defaultLogger.child({ name: 'rpc-author' });
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return Hash
+ */
+export const author_submitExtrinsic = async (context, [extrinsic]) => {
+    return context.chain.submitExtrinsic(extrinsic).catch((error) => {
+        const code = error.isInvalid ? 1010 : 1011;
+        throw new ResponseError(code, error.toString());
+    });
+};
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+export const author_submitAndWatchExtrinsic = async (context, [extrinsic], { subscribe, unsubscribe }) => {
+    let update = (_block) => { };
+    const id = context.chain.headState.subscribeHead((block) => update(block));
+    const callback = subscribe('author_extrinsicUpdate', id, () => context.chain.headState.unsubscribeHead(id));
+    const onExtrinsicFail = ([failedExtrinsic, error]) => {
+        if (failedExtrinsic === extrinsic) {
+            callback(error.toJSON());
+            done(id);
+        }
+    };
+    context.chain.txPool.event.on(APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
+    const done = (id) => {
+        context.chain.txPool.event.removeListener(APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
+        unsubscribe(id);
+    };
+    update = async (block) => {
+        const extrisnics = await block.extrinsics;
+        if (!extrisnics.includes(extrinsic))
+            return;
+        logger.debug({ block: block.hash }, 'author_extrinsicUpdate');
+        callback({
+            inBlock: block.hash,
+        });
+        // wait a bit for InBlock to be sent
+        await new Promise((r) => setTimeout(r, 100));
+        callback({
+            finalized: block.hash,
+        });
+        done(id);
+    };
+    try {
+        await context.chain.submitExtrinsic(extrinsic);
+        // send callback after subscription id is returned
+        setTimeout(() => {
+            callback({
+                ready: null,
+            });
+        }, 50);
+    }
+    catch (error) {
+        logger.error({ error }, 'ExtrinsicFailed');
+        const code = error.isInvalid ? 1010 : 1011;
+        done(id);
+        throw new ResponseError(code, error.toString());
+    }
+    return id;
+};
+/**
+ * @param _context
+ * @param params - [`subid`]
+ */
+export const author_unwatchExtrinsic = async (_context, [subid], { unsubscribe }) => {
+    unsubscribe(subid);
+};
+/**
+ * Get pending extrinsics
+ *
+ * @return Array of pending extrinsics
+ */
+export const author_pendingExtrinsics = async (context) => {
+    return context.chain.txPool.pendingExtrinsics;
+};

package/dist/esm/rpc/substrate/chain.js

@@ -0,0 +1,84 @@
+import { ResponseError } from '../shared';
+const processHeader = (header) => {
+    const res = header.toJSON();
+    res.number = '0x' + res.number.toString(16); // number is hex format
+    return res;
+};
+/**
+ * @param context
+ * @param params - [`blockNumber` | `blockNumber[]` | null]
+ *
+ * @return Block hash | hash[] | null
+ */
+export const chain_getBlockHash = async (context, [blockNumber]) => {
+    const numbers = Array.isArray(blockNumber) ? blockNumber : [blockNumber];
+    const hashes = await Promise.all(numbers.map((n) => context.chain.getBlockAt(n))).then((blocks) => blocks.map((b) => b?.hash || null));
+    return Array.isArray(blockNumber) ? hashes : hashes[0];
+};
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Header - see `@polkadot/types/interfaces`
+ */
+export const chain_getHeader = async (context, [hash]) => {
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        throw new ResponseError(1, `Block ${hash} not found`);
+    }
+    return processHeader(await block.header);
+};
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Block header and extrinsics
+ */
+export const chain_getBlock = async (context, [hash]) => {
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        throw new ResponseError(1, `Block ${hash} not found`);
+    }
+    return {
+        block: {
+            header: processHeader(await block.header),
+            extrinsics: await block.extrinsics,
+        },
+        justifications: null,
+    };
+};
+/**
+ * @param context
+ *
+ * @return head hash
+ */
+export const chain_getFinalizedHead = async (context) => {
+    return context.chain.head.hash;
+};
+export const chain_subscribeNewHead = async (context, _params, { subscribe }) => {
+    let update = () => { };
+    const id = context.chain.headState.subscribeHead(() => update());
+    const callback = subscribe('chain_newHead', id, () => context.chain.headState.unsubscribeHead(id));
+    update = async () => {
+        callback(processHeader(await context.chain.head.header));
+    };
+    setTimeout(update, 50);
+    return id;
+};
+export const chain_subscribeFinalizedHeads = async (context, _params, { subscribe }) => {
+    let update = () => { };
+    const id = context.chain.headState.subscribeHead(() => update());
+    const callback = subscribe('chain_finalizedHead', id, () => context.chain.headState.unsubscribeHead(id));
+    update = async () => {
+        callback(processHeader(await context.chain.head.header));
+    };
+    setTimeout(update, 50);
+    return id;
+};
+export const chain_unsubscribeNewHead = async (_context, [subid], { unsubscribe }) => {
+    unsubscribe(subid);
+};
+export const chain_getHead = chain_getBlockHash;
+export const chain_subscribeNewHeads = chain_subscribeNewHead;
+export const chain_unsubscribeNewHeads = chain_unsubscribeNewHead;
+export const chain_unsubscribeFinalizedHeads = chain_unsubscribeNewHead;

package/dist/esm/rpc/substrate/index.js

@@ -0,0 +1,18 @@
+import * as AuthorRPC from './author';
+import * as ChainRPC from './chain';
+import * as PaymentRPC from './payment';
+import * as StateRPC from './state';
+import * as SystemRPC from './system';
+export { AuthorRPC };
+export { ChainRPC };
+export { PaymentRPC };
+export { StateRPC };
+export { SystemRPC };
+const handlers = {
+    ...AuthorRPC,
+    ...ChainRPC,
+    ...PaymentRPC,
+    ...StateRPC,
+    ...SystemRPC,
+};
+export default handlers;

package/dist/esm/rpc/substrate/payment.js

@@ -0,0 +1,40 @@
+import { hexToU8a } from '@polkadot/util';
+import { ResponseError } from '../shared';
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+export const payment_queryFeeDetails = async (context, [extrinsic, hash]) => {
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        throw new ResponseError(1, `Block ${hash} not found`);
+    }
+    const registry = await block.registry;
+    const tx = hexToU8a(extrinsic);
+    const resp = await block.call('TransactionPaymentApi_query_fee_details', [
+        registry.createType('Extrinsic', tx).toHex(),
+        registry.createType('u32', tx.byteLength).toHex(),
+    ]);
+    return resp.result;
+};
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+export const payment_queryInfo = async (context, [extrinsic, hash]) => {
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        throw new ResponseError(1, `Block ${hash} not found`);
+    }
+    const registry = await block.registry;
+    const tx = hexToU8a(extrinsic);
+    const resp = await block.call('TransactionPaymentApi_query_info', [
+        registry.createType('Extrinsic', tx).toHex(),
+        registry.createType('u32', tx.byteLength).toHex(),
+    ]);
+    return resp.result;
+};