@aztec/accounts 0.82.2 → 0.82.3

package/dest/ecdsa/ecdsa_r/account_contract.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { CompleteAddress } from '@aztec/stdlib/contract';
+import { DefaultAccountContract } from '../../defaults/account_contract.js';
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256r1 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 declare abstract class EcdsaRBaseAccountContract extends DefaultAccountContract {
+    private signingPrivateKey;
+    constructor(signingPrivateKey: Buffer);
+    getDeploymentFunctionAndArgs(): Promise<{
+        constructorName: string;
+        constructorArgs: Buffer[];
+    }>;
+    getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider;
+}
+//# sourceMappingURL=account_contract.d.ts.map

package/dest/ecdsa/ecdsa_r/account_contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account_contract.d.ts","sourceRoot":"","sources":["../../../src/ecdsa/ecdsa_r/account_contract.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAInE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAE5E;;;;;GAKG;AACH,8BAAsB,yBAA0B,SAAQ,sBAAsB;IAChE,OAAO,CAAC,iBAAiB;gBAAjB,iBAAiB,EAAE,MAAM;IAIvC,4BAA4B;;;;IAQlC,sBAAsB,CAAC,QAAQ,EAAE,eAAe,GAAG,mBAAmB;CAGvE"}

package/dest/ecdsa/ecdsa_r/account_contract.js

@@ -0,0 +1,41 @@
+import { Ecdsa } from '@aztec/foundation/crypto';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { DefaultAccountContract } from '../../defaults/account_contract.js';
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256r1 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 EcdsaRBaseAccountContract extends DefaultAccountContract {
+    signingPrivateKey;
+    constructor(signingPrivateKey){
+        super(), this.signingPrivateKey = signingPrivateKey;
+    }
+    async getDeploymentFunctionAndArgs() {
+        const signingPublicKey = await new Ecdsa('secp256r1').computePublicKey(this.signingPrivateKey);
+        return {
+            constructorName: 'constructor',
+            constructorArgs: [
+                signingPublicKey.subarray(0, 32),
+                signingPublicKey.subarray(32, 64)
+            ]
+        };
+    }
+    getAuthWitnessProvider(_address) {
+        return new EcdsaRAuthWitnessProvider(this.signingPrivateKey);
+    }
+}
+/** Creates auth witnesses using ECDSA signatures. */ class EcdsaRAuthWitnessProvider {
+    signingPrivateKey;
+    constructor(signingPrivateKey){
+        this.signingPrivateKey = signingPrivateKey;
+    }
+    async createAuthWit(messageHash) {
+        const ecdsa = new Ecdsa('secp256r1');
+        const signature = await ecdsa.constructSignature(messageHash.toBuffer(), this.signingPrivateKey);
+        return Promise.resolve(new AuthWitness(messageHash, [
+            ...signature.r,
+            ...signature.s
+        ]));
+    }
+}

