chore(port): forward-port v5-next cli/bot/docs backlog to next (#24934)

Forward-ports the small **cli / bot / docs** commits of the v5-next →
next backlog, plus an owner checklist for the spartan-config and
standard-contract-repin commits (both need an explicit v6 decision — see
below).

## Applied (clean cherry-picks, chronological)
- perf(bot): parallelize independent bot factory setup steps (#24581)
- docs: revert threat model for node (#24465) (#24610)
- feat(cli): support funding accounts in validator-keys
new/set-funding-account (#24476)

## ⚠️ Needs owner conflict-resolution (conflict against reshaped `next`;
not included here)
Cherry-pick onto this branch and resolve:
- [x] `git cherry-pick -x 38202d9` — chore(spartan): restore 7 day
mainnet slash grace period (#24804)
- [x] `git cherry-pick -x c3a2a85` — chore: re-pin handshake registry
with owner-bound nullifiers (#24893)

Part of the manual v5-next → next backlog sweep. Draft until conflicts
are resolved and CI is green.

Author: spalladino

yarn-project/THREAT_MODEL.md

@@ -0,0 +1,87 @@
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import type { AztecNode, AztecNodeAdmin, AztecNodeAdminConfig } from '@aztec/stdlib/interfaces/client';
+import type { EmbeddedWallet } from '@aztec/wallets/embedded';
+
+import { mock } from 'jest-mock-extended';
+
+import { type BotConfig, getBotDefaultConfig } from './config.js';
+import { BotFactory } from './factory.js';
+import type { BotStore } from './store/index.js';
+
+class TestBotFactory extends BotFactory {
+  public override withNoMinTxsPerBlock<T>(fn: () => Promise<T>): Promise<T> {
+    return super.withNoMinTxsPerBlock(fn);
+  }
+}
+
+describe('BotFactory.withNoMinTxsPerBlock', () => {
+  let minTxsPerBlock: number | undefined;
+  let setConfigCalls: (number | undefined)[];
+  let factory: TestBotFactory;
+
+  beforeEach(() => {
+    minTxsPerBlock = 3;
+    setConfigCalls = [];
+
+    const aztecNodeAdmin = mock<AztecNodeAdmin>();
+    aztecNodeAdmin.getConfig.mockImplementation(() => Promise.resolve({ minTxsPerBlock } as AztecNodeAdminConfig));
+    aztecNodeAdmin.setConfig.mockImplementation(config => {
+      setConfigCalls.push(config.minTxsPerBlock);
+      minTxsPerBlock = config.minTxsPerBlock;
+      return Promise.resolve();
+    });
+
+    const config: BotConfig = { ...getBotDefaultConfig(), flushSetupTransactions: true };
+    const wallet = mock<EmbeddedWallet>();
+    factory = new TestBotFactory(config, wallet, mock<BotStore>(), mock<AztecNode>(), aztecNodeAdmin);
+  });
+
+  it('zeroes minTxsPerBlock around a call and restores it after', async () => {
+    await factory.withNoMinTxsPerBlock(() => {
+      expect(minTxsPerBlock).toBe(0);
+      return Promise.resolve();
+    });
+
+    expect(setConfigCalls).toEqual([0, 3]);
+    expect(minTxsPerBlock).toBe(3);
+  });
+
+  it('zeroes once and restores once across overlapping calls', async () => {
+    const gates = [promiseWithResolvers<void>(), promiseWithResolvers<void>(), promiseWithResolvers<void>()];
+    const calls = gates.map(gate => factory.withNoMinTxsPerBlock(() => gate.promise));
+
+    gates[0].resolve();
+    await calls[0];
+    expect(minTxsPerBlock).toBe(0);
+
+    gates[1].resolve();
+    await calls[1];
+    expect(minTxsPerBlock).toBe(0);
+
+    gates[2].resolve();
+    await calls[2];
+    expect(setConfigCalls).toEqual([0, 3]);
+    expect(minTxsPerBlock).toBe(3);
+  });
+
+  it('restores minTxsPerBlock when the wrapped call fails', async () => {
+    await expect(factory.withNoMinTxsPerBlock(() => Promise.reject(new Error('boom')))).rejects.toThrow('boom');
+
+    expect(setConfigCalls).toEqual([0, 3]);
+    expect(minTxsPerBlock).toBe(3);
+  });
+
+  it('restores minTxsPerBlock when one of several overlapping calls fails', async () => {
+    const gate = promiseWithResolvers<void>();
+    const failing = factory.withNoMinTxsPerBlock(() => Promise.reject(new Error('boom')));
+    const succeeding = factory.withNoMinTxsPerBlock(() => gate.promise);
+
+    await expect(failing).rejects.toThrow('boom');
+    expect(minTxsPerBlock).toBe(0);
+
+    gate.resolve();
+    await succeeding;
+    expect(setConfigCalls).toEqual([0, 3]);
+    expect(minTxsPerBlock).toBe(3);
+  });
+});