test(security): migrate Allowlist suite to async simulator

The merge of OpenZeppelin#620 moved every unit suite to the async, backend-aware
@openzeppelin/compact-simulator@0.2.0 API, but the Allowlist suite added
on this branch still used the synchronous createSimulator path, so its
spec fails to load against 0.2.0 and breaks the test workflow on OpenZeppelin#625.

* AllowlistSimulator: drop the sync constructor for `static async
  create`, add `artifactName: 'MockAllowlist'`, and return `Promise<R>`
  from every impure pass-through (assertAllowed/allow/disallow return
  `Promise<[]>`, isAllowed returns `Promise<boolean>`).
* Allowlist.test.ts: create the simulator in the async `beforeEach`,
  await every circuit call and `getPublicState`, and assert the
  not-allowed path with `await expect(...).rejects.toThrow(...)`.

No behavioral change; mechanical, mirrors the OpenZeppelin#620 migration pattern.

Author: 0xisk

contracts/src/security/test/Allowlist.test.ts

@@ -14,110 +14,114 @@ const BOB = account('BOB');
 let allowlist: AllowlistSimulator;
 
 describe('Allowlist', () => {
-  beforeEach(() => {
-    allowlist = new AllowlistSimulator();
+  beforeEach(async () => {
+    allowlist = await AllowlistSimulator.create();
   });
 
   describe('default state', () => {
-    it('is empty: no account is allowed', () => {
-      expect(allowlist.isAllowed(ALICE)).toBe(false);
-      expect(allowlist.isAllowed(BOB)).toBe(false);
+    it('is empty: no account is allowed', async () => {
+      expect(await allowlist.isAllowed(ALICE)).toBe(false);
+      expect(await allowlist.isAllowed(BOB)).toBe(false);
     });
 
-    it('assertAllowed throws for a non-member', () => {
-      expect(() => allowlist.assertAllowed(ALICE)).toThrow(
+    it('assertAllowed throws for a non-member', async () => {
+      await expect(allowlist.assertAllowed(ALICE)).rejects.toThrow(
         'Allowlist: account not allowed',
       );
     });
   });
 
   describe('allow', () => {
-    it('adds an account to the allowlist', () => {
-      allowlist.allow(ALICE);
-      expect(allowlist.isAllowed(ALICE)).toBe(true);
+    it('adds an account to the allowlist', async () => {
+      await allowlist.allow(ALICE);
+      expect(await allowlist.isAllowed(ALICE)).toBe(true);
     });
 
-    it('does not affect other accounts', () => {
-      allowlist.allow(ALICE);
-      expect(allowlist.isAllowed(BOB)).toBe(false);
+    it('does not affect other accounts', async () => {
+      await allowlist.allow(ALICE);
+      expect(await allowlist.isAllowed(BOB)).toBe(false);
     });
 
-    it('assertAllowed passes for a member', () => {
-      allowlist.allow(ALICE);
-      expect(() => allowlist.assertAllowed(ALICE)).not.toThrow();
+    it('assertAllowed passes for a member', async () => {
+      await allowlist.allow(ALICE);
+      await allowlist.assertAllowed(ALICE);
     });
 
-    it('is idempotent', () => {
-      allowlist.allow(ALICE);
-      allowlist.allow(ALICE);
-      expect(allowlist.isAllowed(ALICE)).toBe(true);
+    it('is idempotent', async () => {
+      await allowlist.allow(ALICE);
+      await allowlist.allow(ALICE);
+      expect(await allowlist.isAllowed(ALICE)).toBe(true);
     });
 
-    it('clears with a single disallow after being allowed multiple times', () => {
-      allowlist.allow(ALICE);
-      allowlist.allow(ALICE);
-      expect(allowlist.isAllowed(ALICE)).toBe(true);
-      allowlist.disallow(ALICE);
+    it('clears with a single disallow after being allowed multiple times', async () => {
+      await allowlist.allow(ALICE);
+      await allowlist.allow(ALICE);
+      expect(await allowlist.isAllowed(ALICE)).toBe(true);
+      await allowlist.disallow(ALICE);
       // Membership is binary, not a counter: one disallow clears it regardless
       // of how many times it was allowed.
-      expect(allowlist.isAllowed(ALICE)).toBe(false);
+      expect(await allowlist.isAllowed(ALICE)).toBe(false);
     });
   });
 
   describe('disallow', () => {
-    it('removes an account from the allowlist', () => {
-      allowlist.allow(ALICE);
-      allowlist.disallow(ALICE);
-      expect(allowlist.isAllowed(ALICE)).toBe(false);
+    it('removes an account from the allowlist', async () => {
+      await allowlist.allow(ALICE);
+      await allowlist.disallow(ALICE);
+      expect(await allowlist.isAllowed(ALICE)).toBe(false);
     });
 
-    it('assertAllowed throws again after disallow', () => {
-      allowlist.allow(ALICE);
-      allowlist.disallow(ALICE);
-      expect(() => allowlist.assertAllowed(ALICE)).toThrow(
+    it('assertAllowed throws again after disallow', async () => {
+      await allowlist.allow(ALICE);
+      await allowlist.disallow(ALICE);
+      await expect(allowlist.assertAllowed(ALICE)).rejects.toThrow(
         'Allowlist: account not allowed',
       );
     });
 
-    it('is a no-op for a non-member', () => {
-      allowlist.disallow(BOB);
-      expect(allowlist.isAllowed(BOB)).toBe(false);
+    it('is a no-op for a non-member', async () => {
+      await allowlist.disallow(BOB);
+      expect(await allowlist.isAllowed(BOB)).toBe(false);
     });
   });
 
   describe('multiple operations', () => {
-    it('handles allow -> disallow -> allow', () => {
-      allowlist.allow(ALICE);
-      expect(allowlist.isAllowed(ALICE)).toBe(true);
+    it('handles allow -> disallow -> allow', async () => {
+      await allowlist.allow(ALICE);
+      expect(await allowlist.isAllowed(ALICE)).toBe(true);
 
-      allowlist.disallow(ALICE);
-      expect(allowlist.isAllowed(ALICE)).toBe(false);
+      await allowlist.disallow(ALICE);
+      expect(await allowlist.isAllowed(ALICE)).toBe(false);
 
-      allowlist.allow(ALICE);
-      expect(allowlist.isAllowed(ALICE)).toBe(true);
+      await allowlist.allow(ALICE);
+      expect(await allowlist.isAllowed(ALICE)).toBe(true);
     });
 
-    it('tracks several accounts independently', () => {
-      allowlist.allow(ALICE);
-      expect(allowlist.isAllowed(ALICE)).toBe(true);
-      expect(allowlist.isAllowed(BOB)).toBe(false);
+    it('tracks several accounts independently', async () => {
+      await allowlist.allow(ALICE);
+      expect(await allowlist.isAllowed(ALICE)).toBe(true);
+      expect(await allowlist.isAllowed(BOB)).toBe(false);
 
-      allowlist.allow(BOB);
-      allowlist.disallow(ALICE);
-      expect(allowlist.isAllowed(ALICE)).toBe(false);
-      expect(allowlist.isAllowed(BOB)).toBe(true);
+      await allowlist.allow(BOB);
+      await allowlist.disallow(ALICE);
+      expect(await allowlist.isAllowed(ALICE)).toBe(false);
+      expect(await allowlist.isAllowed(BOB)).toBe(true);
     });
   });
 
   describe('simulator wiring', () => {
-    it('exposes the public ledger via getPublicState', () => {
-      const sim = new AllowlistSimulator();
+    it('exposes the public ledger via getPublicState', async () => {
+      const sim = await AllowlistSimulator.create();
 
-      expect(sim.getPublicState().Allowlist__allowed.member(ALICE)).toBe(false);
+      expect(
+        (await sim.getPublicState()).Allowlist__allowed.member(ALICE),
+      ).toBe(false);
 
-      sim.allow(ALICE);
+      await sim.allow(ALICE);
 
-      expect(sim.getPublicState().Allowlist__allowed.member(ALICE)).toBe(true);
+      expect(
+        (await sim.getPublicState()).Allowlist__allowed.member(ALICE),
+      ).toBe(true);
     });
   });
 });

contracts/src/security/test/simulators/AllowlistSimulator.ts

@@ -1,6 +1,6 @@
 import {
-  type BaseSimulatorOptions,
   createSimulator,
+  type SimulatorOptions,
 } from '@openzeppelin/compact-simulator';
 import {
   ledger,
@@ -29,47 +29,49 @@ const AllowlistSimulatorBase = createSimulator<
   contractArgs: () => [],
   ledgerExtractor: (state) => ledger(state),
   witnessesFactory: () => AllowlistWitnesses(),
+  artifactName: 'MockAllowlist',
 });
 
 /**
  * Allowlist Simulator
  */
 export class AllowlistSimulator extends AllowlistSimulatorBase {
-  constructor(
-    options: BaseSimulatorOptions<
+  static async create(
+    options: SimulatorOptions<
       AllowlistPrivateState,
       ReturnType<typeof AllowlistWitnesses>
     > = {},
-  ) {
-    super([], options);
+  ): Promise<AllowlistSimulator> {
+    // biome-ignore lint/complexity/noThisInStatic: super.create must keep the subclass `this`
+    return super.create([], options) as Promise<AllowlistSimulator>;
   }
 
   /**
    * @description Returns whether `account` is currently allowed.
    * @returns True if `account` is a member of the allowlist.
    */
-  public isAllowed(account: Uint8Array): boolean {
+  public isAllowed(account: Uint8Array): Promise<boolean> {
     return this.circuits.impure.isAllowed(account);
   }
 
   /**
    * @description Asserts that `account` is allowed.
    */
-  public assertAllowed(account: Uint8Array) {
-    this.circuits.impure.assertAllowed(account);
+  public assertAllowed(account: Uint8Array): Promise<[]> {
+    return this.circuits.impure.assertAllowed(account);
   }
 
   /**
    * @description Adds `account` to the allowlist.
    */
-  public allow(account: Uint8Array) {
-    this.circuits.impure.allow(account);
+  public allow(account: Uint8Array): Promise<[]> {
+    return this.circuits.impure.allow(account);
   }
 
   /**
    * @description Removes `account` from the allowlist.
    */
-  public disallow(account: Uint8Array) {
-    this.circuits.impure.disallow(account);
+  public disallow(account: Uint8Array): Promise<[]> {
+    return this.circuits.impure.disallow(account);
   }
 }