refactor: remove get outgoing notes from pxe

yarn-project/aztec.js/src/contract/contract.test.ts

@@ -147,7 +147,11 @@ describe('Contract Class', () => {
     wallet = mock<Wallet>();
     wallet.simulateTx.mockResolvedValue(mockTxSimulationResult);
     wallet.createTxExecutionRequest.mockResolvedValue(mockTxRequest);
-    wallet.getContractInstance.mockResolvedValue(contractInstance);
+    wallet.getContractMetadata.mockResolvedValue({
+      contractInstance,
+      isContractInitialized: true,
+      isContractPubliclyDeployed: true,
+    });
     wallet.sendTx.mockResolvedValue(mockTxHash);
     wallet.simulateUnconstrained.mockResolvedValue(mockUnconstrainedResultValue as any as AbiDecoded);
     wallet.getTxReceipt.mockResolvedValue(mockTxReceipt);

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

@@ -22,7 +22,7 @@ export class Contract extends ContractBase {
    * @returns A promise that resolves to a new Contract instance.
    */
   public static async at(address: AztecAddress, artifact: ContractArtifact, wallet: Wallet): Promise<Contract> {
-    const instance = await wallet.getContractInstance(address);
+    const instance = (await wallet.getContractMetadata(address)).contractInstance;
     if (instance === undefined) {
       throw new Error(`Contract instance at ${address.toString()} has not been registered in the wallet's PXE`);
     }

yarn-project/aztec.js/src/contract/deploy_method.ts

@@ -153,7 +153,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
 
     // Register the contract class if it hasn't been published already.
     if (!options.skipClassRegistration) {
-      if (await this.wallet.isContractClassPubliclyRegistered(contractClass.id)) {
+      if ((await this.wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
         this.log.debug(
           `Skipping registration of already registered contract class ${contractClass.id.toString()} for ${instance.address.toString()}`,
         );

yarn-project/aztec.js/src/wallet/base_wallet.ts

@@ -1,5 +1,7 @@
 import {
   type AuthWitness,
+  ContractClassMetadata,
+  ContractMetadata,
   type EventMetadataDefinition,
   type ExtendedNote,
   type GetUnencryptedLogsResponse,
@@ -65,15 +67,6 @@ export abstract class BaseWallet implements Wallet {
   getAddress() {
     return this.getCompleteAddress().address;
   }
-  getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    return this.pxe.getContractInstance(address);
-  }
-  getContractClass(id: Fr): Promise<ContractClassWithId | undefined> {
-    return this.pxe.getContractClass(id);
-  }
-  getContractArtifact(id: Fr): Promise<ContractArtifact | undefined> {
-    return this.pxe.getContractArtifact(id);
-  }
   addCapsule(capsule: Fr[]): Promise<void> {
     return this.pxe.addCapsule(capsule);
   }
@@ -83,9 +76,6 @@ export abstract class BaseWallet implements Wallet {
   getRegisteredAccounts(): Promise<CompleteAddress[]> {
     return this.pxe.getRegisteredAccounts();
   }
-  getRegisteredAccount(address: AztecAddress): Promise<CompleteAddress | undefined> {
-    return this.pxe.getRegisteredAccount(address);
-  }
   registerContact(address: AztecAddress): Promise<AztecAddress> {
     return this.pxe.registerContact(address);
   }
@@ -131,9 +121,6 @@ export abstract class BaseWallet implements Wallet {
   getIncomingNotes(filter: IncomingNotesFilter): Promise<UniqueNote[]> {
     return this.pxe.getIncomingNotes(filter);
   }
-  getOutgoingNotes(filter: OutgoingNotesFilter): Promise<UniqueNote[]> {
-    return this.pxe.getOutgoingNotes(filter);
-  }
   getPublicStorageAt(contract: AztecAddress, storageSlot: Fr): Promise<any> {
     return this.pxe.getPublicStorageAt(contract, storageSlot);
   }
@@ -184,18 +171,15 @@ export abstract class BaseWallet implements Wallet {
   getAuthWitness(messageHash: Fr) {
     return this.pxe.getAuthWitness(messageHash);
   }
-  isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
-    return this.pxe.isContractClassPubliclyRegistered(id);
-  }
-  isContractPubliclyDeployed(address: AztecAddress): Promise<boolean> {
-    return this.pxe.isContractPubliclyDeployed(address);
-  }
-  isContractInitialized(address: AztecAddress): Promise<boolean> {
-    return this.pxe.isContractInitialized(address);
-  }
   getPXEInfo(): Promise<PXEInfo> {
     return this.pxe.getPXEInfo();
   }
+  getContractClassMetadata(id: Fr, includeArtifact: boolean = false): Promise<ContractClassMetadata> {
+    return this.pxe.getContractClassMetadata(id, includeArtifact);
+  }
+  getContractMetadata(address: AztecAddress): Promise<ContractMetadata> {
+    return this.pxe.getContractMetadata(address);
+  }
   getEncryptedEvents<T>(
     event: EventMetadataDefinition,
     from: number,

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

@@ -21,7 +21,9 @@ export async function getWallet(
   address: AztecAddress,
   accountContract: AccountContract,
 ): Promise<AccountWallet> {
-  const completeAddress = await pxe.getRegisteredAccount(address);
+  const completeAddress = (await pxe.getRegisteredAccounts()).find(completeAddress =>
+    completeAddress.address.equals(address),
+  );
   if (!completeAddress) {
     throw new Error(`Account ${address} not found`);
   }

yarn-project/bot/src/factory.ts

@@ -63,7 +63,7 @@ export class BotFactory {
     const salt = Fr.ONE;
     const signingKey = deriveSigningKey(this.config.senderPrivateKey);
     const account = getSchnorrAccount(this.pxe, this.config.senderPrivateKey, signingKey, salt);
-    const isInit = await this.pxe.isContractInitialized(account.getAddress());
+    const isInit = (await this.pxe.getContractMetadata(account.getAddress())).isContractInitialized;
     if (isInit) {
       this.log.info(`Account at ${account.getAddress().toString()} already initialized`);
       const wallet = await account.register();
@@ -122,7 +122,7 @@ export class BotFactory {
     }
 
     const address = deploy.getInstance(deployOpts).address;
-    if (await this.pxe.isContractPubliclyDeployed(address)) {
+    if ((await this.pxe.getContractMetadata(address)).isContractPubliclyDeployed) {
       this.log.info(`Token at ${address.toString()} already deployed`);
       return deploy.register();
     } else {

yarn-project/circuit-types/src/interfaces/pxe.test.ts

@@ -42,7 +42,14 @@ import { SiblingPath } from '../sibling_path/sibling_path.js';
 import { Tx, TxHash, TxProvingResult, TxReceipt, TxSimulationResult } from '../tx/index.js';
 import { TxEffect } from '../tx_effect.js';
 import { TxExecutionRequest } from '../tx_execution_request.js';
-import { type EventMetadataDefinition, type PXE, type PXEInfo, PXESchema } from './pxe.js';
+import {
+  ContractClassMetadata,
+  ContractMetadata,
+  type EventMetadataDefinition,
+  type PXE,
+  type PXEInfo,
+  PXESchema,
+} from './pxe.js';
 import { type SyncStatus } from './sync-status.js';
 
 jest.setTimeout(12_000);
@@ -110,11 +117,6 @@ describe('PXESchema', () => {
     expect(result).toEqual([expect.any(CompleteAddress)]);
   });
 
-  it('getRegisteredAccount', async () => {
-    const result = await context.client.getRegisteredAccount(address);
-    expect(result).toBeInstanceOf(CompleteAddress);
-  });
-
   it('registerContact', async () => {
     const result = await context.client.registerContact(address);
     expect(result).toEqual(address);
@@ -201,11 +203,6 @@ describe('PXESchema', () => {
     expect(result).toEqual([expect.any(BigInt), expect.any(SiblingPath)]);
   });
 
-  it('getOutgoingNotes', async () => {
-    const result = await context.client.getOutgoingNotes({ contractAddress: address });
-    expect(result).toEqual([expect.any(UniqueNote)]);
-  });
-
   it('addNote', async () => {
     await context.client.addNote(ExtendedNote.random(), address);
   });
@@ -269,35 +266,24 @@ describe('PXESchema', () => {
     expect(result).toEqual(await handler.getSyncStatus());
   });
 
-  it('getContractInstance', async () => {
-    const result = await context.client.getContractInstance(address);
-    expect(result).toEqual(instance);
+  it('getContractMetadata', async () => {
+    const { contractInstance, isContractInitialized, isContractPubliclyDeployed } =
+      await context.client.getContractMetadata(address);
+    expect(contractInstance).toEqual(instance);
+    expect(isContractInitialized).toEqual(true);
+    expect(isContractPubliclyDeployed).toEqual(true);
   });
 
-  it('getContractClass', async () => {
-    const result = await context.client.getContractClass(Fr.random());
+  it('getContractClassMetadata', async () => {
+    const {
+      contractClass,
+      isContractClassPubliclyRegistered,
+      artifact: contractArtifact,
+    } = await context.client.getContractClassMetadata(Fr.random(), true);
     const expected = omit(getContractClassFromArtifact(artifact), 'privateFunctionsRoot', 'publicBytecodeCommitment');
-    expect(result).toEqual(expected);
-  });
-
-  it('getContractArtifact', async () => {
-    const result = await context.client.getContractArtifact(Fr.random());
-    deepStrictEqual(result, artifact);
-  });
-
-  it('isContractClassPubliclyRegistered', async () => {
-    const result = await context.client.isContractClassPubliclyRegistered(Fr.random());
-    expect(result).toBe(true);
-  });
-
-  it('isContractPubliclyDeployed', async () => {
-    const result = await context.client.isContractPubliclyDeployed(address);
-    expect(result).toBe(true);
-  });
-
-  it('isContractInitialized', async () => {
-    const result = await context.client.isContractInitialized(address);
-    expect(result).toBe(true);
+    expect(contractClass).toEqual(expected);
+    expect(isContractClassPubliclyRegistered).toEqual(true);
+    deepStrictEqual(contractArtifact, artifact);
   });
 
   it('getEncryptedEvents', async () => {
@@ -433,10 +419,6 @@ class MockPXE implements PXE {
     expect(secret).toBeInstanceOf(Fr);
     return Promise.resolve([1n, SiblingPath.random(L1_TO_L2_MSG_TREE_HEIGHT)]);
   }
-  getOutgoingNotes(filter: OutgoingNotesFilter): Promise<UniqueNote[]> {
-    expect(filter.contractAddress).toEqual(this.address);
-    return Promise.resolve([UniqueNote.random()]);
-  }
   addNote(note: ExtendedNote, scope?: AztecAddress | undefined): Promise<void> {
     expect(note).toBeInstanceOf(ExtendedNote);
     expect(scope).toEqual(this.address);
@@ -510,30 +492,22 @@ class MockPXE implements PXE {
       blocks: 1,
     });
   }
-  getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    expect(address).toEqual(this.address);
-    return Promise.resolve(this.instance);
-  }
-  getContractClass(id: Fr): Promise<ContractClassWithId | undefined> {
+  getContractClassMetadata(id: Fr, includeArtifact: boolean = false): Promise<ContractClassMetadata> {
     expect(id).toBeInstanceOf(Fr);
     const contractClass = getContractClassFromArtifact(this.artifact);
-    return Promise.resolve(contractClass);
-  }
-  getContractArtifact(id: Fr): Promise<ContractArtifact | undefined> {
-    expect(id).toBeInstanceOf(Fr);
-    return Promise.resolve(this.artifact);
-  }
-  isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
-    expect(id).toBeInstanceOf(Fr);
-    return Promise.resolve(true);
-  }
-  isContractPubliclyDeployed(address: AztecAddress): Promise<boolean> {
-    expect(address).toEqual(this.address);
-    return Promise.resolve(true);
+    return Promise.resolve({
+      contractClass,
+      isContractClassPubliclyRegistered: true,
+      artifact: includeArtifact ? this.artifact : undefined,
+    });
   }
-  isContractInitialized(address: AztecAddress): Promise<boolean> {
+  getContractMetadata(address: AztecAddress): Promise<ContractMetadata> {
     expect(address).toEqual(this.address);
-    return Promise.resolve(true);
+    return Promise.resolve({
+      contractInstance: this.instance,
+      isContractInitialized: true,
+      isContractPubliclyDeployed: true,
+    });
   }
   getEncryptedEvents<T>(
     _eventMetadata: EventMetadataDefinition,