@acala-network/chopsticks 0.9.13 → 0.10.0-2

package/dist/cjs/plugins/trace-transaction/table.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TABLE: function() {
+        return TABLE;
+    },
+    opName: function() {
+        return opName;
+    }
+});
+const TABLE = {
+    '0x00': 'STOP',
+    '0x01': 'ADD',
+    '0x02': 'MUL',
+    '0x03': 'SUB',
+    '0x04': 'DIV',
+    '0x05': 'SDIV',
+    '0x06': 'MOD',
+    '0x07': 'SMOD',
+    '0x08': 'ADDMOD',
+    '0x09': 'MULMOD',
+    '0x0a': 'EXP',
+    '0x0b': 'SIGNEXTEND',
+    '0x10': 'LT',
+    '0x11': 'GT',
+    '0x12': 'SLT',
+    '0x13': 'SGT',
+    '0x14': 'EQ',
+    '0x15': 'ISZERO',
+    '0x16': 'AND',
+    '0x17': 'OR',
+    '0x18': 'XOR',
+    '0x19': 'NOT',
+    '0x1a': 'BYTE',
+    '0x35': 'CALLDATALOAD',
+    '0x36': 'CALLDATASIZE',
+    '0x37': 'CALLDATACOPY',
+    '0x38': 'CODESIZE',
+    '0x39': 'CODECOPY',
+    '0x1b': 'SHL',
+    '0x1c': 'SHR',
+    '0x1d': 'SAR',
+    '0x50': 'POP',
+    '0x51': 'MLOAD',
+    '0x52': 'MSTORE',
+    '0x53': 'MSTORE8',
+    '0x56': 'JUMP',
+    '0x57': 'JUMPI',
+    '0x58': 'PC',
+    '0x59': 'MSIZE',
+    '0x5b': 'JUMPDEST',
+    '0x5f': 'PUSH0',
+    '0x60': 'PUSH1',
+    '0x61': 'PUSH2',
+    '0x62': 'PUSH3',
+    '0x63': 'PUSH4',
+    '0x64': 'PUSH5',
+    '0x65': 'PUSH6',
+    '0x66': 'PUSH7',
+    '0x67': 'PUSH8',
+    '0x68': 'PUSH9',
+    '0x69': 'PUSH10',
+    '0x6a': 'PUSH11',
+    '0x6b': 'PUSH12',
+    '0x6c': 'PUSH13',
+    '0x6d': 'PUSH14',
+    '0x6e': 'PUSH15',
+    '0x6f': 'PUSH16',
+    '0x70': 'PUSH17',
+    '0x71': 'PUSH18',
+    '0x72': 'PUSH19',
+    '0x73': 'PUSH20',
+    '0x74': 'PUSH21',
+    '0x75': 'PUSH22',
+    '0x76': 'PUSH23',
+    '0x77': 'PUSH24',
+    '0x78': 'PUSH25',
+    '0x79': 'PUSH26',
+    '0x7a': 'PUSH27',
+    '0x7b': 'PUSH28',
+    '0x7c': 'PUSH29',
+    '0x7d': 'PUSH30',
+    '0x7e': 'PUSH31',
+    '0x7f': 'PUSH32',
+    '0x80': 'DUP1',
+    '0x81': 'DUP2',
+    '0x82': 'DUP3',
+    '0x83': 'DUP4',
+    '0x84': 'DUP5',
+    '0x85': 'DUP6',
+    '0x86': 'DUP7',
+    '0x87': 'DUP8',
+    '0x88': 'DUP9',
+    '0x89': 'DUP10',
+    '0x8a': 'DUP11',
+    '0x8b': 'DUP12',
+    '0x8c': 'DUP13',
+    '0x8d': 'DUP14',
+    '0x8e': 'DUP15',
+    '0x8f': 'DUP16',
+    '0x90': 'SWAP1',
+    '0x91': 'SWAP2',
+    '0x92': 'SWAP3',
+    '0x93': 'SWAP4',
+    '0x94': 'SWAP5',
+    '0x95': 'SWAP6',
+    '0x96': 'SWAP7',
+    '0x97': 'SWAP8',
+    '0x98': 'SWAP9',
+    '0x99': 'SWAP10',
+    '0x9a': 'SWAP11',
+    '0x9b': 'SWAP12',
+    '0x9c': 'SWAP13',
+    '0x9d': 'SWAP14',
+    '0x9e': 'SWAP15',
+    '0x9f': 'SWAP16',
+    '0xf3': 'RETURN',
+    '0xfd': 'REVERT',
+    '0xfe': 'INVALID',
+    '0xef': 'EOFMAGIC',
+    '0x20': 'SHA3',
+    '0x30': 'ADDRESS',
+    '0x31': 'BALANCE',
+    '0x47': 'SELFBALANCE',
+    '0x48': 'BASEFEE',
+    '0x32': 'ORIGIN',
+    '0x33': 'CALLER',
+    '0x34': 'CALLVALUE',
+    '0x3a': 'GASPRICE',
+    '0x3b': 'EXTCODESIZE',
+    '0x3c': 'EXTCODECOPY',
+    '0x3f': 'EXTCODEHASH',
+    '0x3d': 'RETURNDATASIZE',
+    '0x3e': 'RETURNDATACOPY',
+    '0x40': 'BLOCKHASH',
+    '0x41': 'COINBASE',
+    '0x42': 'TIMESTAMP',
+    '0x43': 'NUMBER',
+    '0x44': 'DIFFICULTY',
+    '0x45': 'GASLIMIT',
+    '0x54': 'SLOAD',
+    '0x55': 'SSTORE',
+    '0x5a': 'GAS',
+    '0xa0': 'LOG0',
+    '0xa1': 'LOG1',
+    '0xa2': 'LOG2',
+    '0xa3': 'LOG3',
+    '0xa4': 'LOG4',
+    '0xf0': 'CREATE',
+    '0xf5': 'CREATE2',
+    '0xf1': 'CALL',
+    '0xf2': 'CALLCODE',
+    '0xf4': 'DELEGATECALL',
+    '0xfa': 'STATICCALL',
+    '0xff': 'SUICIDE',
+    '0x46': 'CHAINID'
+};
+const opName = (op)=>{
+    return TABLE[`0x${op.toString(16).padStart(2, '0')}`] || `0x${op.toString(16).padStart(2, '0')}`;
+};

