add dryRun rpc

e2e/dev.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import { u8aToHex } from '@polkadot/util'
 
-import { api, dev, env, expectJson, setupApi, testingPairs } from './helper'
+import { api, dev, env, expectJson, setupApi, testingPairs, ws } from './helper'
 
 setupApi(env.mandala)
 
@@ -63,4 +63,22 @@ describe('dev rpc', () => {
     const timestamp = await dev.timeTravel(date)
     expect(timestamp).eq(Date.parse(date))
   })
+
+  it('dryRun', async () => {
+    const params = [
+      {
+        raw: false,
+        hrmp: {
+          '2034': [
+            {
+              send_at: 13740000,
+              data: '0x000210000400000106540254a37a01cd75b616d63e0ab665bffdb0143c52ae0013000064a7b3b6e00d0a1300000106540254a37a01cd75b616d63e0ab665bffdb0143c52ae0013000064a7b3b6e00d010700f2052a010d010004000101008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48',
+            },
+          ],
+        },
+      },
+    ]
+    const resp = await ws.send('dev_dryRun', params)
+    expect(resp.delta).toMatchSnapshot()
+  })
 })

e2e/dry-run-extrinsic.test.ts

@@ -15,7 +15,7 @@ describe('dry-run-extrinsic', () => {
       },
     })
     const extrinsic = await api.tx.balances.transfer(bob.address, 1e12).signAsync(alice)
-    const { outcome, storageDiff } = await chain.dryRun(extrinsic.toHex())
+    const { outcome, storageDiff } = await chain.dryRunExtrinsic(extrinsic.toHex())
     expect(outcome.toHuman()).toMatchSnapshot()
     expect(storageDiff).toMatchSnapshot()
   })

src/blockchain/block-builder.ts

@@ -175,3 +175,12 @@ export const dryRunExtrinsic = async (
   const newBlock = await initNewBlock(head, header, inherents)
   return newBlock.call('BlockBuilder_apply_extrinsic', extrinsic)
 }
+
+export const dryRunInherents = async (
+  head: Block,
+  inherents: HexString[]
+): Promise<[HexString, HexString | null][]> => {
+  const header = await newHeader(head)
+  const newBlock = await initNewBlock(head, header, inherents)
+  return Object.entries(await newBlock.storageDiff()) as [HexString, HexString | null][]
+}

src/blockchain/block.ts

@@ -131,7 +131,7 @@ export class Block {
     this.#storages.pop()
   }
 
