@acala-network/chopsticks 0.8.5-5 → 0.9.0

package/dist/esm/server.js

@@ -0,0 +1,164 @@
+import { WebSocket, WebSocketServer } from 'ws';
+import { ResponseError } from '@acala-network/chopsticks-core';
+import { z } from 'zod';
+import { defaultLogger, truncate } from './logger';
+const logger = defaultLogger.child({ name: 'ws' });
+const singleRequest = z.object({
+    id: z.number(),
+    jsonrpc: z.literal('2.0'),
+    method: z.string(),
+    params: z.array(z.any()).default([]),
+});
+const batchRequest = z.array(singleRequest);
+const requestSchema = z.union([singleRequest, batchRequest]);
+const parseRequest = (request) => {
+    try {
+        return JSON.parse(request);
+    }
+    catch (e) {
+        return undefined;
+    }
+};
+const createWS = async (port) => {
+    const wss = new WebSocketServer({ port, maxPayload: 1024 * 1024 * 100 });
+    const promise = new Promise((resolve) => {
+        wss.on('listening', () => {
+            resolve([wss, wss.address().port]);
+        });
+        wss.on('error', (_) => {
+            resolve([]);
+        });
+    });
+    return promise;
+};
+export const createServer = async (handler, port) => {
+    let wss;
+    let listenPort;
+    for (let i = 0; i < 10; i++) {
+        const preferPort = (port ?? 0) > 0 ? (port ?? 0) + i : 0;
+        logger.debug('Try starting on port %d', preferPort);
+        const [maybeWss, maybeListenPort] = await createWS(preferPort);
+        if (maybeWss && maybeListenPort) {
+            wss = maybeWss;
+            listenPort = maybeListenPort;
+            break;
+        }
+    }
+    if (!wss || !listenPort) {
+        throw new Error(`Failed to create WebsocketServer at port ${port}`);
+    }
+    wss.on('connection', (ws) => {
+        logger.debug('New connection');
+        const send = (data) => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify(data));
+            }
+        };
+        const subscriptions = {};
+        const subscriptionManager = {
+            subscribe: (method, subid, onCancel = () => { }) => {
+                subscriptions[subid] = onCancel;
+                return (data) => {
+                    if (subscriptions[subid]) {
+                        logger.trace({ method, subid, data: truncate(data) }, 'Subscription notification');
+                        send({
+                            jsonrpc: '2.0',
+                            method,
+                            params: {
+                                result: data,
+                                subscription: subid,
+                            },
+                        });
+                    }
+                };
+            },
+            unsubscribe: (subid) => {
+                if (subscriptions[subid]) {
+                    subscriptions[subid](subid);
+                    delete subscriptions[subid];
+                }
+            },
+        };
+        const processRequest = async (req) => {
+            logger.trace({
+                id: req.id,
+                method: req.method,
+            }, 'Received message');
+            try {
+                const resp = await handler(req, subscriptionManager);
+                logger.trace({
+                    id: req.id,
+                    method: req.method,
+                    result: truncate(resp),
+                }, 'Response for request');
+                return {
+                    id: req.id,
+                    jsonrpc: '2.0',
+                    result: resp ?? null,
+                };
+            }
+            catch (e) {
+                logger.info('Error handling request: %s %o', e, e.stack);
+                return {
+                    id: req.id,
+                    jsonrpc: '2.0',
+                    error: e instanceof ResponseError ? e : { code: -32603, message: `Internal ${e}` },
+                };
+            }
+        };
+        ws.on('close', () => {
+            logger.debug('Connection closed');
+            for (const [subid, onCancel] of Object.entries(subscriptions)) {
+                onCancel(subid);
+            }
+            ws.removeAllListeners();
+        });
+        ws.on('error', () => {
+            logger.debug('Connection error');
+            for (const [subid, onCancel] of Object.entries(subscriptions)) {
+                onCancel(subid);
+            }
+            ws.removeAllListeners();
+        });
+        ws.on('message', async (message) => {
+            const parsed = await requestSchema.safeParseAsync(parseRequest(message.toString()));
+            if (!parsed.success) {
+                logger.info('Invalid request: %s', message);
+                send({
+                    id: null,
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32600,
+                        message: 'Invalid JSON Request',
+                    },
+                });
+                return;
+            }
+            const { data: req } = parsed;
+            if (Array.isArray(req)) {
+                logger.trace({ req }, 'Received batch request');
+                const resp = await Promise.all(req.map(processRequest));
+                send(resp);
+            }
+            else {
+                logger.trace({ req }, 'Received single request');
+                const resp = await processRequest(req);
+                send(resp);
+            }
+        });
+    });
+    return {
+        port: listenPort,
+        close: () => new Promise((resolve, reject) => {
+            wss?.clients.forEach((socket) => socket.close());
+            wss?.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        }),
+    };
+};

