events

gravity-restaking/src/events/mod.rs

@@ -0,0 +1,3 @@
+pub mod sov_events;
+pub mod user_events;
+pub mod validator_events;

gravity-restaking/src/events/sov_events.rs

@@ -0,0 +1,56 @@
+use crate::{unique_payments::PaymentsVec, user_actions::sovereign::SovereignInfo};
+
+multiversx_sc::imports!();
+
+#[multiversx_sc::module]
+pub trait SovEventsModule {
+    #[inline]
+    fn emit_sov_register_event(
+        &self,
+        sov_address: ManagedAddress,
+        sov_info: SovereignInfo<Self::Api>,
+    ) {
+        self.sov_register_event(sov_address, sov_info);
+    }
+
+    #[inline]
+    fn emit_sov_unregister_event(&self, sov_address: ManagedAddress) {
+        self.sov_unregister_event(sov_address);
+    }
+
+    #[inline]
+    fn emit_sov_add_own_security_funds_event(
+        &self,
+        sov_address: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    ) {
+        self.sov_add_own_security_funds_event(sov_address, payments);
+    }
+
+    #[inline]
+    fn emit_sov_set_max_restaking_cap_event(&self, sov_address: ManagedAddress, max: BigUint) {
+        self.sov_set_max_restaking_cap_event(sov_address, max);
+    }
+
+    // Events
+
+    #[event("sovRegisterEvent")]
+    fn sov_register_event(
+        &self,
+        #[indexed] sov_address: ManagedAddress,
+        sov_info: SovereignInfo<Self::Api>,
+    );
+
+    #[event("sovUnregisterEvent")]
+    fn sov_unregister_event(&self, #[indexed] sov_address: ManagedAddress);
+
+    #[event("sovAddOwnSecurityFundsEvent")]
+    fn sov_add_own_security_funds_event(
+        &self,
+        #[indexed] sov_address: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    );
+
+    #[event("sovSetMaxRestakingCapEvent")]
+    fn sov_set_max_restaking_cap_event(&self, #[indexed] sov_address: ManagedAddress, max: BigUint);
+}

gravity-restaking/src/events/user_events.rs

@@ -0,0 +1,142 @@
+use crate::unique_payments::{PaymentsVec, UniquePayments};
+
+multiversx_sc::imports!();
+
+#[multiversx_sc::module]
+pub trait UserEventsModule {
+    #[inline]
+    fn emit_user_deposit_event(&self, caller: ManagedAddress, payments: PaymentsVec<Self::Api>) {
+        self.user_deposit_event(caller, payments);
+    }
+
+    #[inline]
+    fn emit_move_stake_event(
+        &self,
+        caller: ManagedAddress,
+        delegation: ManagedAddress,
+        value: BigUint,
+    ) {
+        self.move_stake_event(caller, delegation, value);
+    }
+
+    #[inline]
+    fn emit_delegate_validator_event(
+        &self,
+        caller: ManagedAddress,
+        validator: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    ) {
+        self.delegate_validator_event(caller, validator, payments);
+    }
+
+    #[inline]
+    fn emit_delgate_sov_event(
+        &self,
+        caller: ManagedAddress,
+        sov: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    ) {
+        self.delegate_sov_event(caller, sov, payments);
+    }
+
+    #[inline]
+    fn emit_revoke_validator_event(
+        &self,
+        caller: ManagedAddress,
+        validator: ManagedAddress,
+        payments: UniquePayments<Self::Api>,
+    ) {
+        self.revoke_validator_event(caller, validator, payments);
+    }
+
+    #[inline]
+    fn emit_revoke_sov_event(
+        &self,
+        caller: ManagedAddress,
+        sov: ManagedAddress,
+        payments: UniquePayments<Self::Api>,
+    ) {
+        self.revoke_sov_event(caller, sov, payments);
+    }
+
+    #[inline]
+    fn emit_unbond_tokens_caller_event(
+        &self,
+        caller: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    ) {
+        self.unbond_tokens_caller_event(caller, payments);
+    }
+
+    #[inline]
+    fn emit_unbond_tokens_gravity_restaking_event(
+        &self,
+        caller: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    ) {
+        self.unbond_tokens_gravity_restaking_event(caller, payments);
+    }
+
+    // Events
+
+    #[event("userDepositEvent")]
+    fn user_deposit_event(
+        &self,
+        #[indexed] caller: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    );
+
+    #[event("moveStakeEvent")]
+    fn move_stake_event(
+        &self,
+        #[indexed] caller: ManagedAddress,
+        #[indexed] delegation: ManagedAddress,
+        value: BigUint,
+    );
+
+    #[event("delegateValidatorEvent")]
+    fn delegate_validator_event(
+        &self,
+        #[indexed] caller: ManagedAddress,
+        #[indexed] validator: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    );
+
+    #[event("delegateSovEvent")]
+    fn delegate_sov_event(
+        &self,
+        #[indexed] caller: ManagedAddress,
+        #[indexed] sov: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    );
+
+    #[event("revokeValidatorEvent")]
+    fn revoke_validator_event(
+        &self,
+        #[indexed] caller: ManagedAddress,
+        #[indexed] validator: ManagedAddress,
+        payments: UniquePayments<Self::Api>,
+    );
+
+    #[event("revokeSovEvent")]
+    fn revoke_sov_event(
+        &self,
+        #[indexed] caller: ManagedAddress,
+        #[indexed] sov: ManagedAddress,
+        payments: UniquePayments<Self::Api>,
+    );
+
+    #[event("unbondTokensCallerEvent")]
+    fn unbond_tokens_caller_event(
+        &self,
+        #[indexed] caller: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    );
+
+    #[event("unbondTokensGravityRestakingEvent")]
+    fn unbond_tokens_gravity_restaking_event(
+        &self,
+        #[indexed] caller: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    );
+}

gravity-restaking/src/events/validator_events.rs

@@ -0,0 +1,91 @@
+use crate::{
+    unique_payments::PaymentsVec,
+    user_actions::validator::{BlsKey, Percent},
+};
+
+multiversx_sc::imports!();
+
+#[multiversx_sc::module]
+pub trait ValidatorEventsModule {
+    #[inline]
+    fn emit_validator_register_event(&self, validator: ManagedAddress, name: ManagedBuffer) {
+        self.validator_register_event(validator, name);
+    }
+
+    #[inline]
+    fn emit_validator_add_bls_keys_event(
+        &self,
+        validator: ManagedAddress,
+        bls_keys: ManagedVec<BlsKey<Self::Api>>,
+    ) {
+        self.validator_add_bls_keys_event(validator, bls_keys);
+    }
+
+    #[inline]
+    fn emit_validator_remove_bls_keys_event(
+        &self,
+        validator: ManagedAddress,
+        bls_keys: ManagedVec<BlsKey<Self::Api>>,
+    ) {
+        self.validator_remove_bls_keys_event(validator, bls_keys);
+    }
+
+    #[inline]
+    fn emit_validator_set_fee_event(&self, validator: ManagedAddress, fee_percent: Percent) {
+        self.validator_set_fee_event(validator, fee_percent);
+    }
+
+    #[inline]
+    fn emit_validator_set_max_delegation_event(
+        &self,
+        validator: ManagedAddress,
+        max_delegation: BigUint,
+    ) {
+        self.validator_set_max_delegation_event(validator, max_delegation);
+    }
+
+    #[inline]
+    fn emit_validator_add_own_delegation_event(
+        &self,
+        validator: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    ) {
+        self.validator_add_own_delegation_event(validator, payments);
+    }
+
+    // Events
+
+    #[event("validatorRegisterEvent")]
+    fn validator_register_event(&self, #[indexed] validator: ManagedAddress, name: ManagedBuffer);
+
+    #[event("validatorAddBlsKeysEvent")]
+    fn validator_add_bls_keys_event(
+        &self,
+        #[indexed] validator: ManagedAddress,
+        bls_keys: ManagedVec<BlsKey<Self::Api>>,
+    );
+
+    #[event("validatorRemoveBlsKeysEvent")]
+    fn validator_remove_bls_keys_event(
+        &self,
+        #[indexed] validator: ManagedAddress,
+        bls_keys: ManagedVec<BlsKey<Self::Api>>,
+    );
+
+    #[event("validatorSetFeeEvent")]
+    fn validator_set_fee_event(&self, #[indexed] validator: ManagedAddress, fee_percent: Percent);
+
+    #[event("validatorSetMaxDelegationEvent")]
+    fn validator_set_max_delegation_event(
+        &self,
+        #[indexed] validator: ManagedAddress,
+        max_delegation: BigUint,
+    );
+
+    #[event("validatorAddOwnDelegationEvent")]
+    fn validator_add_own_delegation_event(
+        &self,
+        #[indexed] validator: ManagedAddress,
+        payments: PaymentsVec<Self::Api>,
+    );
+}

gravity-restaking/src/lib.rs

@@ -4,6 +4,7 @@ use user_actions::sovereign::Epoch;
 
 multiversx_sc::imports!();
 
+pub mod events;
 pub mod token_whitelist;
 pub mod unique_payments;
 pub mod user_actions;
@@ -18,6 +19,9 @@ pub trait GravityRestaking:
     + user_actions::common_actions::CommonActionsModule
     + user_actions::common_storage::CommonStorageModule
     + user_actions::unbond::UnbondModule
+    + events::user_events::UserEventsModule
+    + events::validator_events::ValidatorEventsModule
+    + events::sov_events::SovEventsModule
     + utils::UtilsModule
 {
     #[init]

gravity-restaking/src/user_actions/call_delegation.rs

@@ -28,6 +28,9 @@ pub trait CallDelegationModule:
     + super::unbond::UnbondModule
     + super::common_actions::CommonActionsModule
     + super::common_storage::CommonStorageModule
+    + crate::events::user_events::UserEventsModule
+    + crate::events::validator_events::ValidatorEventsModule
+    + crate::events::sov_events::SovEventsModule
     + utils::UtilsModule
 {
     #[endpoint(moveStakeToReStaking)]
@@ -59,26 +62,30 @@ pub trait CallDelegationModule:
         original_value: BigUint,
         #[call_result] call_result: ManagedAsyncCallResult<()>,
     ) {
-        if let ManagedAsyncCallResult::Ok(()) = call_result {
-            let ids_mapper = self.user_ids();
-            let mut caller_id = ids_mapper.get_id(&original_caller);
-            let mut user_tokens = if caller_id == NULL_ID {
-                caller_id = ids_mapper.insert_new(&original_caller);
+        if call_result.is_err() {
+            return;
+        }
 
-                UniquePayments::new()
-            } else {
-                self.user_tokens(caller_id).get()
-            };
+        let ids_mapper = self.user_ids();
+        let mut caller_id = ids_mapper.get_id(&original_caller);
+        let mut user_tokens = if caller_id == NULL_ID {
+            caller_id = ids_mapper.insert_new(&original_caller);
 
-            let egld_payment = EsdtTokenPayment::new(
-                TokenIdentifier::from_esdt_bytes(EGLD_TOKEN_ID),
-                0,
-                original_value,
-            );
-            user_tokens.add_payment(egld_payment);
+            UniquePayments::new()
+        } else {
+            self.user_tokens(caller_id).get()
+        };
 
-            self.user_tokens(caller_id).set(user_tokens);
-        }
+        let egld_payment = EsdtTokenPayment::new(
+            TokenIdentifier::from_esdt_bytes(EGLD_TOKEN_ID),
+            0,
+            original_value.clone(),
+        );
+        user_tokens.add_payment(egld_payment);
+        self.user_tokens(caller_id).set(user_tokens);
+
+        let delegation = self.blockchain().get_caller();
+        self.emit_move_stake_event(original_caller, delegation, original_value);
     }
 
     #[proxy]