feat: replace private token in testing

docs/docs/external/up-quick-start.md

@@ -12,7 +12,7 @@ The sandbox is preloaded with two [accounts](../concepts/foundation/accounts/mai
 
 #include_code declare-accounts yarn-project/end-to-end/src/guides/up_quick_start.sh bash noTitle,noLineNumbers,noSourceLink
 
-Start by deploying a private token [contract](../concepts/foundation/contracts.md), minting an initial supply of private tokens to Alice:
+Start by deploying a token [contract](../concepts/foundation/contracts.md), initializing it and minting tokens to Alice:
 
 #include_code deploy yarn-project/end-to-end/src/guides/up_quick_start.sh bash noTitle,noLineNumbers,noSourceLink
 

yarn-project/acir-simulator/src/client/private_execution.test.ts

@@ -38,7 +38,7 @@ import {
   ParentContractAbi,
   PendingCommitmentsContractAbi,
   PrivateTokenAirdropContractAbi,
-  PrivateTokenContractAbi,
+  StatefulTestContractAbi,
   TestContractAbi,
 } from '@aztec/noir-contracts/artifacts';
 import { PackedArguments, TxExecutionRequest } from '@aztec/types';
@@ -401,7 +401,7 @@ describe('Private Execution test suite', () => {
     });
   });
 
