@acala-network/chopsticks 0.1.0

package/dist/genesis-provider.d.ts

@@ -0,0 +1,42 @@
+import { HexString } from '@polkadot/util/types';
+import { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted, ProviderStats } from '@polkadot/rpc-provider/types';
+import { Genesis } from './schema';
+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;
+    get isConnected(): boolean;
+    get isReady(): Promise<GenesisProvider>;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    on: (type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb) => (() => void);
+    get blockHash(): HexString;
+    getHeader: () => Promise<{
+        blockHash: `0x${string}`;
+        number: number;
+        stateRoot: `0x${string}`;
+        digest: {
+            logs: never[];
+        };
+    }>;
+    getBlock: () => Promise<{
+        block: {
+            header: {
+                blockHash: `0x${string}`;
+                number: number;
+                stateRoot: `0x${string}`;
+                digest: {
+                    logs: never[];
+                };
+            };
+            extrinsics: never[];
+        };
+    }>;
+    send: (method: string, params: unknown[], _isCacheable?: boolean) => Promise<any>;
+    subscribe: (_type: string, _method: string, _params: unknown[], _cb: ProviderInterfaceCallback) => Promise<number | string>;
+    unsubscribe: (_type: string, _method: string, _id: number | string) => Promise<boolean>;
+}

package/dist/genesis-provider.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisProvider = void 0;
+const node_events_1 = require("node:events");
+const node_fs_1 = require("node:fs");
+const util_1 = require("@polkadot/util");
+const axios_1 = __importDefault(require("axios"));
+const schema_1 = require("./schema");
+const executor_1 = require("./executor");
+class GenesisProvider {
+    #isConnected = false;
+    stats;
+    #eventemitter;
+    #isReadyPromise;
+    #genesis;
+    #stateRoot;
+    constructor(genesis) {
+        this.#genesis = genesis;
+        this.#stateRoot = (0, executor_1.calculateStateRoot)(Object.entries(this.#genesis.genesis.raw.top).reduce((accu, item) => {
+            accu.push(item);
+            return accu;
+        }, []));
+        this.#eventemitter = new node_events_1.EventEmitter();
+        this.#isReadyPromise = new Promise((resolve, reject) => {
+            this.#eventemitter.once('connected', () => {
+                resolve(this);
+            });
+            this.#eventemitter.once('error', reject);
+        });
+        this.connect();
+    }
+    static fromUrl = async (url) => {
+        let isUrl = false;
+        try {
+            new URL(url);
+            isUrl = true;
+        }
+        catch (e) {
+            void e;
+        }
+        let file;
+        if (isUrl) {
+            file = await axios_1.default.get(url).then((x) => x.data);
+        }
+        else if ((0, node_fs_1.lstatSync)(url).isFile()) {
+            file = JSON.parse(String((0, node_fs_1.readFileSync)(url)));
+        }
+        else {
+            throw Error(`invalid genesis path or url ${url}`);
+        }
+        return new GenesisProvider(schema_1.genesisSchema.parse(file));
+    };
+    get isClonable() {
+        return true;
+    }
+    clone = () => {
+        return new GenesisProvider(this.#genesis);
+    };
+    get hasSubscriptions() {
+        return false;
+    }
+    get isConnected() {
+        return this.#isConnected;
+    }
+    get isReady() {
+        return this.#isReadyPromise;
+    }
+    connect = async () => {
+        this.#isConnected = true;
+        this.#eventemitter.emit('connected');
+    };
+    disconnect = async () => {
+        this.#isConnected = false;
+        this.#eventemitter.emit('disconnected');
+    };
+    on = (type, sub) => {
+        this.#eventemitter.on(type, sub);
+        return () => {
+            this.#eventemitter.removeListener(type, sub);
+        };
+    };
+    get blockHash() {
+        return '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3';
+    }
+    getHeader = async () => {
+        return {
+            blockHash: this.blockHash,
+            number: 0,
+            stateRoot: await this.#stateRoot,
+            digest: {
+                logs: [],
+            },
+        };
+    };
+    getBlock = async () => {
+        return {
+            block: {
+                header: await this.getHeader(),
+                extrinsics: [],
+            },
+        };
+    };
+    send = async (method, params, _isCacheable) => {
+        await this.isReady;
+        switch (method) {
+            case 'system_properties':
+                return this.#genesis.properties;
+            case 'system_chain':
+                return this.#genesis.id;
+            case 'system_name':
+                return this.#genesis.name;
+            case 'state_getMetadata': {
+                const code = this.#genesis.genesis.raw.top[(0, util_1.stringToHex)(':code')];
+                return (0, executor_1.getMetadata)(code);
+            }
+            case 'chain_getHeader':
+                return this.getHeader();
+            case 'chain_getBlock':
+                return this.getBlock();
+            case 'chain_getBlockHash':
+                return this.blockHash;
+            case 'state_getKeysPagedAt':
+                return [];
+            case 'state_getStorage':
+            case 'state_getStorageAt':
+                return this.#genesis.genesis.raw.top[params[0]];
+            default:
+                throw Error(`${method} not implemented`);
+        }
+    };
+    subscribe = async (_type, _method, _params, _cb) => {
+        throw Error('unimplemented');
+    };
+    unsubscribe = async (_type, _method, _id) => {
+        throw Error('unimplemented');
+    };
+}
+exports.GenesisProvider = GenesisProvider;

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import '@polkadot/types-codec';
+import { Api } from './api';
+import { Blockchain } from './blockchain';
+import { Config } from './schema';
+import { ProviderInterface } from '@polkadot/rpc-provider/types';
+import { TaskManager } from './task';
+export declare const setup: (argv: Config) => Promise<{
+    chain: Blockchain;
+    api: Api;
+    ws: ProviderInterface;
+    tasks: TaskManager;
+}>;
+export declare const runBlock: (argv: any) => Promise<void>;

