update v1 to use more user friendly names

scripts/v1/SimpleStruct.ts

@@ -7,15 +7,16 @@ const types = {
     { name: "chainId", type: "shortstring" },
     { name: "revision", type: "shortstring" },
   ],
+  // In V1 we privilege user friendly names
   SimpleStruct: [
-    { name: "some_felt252", type: "felt" },
-    { name: "some_u128", type: "u128" },
+    { name: "Some felt252", type: "felt" },
+    { name: "Some u128", type: "u128" },
   ],
 };
 
 interface SimpleStruct {
-  some_felt252: string;
-  some_u128: string;
+  someFelt252: string;
+  someU128: string;
 }
 
 function getDomain(chainId: string): StarknetDomain {
@@ -38,13 +39,13 @@ function getTypedData(myStruct: SimpleStruct, chainId: string): TypedData {
     types,
     primaryType: "SimpleStruct",
     domain: getDomain(chainId),
-    message: { ...myStruct },
+    message: { "Some felt252": myStruct.someFelt252, "Some u128": myStruct.someU128 },
   };
 }
 
 const simpleStruct: SimpleStruct = {
-  some_felt252: "712",
-  some_u128: "42",
+  someFelt252: "712",
+  someU128: "42",
 };
 
 console.log(`test test_valid_hash ${getTypedDataHash(simpleStruct, "0", 420n)};`);

scripts/v1/StructWithArray.ts

@@ -7,15 +7,16 @@ const types = {
     { name: "chainId", type: "shortstring" },
     { name: "revision", type: "shortstring" },
   ],
+  // In V1 we privilege user friendly names
   StructWithArray: [
-    { name: "some_felt252", type: "felt" },
-    { name: "some_array", type: "felt*" },
+    { name: "Some felt252", type: "felt" },
+    { name: "Some array", type: "felt*" },
   ],
 };
 
 interface StructWithArray {
-  some_felt252: string;
-  some_array: string[];
+  someFelt252: string;
+  someArray: string[];
 }
 
 function getDomain(chainId: string): StarknetDomain {
@@ -38,13 +39,13 @@ function getTypedData(myStruct: StructWithArray, chainId: string): TypedData {
     types,
     primaryType: "StructWithArray",
     domain: getDomain(chainId),
-    message: { ...myStruct },
+    message: { "Some felt252": myStruct.someFelt252, "Some array": myStruct.someArray},
   };
 }
 
 const structWithArray: StructWithArray = {
-  some_felt252: "712",
-  some_array: ["4", "2"],
+  someFelt252: "712",
+  someArray: ["4", "2"],
 };
 
 console.log(`test test_valid_hash ${getTypedDataHash(structWithArray, "0", 420n)};`);

scripts/v1/StructWithMerkletree.ts

@@ -7,16 +7,17 @@ const types = {
     { name: "chainId", type: "shortstring" },
     { name: "revision", type: "shortstring" },
   ],
+  // In V1 we privilege user friendly names
   StructWithMerkletree: [
-    { name: "some_felt252", type: "felt" },
-    { name: "some_merkletree_root", type: "merkletree", contains: "SomeLeaf" },
+    { name: "Some felt252", type: "felt" },
+    { name: "Some merkletree root", type: "merkletree", contains: "SomeLeaf" },
   ],
   SomeLeaf: [{ name: "contract_address", type: "ContractAddress" }],
 };
 
 interface StructWithMerkletree {
-  some_felt252: string;
-  some_merkletree_root: SomeLeaf[];
+  someFelt252: string;
+  someMerkletreeRoot: SomeLeaf[];
 }
 
 export interface SomeLeaf {
@@ -43,13 +44,13 @@ function getTypedData(myStruct: StructWithMerkletree, chainId: string): TypedDat
     types,
     primaryType: "StructWithMerkletree",
     domain: getDomain(chainId),
-    message: { ...myStruct },
+    message: { "Some felt252": myStruct.someFelt252, "Some merkletree root": myStruct.someMerkletreeRoot },
   };
 }
 
 const structWithMerkletree: StructWithMerkletree = {
-  some_felt252: "712",
-  some_merkletree_root: [{ contract_address: "0x1" }, { contract_address: "0x2" }],
+  someFelt252: "712",
+  someMerkletreeRoot: [{ contract_address: "0x1" }, { contract_address: "0x2" }],
 };
 
 console.log(`test test_valid_hash ${getTypedDataHash(structWithMerkletree, "0", 420n)};`);

scripts/v1/StructWithString.ts

