add execute block call in follow-chain

packages/chopsticks/src/plugins/follow-chain/index.ts

@@ -1,5 +1,5 @@
 import { Block, defaultLogger, printRuntimeLogs, runTask, taskHandler } from '@acala-network/chopsticks-core'
-import { Header } from '@polkadot/types/interfaces'
+import { Block as BlockType, Header } from '@polkadot/types/interfaces'
 import { HexString } from '@polkadot/util/types'
 import _ from 'lodash'
 import type { Argv } from 'yargs'
@@ -29,12 +29,19 @@ export const cli = (y: Argv) => {
           choices: ['latest', 'finalized'],
           default: 'finalized',
         },
+        'execute-block': {
+          desc: 'Call TryRuntime_execute_block, make sure the wasm is provided and built with `try-runtime` feature',
+          boolean: true,
+        },
       }),
     async (argv) => {
       const port = argv.port ?? 8000
       const endpoint = argv.endpoint as string
       if (/^(https|http):\/\//.test(endpoint || '')) {
-        throw Error('http provider is not supported')
+        throw Error('http endpoint is not supported')
+      }
+      if (argv.executeBlock && !argv.wasmOverride) {
+        throw Error('`execute-block` requires `wasm-override`')
       }
 
       const context = await setupContext(argv as Config, true)
@@ -54,33 +61,80 @@ export const cli = (y: Argv) => {
             const header = registry.createType<Header>('Header', data)
             const wasm = await parent.wasm
 
-            const block = new Block(chain, header.number.toNumber(), header.hash.toHex(), parent)
+            const block = new Block(chain, header.number.toNumber(), header.hash.toHex(), parent, {
+              storage: parent.storage,
+            })
             await chain.setHead(block)
 
-            const calls: [string, HexString[]][] = [['Core_initialize_block', [header.toHex()]]]
+            {
+              // replay block
+              const calls: [string, HexString[]][] = [['Core_initialize_block', [header.toHex()]]]
 
-            for (const extrinsic of await block.extrinsics) {
-              calls.push(['BlockBuilder_apply_extrinsic', [extrinsic]])
-            }
+              for (const extrinsic of await block.extrinsics) {
+                calls.push(['BlockBuilder_apply_extrinsic', [extrinsic]])
+              }
+
+              calls.push(['BlockBuilder_finalize_block', []])
+
+              const runBlockResult = await runTask(
+                {
+                  wasm,
+                  calls,
+                  mockSignatureHost: false,
+                  allowUnresolvedImports: false,
+                  runtimeLogLevel: (argv.runtimeLogLevel as number) || 0,
+                },
+                taskHandler(parent),
+              )
+
+              if ('Error' in runBlockResult) {
+                throw new Error(runBlockResult.Error)
+              }
 
-            calls.push(['BlockBuilder_finalize_block', []])
-
-            const result = await runTask(
-              {
-                wasm,
-                calls,
-                mockSignatureHost: false,
-                allowUnresolvedImports: false,
-                runtimeLogLevel: (argv.runtimeLogLevel as number) || 0,
-              },
-              taskHandler(parent),
-            )
-
-            if ('Error' in result) {
-              throw new Error(result.Error)
+              printRuntimeLogs(runBlockResult.Call.runtimeLogs)
             }
 
-            printRuntimeLogs(result.Call.runtimeLogs)
+            {
+              // try execute block
+              if (!argv.executeBlock) return
+              registry.register({
+                TryStateSelect: {
+                  _enum: {
+                    None: null,
+                    All: null,
+                    RoundRobin: 'u32',
+                    Only: 'Vec<Vec<u8>>',
+                  },
+                },
+              })
+
+              const blockData = registry.createType<BlockType>('Block', {
+                header: await block.header,
+                extrinsics: await block.extrinsics,
+              })
+
+              const select_try_state = registry.createType('TryStateSelect', 'All')
+
+              const calls: [string, HexString[]][] = [
+                ['TryRuntime_execute_block', [blockData.toHex(), '0x00', '0x00', select_try_state.toHex()]],
+              ]
+
+              const executeBlockResult = await runTask(
+                {
+                  wasm,
+                  calls,
+                  mockSignatureHost: false,
+                  allowUnresolvedImports: false,
+                  runtimeLogLevel: (argv.runtimeLogLevel as number) || 0,
+                },
+                taskHandler(parent),
+              )
+
+              if ('Error' in executeBlockResult) {
+                throw new Error(executeBlockResult.Error)
+              }
+              printRuntimeLogs(executeBlockResult.Call.runtimeLogs)
+            }
           } catch (e) {
             logger.error(e, 'Error when processing new head')
             await close()

packages/core/src/blockchain/block.ts

@@ -53,9 +53,9 @@ export class Block {
     parentBlock?: Block,
     block?: {
       /** See `@polkadot/types/interfaces` Header */
-      header: Header
+      header?: Header
       /** Extrinsics */
-      extrinsics: HexString[]
+      extrinsics?: HexString[]
       /** Storage provider. Default to {@link RemoteStorageLayer} with {@link Blockchain.api chain.api} as remote. */
       storage?: StorageLayerProvider
       /** Storage diff to apply. */