package/dest/ecdsa/ecdsa_r/index.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * 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 } from '@aztec/aztec.js/wallet';
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { EcdsaRBaseAccountContract } from './account_contract.js';
+export declare const EcdsaRAccountContractArtifact: ContractArtifact;
+/**
+ * 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 declare class EcdsaRAccountContract extends EcdsaRBaseAccountContract {
+    constructor(signingPrivateKey: Buffer);
+    getContractArtifact(): Promise<ContractArtifact>;
+}
+/**
+ * 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 declare function getEcdsaRAccount(pxe: PXE, secretKey: Fr, signingPrivateKey: Buffer, salt?: Salt): Promise<AccountManager>;
+/**
+ * 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 declare function getEcdsaRWallet(pxe: PXE, address: AztecAddress, signingPrivateKey: Buffer): Promise<AccountWallet>;
+//# sourceMappingURL=index.d.ts.map

package/dest/ecdsa/ecdsa_r/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ecdsa/ecdsa_r/index.ts"],"names":[],"mappings":";;AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,KAAK,IAAI,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAI3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAElE,eAAO,MAAM,6BAA6B,EAAE,gBAE3C,CAAC;AAEF;;;;GAIG;AACH,qBAAa,qBAAsB,SAAQ,yBAAyB;gBACtD,iBAAiB,EAAE,MAAM;IAI5B,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAG1D;AACD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,EAAE,EACb,iBAAiB,EAAE,MAAM,EACzB,IAAI,CAAC,EAAE,IAAI,GACV,OAAO,CAAC,cAAc,CAAC,CAEzB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAElH"}

package/dest/ecdsa/ecdsa_r/index.js

@@ -0,0 +1,44 @@
+/**
+ * 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 } from '@aztec/aztec.js/account';
+import { getWallet } from '@aztec/aztec.js/wallet';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import EcdsaRAccountContractJson from '../../../artifacts/EcdsaRAccount.json' assert {
+    type: 'json'
+};
+import { EcdsaRBaseAccountContract } from './account_contract.js';
+export const EcdsaRAccountContractArtifact = loadContractArtifact(EcdsaRAccountContractJson);
+/**
+ * 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 EcdsaRAccountContract extends EcdsaRBaseAccountContract {
+    constructor(signingPrivateKey){
+        super(signingPrivateKey);
+    }
+    getContractArtifact() {
+        return Promise.resolve(EcdsaRAccountContractArtifact);
+    }
+}
+/**
+ * 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 getEcdsaRAccount(pxe, secretKey, signingPrivateKey, salt) {
+    return AccountManager.create(pxe, secretKey, new EcdsaRAccountContract(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 getEcdsaRWallet(pxe, address, signingPrivateKey) {
+    return getWallet(pxe, address, new EcdsaRAccountContract(signingPrivateKey));
+}

package/dest/ecdsa/ecdsa_r/lazy.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * 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 } from '@aztec/aztec.js/wallet';
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { EcdsaRBaseAccountContract } from './account_contract.js';
+/**
+ * Lazily loads the contract artifact
+ * @returns The contract artifact for the ecdsa K account contract
+ */
+export declare function getEcdsaRAccountContractArtifact(): Promise<ContractArtifact>;
+/**
+ * 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 declare class EcdsaRAccountContract extends EcdsaRBaseAccountContract {
+    constructor(signingPrivateKey: Buffer);
+    getContractArtifact(): Promise<ContractArtifact>;
+}
+/**
+ * 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 declare function getEcdsaRAccount(pxe: PXE, secretKey: Fr, signingPrivateKey: Buffer, salt?: Salt): Promise<AccountManager>;
+/**
+ * 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 declare function getEcdsaRWallet(pxe: PXE, address: AztecAddress, signingPrivateKey: Buffer): Promise<AccountWallet>;
+//# sourceMappingURL=lazy.d.ts.map

package/dest/ecdsa/ecdsa_r/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../../src/ecdsa/ecdsa_r/lazy.ts"],"names":[],"mappings":";;AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,KAAK,IAAI,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAE3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAElE;;;GAGG;AACH,wBAAsB,gCAAgC,8BAQrD;AAED;;;;GAIG;AACH,qBAAa,qBAAsB,SAAQ,yBAAyB;gBACtD,iBAAiB,EAAE,MAAM;IAI5B,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAG1D;AACD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,EAAE,EACb,iBAAiB,EAAE,MAAM,EACzB,IAAI,CAAC,EAAE,IAAI,GACV,OAAO,CAAC,cAAc,CAAC,CAEzB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAElH"}

package/dest/ecdsa/ecdsa_r/lazy.js

@@ -0,0 +1,52 @@
+/**
+ * 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 } from '@aztec/aztec.js/account';
+import { getWallet } from '@aztec/aztec.js/wallet';
+import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { EcdsaRBaseAccountContract } from './account_contract.js';
+/**
+ * Lazily loads the contract artifact
+ * @returns The contract artifact for the ecdsa K 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 secp256k1 public key stored in an immutable encrypted note.
+ * Lazily loads the contract artifact
+ */ export class EcdsaRAccountContract extends EcdsaRBaseAccountContract {
+    constructor(signingPrivateKey){
+        super(signingPrivateKey);
+    }
+    getContractArtifact() {
+        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 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 getEcdsaRAccount(pxe, secretKey, signingPrivateKey, salt) {
+    return AccountManager.create(pxe, secretKey, new EcdsaRAccountContract(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 getEcdsaRWallet(pxe, address, signingPrivateKey) {
+    return getWallet(pxe, address, new EcdsaRAccountContract(signingPrivateKey));
+}

package/dest/ecdsa/index.d.ts

@@ -1,3 +1,4 @@
 export * from './ecdsa_k/index.js';
+export * from './ecdsa_r/index.js';
 export * from './ssh_ecdsa_r/index.js';
 //# sourceMappingURL=index.d.ts.map

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

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

package/dest/ecdsa/index.js

@@ -1,2 +1,3 @@
 export * from './ecdsa_k/index.js';
+export * from './ecdsa_r/index.js';
 export * from './ssh_ecdsa_r/index.js';

package/dest/ecdsa/lazy.d.ts

@@ -1,3 +1,4 @@
 export * from './ecdsa_k/lazy.js';
+export * from './ecdsa_r/lazy.js';
 export * from './ssh_ecdsa_r/lazy.js';
 //# sourceMappingURL=lazy.d.ts.map

package/dest/ecdsa/lazy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/ecdsa/lazy.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/ecdsa/lazy.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC"}

package/dest/ecdsa/lazy.js

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

package/dest/ecdsa/ssh_ecdsa_r/index.d.ts

@@ -13,7 +13,6 @@ import type { ContractArtifact } 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';
-export declare const EcdsaRAccountContractArtifact: ContractArtifact;
 /**
  * Account contract that authenticates transactions using ECDSA signatures
  * verified against a secp256r1 public key stored in an immutable encrypted note.

package/dest/ecdsa/ssh_ecdsa_r/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ecdsa/ssh_ecdsa_r/index.ts"],"names":[],"mappings":";;AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,KAAK,IAAI,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAI3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAC;AAErE,eAAO,MAAM,6BAA6B,EAAE,gBAE3C,CAAC;AAEF;;;;;;;GAOG;AACH,qBAAa,wBAAyB,SAAQ,4BAA4B;gBAC5D,iBAAiB,EAAE,MAAM;IAI5B,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAG1D;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,EAAE,EACb,gBAAgB,EAAE,MAAM,EACxB,IAAI,CAAC,EAAE,IAAI,GACV,OAAO,CAAC,cAAc,CAAC,CAEzB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAEpH"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ecdsa/ssh_ecdsa_r/index.ts"],"names":[],"mappings":";;AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,KAAK,IAAI,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAG3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAC;AAErE;;;;;;;GAOG;AACH,qBAAa,wBAAyB,SAAQ,4BAA4B;gBAC5D,iBAAiB,EAAE,MAAM;IAI5B,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAG1D;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,EAAE,EACb,gBAAgB,EAAE,MAAM,EACxB,IAAI,CAAC,EAAE,IAAI,GACV,OAAO,CAAC,cAAc,CAAC,CAEzB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAEpH"}

package/dest/ecdsa/ssh_ecdsa_r/index.js

@@ -5,12 +5,8 @@
  * @packageDocumentation
  */ import { AccountManager } from '@aztec/aztec.js/account';
 import { getWallet } from '@aztec/aztec.js/wallet';
-import { loadContractArtifact } from '@aztec/stdlib/abi';
-import EcdsaRAccountContractJson from '../../../artifacts/EcdsaKAccount.json' assert {
-    type: 'json'
-};
+import { EcdsaRAccountContractArtifact } from '../ecdsa_r/index.js';
 import { EcdsaRSSHBaseAccountContract } from './account_contract.js';
-export const EcdsaRAccountContractArtifact = loadContractArtifact(EcdsaRAccountContractJson);
 /**
  * Account contract that authenticates transactions using ECDSA signatures
  * verified against a secp256r1 public key stored in an immutable encrypted note.

package/dest/ecdsa/ssh_ecdsa_r/lazy.d.ts

@@ -13,10 +13,6 @@ import type { ContractArtifact } 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';
-/**
- *
- */
-export declare function getEcdsaRAccountContractArtifact(): Promise<ContractArtifact>;
 /**
  * Account contract that authenticates transactions using ECDSA signatures
  * verified against a secp256r1 public key stored in an immutable encrypted note.

package/dest/ecdsa/ssh_ecdsa_r/lazy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../../src/ecdsa/ssh_ecdsa_r/lazy.ts"],"names":[],"mappings":";;AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,KAAK,IAAI,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAE3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAC;AAMrE;;GAEG;AACH,wBAAsB,gCAAgC,8BAQrD;AAED;;;;;;;GAOG;AACH,qBAAa,wBAAyB,SAAQ,4BAA4B;gBAC5D,iBAAiB,EAAE,MAAM;IAI5B,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAG1D;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,EAAE,EACb,gBAAgB,EAAE,MAAM,EACxB,IAAI,CAAC,EAAE,IAAI,GACV,OAAO,CAAC,cAAc,CAAC,CAEzB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAEpH"}
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../../src/ecdsa/ssh_ecdsa_r/lazy.ts"],"names":[],"mappings":";;AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,KAAK,IAAI,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAG3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAC;AAErE;;;;;;;GAOG;AACH,qBAAa,wBAAyB,SAAQ,4BAA4B;gBAC5D,iBAAiB,EAAE,MAAM;IAI5B,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAG1D;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,EAAE,EACb,gBAAgB,EAAE,MAAM,EACxB,IAAI,CAAC,EAAE,IAAI,GACV,OAAO,CAAC,cAAc,CAAC,CAEzB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAEpH"}

package/dest/ecdsa/ssh_ecdsa_r/lazy.js

@@ -5,22 +5,8 @@
  * @packageDocumentation
  */ import { AccountManager } from '@aztec/aztec.js/account';
 import { getWallet } from '@aztec/aztec.js/wallet';
-import { loadContractArtifact } from '@aztec/stdlib/abi';
+import { getEcdsaRAccountContractArtifact } from '../ecdsa_r/lazy.js';
 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.

package/dest/testing/index.d.ts

@@ -5,7 +5,7 @@
  *
  * @packageDocumentation
  */
-import type { PXE } from '@aztec/aztec.js';
+import { AccountManager, type PXE } from '@aztec/aztec.js';
 import type { AccountWalletWithSecretKey } from '@aztec/aztec.js/wallet';
 import type { InitialAccountData } from './configuration.js';
 export { type InitialAccountData, INITIAL_TEST_ACCOUNT_SALTS, INITIAL_TEST_ENCRYPTION_KEYS, INITIAL_TEST_SECRET_KEYS, INITIAL_TEST_SIGNING_KEYS, } from './configuration.js';
@@ -13,6 +13,12 @@ export { type InitialAccountData, INITIAL_TEST_ACCOUNT_SALTS, INITIAL_TEST_ENCRY
  * Gets the basic information for initial test accounts.
  */
 export declare function getInitialTestAccounts(): Promise<InitialAccountData[]>;
+/**
+ * Gets a collection of account managers for the Aztec accounts that are initially stored in the test environment.
+ * @param pxe - PXE instance.
+ * @returns A set of AccountManager implementations for each of the initial accounts.
+ */
+export declare function getInitialTestAccountsManagers(pxe: PXE): Promise<AccountManager[]>;
 /**
  * Gets a collection of wallets for the Aztec accounts that are initially stored in the test environment.
  * @param pxe - PXE instance.

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAOzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAQ7D,OAAO,EACL,KAAK,kBAAkB,EACvB,0BAA0B,EAC1B,4BAA4B,EAC5B,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAatE;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAY7F;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAIrF;AAED;;;;GAIG;AACH,wBAAsB,8BAA8B,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAKpG;AAED,OAAO,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,cAAc,EAAE,KAAK,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAOzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAQ7D,OAAO,EACL,KAAK,kBAAkB,EACvB,0BAA0B,EAC1B,4BAA4B,EAC5B,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAatE;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAMlF;AAED;;;;GAIG;AACH,wBAAsB,6BAA6B,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAInG;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAIrF;AAED;;;;GAIG;AACH,wBAAsB,8BAA8B,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAKpG;AAED,OAAO,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC"}

package/dest/testing/index.js

@@ -17,15 +17,19 @@ export { INITIAL_TEST_ACCOUNT_SALTS, INITIAL_TEST_ENCRYPTION_KEYS, INITIAL_TEST_
             address: await getSchnorrAccountContractAddress(secret, INITIAL_TEST_ACCOUNT_SALTS[i], INITIAL_TEST_SIGNING_KEYS[i])
         })));
 }
+/**
+ * Gets a collection of account managers for the Aztec accounts that are initially stored in the test environment.
+ * @param pxe - PXE instance.
+ * @returns A set of AccountManager implementations for each of the initial accounts.
+ */ export function getInitialTestAccountsManagers(pxe) {
+    return Promise.all(INITIAL_TEST_SECRET_KEYS.map((encryptionKey, i)=>getSchnorrAccount(pxe, encryptionKey, INITIAL_TEST_SIGNING_KEYS[i], INITIAL_TEST_ACCOUNT_SALTS[i])));
+}
 /**
  * Gets a collection of wallets for the Aztec accounts that are initially stored in the test environment.
  * @param pxe - PXE instance.
  * @returns A set of AccountWallet implementations for each of the initial accounts.
- */ export function getInitialTestAccountsWallets(pxe) {
-    return Promise.all(INITIAL_TEST_SECRET_KEYS.map(async (encryptionKey, i)=>{
-        const account = await getSchnorrAccount(pxe, encryptionKey, INITIAL_TEST_SIGNING_KEYS[i], INITIAL_TEST_ACCOUNT_SALTS[i]);
-        return account.getWallet();
-    }));
+ */ export async function getInitialTestAccountsWallets(pxe) {
+    return Promise.all((await Promise.all(await getInitialTestAccountsManagers(pxe))).map((accountManager)=>accountManager.getWallet()));
 }
 /**
  * Queries a PXE for it's registered accounts.

package/package.json

@@ -2,7 +2,7 @@
   "name": "@aztec/accounts",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/accounts",
   "description": "Implementation of sample account contracts for Aztec Network",
-  "version": "0.82.2",
+  "version": "0.82.3",
   "type": "module",
   "exports": {
     "./dapp": "./dest/dapp/index.js",
@@ -77,11 +77,11 @@
     ]
   },
   "dependencies": {
-    "@aztec/aztec.js": "0.82.2",
-    "@aztec/entrypoints": "0.82.2",
-    "@aztec/ethereum": "0.82.2",
-    "@aztec/foundation": "0.82.2",
-    "@aztec/stdlib": "0.82.2",
+    "@aztec/aztec.js": "0.82.3",
+    "@aztec/entrypoints": "0.82.3",
+    "@aztec/ethereum": "0.82.3",
+    "@aztec/foundation": "0.82.3",
+    "@aztec/stdlib": "0.82.3",
     "tslib": "^2.4.0"
   },
   "devDependencies": {

package/src/ecdsa/ecdsa_r/account_contract.ts

@@ -0,0 +1,42 @@
+import type { AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { Ecdsa } 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';
+
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256r1 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 abstract class EcdsaRBaseAccountContract extends DefaultAccountContract {
+  constructor(private signingPrivateKey: Buffer) {
+    super();
+  }
+
+  async getDeploymentFunctionAndArgs() {
+    const signingPublicKey = await new Ecdsa('secp256r1').computePublicKey(this.signingPrivateKey);
+    return {
+      constructorName: 'constructor',
+      constructorArgs: [signingPublicKey.subarray(0, 32), signingPublicKey.subarray(32, 64)],
+    };
+  }
+
+  getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {
+    return new EcdsaRAuthWitnessProvider(this.signingPrivateKey);
+  }
+}
+
+/** Creates auth witnesses using ECDSA signatures. */
+class EcdsaRAuthWitnessProvider implements AuthWitnessProvider {
+  constructor(private signingPrivateKey: Buffer) {}
+
+  async createAuthWit(messageHash: Fr): Promise<AuthWitness> {
+    const ecdsa = new Ecdsa('secp256r1');
+    const signature = await ecdsa.constructSignature(messageHash.toBuffer(), this.signingPrivateKey);
+    return Promise.resolve(new AuthWitness(messageHash, [...signature.r, ...signature.s]));
+  }
+}

package/src/ecdsa/ecdsa_r/index.ts

@@ -0,0 +1,63 @@
+/**
+ * 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 type { NoirCompiledContract } from '@aztec/stdlib/noir';
+
+import EcdsaRAccountContractJson from '../../../artifacts/EcdsaRAccount.json' assert { type: 'json' };
+import { EcdsaRBaseAccountContract } from './account_contract.js';
+
+export const EcdsaRAccountContractArtifact: ContractArtifact = loadContractArtifact(
+  EcdsaRAccountContractJson 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 EcdsaRAccountContract extends EcdsaRBaseAccountContract {
+  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.
+ * @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 getEcdsaRAccount(
+  pxe: PXE,
+  secretKey: Fr,
+  signingPrivateKey: Buffer,
+  salt?: Salt,
+): Promise<AccountManager> {
+  return AccountManager.create(pxe, secretKey, new EcdsaRAccountContract(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 getEcdsaRWallet(pxe: PXE, address: AztecAddress, signingPrivateKey: Buffer): Promise<AccountWallet> {
+  return getWallet(pxe, address, new EcdsaRAccountContract(signingPrivateKey));
+}

package/src/ecdsa/ecdsa_r/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 { EcdsaRBaseAccountContract } from './account_contract.js';
+
+/**
+ * Lazily loads the contract artifact
+ * @returns The contract artifact for the ecdsa K 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 secp256k1 public key stored in an immutable encrypted note.
+ * Lazily loads the contract artifact
+ */
+export class EcdsaRAccountContract extends EcdsaRBaseAccountContract {
+  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 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 getEcdsaRAccount(
+  pxe: PXE,
+  secretKey: Fr,
+  signingPrivateKey: Buffer,
+  salt?: Salt,
+): Promise<AccountManager> {
+  return AccountManager.create(pxe, secretKey, new EcdsaRAccountContract(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 getEcdsaRWallet(pxe: PXE, address: AztecAddress, signingPrivateKey: Buffer): Promise<AccountWallet> {
+  return getWallet(pxe, address, new EcdsaRAccountContract(signingPrivateKey));
+}