fix crowdfunding tests

listings/applications/crowdfunding/src/campaign.cairo

@@ -87,6 +87,7 @@ pub mod Campaign {
         Closed: Closed,
         Upgraded: Upgraded,
         Withdrawn: Withdrawn,
+        WithdrawnAll: WithdrawnAll,
     }
 
     #[derive(Drop, starknet::Event)]
@@ -121,6 +122,11 @@ pub mod Campaign {
         pub amount: u256,
     }
 
+    #[derive(Drop, starknet::Event)]
+    pub struct WithdrawnAll {
+        pub reason: ByteArray,
+    }
+
     pub mod Errors {
         pub const NOT_CREATOR: felt252 = 'Not creator';
         pub const ENDED: felt252 = 'Campaign already ended';
@@ -150,7 +156,8 @@ pub mod Campaign {
         title: ByteArray,
         description: ByteArray,
         target: u256,
-        token_address: ContractAddress
+        token_address: ContractAddress,
+    // TODO: add recepient address
     ) {
         assert(creator.is_non_zero(), Errors::CREATOR_ZERO);
         assert(title.len() > 0, Errors::TITLE_EMPTY);
@@ -201,7 +208,7 @@ pub mod Campaign {
                 self.status.write(Status::CLOSED);
             }
 
-            self._withdraw_all();
+            self._withdraw_all(reason.clone());
 
             self.emit(Event::Closed(Closed { reason }));
         }
@@ -288,7 +295,7 @@ pub mod Campaign {
                     Option::None => 0,
                 };
                 assert(duration > 0, Errors::ZERO_DURATION);
-                self._withdraw_all();
+                self._withdraw_all("contract upgraded");
                 self.total_contributions.write(0);
                 self.end_time.write(get_block_timestamp() + duration);
             }
@@ -327,7 +334,7 @@ pub mod Campaign {
         }
 
         fn _is_expired(self: @ContractState) -> bool {
-            get_block_timestamp() < self.end_time.read()
+            get_block_timestamp() >= self.end_time.read()
         }
 
         fn _is_active(self: @ContractState) -> bool {
@@ -338,14 +345,16 @@ pub mod Campaign {
             self.total_contributions.read() >= self.target.read()
         }
 
-        fn _withdraw_all(ref self: ContractState) {
+        fn _withdraw_all(ref self: ContractState, reason: ByteArray) {
             let mut contributions = self.contributions.get_contributions_as_arr();
             while let Option::Some((contributor, amt)) = contributions
                 .pop_front() {
                     self.contributions.remove(contributor);
                     let success = self.token.read().transfer(contributor, amt);
                     assert(success, Errors::TRANSFER_FAILED);
                 };
+
+            self.emit(Event::WithdrawnAll(WithdrawnAll { reason }));
         }
     }
 }

listings/applications/crowdfunding/src/mock_upgrade.cairo

@@ -1,8 +1,321 @@
 #[starknet::contract]
