Use dryRunExtrinsicsAmortized for proxy call-filtering loop

Replaces the sendTransaction + newBlock per-proxy-action loop with a single dryRunExtrinsicsAmortized batch. Pre-signs every action with the proxy account's current nonce (storage layer pops between extrinsics revert nonce, so sequential nonces would be rejected). Adds eventsFromAmortizedDryRunResult helper that decodes the system events Vec from a per-extrinsic storageDiff and returns a { events: Promise<Codec[]> } shape compatible with checkEvents. Verified locally on Polkadot proxy filtering tests (16 of 16 pass).

Author: rockbmb

packages/shared/src/helpers/index.ts

@@ -780,3 +780,22 @@ export async function testCallsViaForceBatch(
     }
   }
 }
+
+/**
+ * Decode the `system.events` value from a `dryRunExtrinsicsAmortized` storageDiff.
+ *
+ * Returns an object shaped like the one `sendTransaction` returns (`{ events: Promise<Codec[]> }`)
+ * so it can be passed straight to `checkEvents`.
+ */
+export function eventsFromAmortizedDryRunResult(
+  api: ApiPromise,
+  storageDiff: [HexString, HexString | null][],
+): { events: Promise<EventRecord[]> } {
+  const eventsKey = api.query.system.events.key()
+  const entry = storageDiff.find(([k]) => k.toLowerCase() === eventsKey.toLowerCase())
+  const decoded =
+    entry && entry[1] !== null
+      ? (api.createType('Vec<FrameSystemEventRecord>', entry[1]) as unknown as EventRecord[])
+      : []
+  return { events: Promise.resolve(decoded) }
+}

packages/shared/src/proxy.ts

@@ -16,12 +16,20 @@ import type { KeyringPair } from '@polkadot/keyring/types'
 import type { Vec } from '@polkadot/types'
 import type { PalletProxyProxyDefinition } from '@polkadot/types/lookup'
 import type { ISubmittableResult } from '@polkadot/types/types'
+import type { HexString } from '@polkadot/util/types'
 import { encodeAddress } from '@polkadot/util-crypto'
 
 import { assert, expect } from 'vitest'
 
 import BN from 'bn.js'
-import { blockProviderOffset, check, checkEvents, getBlockNumber, type TestConfig } from './helpers/index.js'
+import {
+  blockProviderOffset,
+  check,
+  checkEvents,
+  eventsFromAmortizedDryRunResult,
+  getBlockNumber,
+  type TestConfig,
+} from './helpers/index.js'
 
 /// -------
 /// Helpers
@@ -1244,17 +1252,25 @@ async function proxyCallFilteringSingleTestRunner<
     },
   })
 
-  // Execute each proxy action in its own block and check its results immediately
-  for (const proxyAction of proxyActions) {
-    // Execute the proxy action
-    const proxyTx = client.api.tx.proxy.proxy(alice.address, proxyTypeIx, proxyAction.call)
-    const result = await sendTransaction(proxyTx.signAsync(proxyAccount))
+  // Same base nonce for every action: dryRunExtrinsicsAmortized rolls back nonce per call.
+  const proxyAccountInfo = await client.api.query.system.account(proxyAccount.address)
+  const baseNonce = proxyAccountInfo.nonce.toNumber()
+
+  const signedExtrinsics = await Promise.all(
+    proxyActions.map((proxyAction) =>
+      client.api.tx.proxy
+        .proxy(alice.address, proxyTypeIx, proxyAction.call)
+        .signAsync(proxyAccount, { nonce: baseNonce })
+        .then((signed) => signed.toHex() as HexString),
+    ),
+  )
 
-    // Advance to the next block to ensure events are processed
-    await client.dev.newBlock()
+  const dryRunResults = await client.chain.dryRunExtrinsicsAmortized(signedExtrinsics)
 
-    // Check the events for this specific call
-    const events = await client.api.query.system.events()
+  for (let i = 0; i < proxyActions.length; i++) {
+    const proxyAction = proxyActions[i]
+    const result = eventsFromAmortizedDryRunResult(client.api, dryRunResults[i].storageDiff)
+    const events = await result.events
     const proxyExecutedEvents = events.filter((record) => {
       const { event } = record
       return event.section === 'proxy' && event.method === 'ProxyExecuted'