@aztec/accounts 0.22.0 → 0.24.0

package/src/defaults/account_contract.ts

@@ -0,0 +1,25 @@
+import { AccountContract, AccountInterface, AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { CompleteAddress } from '@aztec/circuit-types';
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { NodeInfo } from '@aztec/types/interfaces';
+
+import { DefaultAccountInterface } from '../defaults/account_interface.js';
+
+/**
+ * Base class for implementing an account contract. Requires that the account uses the
+ * default entrypoint method signature.
+ */
+export abstract class DefaultAccountContract implements AccountContract {
+  abstract getAuthWitnessProvider(address: CompleteAddress): AuthWitnessProvider;
+  abstract getDeploymentArgs(): any[];
+
+  constructor(private artifact: ContractArtifact) {}
+
+  getContractArtifact(): ContractArtifact {
+    return this.artifact;
+  }
+
+  getInterface(address: CompleteAddress, nodeInfo: NodeInfo): AccountInterface {
+    return new DefaultAccountInterface(this.getAuthWitnessProvider(address), address, nodeInfo);
+  }
+}

package/src/defaults/account_entrypoint.ts

@@ -0,0 +1,141 @@
+import { AuthWitnessProvider, EntrypointInterface, FeeOptions } from '@aztec/aztec.js/account';
+import { FunctionCall, PackedArguments, TxExecutionRequest } from '@aztec/circuit-types';
+import { AztecAddress, Fr, FunctionData, GeneratorIndex, TxContext } from '@aztec/circuits.js';
+import { FunctionAbi, encodeArguments } from '@aztec/foundation/abi';
+
+import { DEFAULT_CHAIN_ID, DEFAULT_VERSION } from './constants.js';
+import { buildAppPayload, buildFeePayload, hashPayload } from './entrypoint_payload.js';
+
+/**
+ * Implementation for an entrypoint interface that follows the default entrypoint signature
+ * for an account, which accepts an AppPayload and a FeePayload as defined in noir-libs/aztec-noir/src/entrypoint module
+ */
+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[], feeOpts?: FeeOptions): Promise<TxExecutionRequest> {
+    const { payload: appPayload, packedArguments: appPackedArguments } = buildAppPayload(executions);
+    const { payload: feePayload, packedArguments: feePackedArguments } = buildFeePayload(feeOpts);
+
+    const abi = this.getEntrypointAbi();
+    const entrypointPackedArgs = PackedArguments.fromArgs(encodeArguments(abi, [appPayload, feePayload]));
+
+    const appAuthWitness = await this.auth.createAuthWitness(
+      Fr.fromBuffer(hashPayload(appPayload, GeneratorIndex.SIGNATURE_PAYLOAD)),
+    );
+    const feeAuthWitness = await this.auth.createAuthWitness(
+      Fr.fromBuffer(hashPayload(feePayload, GeneratorIndex.FEE_PAYLOAD)),
+    );
+
+    const txRequest = TxExecutionRequest.from({
+      argsHash: entrypointPackedArgs.hash,
+      origin: this.address,
+      functionData: FunctionData.fromAbi(abi),
+      txContext: TxContext.empty(this.chainId, this.version),
+      packedArguments: [...appPackedArguments, ...feePackedArguments, entrypointPackedArgs],
+      authWitnesses: [appAuthWitness, feeAuthWitness],
+    });
+
+    return txRequest;
+  }
+
+  private getEntrypointAbi() {
+    return {
+      name: 'entrypoint',
+      functionType: 'secret',
+      isInternal: false,
+      parameters: [
+        {
+          name: 'app_payload',
+          type: {
+            kind: 'struct',
+            path: 'authwit::entrypoint::app::AppPayload',
+            fields: [
+              {
+                name: 'function_calls',
+                type: {
+                  kind: 'array',
+                  length: 4,
+                  type: {
+                    kind: 'struct',
+                    path: 'authwit::entrypoint::function_call::FunctionCall',
+                    fields: [
+                      { name: 'args_hash', type: { kind: 'field' } },
+                      {
+                        name: 'function_selector',
+                        type: {
+                          kind: 'struct',
+                          path: 'authwit::aztec::protocol_types::abis::function_selector::FunctionSelector',
+                          fields: [{ name: 'inner', type: { kind: 'integer', sign: 'unsigned', width: 32 } }],
+                        },
+                      },
+                      {
+                        name: 'target_address',
+                        type: {
+                          kind: 'struct',
+                          path: 'authwit::aztec::protocol_types::address::AztecAddress',
+                          fields: [{ name: 'inner', type: { kind: 'field' } }],
+                        },
+                      },
+                      { name: 'is_public', type: { kind: 'boolean' } },
+                    ],
+                  },
+                },
+              },
+              { name: 'nonce', type: { kind: 'field' } },
+            ],
+          },
+          visibility: 'public',
+        },
+        {
+          name: 'fee_payload',
+          type: {
+            kind: 'struct',
+            path: 'authwit::entrypoint::fee::FeePayload',
+            fields: [
+              {
+                name: 'function_calls',
+                type: {
+                  kind: 'array',
+                  length: 2,
+                  type: {
+                    kind: 'struct',
+                    path: 'authwit::entrypoint::function_call::FunctionCall',
+                    fields: [
+                      { name: 'args_hash', type: { kind: 'field' } },
+                      {
+                        name: 'function_selector',
+                        type: {
+                          kind: 'struct',
+                          path: 'authwit::aztec::protocol_types::abis::function_selector::FunctionSelector',
+                          fields: [{ name: 'inner', type: { kind: 'integer', sign: 'unsigned', width: 32 } }],
+                        },
+                      },
+                      {
+                        name: 'target_address',
+                        type: {
+                          kind: 'struct',
+                          path: 'authwit::aztec::protocol_types::address::AztecAddress',
+                          fields: [{ name: 'inner', type: { kind: 'field' } }],
+                        },
+                      },
+                      { name: 'is_public', type: { kind: 'boolean' } },
+                    ],
+                  },
+                },
+              },
+              { name: 'nonce', type: { kind: 'field' } },
+            ],
+          },
+          visibility: 'public',
+        },
+      ],
+      returnTypes: [],
+    } as FunctionAbi;
+  }
+}

