@acala-network/chopsticks 0.9.13 → 0.10.0-2

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

@@ -0,0 +1,150 @@
+export 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'
+};
+export const opName = (op)=>{
+    return TABLE[`0x${op.toString(16).padStart(2, '0')}`] || `0x${op.toString(16).padStart(2, '0')}`;
+};

package/dist/esm/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/esm/plugins/trace-transaction/types.js

@@ -0,0 +1,54 @@
+export 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/esm/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/esm/plugins/trace-transaction/utils.js

@@ -0,0 +1,199 @@
+import { Block, pinoLogger } from '@acala-network/chopsticks-core';
+import { blake2AsHex } from '@polkadot/util-crypto';
+import _ from 'lodash';
+import { registerTypes } from './types.js';
+import { opName } from './table.js';
+import { overrideWasm } from '../../utils/override.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 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`;
+    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) {
+                    pinoLogger.info({
+                        url: asset.browser_download_url
+                    }, 'Downloading ...');
+                    const runtime = await fetch(asset.browser_download_url).then((x)=>x.arrayBuffer());
+                    return Buffer.from(runtime);
+                }
+            }
+        }
+    }
+};
+export 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`);
+    }
+    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;
+};
+/**
+ * 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 const traceVM = async (block, extrinsic, pageSize = 50_000, disableStack = false, enableMemory = true)=>{
+    const meta = await block.meta;
+    registerTypes(meta.registry);
+    let page = 0;
+    let traceNextPage = true;
+    let steps = [];
+    while(traceNextPage){
+        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: 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;
+};
+/**
+ * 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 const traceCalls = async (block, extrinsic)=>{
+    const meta = await block.meta;
+    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;
+};
+/**
+ * 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 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 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;
+    pinoLogger.info(`${_.capitalize(runtimeVersion.specName)} specVersion: ${runtimeVersion.specVersion}`);
+    const extrinsics = await block.extrinsics;
+    const txIndex = extrinsics.findIndex((tx)=>blake2AsHex(tx) === txHash);
+    const tracingBlock = new Block(chain, block.number, block.hash, parent, {
+        header,
+        extrinsics: [],
+        storage: parent.storage
+    });
+    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/esm/utils/tunnel.js

@@ -1,5 +1,6 @@
 import { bootstrap } from 'global-agent';
 bootstrap();
+import { environment } from '@acala-network/chopsticks-core';
 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;
+global.GLOBAL_AGENT.HTTP_PROXY = environment.HTTP_PROXY || environment.http_proxy || environment.HTTPS_PROXY || environment.https_proxy || npmConfig.get('proxy') || npmConfig.get('https-proxy') || global.GLOBAL_AGENT.HTTP_PROXY;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks",
-  "version": "0.9.13",
+  "version": "0.10.0-2",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "bin": "./chopsticks.cjs",
@@ -13,8 +13,8 @@
     "docs:prep": "typedoc"
   },
   "dependencies": {
-    "@acala-network/chopsticks-core": "0.9.13",
-    "@acala-network/chopsticks-db": "0.9.13",
+    "@acala-network/chopsticks-core": "0.10.0-2",
+    "@acala-network/chopsticks-db": "0.10.0-2",
     "@pnpm/npm-conf": "^2.2.2",
     "@polkadot/api-augment": "^10.11.2",
     "@polkadot/types": "^10.11.2",