chore: Cleanup sandbox dependent tests

.circleci/config.yml

@@ -754,7 +754,7 @@ jobs:
           name: "Test"
           command: cond_spot_run_compose end-to-end 4 ./scripts/docker-compose-no-sandbox.yml TEST=e2e_p2p_network.test.ts
 
-  e2e-browser-sandbox:
+  e2e-browser:
     docker:
       - image: aztecprotocol/alpine-build-image
     resource_class: small
@@ -776,7 +776,7 @@ jobs:
           name: "Test"
           command: cond_spot_run_compose end-to-end 4 ./scripts/docker-compose.yml TEST=e2e_card_game.test.ts
 
-  pxe-sandbox:
+  pxe:
     docker:
       - image: aztecprotocol/alpine-build-image
     resource_class: small
@@ -1187,9 +1187,9 @@ workflows:
       - integration-l1-publisher: *e2e_test
       - integration-archiver-l1-to-l2: *e2e_test
       - e2e-p2p: *e2e_test
-      - e2e-browser-sandbox: *e2e_test
+      - e2e-browser: *e2e_test
       - e2e-card-game: *e2e_test
-      - pxe-sandbox: *e2e_test
+      - pxe: *e2e_test
       - cli-docs-sandbox: *e2e_test
       - guides-writing-an-account-contract: *e2e_test
       - guides-dapp-testing: *e2e_test
@@ -1223,9 +1223,9 @@ workflows:
             - integration-l1-publisher
             - integration-archiver-l1-to-l2
             - e2e-p2p
-            - e2e-browser-sandbox
+            - e2e-browser
             - e2e-card-game
-            - pxe-sandbox
+            - pxe
             - cli-docs-sandbox
             - guides-writing-an-account-contract
             - guides-dapp-testing

boxes/blank-react/src/sandbox/index.ts

@@ -0,0 +1,25 @@
+import { createPXEClient, PXE } from '@aztec/aztec.js';
+
+const { PXE_URL = 'http://localhost:8080' } = process.env;
+
+export const waitForSandbox = async (pxe?: PXE) => {
+    pxe = pxe ?? createPXEClient(PXE_URL);
+    while (true) {
+        try {
+            await pxe!.getNodeInfo();
+            return true;
+        } catch (error) {
+            await new Promise(resolve => {
+                setTimeout(resolve, 1000);
+            });
+        }
+    }
+  };
+
+// assumes sandbox is running locally, which this script does not trigger
+// as well as anvil.  anvil can be started with yarn test:integration
+export const setupSandbox = async () => {
+    const pxe = createPXEClient(PXE_URL);
+    await waitForSandbox(pxe);
+    return pxe;
+  };

boxes/blank-react/src/tests/blank.contract.test.ts

@@ -10,21 +10,11 @@ import {
   TxStatus,
   Wallet,
   createDebugLogger,
-  createPXEClient,
-  waitForSandbox,
 } from '@aztec/aztec.js';
+import { setupSandbox } from '../sandbox/index.js';
 
 const logger = createDebugLogger('aztec:http-pxe-client');
 
