Migrate to starknet foundry::deploy contracts using snforge in test

onchain/Scarb.toml

@@ -6,9 +6,18 @@ version = "0.1.0"
 starknet = "2.6.0"
 openzeppelin = { git = "https://github.com/openzeppelin/cairo-contracts", branch = "main" }
 
+[dev-dependencies]
+snforge_std = { git = "https://github.com/foundry-rs/starknet-foundry", tag = "v0.25.0" }
+
 [tool.fmt]
 sort-module-level-items = true
 
 [[target.starknet-contract]]
 sierra = true
 casm = true
+
+build-external-contracts = [
+"openzeppelin::account::account::Account",
+"openzeppelin::presets::account::AccountUpgradeable",
+"openzeppelin::presets::erc20::ERC20Upgradeable",
+]

onchain/src/components/freeze/freeze_test.cairo

@@ -10,6 +10,20 @@ use super::freeze_mock::{AdminMock, COMPONENT};
 use vault::components::AdminComponent::AdminTraitDispatcherTrait;
 use vault::tests::{utils, constants};
 
+use snforge_std::{
+    declare, ContractClassTrait, start_cheat_caller_address, stop_cheat_caller_address
+};
+
+const USER_ONE: felt252 = 'BOB';
+const USER_TWO: felt252 = 'ALICE';
+const USER_THREE: felt252 = 'ROB';
+
+const USER_ONE_ADDR: felt252 = 0x2;
+const OWNER_ADDR: felt252 = 0x1;
+const ZERO_ADDR: felt252 = 0x0;
+
+
+
 /// Deploys the tx approval contract + approver.
 fn setup_contracts() -> (AdminTraitDispatcher, ERC20UpgradeableABIDispatcher, ContractAddress) {
     // Deploy admin signer
@@ -24,7 +38,8 @@ fn setup_contracts() -> (AdminTraitDispatcher, ERC20UpgradeableABIDispatcher, Co
     ];
 
     // deploy manageable
-    let manageable_address = utils::deploy(AdminMock::TEST_CLASS_HASH, :calldata);
+    let manageable_address = utils::deploy_er20_upgradeable(calldata);
+
 
     // send SUPPLY tokens to manageable
     testing::set_contract_address(admin_address);
@@ -146,32 +161,46 @@ fn test_freeze_internal_not_admin() {
 #[test]
 fn test_freeze_internal_admin() {
     let mut component = COMPONENT();
-    let address = contract_address_const::<0x123>();
 
+    let address = contract_address_const::<0x123>();
+    let admin_address = utils::setup_signer().contract_address;
+
+    // start_prank(CheatTarget::One(admin_address), admin_address);
+    // start_cheat_caller_address(land_contract_address, OWNER_ADDR.try_into().unwrap());
+    start_cheat_caller_address(admin_address, USER_ONE.try_into().unwrap());
     // Init component to set admin address to 0x123.
-    component.initializer(address, address, address);
+    component.initializer(admin_address, address, address);
 
-    // Call with the right address.
-    testing::set_caller_address(address);
+
     component.freeze_internal();
 
     assert!(component.is_frozen_internal());
+
+    // stop_prank(CheatTarget::One(admin_address),);
+    stop_cheat_caller_address(admin_address);
+
 }
 
 #[test]
 fn test_freeze_internal_admin_already_frozen() {
     let mut component = COMPONENT();
     let address = contract_address_const::<0x123>();
-
+
+    let admin_address = utils::setup_signer().contract_address;
+     start_cheat_caller_address(admin_address, USER_ONE.try_into().unwrap());
+  //  start_prank(CheatTarget::One(admin_address), admin_address);
     // Init component to set admin address to 0x123.
-    component.initializer(address, address, address);
+   component.initializer(admin_address, address, address);
 
-    // Call with the right address.
-    testing::set_caller_address(address);
+
     component.freeze_internal();
     component.freeze_internal();
 
     assert!(component.is_frozen_internal());
+
+    // stop_prank(CheatTarget::One(admin_address),);
+     stop_cheat_caller_address(admin_address);
+
 }
 
 #[test]
@@ -267,21 +296,33 @@ fn test_assert_only_admin_admin() {
     let mut component = COMPONENT();
     let address = contract_address_const::<0x123>();
 
+   //  start_prank(CheatTarget::One(address), USER_ONE.try_into().unwrap());
+    start_cheat_caller_address(address, USER_ONE.try_into().unwrap());
     // Init component to set admin address to 0x123.
     component.initializer(address, address, address);
 
-    testing::set_caller_address(address);
-    component.assert_only_admin();
+
+    let check_admin = component.assert_only_admin();
+     assert!(check_admin != (), "Only admin");
+   // stop_prank(CheatTarget::One(address),);
+    stop_cheat_caller_address(address);
 }
 
 #[test]
 #[should_panic(expected: "Only admin")]
 fn test_assert_only_admin_not_admin() {
     let mut component = COMPONENT();
     let address = contract_address_const::<0x123>();
+    let dispatch_user = contract_address_const::<1>();
 
+   //  start_prank(CheatTarget::One(dispatch_user), USER_ONE.try_into().unwrap());
+    start_cheat_caller_address(dispatch_user, USER_ONE.try_into().unwrap());
     // Init component to set admin address to 0x123.
     component.initializer(address, address, address);
 
     component.assert_only_admin();
+
+   //  stop_prank(CheatTarget::One(dispatch_user),);
+    stop_cheat_caller_address(dispatch_user);
+
 }

onchain/src/components/tx_approval/tx_approval_test.cairo

@@ -32,7 +32,7 @@ fn setup_contracts() -> (TestExternalDispatcher, ContractAddress, ContractAddres
     // Deploy approval mock contract with approver address.
     let calldata: Array<felt252> = array![approver_address.into()];
 
-    let approval_address = utils::deploy(TransactionApprovalMock::TEST_CLASS_HASH, :calldata);
+    let approval_address = utils::deploy_er20_upgradeable(calldata);
 
     // Deploy ERC20
     let erc20_address = utils::setup_erc20(recipient: approval_address).contract_address;

onchain/src/tests/utils.cairo

@@ -7,11 +7,39 @@ use openzeppelin::presets::interfaces::{
 use openzeppelin::presets::{ERC20Upgradeable, AccountUpgradeable};
 use openzeppelin::token::erc20::dual20::DualCaseERC20Trait;
 use openzeppelin::utils::serde::SerializedAppend;
+use snforge_std as snf;
+use snforge_std::{declare, ContractClassTrait};
+
+
 use starknet::{testing, ContractAddress, contract_address_const};
 use super::constants;
 use vault::contracts::VaultAccount;
 use vault::contracts::account::interface::{IVaultAccountDispatcher, IVaultAccountDispatcherTrait};
 
+
+fn deploy_vault(calldata: Array<felt252>) -> starknet::ContractAddress {
+    let contract_class_hash = declare("VaultAccount").unwrap();
+
+    let (address, _) = contract_class_hash.deploy(@calldata).unwrap_syscall();
+
+    return address;
+}
+
+fn deploy_account_upgradeable(calldata: Array<felt252>) -> starknet::ContractAddress {
+    let contract_class_hash = declare("AccountUpgradeable").unwrap();
+    let (address, _) = contract_class_hash.deploy(@calldata).unwrap_syscall();
+
+    return address;
+}
+
+fn deploy_er20_upgradeable(calldata: Array<felt252>) -> starknet::ContractAddress {
+    let contract_class_hash = declare("ERC20Upgradeable").unwrap();
+
+    let (address, _) = contract_class_hash.deploy(@calldata).unwrap_syscall();
+
+    return address;
+}
+
 fn deploy(contract_class_hash: felt252, calldata: Array<felt252>) -> starknet::ContractAddress {
     let (address, _) = starknet::deploy_syscall(
         contract_class_hash.try_into().unwrap(), 0, calldata.span(), false
@@ -31,22 +59,43 @@ fn setup_erc20(recipient: ContractAddress) -> ERC20UpgradeableABIDispatcher {
     calldata.append_serde(recipient);
 
     // deploy
-    let address = deploy(ERC20Upgradeable::TEST_CLASS_HASH, calldata);
+    let address = deploy_er20_upgradeable(calldata);
+
+    // deploy(ERC20Upgradeable::TEST_CLASS_HASH, calldata);
 
     ERC20UpgradeableABIDispatcher { contract_address: address }
 }
 
+// fn setup_erc20_deploy(recipient: ContractAddress) -> ERC20UpgradeableABIDispatcher {
+//     let mut calldata = array![];
+
+//     calldata.append_serde(constants::NAME());
+//     calldata.append_serde(constants::SYMBOL());
+//     calldata.append_serde(constants::SUPPLY); // 1 ETH
+//     calldata.append_serde(recipient);
+//     calldata.append_serde(recipient);
+
+//     // let (contract_address, _) = deploy_sn("ERC20Upgradeable", @callData)
+
+//     let contract_address = deploy_er20_upgradeable(calldata);
+
+//     ERC20UpgradeableABIDispatcher { contract_address: contract_address }
+// }
+
 fn setup_vault_account() -> IVaultAccountDispatcher {
     setup_custom_vault_account(
         approver: contract_address_const::<0>(), limit: u256 { low: 2, high: 2 }
     )
 }
 
+
 fn setup_custom_vault_account(approver: ContractAddress, limit: u256) -> IVaultAccountDispatcher {
     let calldata = array![];
 
     // deploy
-    let address = deploy(VaultAccount::TEST_CLASS_HASH, calldata);
+    let address = deploy_vault(calldata);
+
+
 
     let (pub_key_x, pub_key_y) = constants::P256_PUBLIC_KEY;
 
@@ -65,7 +114,7 @@ fn setup_custom_signer(public_key: felt252) -> AccountUpgradeableABIDispatcher {
     let calldata = array![public_key];
 
     // deploy
-    let address = deploy(AccountUpgradeable::TEST_CLASS_HASH, calldata);
+     let address = deploy_account_upgradeable(calldata);
 
     AccountUpgradeableABIDispatcher { contract_address: address }
 }