@acala-network/chopsticks 0.1.0

package/dist/rpc/substrate/chain.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("../shared");
+const handlers = {
+    chain_getBlockHash: async (context, [blockNumber]) => {
+        const block = await context.chain.getBlockAt(blockNumber);
+        if (!block) {
+            throw new shared_1.ResponseError(1, 'Block not found');
+        }
+        return block.hash;
+    },
+    chain_getHeader: async (context, [hash]) => {
+        return (await context.chain.getBlock(hash))?.header;
+    },
+    chain_getBlock: async (context, [hash]) => {
+        const block = await context.chain.getBlock(hash);
+        if (!block) {
+            throw new shared_1.ResponseError(1, 'Block not found');
+        }
+        return {
+            block: {
+                header: await block.header,
+                extrinsics: await block.extrinsics,
+            },
+            justifications: null,
+        };
+    },
+    chain_getFinalizedHead: async (context) => {
+        return context.chain.head.hash;
+    },
+    chain_subscribeNewHead: async (context, _params, { subscribe }) => {
+        let update = () => { };
+        const id = context.chain.headState.subscribeHead(() => update());
+        const callback = subscribe('chain_newHead', id, () => context.chain.headState.unsubscribeHead(id));
+        update = async () => {
+            callback(await context.chain.head.header);
+        };
+        update();
+        return id;
+    },
+    chain_subscribeFinalizedHeads: async (context, _params, { subscribe }) => {
+        let update = () => { };
+        const id = context.chain.headState.subscribeHead(() => update());
+        const callback = subscribe('chain_newFinalizedHead', id, () => context.chain.headState.unsubscribeHead(id));
+        update = async () => {
+            callback(await context.chain.head.header);
+        };
+        update();
+        return id;
+    },
+    chain_unsubscribeNewHead: async (_context, [subid], { unsubscribe }) => {
+        unsubscribe(subid);
+    },
+};
+const alias = {
+    chain_subscribeNewHeads: handlers.chain_subscribeNewHead,
+    chain_unsubscribeNewHeads: handlers.chain_unsubscribeNewHead,
+};
+exports.default = {
+    ...handlers,
+    ...alias,
+};

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

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

package/dist/rpc/substrate/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const author_1 = __importDefault(require("./author"));
+const chain_1 = __importDefault(require("./chain"));
+const state_1 = __importDefault(require("./state"));
+const system_1 = __importDefault(require("./system"));
+const handlers = {
+    ...author_1.default,
+    ...chain_1.default,
+    ...state_1.default,
+    ...system_1.default,
+    rpc_methods: async () => ({
+        version: 1,
+        methods: Object.keys(handlers),
+    }),
+};
+exports.default = handlers;

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

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

package/dist/rpc/substrate/state.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../../logger");
+const logger = logger_1.defaultLogger.child({ name: 'rpc-state' });
+const handlers = {
+    state_getRuntimeVersion: async (context, [hash]) => {
+        const block = await context.chain.getBlock(hash);
+        return block?.runtimeVersion;
+    },
+    state_getMetadata: async (context, [hash]) => {
+        const block = await context.chain.getBlock(hash);
+        return block?.metadata;
+    },
+    state_getStorage: async (context, [key, hash]) => {
+        const block = await context.chain.getBlock(hash);
+        return block?.get(key);
+    },
+    state_getKeysPaged: async (context, [prefix, pageSize, startKey, hash]) => {
+        const block = await context.chain.getBlock(hash);
+        return block?.getKeysPaged({ prefix, pageSize, startKey });
+    },
+    state_queryStorageAt: async (context, [keys, hash]) => {
+        const block = await context.chain.getBlock(hash);
+        if (!block) {
+            return [];
+        }
+        const values = await Promise.all(keys.map(async (key) => [key, await block.get(key)]));
+        return [
+            {
+                block: block.hash,
+                changes: values,
+            },
+        ];
+    },
+    state_call: async (context, [method, data, hash]) => {
+        const block = await context.chain.getBlock(hash);
+        if (!block) {
+            return [];
+        }
+        return (await block.call(method, data)).result;
+    },
+    state_subscribeRuntimeVersion: async (context, _params, { subscribe }) => {
+        let update = (_block) => { };
+        const id = context.chain.headState.subscrubeRuntimeVersion((block) => update(block));
+        const callback = subscribe('state_runtimeVersion', id);
+        update = async (block) => callback(await block.runtimeVersion);
+        context.chain.head.runtimeVersion.then(callback);
+        return id;
+    },
+    state_unsubscribeRuntimeVersion: async (_context, [subid], { unsubscribe }) => {
+        unsubscribe(subid);
+    },
+    state_subscribeStorage: async (context, [keys], { subscribe }) => {
+        let update = (_block, _pairs) => { };
+        const id = await context.chain.headState.subscribeStorage(keys, (block, pairs) => update(block, pairs));
+        const callback = subscribe('state_storage', id, () => context.chain.headState.unsubscribeStorage(id));
+        update = async (block, pairs) => {
+            logger.trace({ hash: block.hash }, 'state_subscribeStorage');
+            callback({
+                block: block.hash,
+                changes: pairs,
+            });
+        };
+        (async () => {
+            const pairs = await Promise.all(keys.map(async (key) => {
+                const val = await context.chain.head.get(key);
+                return [key, val];
+            }));
+            callback({
+                block: context.chain.head.hash,
+                changes: pairs,
+            });
+        })();
+        return id;
+    },
+    state_unsubscribeStorage: async (_context, [subid], { unsubscribe }) => {
+        unsubscribe(subid);
+    },
+};
+exports.default = handlers;

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

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

