View function poc - do not merge

executor/src/task.rs

@@ -71,6 +71,7 @@ pub struct TaskCall {
 pub struct CallResponse {
     result: HexString,
     storage_diff: Vec<(HexString, Option<HexString>)>,
+	accessed_storage_keys: Vec<HexString>,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -101,6 +102,8 @@ pub async fn run_task(task: TaskCall, js: crate::JsCallback) -> Result<TaskRespo
     .unwrap();
     let mut ret: Result<Vec<u8>, String> = Ok(Vec::new());
 
+	let mut keys: Vec<HexString> = Vec::new();
+
     for (call, params) in task.calls.as_ref().unwrap() {
         let mut vm = runtime_host::run(runtime_host::Config {
             virtual_machine: vm_proto.clone(),
@@ -121,6 +124,9 @@ pub async fn run_task(task: TaskCall, js: crate::JsCallback) -> Result<TaskRespo
                 }
                 RuntimeHostVm::StorageGet(req) => {
                     let key = HexString(req.key().as_ref().to_vec());
+
+					keys.push(key.clone());
+
                     let key = serde_wasm_bindgen::to_value(&key).map_err(|e| e.to_string())?;
                     let value = js.get_storage(key).await;
                     let value = if value.is_string() {
@@ -202,6 +208,7 @@ pub async fn run_task(task: TaskCall, js: crate::JsCallback) -> Result<TaskRespo
         TaskResponse::Call(CallResponse {
             result: HexString(ret),
             storage_diff: diff,
+			accessed_storage_keys: keys,
         })
     }))
 }

src/api.ts

@@ -44,6 +44,10 @@ export class Api {
     return this.#provider.disconnect()
   }
 
+  get provider() {
+    return this.#provider
+  }
+
   get isReady() {
     if (this.#provider instanceof WsProvider) {
       return this.#provider.isReady

src/index.ts

@@ -13,6 +13,7 @@ import { dryRun } from './dry-run'
 import { runBlock } from './run-block'
 import { setup } from './setup'
 import { setupWithServer } from './setup-with-server'
+import { nonce } from './nonce'
 
 const processConfig = (path: string) => {
   const configFile = readFileSync(path, 'utf8')
@@ -110,6 +111,31 @@ yargs(hideBin(process.argv))
       await dryRun(processArgv(argv))
     }
   )
+  .command(
+    'nonce',
+    'get nonce',
+    (yargs) =>
+      yargs.options({
+        ...defaultOptions,
+        'account-id': {
+          desc: 'Account id hex string',
+          string: true,
+        },
+        'output-path': {
+          desc: 'File path to print output',
+          string: true,
+        },
+        html: {
+          desc: 'Generate html with storage diff',
+        },
+        open: {
+          desc: 'Open generated html',
+        },
+      }),
+    async (argv) => {
+      await nonce(processArgv(argv))
+    }
+  )
   .command(
     'dev',
     'Dev mode',

src/nonce.ts

@@ -0,0 +1,48 @@
+import { ApiPromise } from '@polkadot/api'
+import { TypeRegistry } from '@polkadot/types'
+import { hexToU8a } from '@polkadot/util'
+
+import { Config } from './schema'
+import { runTask, taskHandler } from './executor'
+import { setup } from './setup'
+
+export const nonce = async (argv: Config) => {
+  const accountId = argv['accountId'] as `0x${string}`
+
+  const context = await setup(argv)
+  const wasm = await context.chain.head.wasm
+  const block = context.chain.head
+  const parent = await block.parentBlock
+
+  const getNonce = async () => {
+    const result = await runTask(
+      {
+        wasm,
+        calls: [['AccountNonceApi_account_nonce', accountId]],
+        storage: [],
+        mockSignatureHost: false,
+        allowUnresolvedImports: false,
+      },
+      taskHandler(parent)
+    )
+    if (result.Error) {
+      throw new Error(result.Error)
+    }
+
+    const registry = new TypeRegistry();
+    return {
+      result: registry.createType('u64', hexToU8a(result.Call.result)).toNumber(),
+      accessedStorageKeys: result.Call.accessedStorageKeys,
+    }
+  }
+
+  const { accessedStorageKeys } = await getNonce()
+
+  const api = await ApiPromise.create({ provider: context.api.provider })
+  const unsub = await api.rpc.state.subscribeStorage(accessedStorageKeys, async (_changes) => {
+    const nonce = await getNonce();
+    console.log('>>> nonce:', nonce.result)
+  })
+
+  // process.exit(0)
+}