@@ -7,15 +7,16 @@ const types = {
     { name: "chainId", type: "shortstring" },
     { name: "revision", type: "shortstring" },
   ],
+  // In V1 we privilege user friendly names
   StructWithString: [
-    { name: "some_felt252", type: "felt" },
-    { name: "some_string", type: "string" },
+    { name: "Some felt252", type: "felt" },
+    { name: "Some string", type: "string" },
   ],
 };
 
 interface StructWithString {
-  some_felt252: string;
-  some_string: string;
+  someFelt252: string;
+  someString: string;
 }
 
 function getDomain(chainId: string): StarknetDomain {
@@ -38,13 +39,13 @@ function getTypedData(myStruct: StructWithString, chainId: string): TypedData {
     types,
     primaryType: "StructWithString",
     domain: getDomain(chainId),
-    message: { ...myStruct },
+    message: { "Some felt252": myStruct.someFelt252, "Some string": myStruct.someString },
   };
 }
 
 const structWithByteArray: StructWithString = {
-  some_felt252: "712",
-  some_string: "Some long message that exceeds 31 characters",
+  someFelt252: "712",
+  someString: "Some long message that exceeds 31 characters",
 };
 
 console.log(`test test_valid_hash ${getTypedDataHash(structWithByteArray, "0", 420n)};`);

scripts/v1/StructWithU256.ts

@@ -7,9 +7,10 @@ const types = {
     { name: "chainId", type: "shortstring" },
     { name: "revision", type: "shortstring" },
   ],