-// assumes sandbox is running locally, which this script does not trigger
-// as well as anvil.  anvil can be started with yarn test:integration
-const setupSandbox = async () => {
-  const { PXE_URL = 'http://localhost:8080' } = process.env;
-  const pxe = createPXEClient(PXE_URL);
-  await waitForSandbox(pxe);
-
-  return pxe;
-};
 
 async function deployZKContract(owner: CompleteAddress, wallet: Wallet, pxe: PXE) {
   logger('Deploying Blank contract...');

boxes/blank/src/sandbox/index.ts

@@ -0,0 +1,25 @@
+import { createPXEClient, PXE } from '@aztec/aztec.js';
+
+const { PXE_URL = 'http://localhost:8080' } = process.env;
+
+export const waitForSandbox = async (pxe?: PXE) => {
+    pxe = pxe ?? createPXEClient(PXE_URL);
+    while (true) {
+        try {
+            await pxe!.getNodeInfo();
+            return true;
+        } catch (error) {
+            await new Promise(resolve => {
+                setTimeout(resolve, 1000);
+            });
+        }
+    }
+  };
+
+// assumes sandbox is running locally, which this script does not trigger
+// as well as anvil.  anvil can be started with yarn test:integration
+export const setupSandbox = async () => {
+    const pxe = createPXEClient(PXE_URL);
+    await waitForSandbox(pxe);
+    return pxe;
+  };

boxes/blank/src/tests/blank.contract.test.ts

@@ -10,21 +10,11 @@ import {
   TxStatus,
   Wallet,
   createDebugLogger,
-  createPXEClient,
-  waitForSandbox,
 } from '@aztec/aztec.js';
+import { setupSandbox } from '../sandbox/index.js';
 
 const logger = createDebugLogger('aztec:blank-box-test');
 
-// assumes sandbox is running locally, which this script does not trigger
-// as well as anvil.  anvil can be started with yarn test:integration
-const setupSandbox = async () => {
-  const { PXE_URL = 'http://localhost:8080' } = process.env;
-  const pxe = createPXEClient(PXE_URL);
-  await waitForSandbox(pxe);
-  return pxe;
-};
-
 async function deployZKContract(owner: CompleteAddress, wallet: Wallet, pxe: PXE) {
   logger('Deploying Blank contract...');
   const contractAddress = await deployContract(owner, BlankContract.artifact, [], Fr.random(), pxe);

boxes/token/src/sandbox/index.ts

@@ -0,0 +1,25 @@
+import { createPXEClient, PXE } from '@aztec/aztec.js';
+
+const { PXE_URL = 'http://localhost:8080' } = process.env;
+
+export const waitForSandbox = async (pxe?: PXE) => {
+    pxe = pxe ?? createPXEClient(PXE_URL);
+    while (true) {
+        try {
+            await pxe!.getNodeInfo();
+            return true;
+        } catch (error) {
+            await new Promise(resolve => {
+                setTimeout(resolve, 1000);
+            });
+        }
+    }
+  };
+
+// assumes sandbox is running locally, which this script does not trigger
+// as well as anvil.  anvil can be started with yarn test:integration
+export const setupSandbox = async () => {
+    const pxe = createPXEClient(PXE_URL);
+    await waitForSandbox(pxe);
+    return pxe;
+  };

boxes/token/src/tests/token.contract.test.ts

@@ -13,20 +13,10 @@ import {
   computeAuthWitMessageHash,
   computeMessageSecretHash,
   createDebugLogger,
-  createPXEClient,
   getSandboxAccountsWallets,
-  waitForSandbox,
 } from '@aztec/aztec.js';
 import { afterEach, beforeAll, expect, jest } from '@jest/globals';
-
-// assumes sandbox is running locally, which this script does not trigger
-// as well as anvil.  anvil can be started with yarn test:integration
-const setupSandbox = async () => {
-  const { PXE_URL = 'http://localhost:8080' } = process.env;
-  const pxe = createPXEClient(PXE_URL);
-  await waitForSandbox(pxe);
-  return pxe;
-};
+import { setupSandbox } from '../sandbox/index.js';
 
 const TIMEOUT = 60_000;
 

yarn-project/aztec.js/src/index.ts

@@ -60,7 +60,7 @@ export {
 
 export { getSchnorrAccount, AccountManager, getUnsafeSchnorrAccount } from './account_manager/index.js';
 
-export { waitForSandbox, getSandboxAccountsWallets, deployInitialSandboxAccounts } from './sandbox/index.js';
+export { getSandboxAccountsWallets, deployInitialSandboxAccounts } from './sandbox/index.js';
 
 export { AccountWalletWithPrivateKey, AccountWallet, Wallet, SignerlessWallet } from './wallet/index.js';
 

yarn-project/aztec.js/src/sandbox/index.ts

@@ -1,9 +1,7 @@
 import { Fr, GrumpkinScalar } from '@aztec/foundation/fields';
-import { sleep } from '@aztec/foundation/sleep';
 import { PXE } from '@aztec/types';
 
 import { getSchnorrAccount } from '../account_manager/index.js';
-import { createPXEClient } from '../pxe_client.js';
 import { AccountWalletWithPrivateKey } from '../wallet/index.js';
 
 export const INITIAL_SANDBOX_ENCRYPTION_KEYS = [
@@ -65,19 +63,3 @@ export async function deployInitialSandboxAccounts(pxe: PXE) {
   );
   return accounts;
 }
-
-/**
- * Function to wait until the sandbox becomes ready for use.
- * @param pxe - The pxe client connected to the sandbox.
- */
-export async function waitForSandbox(pxe?: PXE) {
-  pxe = pxe ?? createPXEClient(PXE_URL);
-  while (true) {
-    try {
-      await pxe.getNodeInfo();
-      break;
-    } catch (err) {
-      await sleep(1000);
-    }
-  }
-}

yarn-project/end-to-end/src/e2e_aztec_js_browser.test.ts

@@ -1,39 +1,39 @@
 import { createDebugLogger, fileURLToPath } from '@aztec/aztec.js';
+import { createPXERpcServer } from '@aztec/pxe';
 
 import Koa from 'koa';
 import serve from 'koa-static';
 import path, { dirname } from 'path';
 
+import { setup } from './fixtures/utils.js';
 import { browserTestSuite } from './shared/browser.js';
 
+const { PXE_URL = '' } = process.env;
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const PORT = 3000;
+const PXE_PORT = 3001;
 
 const logger = createDebugLogger('aztec:canary_aztec.js:web');
 const pageLogger = createDebugLogger('aztec:canary_aztec.js:web:page');
-/**
- * This test is a bit of a special case as it's relying on sandbox and web browser and not only on anvil and node.js.
- * To run the test, do the following:
- *    1) Build the whole repository,
- *    2) go to `yarn-project/aztec.js` and build the web packed package with `yarn build:web`,
- *    3) start anvil: `anvil`,
- *    4) open new terminal and optionally set the more verbose debug level: `DEBUG=aztec:*`,
- *    5) go to the sandbox dir `yarn-project/aztec-sandbox` and run `yarn start`,
- *    6) open new terminal and export the URL of PXE from Sandbox: `export PXE_URL='http://localhost:8080'`,
- *    7) go to `yarn-project/end-to-end` and run the test: `yarn test aztec_js_browser`
- *
- * NOTE: If you see aztec-sandbox logs spammed with unexpected logs there is probably a chrome process with a webpage
- *       unexpectedly running in the background. Kill it with `killall chrome`
- */
-const setupApp = () => {
+
+const setupApp = async () => {
+  const { pxe: pxeService } = await setup(1);
+  let pxeURL = PXE_URL;
+  if (!PXE_URL) {
+    const pxeRPCServer = createPXERpcServer(pxeService);
+    pxeRPCServer.start(PXE_PORT);
+    pxeURL = `http://localhost:${PXE_PORT}`;
+  }
+
   const app = new Koa();
   app.use(serve(path.resolve(__dirname, './web')));
   const server = app.listen(PORT, () => {
-    logger(`Server started at http://localhost:${PORT}`);
+    logger(`Web Server started at http://localhost:${PORT}`);
   });
 
-  return server;
+  return { server, pxeURL };
 };
 
 browserTestSuite(setupApp, pageLogger);

yarn-project/end-to-end/src/e2e_card_game.test.ts

@@ -2,19 +2,18 @@ import {
   AccountWallet,
   AztecAddress,
   DebugLogger,
+  GrumpkinScalar,
   PXE,
   Wallet,
-  deployInitialSandboxAccounts,
-  getSandboxAccountsWallets,
+  generatePublicKey,
+  getSchnorrAccount,
 } from '@aztec/aztec.js';
 import { CardGameContract } from '@aztec/noir-contracts/CardGame';
 
 import { setup } from './fixtures/utils.js';
 
 /* eslint-disable camelcase */
 
-const { PXE_URL } = process.env;
-
 interface Card {
   points: bigint;
   strength: bigint;
@@ -53,6 +52,12 @@ function unwrapOptions<T>(options: NoirOption<T>[]): T[] {
 
 const GAME_ID = 42;
 
+const ENCRYPTION_KEYS = [
+  GrumpkinScalar.fromString('2153536ff6628eee01cf4024889ff977a18d9fa61d0e414422f7681cf085c281'),
+  GrumpkinScalar.fromString('aebd1b4be76efa44f5ee655c20bf9ea60f7ae44b9a7fd1fd9f189c7a0b0cdae'),
+  GrumpkinScalar.fromString('0f6addf0da06c33293df974a565b03d1ab096090d907d98055a8b7f4954e120c'),
+];
+
 describe('e2e_card_game', () => {
   let pxe: PXE;
   let logger: DebugLogger;
@@ -72,17 +77,28 @@ describe('e2e_card_game', () => {
   let contractAsThirdPlayer: CardGameContract;
 
   beforeEach(async () => {
-    // Card stats are derived from the users' private keys, so to get consistent values, we set up the
-    // initial sandbox accounts that always use the same private keys, instead of random ones.
-    ({ pxe, logger, teardown } = await setup(0));
-
-    // Get pre-deployed account wallets if we're running against sandbox.
-    if (PXE_URL) {
-      wallets = await getSandboxAccountsWallets(pxe);
-    } else {
-      // Deploy initial wallets if we're NOT running against sandbox.
-      wallets = await Promise.all((await deployInitialSandboxAccounts(pxe)).map(a => a.account.getWallet()));
+    ({ pxe, logger, teardown, wallets } = await setup(0));
+
+    const preRegisteredAccounts = await pxe.getRegisteredAccounts();
+
+    const toRegister = ENCRYPTION_KEYS.filter(key => {
+      const publicKey = generatePublicKey(key);
+      return (
+        preRegisteredAccounts.find(preRegisteredAccount => {
+          return preRegisteredAccount.publicKey.equals(publicKey);
+        }) == undefined
+      );
+    });
+
+    for (let i = 0; i < toRegister.length; i++) {
+      logger(`Deploying account contract ${i}/${toRegister.length}...`);
+      const encryptionPrivateKey = toRegister[i];
+      const account = getSchnorrAccount(pxe, encryptionPrivateKey, GrumpkinScalar.random());
+      const wallet = await account.waitDeploy({ interval: 0.1 });
+      wallets.push(wallet);
     }
+    logger('Account contracts deployed');
+
     [firstPlayerWallet, secondPlayerWallet, thirdPlayerWallet] = wallets;
     [firstPlayer, secondPlayer, thirdPlayer] = wallets.map(a => a.getAddress());
     await deployContract();

yarn-project/end-to-end/src/e2e_cli.test.ts

@@ -6,27 +6,18 @@ import { setup as e2eSetup } from './fixtures/utils.js';
 import { cliTestSuite } from './shared/cli.js';
 
 const HTTP_PORT = 9009;
-let RPC_URL = `http://localhost:${HTTP_PORT}`;
 const debug = createDebugLogger('aztec:e2e_cli');
 
 let http: ReturnType<typeof startHttpRpcServer>;
 let pxe: PXE;
 let teardown: () => Promise<void>;
 
-// Use Sandbox PXE URL if we're running against sandbox
-const { PXE_URL } = process.env;
-if (PXE_URL) {
-  RPC_URL = PXE_URL;
-}
-
 const testSetup = async () => {
   const context = await e2eSetup(2);
   debug(`Environment set up`);
   ({ pxe, teardown } = context);
-  if (!PXE_URL) {
-    http = startHttpRpcServer(pxe, createPXERpcServer, HTTP_PORT);
-    debug(`HTTP RPC server started in port ${HTTP_PORT}`);
-  }
+  http = startHttpRpcServer(pxe, createPXERpcServer, HTTP_PORT);
+  debug(`HTTP RPC server started in port ${HTTP_PORT}`);
   return pxe;
 };
 
@@ -35,4 +26,4 @@ const testCleanup = async () => {
   await teardown();
 };
 
-cliTestSuite('E2E CLI Test', testSetup, testCleanup, createDebugLogger('aztec:e2e_cli'), RPC_URL);
+cliTestSuite('E2E CLI Test', testSetup, testCleanup, createDebugLogger('aztec:e2e_cli'));