feat: client flows benchmarks

barretenberg/cpp/src/barretenberg/crypto/ecdsa/c_bind.cpp

@@ -1,9 +1,12 @@
 #include "ecdsa.hpp"
 #include <barretenberg/ecc/curves/secp256k1/secp256k1.hpp>
+#include <barretenberg/ecc/curves/secp256r1/secp256r1.hpp>
 
 using namespace bb;
 using namespace bb::crypto;
 
+// secp256k1 curve
+
 WASM_EXPORT void ecdsa__compute_public_key(uint8_t const* private_key, uint8_t* public_key_buf)
 {
     auto priv_key = from_buffer<secp256k1::fr>(private_key);
@@ -117,3 +120,119 @@ WASM_EXPORT void ecdsa__verify_signature_(uint8_t const* message_buf,
     ecdsa_signature sig = { r, s, v };
     *result = ecdsa_verify_signature<Sha256Hasher, secp256k1::fq, secp256k1::fr, secp256k1::g1>(message, pubk, sig);
 }
+
+// secp256r1 curve
+
+WASM_EXPORT void ecdsa_r_compute_public_key(uint8_t const* private_key, uint8_t* public_key_buf)
+{
+    auto priv_key = from_buffer<secp256r1::fr>(private_key);
+    secp256r1::g1::affine_element pub_key = secp256r1::g1::one * priv_key;
+    write(public_key_buf, pub_key);
+}
+
+WASM_EXPORT void ecdsa_r_construct_signature(uint8_t const* message,
+                                             size_t msg_len,
+                                             uint8_t const* private_key,
+                                             uint8_t* output_sig_r,
+                                             uint8_t* output_sig_s,
+                                             uint8_t* output_sig_v)
+{
+    using serialize::write;
+    auto priv_key = from_buffer<secp256r1::fr>(private_key);
+    secp256r1::g1::affine_element pub_key = secp256r1::g1::one * priv_key;
+    ecdsa_key_pair<secp256r1::fr, secp256r1::g1> key_pair = { priv_key, pub_key };
+
+    auto sig = ecdsa_construct_signature<Sha256Hasher, secp256r1::fq, secp256r1::fr, secp256r1::g1>(
+        std::string((char*)message, msg_len), key_pair);
+    write(output_sig_r, sig.r);
+    write(output_sig_s, sig.s);
+    write(output_sig_v, sig.v);
+}
+
+WASM_EXPORT void ecdsa_r_construct_signature_(uint8_t const* message_buf,
+                                              uint8_t const* private_key,
+                                              uint8_t* output_sig_r,
+                                              uint8_t* output_sig_s,
+                                              uint8_t* output_sig_v)
+{
+    using serialize::write;
+    auto priv_key = from_buffer<secp256r1::fr>(private_key);
+    secp256r1::g1::affine_element pub_key = secp256r1::g1::one * priv_key;
+    ecdsa_key_pair<secp256r1::fr, secp256r1::g1> key_pair = { priv_key, pub_key };
+
+    auto message = from_buffer<std::string>(message_buf);
+
+    auto sig = ecdsa_construct_signature<Sha256Hasher, secp256r1::fq, secp256r1::fr, secp256r1::g1>(message, key_pair);
+    write(output_sig_r, sig.r);
+    write(output_sig_s, sig.s);
+    write(output_sig_v, sig.v);
+}
+
+WASM_EXPORT void ecdsa_r_recover_public_key_from_signature(uint8_t const* message,
+                                                           size_t msg_len,
+                                                           uint8_t const* sig_r,
+                                                           uint8_t const* sig_s,
+                                                           uint8_t* sig_v,
+                                                           uint8_t* output_pub_key)
+{
+    std::array<uint8_t, 32> r, s;
+    std::copy(sig_r, sig_r + 32, r.begin());
+    std::copy(sig_s, sig_s + 32, s.begin());
+    const uint8_t v = *sig_v;
+
+    ecdsa_signature sig = { r, s, v };
+    auto recovered_pub_key = ecdsa_recover_public_key<Sha256Hasher, secp256r1::fq, secp256r1::fr, secp256r1::g1>(
+        std::string((char*)message, msg_len), sig);
+    write(output_pub_key, recovered_pub_key);
+}
+
+WASM_EXPORT void ecdsa_r_recover_public_key_from_signature_(
+    uint8_t const* message_buf, uint8_t const* sig_r, uint8_t const* sig_s, uint8_t* sig_v, uint8_t* output_pub_key)
+{
+    std::array<uint8_t, 32> r, s;
+    std::copy(sig_r, sig_r + 32, r.begin());
+    std::copy(sig_s, sig_s + 32, s.begin());
+    const uint8_t v = *sig_v;
+
+    auto message = from_buffer<std::string>(message_buf);
+    ecdsa_signature sig = { r, s, v };
+    auto recovered_pub_key =
+        ecdsa_recover_public_key<Sha256Hasher, secp256r1::fq, secp256r1::fr, secp256r1::g1>(message, sig);
+    write(output_pub_key, recovered_pub_key);
+}
+
+WASM_EXPORT bool ecdsa_r_verify_signature(uint8_t const* message,
+                                          size_t msg_len,
+                                          uint8_t const* pub_key,
+                                          uint8_t const* sig_r,
+                                          uint8_t const* sig_s,
+                                          uint8_t const* sig_v)
+{
+    auto pubk = from_buffer<secp256r1::g1::affine_element>(pub_key);
+    std::array<uint8_t, 32> r, s;
+    std::copy(sig_r, sig_r + 32, r.begin());
+    std::copy(sig_s, sig_s + 32, s.begin());
+    const uint8_t v = *sig_v;
+
+    ecdsa_signature sig = { r, s, v };
+    return ecdsa_verify_signature<Sha256Hasher, secp256r1::fq, secp256r1::fr, secp256r1::g1>(
+        std::string((char*)message, msg_len), pubk, sig);
+}
+
+WASM_EXPORT void ecdsa_r_verify_signature_(uint8_t const* message_buf,
+                                           uint8_t const* pub_key,
+                                           uint8_t const* sig_r,
+                                           uint8_t const* sig_s,
+                                           uint8_t const* sig_v,
+                                           bool* result)
+{
+    auto pubk = from_buffer<secp256r1::g1::affine_element>(pub_key);
+    std::array<uint8_t, 32> r, s;
+    std::copy(sig_r, sig_r + 32, r.begin());
+    std::copy(sig_s, sig_s + 32, s.begin());
+    const uint8_t v = *sig_v;
+
+    auto message = from_buffer<std::string>(message_buf);
+    ecdsa_signature sig = { r, s, v };
+    *result = ecdsa_verify_signature<Sha256Hasher, secp256r1::fq, secp256r1::fr, secp256r1::g1>(message, pubk, sig);
+}

barretenberg/cpp/src/barretenberg/crypto/ecdsa/c_bind.h

@@ -1,5 +1,8 @@
 #include "barretenberg/common/wasm_export.hpp"
 #include <ecc/curves/secp256k1/secp256k1.hpp>
+#include <ecc/curves/secp256k1/secp256r1.hpp>
+
+// secp256k1 curve
 
 WASM_EXPORT void ecdsa__compute_public_key(uint8_t const* private_key, uint8_t* public_key_buf);
 
@@ -33,5 +36,42 @@ WASM_EXPORT bool ecdsa__verify_signature(uint8_t const* message,
                                          uint8_t const* sig_s,
                                          uint8_t const* sig_v);
 
-WASM_EXPORT bool ecdsa__verify_signature_(
+// secp256r1 curve
+
+WASM_EXPORT bool ecdsa_r_verify_signature_(
+    uint8_t const* message, uint8_t const* pub_key, uint8_t const* sig_r, uint8_t const* sig_s, uint8_t const* sig_v);
+
+WASM_EXPORT void ecdsa_r_compute_public_key(uint8_t const* private_key, uint8_t* public_key_buf);
+
+WASM_EXPORT void ecdsa_r_construct_signature(uint8_t const* message,
+                                             size_t msg_len,
+                                             uint8_t const* private_key,
+                                             uint8_t* output_sig_r,
+                                             uint8_t* output_sig_s,
+                                             uint8_t* output_sig_v);
+
+WASM_EXPORT void ecdsa_r_construct_signature_(uint8_t const* message_buf,
+                                              uint8_t const* private_key,
+                                              uint8_t* output_sig_r,
+                                              uint8_t* output_sig_s,
+                                              uint8_t* output_sig_v);
+
+WASM_EXPORT void ecdsa_r_recover_public_key_from_signature(uint8_t const* message,
+                                                           size_t msg_len,
+                                                           uint8_t const* sig_r,
+                                                           uint8_t const* sig_s,
+                                                           uint8_t* sig_v,
+                                                           uint8_t* output_pub_key);
+
+WASM_EXPORT void ecdsa_r_recover_public_key_from_signature_(
+    uint8_t const* message_buf, uint8_t const* sig_r, uint8_t const* sig_s, uint8_t* sig_v, uint8_t* output_pub_key);
+
+WASM_EXPORT bool ecdsa_r_verify_signature(uint8_t const* message,
+                                          size_t msg_len,
+                                          uint8_t const* pub_key,
+                                          uint8_t const* sig_r,
+                                          uint8_t const* sig_s,
+                                          uint8_t const* sig_v);
+
+WASM_EXPORT bool ecdsa_r_verify_signature_(
     uint8_t const* message, uint8_t const* pub_key, uint8_t const* sig_r, uint8_t const* sig_s, uint8_t const* sig_v);

yarn-project/accounts/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]));
+  }
+}

yarn-project/accounts/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));
+}

yarn-project/accounts/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));
+}

yarn-project/accounts/src/ecdsa/index.ts

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

yarn-project/accounts/src/ecdsa/lazy.ts

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

yarn-project/accounts/src/ecdsa/ssh_ecdsa_r/index.ts

@@ -8,18 +8,12 @@ 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/EcdsaKAccount.json' assert { type: 'json' };
+import { EcdsaRAccountContractArtifact } from '../ecdsa_r/index.js';
 import { EcdsaRSSHBaseAccountContract } from './account_contract.js';
 
-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.