Add type aliases for KeyPairs (#3816)

commit-id:8a2fb548

---

**Stack**:
- #3816 ⬅
- #3815
- #3814


⚠️ *Part of a stack created by [spr](https://github.com/ejoffe/spr). Do
not merge manually using the UI - doing so may have unexpected results.*

Author: cptartur

CHANGELOG.md

@@ -9,6 +9,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Forge
 
+#### Added
+
+- `Fuzzable` trait implementations for `bool` and `ContractAddress`
+- Type aliases for `StarkCurveKeyPair`, `Secp256k1CurveKeyPair`, `Secp256r1CurveKeyPair`
+
 #### Changed
 
 - Updated the error message returned when calling a nonexistent method on a contract to better align with the format used by the network

snforge_std/src/byte_array.cairo

@@ -14,10 +14,7 @@ pub fn byte_array_as_felt_array(self: @ByteArray) -> Array<felt252> {
 pub fn try_deserialize_bytearray_error(x: Span<felt252>) -> Result<ByteArray, ByteArray> {
     if x.len() > 0 && *x.at(0) == BYTE_ARRAY_MAGIC {
         let mut x_span = x.slice(1, x.len() - 1);
-        return match Serde::<ByteArray>::deserialize(ref x_span) {
-            Option::Some(x) => Result::Ok(x),
-            Option::None => Result::Err("Malformed input provided"),
-        };
+        return Serde::<ByteArray>::deserialize(ref x_span).ok_or("Malformed input provided");
     }
     Result::Err("Input is not a ByteArray-formatted error")
 }

snforge_std/src/cheatcodes.cairo

@@ -1,4 +1,4 @@
-use starknet::{ClassHash, ContractAddress, contract_address_const};
+use starknet::{ClassHash, ContractAddress};
 use super::cheatcode::execute_cheatcode_and_deserialize;
 pub mod block_hash;
 pub mod contract_class;
@@ -30,7 +30,7 @@ pub fn test_selector() -> felt252 {
 }
 
 pub fn test_address() -> ContractAddress {
-    contract_address_const::<469394814521890341860918960550914>()
+    469394814521890341860918960550914.try_into().expect('Test address should be valid')
 }
 
 /// Mocks contract call to a `function_selector` of a contract at the given address, for `n_times`

snforge_std/src/cheatcodes/contract_class.cairo

@@ -127,7 +127,7 @@ pub fn get_class_hash(contract_address: ContractAddress) -> ClassHash {
 fn _prepare_calldata(
     class_hash: @ClassHash, constructor_calldata: @Array::<felt252>,
 ) -> Array<felt252> {
-    let class_hash: felt252 = class_hash.clone().into();
+    let class_hash: felt252 = (*class_hash).into();
     let mut inputs: Array<felt252> = array![class_hash];
     constructor_calldata.serialize(ref inputs);
     inputs

snforge_std/src/config_types.cairo

@@ -13,7 +13,7 @@ pub enum AvailableGasConfig {
 
 #[derive(Drop, Serde)]
 pub enum BlockId {
-    BlockTag: (),
+    BlockTag,
     BlockHash: felt252,
     BlockNumber: felt252,
 }

snforge_std/src/fuzzable.cairo

@@ -1,4 +1,5 @@
 use core::fmt::Debug;
+use starknet::ContractAddress;
 pub use super::cheatcodes::generate_arg::generate_arg;
 
 const MAX_FELT: felt252 = 0x800000000000011000000000000000000000000000000000000000000000000;
@@ -83,3 +84,27 @@ pub impl FuzzableByteArray1000ASCII of Fuzzable<ByteArray> {
         ba
     }
 }
+
+pub impl FuzzableBool of Fuzzable<bool> {
+    fn blank() -> bool {
+        false
+    }
+
+    fn generate() -> bool {
+        generate_arg(0, 1) == 1
+    }
+}
+
+pub impl FuzzableContractAddress of Fuzzable<ContractAddress> {
+    fn blank() -> ContractAddress {
+        0x1.try_into().expect('0x1 should be a valid address')
+    }
+
+    fn generate() -> ContractAddress {
+        // [0, 2 ** 251)
+        let arg = generate_arg(
+            0x0, 3618502788666131106986593281521497120414687020801267626233049500247285301247,
+        );
+        arg.try_into().expect('Should be a valid address')
+    }
+}

snforge_std/src/signature/secp256k1_curve.cairo

@@ -7,8 +7,10 @@ use starknet::secp256k1::Secp256k1Point;
 use crate::cheatcode::execute_cheatcode_and_deserialize;
 use super::SignError;
 
+pub type Secp256k1CurveKeyPair = KeyPair<u256, Secp256k1Point>;
+
 pub impl Secp256k1CurveKeyPairImpl of KeyPairTrait<u256, Secp256k1Point> {
-    fn generate() -> KeyPair<u256, Secp256k1Point> {
+    fn generate() -> Secp256k1CurveKeyPair {
         let (secret_key, pk_x, pk_y) = execute_cheatcode_and_deserialize::<
             'generate_ecdsa_keys', (u256, u256, u256),
         >(array!['Secp256k1'].span());
@@ -18,7 +20,7 @@ pub impl Secp256k1CurveKeyPairImpl of KeyPairTrait<u256, Secp256k1Point> {
         KeyPair { secret_key, public_key }
     }
 
-    fn from_secret_key(secret_key: u256) -> KeyPair<u256, Secp256k1Point> {
+    fn from_secret_key(secret_key: u256) -> Secp256k1CurveKeyPair {
         if (secret_key == 0_u256
             || secret_key >= Secp256Trait::<Secp256k1Point>::get_curve_size()) {
             core::panic_with_felt252('invalid secret_key');
@@ -32,12 +34,8 @@ pub impl Secp256k1CurveKeyPairImpl of KeyPairTrait<u256, Secp256k1Point> {
     }
 }
 
-pub impl Secp256k1CurveSignerImpl of SignerTrait<
-    KeyPair<u256, Secp256k1Point>, u256, (u256, u256),
-> {
-    fn sign(
-        self: KeyPair<u256, Secp256k1Point>, message_hash: u256,
-    ) -> Result<(u256, u256), SignError> {
+pub impl Secp256k1CurveSignerImpl of SignerTrait<Secp256k1CurveKeyPair, u256, (u256, u256)> {
+    fn sign(self: Secp256k1CurveKeyPair, message_hash: u256) -> Result<(u256, u256), SignError> {
         let mut input = array!['Secp256k1'];
         self.secret_key.serialize(ref input);
         message_hash.serialize(ref input);
@@ -46,12 +44,8 @@ pub impl Secp256k1CurveSignerImpl of SignerTrait<
     }
 }
 
-pub impl Secp256k1CurveVerifierImpl of VerifierTrait<
-    KeyPair<u256, Secp256k1Point>, u256, (u256, u256),
-> {
-    fn verify(
-        self: KeyPair<u256, Secp256k1Point>, message_hash: u256, signature: (u256, u256),
-    ) -> bool {
+pub impl Secp256k1CurveVerifierImpl of VerifierTrait<Secp256k1CurveKeyPair, u256, (u256, u256)> {
+    fn verify(self: Secp256k1CurveKeyPair, message_hash: u256, signature: (u256, u256)) -> bool {
         let (r, s) = signature;
         is_valid_signature::<Secp256k1Point>(message_hash, r, s, self.public_key)
     }

snforge_std/src/signature/secp256r1_curve.cairo

@@ -5,8 +5,10 @@ use starknet::secp256r1::Secp256r1Point;
 use crate::cheatcode::execute_cheatcode_and_deserialize;
 use super::SignError;
 
+pub type Secp256r1CurveKeyPair = KeyPair<u256, Secp256r1Point>;
+
 pub impl Secp256r1CurveKeyPairImpl of KeyPairTrait<u256, Secp256r1Point> {
-    fn generate() -> KeyPair<u256, Secp256r1Point> {
+    fn generate() -> Secp256r1CurveKeyPair {
         let (secret_key, pk_x, pk_y) = execute_cheatcode_and_deserialize::<
             'generate_ecdsa_keys', (u256, u256, u256),
         >(array!['Secp256r1'].span());
@@ -16,7 +18,7 @@ pub impl Secp256r1CurveKeyPairImpl of KeyPairTrait<u256, Secp256r1Point> {
         KeyPair { secret_key, public_key }
     }
 
-    fn from_secret_key(secret_key: u256) -> KeyPair<u256, Secp256r1Point> {
+    fn from_secret_key(secret_key: u256) -> Secp256r1CurveKeyPair {
         if (secret_key == 0_u256
             || secret_key >= Secp256Trait::<Secp256r1Point>::get_curve_size()) {
             core::panic_with_felt252('invalid secret_key');
@@ -30,12 +32,8 @@ pub impl Secp256r1CurveKeyPairImpl of KeyPairTrait<u256, Secp256r1Point> {
     }
 }
 
-pub impl Secp256r1CurveSignerImpl of SignerTrait<
-    KeyPair<u256, Secp256r1Point>, u256, (u256, u256),
-> {
-    fn sign(
-        self: KeyPair<u256, Secp256r1Point>, message_hash: u256,
-    ) -> Result<(u256, u256), SignError> {
+pub impl Secp256r1CurveSignerImpl of SignerTrait<Secp256r1CurveKeyPair, u256, (u256, u256)> {
+    fn sign(self: Secp256r1CurveKeyPair, message_hash: u256) -> Result<(u256, u256), SignError> {
         let mut input = array!['Secp256r1'];
         self.secret_key.serialize(ref input);
         message_hash.serialize(ref input);
@@ -44,12 +42,8 @@ pub impl Secp256r1CurveSignerImpl of SignerTrait<
     }
 }
 
-pub impl Secp256r1CurveVerifierImpl of VerifierTrait<
-    KeyPair<u256, Secp256r1Point>, u256, (u256, u256),
-> {
-    fn verify(
-        self: KeyPair<u256, Secp256r1Point>, message_hash: u256, signature: (u256, u256),
-    ) -> bool {
+pub impl Secp256r1CurveVerifierImpl of VerifierTrait<Secp256r1CurveKeyPair, u256, (u256, u256)> {
+    fn verify(self: Secp256r1CurveKeyPair, message_hash: u256, signature: (u256, u256)) -> bool {
         let (r, s) = signature;
         is_valid_signature::<Secp256r1Point>(message_hash, r, s, self.public_key)
     }

snforge_std/src/signature/stark_curve.cairo

@@ -4,16 +4,18 @@ use snforge_std::signature::{KeyPair, KeyPairTrait, SignerTrait, VerifierTrait};
 use crate::cheatcode::execute_cheatcode_and_deserialize;
 use super::SignError;
 
+pub type StarkCurveKeyPair = KeyPair<felt252, felt252>;
+
 pub impl StarkCurveKeyPairImpl of KeyPairTrait<felt252, felt252> {
-    fn generate() -> KeyPair<felt252, felt252> {
+    fn generate() -> StarkCurveKeyPair {
         let (secret_key, public_key) = execute_cheatcode_and_deserialize::<
             'generate_stark_keys', (felt252, felt252),
         >(array![].span());
 
         KeyPair { secret_key, public_key }
     }
 
-    fn from_secret_key(secret_key: felt252) -> KeyPair<felt252, felt252> {
+    fn from_secret_key(secret_key: felt252) -> StarkCurveKeyPair {
         if (secret_key == 0) {
             core::panic_with_felt252('invalid secret_key');
         }
@@ -28,23 +30,19 @@ pub impl StarkCurveKeyPairImpl of KeyPairTrait<felt252, felt252> {
     }
 }
 
-pub impl StarkCurveSignerImpl of SignerTrait<
-    KeyPair<felt252, felt252>, felt252, (felt252, felt252),
-> {
+pub impl StarkCurveSignerImpl of SignerTrait<StarkCurveKeyPair, felt252, (felt252, felt252)> {
     fn sign(
-        self: KeyPair<felt252, felt252>, message_hash: felt252,
+        self: StarkCurveKeyPair, message_hash: felt252,
     ) -> Result<(felt252, felt252), SignError> {
         execute_cheatcode_and_deserialize::<
             'stark_sign_message',
         >(array![self.secret_key, message_hash].span())
     }
 }
 
-pub impl StarkCurveVerifierImpl of VerifierTrait<
-    KeyPair<felt252, felt252>, felt252, (felt252, felt252),
-> {
+pub impl StarkCurveVerifierImpl of VerifierTrait<StarkCurveKeyPair, felt252, (felt252, felt252)> {
     fn verify(
-        self: KeyPair<felt252, felt252>, message_hash: felt252, signature: (felt252, felt252),
+        self: StarkCurveKeyPair, message_hash: felt252, signature: (felt252, felt252),
     ) -> bool {
         let (r, s) = signature;
         check_ecdsa_signature(message_hash, self.public_key, r, s)

snforge_std/src/trace.cairo

@@ -1,4 +1,4 @@
-use core::starknet::ContractAddress;
+use starknet::ContractAddress;
 use crate::cheatcode::execute_cheatcode_and_deserialize;
 
 /// Tree-like structure which contains all of the starknet calls and sub-calls along with the