-  async storageDiff(): Promise<Record<string, string>> {
+  async storageDiff(): Promise<Record<HexString, HexString | null>> {
     const storage = {}
 
     for (const layer of this.#storages) {

src/blockchain/index.ts

@@ -7,11 +7,11 @@ import type { TransactionValidity } from '@polkadot/types/interfaces/txqueue'
 
 import { Api } from '../api'
 import { Block } from './block'
-import { BuildBlockMode, BuildBlockParams, TxPool } from './txpool'
+import { BuildBlockMode, BuildBlockParams, HorizontalMessage, TxPool } from './txpool'
 import { HeadState } from './head-state'
 import { InherentProvider } from './inherent'
 import { defaultLogger } from '../logger'
-import { dryRunExtrinsic } from './block-builder'
+import { dryRunExtrinsic, dryRunInherents } from './block-builder'
 
 const logger = defaultLogger.child({ name: 'blockchain' })
 
@@ -160,7 +160,7 @@ export class Blockchain {
     return this.#head
   }
 
-  async dryRun(
+  async dryRunExtrinsic(
     extrinsic: HexString
   ): Promise<{ outcome: ApplyExtrinsicResult; storageDiff: [HexString, HexString | null][] }> {
     await this.api.isReady
@@ -171,4 +171,11 @@ export class Blockchain {
     const outcome = registry.createType<ApplyExtrinsicResult>('ApplyExtrinsicResult', result)
     return { outcome, storageDiff }
   }
+
+  async dryRunHrmp(hrmp: Record<number, HorizontalMessage[]>): Promise<[HexString, HexString | null][]> {
+    await this.api.isReady
+    const head = this.head
+    const inherents = await this.#inherentProvider.createInherents(head, { horizontalMessages: hrmp })
+    return dryRunInherents(head, inherents)
+  }
 }

src/dry-run.ts

@@ -2,21 +2,25 @@ import { blake2AsHex } from '@polkadot/util-crypto'
 import { writeFileSync } from 'node:fs'
 
 import { Config } from './schema'
-import { generateHtmlDiff } from './utils/generate-html-diff'
+import { generateHtmlDiffPreviewFile } from './utils/generate-html-diff'
 import { openHtml } from './utils/open-html'
 import { setup } from './setup'
 
 export const dryRun = async (argv: Config) => {
   const context = await setup(argv)
 
-  const { outcome, storageDiff } = await context.chain.dryRun(argv['extrinsic'])
+  const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(argv['extrinsic'])
 
   if (outcome.isErr) {
     throw new Error(outcome.asErr.toString())
   }
 
   if (argv['html']) {
-    const filePath = await generateHtmlDiff(context.chain.head, storageDiff, blake2AsHex(argv['extrinsic'], 256))
+    const filePath = await generateHtmlDiffPreviewFile(
+      context.chain.head,
+      storageDiff,
+      blake2AsHex(argv['extrinsic'], 256)
+    )
     console.log(`Generated preview ${filePath}`)
     if (argv['open']) {
       openHtml(filePath)

src/rpc/dev.ts

@@ -1,7 +1,10 @@
-import { Handlers, ResponseError } from './shared'
 import { HexString } from '@polkadot/util/types'
+
+import { Handlers, ResponseError } from './shared'
 import { StorageValues, setStorage } from '../utils/set-storage'
+import { decodeStorageDiff } from '../utils/decoder'
 import { defaultLogger } from '../logger'
+import { generateHtmlDiff } from '../utils/generate-html-diff'
 import { timeTravel } from '../utils/time-travel'
 
 const logger = defaultLogger.child({ name: 'rpc-dev' })
@@ -45,6 +48,31 @@ const handlers: Handlers = {
     await timeTravel(context.chain, timestamp)
     return timestamp
   },
+  dev_dryRun: async (context, [{ html, extrinsic, hrmp, raw }]) => {
+    const dryRun = async () => {
+      if (extrinsic) {
+        const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(extrinsic)
+        if (outcome.isErr) {
+          throw new Error(outcome.asErr.toString())
+        }
+        return storageDiff
+      }
+      return context.chain.dryRunHrmp(hrmp)
+    }
+    const storageDiff = await dryRun()
+    if (html) {
+      return generateHtmlDiff(context.chain.head, storageDiff)
+    }
+    if (raw) {
+      return storageDiff
+    }
+    const [oldData, newData, delta] = await decodeStorageDiff(context.chain.head, storageDiff)
+    return {
+      old: oldData,
+      new: newData,
+      delta,
+    }
+  },
 }
 
 export default handlers

src/run-block.ts

@@ -2,7 +2,7 @@ import { HexString } from '@polkadot/util/types'
 import { writeFileSync } from 'node:fs'
 
 import { Config } from './schema'
-import { generateHtmlDiff } from './utils/generate-html-diff'
+import { generateHtmlDiffPreviewFile } from './utils/generate-html-diff'
 import { openHtml } from './utils/open-html'
 import { runTask, taskHandler } from './executor'
 import { setup } from './setup'
@@ -40,7 +40,7 @@ export const runBlock = async (argv: Config) => {
   }
 
   if (argv['html']) {
-    const filePath = await generateHtmlDiff(block, result.Call.storageDiff, block.hash)
+    const filePath = await generateHtmlDiffPreviewFile(block, result.Call.storageDiff, block.hash)
     console.log(`Generated preview ${filePath}`)
     if (argv['open']) {
       openHtml(filePath)

src/utils/decoder.ts

@@ -3,6 +3,7 @@ import { Block } from '../blockchain/block'
 import { HexString } from '@polkadot/util/types'
 import { StorageEntry } from '@polkadot/types/primitive/types'
 import { StorageKey } from '@polkadot/types'
+import { blake2AsHex } from '@polkadot/util-crypto'
 import { create } from 'jsondiffpatch'
 import { hexToU8a, u8aToHex } from '@polkadot/util'
 import _ from 'lodash'
@@ -53,15 +54,21 @@ export const decodeKeyValue = async (block: Block, key: HexString, value?: HexSt
     return { [key]: value }
   }
 
-  const decodedValue = value ? meta.registry.createType(decodedKey.outputType, hexToU8a(value)).toHuman() : null
+  const decodeValue = () => {
+    if (!value) return null
+    if (storage.section === 'substrate' && storage.method === 'code') {
+      return `:code blake2_256 ${blake2AsHex(value, 256)} (${hexToU8a(value).length} bytes)`
+    }
+    return meta.registry.createType(decodedKey.outputType, hexToU8a(value)).toHuman()
+  }
 
   switch (decodedKey.args.length) {
     case 2: {
       return {
         [storage.section]: {
           [storage.method]: {
             [decodedKey.args[0].toString()]: {
-              [decodedKey.args[1].toString()]: decodedValue,
+              [decodedKey.args[1].toString()]: decodeValue(),
             },
           },
         },
@@ -71,15 +78,15 @@ export const decodeKeyValue = async (block: Block, key: HexString, value?: HexSt
       return {
         [storage.section]: {
           [storage.method]: {
-            [decodedKey.args[0].toString()]: decodedValue,
+            [decodedKey.args[0].toString()]: decodeValue(),
           },
         },
       }
     }
     default:
       return {
         [storage.section]: {
-          [storage.method]: decodedValue,
+          [storage.method]: decodeValue(),
         },
       }
   }

src/utils/generate-html-diff.ts

@@ -4,10 +4,18 @@ import { decodeStorageDiff } from './decoder'
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { template } from 'lodash'
 
-export const generateHtmlDiff = async (block: Block, diff: [HexString, HexString | null][], filename: string) => {
+export const generateHtmlDiff = async (block: Block, diff: [HexString, HexString | null][]) => {
   const [left, _right, delta] = await decodeStorageDiff(block, diff)
   const htmlTemplate = readFileSync('./template/diff.html', 'utf-8')
-  const html = template(htmlTemplate)({ left: JSON.stringify(left), delta: JSON.stringify(delta) })
+  return template(htmlTemplate)({ left: JSON.stringify(left), delta: JSON.stringify(delta) })
+}
+
+export const generateHtmlDiffPreviewFile = async (
+  block: Block,
+  diff: [HexString, HexString | null][],
+  filename: string
+) => {
+  const html = await generateHtmlDiff(block, diff)
   mkdirSync('./preview', { recursive: true })
   const filePath = `./preview/${filename}.html`
   writeFileSync(filePath, html)