@aztec/aztec.js 0.7.3 → 0.7.5

package/src/account/contract/base_account_contract.ts

@@ -0,0 +1,25 @@
+import { ContractAbi } from '@aztec/foundation/abi';
+import { CompleteAddress, NodeInfo } from '@aztec/types';
+
+import { DefaultAccountInterface } from '../defaults/default_interface.js';
+import { AccountInterface, AuthWitnessProvider } from '../interface.js';
+import { AccountContract } from './index.js';
+
+/**
+ * Base class for implementing an account contract. Requires that the account uses the
+ * default entrypoint method signature.
+ */
+export abstract class BaseAccountContract implements AccountContract {
+  abstract getAuthWitnessProvider(address: CompleteAddress): AuthWitnessProvider;
+  abstract getDeploymentArgs(): Promise<any[]>;
+
+  constructor(private abi: ContractAbi) {}
+
+  getContractAbi(): ContractAbi {
+    return this.abi;
+  }
+
+  getInterface(address: CompleteAddress, nodeInfo: NodeInfo): Promise<AccountInterface> {
+    return Promise.resolve(new DefaultAccountInterface(this.getAuthWitnessProvider(address), address, nodeInfo));
+  }
+}

package/src/account/contract/ecdsa_account_contract.ts

@@ -1,29 +1,38 @@
+import { Fr } from '@aztec/circuits.js';
 import { Ecdsa } from '@aztec/circuits.js/barretenberg';
 import { ContractAbi } from '@aztec/foundation/abi';
-import { CompleteAddress, NodeInfo } from '@aztec/types';
+import { AuthWitness, CompleteAddress } from '@aztec/types';
 
 import EcdsaAccountContractAbi from '../../abis/ecdsa_account_contract.json' assert { type: 'json' };