package/dist/cjs/plugins/trace-transaction/types.d.ts

@@ -0,0 +1,30 @@
+import { HexString } from '@polkadot/util/types';
+import { Registry } from '@polkadot/types/types';
+export type CallTrace = {
+    type: 'CALL' | 'CALLCODE' | 'STATICCALL' | 'DELEGATECALL' | 'CREATE' | 'SUICIDE';
+    from: HexString;
+    to: HexString;
+    input: HexString;
+    value: HexString;
+    gas: number;
+    gasUsed: number;
+    output: HexString | null;
+    error: string | null;
+    revertReason: string | null;
+    depth: number;
+    calls: CallTrace[];
+};
+export type Step = {
+    op: number;
+    pc: number;
+    depth: number;
+    gas: number;
+    stack: HexString[];
+    memory: string[] | null;
+};
+export type TraceOutcome = {
+    steps: Step[];
+} | {
+    calls: CallTrace[];
+};
+export declare const registerTypes: (registry: Registry) => void;

package/dist/cjs/plugins/trace-transaction/types.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerTypes", {
+    enumerable: true,
+    get: function() {
+        return registerTypes;
+    }
+});
+const registerTypes = (registry)=>{
+    registry.register({
+        Step: {
+            op: 'u8',
+            pc: 'Compact<u32>',
+            depth: 'Compact<u32>',
+            gas: 'Compact<u64>',
+            stack: 'Vec<Bytes>',
+            memory: 'Option<Vec<Bytes>>'
+        },
+        CallType: {
+            _enum: {
+                CALL: null,
+                CALLCODE: null,
+                STATICCALL: null,
+                DELEGATECALL: null,
+                CREATE: null,
+                SUICIDE: null
+            }
+        },
+        CallTrace: {
+            type: 'CallType',
+            from: 'H160',
+            to: 'H160',
+            input: 'Bytes',
+            value: 'U256',
+            gas: 'Compact<u64>',
+            gasUsed: 'Compact<u64>',
+            output: 'Option<Bytes>',
+            error: 'Option<String>',
+            revertReason: 'Option<String>',
+            depth: 'Compact<u32>',
+            calls: 'Vec<CallTrace>'
+        },
+        TraceOutcome: {
+            _enum: {
+                Calls: 'Vec<CallTrace>',
+                Steps: 'Vec<Step>'
+            }
+        },
+        OpcodeConfig: {
+            page: 'u32',
+            pageSize: 'u32',
+            disableStack: 'bool',
+            enableMemory: 'bool'
+        },
+        TracerConfig: {
+            _enum: {
+                CallTracer: null,
+                OpcodeTracer: 'OpcodeConfig'
+            }
+        }
+    });
+};

