Migrate UDC

CHANGELOG.md

@@ -15,6 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - ERC721Component functions and Storage member
   - `InternalTrait::_set_base_uri` and `InternalTrait::_base_uri` to handle ByteArrays (#857)
   - `ERC721_base_uri` Storage member to store the base URI (#857)
+- UDC preset contract (#919)
 
 ### Changed
 

docs/modules/ROOT/pages/presets.adoc

@@ -3,6 +3,7 @@
 :erc721: xref:/api/erc721.adoc#ERC721[ERC721]
 :erc1155: xref:/api/erc1155.adoc#ERC1155[ERC1155]
 :eth-account-upgradeable: xref:/api/account.adoc#EthAccountUpgradeable[EthAccountUpgradeable]
+:udc: https://github.com/starknet-io/starknet-docs/blob/v0.1.479/components/Starknet/modules/architecture_and_concepts/pages/Smart_Contracts/universal-deployer.adoc[UniversalDeployer]
 :sierra-class-hashes: https://docs.starknet.io/documentation/architecture_and_concepts/Smart_Contracts/class-hash[Sierra class hashes]
 :starkli: https://book.starkli.rs/introduction[starkli]
 :wizard: https://wizard.openzeppelin.com[Wizard for Cairo]
@@ -41,6 +42,9 @@ NOTE: Class hashes were computed using {class-hash-cairo-version}.
 
 | `{eth-account-upgradeable}`
 | `{EthAccountUpgradeable-class-hash}`
+
+| `{udc}`
+| `{UniversalDeployer-class-hash}`
 |===
 
 TIP: {starkli} class-hash command can be used to compute the class hash from a Sierra artifact.

docs/modules/ROOT/pages/utils/_class_hashes.adoc

@@ -7,6 +7,7 @@
 :ERC721-class-hash: 0x06b7c9efc5467c621f58d87995302d940a39b7217b5c5a7a55555c97cabf5cd8
 :ERC1155-class-hash: 0x518be7d9fa527c78d6929bf9e638e9c98b6077722e27e9546cc4342e830386e
 :EthAccountUpgradeable-class-hash: 0x0580fe510cf07255540abda6f9d29aa07cb8944db444bca59e1573904c269844
+:UniversalDeployer-class-hash: 0x0548f35c7316b4dc5efdaa929fe83f1007c7e0ae24bec3045d47c94da00dd386
 
 // Presets page
 :presets-page: xref:presets.adoc[Sierra class hash]

src/presets.cairo

@@ -3,9 +3,11 @@ mod erc1155;
 mod erc20;
 mod erc721;
 mod eth_account;
+mod universal_deployer;
 
 use account::Account;
 use erc1155::ERC1155;
 use erc20::ERC20;
 use erc721::ERC721;
 use eth_account::EthAccountUpgradeable;
+use universal_deployer::UniversalDeployer;

src/presets/universal_deployer.cairo

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts for Cairo v0.9.0 (presets/universal_deployer.cairo)
+
+/// # UniversalDeployer Preset
+///
+/// The Universal Deployer Contract is a singleton smart contract that wraps `deploy_syscall`
+/// to expose it to any contract that doesn't implement it, such as account contracts.
+///
+/// This contract is already deployed at 0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf
+/// on mainnet, testnets, and starknet-devnet.
+/// This address may change in the future.
+#[starknet::contract]
+mod UniversalDeployer {
+    use core::pedersen::pedersen;
+    use openzeppelin::utils::universal_deployer::interface;
+    use starknet::ClassHash;
+    use starknet::ContractAddress;
+    use starknet::SyscallResultTrait;
+    use starknet::get_caller_address;
+
+    #[storage]
+    struct Storage {}
+
+    #[event]
+    #[derive(Drop, PartialEq, starknet::Event)]
+    enum Event {
+        ContractDeployed: ContractDeployed
+    }
+
+    #[derive(Drop, PartialEq, starknet::Event)]
+    struct ContractDeployed {
+        address: ContractAddress,
+        deployer: ContractAddress,
+        unique: bool,
+        class_hash: ClassHash,
+        calldata: Span<felt252>,
+        salt: felt252,
+    }
+
+    #[abi(embed_v0)]
+    impl UniversalDeployerImpl of interface::IUniversalDeployer<ContractState> {
+        fn deploy_contract(
+            ref self: ContractState,
+            class_hash: ClassHash,
+            salt: felt252,
+            unique: bool,
+            calldata: Span<felt252>
+        ) -> ContractAddress {
+            let deployer: ContractAddress = get_caller_address();
+            let from_zero: bool = !unique;
+            let mut _salt: felt252 = salt;
+            if unique {
+                _salt = pedersen(deployer.into(), salt);
+            }
+
+            let (address, _) = starknet::deploy_syscall(class_hash, _salt, calldata, from_zero)
+                .unwrap_syscall();
+
+            self.emit(ContractDeployed { address, deployer, unique, class_hash, calldata, salt });
+            return address;
+        }
+    }
+}

src/tests/presets.cairo

@@ -3,3 +3,4 @@ mod test_erc1155;
 mod test_erc20;
 mod test_erc721;
 mod test_eth_account;
+mod test_universal_deployer;

src/tests/presets/test_universal_deployer.cairo

@@ -0,0 +1,161 @@
+use core::pedersen::pedersen;
+use openzeppelin::presets::universal_deployer::UniversalDeployer::ContractDeployed;
+use openzeppelin::presets::universal_deployer::UniversalDeployer;
+use openzeppelin::tests::mocks::erc20_mocks::DualCaseERC20Mock;
+use openzeppelin::tests::utils::constants::{NAME, SYMBOL, SUPPLY, SALT, CALLER, RECIPIENT};
+use openzeppelin::tests::utils;
+use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait};
+use openzeppelin::utils::serde::SerializedAppend;
+use openzeppelin::utils::universal_deployer::interface::{
+    IUniversalDeployerDispatcher, IUniversalDeployerDispatcherTrait
+};
+use starknet::ClassHash;
+use starknet::ContractAddress;
+use starknet::testing;
+
+
+// 2**251 - 256
+const L2_ADDRESS_UPPER_BOUND: felt252 =
+    0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00;
+const CONTRACT_ADDRESS_PREFIX: felt252 = 'STARKNET_CONTRACT_ADDRESS';
+
+fn ERC20_CLASS_HASH() -> ClassHash {
+    DualCaseERC20Mock::TEST_CLASS_HASH.try_into().unwrap()
+}
+
+fn ERC20_CALLDATA() -> Span<felt252> {
+    let mut calldata = array![];
+    calldata.append_serde(NAME());
+    calldata.append_serde(SYMBOL());
+    calldata.append_serde(SUPPLY);
+    calldata.append_serde(RECIPIENT());
+    calldata.span()
+}
+
+fn deploy_udc() -> IUniversalDeployerDispatcher {
+    let calldata = array![];
+    let address = utils::deploy(UniversalDeployer::TEST_CLASS_HASH, calldata);
+
+    IUniversalDeployerDispatcher { contract_address: address }
+}
+
+#[test]
+fn test_deploy_not_unique() {
+    let udc = deploy_udc();
+    let unique = false;
+    testing::set_contract_address(CALLER());
+
+    // Check address
+    let expected_addr = calculate_contract_address_from_hash(
+        SALT, ERC20_CLASS_HASH(), ERC20_CALLDATA(), Zeroable::zero()
+    );
+    let deployed_addr = udc.deploy_contract(ERC20_CLASS_HASH(), SALT, unique, ERC20_CALLDATA());
+    assert_eq!(expected_addr, deployed_addr);
+
+    // Check event
+    assert_event_contract_deployed(
+        udc.contract_address,
+        deployed_addr,
+        CALLER(),
+        unique,
+        ERC20_CLASS_HASH(),
+        ERC20_CALLDATA(),
+        SALT
+    );
+
+    // Check deployment
+    let erc20 = IERC20Dispatcher { contract_address: deployed_addr };
+    let total_supply = erc20.total_supply();
+    assert_eq!(total_supply, SUPPLY);
+}
+
+#[test]
+fn test_deploy_unique() {
+    let udc = deploy_udc();
+    let unique = true;
+    testing::set_contract_address(CALLER());
+
+    // Check address
+    let hashed_salt = pedersen(CALLER().into(), SALT);
+    let expected_addr = calculate_contract_address_from_hash(
+        hashed_salt, ERC20_CLASS_HASH(), ERC20_CALLDATA(), udc.contract_address
+    );
+    let deployed_addr = udc.deploy_contract(ERC20_CLASS_HASH(), SALT, unique, ERC20_CALLDATA());
+    assert_eq!(expected_addr, deployed_addr);
+
+    // Check event
+    assert_event_contract_deployed(
+        udc.contract_address,
+        deployed_addr,
+        CALLER(),
+        unique,
+        ERC20_CLASS_HASH(),
+        ERC20_CALLDATA(),
+        SALT
+    );
+
+    // Check deployment
+    let erc20 = IERC20Dispatcher { contract_address: deployed_addr };
+    let total_supply = erc20.total_supply();
+    assert_eq!(total_supply, SUPPLY);
+}
+
+//
+// Helpers
+//
+
+/// See https://github.com/starkware-libs/cairo-lang/blob/v0.13.0/src/starkware/cairo/common/hash_state.py
+fn compute_hash_on_elements(mut data: Span<felt252>) -> felt252 {
+    let data_len: usize = data.len();
+    let mut hash = 0;
+    loop {
+        match data.pop_front() {
+            Option::Some(elem) => { hash = pedersen(hash, *elem); },
+            Option::None => {
+                hash = pedersen(hash, data_len.into());
+                break;
+            },
+        };
+    };
+    hash
+}
+
+/// See https://github.com/starkware-libs/cairo-lang/blob/v0.13.0/src/starkware/starknet/core/os/contract_address/contract_address.py
+fn calculate_contract_address_from_hash(
+    salt: felt252,
+    class_hash: ClassHash,
+    constructor_calldata: Span<felt252>,
+    deployer_address: ContractAddress
+) -> ContractAddress {
+    let constructor_calldata_hash = compute_hash_on_elements(constructor_calldata);
+
+    let mut data = array![];
+    data.append_serde(CONTRACT_ADDRESS_PREFIX);
+    data.append_serde(deployer_address);
+    data.append_serde(salt);
+    data.append_serde(class_hash);
+    data.append_serde(constructor_calldata_hash);
+    let raw_address = compute_hash_on_elements(data.span());
+
+    // Felt modulo is discouraged, hence the conversion to u256
+    let u256_addr: u256 = raw_address.into() % L2_ADDRESS_UPPER_BOUND.into();
+    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);
+}

src/utils.cairo

@@ -3,6 +3,7 @@
 
 mod selectors;
 mod serde;
+mod universal_deployer;
 mod unwrap_and_cast;
 
 use starknet::ContractAddress;

src/utils/universal_deployer.cairo

@@ -0,0 +1,2 @@
+mod interface;
+use interface::IUniversalDeployer;

src/utils/universal_deployer/interface.cairo

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts for Cairo v0.9.0 (utils/universal_deployer/interface.cairo)
+
+use starknet::ClassHash;
+use starknet::ContractAddress;
+
+#[starknet::interface]
+trait IUniversalDeployer<TState> {
+    fn deploy_contract(
+        ref self: TState,
+        class_hash: ClassHash,
+        salt: felt252,
+        unique: bool,
+        calldata: Span<felt252>
+    ) -> ContractAddress;
+}