@aztec/aztec.js 0.1.0-alpha13

package/dest/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC"}

package/dest/utils/index.js

@@ -0,0 +1,4 @@
+export * from './secrets.js';
+export * from './account.js';
+export * from './pub_key.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxjQUFjLENBQUMifQ==

package/dest/utils/pub_key.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" resolution-mode="require"/>
+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 declare function pointToPublicKey(point: Point): {
+    x: bigint;
+    y: bigint;
+};
+/**
+ * Method for generating a public grumpkin key from a private key.
+ * @param privateKey - The private key.
+ * @returns The generated public key.
+ */
+export declare function generatePublicKey(privateKey: Buffer): Promise<Point>;
+//# sourceMappingURL=pub_key.d.ts.map

package/dest/utils/pub_key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pub_key.d.ts","sourceRoot":"","sources":["../../src/utils/pub_key.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK;;;EAO5C;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAG1E"}

package/dest/utils/pub_key.js

@@ -0,0 +1,25 @@
+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) {
+    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.
+ * @returns The generated public key.
+ */
+export async function generatePublicKey(privateKey) {
+    const grumpkin = await Grumpkin.new();
+    return Point.fromBuffer(grumpkin.mul(grumpkin.generator(), privateKey));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHViX2tleS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9wdWJfa2V5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUMzRCxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRXBDOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsS0FBWTtJQUMzQyxNQUFNLENBQUMsR0FBRyxLQUFLLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQzdCLE1BQU0sQ0FBQyxHQUFHLEtBQUssQ0FBQyxDQUFDLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDN0IsT0FBTztRQUNMLENBQUM7UUFDRCxDQUFDO0tBQ0YsQ0FBQztBQUNKLENBQUM7QUFFRDs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxpQkFBaUIsQ0FBQyxVQUFrQjtJQUN4RCxNQUFNLFFBQVEsR0FBRyxNQUFNLFFBQVEsQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUN0QyxPQUFPLEtBQUssQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsU0FBUyxFQUFFLEVBQUUsVUFBVSxDQUFDLENBQUMsQ0FBQztBQUMxRSxDQUFDIn0=

package/dest/utils/secrets.d.ts

@@ -0,0 +1,8 @@
+import { Fr } from '@aztec/circuits.js';
+/**
+ * Given a secret, it computes its pedersen hash - used to send l1 to l2 messages
+ * @param secret - the secret to hash - secret could be generated however you want e.g. `Fr.random()`
+ * @returns the hash
+ */
+export declare function computeMessageSecretHash(secret: Fr): Promise<Fr>;
+//# sourceMappingURL=secrets.d.ts.map

package/dest/utils/secrets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets.d.ts","sourceRoot":"","sources":["../../src/utils/secrets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAGtD;;;;GAIG;AACH,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAGtE"}

package/dest/utils/secrets.js

@@ -0,0 +1,12 @@
+import { CircuitsWasm } from '@aztec/circuits.js';
+import { computeSecretMessageHash } from '@aztec/circuits.js/abis';
+/**
+ * Given a secret, it computes its pedersen hash - used to send l1 to l2 messages
+ * @param secret - the secret to hash - secret could be generated however you want e.g. `Fr.random()`
+ * @returns the hash
+ */
+export async function computeMessageSecretHash(secret) {
+    const wasm = await CircuitsWasm.get();
+    return computeSecretMessageHash(wasm, secret);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjcmV0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9zZWNyZXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQU0sTUFBTSxvQkFBb0IsQ0FBQztBQUN0RCxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUVuRTs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSx3QkFBd0IsQ0FBQyxNQUFVO0lBQ3ZELE1BQU0sSUFBSSxHQUFHLE1BQU0sWUFBWSxDQUFDLEdBQUcsRUFBRSxDQUFDO0lBQ3RDLE9BQU8sd0JBQXdCLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0FBQ2hELENBQUMifQ==

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@aztec/aztec.js",
+  "version": "0.1.0-alpha13",
+  "exports": "./dest/index.js",
+  "type": "module",
+  "dependencies": {
+    "@aztec/aztec-rpc": "0.1.0-alpha13",
+    "@aztec/circuits.js": "0.1.0-alpha13",
+    "@aztec/foundation": "0.1.0-alpha13",
+    "@aztec/key-store": "0.1.0-alpha13",
+    "@aztec/noir-contracts": "0.1.0-alpha13",
+    "tslib": "^2.4.0"
+  }
+}

package/src/account_impl/account_collection.ts

@@ -0,0 +1,41 @@
+import { AztecAddress, TxContext } from '@aztec/circuits.js';
+import { ExecutionRequest, TxExecutionRequest } from '@aztec/types';
+import { AccountImplementation } from './index.js';
+
+/**
+ * A concrete account implementation that manages multiple accounts.
+ */
+export class AccountCollection implements AccountImplementation {
+  private accounts: Map<AztecAddress, AccountImplementation> = new Map();
+
+  /**
+   * Registers an account implementation against an aztec address
+   * @param addr - The aztec address agianst which to register the implementation.
+   * @param impl - The account implementation to be registered.
+   */
+  public registerAccount(addr: AztecAddress, impl: AccountImplementation) {
+    this.accounts.set(addr, impl);
+  }
+
+  getAddress(): AztecAddress {
+    if (!this.accounts) throw new Error(`No accounts registered`);
+    return this.accounts.keys().next().value as AztecAddress;
+  }
+
+  /**
+   * Uses a registered account implementation to generate an authenticated request
+   * @param executions - The execution intent to be authenticated.
+   * @param txContext - The tx context under with the execution is to be made.
+   * @returns - The authenticated transaction execution request.
+   */
+  public createAuthenticatedTxRequest(
+    executions: ExecutionRequest[],
+    txContext: TxContext,
+  ): Promise<TxExecutionRequest> {
+    // TODO: Check all executions have the same origin
+    const sender = executions[0].from;
+    const impl = this.accounts.get(sender);
+    if (!impl) throw new Error(`No account implementation registered for ${sender}`);
+    return impl.createAuthenticatedTxRequest(executions, txContext);
+  }
+}

package/src/account_impl/account_contract.ts

@@ -0,0 +1,173 @@
+import { encodeArguments } from '@aztec/acir-simulator';
+import { AztecAddress, CircuitsWasm, Fr, FunctionData, TxContext } from '@aztec/circuits.js';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { sha256 } from '@aztec/foundation/crypto';
+import { PublicKey } from '@aztec/key-store';
+import { ExecutionRequest, PackedArguments, PartialContractAddress, TxExecutionRequest } from '@aztec/types';
+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';
+
+/**
+ * Account backed by an account contract
+ */
+export class AccountContract implements AccountImplementation {
+  constructor(
+    private address: AztecAddress,
+    private pubKey: PublicKey,
+    private authProvider: TxAuthProvider,
+    private partialContractAddress: PartialContractAddress,
+    private contractAbi: ContractAbi,
+    private wasm: CircuitsWasm,
+  ) {}
+
+  getAddress(): AztecAddress {
+    return this.address;
+  }
+
+  async createAuthenticatedTxRequest(
+    executions: ExecutionRequest[],
+    txContext: TxContext,
+  ): Promise<TxExecutionRequest> {
+    this.checkSender(executions);
+    this.checkIsNotDeployment(txContext);
+
+    const [privateCalls, publicCalls] = partition(executions, exec => exec.functionData.isPrivate).map(execs =>
+      execs.map(exec => ({
+        args: exec.args,
+        selector: exec.functionData.functionSelectorBuffer,
+        target: exec.to,
+      })),
+    );
+
+    const { payload, packedArguments: callsPackedArguments } = await buildPayload(privateCalls, publicCalls, this.wasm);
+    const hash = hashPayload(payload);
+
+    const signature = await this.authProvider.authenticateTx(payload, hash, this.address);
+    const signatureAsFrArray = signature.toFields();
+    const publicKeyAsBuffer = this.pubKey.toBuffer();
+    const args = [payload, publicKeyAsBuffer, signatureAsFrArray, this.partialContractAddress];
+    const abi = this.getEntrypointAbi();
+    const selector = generateFunctionSelector(abi.name, abi.parameters);
+    const packedArgs = await PackedArguments.fromArgs(encodeArguments(abi, args), this.wasm);
+    const txRequest = TxExecutionRequest.from({
+      argsHash: packedArgs.hash,
+      origin: this.address,
+      functionData: new FunctionData(selector, true, false),
+      txContext,
+      packedArguments: [...callsPackedArguments, packedArgs],
+    });
+
+    return txRequest;
+  }
+
+  private getEntrypointAbi() {
+    const abi = this.contractAbi.functions.find(f => f.name === 'entrypoint');
+    if (!abi) throw new Error(`Entrypoint abi for account contract not found`);
+    return abi;
+  }
+
+  private checkIsNotDeployment(txContext: TxContext) {
+    if (txContext.isContractDeploymentTx) {
+      throw new Error(`Cannot yet deploy contracts from an account contract`);
+    }
+  }
+
+  private checkSender(executions: ExecutionRequest[]) {
+    const wrongSender = executions.find(e => !e.from.equals(this.address));
+    if (wrongSender) {
+      throw new Error(
+        `Sender ${wrongSender.from.toString()} does not match account address ${this.address.toString()}`,
+      );
+    }
+  }
+}
+
+const ACCOUNT_MAX_PRIVATE_CALLS = 1;
+const ACCOUNT_MAX_PUBLIC_CALLS = 1;
+
+/** A call to a function in a noir contract */
+export type FunctionCall = {
+  /** The encoded arguments */
+  args: Fr[];
+  /** The function selector */
+  selector: Buffer;
+  /** The address of the contract */
+  target: AztecAddress;
+};
+
+/** Encoded payload for the account contract entrypoint */
+export type EntrypointPayload = {
+  // eslint-disable-next-line camelcase
+  /** Concatenated arguments for every call */
+  flattened_args_hashes: Fr[];
+  // eslint-disable-next-line camelcase
+  /** Concatenated selectors for every call */
+  flattened_selectors: Fr[];
+  // eslint-disable-next-line camelcase
+  /** Concatenated target addresses for every call */
+  flattened_targets: Fr[];
+  /** A nonce for replay protection */
+  nonce: Fr;
+};
+
+/** Assembles an entrypoint payload from a set of private and public function calls */
+async function buildPayload(
+  privateCalls: FunctionCall[],
+  publicCalls: FunctionCall[],
+  wasm: CircuitsWasm,
+): Promise<{
+  /**
+   * The payload for the entrypoint function
+   */
+  payload: EntrypointPayload;
+  /**
+   * The packed arguments of functions called
+   */
+  packedArguments: PackedArguments[];
+}> {
+  const nonce = Fr.random();
+  const emptyCall = { args: [], selector: Buffer.alloc(32), target: AztecAddress.ZERO };
+
+  const calls = [
+    ...padArrayEnd(privateCalls, emptyCall, ACCOUNT_MAX_PRIVATE_CALLS),
+    ...padArrayEnd(publicCalls, emptyCall, ACCOUNT_MAX_PUBLIC_CALLS),
+  ];
+
+  const packedArguments = [];
+
+  for (const call of calls) {
+    packedArguments.push(await PackedArguments.fromArgs(call.args, wasm));
+  }
+
+  return {
+    payload: {
+      // eslint-disable-next-line camelcase
+      flattened_args_hashes: packedArguments.map(args => args.hash),
+      // eslint-disable-next-line camelcase
+      flattened_selectors: calls.map(call => Fr.fromBuffer(call.selector)),
+      // eslint-disable-next-line camelcase
+      flattened_targets: calls.map(call => call.target.toField()),
+      nonce,
+    },
+    packedArguments,
+  };
+}
+
+/** Hashes an entrypoint payload (useful for signing) */
+function hashPayload(payload: EntrypointPayload) {
+  // TODO: Switch to keccak when avaiable in Noir
+  return sha256(Buffer.concat(flattenPayload(payload).map(fr => fr.toBuffer())));
+}
+
+/** Flattens an entrypoint payload */
+function flattenPayload(payload: EntrypointPayload) {
+  return [
+    ...payload.flattened_args_hashes,
+    ...payload.flattened_selectors,
+    ...payload.flattened_targets,
+    payload.nonce,
+  ];
+}

package/src/account_impl/index.ts

@@ -0,0 +1,12 @@
+import { AztecAddress, TxContext } from '@aztec/circuits.js';
+import { ExecutionRequest, TxExecutionRequest } from '@aztec/types';
+
+export * from './account_contract.js';
+export * from './account_collection.js';
+
+/** Represents an implementation for a user account contract. Knows how to encode and sign a tx for that particular implementation. */
+export interface AccountImplementation {
+  getAddress(): AztecAddress;
+  /** Creates a tx to be sent from a given account contract given a set of execution requests. */
+  createAuthenticatedTxRequest(executions: ExecutionRequest[], txContext: TxContext): Promise<TxExecutionRequest>;
+}

package/src/auth/ecdsa.ts

@@ -0,0 +1,18 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { AztecAddress } from '../index.js';
+import { AuthPayload, TxAuthProvider } from './index.js';
+
+import { EntrypointPayload } from '../account_impl/account_contract.js';
+import { EcdsaSignature } from '@aztec/circuits.js/barretenberg';
+
+/**
+ * An ecdsa implementation of TxAuthProvider.
+ */
+export class EcdsaAuthProvider implements TxAuthProvider {
+  constructor(private privKey: Buffer) {}
+  authenticateTx(payload: EntrypointPayload, payloadHash: Buffer, _address: AztecAddress): Promise<AuthPayload> {
+    const sig = secp256k1.sign(payloadHash, this.privKey);
+    if (sig.recovery === undefined) throw new Error(`Missing recovery from signature`);
+    return Promise.resolve(EcdsaSignature.fromBigInts(sig.r, sig.s, sig.recovery));
+  }
+}

package/src/auth/index.ts

@@ -0,0 +1,32 @@
+import { AztecAddress, Fr } from '@aztec/circuits.js';
+import { EntrypointPayload } from '../account_impl/account_contract.js';
+
+export * from './ecdsa.js';
+
+/**
+ * An interface for the payload returned from auth operations.
+ */
+export interface AuthPayload {
+  toBuffer(): Buffer;
+  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 {
+  authenticateTx(_payload: EntrypointPayload, _payloadHash: Buffer, _address: AztecAddress): Promise<AuthPayload> {
+    return Promise.resolve({
+      toBuffer: () => Buffer.alloc(0),
+      toFields: () => [],
+    } as AuthPayload);
+  }
+}

package/src/aztec_rpc_client/aztec_rpc_client.ts

@@ -0,0 +1,59 @@
+import { AztecAddress, AztecRPC, EthAddress, Fr, Point, Tx, TxHash } 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;
+};
+
+export const createAztecRpcClient = (url: string): AztecRPC =>
+  createJsonRpcClient<AztecRPC>(
+    url,
+    {
+      AztecAddress,
+      TxExecutionRequest,
+      ContractData,
+      ContractPublicData,
+      TxHash,
+      EthAddress,
+      Point,
+      Fr,
+    },
+    { 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/index.ts

@@ -0,0 +1,2 @@
+export * from './aztec_rpc_client.js';
+export * from './wallet.js';

package/src/aztec_rpc_client/wallet.ts

@@ -0,0 +1,87 @@
+import { AztecAddress, AztecRPC, DeployedContract, Fr, NodeInfo, Point, Tx, TxHash, TxReceipt } from '@aztec/aztec-rpc';
+import { TxContext } from '@aztec/circuits.js';
+import { ContractAbi } from '@aztec/foundation/abi';
+import { ContractData, ContractPublicData, ExecutionRequest, L2BlockL2Logs, TxExecutionRequest } from '@aztec/types';
+import { AccountImplementation } from '../account_impl/index.js';
+
+/**
+ * The wallet interface.
+ */
+export type Wallet = AccountImplementation & AztecRPC;
+
+/**
+ * A base class for Wallet implementations
+ */
+export abstract class BaseWallet implements Wallet {
+  constructor(protected readonly rpc: AztecRPC) {}
+  abstract getAddress(): AztecAddress;
+  abstract createAuthenticatedTxRequest(
+    executions: ExecutionRequest[],
+    txContext: TxContext,
+  ): Promise<TxExecutionRequest>;
+  addAccount(
+    privKey: Buffer,
+    address: AztecAddress,
+    partialContractAddress: Fr,
+    abi?: ContractAbi | undefined,
+  ): Promise<AztecAddress> {
+    return this.rpc.addAccount(privKey, address, partialContractAddress, abi);
+  }
+  getAccounts(): Promise<AztecAddress[]> {
+    return this.rpc.getAccounts();
+  }
+  getAccountPublicKey(address: AztecAddress): Promise<Point> {
+    return this.rpc.getAccountPublicKey(address);
+  }
+  addContracts(contracts: DeployedContract[]): Promise<void> {
+    return this.rpc.addContracts(contracts);
+  }
+  isContractDeployed(contract: AztecAddress): Promise<boolean> {
+    return this.rpc.isContractDeployed(contract);
+  }
+  simulateTx(txRequest: TxExecutionRequest, optionalFromAddress?: AztecAddress | undefined): Promise<Tx> {
+    return this.rpc.simulateTx(txRequest, optionalFromAddress);
+  }
+  sendTx(tx: Tx): Promise<TxHash> {
+    return this.rpc.sendTx(tx);
+  }
+  getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
+    return this.rpc.getTxReceipt(txHash);
+  }
+  getStorageAt(contract: AztecAddress, storageSlot: Fr): Promise<any> {
+    return this.rpc.getStorageAt(contract, storageSlot);
+  }
+  viewTx(functionName: string, args: any[], to: AztecAddress, from?: AztecAddress | undefined): Promise<any> {
+    return this.rpc.viewTx(functionName, args, to, from);
+  }
+  getContractData(contractAddress: AztecAddress): Promise<ContractPublicData | undefined> {
+    return this.rpc.getContractData(contractAddress);
+  }
+  getContractInfo(contractAddress: AztecAddress): Promise<ContractData | undefined> {
+    return this.rpc.getContractInfo(contractAddress);
+  }
+  getUnencryptedLogs(from: number, take: number): Promise<L2BlockL2Logs[]> {
+    return this.rpc.getUnencryptedLogs(from, take);
+  }
+  getBlockNum(): Promise<number> {
+    return this.rpc.getBlockNum();
+  }
+  getNodeInfo(): Promise<NodeInfo> {
+    return this.rpc.getNodeInfo();
+  }
+}
+
+/**
+ * A simple wallet implementation that forwards authentication requests to a provided account implementation.
+ */
+export class AccountWallet extends BaseWallet {
+  constructor(rpc: AztecRPC, protected accountImpl: AccountImplementation) {
+    super(rpc);
+  }
+  getAddress(): AztecAddress {
+    return this.accountImpl.getAddress();
+  }
+  createAuthenticatedTxRequest(executions: ExecutionRequest[], txContext: TxContext): Promise<TxExecutionRequest> {
+    return this.accountImpl.createAuthenticatedTxRequest(executions, txContext);
+  }
+}