-import { StoredKeyAccountEntrypoint } from '../entrypoint/stored_key_account_entrypoint.js';
-import { AccountContract } from './index.js';
+import { AuthWitnessProvider } from '../interface.js';
+import { BaseAccountContract } from './base_account_contract.js';
 
 /**
  * Account contract that authenticates transactions using ECDSA signatures
  * verified against a secp256k1 public key stored in an immutable encrypted note.
- */ export class EcdsaAccountContract implements AccountContract {
-  constructor(private signingPrivateKey: Buffer) {}
+ */
+export class EcdsaAccountContract extends BaseAccountContract {
+  constructor(private signingPrivateKey: Buffer) {
+    super(EcdsaAccountContractAbi as unknown as ContractAbi);
+  }
 
-  public async getDeploymentArgs() {
+  async getDeploymentArgs() {
     const signingPublicKey = await Ecdsa.new().then(e => e.computePublicKey(this.signingPrivateKey));
     return [signingPublicKey.subarray(0, 32), signingPublicKey.subarray(32, 64)];
   }
 
-  public async getEntrypoint({ address }: CompleteAddress, { chainId, version }: NodeInfo) {
-    const ecdsa = await Ecdsa.new();
-    const signClosure = (msg: Buffer) => ecdsa.constructSignature(msg, this.signingPrivateKey);
-    return new StoredKeyAccountEntrypoint(address, signClosure, chainId, version);
+  getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {
+    return new EcdsaAuthWitnessProvider(this.signingPrivateKey);
   }
+}
 
-  public getContractAbi(): ContractAbi {
-    return EcdsaAccountContractAbi as unknown as ContractAbi;
+/** Creates auth witnesses using ECDSA signatures. */
+class EcdsaAuthWitnessProvider implements AuthWitnessProvider {
+  constructor(private signingPrivateKey: Buffer) {}
+
+  async createAuthWitness(message: Fr): Promise<AuthWitness> {
+    const ecdsa = await Ecdsa.new();
+    const signature = ecdsa.constructSignature(message.toBuffer(), this.signingPrivateKey);
+    return new AuthWitness(message, [...signature.r, ...signature.s]);
   }
 }

package/src/account/contract/index.ts

@@ -1,32 +1,37 @@
 import { ContractAbi } from '@aztec/foundation/abi';
 import { CompleteAddress, NodeInfo } from '@aztec/types';
 
-import { Entrypoint } from '../index.js';
+import { AccountInterface } from '../interface.js';
 
 export * from './ecdsa_account_contract.js';
 export * from './schnorr_account_contract.js';
 export * from './single_key_account_contract.js';
-export * from './auth_witness_account_contract.js';
+export * from './base_account_contract.js';
 
 // docs:start:account-contract-interface
 /**
- * An account contract instance. Knows its ABI, deployment arguments, and to create
- * transaction execution requests out of function calls through an entrypoint.
+ * An account contract instance. Knows its ABI, deployment arguments, how to create
+ * transaction execution requests out of function calls, and how to authorize actions.
  */
 export interface AccountContract {
   /**
    * Returns the ABI of this account contract.
    */
   getContractAbi(): ContractAbi;
+
   /**
    * Returns the deployment arguments for this instance.
    */
   getDeploymentArgs(): Promise<any[]>;
+
   /**
-   * Creates an entrypoint for creating transaction execution requests for this account contract.
-   * @param address - Complete address of the deployed account contract.
-   * @param nodeInfo - Chain id and protocol version where the account contract is deployed.
+   * Returns the account interface for this account contract given a deployment at the provided address.
+   * The account interface is responsible for assembling tx requests given requested function calls, and
+   * for creating signed auth witnesses given action identifiers (message hashes).
+   * @param address - Address where this account contract is deployed.
+   * @param nodeInfo - Info on the chain where it is deployed.
+   * @returns An account interface instance for creating tx requests and authorizing actions.
    */
-  getEntrypoint(address: CompleteAddress, nodeInfo: NodeInfo): Promise<Entrypoint>;
+  getInterface(address: CompleteAddress, nodeInfo: NodeInfo): Promise<AccountInterface>;
 }
 // docs:end:account-contract-interface

package/src/account/contract/schnorr_account_contract.ts

@@ -1,30 +1,38 @@
+import { Fr } from '@aztec/circuits.js';
 import { Schnorr } from '@aztec/circuits.js/barretenberg';
 import { ContractAbi } from '@aztec/foundation/abi';
-import { CompleteAddress, GrumpkinPrivateKey, NodeInfo } from '@aztec/types';
+import { AuthWitness, CompleteAddress, GrumpkinPrivateKey } from '@aztec/types';
 
 import SchnorrAccountContractAbi from '../../abis/schnorr_account_contract.json' assert { type: 'json' };
-import { StoredKeyAccountEntrypoint } from '../entrypoint/stored_key_account_entrypoint.js';
-import { AccountContract } from './index.js';
+import { AuthWitnessProvider } from '../interface.js';
+import { BaseAccountContract } from './base_account_contract.js';
 
 /**
  * Account contract that authenticates transactions using Schnorr signatures
  * verified against a Grumpkin public key stored in an immutable encrypted note.
  */
-export class SchnorrAccountContract implements AccountContract {
-  constructor(private signingPrivateKey: GrumpkinPrivateKey) {}
+export class SchnorrAccountContract extends BaseAccountContract {
+  constructor(private signingPrivateKey: GrumpkinPrivateKey) {
+    super(SchnorrAccountContractAbi as unknown as ContractAbi);
+  }
 
-  public async getDeploymentArgs() {
+  async getDeploymentArgs() {
     const signingPublicKey = await Schnorr.new().then(e => e.computePublicKey(this.signingPrivateKey));
     return [signingPublicKey.x, signingPublicKey.y];
   }
 
-  public async getEntrypoint({ address }: CompleteAddress, { chainId, version }: NodeInfo) {
-    const schnorr = await Schnorr.new();
-    const signClosure = (msg: Buffer) => schnorr.constructSignature(msg, this.signingPrivateKey);
-    return new StoredKeyAccountEntrypoint(address, signClosure, chainId, version);
+  getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {
+    return new SchnorrAuthWitnessProvider(this.signingPrivateKey);
   }
+}
 
-  public getContractAbi(): ContractAbi {
-    return SchnorrAccountContractAbi as unknown as ContractAbi;
+/** Creates auth witnesses using Schnorr signatures. */
+class SchnorrAuthWitnessProvider implements AuthWitnessProvider {
+  constructor(private signingPrivateKey: GrumpkinPrivateKey) {}
+
+  async createAuthWitness(message: Fr): Promise<AuthWitness> {
+    const schnorr = await Schnorr.new();
+    const signature = schnorr.constructSignature(message.toBuffer(), this.signingPrivateKey).toBuffer();
+    return new AuthWitness(message, [...signature]);
   }
 }

package/src/account/contract/single_key_account_contract.ts

@@ -1,28 +1,44 @@
+import { Fr, PartialAddress } from '@aztec/circuits.js';
+import { Schnorr } from '@aztec/circuits.js/barretenberg';
 import { ContractAbi } from '@aztec/foundation/abi';
-import { CompleteAddress, GrumpkinPrivateKey, NodeInfo } from '@aztec/types';
+import { AuthWitness, CompleteAddress, GrumpkinPrivateKey } from '@aztec/types';
 
 import SchnorrSingleKeyAccountContractAbi from '../../abis/schnorr_single_key_account_contract.json' assert { type: 'json' };
-import { SingleKeyAccountEntrypoint } from '../entrypoint/single_key_account_entrypoint.js';
-import { AccountContract } from './index.js';
+import { generatePublicKey } from '../../index.js';
+import { AuthWitnessProvider } from '../interface.js';
+import { BaseAccountContract } from './base_account_contract.js';
 
 /**
  * Account contract that authenticates transactions using Schnorr signatures verified against
  * the note encryption key, relying on a single private key for both encryption and authentication.
  */
-export class SingleKeyAccountContract implements AccountContract {
-  constructor(private encryptionPrivateKey: GrumpkinPrivateKey) {}
+export class SingleKeyAccountContract extends BaseAccountContract {
+  constructor(private encryptionPrivateKey: GrumpkinPrivateKey) {
+    super(SchnorrSingleKeyAccountContractAbi as unknown as ContractAbi);
+  }
 
-  public getDeploymentArgs() {
+  getDeploymentArgs(): Promise<any[]> {
     return Promise.resolve([]);
   }
 
-  public getEntrypoint({ address, partialAddress }: CompleteAddress, { chainId, version }: NodeInfo) {
-    return Promise.resolve(
-      new SingleKeyAccountEntrypoint(address, partialAddress, this.encryptionPrivateKey, chainId, version),
-    );
+  getAuthWitnessProvider({ partialAddress }: CompleteAddress): AuthWitnessProvider {
+    return new SingleKeyAuthWitnessProvider(this.encryptionPrivateKey, partialAddress);
   }
+}
+
+/**
+ * Creates auth witnesses using Schnorr signatures and including the partial address and public key
+ * in the witness, so verifiers do not need to store the public key and can instead validate it
+ * by reconstructing the current address.
+ */
+class SingleKeyAuthWitnessProvider implements AuthWitnessProvider {
+  constructor(private privateKey: GrumpkinPrivateKey, private partialAddress: PartialAddress) {}
 
-  public getContractAbi(): ContractAbi {
-    return SchnorrSingleKeyAccountContractAbi as unknown as ContractAbi;
+  async createAuthWitness(message: Fr): Promise<AuthWitness> {
+    const schnorr = await Schnorr.new();
+    const signature = schnorr.constructSignature(message.toBuffer(), this.privateKey);
+    const publicKey = await generatePublicKey(this.privateKey);
+    const witness = [...publicKey.toFields(), ...signature.toBuffer(), this.partialAddress];
+    return new AuthWitness(message, witness);
   }
 }

package/src/account/defaults/default_entrypoint.ts

@@ -0,0 +1,95 @@
+import { AztecAddress, Fr, FunctionData, TxContext } from '@aztec/circuits.js';
+import { FunctionAbiHeader, encodeArguments } from '@aztec/foundation/abi';
+import { FunctionCall, PackedArguments, TxExecutionRequest } from '@aztec/types';
+
+import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from '../../utils/defaults.js';
+import { AuthWitnessProvider, EntrypointInterface } from '../interface.js';
+import { buildPayload, hashPayload } from './entrypoint_payload.js';
+
+/**
+ * Implementation for an entrypoint interface that follows the default entrypoint signature
+ * for an account, which accepts an EntrypointPayload as defined in noir-libs/aztec-noir/src/entrypoint.nr.
+ */
+export class DefaultAccountEntrypoint implements EntrypointInterface {
+  constructor(
+    private address: AztecAddress,
+    private auth: AuthWitnessProvider,
+    private chainId: number = DEFAULT_CHAIN_ID,
+    private version: number = DEFAULT_VERSION,
+  ) {}
+
+  async createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest> {
+    const { payload, packedArguments: callsPackedArguments } = await buildPayload(executions);
+    const abi = this.getEntrypointAbi();
+    const packedArgs = await PackedArguments.fromArgs(encodeArguments(abi, [payload]));
+    const message = Fr.fromBuffer(await hashPayload(payload));
+    const authWitness = await this.auth.createAuthWitness(message);
+    const txRequest = TxExecutionRequest.from({
+      argsHash: packedArgs.hash,
+      origin: this.address,
+      functionData: FunctionData.fromAbi(abi),
+      txContext: TxContext.empty(this.chainId, this.version),
+      packedArguments: [...callsPackedArguments, packedArgs],
+      authWitnesses: [authWitness],
+    });
+
+    return txRequest;
+  }
+
+  private getEntrypointAbi() {
+    return {
+      name: 'entrypoint',
+      functionType: 'secret',
+      isInternal: false,
+      parameters: [
+        {
+          name: 'payload',
+          type: {
+            kind: 'struct',
+            path: 'aztec::entrypoint::EntrypointPayload',
+            fields: [
+              {
+                name: 'flattened_args_hashes',
+                type: {
+                  kind: 'array',
+                  length: 4,
+                  type: {
+                    kind: 'field',
+                  },
+                },
+              },
+              {
+                name: 'flattened_selectors',
+                type: {
+                  kind: 'array',
+                  length: 4,
+                  type: {
+                    kind: 'field',
+                  },
+                },
+              },
+              {
+                name: 'flattened_targets',
+                type: {
+                  kind: 'array',
+                  length: 4,
+                  type: {
+                    kind: 'field',
+                  },
+                },
+              },
+              {
+                name: 'nonce',
+                type: {
+                  kind: 'field',
+                },
+              },
+            ],
+          },
+          visibility: 'public',
+        },
+      ],
+      returnTypes: [],
+    } as unknown as FunctionAbiHeader;
+  }
+}

package/src/account/defaults/default_interface.ts

@@ -0,0 +1,36 @@
+import { CompleteAddress, Fr } from '@aztec/circuits.js';
+import { AuthWitness, FunctionCall, NodeInfo, TxExecutionRequest } from '@aztec/types';
+
+import { AccountInterface, AuthWitnessProvider, EntrypointInterface } from '../interface.js';
+import { DefaultAccountEntrypoint } from './default_entrypoint.js';
+
+/**
+ * Default implementation for an account interface. Requires that the account uses the default
+ * entrypoint signature, which accepts an EntrypointPayload as defined in noir-libs/aztec-noir/src/entrypoint.nr.
+ */
+export class DefaultAccountInterface implements AccountInterface {
+  private entrypoint: EntrypointInterface;
+
+  constructor(
+    private authWitnessProvider: AuthWitnessProvider,
+    private address: CompleteAddress,
+    nodeInfo: Pick<NodeInfo, 'chainId' | 'version'>,
+  ) {
+    this.entrypoint = new DefaultAccountEntrypoint(
+      address.address,
+      authWitnessProvider,
+      nodeInfo.chainId,
+      nodeInfo.version,
+    );
+  }
+
+  createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest> {
+    return this.entrypoint.createTxExecutionRequest(executions);
+  }
+  createAuthWitness(message: Fr): Promise<AuthWitness> {
+    return this.authWitnessProvider.createAuthWitness(message);
+  }
+  getCompleteAddress(): CompleteAddress {
+    return this.address;
+  }
+}

package/src/account/defaults/index.ts

@@ -0,0 +1,3 @@
+export * from './entrypoint_payload.js';
+export * from './default_entrypoint.js';
+export * from './default_interface.js';

package/src/account/index.ts

@@ -1,15 +1,15 @@
 import { AztecRPC, CompleteAddress, GrumpkinPrivateKey } from '@aztec/types';
 
 import { AccountContract, AccountWallet, AztecAddress, Fr } from '../index.js';
-import { Account } from './account.js';
 import { EcdsaAccountContract } from './contract/ecdsa_account_contract.js';
 import { SchnorrAccountContract } from './contract/schnorr_account_contract.js';
 import { SingleKeyAccountContract } from './contract/single_key_account_contract.js';
+import { AccountManager } from './manager/index.js';
 
-export { Account } from './account.js';
 export * from './contract/index.js';
-export * from './entrypoint/index.js';
-export { CompleteAddress };
+export * from './defaults/index.js';
+export { AccountInterface, AuthWitnessProvider } from './interface.js';
+export { AccountManager, CompleteAddress };
 
 /** A contract deployment salt. */
 export type Salt = Fr | number | bigint;
@@ -26,8 +26,8 @@ export function getEcdsaAccount(
   encryptionPrivateKey: GrumpkinPrivateKey,
   signingPrivateKey: Buffer,
   saltOrAddress?: Salt | CompleteAddress,
-): Account {
-  return new Account(rpc, encryptionPrivateKey, new EcdsaAccountContract(signingPrivateKey), saltOrAddress);
+): AccountManager {
+  return new AccountManager(rpc, encryptionPrivateKey, new EcdsaAccountContract(signingPrivateKey), saltOrAddress);
 }
 
 /**
@@ -42,8 +42,8 @@ export function getSchnorrAccount(
   encryptionPrivateKey: GrumpkinPrivateKey,
   signingPrivateKey: GrumpkinPrivateKey,
   saltOrAddress?: Salt | CompleteAddress,
-): Account {
-  return new Account(rpc, encryptionPrivateKey, new SchnorrAccountContract(signingPrivateKey), saltOrAddress);
+): AccountManager {
+  return new AccountManager(rpc, encryptionPrivateKey, new SchnorrAccountContract(signingPrivateKey), saltOrAddress);
 }
 
 /**
@@ -56,8 +56,8 @@ export function getUnsafeSchnorrAccount(
   rpc: AztecRPC,
   encryptionAndSigningPrivateKey: GrumpkinPrivateKey,
   saltOrAddress?: Salt | CompleteAddress,
-): Account {
-  return new Account(
+): AccountManager {
+  return new AccountManager(
     rpc,
     encryptionAndSigningPrivateKey,
     new SingleKeyAccountContract(encryptionAndSigningPrivateKey),
@@ -85,18 +85,18 @@ export function getUnsafeSchnorrWallet(
  * @param rpc - An AztecRPC server instance.
  * @param address - Address for the account.
  * @param accountContract - Account contract implementation.
- * * @returns A wallet for this account that can be used to interact with a contract instance.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
  */
 export async function getWallet(
   rpc: AztecRPC,
   address: AztecAddress,
   accountContract: AccountContract,
 ): Promise<AccountWallet> {
-  const completeAddress = await rpc.getAccount(address);
+  const completeAddress = await rpc.getRegisteredAccount(address);
   if (!completeAddress) {
     throw new Error(`Account ${address} not found`);
   }
   const nodeInfo = await rpc.getNodeInfo();
-  const entrypoint = await accountContract.getEntrypoint(completeAddress, nodeInfo);
-  return new AccountWallet(rpc, entrypoint, completeAddress);
+  const entrypoint = await accountContract.getInterface(completeAddress, nodeInfo);
+  return new AccountWallet(rpc, entrypoint);
 }

package/src/account/interface.ts

@@ -0,0 +1,35 @@
+import { Fr } from '@aztec/circuits.js';
+import { AuthWitness, CompleteAddress, FunctionCall, TxExecutionRequest } from '@aztec/types';
+
+// docs:start:account-interface
+/** Creates authorization witnesses. */
+export interface AuthWitnessProvider {
+  /**
+   * Create an authorization witness for the given message.
+   * @param message - Message to authorize.
+   */
+  createAuthWitness(message: Fr): Promise<AuthWitness>;
+}
+
+/** Creates transaction execution requests out of a set of function calls. */
+export interface EntrypointInterface {
+  /**
+   * Generates an authenticated request out of set of function calls.
+   * @param executions - The execution intents to be run.
+   * @param opts - Options.
+   * @returns The authenticated transaction execution request.
+   */
+  createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest>;
+}
+
+/**
+ * Handler for interfacing with an account. Knows how to create transaction execution
+ * requests and authorize actions for its corresponding account.
+ */
+export interface AccountInterface extends AuthWitnessProvider, EntrypointInterface {
+  /**
+   * Returns the complete address for this account.
+   */
+  getCompleteAddress(): CompleteAddress;
+}
+// docs:end:account-interface

package/src/account/{deploy_account_sent_tx.ts → manager/deploy_account_sent_tx.ts}

@@ -1,7 +1,7 @@
 import { FieldsOf } from '@aztec/circuits.js';
 import { TxHash, TxReceipt } from '@aztec/types';
 
-import { SentTx, WaitOpts, Wallet } from '../index.js';
+import { SentTx, WaitOpts, Wallet } from '../../index.js';
 
 /** Extends a transaction receipt with a wallet instance for the newly deployed contract. */
 export type DeployAccountTxReceipt = FieldsOf<TxReceipt> & {

package/src/account/{account.ts → manager/index.ts}

@@ -1,15 +1,16 @@
 import { Fr, PublicKey, getContractDeploymentInfo } from '@aztec/circuits.js';
 import { AztecRPC, CompleteAddress, GrumpkinPrivateKey } from '@aztec/types';
 
-import { AccountWallet, ContractDeployer, DeployMethod, WaitOpts, generatePublicKey } from '../index.js';
+import { AccountWallet, ContractDeployer, DeployMethod, WaitOpts, generatePublicKey } from '../../index.js';
+import { AccountContract, Salt } from '../index.js';
+import { AccountInterface } from '../interface.js';
 import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
-import { AccountContract, Entrypoint, Salt } from './index.js';
 
 /**
  * Manages a user account. Provides methods for calculating the account's address, deploying the account contract,
  * and creating and registering the user wallet in the RPC server.
  */
-export class Account {
+export class AccountManager {
   /** Deployment salt for the account contract. */
   public readonly salt?: Fr;
 
@@ -41,10 +42,10 @@ export class Account {
    * Returns the entrypoint for this account as defined by its account contract.
    * @returns An entrypoint.
    */
-  public async getEntrypoint(): Promise<Entrypoint> {
+  public async getAccount(): Promise<AccountInterface> {
     const nodeInfo = await this.rpc.getNodeInfo();
     const completeAddress = await this.getCompleteAddress();
-    return this.accountContract.getEntrypoint(completeAddress, nodeInfo);
+    return this.accountContract.getInterface(completeAddress, nodeInfo);
   }
 
   /**
@@ -72,8 +73,8 @@ export class Account {
    * @returns A Wallet instance.
    */
   public async getWallet(): Promise<AccountWallet> {
-    const entrypoint = await this.getEntrypoint();
-    return new AccountWallet(this.rpc, entrypoint, await this.getCompleteAddress());
+    const entrypoint = await this.getAccount();
+    return new AccountWallet(this.rpc, entrypoint);
   }
 
   /**

package/src/{aztec_rpc_client/aztec_rpc_client.ts → aztec_rpc_client.ts}

@@ -1,6 +1,7 @@
 import { AztecAddress, CompleteAddress, EthAddress, Fr, GrumpkinScalar, Point } from '@aztec/circuits.js';
-import { createJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rpc/client';
+import { createJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
 import {
+  AuthWitness,
   AztecRPC,
   ContractData,
   ExtendedContractData,
@@ -14,7 +15,7 @@ import {
 
 export { makeFetch } from '@aztec/foundation/json-rpc/client';
 
-export const createAztecRpcClient = (url: string, fetch = defaultFetch): AztecRPC =>
+export const createAztecRpcClient = (url: string, fetch = makeFetch([1, 2, 3], true)): AztecRPC =>
   createJsonRpcClient<AztecRPC>(
     url,
     {
@@ -29,6 +30,7 @@ export const createAztecRpcClient = (url: string, fetch = defaultFetch): AztecRP
       Fr,
       GrumpkinScalar,
       NotePreimage,
+      AuthWitness,
     },
     { Tx, TxReceipt, L2BlockL2Logs },
     false,

package/src/contract/contract.test.ts

@@ -14,7 +14,7 @@ import {
 
 import { MockProxy, mock } from 'jest-mock-extended';
 
-import { Wallet } from '../aztec_rpc_client/wallet.js';
+import { Wallet } from '../wallet/index.js';
 import { Contract } from './contract.js';
 
 describe('Contract Class', () => {
@@ -28,7 +28,13 @@ describe('Contract Class', () => {
   const mockTxHash = { type: 'TxHash' } as any as TxHash;
   const mockTxReceipt = { type: 'TxReceipt' } as any as TxReceipt;
   const mockViewResultValue = 1;
-  const mockNodeInfo: NodeInfo = { version: 1, chainId: 2, rollupAddress: EthAddress.random(), client: '' };
+  const mockNodeInfo: NodeInfo = {
+    version: 1,
+    chainId: 2,
+    rollupAddress: EthAddress.random(),
+    client: '',
+    compatibleNargoVersion: 'vx.x.x-aztec.x',
+  };
 
   const defaultAbi: ContractAbi = {
     name: 'FooContract',
@@ -102,7 +108,7 @@ describe('Contract Class', () => {
     wallet.getTxReceipt.mockResolvedValue(mockTxReceipt);
     wallet.getNodeInfo.mockResolvedValue(mockNodeInfo);
     wallet.simulateTx.mockResolvedValue(mockTx);
-    wallet.getAccounts.mockResolvedValue([account]);
+    wallet.getRegisteredAccounts.mockResolvedValue([account]);
   });
 
   it('should create and send a contract method tx', async () => {

package/src/contract/contract.ts

@@ -2,8 +2,8 @@ import { ContractAbi } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { PublicKey } from '@aztec/types';
 
-import { Wallet } from '../aztec_rpc_client/wallet.js';
 import { DeployMethod, Point } from '../index.js';
+import { Wallet } from '../wallet/index.js';
 import { ContractBase } from './contract_base.js';
 
 /**

package/src/contract/contract_base.ts

@@ -2,7 +2,7 @@ import { ContractAbi, FunctionAbi, FunctionSelector } from '@aztec/foundation/ab
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { CompleteAddress, DeployedContract } from '@aztec/types';
 
-import { Wallet } from '../aztec_rpc_client/wallet.js';
+import { Wallet } from '../wallet/index.js';
 import { ContractFunctionInteraction } from './contract_function_interaction.js';
 
 /**

package/src/contract/contract_function_interaction.ts

@@ -1,8 +1,8 @@
 import { AztecAddress, FunctionData } from '@aztec/circuits.js';
-import { FunctionAbi, FunctionType, encodeArguments } from '@aztec/foundation/abi';
+import { FunctionAbiHeader, FunctionType, encodeArguments } from '@aztec/foundation/abi';
 import { FunctionCall, TxExecutionRequest } from '@aztec/types';
 
-import { Wallet } from '../aztec_rpc_client/wallet.js';
+import { Wallet } from '../wallet/index.js';
 import { BaseContractInteraction, SendMethodOptions } from './base_contract_interaction.js';
 
 export { SendMethodOptions };
@@ -26,7 +26,7 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
   constructor(
     protected wallet: Wallet,
     protected contractAddress: AztecAddress,
-    protected functionDao: FunctionAbi,
+    protected functionDao: FunctionAbiHeader,
     protected args: any[],
   ) {
     super(wallet);

package/src/contract_deployer/deploy_method.ts

@@ -89,6 +89,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
       argsHash: packedArguments.hash,
       txContext,
       packedArguments: [packedArguments],
+      authWitnesses: [],
     });
 
     this.txRequest = txRequest;