@aztec/aztec.js 0.1.0-alpha20 → 0.1.0-alpha22

package/src/account_impl/account_contract.ts

@@ -8,7 +8,7 @@ import partition from 'lodash.partition';
 import { generateFunctionSelector } from '../index.js';
 import { AccountImplementation } from './index.js';
 import { ContractAbi } from '@aztec/foundation/abi';
-import { TxAuthProvider } from '../auth/index.js';
+import { EcdsaAuthProvider, SchnorrAuthProvider } from '../auth/index.js';
 
 /**
  * Account backed by an account contract
@@ -17,7 +17,7 @@ export class AccountContract implements AccountImplementation {
   constructor(
     private address: AztecAddress,
     private pubKey: PublicKey,
-    private authProvider: TxAuthProvider,
+    private authProvider: EcdsaAuthProvider | SchnorrAuthProvider,
     private partialContractAddress: PartialContractAddress,
     private contractAbi: ContractAbi,
     private wasm: CircuitsWasm,

package/src/auth/ecdsa.ts

@@ -1,14 +1,14 @@
 import { secp256k1 } from '@noble/curves/secp256k1';
-import { AztecAddress } from '../index.js';
-import { AuthPayload, TxAuthProvider } from './index.js';
+import { EcdsaSignature } from '@aztec/circuits.js/barretenberg';
 
+import { AztecAddress } from '../index.js';
+import { AuthPayload } from './index.js';
 import { EntrypointPayload } from '../account_impl/account_contract.js';
-import { EcdsaSignature } from '@aztec/circuits.js/barretenberg';
 
 /**
- * An ecdsa implementation of TxAuthProvider.
+ * An ecdsa implementation of auth provider.
  */
