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

package/lib/blockchain/head-state.d.ts

@@ -1,5 +1,5 @@
 import { Block } from './block';
-type Callback = (block: Block, pairs: [string, string][]) => void | Promise<void>;
+type Callback = (block: Block, pairs: [string, string | null][]) => void | Promise<void>;
 export declare const randomId: () => string;
 export declare class HeadState {
     #private;

package/lib/blockchain/head-state.js

@@ -48,7 +48,7 @@ class HeadState {
             const id = (0, exports.randomId)();
             __classPrivateFieldGet(this, _HeadState_storageListeners, "f")[id] = [keys, cb];
             for (const key of keys) {
-                __classPrivateFieldGet(this, _HeadState_oldValues, "f")[key] = yield __classPrivateFieldGet(this, _HeadState_head, "f").get(key);
+                __classPrivateFieldGet(this, _HeadState_oldValues, "f")[key] = yield __classPrivateFieldGet(this, _HeadState_head, "f").get(key).then((val) => val || null);
             }
             return id;
         });
@@ -61,7 +61,7 @@ class HeadState {
             const id = (0, exports.randomId)();
             const codeKey = (0, util_1.stringToHex)(':code');
             __classPrivateFieldGet(this, _HeadState_storageListeners, "f")[id] = [[codeKey], cb];
-            __classPrivateFieldGet(this, _HeadState_oldValues, "f")[codeKey] = yield __classPrivateFieldGet(this, _HeadState_head, "f").get(codeKey);
+            __classPrivateFieldGet(this, _HeadState_oldValues, "f")[codeKey] = yield __classPrivateFieldGet(this, _HeadState_head, "f").get(codeKey).then((val) => val || null);
             return id;
         });
     }

package/lib/blockchain/index.js

@@ -452,6 +452,7 @@ class Blockchain {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             yield (0, wasm_executor_1.releaseWorker)();
+            yield this.api.disconnect();
             yield ((_a = this.db) === null || _a === void 0 ? void 0 : _a.destroy());
         });
     }

package/lib/chopsticks-provider.d.ts

@@ -0,0 +1,31 @@
+import { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted } from '@polkadot/rpc-provider/types';
+import { Blockchain } from './blockchain';
+interface SubscriptionHandler {
+    callback: ProviderInterfaceCallback;
+    type: string;
+}
+/**
+ * Provider for local chopsticks chain
+ */
+export declare class ChopsticksProvider implements ProviderInterface {
+    #private;
+    readonly chain: Blockchain;
+    constructor(chain: Blockchain);
+    static fromEndpoint: (endpoint: string, block?: number | string | null, cache?: string) => Promise<ChopsticksProvider>;
+    get hasSubscriptions(): boolean;
+    get isClonable(): boolean;
+    get isConnected(): boolean;
+    get isReady(): Promise<void>;
+    clone: () => ChopsticksProvider;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    on: (type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb) => (() => void);
+    subscriptionManager: {
+        subscribe: (method: string, subid: string, onCancel?: () => void) => (data: any) => void;
+        unsubscribe: (subid: string) => void;
+    };
+    send: <T>(method: string, params: unknown[], _isCacheable?: boolean, subscription?: SubscriptionHandler) => Promise<T>;
+    subscribe(type: string, method: string, params: unknown[], callback: ProviderInterfaceCallback): Promise<number | string>;
+    unsubscribe(_type: string, method: string, id: number | string): Promise<boolean>;
+}
+export {};

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, cache) => __awaiter(void 0, void 0, void 0, function* () {
+    return new ChopsticksProvider(yield (0, setup_1.setup)({
+        endpoint,
+        mockSignatureHost: true,
+        block,
+        db: cache,
+    }));
+});

package/lib/index.d.ts

@@ -22,4 +22,5 @@ export * from './setup';
 export * from './blockchain/inherent';
 export * from './logger';
 export * from './offchain';
+export * from './chopsticks-provider';
 export * from './rpc';

package/lib/index.js