package/dist/index.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBlock = exports.setup = void 0;
+require("@polkadot/types-codec");
+const api_1 = require("./api");
+const blockchain_1 = require("./blockchain");
+const txpool_1 = require("./blockchain/txpool");
+const schema_1 = require("./schema");
+const genesis_provider_1 = require("./genesis-provider");
+const inherents_1 = require("./blockchain/inherents");
+const task_1 = require("./task");
+const api_2 = require("@polkadot/api");
+const server_1 = require("./server");
+const logger_1 = require("./logger");
+const rpc_1 = require("./rpc");
+const helpers_1 = require("yargs/helpers");
+const import_storage_1 = require("./utils/import-storage");
+const db_1 = require("./db");
+const node_fs_1 = require("node:fs");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const yargs_1 = __importDefault(require("yargs"));
+const setup = async (argv) => {
+    const port = argv.port || Number(process.env.PORT) || 8000;
+    let wsProvider;
+    if (argv.genesis) {
+        if (typeof argv.genesis === 'string') {
+            wsProvider = await genesis_provider_1.GenesisProvider.fromUrl(argv.genesis);
+        }
+        else {
+            wsProvider = new genesis_provider_1.GenesisProvider(argv.genesis);
+        }
+    }
+    else {
+        wsProvider = new api_2.WsProvider(argv.endpoint);
+    }
+    const api = new api_1.Api(wsProvider);
+    await api.isReady;
+    let blockHash;
+    if (argv.block == null) {
+        blockHash = await api.getBlockHash();
+    }
+    else if (Number.isInteger(argv.block)) {
+        blockHash = await api.getBlockHash(Number(argv.block));
+    }
+    else {
+        blockHash = argv.block;
+    }
+    logger_1.defaultLogger.info({ ...argv, blockHash }, 'Args');
+    let db;
+    if (argv.db) {
+        db = await (0, db_1.openDb)(argv.db);
+    }
+    const header = await api.getHeader(blockHash);
+    const tasks = new task_1.TaskManager(port, argv['mock-signature-host'], argv['executor-cmd']);
+    const setTimestamp = new inherents_1.SetTimestamp();
+    const inherents = new inherents_1.InherentProviders(setTimestamp, [new inherents_1.SetValidationData(tasks, 1)]);
+    const chain = new blockchain_1.Blockchain({
+        api,
+        tasks,
+        buildBlockMode: argv['build-block-mode'],
+        inherentProvider: inherents,
+        db,
+        header: {
+            hash: blockHash,
+            number: Number(header.number),
+        },
+    });
+    const context = { chain, api, ws: wsProvider, tasks };
+    const listeningPort = await (0, server_1.createServer)(port, (0, rpc_1.handler)(context)).port;
+    tasks.updateListeningPort(listeningPort);
+    await (0, import_storage_1.importStorage)(chain, argv['import-storage']);
+    await (0, import_storage_1.overrideWasm)(chain, argv['wasm-override']);
+    if (argv.genesis) {
+        // mine 1st block when starting from genesis to set some mock validation data
+        await chain.newBlock();
+    }
+    return context;
+};
+exports.setup = setup;
+const runBlock = async (argv) => {
+    const context = await (0, exports.setup)(argv);
+    const header = await context.chain.head.header;
+    const parent = header.parentHash.toHex();
+    const wasm = await context.chain.head.wasm;
+    const block = context.chain.head;
+    const calls = [['Core_initialize_block', header.toHex()]];
+    for (const extrinsic of await block.extrinsics) {
+        calls.push(['BlockBuilder_apply_extrinsic', extrinsic]);
+    }
+    calls.push(['BlockBuilder_finalize_block', '0x']);
+    await context.tasks.addAndRunTask({
+        Call: {
+            blockHash: parent,
+            wasm,
+            calls,
+        },
+    }, (output) => {
+        if (argv['output-path']) {
+            (0, node_fs_1.writeFileSync)(argv['output-path'], JSON.stringify(output, null, 2));
+        }
+        else {
+            console.dir(output, { depth: null, colors: false });
+        }
+    });
+    setTimeout(() => process.exit(0), 50);
+};
+exports.runBlock = runBlock;
+const processConfig = (argv) => {
+    if (argv.config) {
+        const configFile = (0, node_fs_1.readFileSync)(argv.config, 'utf8');
+        const config = js_yaml_1.default.load(configFile);
+        const parsed = schema_1.configSchema.parse(config);
+        return { ...parsed, ...argv };
+    }
+    return argv;
+};
+(0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+    .command('run-block', 'Replay a block', (yargs) => yargs.options({
+    port: {
+        desc: 'Port to listen on',
+        number: true,
+    },
+    endpoint: {
+        desc: 'Endpoint to connect to',
+        string: true,
+    },
+    block: {
+        desc: 'Block hash or block number. Default to latest block',
+        string: true,
+    },
+    'executor-cmd': {
+        desc: 'Command to execute the executor',
+        string: true,
+    },
+    'output-path': {
+        desc: 'File path to print output',
+        string: true,
+    },
+    db: {
+        desc: 'Path to database',
+        string: true,
+    },
+    'wasm-override': {
+        desc: 'Path to wasm override',
+        string: true,
+    },
+    config: {
+        desc: 'Path to config file',
+        string: true,
+    },
+}), (argv) => {
+    (0, exports.runBlock)(processConfig(argv)).catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+})
+    .command('dev', 'Dev mode', (yargs) => yargs.options({
+    port: {
+        desc: 'Port to listen on',
+        number: true,
+    },
+    endpoint: {
+        desc: 'Endpoint to connect to',
+        string: true,
+    },
+    block: {
+        desc: 'Block hash or block number. Default to latest block',
+        string: true,
+    },
+    'executor-cmd': {
+        desc: 'Command to execute the executor',
+        string: true,
+    },
+    'build-block-mode': {
+        desc: 'Build block mode. Default to Batch',
+        enum: [txpool_1.BuildBlockMode.Batch, txpool_1.BuildBlockMode.Manual, txpool_1.BuildBlockMode.Instant],
+    },
+    'import-storage': {
+        desc: 'Pre-defined JSON/YAML storage file path',
+        string: true,
+    },
+    'mock-signature-host': {
+        desc: 'Mock signature host so any signature starts with 0xdeadbeef and filled by 0xcd is considered valid',
+        boolean: true,
+    },
+    db: {
+        desc: 'Path to database',
+        string: true,
+    },
+    'wasm-override': {
+        desc: 'Path to wasm override',
+        string: true,
+    },
+    config: {
+        desc: 'Path to config file',
+        string: true,
+    },
+}), (argv) => {
+    (0, exports.setup)(processConfig(argv)).catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+})
+    .strict()
+    .help().argv;

package/dist/logger.d.ts

@@ -0,0 +1,7 @@
+export declare const defaultLogger: import("pino").Logger<{
+    level: string;
+    transport: {
+        target: string;
+    };
+}>;
+export declare const truncate: (str?: string) => string | undefined;

package/dist/logger.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncate = exports.defaultLogger = void 0;
+const pino_1 = __importDefault(require("pino"));
+exports.defaultLogger = (0, pino_1.default)({
+    level: process.env.LOG_LEVEL || 'info',
+    transport: {
+        target: 'pino-pretty',
+    },
+});
+const truncate = (str) => {
+    if (str == null) {
+        return str;
+    }
+    if (str.length > 66) {
+        return str.slice(0, 34) + '…' + str.slice(-32);
+    }
+    else {
+        return str;
+    }
+};
+exports.truncate = truncate;

package/dist/rpc/dev.d.ts

@@ -0,0 +1,3 @@
+import { Handlers } from './shared';
+declare const handlers: Handlers;
+export default handlers;

package/dist/rpc/dev.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("./shared");
+const set_storage_1 = require("../utils/set-storage");
+const logger_1 = require("../logger");
+const logger = logger_1.defaultLogger.child({ name: 'rpc-dev' });
+const handlers = {
+    dev_newBlock: async (context, [param]) => {
+        const { count, to } = param || {};
+        const now = context.chain.head.number;
+        const diff = to ? to - now : count;
+        const finalCount = diff > 0 ? diff : 1;
+        let finalHash;
+        for (let i = 0; i < finalCount; i++) {
+            const block = await context.chain.newBlock();
+            logger.debug({ hash: block.hash }, 'dev_newBlock');
+            finalHash = block.hash;
+        }
+        return finalHash;
+    },
+    dev_setStorages: async (context, params) => {
+        const [values, blockHash] = params;
+        const hash = await (0, set_storage_1.setStorage)(context.chain, values, blockHash).catch((error) => {
+            throw new shared_1.ResponseError(1, error.toString());
+        });
+        logger.debug({
+            hash,
+            values,
+        }, 'dev_setStorages');
+        return hash;
+    },
+};
+exports.default = handlers;

package/dist/rpc/exec.d.ts

@@ -0,0 +1,3 @@
+import { Handlers } from './shared';
+declare const handlers: Handlers;
+export default handlers;

package/dist/rpc/exec.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("./shared");
+const logger_1 = require("../logger");
+const logger = logger_1.defaultLogger.child({ name: 'rpc-exec' });
+const handlers = {
+    exec_storageGet: async (context, [_taskId, blockHash, key]) => {
+        const block = await context.chain.getBlock(blockHash);
+        if (!block) {
+            throw new shared_1.ResponseError(1, `Block not found ${blockHash}`);
+        }
+        const value = await block.get(key);
+        logger.trace({ blockHash, key, value: (0, logger_1.truncate)(value) }, 'exec_storageGet');
+        return value;
+    },
+    exec_prefixKeys: async (context, [_taskId, blockHash, key]) => {
+        const block = await context.chain.getBlock(blockHash);
+        if (!block) {
+            throw new shared_1.ResponseError(1, `Block not found ${blockHash}`);
+        }
+        return block.getKeysPaged({ prefix: key, pageSize: 1000, startKey: key });
+    },
+    exec_nextKey: async (context, [_taskId, blockHash, key]) => {
+        const block = await context.chain.getBlock(blockHash);
+        if (!block) {
+            throw new shared_1.ResponseError(1, `Block not found ${blockHash}`);
+        }
+        const res = await block.getKeysPaged({ prefix: key, pageSize: 1, startKey: key });
+        return res[0] || null;
+    },
+    exec_getTask: async (context, [taskId]) => {
+        logger.trace({ taskId }, 'exec_getTask');
+        const task = context.tasks.getTask(Number(taskId));
+        if (!task) {
+            throw new shared_1.ResponseError(1, `Task not found ${taskId}`);
+        }
+        return task.task;
+    },
+    exec_taskResult: async (context, [taskId, resp]) => {
+        logger.trace({ taskId }, 'exec_taskResult');
+        context.tasks.getTask(Number(taskId))?.callback(resp);
+    },
+};
+exports.default = handlers;

package/dist/rpc/index.d.ts

@@ -0,0 +1,5 @@
+import { Context, SubscriptionManager } from './shared';
+export declare const handler: (context: Context) => ({ method, params }: {
+    method: string;
+    params: string[];
+}, subscriptionManager: SubscriptionManager) => Promise<string | number | void | object | null | undefined>;

package/dist/rpc/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const shared_1 = require("./shared");
+const dev_1 = __importDefault(require("./dev"));
+const exec_1 = __importDefault(require("./exec"));
+const substrate_1 = __importDefault(require("./substrate"));
+const allHandlers = {
+    ...exec_1.default,
+    ...substrate_1.default,
+    ...dev_1.default,
+};
+const handler = (context) => ({ method, params }, subscriptionManager) => {
+    shared_1.logger.trace('Handling %s', method);
+    const handler = allHandlers[method];
+    if (!handler) {
+        shared_1.logger.warn('Method not found %s', method);
+        throw new shared_1.ResponseError(-32601, `Method not found: ${method}`);
+    }
+    return handler(context, params, subscriptionManager);
+};
+exports.handler = handler;

package/dist/rpc/shared.d.ts

@@ -0,0 +1,30 @@
+import { ProviderInterface } from '@polkadot/rpc-provider/types';
+import { Api } from '../api';
+import { Blockchain } from '../blockchain';
+import { TaskManager } from '../task';
+export declare const logger: import("pino").default.Logger<{
+    level: string;
+    transport: {
+        target: string;
+    };
+} & import("pino").default.ChildLoggerOptions>;
+export declare class ResponseError extends Error {
+    code: number;
+    constructor(code: number, message: string);
+    toJSON(): {
+        code: number;
+        message: string;
+    };
+}
+export interface Context {
+    chain: Blockchain;
+    api: Api;
+    ws: ProviderInterface;
+    tasks: TaskManager;
+}
+export interface SubscriptionManager {
+    subscribe: (method: string, subid: string, onCancel?: () => void) => (data: any) => void;
+    unsubscribe: (subid: string) => void;
+}
+export type Handler = (context: Context, params: any[], subscriptionManager: SubscriptionManager) => Promise<object | string | number | void | undefined | null>;
+export type Handlers = Record<string, Handler>;

package/dist/rpc/shared.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseError = exports.logger = void 0;
+const logger_1 = require("../logger");
+exports.logger = logger_1.defaultLogger.child({ name: 'rpc' });
+class ResponseError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.message = message;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            message: this.message,
+        };
+    }
+}
+exports.ResponseError = ResponseError;

