General cheatcode

.gitignore

@@ -3,4 +3,4 @@
 .idea/
 .spr.yml
 node_modules
-.DS_Store
+.DS_Store

Cargo.toml

@@ -36,6 +36,7 @@ members = [
     "crates/bin/cairo-format",
     "crates/bin/cairo-test",
     "crates/bin/cairo-run",
+    "crates/bin/sierra-compile",
     "crates/bin/starknet-compile",
     "crates/bin/starknet-sierra-compile",
     "crates/bin/generate-syntax",

corelib/src/cheatcodes.cairo

@@ -1,28 +1,17 @@
 use array::ArrayTrait;
-use option::OptionTrait;
+use array::SpanTrait;
 use clone::Clone;
+use integer::Into;
+use integer::TryInto;
+use option::OptionTrait;
+use starknet::testing::cheatcode;
 
-extern fn start_roll(
-    block_number: felt252, target_contract_address: felt252
-) -> Result::<(), felt252> nopanic;
-
-extern fn stop_roll(target_contract_address: felt252) -> Result::<(), felt252> nopanic;
-
-extern fn start_warp(
-    block_timestamp: felt252, target_contract_address: felt252
-) -> Result::<(), felt252> nopanic;
-
-extern fn stop_warp(target_contract_address: felt252) -> Result::<(), felt252> nopanic;
-
-extern fn start_prank(
-    caller_address: felt252, target_contract_address: felt252
-) -> Result::<(), felt252> nopanic;
-
-extern fn stop_prank(target_contract_address: felt252) -> Result::<(), felt252> nopanic;
-
-extern fn declare(contract: felt252) -> Result::<felt252, felt252> nopanic;
-
-extern fn declare_cairo0(contract: felt252) -> Result::<felt252, felt252> nopanic;
+#[derive(Drop, Clone)]
+struct PreparedContract {
+    contract_address: felt252,
+    class_hash: felt252,
+    constructor_calldata: Span::<felt252>,
+}
 
 #[derive(Drop, Clone)]
 struct RevertedTransaction {
@@ -35,146 +24,64 @@ trait RevertedTransactionTrait {
 
 impl RevertedTransactionImpl of RevertedTransactionTrait {
     fn first(self: @RevertedTransaction) -> felt252 {
-        *self.panic_data.at(0_usize)
+        *self.panic_data.at(0)
     }
 }
 
-extern fn invoke_impl(
-    contract_address: felt252, function_name: felt252, calldata: @Array::<felt252>
-) -> Result::<(), Array<felt252>> nopanic;
-
-fn invoke(
-    contract_address: felt252, function_name: felt252, calldata: @Array::<felt252>
-) -> Result::<(), RevertedTransaction> nopanic {
-    match invoke_impl(contract_address, function_name, calldata) {
-        Result::Ok(x) => Result::<(), RevertedTransaction>::Ok(x),
-        Result::Err(x) => Result::<(),
-        RevertedTransaction>::Err(RevertedTransaction { panic_data: x,  })
-    }
-}
+fn declare(contract: felt252) -> Result::<felt252, felt252> {
+    let span = cheatcode::<'declare'>(array![contract].span());
 
-extern fn mock_call(
-    contract_address: felt252, function_name: felt252, response: @Array::<felt252>
-) -> Result::<(), felt252> nopanic;
+    let exit_code = *span[0];
+    let result = *span[1];
 
-#[derive(Drop, Clone)]
-struct PreparedContract {
-    contract_address: felt252,
-    class_hash: felt252,
-    constructor_calldata: @Array::<felt252>,
-}
-
-// returns deployed `contract_address`
-extern fn deploy_impl(
-    prepared_contract_address: felt252,
-    prepared_class_hash: felt252,
-    prepared_constructor_calldata: @Array::<felt252>
-) -> Result::<felt252, Array<felt252>> nopanic;
-
-fn deploy(prepared_contract: PreparedContract) -> Result::<felt252, RevertedTransaction> nopanic {
-    let PreparedContract{contract_address, class_hash, constructor_calldata } = prepared_contract;
-    match deploy_impl(contract_address, class_hash, constructor_calldata) {
-        Result::Ok(x) => Result::<felt252, RevertedTransaction>::Ok(x),
-        Result::Err(x) => Result::<felt252,
-        RevertedTransaction>::Err(RevertedTransaction { panic_data: x,  })
+    if exit_code == 0 {
+        Result::<felt252, felt252>::Ok(result)
+    } else {
+        Result::<felt252, felt252>::Err(result)
     }
 }
 
-extern fn prepare_impl(
-    class_hash: felt252, calldata: @Array::<felt252>
-) -> Result::<(Array::<felt252>, felt252, felt252), felt252> nopanic;
-
-fn prepare(
-    class_hash: felt252, calldata: @Array::<felt252>
-) -> Result::<PreparedContract, felt252> nopanic {
-    match prepare_impl(class_hash, calldata) {
-        Result::Ok((
-            constructor_calldata, contract_address, class_hash
-        )) => Result::<PreparedContract,
-        felt252>::Ok(
-            PreparedContract {
-                constructor_calldata: @constructor_calldata,
-                contract_address: contract_address,
-                class_hash: class_hash,
+fn deploy(prepared_contract: PreparedContract) -> Result::<felt252, RevertedTransaction> {
+    let PreparedContract{contract_address, class_hash, mut constructor_calldata } =
+        prepared_contract;
+    let mut inputs = array![contract_address, class_hash];
+
+    let calldata_len = constructor_calldata.len().into();
+    inputs.append(calldata_len);
+
+    loop {
+        match constructor_calldata.pop_front() {
+            Option::Some(value) => {
+                inputs.append(*value);
+            },
+            Option::None(_) => {
+                break ();
+            },
+        };
+    };
+
+    let outputs = cheatcode::<'deploy'>(inputs.span());
+    let exit_code = *outputs[0];
+
+    if exit_code == 0 {
+        let result = *outputs[1];
+        Result::<felt252, RevertedTransaction>::Ok(result)
+    } else {
+        // TODO: feel free to change depending on the cheatcode::<'deploy'> low level implementation of error handling
+        let panic_data_len_felt = *outputs[1];
+        let panic_data_len = panic_data_len_felt.try_into().unwrap();
+        let mut panic_data = array![];
+
+        let mut i = 2;
+        loop {
+            if panic_data_len + 2 == i {
+                break ();
             }
-        ),
-        Result::Err(x) => Result::<PreparedContract, felt252>::Err(x)
-    }
-}
-
-fn deploy_contract(
-    contract: felt252, calldata: @Array::<felt252>
-) -> Result::<felt252, RevertedTransaction> {
-    let mut class_hash: Option::<felt252> = Option::None(());
-    match declare(contract) {
-        Result::Ok(x) => {
-            class_hash = Option::Some(x);
-        },
-        Result::Err(x) => {
-            let mut panic_data = ArrayTrait::new();
-            panic_data.append(x);
-
-            return Result::<felt252, RevertedTransaction>::Err(RevertedTransaction { panic_data });
-        }
-    }
-
-    let mut prepared_contract: Option::<PreparedContract> = Option::None(());
-    match prepare(class_hash.unwrap(), calldata) {
-        Result::Ok(x) => {
-            prepared_contract = Option::Some(x);
-        },
-        Result::Err(x) => {
-            let mut panic_data = ArrayTrait::new();
-            panic_data.append(x);
-
-            return Result::<felt252, RevertedTransaction>::Err(RevertedTransaction { panic_data });
-        }
-    }
-    deploy(prepared_contract.unwrap())
-}
-
-fn deploy_contract_cairo0(
-    contract: felt252, calldata: @Array::<felt252>
-) -> Result::<felt252, RevertedTransaction> {
-    let mut class_hash: Option::<felt252> = Option::None(());
-    match declare_cairo0(contract) {
-        Result::Ok(x) => {
-            class_hash = Option::Some(x);
-        },
-        Result::Err(x) => {
-            let mut panic_data = ArrayTrait::new();
-            panic_data.append(x);
-
-            return Result::<felt252, RevertedTransaction>::Err(RevertedTransaction { panic_data });
-        }
-    }
-
-    let mut prepared_contract: Option::<PreparedContract> = Option::None(());
-    match prepare(class_hash.unwrap(), calldata) {
-        Result::Ok(x) => {
-            prepared_contract = Option::Some(x);
-        },
-        Result::Err(x) => {
-            let mut panic_data = ArrayTrait::new();
-            panic_data.append(x);
-
-            return Result::<felt252, RevertedTransaction>::Err(RevertedTransaction { panic_data });
-        }
-    }
-    deploy(prepared_contract.unwrap())
-}
-
-extern fn call_impl(
-    contract: felt252, function_name: felt252, calldata: @Array::<felt252>
-) -> Result::<Array<felt252>, Array<felt252>> nopanic;
-
+            let value = *outputs[i];
+            panic_data.append(value);
+            i += 1;
+        };
 
-fn call(
-    contract: felt252, function_name: felt252, calldata: @Array::<felt252>
-) -> Result::<Array<felt252>, RevertedTransaction> nopanic {
-    match call_impl(contract, function_name, calldata) {
-        Result::Ok(x) => Result::<Array<felt252>, RevertedTransaction>::Ok(x),
-        Result::Err(x) => Result::<Array<felt252>,
-        RevertedTransaction>::Err(RevertedTransaction { panic_data: x,  })
+        Result::<felt252, RevertedTransaction>::Err(RevertedTransaction { panic_data })
     }
 }

corelib/src/lib.cairo

@@ -310,24 +310,9 @@ use starknet::System;
 
 // Cheatcodes
 mod cheatcodes;
-use cheatcodes::start_roll;
-use cheatcodes::stop_roll;
 use cheatcodes::declare;
-use cheatcodes::declare_cairo0;
-use cheatcodes::start_prank;
-use cheatcodes::stop_prank;
-use cheatcodes::start_warp;
-use cheatcodes::stop_warp;
-use cheatcodes::invoke;
-use cheatcodes::mock_call;
 use cheatcodes::deploy;
-use cheatcodes::deploy_impl;
 use cheatcodes::PreparedContract;
-use cheatcodes::prepare_impl;
-use cheatcodes::prepare;
-use cheatcodes::deploy_contract;
-use cheatcodes::deploy_contract_cairo0;
-use cheatcodes::call;
 
 mod protostar_print;
 

corelib/src/protostar_print.cairo

@@ -1,14 +1,15 @@
 use array::ArrayTrait;
 use traits::Into;
-use starknet::ContractAddressIntoFelt252;
 use option::Option;
+use starknet::ContractAddressIntoFelt252;
+use starknet::testing::cheatcode;
 
 extern fn print(message: Array<felt252>) nopanic;
 
 fn print_felt252(message: felt252) {
     let mut arr = ArrayTrait::new();
     arr.append(message);
-    print(arr);
+    cheatcode::<'print'>(arr.span());
 }
 
 trait PrintTrait<T> {
@@ -64,6 +65,6 @@ impl U256PrintImpl of PrintTrait<u256> {
 
 impl ArrayGenericPrintImpl of PrintTrait<Array<felt252>> {
     fn print(mut self: Array::<felt252>) {
-        print(self);
+        cheatcode::<'print'>(self.span());
     }
 }

crates/bin/cairo-compile/src/main.rs

@@ -36,7 +36,6 @@ fn main() -> anyhow::Result<()> {
     let sierra_program = compile_cairo_project_at_path(
         &args.path,
         CompilerConfig { replace_ids: args.replace_ids, ..CompilerConfig::default() },
-        None,
     )?;
 
     match args.output {

crates/bin/sierra-compile/src/main.rs

@@ -40,4 +40,4 @@ fn main() -> anyhow::Result<()> {
     .with_context(|| "Compilation failed.")?;
 
     fs::write(args.output, format!("{cairo_program}")).with_context(|| "Failed to write output.")
-}
+}