package/src/defaults/account_interface.ts

@@ -0,0 +1,39 @@
+import { AccountInterface, AuthWitnessProvider, EntrypointInterface, FeeOptions } from '@aztec/aztec.js/account';
+import { AuthWitness, FunctionCall, TxExecutionRequest } from '@aztec/circuit-types';
+import { CompleteAddress, Fr } from '@aztec/circuits.js';
+import { NodeInfo } from '@aztec/types/interfaces';
+
+import { DefaultAccountEntrypoint } from './account_entrypoint.js';
+
+/**
+ * Default implementation for an account interface. Requires that the account uses the default
+ * entrypoint signature, which accept an AppPayload and a FeePayload as defined in noir-libs/aztec-noir/src/entrypoint module
+ */
+export class DefaultAccountInterface implements AccountInterface {
+  private entrypoint: EntrypointInterface;
+
+  constructor(
+    private authWitnessProvider: AuthWitnessProvider,
+    private address: CompleteAddress,
+    nodeInfo: Pick<NodeInfo, 'chainId' | 'protocolVersion'>,
+  ) {
+    this.entrypoint = new DefaultAccountEntrypoint(
+      address.address,
+      authWitnessProvider,
+      nodeInfo.chainId,
+      nodeInfo.protocolVersion,
+    );
+  }
+
+  createTxExecutionRequest(executions: FunctionCall[], fee?: FeeOptions): Promise<TxExecutionRequest> {
+    return this.entrypoint.createTxExecutionRequest(executions, fee);
+  }
+
+  createAuthWitness(message: Fr): Promise<AuthWitness> {
+    return this.authWitnessProvider.createAuthWitness(message);
+  }
+
+  getCompleteAddress(): CompleteAddress {
+    return this.address;
+  }
+}

package/src/defaults/constants.ts

@@ -0,0 +1,4 @@
+/** Default L1 chain ID to use when constructing txs (matches hardhat and anvil's default). */
+export const DEFAULT_CHAIN_ID = 31337;
+/** Default protocol version to use. */
+export const DEFAULT_VERSION = 1;

package/src/defaults/entrypoint_payload.ts