package/dist/rpc/substrate/system.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const handlers = {
+    system_chain: async (context) => {
+        return context.api.getSystemChain();
+    },
+    system_properties: async (context) => {
+        return context.api.getSystemProperties();
+    },
+    system_name: async (context) => {
+        return context.api.getSystemName();
+    },
+    system_version: async (_context) => {
+        return 'chopsticks-1.1.0';
+    },
+    system_chainType: async (_context) => {
+        return 'Development';
+    },
+    system_health: async () => {
+        return {
+            peers: 0,
+            isSyncing: false,
+            shouldhVePeers: false,
+        };
+    },
+};
+exports.default = handlers;

package/dist/schema/index.d.ts

@@ -0,0 +1,183 @@
+import { BuildBlockMode } from '../blockchain/txpool';
+import { z } from 'zod';
+export declare const genesisSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    properties: z.ZodObject<{
+        ss58Format: z.ZodOptional<z.ZodNumber>;
+        tokenDecimals: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
+        tokenSymbol: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    }, "strip", z.ZodTypeAny, {
+        ss58Format?: number | undefined;
+        tokenDecimals?: number | number[] | undefined;
+        tokenSymbol?: string | string[] | undefined;
+    }, {
+        ss58Format?: number | undefined;
+        tokenDecimals?: number | number[] | undefined;
+        tokenSymbol?: string | string[] | undefined;
+    }>;
+    genesis: z.ZodObject<{
+        raw: z.ZodObject<{
+            top: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            top: Record<string, string>;
+        }, {
+            top: Record<string, string>;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        raw: {
+            top: Record<string, string>;
+        };
+    }, {
+        raw: {
+            top: Record<string, string>;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    properties: {
+        ss58Format?: number | undefined;
+        tokenDecimals?: number | number[] | undefined;
+        tokenSymbol?: string | string[] | undefined;
+    };
+    id: string;
+    genesis: {
+        raw: {
+            top: Record<string, string>;
+        };
+    };
+}, {
+    name: string;
+    properties: {
+        ss58Format?: number | undefined;
+        tokenDecimals?: number | number[] | undefined;
+        tokenSymbol?: string | string[] | undefined;
+    };
+    id: string;
+    genesis: {
+        raw: {
+            top: Record<string, string>;
+        };
+    };
+}>;
+export type Genesis = z.infer<typeof genesisSchema>;
+export declare const configSchema: z.ZodObject<{
+    port: z.ZodOptional<z.ZodNumber>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    block: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    'executor-cmd': z.ZodOptional<z.ZodString>;
+    'build-block-mode': z.ZodOptional<z.ZodNativeEnum<typeof BuildBlockMode>>;
+    'import-storage': z.ZodOptional<z.ZodAny>;
+    'mock-signature-host': z.ZodOptional<z.ZodBoolean>;
+    db: z.ZodOptional<z.ZodString>;
+    'wasm-override': z.ZodOptional<z.ZodString>;
+    genesis: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        properties: z.ZodObject<{
+            ss58Format: z.ZodOptional<z.ZodNumber>;
+            tokenDecimals: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
+            tokenSymbol: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        }, "strip", z.ZodTypeAny, {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        }, {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        }>;
+        genesis: z.ZodObject<{
+            raw: z.ZodObject<{
+                top: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                top: Record<string, string>;
+            }, {
+                top: Record<string, string>;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            raw: {
+                top: Record<string, string>;
+            };
+        }, {
+            raw: {
+                top: Record<string, string>;
+            };
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        id: string;
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    }, {
+        name: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        id: string;
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    }>]>>;
+}, "strict", z.ZodTypeAny, {
+    db?: string | undefined;
+    genesis?: string | {
+        name: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        id: string;
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    } | undefined;
+    port?: number | undefined;
+    endpoint?: string | undefined;
+    block?: string | number | undefined;
+    'executor-cmd'?: string | undefined;
+    'build-block-mode'?: BuildBlockMode | undefined;
+    'import-storage'?: any;
+    'mock-signature-host'?: boolean | undefined;
+    'wasm-override'?: string | undefined;
+}, {
+    db?: string | undefined;
+    genesis?: string | {
+        name: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        id: string;
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    } | undefined;
+    port?: number | undefined;
+    endpoint?: string | undefined;
+    block?: string | number | undefined;
+    'executor-cmd'?: string | undefined;
+    'build-block-mode'?: BuildBlockMode | undefined;
+    'import-storage'?: any;
+    'mock-signature-host'?: boolean | undefined;
+    'wasm-override'?: string | undefined;
+}>;
+export type Config = z.infer<typeof configSchema>;

package/dist/schema/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configSchema = exports.genesisSchema = void 0;
+const txpool_1 = require("../blockchain/txpool");
+const zod_1 = require("zod");
+exports.genesisSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    properties: zod_1.z.object({
+        ss58Format: zod_1.z.number().optional(),
+        tokenDecimals: zod_1.z.union([zod_1.z.number(), zod_1.z.array(zod_1.z.number())]).optional(),
+        tokenSymbol: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
+    }),
+    genesis: zod_1.z.object({ raw: zod_1.z.object({ top: zod_1.z.record(zod_1.z.string()) }) }),
+});
+exports.configSchema = zod_1.z
+    .object({
+    port: zod_1.z.number().optional(),
+    endpoint: zod_1.z.string().optional(),
+    block: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+    'executor-cmd': zod_1.z.string().optional(),
+    'build-block-mode': zod_1.z.nativeEnum(txpool_1.BuildBlockMode).optional(),
+    'import-storage': zod_1.z.any().optional(),
+    'mock-signature-host': zod_1.z.boolean().optional(),
+    db: zod_1.z.string().optional(),
+    'wasm-override': zod_1.z.string().optional(),
+    genesis: zod_1.z.union([zod_1.z.string(), exports.genesisSchema]).optional(),
+})
+    .strict();

