@acala-network/chopsticks-core 0.8.4 → 0.8.5-1

package/lib/chopsticks-provider.js

@@ -1,249 +1,169 @@
 "use strict";
-// import { EventEmitter } from 'eventemitter3'
-// import {
-//   ProviderInterface,
-//   ProviderInterfaceCallback,
-//   ProviderInterfaceEmitCb,
-//   ProviderInterfaceEmitted,
-//   ProviderStats,
-// } from '@polkadot/rpc-provider/types'
-// import { StorageValues } from './utils'
-// import { defaultLogger } from './logger'
-// const logger = defaultLogger.child({ name: '[Chopsticks provider]' })
-// interface SubscriptionHandler {
-//   callback: ProviderInterfaceCallback
-//   type: string
-// }
-// interface Subscription extends SubscriptionHandler {
-//   method: string
-//   params: unknown[]
-//   onCancel?: () => void
-//   result?: unknown
-// }
-// interface Handler {
-//   callback: ProviderInterfaceCallback
-//   method: string
-//   params: unknown[]
-//   start: number
-//   subscription?: SubscriptionHandler | undefined
-// }
-// export interface ChopsticksProviderProps {
-//   /** upstream endpoint */
-//   endpoint: string
-//   /** default to latest block */
-//   blockHash?: string
-//   dbPath?: string
-//   storageValues?: StorageValues
-// }
-// /**
-//  * A provider for ApiPromise.
-//  *
-//  * Currectly only support browser environment.
-//  */
-// export class ChopsticksProvider implements ProviderInterface {
-//   #isConnected = false
-//   #eventemitter: EventEmitter
-//   #isReadyPromise: Promise<void>
-//   #endpoint: string
-//   readonly stats?: ProviderStats
-//   #subscriptions: Record<string, Subscription> = {}
-//   #worker: Worker
-//   #blockHash: string | undefined
-//   #dbPath: string | undefined
-//   #storageValues: StorageValues | undefined
-//   #handlers: Record<string, Handler> = {}
-//   #idCounter = 0
-//   constructor({ endpoint, blockHash, dbPath, storageValues }: ChopsticksProviderProps) {
-//     if (!endpoint) {
-//       throw new Error('ChopsticksProvider requires the upstream endpoint')
-//     }
-//     this.#endpoint = endpoint
-//     this.#blockHash = blockHash
-//     this.#dbPath = dbPath
-//     this.#storageValues = storageValues
-//     this.#eventemitter = new EventEmitter()
-//     this.#isReadyPromise = new Promise((resolve, reject): void => {
-//       this.#eventemitter.once('connected', (): void => {
-//         logger.debug('isReadyPromise: connected.')
-//         resolve()
-//       })
-//       this.#eventemitter.once('error', reject)
-//     })
-//     const chopsticksWorker = new Worker(new URL('./chopsticks-worker', import.meta.url), { type: 'module' })
-//     this.#worker = chopsticksWorker
-//     this.connect()
-//   }
-//   get hasSubscriptions(): boolean {
-//     return true
-//   }
-//   get isClonable(): boolean {
-//     return true
-//   }
-//   get isConnected(): boolean {
-//     return this.#isConnected
-//   }
-//   get isReady(): Promise<void> {
-//     return this.#isReadyPromise
-//   }
-//   clone = (): ProviderInterface => {
-//     return new ChopsticksProvider({ endpoint: this.#endpoint })
-//   }
-//   connect = async (): Promise<void> => {
-//     if (this.#isConnected) {
-//       return
-//     }
-//     this.#worker!.onmessage = this.#onWorkerMessage
-//     this.#worker?.postMessage({
-//       type: 'connect',
-//       endpoint: this.#endpoint,
-//       blockHash: this.#blockHash,
-//       dbPath: this.#dbPath,
-//       storageValues: this.#storageValues,
-//     })
-//   }
-//   disconnect = async (): Promise<void> => {
-//     this.#worker?.postMessage({ type: 'disconnect' })
-//     this.#isConnected = false
-//     this.#eventemitter.emit('disconnected')
-//   }
-//   on = (type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): (() => void) => {
-//     this.#eventemitter.on(type, sub)
-//     return (): void => {
-//       this.#eventemitter.removeListener(type, sub)
-//     }
-//   }
-//   send = async <T>(
-//     method: string,
-//     params: unknown[],
-//     _isCacheable?: boolean,
-//     subscription?: SubscriptionHandler,
-//   ): Promise<T> => {
-//     return new Promise<T>((resolve, reject): void => {
-//       try {
-//         if (!this.isConnected || this.#worker === undefined) {
-//           throw new Error('Api is not connected')
-//         }
-//         logger.debug('send', { method, params })
-//         const id = `${method}::${this.#idCounter++}`
-//         const callback = (error?: Error | null, result?: T): void => {
-//           if (subscription) {
-//             // if it's a subscription, we usually returns the subid
-//             const subid = result as string
-//             if (subid) {
-//               if (!this.#subscriptions[subid]) {
-//                 this.#subscriptions[subid] = {
-//                   callback: subscription.callback,
-//                   method,
-//                   params,
-//                   type: subscription.type,
-//                 }
-//               }
-//             }
-//           }
-//           error ? reject(error) : resolve(result as T)
-//         }
-//         this.#handlers[id] = {
-//           callback,
-//           method,
-//           params,
-//           start: Date.now(),
-//           subscription,
-//         }
-//         this.#worker?.postMessage({
-//           type: 'send',
-//           id,
-//           method,
-//           params,
-//         })
-//       } catch (error) {
-//         reject(error)
-//       }
-//     })
-//   }
-//   subscribe(
-//     type: string,
-//     method: string,
-//     params: unknown[],
-//     callback: ProviderInterfaceCallback,
-//   ): Promise<number | string> {
-//     return this.send<string | number>(method, params, false, { callback, type })
-//   }
-//   async unsubscribe(_type: string, method: string, id: number | string): Promise<boolean> {
-//     if (!this.#subscriptions[id]) {
-//       logger.error(`Unable to find active subscription=${id}`)
-//       return false
-//     }
-//     try {
-//       return this.isConnected ? this.send<boolean>(method, [id]) : true
-//     } catch {
-//       return false
-//     }
-//   }
-//   #onWorkerMessage = (e: any) => {
-//     switch (e.data.type) {
-//       case 'connection':
-//         logger.debug('connection.', e.data)
-//         if (e.data.connected) {
-//           this.#isConnected = true
-//           this.#eventemitter.emit('connected')
-//         } else {
-//           this.#isConnected = false
-//           this.#eventemitter.emit('error', new Error('Unable to connect to the chain'))
-//           logger.error(`Unable to connect to the chain: ${e.data.message}`)
-//         }
-//         break
-//       case 'subscribe-callback':
-//         {
-//           logger.debug('subscribe-callback', e.data)
-//           const sub = this.#subscriptions[e.data.subid]
-//           if (!sub) {
-//             // record it first, sometimes callback comes first
-//             this.#subscriptions[e.data.subid] = {
-//               callback: () => {},
-//               method: e.data.method,
-//               params: e.data.params,
-//               type: e.data.type,
-//               result: JSON.parse(e.data.result),
-//             }
-//             return
-//           }
-//           sub.callback(null, JSON.parse(e.data.result))
-//         }
-//         break
-//       case 'unsubscribe-callback':
-//         {
-//           logger.debug('unsubscribe-callback', e.data)
-//           const sub = this.#subscriptions[e.data.subid]
-//           if (!sub) {
-//             logger.error(`Unable to find active subscription=${e.data.subid}`)
-//             return
-//           }
-//           sub?.onCancel?.()
-//           delete this.#subscriptions[e.data.subid]
-//         }
-//         break
-//       case 'send-result':
-//         {
-//           const handler = this.#handlers[e.data.id]
-//           if (!handler) {
-//             logger.error(`Unable to find handler=${e.data.id}`)
-//             return
-//           }
-//           logger.debug('send-result', {
-//             method: e.data.method,
-//             result: JSON.parse(e.data.result || '{}'),
-//             data: e.data,
-//           })
-//           try {
-//             handler.callback(null, e.data.result ? JSON.parse(e.data.result) : undefined)
-//           } catch (error) {
-//             handler.callback(error as Error, undefined)
-//           }
-//           delete this.#handlers[e.data.id]
-//         }
-//         break
-//       default:
-//         break
-//     }
-//   }
-// }
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChopsticksProvider = void 0;
+const eventemitter3_1 = require("eventemitter3");
+const rpc_1 = require("./rpc");
+const logger_1 = require("./logger");
+const setup_1 = require("./setup");
+const providerHandlers = Object.assign(Object.assign({}, rpc_1.allHandlers), { dev_newBlock: (context, _params, _subscriptionManager) => __awaiter(void 0, void 0, void 0, function* () {
+        const block = yield context.chain.newBlock();
+        return block.hash;
+    }) });
+const logger = logger_1.defaultLogger.child({ name: '[Chopsticks provider]' });
+/**
+ * Provider for local chopsticks chain
+ */
+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 = () => __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _ChopsticksProvider_isConnected, true, "f");
+            __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").emit('connected');
+        });
+        this.disconnect = () => __awaiter(this, void 0, void 0, function* () {
+            __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) => {
+                var _b;
+                logger.debug('unsubscribe-callback', subid);
+                const sub = __classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[subid];
+                if (sub) {
+                    (_b = sub.onCancel) === null || _b === void 0 ? void 0 : _b.call(sub);
+                    delete __classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[subid];
+                }
+                else {
+                    logger.trace(`Unable to find active subscription=${subid}`);
+                }
+            },
+        };
+        this.send = (method, params, _isCacheable, subscription) => __awaiter(this, void 0, void 0, function* () {
+            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 = yield 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 eventemitter3_1.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 });
+    }
+    unsubscribe(_type, method, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[id]) {
+                logger.trace(`Unable to find active subscription=${id}`);
+                return false;
+            }
+            try {
+                return this.send(method, [id]);
+            }
+            catch (_b) {
+                return false;
+            }
+        });
+    }
+}
+exports.ChopsticksProvider = ChopsticksProvider;
+_a = ChopsticksProvider, _ChopsticksProvider_isConnected = new WeakMap(), _ChopsticksProvider_eventemitter = new WeakMap(), _ChopsticksProvider_isReadyPromise = new WeakMap(), _ChopsticksProvider_subscriptions = new WeakMap();
+ChopsticksProvider.fromEndpoint = (endpoint, block, db) => __awaiter(void 0, void 0, void 0, function* () {
+    return new ChopsticksProvider(yield (0, setup_1.setup)({
+        endpoint,
+        mockSignatureHost: true,
+        block,
+        db,
+    }));
+});