-pub mod MockContract {
+pub mod MockUpgrade {
+    use components::ownable::ownable_component::OwnableInternalTrait;
+    use core::num::traits::zero::Zero;
+    use openzeppelin::token::erc20::interface::{IERC20Dispatcher, IERC20DispatcherTrait};
+    use starknet::{
+        ClassHash, ContractAddress, SyscallResultTrait, get_block_timestamp, contract_address_const,
+        get_caller_address, get_contract_address, class_hash::class_hash_const
+    };
+    use components::ownable::ownable_component;
+    use crowdfunding::campaign::contributions::contributable_component;
+    use crowdfunding::campaign::{ICampaign, Details, Status};
+
+    component!(path: ownable_component, storage: ownable, event: OwnableEvent);
+    component!(path: contributable_component, storage: contributions, event: ContributableEvent);
+
+    #[abi(embed_v0)]
+    pub impl OwnableImpl = ownable_component::Ownable<ContractState>;
+    impl OwnableInternalImpl = ownable_component::OwnableInternalImpl<ContractState>;
+    #[abi(embed_v0)]
+    impl ContributableImpl = contributable_component::Contributable<ContractState>;
+
     #[storage]
-    struct Storage {}
+    struct Storage {
+        #[substorage(v0)]
+        ownable: ownable_component::Storage,
+        #[substorage(v0)]
+        contributions: contributable_component::Storage,
+        end_time: u64,
+        token: IERC20Dispatcher,
+        creator: ContractAddress,
+        target: u256,
+        title: ByteArray,
+        description: ByteArray,
+        total_contributions: u256,
+        status: Status
+    }
+
     #[event]
     #[derive(Drop, starknet::Event)]
-    enum Event {}
+    pub enum Event {
+        #[flat]
+        OwnableEvent: ownable_component::Event,
+        Activated: Activated,
+        ContributableEvent: contributable_component::Event,
+        ContributionMade: ContributionMade,
+        Claimed: Claimed,
+        Closed: Closed,
+        Upgraded: Upgraded,
+        Withdrawn: Withdrawn,
+        WithdrawnAll: WithdrawnAll,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct ContributionMade {
+        #[key]
+        pub contributor: ContractAddress,
+        pub amount: u256,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct Claimed {
+        pub amount: u256,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct Activated {}
+
+    #[derive(Drop, starknet::Event)]
+    pub struct Closed {
+        pub reason: ByteArray,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct Upgraded {
+        pub implementation: ClassHash
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct Withdrawn {
+        #[key]
+        pub contributor: ContractAddress,
+        pub amount: u256,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    pub struct WithdrawnAll {
+        pub reason: ByteArray,
+    }
+
+    pub mod Errors {
+        pub const NOT_CREATOR: felt252 = 'Not creator';
+        pub const ENDED: felt252 = 'Campaign already ended';
+        pub const NOT_PENDING: felt252 = 'Campaign not pending';
+        pub const STILL_ACTIVE: felt252 = 'Campaign not ended';
+        pub const STILL_PENDING: felt252 = 'Campaign not yet active';
+        pub const CLOSED: felt252 = 'Campaign closed';
+        pub const FAILED: felt252 = 'Campaign failed';
+        pub const CLASS_HASH_ZERO: felt252 = 'Class hash cannot be zero';
+        pub const ZERO_DONATION: felt252 = 'Donation must be > 0';
+        pub const ZERO_TARGET: felt252 = 'Target must be > 0';
+        pub const ZERO_DURATION: felt252 = 'Duration must be > 0';
+        pub const ZERO_FUNDS: felt252 = 'No funds to claim';
+        pub const TRANSFER_FAILED: felt252 = 'Transfer failed';
+        pub const TITLE_EMPTY: felt252 = 'Title empty';
+        pub const ZERO_ADDRESS_CALLER: felt252 = 'Caller cannot be zero';
+        pub const CREATOR_ZERO: felt252 = 'Creator address cannot be zero';
+        pub const TARGET_NOT_REACHED: felt252 = 'Target not reached';
+        pub const TARGET_ALREADY_REACHED: felt252 = 'Target already reached';
+        pub const NOTHING_TO_WITHDRAW: felt252 = 'Nothing to withdraw';
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        creator: ContractAddress,
+        title: ByteArray,
+        description: ByteArray,
+        target: u256,
+        token_address: ContractAddress,
+    // TODO: add recepient address
+    ) {
+        assert(creator.is_non_zero(), Errors::CREATOR_ZERO);
+        assert(title.len() > 0, Errors::TITLE_EMPTY);
+        assert(target > 0, Errors::ZERO_TARGET);
+
+        self.token.write(IERC20Dispatcher { contract_address: token_address });
+
+        self.title.write(title);
+        self.target.write(target);
+        self.description.write(description);
+        self.creator.write(creator);
+        self.ownable._init(get_caller_address());
+        self.status.write(Status::PENDING)
+    }
+
+    #[abi(embed_v0)]
+    impl MockUpgrade of ICampaign<ContractState> {
+        fn claim(ref self: ContractState) {
+            self._assert_only_creator();
+            assert(self._is_active() && self._is_expired(), Errors::STILL_ACTIVE);
+            assert(self._is_target_reached(), Errors::TARGET_NOT_REACHED);
+
+            let this = get_contract_address();
+            let token = self.token.read();
+
+            let amount = token.balance_of(this);
+            assert(amount > 0, Errors::ZERO_FUNDS);
+
+            self.status.write(Status::SUCCESSFUL);
+
+            // no need to reset the contributions, as the campaign has ended
+            // and the data can be used as a testament to how much was raised
+
+            let owner = get_caller_address();
+            let success = token.transfer(owner, amount);
+            assert(success, Errors::TRANSFER_FAILED);
+
+            self.emit(Event::Claimed(Claimed { amount }));
+        }
+
+        fn close(ref self: ContractState, reason: ByteArray) {
+            self._assert_only_creator();
+            assert(self._is_active(), Errors::ENDED);
+
+            if !self._is_target_reached() && self._is_expired() {
+                self.status.write(Status::FAILED);
+            } else {
+                self.status.write(Status::CLOSED);
+            }
+
+            self._withdraw_all(reason.clone());
+
+            self.emit(Event::Closed(Closed { reason }));
+        }
+
+        fn contribute(ref self: ContractState, amount: u256) {
+            assert(self.status.read() != Status::PENDING, Errors::STILL_PENDING);
+            assert(self._is_active() && !self._is_expired(), Errors::ENDED);
+            assert(amount > 0, Errors::ZERO_DONATION);
+
+            let contributor = get_caller_address();
+            let this = get_contract_address();
+            let success = self.token.read().transfer_from(contributor, this, amount);
+            assert(success, Errors::TRANSFER_FAILED);
+
+            self.contributions.add(contributor, amount);
+            self.total_contributions.write(self.total_contributions.read() + amount);
+
+            self.emit(Event::ContributionMade(ContributionMade { contributor, amount }));
+        }
+
+        fn get_contribution(self: @ContractState, contributor: ContractAddress) -> u256 {
+            self.contributions.get(contributor)
+        }
+
+        fn get_contributions(self: @ContractState) -> Array<(ContractAddress, u256)> {
+            self.contributions.get_contributions_as_arr()
+        }
+
+        fn get_details(self: @ContractState) -> Details {
+            Details {
+                creator: self.creator.read(),
+                title: self.title.read(),
+                description: self.description.read(),
+                target: self.target.read(),
+                end_time: self.end_time.read(),
+                status: self.status.read(),
+                token: self.token.read().contract_address,
+                total_contributions: self.total_contributions.read(),
+            }
+        }
+
+        fn start(ref self: ContractState, duration: u64) {
+            self._assert_only_creator();
+            assert(self.status.read() == Status::PENDING, Errors::NOT_PENDING);
+            assert(duration > 0, Errors::ZERO_DURATION);
+
+            self.end_time.write(get_block_timestamp() + duration);
+            self.status.write(Status::ACTIVE);
+
+            self.emit(Event::Activated(Activated {}));
+        }
+
+        /// There are currently 3 possibilities for performing contract upgrades:
+        ///  1. Trust the campaign factory owner -> this is suboptimal, as factory owners have no responsibility to either creators or contributors,
+        ///     and there's nothing stopping them from implementing a malicious upgrade.
+        ///  2. Trust the campaign creator -> the contributors already trust the campaign creator that they'll do what they promised in the campaign.
+        ///     It's not a stretch to trust them with verifying that the contract upgrade is necessary. 
+        ///  3. Trust no one, contract upgrades are forbidden -> could be a problem if a vulnerability is discovered and campaign funds are in danger.
+        /// 
+        /// This function implements the 2nd option, as it seems to be the most optimal solution, especially from the point of view of what to do if
+        /// any of the upgrades fail for whatever reason - campaign creator is solely responsible for upgrading their contracts. 
+        /// 
+        /// To improve contributor trust, contract upgrades refund all of contributor funds, so that on the off chance that the creator is in cahoots
+        /// with factory owners to implement a malicious upgrade, the contributor funds would be returned.
+        /// There are some problems with this though:
+        ///  - contributors wouldn't have even been donating if they weren't trusting the creator - since the funds end up with them in the end, they
+        ///    have to trust that creators would use the campaign funds as they promised when creating the campaign.
+        ///  - since the funds end up with the creators, they have no incentive to implement a malicious upgrade - they'll have the funds either way.
+        ///  - each time there's an upgrade, the campaign gets reset, which introduces a new problem - what if the Campaign was close to ending?
+        ///    We just took all of their contributions away, and there might not be enough time to get them back. We solve this by letting the creators
+        ///    prolong the duration of the campaign.
+        fn upgrade(ref self: ContractState, impl_hash: ClassHash, new_duration: Option<u64>) {
+            self.ownable._assert_only_owner();
+            assert(impl_hash.is_non_zero(), Errors::CLASS_HASH_ZERO);
+            assert(
+                self.status.read() == Status::ACTIVE || self.status.read() == Status::PENDING,
+                Errors::ENDED
+            );
+
+            // only active campaigns have funds to refund and duration to update
+            if self.status.read() == Status::ACTIVE {
+                let duration = match new_duration {
+                    Option::Some(val) => val,
+                    Option::None => 0,
+                };
+                assert(duration > 0, Errors::ZERO_DURATION);
+                self._withdraw_all("contract upgraded");
+                self.total_contributions.write(0);
+                self.end_time.write(get_block_timestamp() + duration);
+            }
+
+            starknet::syscalls::replace_class_syscall(impl_hash).unwrap_syscall();
+
+            self.emit(Event::Upgraded(Upgraded { implementation: impl_hash }));
+        }
+
+        fn withdraw(ref self: ContractState) {
+            assert(self.status.read() != Status::PENDING, Errors::STILL_PENDING);
+            assert(self.status.read() != Status::SUCCESSFUL, Errors::ENDED);
+            assert(self.status.read() != Status::CLOSED, Errors::CLOSED);
+            assert(!self._is_target_reached(), Errors::TARGET_ALREADY_REACHED);
+            assert(self.contributions.get(get_caller_address()) != 0, Errors::NOTHING_TO_WITHDRAW);
+
+            let contributor = get_caller_address();
+            let amount = self.contributions.remove(contributor);
+
+            // no need to set total_contributions to 0, as the campaign has ended
+            // and the field can be used as a testament to how much was raised
+
+            let success = self.token.read().transfer(contributor, amount);
+            assert(success, Errors::TRANSFER_FAILED);
+
+            self.emit(Event::Withdrawn(Withdrawn { contributor, amount }));
+        }
+    }
+
+    #[generate_trait]
+    impl MockUpgradeInternalImpl of CampaignInternalTrait {
+        fn _assert_only_creator(self: @ContractState) {
+            let caller = get_caller_address();
+            assert(caller.is_non_zero(), Errors::ZERO_ADDRESS_CALLER);
+            assert(caller == self.creator.read(), Errors::NOT_CREATOR);
+        }
+
+        fn _is_expired(self: @ContractState) -> bool {
+            get_block_timestamp() >= self.end_time.read()
+        }
+
+        fn _is_active(self: @ContractState) -> bool {
+            self.status.read() == Status::ACTIVE
+        }
+
+        fn _is_target_reached(self: @ContractState) -> bool {
+            self.total_contributions.read() >= self.target.read()
+        }
+
+        fn _withdraw_all(ref self: ContractState, reason: ByteArray) {
+            let mut contributions = self.contributions.get_contributions_as_arr();
+            while let Option::Some((contributor, amt)) = contributions
+                .pop_front() {
+                    self.contributions.remove(contributor);
+                    let success = self.token.read().transfer(contributor, amt);
+                    assert(success, Errors::TRANSFER_FAILED);
+                };
+
+            self.emit(Event::WithdrawnAll(WithdrawnAll { reason }));
+        }
+    }
 }