package/dist/server.d.ts

@@ -0,0 +1,9 @@
+import { SubscriptionManager } from './rpc/shared';
+export type Handler = (data: {
+    method: string;
+    params: string[];
+}, subscriptionManager: SubscriptionManager) => Promise<any>;
+export declare const createServer: (port: number, handler: Handler) => {
+    port: Promise<number>;
+    close: () => Promise<void>;
+};

package/dist/server.js

@@ -0,0 +1,148 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = void 0;
+const ws_1 = __importStar(require("ws"));
+const logger_1 = require("./logger");
+const logger = logger_1.defaultLogger.child({ name: 'ws' });
+const parseRequest = (request) => {
+    try {
+        return JSON.parse(request);
+    }
+    catch (e) {
+        return undefined;
+    }
+};
+const createServer = (port, handler) => {
+    logger.debug('Starting on port %d', port);
+    const wss = new ws_1.WebSocketServer({ port, maxPayload: 1024 * 1024 * 100 });
+    const promise = new Promise((resolve, reject) => {
+        wss.on('listening', () => {
+            logger.debug(wss.address(), 'Listening');
+            resolve(wss.address().port);
+        });
+        wss.on('error', (err) => {
+            logger.error(err, 'Error');
+            reject(err);
+        });
+    });
+    wss.on('connection', (ws) => {
+        logger.debug('New connection');
+        const send = (data) => {
+            if (ws.readyState === ws_1.default.OPEN) {
+                ws.send(JSON.stringify(data));
+            }
+        };
+        const subscriptions = {};
+        const subscriptionManager = {
+            subscribe: (method, subid, onCancel = () => { }) => {
+                subscriptions[subid] = onCancel;
+                return (data) => {
+                    if (subscriptions[subid]) {
+                        send({
+                            jsonrpc: '2.0',
+                            method,
+                            params: {
+                                result: data,
+                                subscription: subid,
+                            },
+                        });
+                    }
+                };
+            },
+            unsubscribe: (subid) => {
+                if (subscriptions[subid]) {
+                    subscriptions[subid](subid);
+                    delete subscriptions[subid];
+                }
+            },
+        };
+        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 req = parseRequest(message.toString());
+            if (!req || req.id == null || req.method == null) {
+                logger.info('Invalid request: %s', message);
+                send({
+                    id: null,
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32600,
+                        message: 'Invalid JSON Request',
+                    },
+                });
+                return;
+            }
+            logger.trace({
+                id: req.id,
+                method: req.method,
+            }, 'Received message');
+            try {
+                const resp = await handler(req, subscriptionManager);
+                logger.trace('Sending response for request %o %o', req.id, req.method);
+                send({
+                    id: req.id,
+                    jsonrpc: '2.0',
+                    result: resp || null,
+                });
+            }
+            catch (e) {
+                logger.info('Error handling request: %s %o', e, e.stack);
+                send({
+                    id: req.id,
+                    jsonrpc: '2.0',
+                    error: e,
+                });
+            }
+        });
+    });
+    return {
+        port: promise,
+        close: () => new Promise((resolve, reject) => {
+            wss.clients.forEach((socket) => socket.close());
+            wss.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        }),
+    };
+};
+exports.createServer = createServer;