package/dist/cjs/plugins/trace-transaction/utils.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Block, Blockchain, RuntimeVersion } from '@acala-network/chopsticks-core';
+import { HexString } from '@polkadot/util/types';
+import { Step } from './types.js';
+/**
+ * Fetches the runtime with tracing feature from Github releases.
+ * @param runtimeVersion - The version of the runtime.
+ * @returns A Promise that resolves to the fetched runtime as a Buffer.
+ */
+export declare const fetchRuntime: (runtimeVersion: RuntimeVersion) => Promise<Buffer | undefined>;
+export declare const fetchEVMTransaction: (runtimeVersion: RuntimeVersion, txHash: string) => Promise<any>;
+/**
+ * Traces the execution of a transaction in the VM.
+ * @param block - The block to trace the extrinsic in.
+ * @param extrinsic - The extrinsic to trace.
+ * @returns An array of VM steps.
+ * @throws Error if the trace outcome is invalid.
+ */
+export declare const traceVM: (block: Block, extrinsic: HexString, pageSize?: number, disableStack?: boolean, enableMemory?: boolean) => Promise<Step[]>;
+/**
+ * Traces the calls made by an extrinsic in a block.
+ * @param block - The block to trace the extrinsic in.
+ * @param extrinsic - The extrinsic to trace.
+ * @returns An array of calls made by the extrinsic.
+ * @throws Error if the trace outcome is invalid.
+ */
+export declare const traceCalls: (block: Block, extrinsic: HexString) => Promise<import("./types.js").CallTrace[]>;
+/**
+ * Prepares a block for tracing a transaction.
+ * @param chain The blockchain instance.
+ * @param blockHashNumber The block hash or block number.
+ * @param txHash The transaction hash.
+ * @param wasmPath The path to the runtime wasm file.
+ * @returns An object containing the tracing block and the transaction extrinsic.
+ * @throws Error if the block or parent block is not found, or if the runtime wasm with tracing feature cannot be found.
+ */
+export declare const prepareBlock: (chain: Blockchain, blockHashNumber: HexString | number, txHash: string, wasmPath?: string) => Promise<{
+    tracingBlock: Block;
+    extrinsic: `0x${string}`;
+}>;

