feat: Advanced factory contract

Scarb.lock

@@ -1,6 +1,16 @@
 # Code generated by scarb DO NOT EDIT.
 version = 1
 
+[[package]]
+name = "advanced_factory"
+version = "0.1.0"
+dependencies = [
+ "alexandria_storage",
+ "components",
+ "crowdfunding",
+ "snforge_std",
+]
+
 [[package]]
 name = "alexandria_storage"
 version = "0.3.0"
@@ -44,6 +54,15 @@ version = "0.1.0"
 name = "counter"
 version = "0.1.0"
 
+[[package]]
+name = "crowdfunding"
+version = "0.1.0"
+dependencies = [
+ "components",
+ "openzeppelin",
+ "snforge_std",
+]
+
 [[package]]
 name = "custom_type_serde"
 version = "0.1.0"

Scarb.toml

@@ -16,6 +16,8 @@ starknet = ">=2.6.4"
 openzeppelin = { git = "https://github.com/OpenZeppelin/cairo-contracts.git", tag="v0.14.0" }
 components = { path = "listings/applications/components" }
 snforge_std = { git = "https://github.com/foundry-rs/starknet-foundry.git", tag = "v0.25.0" }
+# The latest Alexandria release supports only Cairo v2.6.0, so using explicit rev that supports Cairo v2.6.3
+alexandria_storage = { git = "https://github.com/keep-starknet-strange/alexandria.git", rev="800f5ad" }
 
 [workspace.package]
 description = "Collection of examples of how to use the Cairo programming language to create smart contracts on Starknet."

listings/advanced-concepts/using_lists/Scarb.toml

@@ -5,7 +5,7 @@ edition = '2023_11'
 
 [dependencies]
 starknet.workspace = true
-alexandria_storage = { git = "https://github.com/keep-starknet-strange/alexandria.git",  rev="800f5ad"}
+alexandria_storage.workspace = true
 
 [scripts]
 test.workspace = true

listings/applications/advanced_factory/.gitignore

@@ -0,0 +1,2 @@
+target
+.snfoundry_cache/

listings/applications/advanced_factory/Scarb.toml

@@ -0,0 +1,18 @@
+[package]
+name = "advanced_factory"
+version.workspace = true
+edition = "2023_11"
+
+[dependencies]
+starknet.workspace = true
+components.workspace = true
+alexandria_storage.workspace = true
+snforge_std.workspace = true
+crowdfunding = { path = "../crowdfunding" }
+
+[scripts]
+test.workspace = true
+
+[[target.starknet-contract]]
+casm = true
+build-external-contracts = ["crowdfunding::campaign::Campaign"]

listings/applications/advanced_factory/src/contract.cairo