package/dist/task.d.ts

@@ -0,0 +1,38 @@
+export interface TaskResponseCall {
+    Call: {
+        result: string;
+        storageDiff: [string, string | null][];
+    };
+}
+export interface TaskResponseError {
+    Error: string;
+}
+export type TaskResponse = TaskResponseCall | TaskResponseError;
+interface TaskCall {
+    wasm: string;
+    blockHash: string;
+    calls: [string, string][];
+    mockSignatureHost?: boolean;
+    allowUnresolvedImports?: boolean;
+}
+interface TaskCalculateStateRoot {
+    entries: [string, string][];
+}
+type Task = {
+    Call: TaskCall;
+} | {
+    CalculateStateRoot: TaskCalculateStateRoot;
+};
+export declare class TaskManager {
+    #private;
+    constructor(listeningPort: number, mockSignatureHost?: boolean, executorCmd?: string, allowUnresolvedImports?: boolean);
+    updateListeningPort(port: number): void;
+    addTask(task: Task, callback?: (res: TaskResponse) => any): number;
+    getTask(taskId: number): {
+        task: Task;
+        callback: (res: TaskResponse) => any;
+    };
+    runTask(taskId: number): Promise<void>;
+    addAndRunTask(task: Task, callback?: (res: TaskResponse) => any): Promise<void>;
+}
+export {};

package/dist/task.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskManager = void 0;
+const node_child_process_1 = require("node:child_process");
+const logger_1 = require("./logger");
+const executor_1 = require("./executor");
+const logger = logger_1.defaultLogger.child({ name: 'task' });
+class TaskManager {
+    #tasks = [];
+    #listeningPort;
+    #mockSignatureHost;
+    #executorCmd;
+    #allowUnresolvedImports;
+    constructor(listeningPort, mockSignatureHost = false, executorCmd, allowUnresolvedImports = false) {
+        this.#listeningPort = listeningPort;
+        this.#mockSignatureHost = mockSignatureHost;
+        this.#executorCmd = executorCmd;
+        this.#allowUnresolvedImports = allowUnresolvedImports;
+        if (this.#mockSignatureHost) {
+            logger.info('Mock signature host enabled');
+        }
+        if (this.#allowUnresolvedImports) {
+            logger.info('Allow unresolved imports enabled. Wasm may expect more host functions, but will not fail on load');
+        }
+    }
+    updateListeningPort(port) {
+        this.#listeningPort = port;
+    }
+    addTask(task, callback = () => { }) {
+        logger.debug({
+            kind: Object.keys(task)[0],
+        }, 'AddTask');
+        if ('Call' in task && task.Call.mockSignatureHost === undefined) {
+            task.Call.mockSignatureHost = this.#mockSignatureHost;
+        }
+        if ('Call' in task && task.Call.allowUnresolvedImports === undefined) {
+            task.Call.allowUnresolvedImports = this.#allowUnresolvedImports;
+        }
+        this.#tasks.push({ task, callback });
+        return this.#tasks.length - 1;
+    }
+    getTask(taskId) {
+        return this.#tasks[taskId];
+    }
+    runTask(taskId) {
+        if (this.#executorCmd) {
+            const cmd = `${this.#executorCmd} --runner-url=ws://localhost:${this.#listeningPort} --task-id=${taskId}`;
+            logger.info({ taskId, cmd }, 'RunTask');
+            const p = (0, node_child_process_1.spawn)(cmd, { shell: true, stdio: 'inherit' });
+            return new Promise((resolve) => {
+                p.once('exit', (code) => {
+                    logger.debug({ taskId, code }, 'RunTask done');
+                    resolve();
+                });
+            });
+        }
+        else {
+            return (0, executor_1.runTask)(taskId, `ws://localhost:${this.#listeningPort}`);
+        }
+    }
+    async addAndRunTask(task, callback = () => { }) {
+        const taskId = this.addTask(task, callback);
+        await this.runTask(taskId);
+    }
+}
+exports.TaskManager = TaskManager;

package/dist/utils/import-storage.d.ts

@@ -0,0 +1,4 @@
+import { Blockchain } from '../blockchain';
+import { StorageValues } from './set-storage';
+export declare const importStorage: (chain: Blockchain, storage?: string | StorageValues) => Promise<void>;
+export declare const overrideWasm: (chain: Blockchain, wasmPath?: string) => Promise<void>;