package/lib/database.d.ts

@@ -0,0 +1,26 @@
+import { HexString } from '@polkadot/util/types';
+export interface BlockEntry {
+    hash: HexString;
+    number: number;
+    header: HexString;
+    parentHash: HexString | null;
+    extrinsics: HexString[];
+    storageDiff: Record<HexString, HexString | null> | null;
+}
+export interface KeyValueEntry {
+    blockHash: string;
+    key: string;
+    value: string | null;
+}
+export declare class Database {
+    constructor(location: string);
+    close: () => Promise<void>;
+    saveBlock: (block: BlockEntry) => Promise<void>;
+    queryBlock: (hash: HexString) => Promise<BlockEntry | null>;
+    queryBlockByNumber: (number: number) => Promise<BlockEntry | null>;
+    queryHighestBlock: () => Promise<BlockEntry | null>;
+    deleteBlock: (hash: HexString) => Promise<void>;
+    blocksCount: () => Promise<number>;
+    saveStorage: (blockHash: HexString, key: HexString, value: HexString | null) => Promise<void>;
+    queryStorage: (blockHash: HexString, key: HexString) => Promise<KeyValueEntry | null>;
+}

package/lib/database.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/genesis-provider.d.ts

@@ -6,7 +6,6 @@ export declare class GenesisProvider implements ProviderInterface {
     #private;
     readonly stats?: ProviderStats;
     constructor(genesis: Genesis);
-    static fromUrl: (url: string) => Promise<GenesisProvider>;
     get isClonable(): boolean;
     clone: () => ProviderInterface;
     get hasSubscriptions(): boolean;

package/lib/genesis-provider.js

@@ -1,27 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -42,17 +19,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _a, _GenesisProvider_isConnected, _GenesisProvider_eventemitter, _GenesisProvider_isReadyPromise, _GenesisProvider_genesis, _GenesisProvider_stateRoot;
+var _GenesisProvider_isConnected, _GenesisProvider_eventemitter, _GenesisProvider_isReadyPromise, _GenesisProvider_genesis, _GenesisProvider_stateRoot;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenesisProvider = void 0;
 const eventemitter3_1 = require("eventemitter3");
-const axios_1 = __importDefault(require("axios"));
 const schema_1 = require("./schema");
 const wasm_executor_1 = require("./wasm-executor");
-const utils_1 = require("./utils");
 class GenesisProvider {
     constructor(genesis) {
         _GenesisProvider_isConnected.set(this, false);
@@ -126,7 +98,7 @@ class GenesisProvider {
         this.unsubscribe = (_type, _method, _id) => __awaiter(this, void 0, void 0, function* () {
             throw Error('unimplemented');
         });
-        __classPrivateFieldSet(this, _GenesisProvider_genesis, genesis, "f");
+        __classPrivateFieldSet(this, _GenesisProvider_genesis, schema_1.genesisSchema.parse(genesis), "f");
         __classPrivateFieldSet(this, _GenesisProvider_stateRoot, (0, wasm_executor_1.calculateStateRoot)(Object.entries(__classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top).reduce((accu, item) => {
             accu.push(item);
             return accu;
@@ -137,6 +109,7 @@ class GenesisProvider {
                 resolve();
             });
             __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").once('error', reject);
+            this.connect();
         }), "f");
     }
     get isClonable() {
@@ -149,7 +122,6 @@ class GenesisProvider {
         return __classPrivateFieldGet(this, _GenesisProvider_isConnected, "f");
     }
     get isReady() {
-        this.connect();
         return __classPrivateFieldGet(this, _GenesisProvider_isReadyPromise, "f");
     }
     get blockHash() {
@@ -173,19 +145,4 @@ class GenesisProvider {
     }
 }
 exports.GenesisProvider = GenesisProvider;
-_a = GenesisProvider, _GenesisProvider_isConnected = new WeakMap(), _GenesisProvider_eventemitter = new WeakMap(), _GenesisProvider_isReadyPromise = new WeakMap(), _GenesisProvider_genesis = new WeakMap(), _GenesisProvider_stateRoot = new WeakMap();
-GenesisProvider.fromUrl = (url) => __awaiter(void 0, void 0, void 0, function* () {
-    const getFile = (url) => __awaiter(void 0, void 0, void 0, function* () {
-        if ((0, utils_1.isUrl)(url)) {
-            return axios_1.default.get(url).then((x) => x.data);
-        }
-        else if (typeof process === 'object') {
-            const { lstatSync, readFileSync } = yield Promise.resolve().then(() => __importStar(require('node:fs')));
-            if (lstatSync(url).isFile()) {
-                return JSON.parse(String(readFileSync(url)));
-            }
-        }
-        throw Error(`invalid genesis path or url ${url}`);
-    });
-    return new GenesisProvider(schema_1.genesisSchema.parse(yield getFile(url)));
-});
+_GenesisProvider_isConnected = new WeakMap(), _GenesisProvider_eventemitter = new WeakMap(), _GenesisProvider_isReadyPromise = new WeakMap(), _GenesisProvider_genesis = new WeakMap(), _GenesisProvider_stateRoot = new WeakMap();

package/lib/index.d.ts

@@ -19,7 +19,10 @@ export * from './wasm-executor';
 export * from './schema';
 export * from './xcm';
 export * from './setup';
+export * from './database';
 export * from './blockchain/inherent';
 export * from './logger';
 export * from './offchain';
+export * from './chopsticks-provider';
+export * from './genesis-provider';
 export * from './rpc';

package/lib/index.js

@@ -35,8 +35,10 @@ __exportStar(require("./wasm-executor"), exports);
 __exportStar(require("./schema"), exports);
 __exportStar(require("./xcm"), exports);
 __exportStar(require("./setup"), exports);
+__exportStar(require("./database"), exports);
 __exportStar(require("./blockchain/inherent"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./offchain"), exports);
-// export * from './chopsticks-provider'
+__exportStar(require("./chopsticks-provider"), exports);
+__exportStar(require("./genesis-provider"), exports);
 __exportStar(require("./rpc"), exports);

package/lib/rpc/substrate/author.js

@@ -66,9 +66,12 @@ const author_submitAndWatchExtrinsic = (context, [extrinsic], { subscribe, unsub
     });
     try {
         yield context.chain.submitExtrinsic(extrinsic);
-        callback({
-            ready: null,
-        });
+        // send callback after subscription id is returned
+        setTimeout(() => {
+            callback({
+                ready: null,
+            });
+        }, 50);
     }
     catch (error) {
         logger.error({ error }, 'ExtrinsicFailed');

package/lib/rpc/substrate/chain.js

@@ -78,7 +78,7 @@ const chain_subscribeNewHead = (context, _params, { subscribe }) => __awaiter(vo
     update = () => __awaiter(void 0, void 0, void 0, function* () {
         callback(processHeader(yield context.chain.head.header));
     });
-    update();
+    setTimeout(update, 50);
     return id;
 });
 exports.chain_subscribeNewHead = chain_subscribeNewHead;
@@ -89,7 +89,7 @@ const chain_subscribeFinalizedHeads = (context, _params, { subscribe }) => __awa
     update = () => __awaiter(void 0, void 0, void 0, function* () {
         callback(processHeader(yield context.chain.head.header));
     });
-    update();
+    setTimeout(update, 50);
     return id;
 });
 exports.chain_subscribeFinalizedHeads = chain_subscribeFinalizedHeads;