package/dist/esm/setup-with-server.js

@@ -0,0 +1,22 @@
+import { createServer } from './server';
+import { handler } from './rpc';
+import { logger } from '@acala-network/chopsticks-core';
+import { setupContext } from './context';
+export const setupWithServer = async (argv) => {
+    const context = await setupContext(argv);
+    const port = argv.port ?? 8000;
+    if (argv.genesis) {
+        // mine 1st block when starting from genesis to set some mock validation data
+        await context.chain.newBlock();
+    }
+    const { close, port: listenPort } = await createServer(handler(context), port);
+    logger.info(`${await context.chain.api.getSystemChain()} RPC listening on port ${listenPort}`);
+    return {
+        ...context,
+        listenPort,
+        async close() {
+            await context.chain.close();
+            await close();
+        },
+    };
+};

package/dist/esm/types.js

@@ -0,0 +1,2 @@
+export * from '@acala-network/chopsticks-core/src/rpc/substrate';
+export * from './plugins/types';

package/dist/esm/utils/decoder.js

@@ -0,0 +1,15 @@
+import { decodeBlockStorageDiff } from '@acala-network/chopsticks-core';
+import { create } from 'jsondiffpatch';
+import _ from 'lodash';
+const diffPatcher = create({
+    array: { detectMove: false },
+    textDiff: { minLength: Number.MAX_VALUE }, // skip text diff
+});
+export const decodeStorageDiff = async (block, diff) => {
+    const [oldState, newState] = await decodeBlockStorageDiff(block, diff);
+    const oldStateWithoutEvents = _.cloneDeep(oldState);
+    if (oldStateWithoutEvents['system']?.['events']) {
+        oldStateWithoutEvents['system']['events'] = [];
+    }
+    return { oldState, newState, delta: diffPatcher.diff(oldStateWithoutEvents, newState) };
+};

package/dist/esm/utils/generate-html-diff.js

@@ -0,0 +1,16 @@
+import { decodeStorageDiff } from './decoder';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { template } from 'lodash';
+import path from 'node:path';
+export const generateHtmlDiff = async (block, diff) => {
+    const { oldState, delta } = await decodeStorageDiff(block, diff);
+    const htmlTemplate = readFileSync(path.join(__dirname, '../../../template/diff.html'), 'utf-8');
+    return template(htmlTemplate)({ left: JSON.stringify(oldState), delta: JSON.stringify(delta) });
+};
+export const generateHtmlDiffPreviewFile = async (block, diff, filename) => {
+    const html = await generateHtmlDiff(block, diff);
+    mkdirSync('./preview', { recursive: true });
+    const filePath = `./preview/${filename}.html`;
+    writeFileSync(filePath, html);
+    return filePath;
+};

package/dist/esm/utils/open-html.js

@@ -0,0 +1,5 @@
+import { execSync } from 'node:child_process';
+export const openHtml = (filePath) => {
+    const start = process.platform == 'darwin' ? 'open' : process.platform == 'win32' ? 'start' : 'xdg-open';
+    execSync(start + ' ' + filePath);
+};

package/dist/esm/utils/override.js

@@ -0,0 +1,43 @@
+import { setStorage } from '@acala-network/chopsticks-core';
+import { existsSync, readFileSync } from 'node:fs';
+import yaml from 'js-yaml';
+import { defaultLogger } from '../logger';
+export const overrideStorage = async (chain, storage, at) => {
+    if (storage == null) {
+        return;
+    }
+    let storageValue;
+    if (typeof storage === 'string') {
+        if (!existsSync(storage))
+            throw Error(`File ${storage} does not exist`);
+        storageValue = yaml.load(String(readFileSync(storage)));
+    }
+    else {
+        storageValue = storage;
+    }
+    const blockHash = await setStorage(chain, storageValue, at);
+    defaultLogger.trace({ blockHash, storage }, 'OverrideStorage');
+};
+export const overrideWasm = async (chain, wasmPath, at) => {
+    if (wasmPath == null) {
+        return;
+    }
+    const wasm = readFileSync(wasmPath);
+    let wasmHex;
+    if (wasm.at(0) === 0x30 && wasm.at(1) === 0x78) {
+        // starts with 0x
+        wasmHex = wasm.toString().trim();
+    }
+    else {
+        wasmHex = '0x' + wasm.toString('hex');
+    }
+    if (at) {
+        const block = await chain.getBlock(at);
+        if (!block)
+            throw new Error(`Cannot find block ${at}`);
+        block.setWasm(wasmHex);
+    }
+    else {
+        chain.head.setWasm(wasmHex);
+    }
+};

package/dist/esm/utils/tunnel.js