@@ -0,0 +1,112 @@
+import { FeeOptions } from '@aztec/aztec.js/account';
+import { Fr } from '@aztec/aztec.js/fields';
+import { FunctionCall, PackedArguments, emptyFunctionCall } from '@aztec/circuit-types';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { pedersenHash } from '@aztec/foundation/crypto';
+
+// These must match the values defined in:
+// - noir-projects/aztec-nr/aztec/src/entrypoint/app.nr
+const ACCOUNT_MAX_CALLS = 4;
+// - and noir-projects/aztec-nr/aztec/src/entrypoint/fee.nr
+const FEE_MAX_CALLS = 2;
+
+/** Encoded function call for account contract entrypoint */
+type EntrypointFunctionCall = {
+  // eslint-disable-next-line camelcase
+  /** Arguments hash for the call */
+  args_hash: Fr;
+  // eslint-disable-next-line camelcase
+  /** Selector of the function to call */
+  function_selector: Fr;
+  // eslint-disable-next-line camelcase
+  /** Address of the contract to call */
+  target_address: Fr;
+  // eslint-disable-next-line camelcase
+  /** Whether the function is public or private */
+  is_public: boolean;
+};
+
+/** Encoded payload for the account contract entrypoint */
+type EntrypointPayload = {
+  // eslint-disable-next-line camelcase
+  /** Encoded function calls to execute */
+  function_calls: EntrypointFunctionCall[];
+  /** A nonce for replay protection */
+  nonce: Fr;
+};
+
+/** Represents a generic payload to be executed in the context of an account contract */
+export type PayloadWithArguments = {
+  /** The payload to be run */
+  payload: EntrypointPayload;
+  /** The packed arguments for the function calls */
+  packedArguments: PackedArguments[];
+};
+
+/**
+ * Builds a payload to be sent to the account contract
+ * @param calls - The function calls to run
+ * @param maxCalls - The maximum number of call expected to be run. Used for padding
+ * @returns A payload object and packed arguments
+ */
+function buildPayload(calls: FunctionCall[], maxCalls: number): PayloadWithArguments {
+  const nonce = Fr.random();
+
+  const paddedCalls = padArrayEnd(calls, emptyFunctionCall(), maxCalls);
+  const packedArguments: PackedArguments[] = [];
+  for (const call of paddedCalls) {
+    packedArguments.push(PackedArguments.fromArgs(call.args));
+  }
+
+  const formattedCalls: EntrypointFunctionCall[] = paddedCalls.map((call, index) => ({
+    // eslint-disable-next-line camelcase
+    args_hash: packedArguments[index].hash,
+    // eslint-disable-next-line camelcase
+    function_selector: call.functionData.selector.toField(),
+    // eslint-disable-next-line camelcase
+    target_address: call.to.toField(),
+    // eslint-disable-next-line camelcase
+    is_public: !call.functionData.isPrivate,
+  }));
+
+  return {
+    payload: {
+      // eslint-disable-next-line camelcase
+      function_calls: formattedCalls,
+      nonce,
+    },
+    packedArguments,
+  };
+}
+
+/** Assembles an entrypoint app payload from a set of private and public function calls */
+export function buildAppPayload(calls: FunctionCall[]): PayloadWithArguments {
+  return buildPayload(calls, ACCOUNT_MAX_CALLS);
+}
+
+/** Creates the payload for paying the fee for a transaction */
+export function buildFeePayload(feeOpts?: FeeOptions): PayloadWithArguments {
+  const calls = feeOpts?.paymentMethod.getFunctionCalls(new Fr(feeOpts.maxFee)) ?? [];
+  return buildPayload(calls, FEE_MAX_CALLS);
+}
+
+/** Hashes a payload to a 32-byte buffer */
+export function hashPayload(payload: EntrypointPayload, generatorIndex: number) {
+  return pedersenHash(
+    flattenPayload(payload).map(fr => fr.toBuffer()),
+    generatorIndex,
+  );
+}
+
+/** Flattens an payload */
+function flattenPayload(payload: EntrypointPayload) {
+  return [
+    ...payload.function_calls.flatMap(call => [
+      call.args_hash,
+      call.function_selector,
+      call.target_address,
+      new Fr(call.is_public),
+    ]),
+    payload.nonce,
+  ];
+}