package/dist/rpc/substrate/author.d.ts

@@ -0,0 +1,3 @@
+import { Handlers } from '../shared';
+declare const handlers: Handlers;
+export default handlers;

package/dist/rpc/substrate/author.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../../logger");
+const logger = logger_1.defaultLogger.child({ name: 'rpc-author' });
+const handlers = {
+    author_submitExtrinsic: async (context, [extrinsic]) => {
+        return context.chain.submitExtrinsic(extrinsic);
+    },
+    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));
+        update = async (block) => {
+            logger.debug({ block: block.hash }, 'author_extrinsicUpdate');
+            // for now just assume tx is always included on next block
+            callback({
+                InBlock: block.hash,
+            });
+            callback({
+                Finalized: block.hash,
+            });
+            unsubscribe(id);
+        };
+        context.chain
+            .submitExtrinsic(extrinsic)
+            .then(() => {
+            callback({
+                Ready: null,
+            });
+        })
+            .catch((error) => {
+            logger.error({ error }, 'ExtrinsicFailed');
+            callback({ Invalid: null });
+            unsubscribe(id);
+        });
+        return id;
+    },
+    author_unwatchExtrinsic: async (_context, [subid], { unsubscribe }) => {
+        unsubscribe(subid);
+    },
+};
+exports.default = handlers;

package/dist/rpc/substrate/chain.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    chain_subscribeNewHeads: import("../shared").Handler;
+    chain_unsubscribeNewHeads: import("../shared").Handler;
+};
+export default _default;