@aztec/aztec.js 0.7.10 → 0.8.4

package/src/sandbox/index.ts

@@ -4,7 +4,7 @@ import { sleep } from '@aztec/foundation/sleep';
 import zip from 'lodash.zip';
 
 import SchnorrAccountContractAbi from '../abis/schnorr_account_contract.json' assert { type: 'json' };
-import { AccountWallet, AztecRPC, createAztecRpcClient, getSchnorrAccount } from '../index.js';
+import { AccountWallet, PXE, createPXEClient, getSchnorrAccount } from '../index.js';
 
 export const INITIAL_SANDBOX_ENCRYPTION_KEYS = [
   GrumpkinScalar.fromString('2153536ff6628eee01cf4024889ff977a18d9fa61d0e414422f7681cf085c281'),
@@ -18,29 +18,29 @@ export const INITIAL_SANDBOX_SALTS = [Fr.ZERO, Fr.ZERO, Fr.ZERO];
 
 export const INITIAL_SANDBOX_ACCOUNT_CONTRACT_ABI = SchnorrAccountContractAbi;
 
-export const { SANDBOX_URL = 'http://localhost:8080' } = process.env;
+export const { PXE_URL = 'http://localhost:8080' } = process.env;
 
 /**
  * Gets a collection of wallets for the Aztec accounts that are initially stored in the sandbox.
- * @param aztecRpc - An instance of the Aztec RPC interface.
+ * @param pxe - PXE instance.
  * @returns A set of AccountWallet implementations for each of the initial accounts.
  */
-export function getSandboxAccountsWallets(aztecRpc: AztecRPC): Promise<AccountWallet[]> {
+export function getSandboxAccountsWallets(pxe: PXE): Promise<AccountWallet[]> {
   return Promise.all(
     zip(INITIAL_SANDBOX_ENCRYPTION_KEYS, INITIAL_SANDBOX_SIGNING_KEYS, INITIAL_SANDBOX_SALTS).map(
-      ([encryptionKey, signingKey, salt]) => getSchnorrAccount(aztecRpc, encryptionKey!, signingKey!, salt).getWallet(),
+      ([encryptionKey, signingKey, salt]) => getSchnorrAccount(pxe, encryptionKey!, signingKey!, salt).getWallet(),
     ),
   );
 }
 
 /**
  * Deploys the initial set of schnorr signature accounts to the sandbox
- * @param aztecRpc - An instance of the Aztec RPC interface.
+ * @param pxe - PXE instance.
  * @returns The set of deployed Account objects and associated private encryption keys
  */
-export async function deployInitialSandboxAccounts(aztecRpc: AztecRPC) {
+export async function deployInitialSandboxAccounts(pxe: PXE) {
   const accounts = INITIAL_SANDBOX_ENCRYPTION_KEYS.map((privateKey, i) => {
-    const account = getSchnorrAccount(aztecRpc, privateKey, INITIAL_SANDBOX_SIGNING_KEYS[i], INITIAL_SANDBOX_SALTS[i]);
+    const account = getSchnorrAccount(pxe, privateKey, INITIAL_SANDBOX_SIGNING_KEYS[i], INITIAL_SANDBOX_SALTS[i]);
     return {
       account,
       privateKey,
@@ -70,13 +70,13 @@ export async function deployInitialSandboxAccounts(aztecRpc: AztecRPC) {
 
 /**
  * Function to wait until the sandbox becomes ready for use.
- * @param rpc - The rpc client connected to the sandbox.
+ * @param pxe - The pxe client connected to the sandbox.
  */
-export async function waitForSandbox(rpc?: AztecRPC) {
-  rpc = rpc ?? createAztecRpcClient(SANDBOX_URL);
+export async function waitForSandbox(pxe?: PXE) {
+  pxe = pxe ?? createPXEClient(PXE_URL);
   while (true) {
     try {
-      await rpc.getNodeInfo();
+      await pxe.getNodeInfo();
       break;
     } catch (err) {
       await sleep(1000);

package/src/utils/abi_types.ts

@@ -1,4 +1,10 @@
-import { Fr } from '@aztec/circuits.js';
+import { AztecAddress, EthAddress, Fr } from '@aztec/circuits.js';
 
 /** Any type that can be converted into a field for a contract call. */
 export type FieldLike = Fr | Buffer | bigint | number | { /** Converts to field */ toField: () => Fr };
+
+/** Any type that can be converted into an EthereumAddress Aztec.nr struct. */
+export type EthAddressLike = { /** Wrapped address */ address: FieldLike } | EthAddress;
+
+/** Any type that can be converted into an EthereumAddress Aztec.nr struct. */
+export type AztecAddressLike = { /** Wrapped address */ address: FieldLike } | AztecAddress;

package/src/utils/authwit.ts

@@ -0,0 +1,24 @@
+import { AztecAddress, CircuitsWasm, GeneratorIndex } from '@aztec/circuits.js';
+import { pedersenPlookupCompressWithHashIndex } from '@aztec/circuits.js/barretenberg';
+import { FunctionCall, PackedArguments } from '@aztec/types';
+
+/**
+ * Compute an authentication witness message hash from a caller and a request
+ * H(caller: AztecAddress, target: AztecAddress, selector: Field, args_hash: Field)
+ * @param caller - The caller approved to make the call
+ * @param request - The request to be made (function call)
+ * @returns The message hash for the witness
+ */
+export const computeAuthWitMessageHash = async (caller: AztecAddress, request: FunctionCall) => {
+  const wasm = await CircuitsWasm.get();
+  return pedersenPlookupCompressWithHashIndex(
+    wasm,
+    [
+      caller.toField(),
+      request.to.toField(),
+      request.functionData.selector.toField(),
+      (await PackedArguments.fromArgs(request.args, wasm)).hash,
+    ].map(fr => fr.toBuffer()),
+    GeneratorIndex.SIGNATURE_PAYLOAD,
+  );
+};

package/src/utils/cheat_codes.ts

@@ -3,7 +3,7 @@ import { pedersenPlookupCommitInputs } from '@aztec/circuits.js/barretenberg';
 import { toBigIntBE, toHex } from '@aztec/foundation/bigint-buffer';
 import { keccak } from '@aztec/foundation/crypto';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { AztecRPC, NotePreimage } from '@aztec/types';
+import { NotePreimage, PXE } from '@aztec/types';
 
 import fs from 'fs';
 
@@ -22,9 +22,9 @@ export class CheatCodes {
     public aztec: AztecCheatCodes,
   ) {}
 
-  static async create(rpcUrl: string, aztecRpc: AztecRPC): Promise<CheatCodes> {
+  static async create(rpcUrl: string, pxe: PXE): Promise<CheatCodes> {
     const ethCheatCodes = new EthCheatCodes(rpcUrl);
-    const aztecCheatCodes = new AztecCheatCodes(aztecRpc, await CircuitsWasm.get(), ethCheatCodes);
+    const aztecCheatCodes = new AztecCheatCodes(pxe, await CircuitsWasm.get(), ethCheatCodes);
     return new CheatCodes(ethCheatCodes, aztecCheatCodes);
   }
 }
@@ -35,7 +35,7 @@ export class CheatCodes {
 export class EthCheatCodes {
   constructor(
     /**
-     * The RPC client to use for interacting with the chain
+     * The RPC URL to use for interacting with the chain
      */
     public rpcUrl: string,
     /**
@@ -209,9 +209,9 @@ export class EthCheatCodes {
 export class AztecCheatCodes {
   constructor(
     /**
-     * The RPC client to use for interacting with the chain
+     * The PXE Service to use for interacting with the chain
      */
-    public aztecRpc: AztecRPC,
+    public pxe: PXE,
     /**
      * The circuits wasm module used for pedersen hashing
      */
@@ -248,7 +248,7 @@ export class AztecCheatCodes {
    * @returns The current block number
    */
   public async blockNumber(): Promise<number> {
-    return await this.aztecRpc.getBlockNumber();
+    return await this.pxe.getBlockNumber();
   }
 
   /**
@@ -257,7 +257,7 @@ export class AztecCheatCodes {
    * @param to - The timestamp to set the next block to (must be greater than current time)
    */
   public async warp(to: number): Promise<void> {
-    const rollupContract = (await this.aztecRpc.getNodeInfo()).rollupAddress;
+    const rollupContract = (await this.pxe.getNodeInfo()).l1ContractAddresses.rollupAddress;
     await this.eth.setNextBlockTimestamp(to);
     // also store this time on the rollup contract (slot 1 tracks `lastBlockTs`).
     // This is because when the sequencer executes public functions, it uses the timestamp stored in the rollup contract.
@@ -273,7 +273,7 @@ export class AztecCheatCodes {
    * @returns The value stored at the given slot
    */
   public async loadPublic(who: AztecAddress, slot: Fr | bigint): Promise<Fr> {
-    const storageValue = await this.aztecRpc.getPublicStorageAt(who, new Fr(slot));
+    const storageValue = await this.pxe.getPublicStorageAt(who, new Fr(slot));
     if (storageValue === undefined) {
       throw new Error(`Storage slot ${slot} not found`);
     }
@@ -288,6 +288,6 @@ export class AztecCheatCodes {
    * @returns The notes stored at the given slot
    */
   public loadPrivate(owner: AztecAddress, contract: AztecAddress, slot: Fr | bigint): Promise<NotePreimage[]> {
-    return this.aztecRpc.getPrivateStorageAt(owner, contract, new Fr(slot));
+    return this.pxe.getPrivateStorageAt(owner, contract, new Fr(slot));
   }
 }

package/src/utils/index.ts

@@ -1,7 +1,7 @@
 export * from './secrets.js';
-export * from './account.js';
 export * from './pub_key.js';
 export * from './l1_contracts.js';
 export * from './l2_contracts.js';
 export * from './abi_types.js';
 export * from './cheat_codes.js';
+export * from './authwit.js';

package/src/utils/l1_contracts.ts

@@ -1,50 +1,14 @@
-import { EthAddress } from '@aztec/circuits.js';
+import { L1ContractAddresses } from '@aztec/ethereum';
 import { retryUntil } from '@aztec/foundation/retry';
 
-/**
- * A dictionary of the Aztec-deployed L1 contracts.
- */
-export type L1ContractAddresses = {
-  /**
-   * Address fo the main Aztec rollup contract.
-   */
-  rollup: EthAddress;
-  /**
-   * Address of the contract that emits events on public contract deployment.
-   */
-  contractDeploymentEmitter: EthAddress;
-  /**
-   * Address of the L1/L2 messaging inbox contract.
-   */
-  inbox: EthAddress;
-  /**
-   * Address of the L1/L2 messaging outbox contract.
-   */
-  outbox: EthAddress;
-  /**
-   * Address of the decoder helper contract
-   */
-  decoderHelper?: EthAddress;
-
-  /**
-   * Registry Address.
-   */
-  registry: EthAddress;
-};
-
-/**
- * string dictionary of aztec contract addresses that we receive over http.
- */
-type L1ContractAddressesResp = {
-  [K in keyof L1ContractAddresses]: string;
-};
+import { createPXEClient } from '../pxe_client.js';
 
 export const getL1ContractAddresses = async (url: string): Promise<L1ContractAddresses> => {
-  const reqUrl = new URL(`${url}/api/l1-contract-addresses`);
+  const pxeClient = createPXEClient(url);
   const response = await retryUntil(
     async () => {
       try {
-        return (await (await fetch(reqUrl.toString())).json()) as unknown as L1ContractAddressesResp;
+        return (await pxeClient.getNodeInfo()).l1ContractAddresses;
       } catch (err) {
         // do nothing
       }
@@ -53,8 +17,5 @@ export const getL1ContractAddresses = async (url: string): Promise<L1ContractAdd
     120,
     1,
   );
-  const result = Object.fromEntries(
-    Object.entries(response).map(([key, value]) => [key, EthAddress.fromString(value)]),
-  );
-  return result as L1ContractAddresses;
+  return response;
 };

package/src/utils/l2_contracts.ts

@@ -1,12 +1,12 @@
 import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { AztecRPC } from '@aztec/types';
+import { PXE } from '@aztec/types';
 
 /**
  * Checks whether a give contract is deployed on the network.
- * @param aztecRpcClient - The aztec rpc client to use to obtain the information.
+ * @param pxe - The PXE to use to obtain the information.
  * @param contractAddress - The address of the contract to check.
  * @returns A flag indicating whether the contract is deployed.
  */
-export async function isContractDeployed(aztecRpcClient: AztecRPC, contractAddress: AztecAddress): Promise<boolean> {
-  return !!(await aztecRpcClient.getContractData(contractAddress));
+export async function isContractDeployed(pxe: PXE, contractAddress: AztecAddress): Promise<boolean> {
+  return !!(await pxe.getContractData(contractAddress));
 }

package/src/wallet/account_wallet.ts

@@ -1,6 +1,6 @@
 import { Fr } from '@aztec/circuits.js';
 import { ABIParameterVisibility, FunctionAbiHeader, FunctionType } from '@aztec/foundation/abi';
-import { AuthWitness, AztecRPC, FunctionCall, TxExecutionRequest } from '@aztec/types';
+import { AuthWitness, FunctionCall, PXE, TxExecutionRequest } from '@aztec/types';
 
 import { AccountInterface } from '../account/interface.js';
 import { ContractFunctionInteraction } from '../index.js';
@@ -10,8 +10,8 @@ import { BaseWallet } from './base_wallet.js';
  * A wallet implementation that forwards authentication requests to a provided account.
  */
 export class AccountWallet extends BaseWallet {
-  constructor(rpc: AztecRPC, protected account: AccountInterface) {
-    super(rpc);
+  constructor(pxe: PXE, protected account: AccountInterface) {
+    super(pxe);
   }
 
   createTxExecutionRequest(execs: FunctionCall[]): Promise<TxExecutionRequest> {
@@ -21,7 +21,7 @@ export class AccountWallet extends BaseWallet {
   async createAuthWitness(message: Fr | Buffer): Promise<AuthWitness> {
     message = Buffer.isBuffer(message) ? Fr.fromBuffer(message) : message;
     const witness = await this.account.createAuthWitness(message);
-    await this.rpc.addAuthWitness(witness);
+    await this.pxe.addAuthWitness(witness);
     return witness;
   }
 

package/src/wallet/base_wallet.ts

@@ -1,14 +1,15 @@
 import { AztecAddress, Fr, GrumpkinPrivateKey, PartialAddress } from '@aztec/circuits.js';
 import {
   AuthWitness,
-  AztecRPC,
   ContractData,
   DeployedContract,
   ExtendedContractData,
   FunctionCall,
   L2BlockL2Logs,
+  L2Tx,
   NodeInfo,
   NotePreimage,
+  PXE,
   SyncStatus,
   Tx,
   TxExecutionRequest,
@@ -23,7 +24,7 @@ import { Wallet } from './index.js';
  * A base class for Wallet implementations
  */
 export abstract class BaseWallet implements Wallet {
-  constructor(protected readonly rpc: AztecRPC) {}
+  constructor(protected readonly pxe: PXE) {}
 
   abstract getCompleteAddress(): CompleteAddress;
 
@@ -32,75 +33,88 @@ export abstract class BaseWallet implements Wallet {
   abstract createAuthWitness(message: Fr): Promise<AuthWitness>;
 
   registerAccount(privKey: GrumpkinPrivateKey, partialAddress: PartialAddress): Promise<void> {
-    return this.rpc.registerAccount(privKey, partialAddress);
+    return this.pxe.registerAccount(privKey, partialAddress);
   }
   registerRecipient(account: CompleteAddress): Promise<void> {
-    return this.rpc.registerRecipient(account);
+    return this.pxe.registerRecipient(account);
   }
   getRegisteredAccounts(): Promise<CompleteAddress[]> {
-    return this.rpc.getRegisteredAccounts();
+    return this.pxe.getRegisteredAccounts();
   }
   getRegisteredAccount(address: AztecAddress): Promise<CompleteAddress | undefined> {
-    return this.rpc.getRegisteredAccount(address);
+    return this.pxe.getRegisteredAccount(address);
   }
   getRecipients(): Promise<CompleteAddress[]> {
-    return this.rpc.getRecipients();
+    return this.pxe.getRecipients();
   }
   getRecipient(address: AztecAddress): Promise<CompleteAddress | undefined> {
-    return this.rpc.getRecipient(address);
+    return this.pxe.getRecipient(address);
   }
   addContracts(contracts: DeployedContract[]): Promise<void> {
-    return this.rpc.addContracts(contracts);
+    return this.pxe.addContracts(contracts);
   }
   getContracts(): Promise<AztecAddress[]> {
-    return this.rpc.getContracts();
+    return this.pxe.getContracts();
   }
   simulateTx(txRequest: TxExecutionRequest, simulatePublic: boolean): Promise<Tx> {
-    return this.rpc.simulateTx(txRequest, simulatePublic);
+    return this.pxe.simulateTx(txRequest, simulatePublic);
   }
   sendTx(tx: Tx): Promise<TxHash> {
-    return this.rpc.sendTx(tx);
+    return this.pxe.sendTx(tx);
+  }
+  getTx(txHash: TxHash): Promise<L2Tx | undefined> {
+    return this.pxe.getTx(txHash);
   }
   getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
-    return this.rpc.getTxReceipt(txHash);
+    return this.pxe.getTxReceipt(txHash);
   }
   getPrivateStorageAt(owner: AztecAddress, contract: AztecAddress, storageSlot: Fr): Promise<NotePreimage[]> {
-    return this.rpc.getPrivateStorageAt(owner, contract, storageSlot);
+    return this.pxe.getPrivateStorageAt(owner, contract, storageSlot);
   }
   getPublicStorageAt(contract: AztecAddress, storageSlot: Fr): Promise<any> {
-    return this.rpc.getPublicStorageAt(contract, storageSlot);
+    return this.pxe.getPublicStorageAt(contract, storageSlot);
+  }
+  addNote(
+    account: AztecAddress,
+    contract: AztecAddress,
+    storageSlot: Fr,
+    preimage: NotePreimage,
+    txHash: TxHash,
+    nonce?: Fr,
+  ): Promise<void> {
+    return this.pxe.addNote(account, contract, storageSlot, preimage, txHash, nonce);
   }
   getNoteNonces(contract: AztecAddress, storageSlot: Fr, preimage: NotePreimage, txHash: TxHash): Promise<Fr[]> {
-    return this.rpc.getNoteNonces(contract, storageSlot, preimage, txHash);
+    return this.pxe.getNoteNonces(contract, storageSlot, preimage, txHash);
   }
   viewTx(functionName: string, args: any[], to: AztecAddress, from?: AztecAddress | undefined): Promise<any> {
-    return this.rpc.viewTx(functionName, args, to, from);
+    return this.pxe.viewTx(functionName, args, to, from);
   }
   getExtendedContractData(contractAddress: AztecAddress): Promise<ExtendedContractData | undefined> {
-    return this.rpc.getExtendedContractData(contractAddress);
+    return this.pxe.getExtendedContractData(contractAddress);
   }
   getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined> {
-    return this.rpc.getContractData(contractAddress);
+    return this.pxe.getContractData(contractAddress);
   }
   getUnencryptedLogs(from: number, limit: number): Promise<L2BlockL2Logs[]> {
-    return this.rpc.getUnencryptedLogs(from, limit);
+    return this.pxe.getUnencryptedLogs(from, limit);
   }
   getBlockNumber(): Promise<number> {
-    return this.rpc.getBlockNumber();
+    return this.pxe.getBlockNumber();
   }
   getNodeInfo(): Promise<NodeInfo> {
-    return this.rpc.getNodeInfo();
+    return this.pxe.getNodeInfo();
   }
-  isGlobalStateSynchronised() {
-    return this.rpc.isGlobalStateSynchronised();
+  isGlobalStateSynchronized() {
+    return this.pxe.isGlobalStateSynchronized();
   }
-  isAccountStateSynchronised(account: AztecAddress) {
-    return this.rpc.isAccountStateSynchronised(account);
+  isAccountStateSynchronized(account: AztecAddress) {
+    return this.pxe.isAccountStateSynchronized(account);
   }
   getSyncStatus(): Promise<SyncStatus> {
-    return this.rpc.getSyncStatus();
+    return this.pxe.getSyncStatus();
   }
   addAuthWitness(authWitness: AuthWitness) {
-    return this.rpc.addAuthWitness(authWitness);
+    return this.pxe.addAuthWitness(authWitness);
   }
 }

package/src/wallet/index.ts

@@ -1,4 +1,4 @@
-import { AccountInterface, AztecRPC } from '../index.js';
+import { AccountInterface, PXE } from '../index.js';
 
 export * from './base_wallet.js';
 export * from './account_wallet.js';
@@ -7,4 +7,4 @@ export * from './signerless_wallet.js';
 /**
  * The wallet interface.
  */
-export type Wallet = AccountInterface & AztecRPC;
+export type Wallet = AccountInterface & PXE;

package/src/wallet/signerless_wallet.ts

@@ -15,7 +15,7 @@ export class SignerlessWallet extends BaseWallet {
     const [execution] = executions;
     const wasm = await CircuitsWasm.get();
     const packedArguments = await PackedArguments.fromArgs(execution.args, wasm);
-    const { chainId, protocolVersion } = await this.rpc.getNodeInfo();
+    const { chainId, protocolVersion } = await this.pxe.getNodeInfo();
     const txContext = TxContext.empty(chainId, protocolVersion);
     return Promise.resolve(
       new TxExecutionRequest(

package/.eslintrc.cjs

@@ -1 +0,0 @@
-module.exports = require('@aztec/foundation/eslint');