-  describe('private token contract', () => {
+  describe('stateful test contract contract', () => {
     const contractAddress = defaultContractAddress;
     const mockFirstNullifier = new Fr(1111);
     let currentNoteIndex = 0n;
@@ -439,7 +439,7 @@ describe('Private Execution test suite', () => {
 
       oracle.getFunctionABI.mockImplementation((_, selector) =>
         Promise.resolve(
-          PrivateTokenContractAbi.functions.find(f =>
+          StatefulTestContractAbi.functions.find(f =>
             selector.equals(FunctionSelector.fromNameAndParameters(f.name, f.parameters)),
           )!,
         ),
@@ -484,9 +484,9 @@ describe('Private Execution test suite', () => {
     });
 
     it('should a constructor with arguments that inserts notes', async () => {
-      const abi = getFunctionAbi(PrivateTokenContractAbi, 'constructor');
+      const abi = getFunctionAbi(StatefulTestContractAbi, 'constructor');
 
-      const result = await runSimulator({ args: [140, owner], abi });
+      const result = await runSimulator({ args: [owner, 140], abi });
 
       expect(result.newNotes).toHaveLength(1);
       const newNote = result.newNotes[0];
@@ -501,10 +501,10 @@ describe('Private Execution test suite', () => {
       );
     });
 
-    it('should run the mint function', async () => {
-      const abi = getFunctionAbi(PrivateTokenContractAbi, 'mint');
+    it('should run the create_note function', async () => {
+      const abi = getFunctionAbi(StatefulTestContractAbi, 'create_note');
 
-      const result = await runSimulator({ args: [140, owner], abi });
+      const result = await runSimulator({ args: [owner, 140], abi });
 
       expect(result.newNotes).toHaveLength(1);
       const newNote = result.newNotes[0];
@@ -519,9 +519,9 @@ describe('Private Execution test suite', () => {
       );
     });
 
-    it('should run the transfer function', async () => {
+    it('should run the destroy_and_create function', async () => {
       const amountToTransfer = 100n;
-      const abi = getFunctionAbi(PrivateTokenContractAbi, 'transfer');
+      const abi = getFunctionAbi(StatefulTestContractAbi, 'destroy_and_create');
 
       const storageSlot = computeSlotForMapping(new Fr(1n), owner.toField(), circuitsWasm);
       const recipientStorageSlot = computeSlotForMapping(new Fr(1n), recipient.toField(), circuitsWasm);
@@ -534,7 +534,7 @@ describe('Private Execution test suite', () => {
       );
       await insertLeaves(consumedNotes.map(n => n.siloedNoteHash));
 
-      const args = [amountToTransfer, recipient];
+      const args = [recipient, amountToTransfer];
       const result = await runSimulator({ args, abi, msgSender: owner });
 
       // The two notes were nullified
@@ -565,10 +565,10 @@ describe('Private Execution test suite', () => {
       expect(readRequests).toEqual(expect.arrayContaining(consumedNotes.map(n => n.uniqueSiloedNoteHash)));
     });
 
-    it('should be able to transfer with dummy notes', async () => {
+    it('should be able to destroy_and_create with dummy notes', async () => {
       const amountToTransfer = 100n;
       const balance = 160n;
-      const abi = getFunctionAbi(PrivateTokenContractAbi, 'transfer');
+      const abi = getFunctionAbi(StatefulTestContractAbi, 'destroy_and_create');
 
       const storageSlot = computeSlotForMapping(new Fr(1n), owner.toField(), circuitsWasm);
 
@@ -580,7 +580,7 @@ describe('Private Execution test suite', () => {
       );
       await insertLeaves(consumedNotes.map(n => n.siloedNoteHash));
 
-      const args = [amountToTransfer, recipient];
+      const args = [recipient, amountToTransfer];
       const result = await runSimulator({ args, abi, msgSender: owner });
 
       const newNullifiers = result.callStackItem.publicInputs.newNullifiers.filter(field => !field.equals(Fr.ZERO));

yarn-project/acir-simulator/src/client/unconstrained_execution.test.ts

@@ -3,7 +3,7 @@ import { FunctionSelector, encodeArguments } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr, GrumpkinScalar } from '@aztec/foundation/fields';
-import { PrivateTokenContractAbi } from '@aztec/noir-contracts/artifacts';
+import { StatefulTestContractAbi } from '@aztec/noir-contracts/artifacts';
 import { FunctionCall } from '@aztec/types';
 
 import { mock } from 'jest-mock-extended';
@@ -39,9 +39,9 @@ describe('Unconstrained Execution test suite', () => {
       });
     });
 
-    it('should run the getBalance function', async () => {
+    it('should run the summed_values function', async () => {
       const contractAddress = AztecAddress.random();
-      const abi = PrivateTokenContractAbi.functions.find(f => f.name === 'getBalance')!;
+      const abi = StatefulTestContractAbi.functions.find(f => f.name === 'summed_values')!;
 
       const preimages = [...Array(5).fill(buildNote(1n, owner)), ...Array(2).fill(buildNote(2n, owner))];
 

yarn-project/end-to-end/src/canary/browser.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-console */
 import * as AztecJs from '@aztec/aztec.js';
-import { PrivateTokenContractAbi } from '@aztec/noir-contracts/artifacts';
+import { TokenContractAbi } from '@aztec/noir-contracts/artifacts';
 
 import { Server } from 'http';
 import Koa from 'koa';
@@ -111,60 +111,66 @@ export const browserTestSuite = (setup: () => Server, pageLogger: AztecJs.DebugL
       expect(stringAccounts.includes(result)).toBeTruthy();
     }, 15_000);
 
-    it('Deploys Private Token contract', async () => {
-      await deployPrivateTokenContract();
-    }, 30_000);
+    it('Deploys Token contract', async () => {
+      await deployTokenContract();
+    }, 60_000);
 
     it("Gets the owner's balance", async () => {
       const result = await page.evaluate(
-        async (rpcUrl, contractAddress, PrivateTokenContractAbi) => {
+        async (rpcUrl, contractAddress, TokenContractAbi) => {
           const { Contract, AztecAddress, createAztecRpcClient } = window.AztecJs;
           const client = createAztecRpcClient(rpcUrl!);
           const owner = (await client.getRegisteredAccounts())[0].address;
           const [wallet] = await AztecJs.getSandboxAccountsWallets(client);
-          const contract = await Contract.at(AztecAddress.fromString(contractAddress), PrivateTokenContractAbi, wallet);
-          const balance = await contract.methods.getBalance(owner).view({ from: owner });
-          console.log(`Owner's balance: ${balance}`);
+          const contract = await Contract.at(AztecAddress.fromString(contractAddress), TokenContractAbi, wallet);
+          const balance = await contract.methods.balance_of_private({ address: owner }).view({ from: owner });
           return balance;
         },
         SANDBOX_URL,
-        (await getPrivateTokenAddress()).toString(),
-        PrivateTokenContractAbi,
+        (await getTokenAddress()).toString(),
+        TokenContractAbi,
       );
       expect(result).toEqual(initialBalance);
     });
 
     it('Sends a transfer TX', async () => {
       const result = await page.evaluate(
-        async (rpcUrl, contractAddress, transferAmount, PrivateTokenContractAbi) => {
+        async (rpcUrl, contractAddress, transferAmount, TokenContractAbi) => {
           console.log(`Starting transfer tx`);
           const { AztecAddress, Contract, createAztecRpcClient } = window.AztecJs;
           const client = createAztecRpcClient(rpcUrl!);
           const accounts = await client.getRegisteredAccounts();
-          const owner = accounts[0].address;
           const receiver = accounts[1].address;
           const [wallet] = await AztecJs.getSandboxAccountsWallets(client);
-          const contract = await Contract.at(AztecAddress.fromString(contractAddress), PrivateTokenContractAbi, wallet);
-          await contract.methods.transfer(transferAmount, receiver).send().wait();
+          const contract = await Contract.at(AztecAddress.fromString(contractAddress), TokenContractAbi, wallet);
+          await contract.methods
+            .transfer({ address: accounts[0].address }, { address: receiver }, transferAmount, 0)
+            .send()
+            .wait();
           console.log(`Transferred ${transferAmount} tokens to new Account`);
-          const receiverBalance = await contract.methods.getBalance(receiver).view({ from: receiver });
-          console.log(`Receiver's balance is now: ${receiverBalance}`);
-          const senderBalance = await contract.methods.getBalance(owner).view({ from: owner });
-          console.log(`Updated sender balance: ${senderBalance}`);
-          return receiverBalance;
+          return await contract.methods.balance_of_private({ address: receiver }).view({ from: receiver });
         },
         SANDBOX_URL,
-        (await getPrivateTokenAddress()).toString(),
+        (await getTokenAddress()).toString(),
         transferAmount,
-        PrivateTokenContractAbi,
+        TokenContractAbi,
       );
       expect(result).toEqual(transferAmount);
     }, 60_000);
 
-    const deployPrivateTokenContract = async () => {
+    const deployTokenContract = async () => {
       const txHash = await page.evaluate(
-        async (rpcUrl, privateKeyString, initialBalance, PrivateTokenContractAbi) => {
-          const { GrumpkinScalar, DeployMethod, createAztecRpcClient, getUnsafeSchnorrAccount } = window.AztecJs;
+        async (rpcUrl, privateKeyString, initialBalance, TokenContractAbi) => {
+          const {
+            GrumpkinScalar,
+            DeployMethod,
+            createAztecRpcClient,
+            getUnsafeSchnorrAccount,
+            Contract,
+            Fr,
+            computeMessageSecretHash,
+            getSandboxAccountsWallets,
+          } = window.AztecJs;
           const client = createAztecRpcClient(rpcUrl!);
           let accounts = await client.getRegisteredAccounts();
           if (accounts.length === 0) {
@@ -173,30 +179,35 @@ export const browserTestSuite = (setup: () => Server, pageLogger: AztecJs.DebugL
             await getUnsafeSchnorrAccount(client, privateKey).waitDeploy();
             accounts = await client.getRegisteredAccounts();
           }
-          const owner = accounts[0];
-          const tx = new DeployMethod(owner.publicKey, client, PrivateTokenContractAbi, [
-            initialBalance,
-            owner.address,
-          ]).send();
+          const [owner] = await getSandboxAccountsWallets(client);
+          const tx = new DeployMethod(accounts[0].publicKey, client, TokenContractAbi).send();
           await tx.wait();
           const receipt = await tx.getReceipt();
           console.log(`Contract Deployed: ${receipt.contractAddress}`);
+
+          const token = await Contract.at(receipt.contractAddress!, TokenContractAbi, owner);
+          await token.methods._initialize({ address: owner.getAddress() }).send().wait();
+          const secret = Fr.random();
+          const secretHash = await computeMessageSecretHash(secret);
+          await token.methods.mint_private(initialBalance, secretHash).send().wait();
+          await token.methods.redeem_shield({ address: owner.getAddress() }, initialBalance, secret).send().wait();
+
           return receipt.txHash.toString();
         },
         SANDBOX_URL,
         privKey.toString(),
         initialBalance,
-        PrivateTokenContractAbi,
+        TokenContractAbi,
       );
 
       const txResult = await testClient.getTxReceipt(AztecJs.TxHash.fromString(txHash));
       expect(txResult.status).toEqual(AztecJs.TxStatus.MINED);
       contractAddress = txResult.contractAddress!;
     };
 
-    const getPrivateTokenAddress = async () => {
+    const getTokenAddress = async () => {
       if (!contractAddress) {
-        await deployPrivateTokenContract();
+        await deployTokenContract();
       }
       return contractAddress;
     };

yarn-project/end-to-end/src/canary/cli.ts

@@ -1,4 +1,4 @@
-import { AztecAddress, AztecRPC, CompleteAddress, DebugLogger } from '@aztec/aztec.js';
+import { AztecAddress, AztecRPC, CompleteAddress, DebugLogger, Fr, computeMessageSecretHash } from '@aztec/aztec.js';
 import { getProgram } from '@aztec/cli';
 
 import stringArgv from 'string-argv';
@@ -52,7 +52,9 @@ export const cliTestSuite = (
       if (addRpcUrl) {
         args.push('--rpc-url', rpcUrl);
       }
-      return cli.parseAsync(args);
+      const res = cli.parseAsync(args);
+      resetCli();
+      return res;
     };
 
     // Returns first match across all logs collected so far
@@ -115,8 +117,8 @@ export const cliTestSuite = (
       expect(foundAddress).toBeDefined();
       const ownerAddress = AztecAddress.fromString(foundAddress!);
 
-      debug('Deploy Private Token Contract using created account.');
-      await run(`deploy PrivateTokenContractAbi --args ${INITIAL_BALANCE} ${ownerAddress} --salt 0`);
+      debug('Deploy Token Contract using created account.');
+      await run(`deploy TokenContractAbi --salt 0`);
       const loggedAddress = findInLogs(/Contract\sdeployed\sat\s+(?<address>0x[a-fA-F0-9]+)/)?.groups?.address;
       expect(loggedAddress).toBeDefined();
       contractAddress = AztecAddress.fromString(loggedAddress!);
@@ -129,6 +131,22 @@ export const cliTestSuite = (
       const checkResult = findInLogs(/Contract\sfound\sat\s+(?<address>0x[a-fA-F0-9]+)/)?.groups?.address;
       expect(checkResult).toEqual(deployedContract?.contractAddress.toString());
 
+      debug('Initialize token contract.');
+      await run(
+        `send _initialize --args ${ownerAddress} --contract-abi TokenContractAbi --contract-address ${contractAddress.toString()}  --private-key ${privKey}`,
+      );
+
+      const secret = Fr.random();
+      const secretHash = await computeMessageSecretHash(secret);
+
+      debug('Mint initial tokens.');
+      await run(
+        `send mint_private --args ${INITIAL_BALANCE} ${secretHash} --contract-abi TokenContractAbi --contract-address ${contractAddress.toString()} --private-key ${privKey}`,
+      );
+      await run(
+        `send redeem_shield --args ${ownerAddress} ${INITIAL_BALANCE} ${secret} --contract-abi TokenContractAbi --contract-address ${contractAddress.toString()} --private-key ${privKey}`,
+      );
+
       // clear logs
       clearLogs();
       await run(`get-contract-data ${loggedAddress}`);
@@ -137,7 +155,7 @@ export const cliTestSuite = (
 
       debug("Check owner's balance");
       await run(
-        `call getBalance --args ${ownerAddress} --contract-abi PrivateTokenContractAbi --contract-address ${contractAddress.toString()}`,
+        `call balance_of_private --args ${ownerAddress} --contract-abi TokenContractAbi --contract-address ${contractAddress.toString()}`,
       );
       const balance = findInLogs(/View\sresult:\s+(?<data>\S+)/)?.groups?.data;
       expect(balance!).toEqual(`${BigInt(INITIAL_BALANCE).toString()}n`);
@@ -148,7 +166,7 @@ export const cliTestSuite = (
       const receiver = existingAccounts.find(acc => acc.address.toString() !== ownerAddress.toString());
 
       await run(
-        `send transfer --args ${TRANSFER_BALANCE} ${receiver?.address.toString()} --contract-address ${contractAddress.toString()} --contract-abi PrivateTokenContractAbi --private-key ${privKey}`,
+        `send transfer --args ${ownerAddress.toString()} ${receiver?.address.toString()}  ${TRANSFER_BALANCE} 0 --contract-address ${contractAddress.toString()} --contract-abi TokenContractAbi --private-key ${privKey}`,
       );
       const txHash = findInLogs(/Transaction\shash:\s+(?<txHash>\S+)/)?.groups?.txHash;
 
@@ -159,13 +177,11 @@ export const cliTestSuite = (
       expect(parsedResult.txHash).toEqual(txHash);
       expect(parsedResult.status).toEqual('mined');
       debug("Check Receiver's balance");
-      // Reset CLI as we're calling getBalance again
-      resetCli();
       clearLogs();
       await run(
-        `call getBalance --args ${receiver?.address.toString()} --contract-abi PrivateTokenContractAbi --contract-address ${contractAddress.toString()}`,
+        `call balance_of_private --args ${receiver?.address.toString()} --contract-abi TokenContractAbi --contract-address ${contractAddress.toString()}`,
       );
       const receiverBalance = findInLogs(/View\sresult:\s+(?<data>\S+)/)?.groups?.data;
       expect(receiverBalance).toEqual(`${BigInt(TRANSFER_BALANCE).toString()}n`);
-    }, 30_000);
+    }, 100_000);
   });

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

@@ -101,6 +101,7 @@ PublicTokenContractAbi
 SchnorrAccountContractAbi
 SchnorrHardcodedAccountContractAbi
 SchnorrSingleKeyAccountContractAbi
+StatefulTestContractAbi
 TestContractAbi
 TokenContractAbi
 UniswapContractAbi