@@ -0,0 +1,11 @@
+import 'global-agent/bootstrap';
+import npmConf from '@pnpm/npm-conf';
+const npmConfig = npmConf().config;
+global.GLOBAL_AGENT.HTTP_PROXY =
+    process.env.HTTP_PROXY ||
+        process.env.http_proxy ||
+        process.env.HTTPS_PROXY ||
+        process.env.https_proxy ||
+        npmConfig.get('proxy') ||
+        npmConfig.get('https-proxy') ||
+        global.GLOBAL_AGENT.HTTP_PROXY;

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+import '@polkadot/api-augment';
+export * from '@acala-network/chopsticks-core';
+export { setupWithServer } from './setup-with-server';
+export { fetchConfig } from './schema';

package/dist/types/logger.d.ts

@@ -0,0 +1 @@
+export { defaultLogger, truncate } from '@acala-network/chopsticks-core';

package/dist/types/plugins/dry-run/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cli';
+export * from './rpc';

package/{lib → dist/types}/plugins/run-block/index.d.ts

@@ -75,13 +75,21 @@ export interface RunBlockResponse {
          */
         phase: Phase;
         /**
-         * Parsed storage diff. Only available when `includeParsed` is true.
+         * The modified storages of this phase.
          */
-        parsed?: Record<string, Record<string, any>>;
-        /**
-         * Raw storage diff. Only available when `includeRaw` is true.
-         */
-        raw?: [HexString, HexString | null][];
+        storageDiff: {
+            /**
+             * Raw storage diff in bytes. Only available when `includeRaw` is true.
+             */
+            raw?: {
+                key: HexString;
+                value: HexString | null;
+            };
+            /**
+             * Decoded storage diff. Only available when `includeParsed` is true.
+             */
+            parsed?: any;
+        }[];
         /**
          * Runtime logs.
          */

package/dist/types/plugins/types.d.ts

@@ -0,0 +1,11 @@
+export { rpc as newBlock } from './new-block';
+export { rpc as dryRun } from './dry-run';
+export { rpc as setBlockBuildMode } from './set-block-build-mode';
+export { rpc as setHead } from './set-head';
+export { rpc as setRuntimeLogLevel } from './set-runtime-log-level';
+export { rpc as setStorage } from './set-storage';
+export { rpc as timeTravel } from './time-travel';
+export { rpc as runBlock } from './run-block';
+export type { NewBlockParams } from './new-block';
+export type { DryRunParams } from './dry-run';
+export type { RunBlockParams } from './run-block';

package/dist/types/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './decoder';
+export * from './generate-html-diff';
+export * from './open-html';
+export * from './override';

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@acala-network/chopsticks",
-  "version": "0.8.5-5",
+  "version": "0.9.0",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "bin": "./chopsticks.js",
   "scripts": {
-    "clean": "rm -rf lib tsconfig.tsbuildinfo",
-    "build": "tsc -p ./tsconfig.json",
+    "clean": "rm -rf dist",
+    "build": "yarn clean && tsc -p ./tsconfig.json && tsc -p ./tsconfig.esm.json",
     "script:start": "cd ../..; ts-node --transpile-only -r tsconfig-paths/register packages/chopsticks/src/cli.ts",
     "script:run": "cd ../..; LOG_LEVEL=trace ts-node-dev --transpile-only -r tsconfig-paths/register --inspect --notify=false packages/chopsticks/src/cli.ts -- --config=configs/dev.yml",
     "dev:karura": "cd ../..; ts-node-dev --transpile-only --inspect -r tsconfig-paths/register --notify=false packages/chopsticks/src/cli.ts -- --config=configs/karura.yml",
@@ -17,8 +17,8 @@
     "docs:prep": "typedoc"
   },
   "dependencies": {
-    "@acala-network/chopsticks-core": "0.8.5-5",
-    "@acala-network/chopsticks-db": "0.8.5-5",
+    "@acala-network/chopsticks-core": "0.9.0",
+    "@acala-network/chopsticks-db": "0.9.0",
     "@pnpm/npm-conf": "^2.2.2",
     "axios": "^1.5.1",
     "dotenv": "^16.3.1",
@@ -42,24 +42,33 @@
     "typescript": "^5.1.6"
   },
   "files": [
-    "lib",
+    "dist/esm/**",
+    "dist/cjs/**",
+    "dist/types/**",
     "template",
     "chopsticks.js"
   ],
-  "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
   "exports": {
     ".": {
-      "types": "./lib/index.d.ts",
-      "default": "./lib/index.js"
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
     },
     "./*": {
-      "types": "./lib/*.d.ts",
-      "default": "./lib/*.js"
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
     },
     "./plugins/*": {
-      "types": "./lib/plugins/*.d.ts",
-      "default": "./lib/plugins/*.js"
+      "types": "./dist/types/plugins/*.d.ts",
+      "require": "./dist/cjs/plugins/*.js",
+      "import": "./dist/esm/plugins/*.js",
+      "default": "./dist/esm/plugins/*.js"
     },
     "./package.json": "./package.json"
   }