@@ -38,5 +38,5 @@ __exportStar(require("./setup"), 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("./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;

package/lib/rpc/substrate/index.d.ts

@@ -24,20 +24,20 @@ declare const handlers: {
     }>;
     system_dryRun: import("..").Handler<[`0x${string}`, `0x${string}`], string>;
     system_accountNextIndex: import("..").Handler<[`0x${string}`], number>;
-    state_getRuntimeVersion: import("..").Handler<[`0x${string}`], import("../..").RuntimeVersion | undefined>;
-    state_getMetadata: import("..").Handler<[`0x${string}`], `0x${string}` | undefined>;
-    state_getStorage: import("..").Handler<[`0x${string}`, `0x${string}`], string | undefined>;
+    state_getRuntimeVersion: import("..").Handler<[`0x${string}`], import("../..").RuntimeVersion | null>;
+    state_getMetadata: import("..").Handler<[`0x${string}`], `0x${string}` | null>;
+    state_getStorage: import("..").Handler<[`0x${string}`, `0x${string}`], string | null>;
     state_getKeysPaged: import("..").Handler<[string, number, string, `0x${string}`], string[] | undefined>;
     state_queryStorageAt: import("..").Handler<[string[], `0x${string}`], [] | [{
         block: `0x${string}`;
-        changes: (string | undefined)[][];
+        changes: [string, string | null][];
     }]>;
     state_call: import("..").Handler<[`0x${string}`, `0x${string}`, `0x${string}`], `0x${string}`>;
     state_subscribeRuntimeVersion: import("..").Handler<[], string>;
     state_unsubscribeRuntimeVersion: import("..").Handler<[`0x${string}`], void>;
     state_subscribeStorage: import("..").Handler<[string[]], string>;
     state_unsubscribeStorage: import("..").Handler<[string], void>;
-    childstate_getStorage: import("..").Handler<[`0x${string}`, `0x${string}`, `0x${string}`], string | undefined>;
+    childstate_getStorage: import("..").Handler<[`0x${string}`, `0x${string}`, `0x${string}`], string | null>;
     childstate_getKeysPaged: import("..").Handler<[`0x${string}`, `0x${string}`, number, `0x${string}`, `0x${string}`], `0x${string}`[] | undefined>;
     payment_queryFeeDetails: import("..").Handler<[`0x${string}`, `0x${string}`], `0x${string}`>;
     payment_queryInfo: import("..").Handler<[`0x${string}`, `0x${string}`], `0x${string}`>;

package/lib/rpc/substrate/state.d.ts

@@ -7,21 +7,21 @@ import { RuntimeVersion } from '../../wasm-executor';
  *
  * @return runtime version
  */
-export declare const state_getRuntimeVersion: Handler<[HexString], RuntimeVersion | undefined>;
+export declare const state_getRuntimeVersion: Handler<[HexString], RuntimeVersion | null>;
 /**
  * @param context
  * @param params - [`blockhash`]
  *
  * @return metadata
  */
-export declare const state_getMetadata: Handler<[HexString], HexString | undefined>;
+export declare const state_getMetadata: Handler<[HexString], HexString | null>;
 /**
  * @param context
  * @param params - [`key`, `blockhash`]
  *
  * @return storage value
  */
-export declare const state_getStorage: Handler<[HexString, HexString], string | undefined>;
+export declare const state_getStorage: Handler<[HexString, HexString], string | null>;
 /**
  * @param context
  * @param params - [`prefix`, `pageSize`, `startKey`, `blockhash`]
@@ -41,7 +41,7 @@ export declare const state_queryStorageAt: Handler<[
 ], [] | [
     {
         block: HexString;
-        changes: (string | undefined)[][];
+        changes: [string, string | null][];
     }
 ]>;
 /**
@@ -81,7 +81,7 @@ export declare const state_unsubscribeStorage: Handler<[string], void>;
  *
  * @return storage valuse
  */
-export declare const childstate_getStorage: Handler<[HexString, HexString, HexString], string | undefined>;
+export declare const childstate_getStorage: Handler<[HexString, HexString, HexString], string | null>;
 /**
  * @param context
  * @param params - [`child`, `prefix`, `pageSize`, `startKey`, `blockhash`]

package/lib/rpc/substrate/state.js

@@ -22,7 +22,7 @@ const logger = logger_1.defaultLogger.child({ name: 'rpc-state' });
  */
 const state_getRuntimeVersion = (context, [hash]) => __awaiter(void 0, void 0, void 0, function* () {
     const block = yield context.chain.getBlock(hash);
-    return block === null || block === void 0 ? void 0 : block.runtimeVersion;
+    return (block === null || block === void 0 ? void 0 : block.runtimeVersion) || null;
 });
 exports.state_getRuntimeVersion = state_getRuntimeVersion;
 /**
@@ -33,7 +33,7 @@ exports.state_getRuntimeVersion = state_getRuntimeVersion;
  */
 const state_getMetadata = (context, [hash]) => __awaiter(void 0, void 0, void 0, function* () {
     const block = yield context.chain.getBlock(hash);
-    return block === null || block === void 0 ? void 0 : block.metadata;
+    return (block === null || block === void 0 ? void 0 : block.metadata) || null;
 });
 exports.state_getMetadata = state_getMetadata;
 /**
@@ -44,7 +44,8 @@ exports.state_getMetadata = state_getMetadata;
  */
 const state_getStorage = (context, [key, hash]) => __awaiter(void 0, void 0, void 0, function* () {
     const block = yield context.chain.getBlock(hash);
-    return block === null || block === void 0 ? void 0 : block.get(key);
+    const value = (yield (block === null || block === void 0 ? void 0 : block.get(key))) || null;
+    return value || null;
 });
 exports.state_getStorage = state_getStorage;
 /**
@@ -69,7 +70,7 @@ const state_queryStorageAt = (context, [keys, hash]) => __awaiter(void 0, void 0
     if (!block) {
         return [];
     }
-    const values = yield Promise.all(keys.map((key) => __awaiter(void 0, void 0, void 0, function* () { return [key, yield block.get(key)]; })));
+    const values = yield Promise.all(keys.map((key) => __awaiter(void 0, void 0, void 0, function* () { return [key, yield block.get(key).then((val) => val || null)]; })));
     return [
         {
             block: block.hash,
@@ -101,7 +102,9 @@ const state_subscribeRuntimeVersion = (context, _params, { subscribe }) => __awa
     const id = yield context.chain.headState.subscrubeRuntimeVersion((block) => update(block));
     const callback = subscribe('state_runtimeVersion', id);
     update = (block) => __awaiter(void 0, void 0, void 0, function* () { return callback(yield block.runtimeVersion); });
-    context.chain.head.runtimeVersion.then(callback);
+    setTimeout(() => {
+        context.chain.head.runtimeVersion.then(callback);
+    }, 50);
     return id;
 });
 exports.state_subscribeRuntimeVersion = state_subscribeRuntimeVersion;
@@ -135,7 +138,7 @@ const state_subscribeStorage = (context, [keys], { subscribe }) => __awaiter(voi
     (() => __awaiter(void 0, void 0, void 0, function* () {
         const pairs = yield Promise.all(keys.map((key) => __awaiter(void 0, void 0, void 0, function* () {
             const val = yield context.chain.head.get(key);
-            return [key, val];
+            return [key, val || null];
         })));
         callback({
             block: context.chain.head.hash,
@@ -165,7 +168,8 @@ const childstate_getStorage = (context, [child, key, hash]) => __awaiter(void 0,
         throw new shared_1.ResponseError(-32000, 'Client error: Invalid child storage key');
     }
     const block = yield context.chain.getBlock(hash);
-    return block === null || block === void 0 ? void 0 : block.get((0, utils_1.prefixedChildKey)(child, key));
+    const value = yield (block === null || block === void 0 ? void 0 : block.get((0, utils_1.prefixedChildKey)(child, key)));
+    return value || null;
 });
 exports.childstate_getStorage = childstate_getStorage;
 /**

package/lib/wasm-executor/index.d.ts

@@ -30,7 +30,7 @@ export interface WasmExecutor {
         runtimeLogLevel: number;
     }, callback?: JsCallback) => Promise<any>;
 }
-export declare const getRuntimeVersion: (code: HexString) => Promise<RuntimeVersion>;
+export declare const getRuntimeVersion: ((code: HexString) => Promise<RuntimeVersion>) & _.MemoizedFunction;
 export declare const calculateStateRoot: (entries: [HexString, HexString][], trie_version: number) => Promise<HexString>;
 export declare const decodeProof: (trieRootHash: HexString, keys: HexString[], nodes: HexString[]) => Promise<Record<`0x${string}`, `0x${string}` | null>>;
 export declare const createProof: (nodes: HexString[], entries: [HexString, HexString | null][]) => Promise<{

package/lib/wasm-executor/index.js

@@ -56,15 +56,14 @@ const getWorker = () => __awaiter(void 0, void 0, void 0, function* () {
     }
     return __executor_worker;
 });
-const getRuntimeVersion = (code) => __awaiter(void 0, void 0, void 0, function* () {
+exports.getRuntimeVersion = lodash_1.default.memoize((code) => __awaiter(void 0, void 0, void 0, function* () {
     const worker = yield getWorker();
     return worker.remote.getRuntimeVersion(code).then((version) => {
         version.specName = (0, util_1.hexToString)(version.specName);
         version.implName = (0, util_1.hexToString)(version.implName);
         return version;
     });
-});
-exports.getRuntimeVersion = getRuntimeVersion;
+}));
 // trie_version: 0 for old trie, 1 for new trie
 const calculateStateRoot = (entries, trie_version) => __awaiter(void 0, void 0, void 0, function* () {
     const worker = yield getWorker();

package/lib/wasm-executor/node-wasm-executor.mjs

@@ -29,6 +29,6 @@ const runTask = async (task, callback) => {
 	return pkg.run_task(task, callback, process.env.RUST_LOG)
 }
 
-export const wasmExecutor = { runTask, getRuntimeVersion, calculateStateRoot, createProof, decodeProof }
+const wasmExecutor = { runTask, getRuntimeVersion, calculateStateRoot, createProof, decodeProof }
 
 Comlink.expose(wasmExecutor, nodeEndpoint(parentPort))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks-core",
-  "version": "0.8.4",
+  "version": "0.8.5-0",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "scripts": {
@@ -11,7 +11,7 @@
     "docs:prep": "typedoc"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.8.4",
+    "@acala-network/chopsticks-executor": "0.8.5-0",
     "@polkadot/api": "^10.9.1",
     "@polkadot/util-crypto": "^12.3.2",
     "axios": "^1.5.1",
@@ -47,5 +47,9 @@
       "default": "./lib/*.js"
     },
     "./package.json": "./package.json"
+  },
+  "browser": {
+    "./lib/wasm-executor/node-wasm-executor.mjs": "./lib/wasm-executor/browser-wasm-executor.mjs",
+    "./lib/wasm-executor/node-worker.js": "./lib/wasm-executor/browser-worker.js"
   }
 }

package/lib/chopsticks-worker.d.ts

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

package/lib/chopsticks-worker.js

@@ -1,101 +0,0 @@
-"use strict";
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const rpc_1 = require("./rpc");
-const logger_1 = require("./logger");
-const utils_1 = require("./utils");
-const setup_1 = require("./setup");
-let chain;
-const logger = logger_1.defaultLogger.child({ name: '[Chopsticks worker]' });
-const subscriptions = {};
-const providerHandlers = Object.assign(Object.assign({}, rpc_1.allHandlers), { new_block: (context, _params, _subscriptionManager) => __awaiter(void 0, void 0, void 0, function* () {
-        const { chain } = context;
-        const block = yield chain.newBlock();
-        return block;
-    }) });
-const subscriptionManager = {
-    subscribe: (method, subid, onCancel = () => { }) => {
-        subscriptions[subid] = onCancel;
-        return (data) => {
-            postMessage({
-                type: 'subscribe-callback',
-                method,
-                subid,
-                result: JSON.stringify(data),
-            });
-        };
-    },
-    unsubscribe: (subid) => {
-        if (subscriptions[subid]) {
-            subscriptions[subid](subid); // call onCancel
-            postMessage({
-                type: 'unsubscribe-callback',
-                subid,
-            });
-        }
-    },
-};
-onmessage = (e) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    switch (e.data.type) {
-        case 'connect':
-            try {
-                logger.debug('onMessage: connect. Initializing...');
-                chain = yield (0, setup_1.setup)({
-                    endpoint: e.data.endpoint,
-                    mockSignatureHost: true,
-                    db: e.data.dbPath,
-                    block: e.data.blockHash,
-                });
-                logger.debug('onMessage: connect. Chain setup done.');
-                yield (0, utils_1.setStorage)(chain, e.data.storageValues);
-                logger.debug('onMessage: connect. Set storage done.');
-                postMessage({
-                    type: 'connection',
-                    connected: true,
-                });
-            }
-            catch (e) {
-                logger.error('onMessage: connect error.', e);
-                postMessage({
-                    type: 'connection',
-                    connected: false,
-                    message: e,
-                });
-            }
-            break;
-        case 'disconnect':
-            if (chain) {
-                yield ((_a = chain === null || chain === void 0 ? void 0 : chain.api) === null || _a === void 0 ? void 0 : _a.disconnect());
-                yield (chain === null || chain === void 0 ? void 0 : chain.close());
-            }
-            break;
-        case 'send':
-            {
-                const { method, params } = e.data;
-                const handler = providerHandlers[method];
-                if (!handler) {
-                    logger.error(`Unable to find rpc handler=${method}`);
-                    return Promise.reject(new Error(`Unable to find handler=${method}`));
-                }
-                const result = yield handler({ chain: chain }, params, subscriptionManager);
-                postMessage({
-                    type: 'send-result',
-                    id: e.data.id,
-                    method: method,
-                    result: JSON.stringify(result),
-                });
-            }
-            break;
-        default:
-            break;
-    }
-});