@@ -0,0 +1,152 @@
+// ANCHOR: contract
+pub use starknet::{ContractAddress, ClassHash};
+
+#[starknet::interface]
+pub trait ICampaignFactory<TContractState> {
+    fn create_campaign(
+        ref self: TContractState,
+        title: ByteArray,
+        description: ByteArray,
+        goal: u256,
+        start_time: u64,
+        end_time: u64,
+        token_address: ContractAddress
+    ) -> ContractAddress;
+    fn get_campaign_class_hash(self: @TContractState) -> ClassHash;
+    fn update_campaign_class_hash(ref self: TContractState, new_class_hash: ClassHash);
+    fn upgrade_campaign(
+        ref self: TContractState, campaign_address: ContractAddress, new_end_time: Option<u64>
+    );
+}
+
+#[starknet::contract]
+pub mod CampaignFactory {
+    use core::num::traits::zero::Zero;
+    use starknet::{
+        ContractAddress, ClassHash, SyscallResultTrait, syscalls::deploy_syscall,
+        get_caller_address, get_contract_address
+    };
+    use alexandria_storage::list::{List, ListTrait};
+    use crowdfunding::campaign::{ICampaignDispatcher, ICampaignDispatcherTrait};
+    use components::ownable::ownable_component;
+
+    component!(path: ownable_component, storage: ownable, event: OwnableEvent);
+
+    #[abi(embed_v0)]
+    impl OwnableImpl = ownable_component::Ownable<ContractState>;
+    impl OwnableInternalImpl = ownable_component::OwnableInternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        ownable: ownable_component::Storage,
+        /// Store all of the created campaign instances' addresses and thei class hashes
+        campaigns: LegacyMap<(ContractAddress, ContractAddress), ClassHash>,
+        /// Store the class hash of the contract to deploy
+        campaign_class_hash: ClassHash,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        #[flat]
+        OwnableEvent: ownable_component::Event,
+        CampaignClassHashUpgraded: CampaignClassHashUpgraded,
+        CampaignCreated: CampaignCreated,
+        ClassHashUpdated: ClassHashUpdated,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct ClassHashUpdated {
+        pub new_class_hash: ClassHash,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct CampaignClassHashUpgraded {
+        pub campaign: ContractAddress,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct CampaignCreated {
+        pub creator: ContractAddress,
+        pub contract_address: ContractAddress
+    }
+
+    pub mod Errors {
+        pub const CLASS_HASH_ZERO: felt252 = 'Class hash cannot be zero';
+        pub const ZERO_ADDRESS: felt252 = 'Zero address';
+        pub const SAME_IMPLEMENTATION: felt252 = 'Implementation is unchanged';
+        pub const CAMPAIGN_NOT_FOUND: felt252 = 'Campaign not found';
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, class_hash: ClassHash) {
+        assert(class_hash.is_non_zero(), Errors::CLASS_HASH_ZERO);
+        self.campaign_class_hash.write(class_hash);
+        self.ownable._init(get_caller_address());
+    }
+
+
+    #[abi(embed_v0)]
+    impl CampaignFactory of super::ICampaignFactory<ContractState> {
+        fn create_campaign(
+            ref self: ContractState,
+            title: ByteArray,
+            description: ByteArray,
+            goal: u256,
+            start_time: u64,
+            end_time: u64,
+            token_address: ContractAddress,
+        ) -> ContractAddress {
+            let creator = get_caller_address();
+
+            // Create contructor arguments
+            let mut constructor_calldata: Array::<felt252> = array![];
+            ((creator, title, description, goal), start_time, end_time, token_address)
+                .serialize(ref constructor_calldata);
+
+            // Contract deployment
+            let (contract_address, _) = deploy_syscall(
+                self.campaign_class_hash.read(), 0, constructor_calldata.span(), false
+            )
+                .unwrap_syscall();
+
+            // track new campaign instance
+            self.campaigns.write((creator, contract_address), self.campaign_class_hash.read());
+
+            self.emit(Event::CampaignCreated(CampaignCreated { creator, contract_address }));
+
+            contract_address
+        }
+
+        fn get_campaign_class_hash(self: @ContractState) -> ClassHash {
+            self.campaign_class_hash.read()
+        }
+
+        fn update_campaign_class_hash(ref self: ContractState, new_class_hash: ClassHash) {
+            self.ownable._assert_only_owner();
+            assert(new_class_hash.is_non_zero(), Errors::CLASS_HASH_ZERO);
+
+            self.campaign_class_hash.write(new_class_hash);
+
+            self.emit(Event::ClassHashUpdated(ClassHashUpdated { new_class_hash }));
+        }
+
+        fn upgrade_campaign(
+            ref self: ContractState, campaign_address: ContractAddress, new_end_time: Option<u64>
+        ) {
+            assert(campaign_address.is_non_zero(), Errors::ZERO_ADDRESS);
+
+            let creator = get_caller_address();
+            let old_class_hash = self.campaigns.read((creator, campaign_address));
+            assert(old_class_hash.is_non_zero(), Errors::CAMPAIGN_NOT_FOUND);
+            assert(old_class_hash != self.campaign_class_hash.read(), Errors::SAME_IMPLEMENTATION);
+
+            let campaign = ICampaignDispatcher { contract_address: campaign_address };
+            campaign.upgrade(self.campaign_class_hash.read(), new_end_time);
+        }
+    }
+}
+// ANCHOR_END: contract
+
+

listings/applications/advanced_factory/src/lib.cairo

@@ -0,0 +1,5 @@
+mod contract;
+mod mock_upgrade;
+
+#[cfg(test)]
+mod tests;

listings/applications/advanced_factory/src/mock_upgrade.cairo

@@ -0,0 +1,8 @@
+#[starknet::contract]
+pub mod MockContract {
+    #[storage]
+    struct Storage {}
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {}
+}