Updated claim ticket payment logic

launchpad-common/src/config.rs

@@ -41,6 +41,10 @@ pub trait ConfigModule {
     #[storage_mapper("nrWinningTickets")]
     fn nr_winning_tickets(&self) -> SingleValueMapper<usize>;
 
+    #[view(getTotalLaunchpadTokensDeposited)]
+    #[storage_mapper("totalLaunchpadTokensDeposited")]
+    fn total_launchpad_tokens_deposited(&self) -> SingleValueMapper<BigUint>;
+
     #[storage_mapper("launchpadTokensDeposited")]
     fn launchpad_tokens_deposited(&self) -> SingleValueMapper<bool>;
 

launchpad-common/src/setup.rs

@@ -21,6 +21,7 @@ pub trait SetupModule:
         require!(payment_amount == amount_needed, "Wrong amount");
 
         self.launchpad_tokens_deposited().set(true);
+        self.total_launchpad_tokens_deposited().set(payment_amount);
     }
 
     #[only_owner]

launchpad-guaranteed-tickets/src/lib.rs

@@ -3,7 +3,7 @@
 multiversx_sc::imports!();
 multiversx_sc::derive_imports!();
 
-use launchpad_common::{launch_stage::Flags, tickets::WINNING_TICKET};
+use launchpad_common::{config::TokenAmountPair, launch_stage::Flags, tickets::WINNING_TICKET};
 
 use crate::guranteed_ticket_winners::GuaranteedTicketsSelectionOperation;
 
@@ -212,7 +212,36 @@ pub trait LaunchpadGuaranteedTickets:
     #[only_owner]
     #[endpoint(claimTicketPayment)]
     fn claim_ticket_payment_endpoint(&self) {
-        self.claim_ticket_payment();
+        self.require_claim_period();
+
+        let owner = self.blockchain().get_caller();
+
+        let ticket_price: TokenAmountPair<Self::Api> = self.ticket_price().get();
+        let ticket_payment_mapper = self.claimable_ticket_payment();
+        let claimable_ticket_payment = ticket_payment_mapper.get();
+        if claimable_ticket_payment > 0 {
+            ticket_payment_mapper.clear();
+
+            self.send()
+                .direct(&owner, &ticket_price.token_id, 0, &claimable_ticket_payment);
+        }
+
+        let total_launchpad_tokens_deposited = self.total_launchpad_tokens_deposited().get();
+        let amount_per_ticket = self.launchpad_tokens_per_winning_ticket().get();
+        let total_nr_winning_tickets = claimable_ticket_payment / ticket_price.amount;
+
+        let total_launchpad_tokens_won = total_nr_winning_tickets * amount_per_ticket;
+
+        if total_launchpad_tokens_won >= total_launchpad_tokens_deposited {
+            return;
+        }
+
+        let launchpad_token_id = self.launchpad_token_id().get();
+        let extra_launchpad_tokens = total_launchpad_tokens_deposited - total_launchpad_tokens_won;
+        if extra_launchpad_tokens > 0 {
+            self.send()
+                .direct_esdt(&owner, &launchpad_token_id, 0, &extra_launchpad_tokens);
+        }
     }
 
     #[view(getUserTicketsStatus)]

launchpad-guaranteed-tickets/src/token_release.rs

@@ -62,7 +62,7 @@ pub trait TokenReleaseModule: config::ConfigModule {
             "Wrong claim start round"
         );
         require!(
-            vesting_release_period > 0,
+            vesting_release_period > 0 || initial_release_percentage == MAX_PERCENTAGE,
             "Wrong vesting release recurrency"
         );
 
@@ -89,9 +89,11 @@ pub trait TokenReleaseModule: config::ConfigModule {
     fn compute_claimable_tokens(&self, address: &ManagedAddress) -> BigUint {
         let user_total_claimable_balance = self.user_total_claimable_balance(address).get();
         let user_claimed_balance = self.user_claimed_balance(address).get();
-        if user_total_claimable_balance == user_claimed_balance {
-            return BigUint::zero();
-        }
+        require!(
+            user_claimed_balance < user_total_claimable_balance,
+            "Already claimed all tokens"
+        );
+
         let unlock_schedule_mapper = self.unlock_schedule();
         if unlock_schedule_mapper.is_empty() {
             return BigUint::zero();
@@ -102,6 +104,10 @@ pub trait TokenReleaseModule: config::ConfigModule {
             return BigUint::zero();
         }
 
+        if unlock_schedule.initial_release_percentage == MAX_PERCENTAGE {
+            return user_total_claimable_balance;
+        }
+
         let rounds_passed = current_round - unlock_schedule.claim_start_round;
         let mut claimable_periods = rounds_passed / unlock_schedule.vesting_release_period;
         if claimable_periods > unlock_schedule.vesting_release_times {

launchpad-guaranteed-tickets/tests/guaranteed_tickets_setup/mod.rs

@@ -9,6 +9,7 @@ use launchpad_common::{
     user_interactions::UserInteractionsModule,
     winner_selection::WinnerSelectionModule,
 };
+use launchpad_guaranteed_tickets::token_release::TokenReleaseModule;
 use launchpad_guaranteed_tickets::{
     guaranteed_tickets_init::GuaranteedTicketsInitModule, LaunchpadGuaranteedTickets,
 };
@@ -201,8 +202,32 @@ where
             &self.lp_wrapper,
             &rust_biguint!(0),
             |sc| {
-                sc.claim_ticket_payment();
+                sc.claim_ticket_payment_endpoint();
             },
         )
     }
+
+    pub fn set_unlock_schedule(
+        &mut self,
+        claim_start_round: u64,
+        initial_release_percentage: u64,
+        vesting_release_times: u64,
+        vesting_release_percentage: u64,
+        vesting_release_period: u64,
+    ) {
+        let _ = self.b_mock.execute_tx(
+            &self.owner_address,
+            &self.lp_wrapper,
+            &rust_biguint!(0),
+            |sc| {
+                sc.set_unlock_schedule(
+                    claim_start_round,
+                    initial_release_percentage,
+                    vesting_release_times,
+                    vesting_release_percentage,
+                    vesting_release_period,
+                );
+            },
+        );
+    }
 }