+  // In V1 we privilege user friendly names
   StructWithU256: [
-    { name: "some_felt252", type: "felt" },
-    { name: "some_u256", type: "u256" },
+    { name: "Some felt252", type: "felt" },
+    { name: "Some u256", type: "u256" },
   ],
   u256: [
     { name: "low", type: "felt" },
@@ -18,8 +19,8 @@ const types = {
 };
 
 interface StructWithU256 {
-  some_felt252: string;
-  some_u256: Uint256;
+  someFelt252: string;
+  someU256: Uint256;
 }
 
 function getDomain(chainId: string): StarknetDomain {
@@ -42,13 +43,13 @@ function getTypedData(myStruct: StructWithU256, chainId: string): TypedData {
     types,
     primaryType: "StructWithU256",
     domain: getDomain(chainId),
-    message: { ...myStruct },
+    message: { "Some felt252": myStruct.someFelt252, "Some u256": myStruct.someU256 },
   };
 }
 
 const structWithU256: StructWithU256 = {
-  some_felt252: "712",
-  some_u256: uint256.bnToUint256(42),
+  someFelt252: "712",
+  someU256: uint256.bnToUint256(42),
 };
 
 console.log(`test test_valid_hash ${getTypedDataHash(structWithU256, "0", 420n)};`);

src/examples/v1/simple_struct.cairo

@@ -4,7 +4,7 @@ use hash::{HashStateTrait, HashStateExTrait};
 use off_chain_signature::interfaces::{IOffChainMessageHash, IStructHash, v1::StarknetDomain};
 
 const SIMPLE_STRUCT_TYPE_HASH: felt252 =
-    selector!("\"SimpleStruct\"(\"some_felt252\":\"felt\",\"some_u128\":\"u128\")");
+    selector!("\"SimpleStruct\"(\"Some felt252\":\"felt\",\"Some u128\":\"u128\")");
 
 #[derive(Drop, Copy, Hash)]
 struct SimpleStruct {
@@ -43,7 +43,7 @@ mod tests {
     #[test]
     fn test_valid_hash() {
         // This value was computed using StarknetJS
-        let message_hash = 0x31f29d7fd9a54a5ad9219280638b91734ad8344ed46440bab683e0a3ba9b5f;
+        let message_hash = 0x36d6400355ba0b29321d77f6852ee5139d0e10dae54fdd80e11c24f1ef963c7;
         let simple_struct = SimpleStruct { some_felt252: 712, some_u128: 42 };
         set_caller_address(420.try_into().unwrap());
         assert_eq!(simple_struct.get_message_hash(), message_hash);

src/examples/v1/struct_with_array.cairo

@@ -5,7 +5,7 @@ use hash::{LegacyHash, HashStateTrait, HashStateExTrait};
 use off_chain_signature::interfaces::{IOffChainMessageHash, IStructHash, v1::StarknetDomain};
 
 const STRUCT_WITH_ARRAY_TYPE_HASH: felt252 =
-    selector!("\"StructWithArray\"(\"some_felt252\":\"felt\",\"some_array\":\"felt*\")");
+    selector!("\"StructWithArray\"(\"Some felt252\":\"felt\",\"Some array\":\"felt*\")");
 
 #[derive(Drop, Copy)]
 struct StructWithArray {
@@ -67,7 +67,7 @@ mod tests {
     #[test]
     fn test_valid_hash() {
         // This value was computed using StarknetJS
-        let message_hash = 0x723b50f650b3b037620c51955e482aeb7786fadeb0d7a384ef99278102f038f;
+        let message_hash = 0x6ef360ec9d363c6cf700203278eff2850dc44286f518d2a5eb9481065dc4bfb;
         let mut some_array = ArrayTrait::new();
         some_array.append(4);
         some_array.append(2);

src/examples/v1/struct_with_merkletree.cairo

@@ -5,7 +5,7 @@ use off_chain_signature::interfaces::{IOffChainMessageHash, IStructHash, v1::Sta
 
 const STRUCT_WITH_MERKLETREE_TYPE_HASH: felt252 =
     selector!(
-        "\"StructWithMerkletree\"(\"some_felt252\":\"felt\",\"some_merkletree_root\":\"merkletree\")"
+        "\"StructWithMerkletree\"(\"Some felt252\":\"felt\",\"Some merkletree root\":\"merkletree\")"
     );
 
 #[derive(Drop, Copy, Hash)]
@@ -45,7 +45,7 @@ mod tests {
     #[test]
     fn test_valid_hash() {
         // This value was computed using StarknetJS
-        let message_hash = 0x2a89d9f00b3ead36ea204b956bc9ac862a5e7e0f2ad2bf790322dda9690629e;
+        let message_hash = 0x4a20d0536b5fb562e72ef4c742111b30fd7317409cd1d95ace97055e2476b63;
         let simple_struct = StructWithMerkletree {
             some_felt252: 712,
             some_merkletree_root: 0x12cee444dbe3866ab527d0b89fa884d2f21b6eca0f2dfd8ecd73cb3d7297edc

src/examples/v1/struct_with_string.cairo

@@ -4,7 +4,7 @@ use hash::{HashStateTrait, HashStateExTrait};
 use off_chain_signature::interfaces::{IOffChainMessageHash, IStructHash, v1::StarknetDomain};
 
 const STRUCT_WITH_U256_TYPE_HASH: felt252 =
-    selector!("\"StructWithString\"(\"some_felt252\":\"felt\",\"some_string\":\"string\")");
+    selector!("\"StructWithString\"(\"Some felt252\":\"felt\",\"Some string\":\"string\")");
 
 #[derive(Drop)]
 struct StructWithString {
@@ -58,7 +58,7 @@ mod tests {
     #[test]
     fn test_valid_hash() {
         // This value was computed using StarknetJS
-        let message_hash = 0x48458bddb2f72c9d82fcf26efc35a8134db6dca6e9c7ac33b2814251a7c153e;
+        let message_hash = 0x73af00bf71d41fb165a48b8813cfa1ca29c429324ebbf5ffc732793ecfd8586;
         let simple_struct = StructWithString {
             some_felt252: 712, some_string: "Some long message that exceeds 31 characters"
         };

src/examples/v1/struct_with_u256.cairo

@@ -5,7 +5,7 @@ use off_chain_signature::interfaces::{IOffChainMessageHash, IStructHash, v1::Sta
 
 const STRUCT_WITH_U256_TYPE_HASH: felt252 =
     selector!(
-        "\"StructWithU256\"(\"some_felt252\":\"felt\",\"some_u256\":\"u256\")\"u256\"(\"low\":\"u128\",\"high\":\"u128\")"
+        "\"StructWithU256\"(\"Some felt252\":\"felt\",\"Some u256\":\"u256\")\"u256\"(\"low\":\"u128\",\"high\":\"u128\")"
     );
 
 const U256_TYPE_HASH: felt252 = selector!("\"u256\"(\"low\":\"u128\",\"high\":\"u128\")");
@@ -59,7 +59,7 @@ mod tests {
     #[test]
     fn test_valid_hash() {
         // This value was computed using StarknetJS
-        let message_hash = 0x454092ee54244e714ea5a7afb1ea3371f923e5d0b1418246343446b7bf18cc5;
+        let message_hash = 0xb016dbeda9552a06b8fd446446aa2aa95fa887e72a0afeeac5b99567c60901;
         let simple_struct = StructWithU256 { some_felt252: 712, some_u256: 42 };
         set_caller_address(420.try_into().unwrap());
         assert_eq!(simple_struct.get_message_hash(), message_hash);