-export class EcdsaAuthProvider implements TxAuthProvider {
+export class EcdsaAuthProvider {
   constructor(private privKey: Buffer) {}
   authenticateTx(payload: EntrypointPayload, payloadHash: Buffer, _address: AztecAddress): Promise<AuthPayload> {
     const sig = secp256k1.sign(payloadHash, this.privKey);

package/src/auth/index.ts

@@ -2,6 +2,7 @@ import { AztecAddress, Fr } from '@aztec/circuits.js';
 import { EntrypointPayload } from '../account_impl/account_contract.js';
 
 export * from './ecdsa.js';
+export * from './schnorr.js';
 
 /**
  * An interface for the payload returned from auth operations.
@@ -11,18 +12,10 @@ export interface AuthPayload {
   toFields(): Fr[];
 }
 
-/**
- * The interface for an auth operations provider.
- * TODO: How coupled should the auth provider be a to a specific account contract implementation? Can we remove the dependency on a specific EntrypointPayload format here?
- */
-export interface TxAuthProvider {
-  authenticateTx(payload: EntrypointPayload, payloadHash: Buffer, address: AztecAddress): Promise<AuthPayload>;
-}
-
 /**
  * A dummy implementation of the auth provider
  */
-export class DummyAuthProvider implements TxAuthProvider {
+export class DummyAuthProvider {
   authenticateTx(_payload: EntrypointPayload, _payloadHash: Buffer, _address: AztecAddress): Promise<AuthPayload> {
     return Promise.resolve({
       toBuffer: () => Buffer.alloc(0),

package/src/auth/schnorr.ts

@@ -0,0 +1,13 @@
+import { Schnorr } from '@aztec/circuits.js/barretenberg';
+import { AuthPayload, AztecAddress, EntrypointPayload } from '@aztec/aztec.js';
+
+/**
+ * Implementation of a schnorr signature provider
+ */
+export class SchnorrAuthProvider {
+  constructor(private signer: Schnorr, private privateKey: Buffer) {}
+  authenticateTx(_payload: EntrypointPayload, _payloadHash: Buffer, _address: AztecAddress): Promise<AuthPayload> {
+    const sig = this.signer.constructSignature(_payloadHash, this.privateKey);
+    return Promise.resolve(sig as AuthPayload);
+  }
+}

package/src/aztec_rpc_client/aztec_rpc_client.ts

@@ -1,36 +1,6 @@
-import { AztecAddress, AztecRPC, EthAddress, Fr, Point, Tx, TxHash } from '@aztec/aztec-rpc';
+import { AztecAddress, AztecRPC, EthAddress, Fr, Point, Tx } from '@aztec/aztec-rpc';
 import { createJsonRpcClient } from '@aztec/foundation/json-rpc';
-import { ContractData, ContractDeploymentTx, ContractPublicData, TxExecutionRequest } from '@aztec/types';
-
-/**
- * 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;
-
-  /**
-   * Registry Address.
-   */
-  registry: EthAddress;
-};
-
-/**
- * string dictionary of aztec contract addresses that we receive over http.
- */
-type L1ContractAddressesResp = {
-  [K in keyof L1ContractAddresses]: string;
-};
+import { ContractData, ContractDeploymentTx, ContractPublicData, TxExecutionRequest, TxHash } from '@aztec/types';
 
 export const createAztecRpcClient = (url: string): AztecRPC =>
   createJsonRpcClient<AztecRPC>(
@@ -48,12 +18,3 @@ export const createAztecRpcClient = (url: string): AztecRPC =>
     { Tx, ContractDeploymentTx },
     false,
   );
-
-export const getL1ContractAddresses = async (url: string): Promise<L1ContractAddresses> => {
-  const reqUrl = new URL(`${url}/api/l1-contract-addresses`);
-  const response = (await (await fetch(reqUrl.toString())).json()) as unknown as L1ContractAddressesResp;
-  const result = Object.fromEntries(
-    Object.entries(response).map(([key, value]) => [key, EthAddress.fromString(value)]),
-  );
-  return result as L1ContractAddresses;
-};

package/src/aztec_rpc_client/wallet.ts

@@ -33,6 +33,9 @@ export abstract class BaseWallet implements Wallet {
   getAccountPublicKey(address: AztecAddress): Promise<Point> {
     return this.rpc.getAccountPublicKey(address);
   }
+  getAccountAddress(publicKey: Point): Promise<AztecAddress> {
+    return this.rpc.getAccountAddress(publicKey);
+  }
   addContracts(contracts: DeployedContract[]): Promise<void> {
     return this.rpc.addContracts(contracts);
   }

package/src/utils/account.ts

@@ -1,16 +1,17 @@
 import { AztecRPC, TxStatus, getContractDeploymentInfo } from '@aztec/aztec-rpc';
-import { AztecAddress, CircuitsWasm, Fr, Point } from '@aztec/circuits.js';
+import { CircuitsWasm, Fr } from '@aztec/circuits.js';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { EcdsaAccountContractAbi } from '@aztec/noir-contracts/examples';
+import { SchnorrAccountContractAbi } from '@aztec/noir-contracts/examples';
 import { AccountWallet, Wallet } from '../aztec_rpc_client/wallet.js';
 import {
   AccountCollection,
   AccountContract,
   ContractDeployer,
-  EcdsaAuthProvider,
+  SchnorrAuthProvider,
   generatePublicKey,
 } from '../index.js';
+import { Schnorr } from '@aztec/circuits.js/barretenberg';
 
 /**
  * Creates an Aztec Account.
@@ -19,41 +20,71 @@ import {
 export async function createAccounts(
   aztecRpcClient: AztecRPC,
   privateKey?: Buffer,
+  salt = Fr.random(),
   numberOfAccounts = 1,
   logger = createDebugLogger('aztec:aztec.js:accounts'),
 ): Promise<Wallet> {
+  const accountAbi = SchnorrAccountContractAbi;
   const accountImpls = new AccountCollection();
-  const results: [AztecAddress, Point][] = [];
   const wasm = await CircuitsWasm.get();
   for (let i = 0; i < numberOfAccounts; ++i) {
     // TODO(#662): Let the aztec rpc server generate the keypair rather than hardcoding the private key
     const privKey = i == 0 && privateKey ? privateKey : randomBytes(32);
-    const accountAbi = EcdsaAccountContractAbi;
     const publicKey = await generatePublicKey(privKey);
-    const salt = Fr.random();
     const deploymentInfo = await getContractDeploymentInfo(accountAbi, [], salt, publicKey);
     await aztecRpcClient.addAccount(privKey, deploymentInfo.address, deploymentInfo.partialAddress, accountAbi);
     const contractDeployer = new ContractDeployer(accountAbi, aztecRpcClient, publicKey);
     const tx = contractDeployer.deploy().send({ contractAddressSalt: salt });
-    await tx.isMined(0, 0.1);
+    await tx.isMined(0, 0.5);
     const receipt = await tx.getReceipt();
     if (receipt.status !== TxStatus.MINED) {
       throw new Error(`Deployment tx not mined (status is ${receipt.status})`);
     }
     const address = receipt.contractAddress!;
+    if (!address.equals(deploymentInfo.address)) {
+      throw new Error(
+        `Deployment address does not match for account contract (expected ${deploymentInfo.address.toString()} got ${address.toString()})`,
+      );
+    }
     logger(`Created account ${address.toString()} with public key ${publicKey.toString()}`);
     accountImpls.registerAccount(
       address,
       new AccountContract(
         address,
         publicKey,
-        new EcdsaAuthProvider(privKey),
+        new SchnorrAuthProvider(await Schnorr.new(), privKey),
         deploymentInfo.partialAddress,
         accountAbi,
         wasm,
       ),
     );
-    results.push([address, publicKey]);
   }
   return new AccountWallet(aztecRpcClient, accountImpls);
 }
+
+/**
+ * Gets the Aztec accounts that are stored in an Aztec RPC instance.
+ * @param aztecRpcClient - An instance of the Aztec RPC interface.
+ * @param numberOfAccounts - The number of accounts to fetch.
+ * @returns An AccountWallet implementation that includes all the accounts found.
+ */
+export async function getAccountWallet(aztecRpcClient: AztecRPC, privateKey: Buffer, salt: Fr) {
+  const wasm = await CircuitsWasm.get();
+  const accountCollection = new AccountCollection();
+  const publicKey = await generatePublicKey(privateKey);
+  const address = await aztecRpcClient.getAccountAddress(publicKey);
+  const deploymentInfo = await getContractDeploymentInfo(SchnorrAccountContractAbi, [], salt, publicKey);
+
+  accountCollection.registerAccount(
+    address,
+    new AccountContract(
+      address,
+      publicKey,
+      new SchnorrAuthProvider(await Schnorr.new(), privateKey),
+      deploymentInfo.partialAddress,
+      SchnorrAccountContractAbi,
+      wasm,
+    ),
+  );
+  return new AccountWallet(aztecRpcClient, accountCollection);
+}

package/src/utils/index.ts

@@ -1,3 +1,4 @@
 export * from './secrets.js';
 export * from './account.js';
 export * from './pub_key.js';
+export * from './l1_contracts.js';

package/src/utils/l1_contracts.ts

@@ -0,0 +1,40 @@
+import { EthAddress } from '@aztec/circuits.js';
+
+/**
+ * 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;
+
+  /**
+   * Registry Address.
+   */
+  registry: EthAddress;
+};
+
+/**
+ * string dictionary of aztec contract addresses that we receive over http.
+ */
+type L1ContractAddressesResp = {
+  [K in keyof L1ContractAddresses]: string;
+};
+
+export const getL1ContractAddresses = async (url: string): Promise<L1ContractAddresses> => {
+  const reqUrl = new URL(`${url}/api/l1-contract-addresses`);
+  const response = (await (await fetch(reqUrl.toString())).json()) as unknown as L1ContractAddressesResp;
+  const result = Object.fromEntries(
+    Object.entries(response).map(([key, value]) => [key, EthAddress.fromString(value)]),
+  );
+  return result as L1ContractAddresses;
+};

package/src/utils/pub_key.ts

@@ -1,20 +1,6 @@
 import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 import { Point } from '../index.js';
 
-/**
- * Converts a Point type to a public key represented by BigInt coordinates
- * @param point - The Point to convert.
- * @returns An object with x & y coordinates represented as bigints.
- */
-export function pointToPublicKey(point: Point) {
-  const x = point.x.toBigInt();
-  const y = point.y.toBigInt();
-  return {
-    x,
-    y,
-  };
-}
-
 /**
  * Method for generating a public grumpkin key from a private key.
  * @param privateKey - The private key.