package/dist/cjs/plugins/trace-transaction/utils.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    fetchEVMTransaction: function() {
+        return fetchEVMTransaction;
+    },
+    fetchRuntime: function() {
+        return fetchRuntime;
+    },
+    prepareBlock: function() {
+        return prepareBlock;
+    },
+    traceCalls: function() {
+        return traceCalls;
+    },
+    traceVM: function() {
+        return traceVM;
+    }
+});
+const _chopstickscore = require("@acala-network/chopsticks-core");
+const _utilcrypto = require("@polkadot/util-crypto");
+const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
+const _types = require("./types.js");
+const _table = require("./table.js");
+const _override = require("../../utils/override.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const fetchRuntime = async (runtimeVersion)=>{
+    const GIHTUB_RELEASES_API = 'https://api.github.com/repos/AcalaNetwork/Acala/releases';
+    const assetName = `${runtimeVersion.specName}_runtime_tracing_${runtimeVersion.specVersion}.compact.compressed.wasm`;
+    _chopstickscore.pinoLogger.info({
+        assetName
+    }, 'Search for runtime with tracing feature from Github releases ...');
+    const releases = await fetch(GIHTUB_RELEASES_API).then((res)=>res.json());
+    for (const release of releases){
+        if (release.assets) {
+            for (const asset of release.assets){
+                if (asset.name === assetName) {
+                    _chopstickscore.pinoLogger.info({
+                        url: asset.browser_download_url
+                    }, 'Downloading ...');
+                    const runtime = await fetch(asset.browser_download_url).then((x)=>x.arrayBuffer());
+                    return Buffer.from(runtime);
+                }
+            }
+        }
+    }
+};
+const fetchEVMTransaction = async (runtimeVersion, txHash)=>{
+    const ACALA_ETH_RPC = 'https://eth-rpc-acala.aca-api.network';
+    const KARURA_ETH_RPC = 'https://eth-rpc-karura.aca-api.network';
+    let ethRpc;
+    if (runtimeVersion.specName.includes('acala')) {
+        ethRpc = ACALA_ETH_RPC;
+    } else if (runtimeVersion.specName.includes('karura')) {
+        ethRpc = KARURA_ETH_RPC;
+    } else {
+        throw new Error(`Unsupported chain. Only Acala and Karura are supported`);
+    }
+    _chopstickscore.pinoLogger.info(`Fetching EVM transaction ...`);
+    const response = await fetch(ethRpc, {
+        headers: [
+            [
+                'Content-Type',
+                'application/json'
+            ],
+            [
+                'Accept',
+                'application/json'
+            ]
+        ],
+        method: 'POST',
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'eth_getTransactionByHash',
+            params: [
+                txHash
+            ]
+        })
+    });
+    const data = await response.json();
+    if (data.error) {
+        throw new Error(data.error.message);
+    }
+    return data.result;
+};
+const traceVM = async (block, extrinsic, pageSize = 50_000, disableStack = false, enableMemory = true)=>{
+    const meta = await block.meta;
+    (0, _types.registerTypes)(meta.registry);
+    let page = 0;
+    let traceNextPage = true;
+    let steps = [];
+    while(traceNextPage){
+        _chopstickscore.pinoLogger.info(`VM trace page ${page} ...`);
+        const tracerConfig = meta.registry.createType('TracerConfig', {
+            OpcodeTracer: {
+                page,
+                pageSize,
+                disableStack,
+                enableMemory
+            }
+        }).toHex();
+        const taskResponse = await block.call('EVMTraceApi_trace_extrinsic', [
+            extrinsic,
+            tracerConfig
+        ]);
+        const outcome = meta.registry.createType('Result<TraceOutcome, TransactionValidityError>', taskResponse.result).asOk.toJSON();
+        if (!('steps' in outcome)) {
+            throw new Error('Invalid trace outcome');
+        }
+        steps = steps.concat(outcome.steps.map((step)=>({
+                ...step,
+                op: (0, _table.opName)(step.op),
+                // transform memory to 64 bytes chunks
+                memory: step.memory ? step.memory.map((chunk, idx)=>{
+                    // remove 0x prefix
+                    const slice = chunk.slice(2);
+                    // make sure each chunk is 64 bytes
+                    if (slice.length < 64 && idx + 1 < step.memory.length) {
+                        return slice.padStart(64, '0');
+                    }
+                    return slice;
+                }) : null
+            })));
+        page += 1;
+        traceNextPage = outcome.steps.length == pageSize;
+    }
+    return steps;
+};
+const traceCalls = async (block, extrinsic)=>{
+    const meta = await block.meta;
+    (0, _types.registerTypes)(meta.registry);
+    const tracerConfig = meta.registry.createType('TracerConfig', {
+        CallTracer: null
+    }).toHex();
+    const taskResponse = await block.call('EVMTraceApi_trace_extrinsic', [
+        extrinsic,
+        tracerConfig
+    ]);
+    const outcome = meta.registry.createType('Result<TraceOutcome, TransactionValidityError>', taskResponse.result).asOk.toJSON();
+    if (!('calls' in outcome)) {
+        throw new Error('Invalid trace outcome');
+    }
+    return outcome.calls;
+};
+const prepareBlock = async (chain, blockHashNumber, txHash, wasmPath)=>{
+    let wasm = wasmPath;
+    const block = typeof blockHashNumber == 'number' ? await chain.getBlockAt(blockHashNumber) : await chain.getBlock(blockHashNumber);
+    if (!block) {
+        throw new Error(`Block not found ${blockHashNumber}`);
+    }
+    const header = await block.header;
+    const parent = await chain.getBlock(header.parentHash.toHex());
+    if (!parent) {
+        throw new Error(`Block not found ${blockHashNumber}`);
+    }
+    await chain.setHead(parent);
+    // override wasm with tracing feature
+    if (typeof wasm === 'string') {
+        await (0, _override.overrideWasm)(chain, wasm);
+    } else {
+        // Fetch runtime wasm with tracing feature from Github releases
+        if (!wasm) {
+            wasm = await fetchRuntime(await chain.head.runtimeVersion);
+            if (!wasm) {
+                throw new Error('Could not find runtime with tracing feature from Github releasesw. Make sure to manually override runtime wasm built with `tracing` feature enabled.');
+            }
+        }
+        chain.head.setWasm(`0x${wasm.toString('hex')}`);
+    }
+    const runtimeVersion = await chain.head.runtimeVersion;
+    _chopstickscore.pinoLogger.info(`${_lodash.default.capitalize(runtimeVersion.specName)} specVersion: ${runtimeVersion.specVersion}`);
+    const extrinsics = await block.extrinsics;
+    const txIndex = extrinsics.findIndex((tx)=>(0, _utilcrypto.blake2AsHex)(tx) === txHash);
+    const tracingBlock = new _chopstickscore.Block(chain, block.number, block.hash, parent, {
+        header,
+        extrinsics: [],
+        storage: parent.storage
+    });
+    _chopstickscore.pinoLogger.info(`Preparing block ${chain.head.number + 1} ...`);
+    const { storageDiff } = await tracingBlock.call('Core_initialize_block', [
+        header.toHex()
+    ]);
+    tracingBlock.pushStorageLayer().setAll(storageDiff);
+    for (const extrinsic of extrinsics.slice(0, txIndex)){
+        const { storageDiff } = await tracingBlock.call('BlockBuilder_apply_extrinsic', [
+            extrinsic
+        ]);
+        tracingBlock.pushStorageLayer().setAll(storageDiff);
+    }
+    return {
+        tracingBlock,
+        extrinsic: extrinsics[txIndex]
+    };
+};

