@aztec/accounts 0.76.4 → 0.77.0-testnet-ignition.21

package/src/ecdsa/ecdsa_k/index.ts

@@ -6,14 +6,34 @@
  */
 import { AccountManager, type Salt } from '@aztec/aztec.js/account';
 import { type AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
-import { type PXE } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr } from '@aztec/circuits.js';
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
-import { EcdsaKAccountContract } from './account_contract.js';
+import EcdsaKAccountContractJson from '../../../artifacts/EcdsaKAccount.json' assert { type: 'json' };
+import { EcdsaKBaseAccountContract } from './account_contract.js';
 
-export { EcdsaKAccountContractArtifact } from './artifact.js';
-export { EcdsaKAccountContract };
+export const EcdsaKAccountContractArtifact: ContractArtifact = loadContractArtifact(
+  EcdsaKAccountContractJson as NoirCompiledContract,
+);
 
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256k1 public key stored in an immutable encrypted note.
+ * Eagerly loads the contract artifact
+ */
+export class EcdsaKAccountContract extends EcdsaKBaseAccountContract {
+  constructor(signingPrivateKey: Buffer) {
+    super(signingPrivateKey);
+  }
+
+  override getContractArtifact(): Promise<ContractArtifact> {
+    return Promise.resolve(EcdsaKAccountContractArtifact);
+  }
+}
 /**
  * Creates an Account that relies on an ECDSA signing key for authentication.
  * @param pxe - An PXE server instance.

package/src/ecdsa/ecdsa_k/lazy.ts

@@ -0,0 +1,71 @@
+/**
+ * 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, type Salt } from '@aztec/aztec.js/account';
+import { type AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+
+import { EcdsaKBaseAccountContract } from './account_contract.js';
+
+/**
+ * Lazily loads the contract artifact
+ * @returns The contract artifact for the ecdsa K account contract
+ */
+export async function getEcdsaKAccountContractArtifact() {
+  // Cannot assert this import as it's incompatible with browsers
+  // https://caniuse.com/mdn-javascript_statements_import_import_assertions_type_json
+  // Use the new "with" syntax once supported by firefox
+  // https://caniuse.com/mdn-javascript_statements_import_import_attributes_type_json
+  // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
+  const { default: ecdsaKAccountContractJson } = await import('../../../artifacts/EcdsaKAccount.json');
+  return loadContractArtifact(ecdsaKAccountContractJson);
+}
+
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256k1 public key stored in an immutable encrypted note.
+ * Lazily loads the contract artifact
+ */
+export class EcdsaKAccountContract extends EcdsaKBaseAccountContract {
+  constructor(signingPrivateKey: Buffer) {
+    super(signingPrivateKey);
+  }
+
+  override getContractArtifact(): Promise<ContractArtifact> {
+    return getEcdsaKAccountContractArtifact();
+  }
+}
+/**
+ * Creates an Account that relies on an ECDSA signing key for authentication.
+ * @param pxe - An PXE server instance.
+ * @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,
+): Promise<AccountManager> {
+  return AccountManager.create(pxe, secretKey, new EcdsaKAccountContract(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 getEcdsaKWallet(pxe: PXE, address: AztecAddress, signingPrivateKey: Buffer): Promise<AccountWallet> {
+  return getWallet(pxe, address, new EcdsaKAccountContract(signingPrivateKey));
+}

package/src/ecdsa/lazy.ts

@@ -0,0 +1,2 @@
+export * from './ecdsa_k/lazy.js';
+export * from './ssh_ecdsa_r/lazy.js';

package/src/ecdsa/ssh_ecdsa_r/account_contract.ts

@@ -1,12 +1,11 @@
-import { type AuthWitnessProvider } from '@aztec/aztec.js/account';
-import { AuthWitness, type CompleteAddress } from '@aztec/circuit-types';
-import { EcdsaSignature } from '@aztec/circuits.js/barretenberg';
-import { type ContractArtifact } from '@aztec/foundation/abi';
-import { type Fr } from '@aztec/foundation/fields';
+import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { EcdsaSignature } from '@aztec/foundation/crypto';
+import type { Fr } from '@aztec/foundation/fields';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { CompleteAddress } from '@aztec/stdlib/contract';
 
 import { DefaultAccountContract } from '../../defaults/account_contract.js';
 import { signWithAgent } from '../../utils/ssh_agent.js';
-import { EcdsaRAccountContractArtifact } from './artifact.js';
 
 const secp256r1N = 115792089210356248762697446949407573529996955224135760342422259061068512044369n;
 /**
@@ -15,10 +14,12 @@ const secp256r1N = 1157920892103562487626974469494075735299969552241357603424222
  * Since this implementation relays signatures to an SSH agent, we provide the
  * public key here not for signature verification, but to identify actual identity
  * that will be used to sign authwitnesses.
+ * This abstract version does not provide a way to retrieve the artifact, as it
+ * can be implemented with or without lazy loading.
  */
