chore(blockifier_reexecution): compile sierra to versioned runnable class

[AvivYossef-starkware]

No description provided.

[reviewable-StarkWare]

This change is 

[AvivYossef-starkware]

Warning

This pull request is not mergeable via GitHub because a downstack PR is open. Once all requirements are satisfied, merge this PR as a stack on Graphite.
Learn more

• refactor(blockifier): state reader trait #2681
• chore(papyrus_execution): get versioned contract class #2680
• chore(blockifier_reexecution): compile sierra to versioned runnable class #2679 👈 (View in Graphite)
• chore(blockifier): add get versioned class to feature contract #2678
• chore(blockifier): add erc20 sierra contract #2668 : 1 other dependent PR (#2641 )
• refactor(blockifier): use get versioned contract class in py state reader #2614
• refactor(papyrus_rpc): get compiled class #2493
• feat(papyrus_storage): add sierra version to papyrus cache #2438
• feat(papyrus_storage): get versioned casm #2420 : 1 other dependent PR (#2421 )
• refactor(starknet_integration_tests): add sierra contract class to dummy state #2467
• feat(blockifier): get sierra contract class from feature contract #2466
• main

This stack of pull requests is managed by Graphite. Learn more about stacking.

[dorimedini-starkware]

Reviewed 4 of 4 files at r1, all commit messages.
Reviewable status: all files reviewed, 2 unresolved discussions (waiting on @amosStarkware and @AvivYossef-starkware)

---

crates/blockifier_reexecution/src/state_reader/test_state_reader.rs line 138 at r1 (raw file):

            StarknetContractClass::Sierra(sierra) => {
                let (casm, _) = sierra_to_versioned_contract_class_v1(sierra).unwrap();
                let runnable_contract_class: RunnableCompiledClass = casm.try_into().unwrap();

personally prefer to avoid let x: X = y.into() when you can do let x = X::from(y)
non-blocking

Suggestion:

let runnable_contract_class = RunnableCompiledClass::try_from(casm).unwrap();

---

crates/blockifier_reexecution/src/state_reader/compile.rs line 79 at r1 (raw file):

pub fn sierra_to_versioned_contract_class_v1(
    sierra: FlattenedSierraClass,
) -> StateResult<(ContractClass, SierraVersion)> {

doesn't this tuple type have a name you can use?

Code quote:

(ContractClass, SierraVersion)

---

crates/blockifier_reexecution/src/state_reader/compile.rs line 100 at r1 (raw file):

        .collect::<Vec<u64>>()
        .try_into()
        .expect("Expected exactly 3 elements.");

this version-from-sierra logic is duplicated, no? is this avoidable? I realize the type of the sierra contract isn't the same but is there something you can reuse?
non-blocking

Code quote:

    let [major, minor, patch] = sierra
        .sierra_program
        .clone()
        .into_iter()
        .take(3)
        .map(|big_uint_as_hex| u64::try_from(big_uint_as_hex.value).unwrap())
        .collect::<Vec<u64>>()
        .try_into()
        .expect("Expected exactly 3 elements.");

---

crates/blockifier_reexecution/src/state_reader/offline_state_reader.rs line 163 at r1 (raw file):

        match self.get_contract_class(&class_hash)? {
            StarknetContractClass::Sierra(sierra) => {
                let (casm, _) = sierra_to_versioned_contract_class_v1(sierra).unwrap();

why is this line needed...? where is casm used?

Code quote:

let (casm, _) = sierra_to_versioned_contract_class_v1(sierra).unwrap();