@aztec/accounts 0.71.0 → 0.73.0

package/src/ecdsa/ecdsa_k/index.ts

@@ -20,9 +20,15 @@ export { EcdsaKAccountContract };
  * @param secretKey - Secret key used to derive all the keystore keys.
  * @param signingPrivateKey - Secp256k1 key used for signing transactions.
  * @param salt - Deployment salt.
+ * @returns An account manager initialized with the account contract and its deployment params
  */
-export function getEcdsaKAccount(pxe: PXE, secretKey: Fr, signingPrivateKey: Buffer, salt?: Salt): AccountManager {
-  return new AccountManager(pxe, secretKey, new EcdsaKAccountContract(signingPrivateKey), salt);
+export function getEcdsaKAccount(
+  pxe: PXE,
+  secretKey: Fr,
+  signingPrivateKey: Buffer,
+  salt?: Salt,
+): Promise<AccountManager> {
+  return AccountManager.create(pxe, secretKey, new EcdsaKAccountContract(signingPrivateKey), salt);
 }
 
 /**

package/src/ecdsa/ssh_ecdsa_r/account_contract.ts

@@ -22,7 +22,7 @@ export class EcdsaRSSHAccountContract extends DefaultAccountContract {
   }
 
   getDeploymentArgs() {
-    return [this.signingPublicKey.subarray(0, 32), this.signingPublicKey.subarray(32, 64)];
+    return Promise.resolve([this.signingPublicKey.subarray(0, 32), this.signingPublicKey.subarray(32, 64)]);
   }
 
   getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {

package/src/ecdsa/ssh_ecdsa_r/index.ts

@@ -20,9 +20,15 @@ export { EcdsaRSSHAccountContract };
  * @param secretKey - Secret key used to derive all the keystore keys.
  * @param signingPublicKey - Secp2561 key used to identify its corresponding private key in the SSH Agent.
  * @param salt - Deployment salt.
+ * @returns An account manager initialized with the account contract and its deployment params
  */
-export function getEcdsaRSSHAccount(pxe: PXE, secretKey: Fr, signingPublicKey: Buffer, salt?: Salt): AccountManager {
-  return new AccountManager(pxe, secretKey, new EcdsaRSSHAccountContract(signingPublicKey), salt);
+export function getEcdsaRSSHAccount(
+  pxe: PXE,
+  secretKey: Fr,
+  signingPublicKey: Buffer,
+  salt?: Salt,
+): Promise<AccountManager> {
+  return AccountManager.create(pxe, secretKey, new EcdsaRSSHAccountContract(signingPublicKey), salt);
 }
 
 /**

package/src/schnorr/account_contract.ts

@@ -16,8 +16,8 @@ export class SchnorrAccountContract extends DefaultAccountContract {
     super(SchnorrAccountContractArtifact as ContractArtifact);
   }
 
-  getDeploymentArgs() {
-    const signingPublicKey = new Schnorr().computePublicKey(this.signingPrivateKey);
+  async getDeploymentArgs() {
+    const signingPublicKey = await new Schnorr().computePublicKey(this.signingPrivateKey);
     return [signingPublicKey.x, signingPublicKey.y];
   }
 
@@ -30,9 +30,9 @@ export class SchnorrAccountContract extends DefaultAccountContract {
 class SchnorrAuthWitnessProvider implements AuthWitnessProvider {
   constructor(private signingPrivateKey: GrumpkinScalar) {}
 
-  createAuthWit(messageHash: Fr): Promise<AuthWitness> {
+  async createAuthWit(messageHash: Fr): Promise<AuthWitness> {
     const schnorr = new Schnorr();
-    const signature = schnorr.constructSignature(messageHash.toBuffer(), this.signingPrivateKey).toBuffer();
-    return Promise.resolve(new AuthWitness(messageHash, [...signature]));
+    const signature = await schnorr.constructSignature(messageHash.toBuffer(), this.signingPrivateKey);
+    return new AuthWitness(messageHash, [...signature.toBuffer()]);
   }
 }

package/src/schnorr/index.ts

@@ -21,14 +21,15 @@ export { SchnorrAccountContractArtifact } from './artifact.js';
  * @param secretKey - Secret key used to derive all the keystore keys.
  * @param signingPrivateKey - Grumpkin key used for signing transactions.
  * @param salt - Deployment salt.
+ * @returns An account manager initialized with the account contract and its deployment params
  */
 export function getSchnorrAccount(
   pxe: PXE,
   secretKey: Fr,
   signingPrivateKey: GrumpkinScalar,
   salt?: Salt,
-): AccountManager {
-  return new AccountManager(pxe, secretKey, new SchnorrAccountContract(signingPrivateKey), salt);
+): Promise<AccountManager> {
+  return AccountManager.create(pxe, secretKey, new SchnorrAccountContract(signingPrivateKey), salt);
 }
 
 /**

package/src/single_key/account_contract.ts

@@ -16,8 +16,8 @@ export class SingleKeyAccountContract extends DefaultAccountContract {
     super(SchnorrSingleKeyAccountContractArtifact as ContractArtifact);
   }
 
-  getDeploymentArgs(): undefined {
-    return undefined;
+  getDeploymentArgs() {
+    return Promise.resolve(undefined);
   }
 
   getAuthWitnessProvider(account: CompleteAddress): AuthWitnessProvider {
@@ -33,9 +33,9 @@ export class SingleKeyAccountContract extends DefaultAccountContract {
 class SingleKeyAuthWitnessProvider implements AuthWitnessProvider {
   constructor(private privateKey: GrumpkinScalar, private account: CompleteAddress) {}
 
-  createAuthWit(messageHash: Fr): Promise<AuthWitness> {
+  async createAuthWit(messageHash: Fr): Promise<AuthWitness> {
     const schnorr = new Schnorr();
-    const signature = schnorr.constructSignature(messageHash.toBuffer(), this.privateKey);
+    const signature = await schnorr.constructSignature(messageHash.toBuffer(), this.privateKey);
     const witness = [...this.account.publicKeys.toFields(), ...signature.toBuffer(), this.account.partialAddress];
     return Promise.resolve(new AuthWitness(messageHash, witness));
   }

package/src/single_key/index.ts

@@ -20,10 +20,11 @@ export { SchnorrSingleKeyAccountContractArtifact as SingleKeyAccountContractArti
  * @param pxe - An PXE server instance.
  * @param secretKey - Secret key used to derive all the keystore keys (in this case also used to get signing key).
  * @param salt - Deployment salt.
+ * @returns An account manager initialized with the account contract and its deployment params
  */
-export function getSingleKeyAccount(pxe: PXE, secretKey: Fr, salt?: Salt): AccountManager {
+export function getSingleKeyAccount(pxe: PXE, secretKey: Fr, salt?: Salt) {
   const encryptionPrivateKey = deriveMasterIncomingViewingSecretKey(secretKey);
-  return new AccountManager(pxe, secretKey, new SingleKeyAccountContract(encryptionPrivateKey), salt);
+  return AccountManager.create(pxe, secretKey, new SingleKeyAccountContract(encryptionPrivateKey), salt);
 }
 
 /**

package/src/testing/configuration.ts

@@ -29,9 +29,15 @@ export const INITIAL_TEST_ACCOUNT_SALTS = [Fr.ZERO, Fr.ZERO, Fr.ZERO];
  */
 export function getInitialTestAccountsWallets(pxe: PXE): Promise<AccountWalletWithSecretKey[]> {
   return Promise.all(
-    INITIAL_TEST_SECRET_KEYS.map((encryptionKey, i) =>
-      getSchnorrAccount(pxe, encryptionKey!, INITIAL_TEST_SIGNING_KEYS[i]!, INITIAL_TEST_ACCOUNT_SALTS[i]).getWallet(),
-    ),
+    INITIAL_TEST_SECRET_KEYS.map(async (encryptionKey, i) => {
+      const account = await getSchnorrAccount(
+        pxe,
+        encryptionKey!,
+        INITIAL_TEST_SIGNING_KEYS[i]!,
+        INITIAL_TEST_ACCOUNT_SALTS[i],
+      );
+      return account.getWallet();
+    }),
   );
 }
 
@@ -42,20 +48,29 @@ export function getInitialTestAccountsWallets(pxe: PXE): Promise<AccountWalletWi
  */
 export async function getDeployedTestAccountsWallets(pxe: PXE): Promise<AccountWalletWithSecretKey[]> {
   const registeredAccounts = await pxe.getRegisteredAccounts();
-  return Promise.all(
-    INITIAL_TEST_SECRET_KEYS.filter(initialSecretKey => {
+  const publicKeys = await Promise.all(
+    INITIAL_TEST_SECRET_KEYS.map(async initialSecretKey => {
       const initialEncryptionKey = deriveMasterIncomingViewingSecretKey(initialSecretKey);
-      const publicKey = generatePublicKey(initialEncryptionKey);
-      return (
-        registeredAccounts.find(registered => registered.publicKeys.masterIncomingViewingPublicKey.equals(publicKey)) !=
-        undefined
-      );
-    }).map(secretKey => {
-      const signingKey = deriveSigningKey(secretKey);
-      // TODO(#5726): use actual salt here instead of hardcoding Fr.ZERO
-      return getSchnorrAccount(pxe, secretKey, signingKey, Fr.ZERO).getWallet();
+      const publicKey = await generatePublicKey(initialEncryptionKey);
+      return { sk: initialSecretKey, pk: publicKey };
     }),
   );
+  return Promise.all(
+    publicKeys
+      .filter(keyPairs => {
+        return (
+          registeredAccounts.find(registered =>
+            registered.publicKeys.masterIncomingViewingPublicKey.equals(keyPairs.pk),
+          ) != undefined
+        );
+      })
+      .map(async keyPairs => {
+        const signingKey = deriveSigningKey(keyPairs.sk);
+        // TODO(#5726): use actual salt here instead of hardcoding Fr.ZERO
+        const account = await getSchnorrAccount(pxe, keyPairs.sk, signingKey, Fr.ZERO);
+        return account.getWallet();
+      }),
+  );
 }
 
 /**
@@ -64,13 +79,20 @@ export async function getDeployedTestAccountsWallets(pxe: PXE): Promise<AccountW
  * @returns The set of deployed Account objects and associated private encryption keys
  */
 export async function deployInitialTestAccounts(pxe: PXE) {
-  const accounts = INITIAL_TEST_SECRET_KEYS.map((secretKey, i) => {
-    const account = getSchnorrAccount(pxe, secretKey, INITIAL_TEST_SIGNING_KEYS[i], INITIAL_TEST_ACCOUNT_SALTS[i]);
-    return {
-      account,
-      secretKey,
-    };
-  });
+  const accounts = await Promise.all(
+    INITIAL_TEST_SECRET_KEYS.map(async (secretKey, i) => {
+      const account = await getSchnorrAccount(
+        pxe,
+        secretKey,
+        INITIAL_TEST_SIGNING_KEYS[i],
+        INITIAL_TEST_ACCOUNT_SALTS[i],
+      );
+      return {
+        account,
+        secretKey,
+      };
+    }),
+  );
   // Register contract class to avoid duplicate nullifier errors
   const { l1ChainId: chainId, protocolVersion } = await pxe.getNodeInfo();
   const deployWallet = new SignerlessWallet(pxe, new DefaultMultiCallEntrypoint(chainId, protocolVersion));
@@ -80,7 +102,7 @@ export async function deployInitialTestAccounts(pxe: PXE) {
     accounts.map(async x => {
       const deployMethod = await x.account.getDeployMethod();
       const tx = await deployMethod.prove({
-        contractAddressSalt: x.account.salt,
+        contractAddressSalt: new Fr(x.account.salt),
         universalDeploy: true,
       });
       return tx;

package/src/testing/create_account.ts

@@ -10,10 +10,11 @@ import { getSchnorrAccount } from '../schnorr/index.js';
  * @param pxe - PXE.
  * @returns - A wallet for a fresh account.
  */
-export function createAccount(pxe: PXE): Promise<AccountWalletWithSecretKey> {
+export async function createAccount(pxe: PXE): Promise<AccountWalletWithSecretKey> {
   const secretKey = Fr.random();
   const signingKey = deriveSigningKey(secretKey);
-  return getSchnorrAccount(pxe, secretKey, signingKey).waitSetup();
+  const account = await getSchnorrAccount(pxe, secretKey, signingKey);
+  return account.waitSetup();
 }
 
 /**
@@ -40,20 +41,22 @@ export async function createAccounts(
   const accountsAndDeployments = await Promise.all(
     secrets.map(async (secret, index) => {
       const signingKey = deriveSigningKey(secret);
-      const account = getSchnorrAccount(pxe, secret, signingKey);
+      const account = await getSchnorrAccount(pxe, secret, signingKey);
 
       // only register the contract class once
       let skipClassRegistration = true;
       if (index === 0) {
         // for the first account, check if the contract class is already registered, otherwise we should register now
-        if (!(await pxe.isContractClassPubliclyRegistered(account.getInstance().contractClassId))) {
+        if (
+          !(await pxe.getContractClassMetadata(account.getInstance().contractClassId)).isContractClassPubliclyRegistered
+        ) {
           skipClassRegistration = false;
         }
       }
 
       const deployMethod = await account.getDeployMethod();
       const provenTx = await deployMethod.prove({
-        contractAddressSalt: account.salt,
+        contractAddressSalt: new Fr(account.salt),
         skipClassRegistration,
         skipPublicDeployment: true,
         universalDeploy: true,