-export class EcdsaRSSHAccountContract extends DefaultAccountContract {
+export abstract class EcdsaRSSHBaseAccountContract extends DefaultAccountContract {
   constructor(private signingPublicKey: Buffer) {
-    super(EcdsaRAccountContractArtifact as ContractArtifact);
+    super();
   }
 
   getDeploymentArgs() {

package/src/ecdsa/ssh_ecdsa_r/index.ts

@@ -6,13 +6,37 @@
  */
 import { AccountManager, type Salt } from '@aztec/aztec.js/account';
 import { type AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
-import { type PXE } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr } from '@aztec/circuits.js';
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
-import { EcdsaRSSHAccountContract } from './account_contract.js';
+import EcdsaRAccountContractJson from '../../../artifacts/EcdsaKAccount.json' assert { type: 'json' };
+import { EcdsaRSSHBaseAccountContract } from './account_contract.js';
 
-export { EcdsaRAccountContractArtifact } from './artifact.js';
-export { EcdsaRSSHAccountContract };
+export const EcdsaRAccountContractArtifact: ContractArtifact = loadContractArtifact(
+  EcdsaRAccountContractJson as NoirCompiledContract,
+);
+
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256r1 public key stored in an immutable encrypted note.
+ * Since this implementation relays signatures to an SSH agent, we provide the
+ * public key here not for signature verification, but to identify actual identity
+ * that will be used to sign authwitnesses.
+ * Eagerly loads the contract artifact
+ */
+export class EcdsaRSSHAccountContract extends EcdsaRSSHBaseAccountContract {
+  constructor(signingPrivateKey: Buffer) {
+    super(signingPrivateKey);
+  }
+
+  override getContractArtifact(): Promise<ContractArtifact> {
+    return Promise.resolve(EcdsaRAccountContractArtifact);
+  }
+}
 
 /**
  * Creates an Account that relies on an ECDSA signing key for authentication.

package/src/ecdsa/ssh_ecdsa_r/lazy.ts

@@ -0,0 +1,78 @@
+/**
+ * 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, type Salt } from '@aztec/aztec.js/account';
+import { type AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+
+import { EcdsaRSSHBaseAccountContract } from './account_contract.js';
+
+/*
+ * Lazily loads the contract artifact
+ * @returns The contract artifact for the ecdsa R account contract
+ */
+/**
+ *
+ */
+export async function getEcdsaRAccountContractArtifact() {
+  // Cannot assert this import as it's incompatible with browsers
+  // https://caniuse.com/mdn-javascript_statements_import_import_assertions_type_json
+  // Use the new "with" syntax once supported by firefox
+  // https://caniuse.com/mdn-javascript_statements_import_import_attributes_type_json
+  // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
+  const { default: ecdsaKAccountContractJson } = await import('../../../artifacts/EcdsaRAccount.json');
+  return loadContractArtifact(ecdsaKAccountContractJson);
+}
+
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256r1 public key stored in an immutable encrypted note.
+ * Since this implementation relays signatures to an SSH agent, we provide the
+ * public key here not for signature verification, but to identify actual identity
+ * that will be used to sign authwitnesses.
+ * Lazily loads the contract artifact
+ */
+export class EcdsaRSSHAccountContract extends EcdsaRSSHBaseAccountContract {
+  constructor(signingPrivateKey: Buffer) {
+    super(signingPrivateKey);
+  }
+
+  override getContractArtifact(): Promise<ContractArtifact> {
+    return getEcdsaRAccountContractArtifact();
+  }
+}
+
+/**
+ * Creates an Account that relies on an ECDSA signing key for authentication.
+ * @param pxe - An PXE server instance.
+ * @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,
+): Promise<AccountManager> {
+  return AccountManager.create(pxe, secretKey, new EcdsaRSSHAccountContract(signingPublicKey), 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 getEcdsaRSSHWallet(pxe: PXE, address: AztecAddress, signingPublicKey: Buffer): Promise<AccountWallet> {
+  return getWallet(pxe, address, new EcdsaRSSHAccountContract(signingPublicKey));
+}

package/src/schnorr/account_contract.ts

@@ -1,19 +1,20 @@
-import { type AuthWitnessProvider } from '@aztec/aztec.js/account';
-import { AuthWitness, type CompleteAddress, type GrumpkinScalar } from '@aztec/circuit-types';
-import { Schnorr } from '@aztec/circuits.js/barretenberg';
-import { type ContractArtifact } from '@aztec/foundation/abi';
-import { type Fr } from '@aztec/foundation/fields';
+import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { Schnorr } from '@aztec/foundation/crypto';
+import { Fr, GrumpkinScalar } from '@aztec/foundation/fields';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { CompleteAddress } from '@aztec/stdlib/contract';
 
 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.
+ * This abstract version does not provide a way to retrieve the artifact, as it
+ * can be implemented with or without lazy loading.
  */
-export class SchnorrAccountContract extends DefaultAccountContract {
+export abstract class SchnorrBaseAccountContract extends DefaultAccountContract {
   constructor(private signingPrivateKey: GrumpkinScalar) {
-    super(SchnorrAccountContractArtifact as ContractArtifact);
+    super();
   }
 
   async getDeploymentArgs() {
@@ -27,7 +28,7 @@ export class SchnorrAccountContract extends DefaultAccountContract {
 }
 
 /** Creates auth witnesses using Schnorr signatures. */
-class SchnorrAuthWitnessProvider implements AuthWitnessProvider {
+export class SchnorrAuthWitnessProvider implements AuthWitnessProvider {
   constructor(private signingPrivateKey: GrumpkinScalar) {}
 
   async createAuthWit(messageHash: Fr): Promise<AuthWitness> {

package/src/schnorr/index.ts

@@ -4,16 +4,35 @@
  *
  * @packageDocumentation
  */
-import { AccountManager, type Salt } from '@aztec/aztec.js/account';
-import { type AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
-import { type GrumpkinScalar, type PXE } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr } from '@aztec/circuits.js';
+import { AccountManager, type Salt, getAccountContractAddress } from '@aztec/aztec.js/account';
+import { type AccountWallet, type AccountWalletWithSecretKey, getWallet } from '@aztec/aztec.js/wallet';
+import { Fr, GrumpkinScalar } from '@aztec/foundation/fields';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
-import { SchnorrAccountContract } from './account_contract.js';
+import SchnorrAccountContractJson from '../../artifacts/SchnorrAccount.json' assert { type: 'json' };
+import { SchnorrBaseAccountContract } from './account_contract.js';
 
-export { SchnorrAccountContract };
+export const SchnorrAccountContractArtifact = loadContractArtifact(SchnorrAccountContractJson as NoirCompiledContract);
 
-export { SchnorrAccountContractArtifact } from './artifact.js';
+/**
+ * Account contract that authenticates transactions using Schnorr signatures
+ * verified against a Grumpkin public key stored in an immutable encrypted note.
+ * Eagerly loads the contract artifact
+ */
+export class SchnorrAccountContract extends SchnorrBaseAccountContract {
+  constructor(signingPrivateKey: GrumpkinScalar) {
+    super(signingPrivateKey);
+  }
+
+  override getContractArtifact(): Promise<ContractArtifact> {
+    return Promise.resolve(SchnorrAccountContractArtifact);
+  }
+}
 
 /**
  * Creates an Account Manager that relies on a Grumpkin signing key for authentication.
@@ -46,3 +65,33 @@ export function getSchnorrWallet(
 ): Promise<AccountWallet> {
   return getWallet(pxe, address, new SchnorrAccountContract(signingPrivateKey));
 }
+
+/**
+ * Gets a wallet for an already registered account using Schnorr signatures.
+ * @param pxe - An PXE server instance.
+ * @param secretKey - Secret key used to derive all the keystore keys.
+ * @param signingPrivateKey - Grumpkin key used for signing transactions.
+ * @param salt - Deployment salt.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export async function getSchnorrWalletWithSecretKey(
+  pxe: PXE,
+  secretKey: Fr,
+  signingPrivateKey: GrumpkinScalar,
+  salt: Salt,
+): Promise<AccountWalletWithSecretKey> {
+  const account = await getSchnorrAccount(pxe, secretKey, signingPrivateKey, salt);
+  return account.getWallet();
+}
+
+/**
+ * Compute the address of a schnorr account contract.
+ * @param secret - A seed for deriving the signing key and public keys.
+ * @param salt - The contract address salt.
+ * @param signingPrivateKey - A specific signing private key that's not derived from the secret.
+ */
+export async function getSchnorrAccountContractAddress(secret: Fr, salt: Fr, signingPrivateKey?: GrumpkinScalar) {
+  const signingKey = signingPrivateKey ?? deriveSigningKey(secret);
+  const accountContract = new SchnorrAccountContract(signingKey);
+  return await getAccountContractAddress(accountContract, secret, salt);
+}

package/src/schnorr/lazy.ts

@@ -0,0 +1,107 @@
+/**
+ * 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, type Salt, getAccountContractAddress } from '@aztec/aztec.js/account';
+import { type AccountWallet, type AccountWalletWithSecretKey, getWallet } from '@aztec/aztec.js/wallet';
+import { Fr, GrumpkinScalar } from '@aztec/foundation/fields';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+
+import { SchnorrBaseAccountContract } from './account_contract.js';
+
+/**
+ * Lazily loads the contract artifact
+ * @returns The contract artifact for the schnorr account contract
+ */
+export async function getSchnorrAccountContractArtifact() {
+  // Cannot assert this import as it's incompatible with browsers
+  // https://caniuse.com/mdn-javascript_statements_import_import_assertions_type_json
+  // Use the new "with" syntax once supported by firefox
+  // https://caniuse.com/mdn-javascript_statements_import_import_attributes_type_json
+  // In the meantime, this lazy import is INCOMPATIBLE WITH NODEJS
+  const { default: schnorrAccountContractJson } = await import('../../artifacts/SchnorrAccount.json');
+  return loadContractArtifact(schnorrAccountContractJson);
+}
+
+/**
+ * Account contract that authenticates transactions using Schnorr signatures
+ * verified against a Grumpkin public key stored in an immutable encrypted note.
+ * Lazily loads the contract artifact
+ */
+export class SchnorrAccountContract extends SchnorrBaseAccountContract {
+  constructor(signingPrivateKey: GrumpkinScalar) {
+    super(signingPrivateKey);
+  }
+
+  override getContractArtifact(): Promise<ContractArtifact> {
+    return getSchnorrAccountContractArtifact();
+  }
+}
+
+/**
+ * Creates an Account Manager that relies on a Grumpkin signing key for authentication.
+ * @param pxe - An PXE server instance.
+ * @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,
+): Promise<AccountManager> {
+  return AccountManager.create(pxe, secretKey, 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: GrumpkinScalar,
+): Promise<AccountWallet> {
+  return getWallet(pxe, address, new SchnorrAccountContract(signingPrivateKey));
+}
+
+/**
+ * Gets a wallet for an already registered account using Schnorr signatures.
+ * @param pxe - An PXE server instance.
+ * @param secretKey - Secret key used to derive all the keystore keys.
+ * @param signingPrivateKey - Grumpkin key used for signing transactions.
+ * @param salt - Deployment salt.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export async function getSchnorrWalletWithSecretKey(
+  pxe: PXE,
+  secretKey: Fr,
+  signingPrivateKey: GrumpkinScalar,
+  salt: Salt,
+): Promise<AccountWalletWithSecretKey> {
+  const account = await getSchnorrAccount(pxe, secretKey, signingPrivateKey, salt);
+  return account.getWallet();
+}
+
+/**
+ * Compute the address of a schnorr account contract.
+ * @param secret - A seed for deriving the signing key and public keys.
+ * @param salt - The contract address salt.
+ * @param signingPrivateKey - A specific signing private key that's not derived from the secret.
+ */
+export async function getSchnorrAccountContractAddress(secret: Fr, salt: Fr, signingPrivateKey?: GrumpkinScalar) {
+  const signingKey = signingPrivateKey ?? deriveSigningKey(secret);
+  const accountContract = new SchnorrAccountContract(signingKey);
+  return await getAccountContractAddress(accountContract, secret, salt);
+}

package/src/single_key/account_contract.ts

@@ -1,19 +1,20 @@
-import { type AuthWitnessProvider } from '@aztec/aztec.js/account';
-import { AuthWitness, type CompleteAddress, type GrumpkinScalar } from '@aztec/circuit-types';
-import { Schnorr } from '@aztec/circuits.js/barretenberg';
-import { type ContractArtifact } from '@aztec/foundation/abi';
-import { type Fr } from '@aztec/foundation/fields';
+import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { Schnorr } from '@aztec/foundation/crypto';
+import { type Fr, GrumpkinScalar } from '@aztec/foundation/fields';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { CompleteAddress } from '@aztec/stdlib/contract';
 
 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.
+ * This abstract version does not provide a way to retrieve the artifact, as it
+ * can be implemented with or without lazy loading.
  */
-export class SingleKeyAccountContract extends DefaultAccountContract {
+export abstract class SingleKeyBaseAccountContract extends DefaultAccountContract {
   constructor(private encryptionPrivateKey: GrumpkinScalar) {
-    super(SchnorrSingleKeyAccountContractArtifact as ContractArtifact);
+    super();
   }
 
   getDeploymentArgs() {

package/src/single_key/index.ts

@@ -4,16 +4,36 @@
  *
  * @packageDocumentation
  */
+import type { AztecAddress, Fr, GrumpkinScalar } from '@aztec/aztec.js';
 import { AccountManager, type Salt } from '@aztec/aztec.js/account';
 import { type AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
-import { type GrumpkinScalar, type PXE } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr, deriveMasterIncomingViewingSecretKey } from '@aztec/circuits.js';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { deriveMasterIncomingViewingSecretKey } from '@aztec/stdlib/keys';
+import type { NoirCompiledContract } from '@aztec/stdlib/noir';
 
-import { SingleKeyAccountContract } from './account_contract.js';
+import SchnorrSingleKeyAccountContractJson from '../../artifacts/SchnorrSingleKeyAccount.json' assert { type: 'json' };
+import { SingleKeyBaseAccountContract } from './account_contract.js';
 
-export { SingleKeyAccountContract };
+export const SchnorrSingleKeyAccountContractArtifact = loadContractArtifact(
+  SchnorrSingleKeyAccountContractJson as NoirCompiledContract,
+);
 
-export { SchnorrSingleKeyAccountContractArtifact as SingleKeyAccountContractArtifact } 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.
+ * Eagerly loads the contract artifact
+ */
+export class SingleKeyAccountContract extends SingleKeyBaseAccountContract {
+  constructor(signingPrivateKey: GrumpkinScalar) {
+    super(signingPrivateKey);
+  }
+
+  override getContractArtifact(): Promise<ContractArtifact> {
+    return Promise.resolve(SchnorrSingleKeyAccountContractArtifact);
+  }
+}
 
 /**
  * Creates an Account that uses the same Grumpkin key for encryption and authentication.
@@ -22,7 +42,7 @@ export { SchnorrSingleKeyAccountContractArtifact as SingleKeyAccountContractArti
  * @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) {
+export function getUnsafeSchnorrAccount(pxe: PXE, secretKey: Fr, salt?: Salt) {
   const encryptionPrivateKey = deriveMasterIncomingViewingSecretKey(secretKey);
   return AccountManager.create(pxe, secretKey, new SingleKeyAccountContract(encryptionPrivateKey), salt);
 }
@@ -34,12 +54,10 @@ export function getSingleKeyAccount(pxe: PXE, secretKey: Fr, salt?: Salt) {
  * @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(
+export function getUnsafeSchnorrWallet(
   pxe: PXE,
   address: AztecAddress,
-  signingKey: GrumpkinScalar,
+  signingPrivateKey: GrumpkinScalar,
 ): Promise<AccountWallet> {
-  return getWallet(pxe, address, new SingleKeyAccountContract(signingKey));
+  return getWallet(pxe, address, new SingleKeyAccountContract(signingPrivateKey));
 }
-
-export { getSingleKeyAccount as getUnsafeSchnorrAccount, getSingleKeyWallet as getUnsafeSchnorrWallet };