package/dist/cjs/utils/tunnel.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 const _globalagent = require("global-agent");
+const _chopstickscore = require("@acala-network/chopsticks-core");
 const _npmconf = /*#__PURE__*/ _interop_require_default(require("@pnpm/npm-conf"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -11,4 +12,4 @@ function _interop_require_default(obj) {
 }
 (0, _globalagent.bootstrap)();
 const npmConfig = (0, _npmconf.default)().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;
+global.GLOBAL_AGENT.HTTP_PROXY = _chopstickscore.environment.HTTP_PROXY || _chopstickscore.environment.http_proxy || _chopstickscore.environment.HTTPS_PROXY || _chopstickscore.environment.https_proxy || npmConfig.get('proxy') || npmConfig.get('https-proxy') || global.GLOBAL_AGENT.HTTP_PROXY;

package/dist/esm/cli.js

@@ -2,7 +2,7 @@ import { config as dotenvConfig } from 'dotenv';
 import { hideBin } from 'yargs/helpers';
 import _ from 'lodash';
 import yargs from 'yargs';
-import { connectParachains, connectVertical } from '@acala-network/chopsticks-core';
+import { connectParachains, connectVertical, environment } from '@acala-network/chopsticks-core';
 import { configSchema, fetchConfig, getYargsOptions } from './schema/index.js';
 import { pluginExtendCli } from './plugins/index.js';
 import { setupWithServer } from './index.js';
@@ -11,8 +11,8 @@ const processArgv = async (argv)=>{
     if (argv.config) {
         Object.assign(argv, _.defaults(argv, await fetchConfig(argv.config)));
     }
-    if (process.env.PORT) {
-        argv.port = Number(process.env.PORT);
+    if (environment.PORT) {
+        argv.port = Number(environment.PORT);
     }
 };
 const commands = yargs(hideBin(process.argv)).scriptName('chopsticks').middleware(processArgv, false).command('*', 'Dev mode, fork off a chain', (yargs)=>yargs.config('config', 'Path to config file with default options', ()=>({})).options(getYargsOptions(configSchema.shape)), async (argv)=>{
@@ -35,7 +35,7 @@ const commands = yargs(hideBin(process.argv)).scriptName('chopsticks').middlewar
         parachains.push(chain);
     }
     if (parachains.length > 1) {
-        await connectParachains(parachains);
+        await connectParachains(parachains, environment.DISABLE_AUTO_HRMP);
     }
     if (argv.relaychain) {
         const { chain: relaychain } = await setupWithServer(await fetchConfig(argv.relaychain));
@@ -44,7 +44,7 @@ const commands = yargs(hideBin(process.argv)).scriptName('chopsticks').middlewar
         }
     }
 }).strict().help().alias('help', 'h').alias('version', 'v').alias('config', 'c').alias('endpoint', 'e').alias('port', 'p').alias('block', 'b').alias('import-storage', 's').alias('wasm-override', 'w').usage('Usage: $0 <command> [options]').example('$0', '-c acala');
-if (!process.env.DISABLE_PLUGINS) {
+if (!environment.DISABLE_PLUGINS) {
     pluginExtendCli(commands.config('config', 'Path to config file with default options', ()=>({}))).then(()=>commands.parse());
 } else {
     commands.parse();

package/dist/esm/plugins/index.js

@@ -1,3 +1,4 @@
+import { environment } from '@acala-network/chopsticks-core';
 import { lstatSync, readdirSync } from 'fs';
 import _ from 'lodash';
 import { defaultLogger } from '../logger.js';
@@ -10,7 +11,7 @@ const plugins = readdirSync(new URL('.', import.meta.url)).filter((file)=>lstatS
 // find all rpc methods
 export const rpcPluginMethods = plugins.filter((name)=>readdirSync(new URL(name, import.meta.url)).some((file)=>file.startsWith('rpc'))).map((name)=>`dev_${_.camelCase(name)}`);
 export const loadRpcPlugin = async (method)=>{
-    if (process.env.DISABLE_PLUGINS) {
+    if (environment.DISABLE_PLUGINS) {
         return undefined;
     }
     if (rpcPluginHandlers[method]) return rpcPluginHandlers[method];

package/dist/esm/plugins/trace-transaction/README.md

@@ -0,0 +1,12 @@
+# EVM+ trace transaction plugin
+
+This plugin allows you to trace the execution of a transaction on the Acala & Karura EVM+. The plugin will take a transaction hash as input and will look up the mainnet for transaction details and perform a trace call for the transaction. You can do either call trace or VM trace
+
+Example usage:
+To trace transaction calls, you can use the following command:
+
+```bash
+npx @acala-network/chopsticks trace-transaction <tx-hash> --config acala --output trace.json
+```
+
+VM trace can be enabled by add `--vm` flag to the command