package/src/defaults/index.ts

@@ -0,0 +1,13 @@
+/**
+ * The `@aztec/accounts/defaults` export provides the base class {@link DefaultAccountContract} for implementing account contracts that use the default entrypoint payload module.
+ *
+ * Read more in {@link https://docs.aztec.network/developers/wallets/writing_an_account_contract | Writing an account contract}.
+ *
+ * @packageDocumentation
+ */
+
+export * from './entrypoint_payload.js';
+export * from './account_entrypoint.js';
+export * from './account_interface.js';
+export * from './account_contract.js';
+export * from './constants.js';

package/src/ecdsa/account_contract.ts

@@ -0,0 +1,38 @@
+import { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { AuthWitness, CompleteAddress } from '@aztec/circuit-types';
+import { Ecdsa } from '@aztec/circuits.js/barretenberg';
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { Fr } from '@aztec/foundation/fields';
+
+import { DefaultAccountContract } from '../defaults/account_contract.js';
+import { EcdsaAccountContractArtifact } from './artifact.js';
+
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256k1 public key stored in an immutable encrypted note.
+ */
+export class EcdsaAccountContract extends DefaultAccountContract {
+  constructor(private signingPrivateKey: Buffer) {
+    super(EcdsaAccountContractArtifact as ContractArtifact);
+  }
+
+  getDeploymentArgs() {
+    const signingPublicKey = new Ecdsa().computePublicKey(this.signingPrivateKey);
+    return [signingPublicKey.subarray(0, 32), signingPublicKey.subarray(32, 64)];
+  }
+
+  getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {
+    return new EcdsaAuthWitnessProvider(this.signingPrivateKey);
+  }
+}
+
+/** Creates auth witnesses using ECDSA signatures. */
+class EcdsaAuthWitnessProvider implements AuthWitnessProvider {
+  constructor(private signingPrivateKey: Buffer) {}
+
+  createAuthWitness(message: Fr): Promise<AuthWitness> {
+    const ecdsa = new Ecdsa();
+    const signature = ecdsa.constructSignature(message.toBuffer(), this.signingPrivateKey);
+    return Promise.resolve(new AuthWitness(message, [...signature.r, ...signature.s]));
+  }
+}

package/src/ecdsa/artifact.ts

@@ -0,0 +1,5 @@
+import { NoirCompiledContract, loadContractArtifact } from '@aztec/aztec.js';
+
+import EcdsaAccountContractJson from '../artifacts/EcdsaAccount.json' assert { type: 'json' };
+
+export const EcdsaAccountContractArtifact = loadContractArtifact(EcdsaAccountContractJson as NoirCompiledContract);

package/src/ecdsa/index.ts

@@ -0,0 +1,42 @@
+/**
+ * The `@aztec/accounts/ecdsa` export provides an ECDSA account contract implementation, that uses an ECDSA private key for authentication, and a Grumpkin key for encryption.
+ * Consider using this account type when working with integrations with Ethereum wallets.
+ *
+ * @packageDocumentation
+ */
+import { AccountManager, Salt } from '@aztec/aztec.js/account';
+import { AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
+import { GrumpkinPrivateKey, PXE } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/circuits.js';
+
+import { EcdsaAccountContract } from './account_contract.js';
+
+export { EcdsaAccountContractArtifact } from './artifact.js';
+export { EcdsaAccountContract };
+
+/**
+ * Creates an Account that relies on an ECDSA signing key for authentication.
+ * @param pxe - An PXE server instance.
+ * @param encryptionPrivateKey - Grumpkin key used for note encryption.
+ * @param signingPrivateKey - Secp256k1 key used for signing transactions.
+ * @param salt - Deployment salt.
+ */
+export function getEcdsaAccount(
+  pxe: PXE,
+  encryptionPrivateKey: GrumpkinPrivateKey,
+  signingPrivateKey: Buffer,
+  salt?: Salt,
+): AccountManager {
+  return new AccountManager(pxe, encryptionPrivateKey, new EcdsaAccountContract(signingPrivateKey), salt);
+}
+
+/**
+ * Gets a wallet for an already registered account using ECDSA signatures.
+ * @param pxe - An PXE server instance.
+ * @param address - Address for the account.
+ * @param signingPrivateKey - ECDSA key used for signing transactions.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export function getEcdsaWallet(pxe: PXE, address: AztecAddress, signingPrivateKey: Buffer): Promise<AccountWallet> {
+  return getWallet(pxe, address, new EcdsaAccountContract(signingPrivateKey));
+}

package/src/schnorr/account_contract.ts

@@ -0,0 +1,38 @@
+import { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { AuthWitness, CompleteAddress, GrumpkinPrivateKey } from '@aztec/circuit-types';
+import { Schnorr } from '@aztec/circuits.js/barretenberg';
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { Fr } from '@aztec/foundation/fields';
+
+import { DefaultAccountContract } from '../defaults/account_contract.js';
+import { SchnorrAccountContractArtifact } from './artifact.js';
+
+/**
+ * Account contract that authenticates transactions using Schnorr signatures
+ * verified against a Grumpkin public key stored in an immutable encrypted note.
+ */
+export class SchnorrAccountContract extends DefaultAccountContract {
+  constructor(private signingPrivateKey: GrumpkinPrivateKey) {
+    super(SchnorrAccountContractArtifact as ContractArtifact);
+  }
+
+  getDeploymentArgs() {
+    const signingPublicKey = new Schnorr().computePublicKey(this.signingPrivateKey);
+    return [signingPublicKey.x, signingPublicKey.y];
+  }
+
+  getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {
+    return new SchnorrAuthWitnessProvider(this.signingPrivateKey);
+  }
+}
+
+/** Creates auth witnesses using Schnorr signatures. */
+class SchnorrAuthWitnessProvider implements AuthWitnessProvider {
+  constructor(private signingPrivateKey: GrumpkinPrivateKey) {}
+
+  createAuthWitness(message: Fr): Promise<AuthWitness> {
+    const schnorr = new Schnorr();
+    const signature = schnorr.constructSignature(message.toBuffer(), this.signingPrivateKey).toBuffer();
+    return Promise.resolve(new AuthWitness(message, [...signature]));
+  }
+}

package/src/schnorr/artifact.ts

@@ -0,0 +1,5 @@
+import { NoirCompiledContract, loadContractArtifact } from '@aztec/aztec.js';
+
+import SchnorrAccountContractJson from '../artifacts/SchnorrAccount.json' assert { type: 'json' };
+
+export const SchnorrAccountContractArtifact = loadContractArtifact(SchnorrAccountContractJson as NoirCompiledContract);

package/src/schnorr/index.ts

@@ -0,0 +1,47 @@
+/**
+ * The `@aztec/accounts/schnorr` export provides an account contract implementation that uses Schnorr signatures with a Grumpkin key for authentication, and a separate Grumpkin key for encryption.
+ * This is the suggested account contract type for most use cases within Aztec.
+ *
+ * @packageDocumentation
+ */
+import { AccountManager, Salt } from '@aztec/aztec.js/account';
+import { AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
+import { GrumpkinPrivateKey, PXE } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/circuits.js';
+
+import { SchnorrAccountContract } from './account_contract.js';
+
+export { SchnorrAccountContract };
+
+export { SchnorrAccountContractArtifact } from './artifact.js';
+
+/**
+ * Creates an Account Manager that relies on a Grumpkin signing key for authentication.
+ * @param pxe - An PXE server instance.
+ * @param encryptionPrivateKey - Grumpkin key used for note encryption.
+ * @param signingPrivateKey - Grumpkin key used for signing transactions.
+ * @param salt - Deployment salt.
+ */
+export function getSchnorrAccount(
+  pxe: PXE,
+  encryptionPrivateKey: GrumpkinPrivateKey,
+  signingPrivateKey: GrumpkinPrivateKey,
+  salt?: Salt,
+): AccountManager {
+  return new AccountManager(pxe, encryptionPrivateKey, new SchnorrAccountContract(signingPrivateKey), salt);
+}
+
+/**
+ * Gets a wallet for an already registered account using Schnorr signatures.
+ * @param pxe - An PXE server instance.
+ * @param address - Address for the account.
+ * @param signingPrivateKey - Grumpkin key used for signing transactions.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export function getSchnorrWallet(
+  pxe: PXE,
+  address: AztecAddress,
+  signingPrivateKey: GrumpkinPrivateKey,
+): Promise<AccountWallet> {
+  return getWallet(pxe, address, new SchnorrAccountContract(signingPrivateKey));
+}

package/src/single_key/account_contract.ts

@@ -0,0 +1,45 @@
+import { generatePublicKey } from '@aztec/aztec.js';
+import { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { AuthWitness, CompleteAddress, GrumpkinPrivateKey } from '@aztec/circuit-types';
+import { PartialAddress } from '@aztec/circuits.js';
+import { Schnorr } from '@aztec/circuits.js/barretenberg';
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { Fr } from '@aztec/foundation/fields';
+
+import { DefaultAccountContract } from '../defaults/account_contract.js';
+import { SchnorrSingleKeyAccountContractArtifact } from './artifact.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 extends DefaultAccountContract {
+  constructor(private encryptionPrivateKey: GrumpkinPrivateKey) {
+    super(SchnorrSingleKeyAccountContractArtifact as ContractArtifact);
+  }
+
+  getDeploymentArgs(): any[] {
+    return [];
+  }
+
+  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) {}
+
+  createAuthWitness(message: Fr): Promise<AuthWitness> {
+    const schnorr = new Schnorr();
+    const signature = schnorr.constructSignature(message.toBuffer(), this.privateKey);
+    const publicKey = generatePublicKey(this.privateKey);
+    const witness = [...publicKey.toFields(), ...signature.toBuffer(), this.partialAddress];
+    return Promise.resolve(new AuthWitness(message, witness));
+  }
+}

package/src/single_key/artifact.ts

@@ -0,0 +1,7 @@
+import { NoirCompiledContract, loadContractArtifact } from '@aztec/aztec.js';
+
+import SchnorrSingleKeyAccountContractJson from '../artifacts/SchnorrSingleKeyAccount.json' assert { type: 'json' };
+
+export const SchnorrSingleKeyAccountContractArtifact = loadContractArtifact(
+  SchnorrSingleKeyAccountContractJson as NoirCompiledContract,
+);

package/src/single_key/index.ts

@@ -0,0 +1,52 @@
+/**
+ * The `@aztec/accounts/single_key` export provides a testing account contract implementation that uses a single Grumpkin key for both authentication and encryption.
+ * It is not recommended to use this account type in production.
+ *
+ * @packageDocumentation
+ */
+import { AccountManager, Salt } from '@aztec/aztec.js/account';
+import { AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
+import { GrumpkinPrivateKey, PXE } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/circuits.js';
+
+import { SingleKeyAccountContract } from './account_contract.js';
+
+export { SingleKeyAccountContract };
+
+export { SchnorrSingleKeyAccountContractArtifact as SingleKeyAccountContractArtifact } from './artifact.js';
+
+/**
+ * Creates an Account that uses the same Grumpkin key for encryption and authentication.
+ * @param pxe - An PXE server instance.
+ * @param encryptionAndSigningPrivateKey - Grumpkin key used for note encryption and signing transactions.
+ * @param salt - Deployment salt .
+ */
+export function getSingleKeyAccount(
+  pxe: PXE,
+  encryptionAndSigningPrivateKey: GrumpkinPrivateKey,
+  salt?: Salt,
+): AccountManager {
+  return new AccountManager(
+    pxe,
+    encryptionAndSigningPrivateKey,
+    new SingleKeyAccountContract(encryptionAndSigningPrivateKey),
+    salt,
+  );
+}
+
+/**
+ * Gets a wallet for an already registered account using Schnorr signatures with a single key for encryption and authentication.
+ * @param pxe - An PXE server instance.
+ * @param address - Address for the account.
+ * @param signingPrivateKey - Grumpkin key used for note encryption and signing transactions.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export function getSingleKeyWallet(
+  pxe: PXE,
+  address: AztecAddress,
+  signingKey: GrumpkinPrivateKey,
+): Promise<AccountWallet> {
+  return getWallet(pxe, address, new SingleKeyAccountContract(signingKey));
+}
+
+export { getSingleKeyAccount as getUnsafeSchnorrAccount, getSingleKeyWallet as getUnsafeSchnorrWallet };