refactor: replace usage of GrumpkinPrivateKey with EmbeddedCurveScalar

noir-projects/aztec-nr/aztec/src/encrypted_logs/header.nr

@@ -1,4 +1,4 @@
-use dep::protocol_types::{address::AztecAddress, grumpkin_private_key::GrumpkinPrivateKey, point::Point};
+use dep::protocol_types::{address::AztecAddress, embedded_curve_scalar::EmbeddedCurveScalar, point::Point};
 
 use crate::keys::point_to_symmetric_key::point_to_symmetric_key;
 
@@ -13,7 +13,7 @@ impl EncryptedLogHeader {
         EncryptedLogHeader { address }
     }
 
-    fn compute_ciphertext(self, secret: GrumpkinPrivateKey, point: Point) -> [u8; 48] {
+    fn compute_ciphertext(self, secret: EmbeddedCurveScalar, point: Point) -> [u8; 48] {
         let full_key = point_to_symmetric_key(secret, point);
         let mut sym_key = [0; 16];
         let mut iv = [0; 16];
@@ -32,7 +32,7 @@ impl EncryptedLogHeader {
 fn test_encrypted_log_header() {
     let address = AztecAddress::from_field(0xdeadbeef);
     let header = EncryptedLogHeader::new(address);
-    let secret = GrumpkinPrivateKey::new(
+    let secret = EmbeddedCurveScalar::new(
         0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,
         0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd
     );

noir-projects/aztec-nr/aztec/src/encrypted_logs/incoming_body.nr

@@ -1,6 +1,6 @@
 use crate::note::note_interface::NoteInterface;
 use crate::event::event_interface::EventInterface;
-use dep::protocol_types::{grumpkin_private_key::GrumpkinPrivateKey, point::Point};
+use dep::protocol_types::{embedded_curve_scalar::EmbeddedCurveScalar, point::Point};
 
 use std::aes128::aes128_encrypt;
 use crate::keys::point_to_symmetric_key::point_to_symmetric_key;
@@ -20,7 +20,7 @@ impl<M> EncryptedLogIncomingBody<M> {
         EncryptedLogIncomingBody { plaintext }
     }
 
-    pub fn compute_ciphertext(self, eph_sk: GrumpkinPrivateKey, ivpk_app: Point) -> [u8] {
+    pub fn compute_ciphertext(self, eph_sk: EmbeddedCurveScalar, ivpk_app: Point) -> [u8] {
         let full_key = point_to_symmetric_key(eph_sk, ivpk_app);
         let mut sym_key = [0; 16];
         let mut iv = [0; 16];
@@ -37,7 +37,7 @@ mod test {
     use crate::encrypted_logs::incoming_body::EncryptedLogIncomingBody;
     use dep::protocol_types::{
         address::AztecAddress, traits::Empty, constants::GENERATOR_INDEX__NOTE_NULLIFIER,
-        grumpkin_private_key::GrumpkinPrivateKey, point::Point, traits::Serialize,
+        embedded_curve_scalar::EmbeddedCurveScalar, point::Point, traits::Serialize,
         abis::event_selector::EventSelector
     };
 
@@ -119,7 +119,7 @@ mod test {
 
         let storage_slot = 2;
 
-        let eph_sk = GrumpkinPrivateKey::new(
+        let eph_sk = EmbeddedCurveScalar::new(
             0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,
             0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd
         );
@@ -218,7 +218,7 @@ mod test {
     fn test_encrypted_log_event_incoming_body() {
         let test_event = TestEvent { value0: 1, value1: 2, value2: 3 };
 
-        let eph_sk = GrumpkinPrivateKey::new(
+        let eph_sk = EmbeddedCurveScalar::new(
             0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,
             0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd
         );

noir-projects/aztec-nr/aztec/src/encrypted_logs/outgoing_body.nr

@@ -1,5 +1,5 @@
 use dep::protocol_types::{
-    address::AztecAddress, grumpkin_private_key::GrumpkinPrivateKey, point::Point,
+    address::AztecAddress, embedded_curve_scalar::EmbeddedCurveScalar, point::Point,
     constants::GENERATOR_INDEX__SYMMETRIC_KEY, hash::poseidon2_hash
 };
 
@@ -8,17 +8,17 @@ use std::aes128::aes128_encrypt;
 use crate::keys::point_to_symmetric_key::point_to_symmetric_key;
 
 struct EncryptedLogOutgoingBody {
-    eph_sk: GrumpkinPrivateKey,
+    eph_sk: EmbeddedCurveScalar,
     recipient: AztecAddress,
     recipient_ivpk_app: Point,
 }
 
 impl EncryptedLogOutgoingBody {
-    pub fn new(eph_sk: GrumpkinPrivateKey, recipient: AztecAddress, recipient_ivpk_app: Point) -> Self {
+    pub fn new(eph_sk: EmbeddedCurveScalar, recipient: AztecAddress, recipient_ivpk_app: Point) -> Self {
         Self { eph_sk, recipient, recipient_ivpk_app }
     }
 
-    pub fn compute_ciphertext(self, ovsk_app: GrumpkinPrivateKey, eph_pk: Point) -> [u8; 176] {
+    pub fn compute_ciphertext(self, ovsk_app: EmbeddedCurveScalar, eph_pk: Point) -> [u8; 176] {
         // Again, we could compute `eph_pk` here, but we keep the interface more similar
         // and also make it easier to optimise it later as we just pass it along
 
@@ -64,22 +64,22 @@ mod test {
     use crate::encrypted_logs::outgoing_body::EncryptedLogOutgoingBody;
     use dep::protocol_types::{
         address::AztecAddress, traits::Empty, constants::GENERATOR_INDEX__NOTE_NULLIFIER,
-        grumpkin_private_key::GrumpkinPrivateKey, point::Point, hash::poseidon2_hash
+        embedded_curve_scalar::EmbeddedCurveScalar, point::Point, hash::poseidon2_hash
     };
 
     use crate::context::PrivateContext;
 
     #[test]
     fn test_encrypted_log_outgoing_body() {
-        let eph_sk = GrumpkinPrivateKey::new(
+        let eph_sk = EmbeddedCurveScalar::new(
             0x000000000000000000000000000000000f096b423017226a18461115fa8d34bb,
             0x00000000000000000000000000000000d0d302ee245dfaf2807e604eec4715fe
         );
-        let recipient_ivsk_app = GrumpkinPrivateKey::new(
+        let recipient_ivsk_app = EmbeddedCurveScalar::new(
             0x000000000000000000000000000000000f4d97c25d578f9348251a71ca17ae31,
             0x000000000000000000000000000000004828f8f95676ebb481df163f87fd4022
         );
-        let sender_ovsk_app = GrumpkinPrivateKey::new(
+        let sender_ovsk_app = EmbeddedCurveScalar::new(
             0x00000000000000000000000000000000089c6887cb1446d86c64e81afc78048b,
             0x0000000000000000000000000000000074d2e28c6bc5176ac02cf7c7d36a444e
         );

noir-projects/aztec-nr/aztec/src/encrypted_logs/payload.nr

@@ -1,5 +1,5 @@
 use dep::protocol_types::{
-    address::AztecAddress, grumpkin_private_key::GrumpkinPrivateKey, point::{Point, pub_key_to_bytes},
+    address::AztecAddress, embedded_curve_scalar::EmbeddedCurveScalar, point::{Point, pub_key_to_bytes},
     constants::{GENERATOR_INDEX__IVSK_M, GENERATOR_INDEX__OVSK_M}, hash::poseidon2_hash
 };
 
@@ -24,7 +24,7 @@ pub fn compute_encrypted_event_log<Event, NB, MB, OB>(
     event: Event
 ) -> [u8; OB] where Event: EventInterface<NB, MB> {
     // @todo Need to draw randomness from the full domain of Fq not only Fr
-    let eph_sk: GrumpkinPrivateKey = fr_to_private_key(unsafe_rand());
+    let eph_sk: EmbeddedCurveScalar = fr_to_private_key(unsafe_rand());
     let eph_pk = eph_sk.derive_public_key();
 
     // TODO: (#7177) This value needs to be populated!
@@ -81,7 +81,7 @@ pub fn compute_encrypted_note_log<Note, N, NB, M>(
     note: Note
 ) -> [u8; M] where Note: NoteInterface<N, NB> {
     // @todo Need to draw randomness from the full domain of Fq not only Fr
-    let eph_sk: GrumpkinPrivateKey = fr_to_private_key(unsafe_rand());
+    let eph_sk: EmbeddedCurveScalar = fr_to_private_key(unsafe_rand());
     let eph_pk = eph_sk.derive_public_key();
 
     // TODO: (#7177) This value needs to be populated!
@@ -129,7 +129,7 @@ pub fn compute_encrypted_note_log<Note, N, NB, M>(
     encrypted_bytes
 }
 
-fn fr_to_private_key(r: Field) -> GrumpkinPrivateKey {
+fn fr_to_private_key(r: Field) -> EmbeddedCurveScalar {
     let r_bytes = r.to_be_bytes(32);
 
     let mut high_bytes = [0; 32];
@@ -143,7 +143,7 @@ fn fr_to_private_key(r: Field) -> GrumpkinPrivateKey {
     let low = bytes32_to_field(low_bytes);
     let high = bytes32_to_field(high_bytes);
 
-    GrumpkinPrivateKey::new(high, low)
+    EmbeddedCurveScalar::new(high, low)
 }
 
 fn compute_ivpk_app(ivpk: Point, contract_address: AztecAddress) -> Point {

noir-projects/aztec-nr/aztec/src/keys/point_to_symmetric_key.nr

@@ -1,12 +1,12 @@
 use dep::protocol_types::{
-    constants::GENERATOR_INDEX__SYMMETRIC_KEY, grumpkin_private_key::GrumpkinPrivateKey,
+    constants::GENERATOR_INDEX__SYMMETRIC_KEY, embedded_curve_scalar::EmbeddedCurveScalar,
     point::{Point, pub_key_to_bytes}, utils::arr_copy_slice
 };
 use std::{hash::sha256, embedded_curve_ops::{EmbeddedCurveScalar, multi_scalar_mul}};
 
 // TODO(#5726): This function is called deriveAESSecret in TS. I don't like point_to_symmetric_key name much since
 // point is not the only input of the function. Unify naming with TS once we have a better name.
-pub fn point_to_symmetric_key(secret: GrumpkinPrivateKey, point: Point) -> [u8; 32] {
+pub fn point_to_symmetric_key(secret: EmbeddedCurveScalar, point: Point) -> [u8; 32] {
     let shared_secret_fields = multi_scalar_mul(
         [Point { x: point.x, y: point.y, is_infinite: false }],
         [EmbeddedCurveScalar { lo: secret.low, hi: secret.high }]
@@ -22,7 +22,7 @@ pub fn point_to_symmetric_key(secret: GrumpkinPrivateKey, point: Point) -> [u8;
 #[test]
 fn check_point_to_symmetric_key() {
     // Value taken from "derive shared secret" test in encrypt_buffer.test.ts
-    let secret = GrumpkinPrivateKey::new(
+    let secret = EmbeddedCurveScalar::new(
         0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,
         0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd
     );

noir-projects/noir-contracts/contracts/test_contract/src/main.nr

@@ -13,7 +13,7 @@ contract Test {
     use dep::aztec::protocol_types::{
         abis::private_circuit_public_inputs::PrivateCircuitPublicInputs,
         constants::{MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, CANONICAL_KEY_REGISTRY_ADDRESS},
-        traits::{Serialize, ToField, FromField}, point::Point, grumpkin_private_key::GrumpkinPrivateKey,
+        traits::{Serialize, ToField, FromField}, point::Point, embedded_curve_scalar::EmbeddedCurveScalar,
         storage::map::derive_storage_slot_in_map
     };
 
@@ -404,14 +404,14 @@ contract Test {
     }
 
     #[aztec(private)]
-    fn compute_note_header_ciphertext(secret: GrumpkinPrivateKey, point: Point) -> [u8; 48] {
+    fn compute_note_header_ciphertext(secret: EmbeddedCurveScalar, point: Point) -> [u8; 48] {
         EncryptedLogHeader::new(context.this_address()).compute_ciphertext(secret, point)
     }
 
     // 64 bytes + 32 * #fields + 16 = 112 bytes
     #[aztec(private)]
     fn compute_incoming_log_body_ciphertext(
-        secret: GrumpkinPrivateKey,
+        secret: EmbeddedCurveScalar,
         point: Point,
         storage_slot: Field,
         value: Field
@@ -422,10 +422,10 @@ contract Test {
 
     #[aztec(private)]
     fn compute_outgoing_log_body_ciphertext(
-        eph_sk: GrumpkinPrivateKey,
+        eph_sk: EmbeddedCurveScalar,
         recipient: AztecAddress,
         recipient_ivpk_app: Point,
-        ovsk_app: GrumpkinPrivateKey
+        ovsk_app: EmbeddedCurveScalar
     ) -> [u8; 176] {
         let eph_pk = eph_sk.derive_public_key();
         EncryptedLogOutgoingBody::new(eph_sk, recipient, recipient_ivpk_app).compute_ciphertext(ovsk_app, eph_pk)

noir-projects/noir-contracts/contracts/test_log_contract/src/main.nr

@@ -1,6 +1,6 @@
 contract TestLog {
     use dep::aztec::prelude::PrivateSet;
-    use dep::aztec::protocol_types::{traits::Serialize, point::Point, grumpkin_private_key::GrumpkinPrivateKey, address::AztecAddress};
+    use dep::aztec::protocol_types::{traits::Serialize, point::Point, embedded_curve_scalar::EmbeddedCurveScalar, address::AztecAddress};
     use dep::value_note::value_note::ValueNote;
     use dep::aztec::encrypted_logs::incoming_body::EncryptedLogIncomingBody;
     use dep::aztec::event::event_interface::EventInterface;
@@ -29,7 +29,7 @@ contract TestLog {
 
     #[aztec(private)]
     fn compute_incoming_log_body_ciphertext(
-        secret: GrumpkinPrivateKey,
+        secret: EmbeddedCurveScalar,
         point: Point,
         randomness: Field,
         event_type_id: Field,

noir-projects/noir-protocol-circuits/crates/private-kernel-lib/src/private_kernel_reset.nr

@@ -113,7 +113,7 @@ mod tests {
         max_block_number::MaxBlockNumber, note_hash::{NoteHash, ScopedNoteHash},
         nullifier::{Nullifier, ScopedNullifier}, log_hash::NoteLogHash, read_request::ScopedReadRequest
     },
-        address::AztecAddress, grumpkin_private_key::GrumpkinPrivateKey,
+        address::AztecAddress, embedded_curve_scalar::EmbeddedCurveScalar,
         tests::{fixture_builder::FixtureBuilder}, utils::{arrays::{array_eq, array_length}},
         traits::{Empty, is_empty, is_empty_array}, point::Point
     };

noir-projects/noir-protocol-circuits/crates/private-kernel-lib/src/private_kernel_tail.nr

@@ -61,7 +61,7 @@ mod tests {
         kernel_circuit_public_inputs::KernelCircuitPublicInputs, max_block_number::MaxBlockNumber,
         note_hash::{NoteHash, ScopedNoteHash}, nullifier::{Nullifier, ScopedNullifier}, gas::Gas
     },
-        address::{AztecAddress, EthAddress}, grumpkin_private_key::GrumpkinPrivateKey,
+        address::{AztecAddress, EthAddress}, embedded_curve_scalar::EmbeddedCurveScalar,
         hash::{
         sha256_to_field, silo_note_hash, silo_nullifier, compute_siloed_encrypted_log_hash,
         compute_siloed_unencrypted_log_hash

noir-projects/noir-protocol-circuits/crates/reset-kernel-lib/src/private_validation_request_processor.nr

@@ -13,7 +13,7 @@ use dep::types::{
     MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_KEY_VALIDATION_REQUESTS_PER_TX,
     GENERATOR_INDEX__NSK_M, MAX_NOTE_HASH_READ_REQUESTS_PER_TX, MAX_NULLIFIER_READ_REQUESTS_PER_TX
 },
-    grumpkin_private_key::GrumpkinPrivateKey, hash::poseidon2_hash, traits::is_empty,
+    embedded_curve_scalar::EmbeddedCurveScalar, hash::poseidon2_hash, traits::is_empty,
     utils::arrays::filter_array_to_bounded_vec
 };
 

noir-projects/noir-protocol-circuits/crates/reset-kernel-lib/src/reset/key_validation_hint.nr

@@ -1,18 +1,18 @@
 use dep::types::{
     traits::{Empty, is_empty}, abis::{validation_requests::ScopedKeyValidationRequestAndGenerator},
-    constants::MAX_KEY_VALIDATION_REQUESTS_PER_TX, grumpkin_private_key::GrumpkinPrivateKey,
+    constants::MAX_KEY_VALIDATION_REQUESTS_PER_TX, embedded_curve_scalar::EmbeddedCurveScalar,
     hash::poseidon2_hash, utils::arrays::filter_array_to_bounded_vec
 };
 
 struct KeyValidationHint {
-  sk_m: GrumpkinPrivateKey,
+  sk_m: EmbeddedCurveScalar,
   request_index: u64,
 }
 
 impl Empty for KeyValidationHint {
     fn empty() -> Self {
         KeyValidationHint {
-            sk_m: GrumpkinPrivateKey::empty(),
+            sk_m: EmbeddedCurveScalar::empty(),
             request_index: 0,
         }
     }
@@ -51,7 +51,7 @@ pub fn reset_key_validation_requests<N>(
 
             // Then we check that siloing the master secret key with the contract address gives the app secret key
 
-            let sk_app = poseidon2_hash([sk_m.high, sk_m.low, contract_address.to_field(), sk_app_generator]);
+            let sk_app = poseidon2_hash([sk_m.hi, sk_m.lo, contract_address.to_field(), sk_app_generator]);
             assert(
                 sk_app.eq(request.sk_app), "Failed to derive matching app secret key from the secret key."
             );

noir-projects/noir-protocol-circuits/crates/types/src/embedded_curve_scalar.nr

@@ -0,0 +1,8 @@
+use dep::std::embedded_curve_ops::EmbeddedCurveScalar;
+use crate::{embedded_curve_point::EmbeddedCurvePoint, traits::Empty};
+
+impl Empty for EmbeddedCurveScalar {
+    fn empty() -> Self {
+        Self { hi: 0, lo: 0 }
+    }
+}

noir-projects/noir-protocol-circuits/crates/types/src/lib.nr

@@ -2,7 +2,7 @@ mod utils;
 mod address;
 mod debug_log;
 mod point;
-mod grumpkin_private_key;
+mod embedded_curve_scalar;
 // This is intentionally spelled like this 
 // since contract is a reserved keyword, so it cannot 
 // be used as an ident.

noir/noir-repo/noir_stdlib/src/embedded_curve_ops.nr

@@ -56,13 +56,28 @@ struct EmbeddedCurveScalar {
 }
 
 impl EmbeddedCurveScalar {
+    pub fn new(hi: Field, lo: Field) -> Self {
+        EmbeddedCurveScalar { hi, lo }
+    }
+
+    pub fn derive_public_key(self) -> EmbeddedCurvePoint {
+        let public_key = fixed_base_scalar_mul(self.lo, self.hi);
+        EmbeddedCurvePoint { x: public_key[0], y: public_key[1], is_infinite: false }
+    }
+
     #[field(bn254)]
     fn from_field(scalar: Field) -> EmbeddedCurveScalar {
         let (a,b) = crate::field::bn254::decompose(scalar);
         EmbeddedCurveScalar { lo: a, hi: b }
     }
 }
 
+impl Eq for EmbeddedCurveScalar {
+    fn eq(self, key: EmbeddedCurveScalar) -> bool {
+        (key.hi == self.hi) & (key.lo == self.lo)
+    }
+}
+
 // Computes a multi scalar multiplication over the embedded curve.
 // For bn254, We have Grumpkin and Baby JubJub.
 // For bls12-381, we have JubJub and Bandersnatch.