Migrate UDC

src/presets/universal_deployer.cairo

@@ -47,31 +47,16 @@ mod UniversalDeployer {
             calldata: Span<felt252>
         ) -> ContractAddress {
             let deployer: ContractAddress = get_caller_address();
-
-            // Defaults for non-unique deployment
-            let mut _salt: felt252 = salt;
             let from_zero: bool = !unique;
-
+            let mut _salt: felt252 = salt;
             if unique {
                 _salt = pedersen(deployer.into(), salt);
-                from_zero = false;
             }
 
             let (address, _) = starknet::deploy_syscall(class_hash, _salt, calldata, from_zero)
                 .unwrap_syscall();
 
-            self
-                .emit(
-                    ContractDeployed {
-                        address: address,
-                        deployer: deployer,
-                        unique: unique,
-                        class_hash: class_hash,
-                        calldata: calldata,
-                        salt: salt
-                    }
-                );
-
+            self.emit(ContractDeployed { address, deployer, unique, class_hash, calldata, salt });
             return address;
         }
     }

src/tests/presets/test_universal_deployer.cairo

@@ -53,19 +53,15 @@ fn test_deploy_not_unique() {
     assert_eq!(expected_addr, deployed_addr);
 
     // Check event
-    let event = utils::pop_log::<UniversalDeployer::Event>(udc.contract_address).unwrap();
-    let expected = UniversalDeployer::Event::ContractDeployed(
-        ContractDeployed {
-            address: deployed_addr,
-            deployer: CALLER(),
-            unique: unique,
-            class_hash: ERC20_CLASS_HASH(),
-            calldata: ERC20_CALLDATA(),
-            salt: SALT
-        }
+    assert_event_contract_deployed(
+        udc.contract_address,
+        deployed_addr,
+        CALLER(),
+        unique,
+        ERC20_CLASS_HASH(),
+        ERC20_CALLDATA(),
+        SALT
     );
-    assert!(event == expected);
-    utils::assert_no_events_left(udc.contract_address);
 
     // Check deployment
     let erc20 = IERC20Dispatcher { contract_address: deployed_addr };
@@ -88,19 +84,15 @@ fn test_deploy_unique() {
     assert_eq!(expected_addr, deployed_addr);
 
     // Check event
-    let event = utils::pop_log::<UniversalDeployer::Event>(udc.contract_address).unwrap();
-    let expected = UniversalDeployer::Event::ContractDeployed(
-        ContractDeployed {
-            address: deployed_addr,
-            deployer: CALLER(),
-            unique: unique,
-            class_hash: ERC20_CLASS_HASH(),
-            calldata: ERC20_CALLDATA(),
-            salt: SALT
-        }
+    assert_event_contract_deployed(
+        udc.contract_address,
+        deployed_addr,
+        CALLER(),
+        unique,
+        ERC20_CLASS_HASH(),
+        ERC20_CALLDATA(),
+        SALT
     );
-    assert!(event == expected);
-    utils::assert_no_events_left(udc.contract_address);
 
     // Check deployment
     let erc20 = IERC20Dispatcher { contract_address: deployed_addr };
@@ -150,3 +142,20 @@ fn calculate_contract_address_from_hash(
     let felt_addr = u256_addr.try_into().unwrap();
     starknet::contract_address_try_from_felt252(felt_addr).unwrap()
 }
+
+fn assert_event_contract_deployed(
+    contract: ContractAddress,
+    address: ContractAddress,
+    deployer: ContractAddress,
+    unique: bool,
+    class_hash: ClassHash,
+    calldata: Span<felt252>,
+    salt: felt252
+) {
+    let event = utils::pop_log::<UniversalDeployer::Event>(contract).unwrap();
+    let expected = UniversalDeployer::Event::ContractDeployed(
+        ContractDeployed { address, deployer, unique, class_hash, calldata, salt }
+    );
+    assert!(event == expected);
+    utils::assert_no_events_left(contract);
+}