Use OZ 0.8.1 implementation of STRK and ETH ERC20 token contracts (#750)

Author: FabijanC

crates/starknet-devnet-core/contracts/system_artifacts/ERC20_Mintable_OZ_0.20.0.sierra

@@ -26,12 +26,13 @@ pub const CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH: &str =
 
 pub const CAIRO_1_ERC20_CONTRACT: &str = include_str!(concat!(
     env!("CARGO_MANIFEST_DIR"),
-    "/contracts/system_artifacts/ERC20_Mintable_OZ_0.20.0.sierra"
+    "/contracts/system_artifacts/ERC20_Mintable_OZ_0.8.1.sierra"
 ));
 
-/// Unlike in previous Devnet versions, now using the actual hash of the predeployed artifact
+/// Hardcoded to match the hash of the unchanged OZ ERC20.cairo even despite the changes: commented
+/// attributes in struct Approval (owner, spender), the addition of mintability.
 pub const CAIRO_1_ERC20_CONTRACT_CLASS_HASH: Felt =
-    Felt::from_hex_unchecked("0x011374319a6e07b4f2738fa3bfa8cf2181bfb0dbb4d800215baa87b83a57877e");
+    Felt::from_hex_unchecked("0x046ded64ae2dead6448e247234bab192a9c483644395b66f2155f2614e5804b0");
 
 /// only used in tests; if artifact needed in production, add a new constant that uses include_str!
 pub const CAIRO_0_ERC20_CONTRACT_PATH: &str =

crates/starknet-devnet-core/contracts/system_artifacts/ERC20_Mintable_OZ_0.8.1.sierra

@@ -3,7 +3,6 @@ use starknet_rs_core::types::Felt;
 use starknet_rs_core::utils::cairo_short_string_to_felt;
 use starknet_types::contract_address::ContractAddress;
 use starknet_types::felt::felt_from_prefixed_hex;
-use starknet_types_core::hash::Poseidon;
 
 use crate::constants::{
     CHARGEABLE_ACCOUNT_ADDRESS, UDC_CONTRACT, UDC_CONTRACT_ADDRESS, UDC_CONTRACT_CLASS_HASH,
@@ -23,40 +22,6 @@ pub(crate) fn create_erc20_at_address_extended(
     Ok(erc20_fee_contract)
 }
 
-fn store_short_string_as_byte_array(
-    state: &mut StarknetState,
-    contract_address: ContractAddress,
-    storage_var_name: &str,
-    short_str: &str,
-) -> DevnetResult<()> {
-    let storage_var_address = get_storage_var_address(storage_var_name, &[])?.try_into()?;
-
-    let felt_value =
-        cairo_short_string_to_felt(short_str).map_err(|_| Error::UnexpectedInternalError {
-            msg: format!("Cannot create a ByteArray from {short_str}"),
-        })?;
-
-    state.set_storage_at(
-        contract_address.try_into()?,
-        storage_var_address,
-        short_str.len().into(),
-    )?;
-
-    // That's how ByteArray is defined
-    let capacity_arg = cairo_short_string_to_felt("ByteArray")
-        .map_err(|e| Error::UnexpectedInternalError { msg: e.to_string() })?;
-
-    let chunk_index = Felt::ZERO;
-    let mut hashable = [storage_var_address.into(), chunk_index, capacity_arg];
-    Poseidon::hades_permutation(&mut hashable);
-    let chunk_base = starknet_api::state::StorageKey::try_from(hashable[0])?;
-
-    // no offset in chunk because the word is expected to be short
-    state.set_storage_at(contract_address.try_into()?, chunk_base, felt_value)?;
-
-    Ok(())
-}
-
 /// Set initial values of ERC20 contract storage
 pub(crate) fn initialize_erc20_at_address(
     state: &mut StarknetState,
@@ -66,11 +31,17 @@ pub(crate) fn initialize_erc20_at_address(
 ) -> DevnetResult<()> {
     let contract_address = ContractAddress::new(contract_address)?;
 
-    for (storage_var_name, string) in [("ERC20_name", erc20_name), ("ERC20_symbol", erc20_symbol)] {
-        store_short_string_as_byte_array(state, contract_address, storage_var_name, string)?;
-    }
-
     for (storage_var_name, storage_value) in [
+        (
+            "ERC20_name",
+            cairo_short_string_to_felt(erc20_name)
+                .map_err(|err| Error::UnexpectedInternalError { msg: err.to_string() })?,
+        ),
+        (
+            "ERC20_symbol",
+            cairo_short_string_to_felt(erc20_symbol)
+                .map_err(|err| Error::UnexpectedInternalError { msg: err.to_string() })?,
+        ),
         ("ERC20_decimals", 18.into()),
         // necessary to set - otherwise minting txs cannot be executed
         ("Ownable_owner", felt_from_prefixed_hex(CHARGEABLE_ACCOUNT_ADDRESS)?),

crates/starknet-devnet-core/contracts/system_artifacts/compilation_info.txt

@@ -41,7 +41,7 @@ pub const CAIRO_1_ACCOUNT_CONTRACT_0_8_0_SIERRA_PATH: &str = concat!(
 
 // system contracts
 pub const CAIRO_1_ERC20_CONTRACT_CLASS_HASH: Felt =
-    Felt::from_hex_unchecked("0x011374319a6e07b4f2738fa3bfa8cf2181bfb0dbb4d800215baa87b83a57877e");
+    Felt::from_hex_unchecked("0x046ded64ae2dead6448e247234bab192a9c483644395b66f2155f2614e5804b0");
 pub const ETH_ERC20_CONTRACT_ADDRESS: Felt =
     Felt::from_hex_unchecked("0x49D36570D4E46F48E99674BD3FCC84644DDD6B96F7C741B1562B82F9E004DC7");
 pub const STRK_ERC20_CONTRACT_ADDRESS: Felt =

crates/starknet-devnet-core/src/constants.rs

@@ -1,7 +1,8 @@
 use serde_json::json;
-use starknet_rs_core::codec::Decode;
-use starknet_rs_core::types::{BlockId, BlockTag, ByteArray, Felt, FunctionCall};
-use starknet_rs_core::utils::{get_selector_from_name, get_storage_var_address};
+use starknet_rs_core::types::{BlockId, BlockTag, Felt, FunctionCall};
+use starknet_rs_core::utils::{
+    get_selector_from_name, get_storage_var_address, parse_cairo_short_string,
+};
 use starknet_rs_providers::Provider;
 
 use crate::common::background_devnet::BackgroundDevnet;
@@ -105,14 +106,14 @@ async fn test_config() {
     assert_eq!(fetched_config, expected_config);
 }
 
-/// Part of the responsibility of this test was transferred to test
-/// `predeployed_erc20_tokens_return_expected_values_from_property_getters`
 #[tokio::test]
 async fn predeployed_erc20_tokens_have_expected_storage() {
     let devnet = BackgroundDevnet::spawn().await.unwrap();
     for (token_address, var_name, expected_value) in [
-        (ETH_ERC20_CONTRACT_ADDRESS, "ERC20_decimals", Felt::from(18)),
-        (STRK_ERC20_CONTRACT_ADDRESS, "ERC20_decimals", Felt::from(18)),
+        (ETH_ERC20_CONTRACT_ADDRESS, "ERC20_name", "Ether"),
+        (ETH_ERC20_CONTRACT_ADDRESS, "ERC20_symbol", "ETH"),
+        (STRK_ERC20_CONTRACT_ADDRESS, "ERC20_name", "StarkNet Token"),
+        (STRK_ERC20_CONTRACT_ADDRESS, "ERC20_symbol", "STRK"),
     ] {
         let actual_value = devnet
             .json_rpc_client
@@ -124,7 +125,7 @@ async fn predeployed_erc20_tokens_have_expected_storage() {
             .await
             .unwrap();
 
-        assert_eq!(actual_value, expected_value);
+        assert_eq!(parse_cairo_short_string(&actual_value).unwrap().as_str(), expected_value);
     }
 }
 
@@ -150,8 +151,7 @@ async fn predeployed_erc20_tokens_return_expected_values_from_property_getters()
             .await
             .unwrap();
 
-        // We expect the felt vector to contain the encoded ByteArray, thus we decode it
-        let actual_string: String = ByteArray::decode(&actual_felts).unwrap().try_into().unwrap();
-        assert_eq!(&actual_string, expected_value);
+        assert_eq!(actual_felts.len(), 1);
+        assert_eq!(parse_cairo_short_string(&actual_felts[0]).unwrap(), expected_value);
     }
 }