Add rewards to Everstake staking

apps/parser/src/consumers/fetch_token_addresses_consumer.rs

@@ -65,7 +65,7 @@ impl MessageConsumer<ChainAddressPayload, usize> for FetchTokenAddressesConsumer
         let missing_ids: Vec<_> = asset_ids.into_iter().filter(|id| !existing_ids.contains(id)).collect();
         let existing_addresses: Vec<_> = non_zero_addresses
             .into_iter()
-            .filter(|addr| AssetId::new(&addr.asset_id).map_or(false, |id| existing_ids.contains(&id)))
+            .filter(|addr| AssetId::new(&addr.asset_id).is_some_and(|id| existing_ids.contains(&id)))
             .collect();
 
         let _ = self

crates/gem_evm/src/everstake/contracts.rs

@@ -13,6 +13,7 @@ sol! {
         function depositedBalanceOf(address account) view returns (uint256);
         function pendingBalanceOf(address account) view returns (uint256);
         function pendingDepositedBalanceOf(address account) view returns (uint256);
+        function restakedRewardOf(address account) view returns (uint256);
         function withdrawRequest(address staker) view returns (WithdrawRequest memory);
         function claimWithdrawRequest() external;
     }

crates/gem_evm/src/everstake/mapper.rs

@@ -50,13 +50,13 @@ pub fn map_withdraw_request_to_delegations(withdraw_request: &WithdrawRequest) -
     delegations
 }
 
-pub fn map_balance_to_delegation(balance: &BigUint, state: DelegationState) -> DelegationBase {
+pub fn map_balance_to_delegation(balance: &BigUint, restaked_reward: &BigUint, state: DelegationState) -> DelegationBase {
     DelegationBase {
         asset_id: AssetId::from_chain(Chain::Ethereum),
         state,
         balance: balance.clone(),
         shares: BigUint::zero(),
-        rewards: BigUint::zero(),
+        rewards: restaked_reward.clone(),
         completion_date: None,
         delegation_id: delegation_id(EVERSTAKE_POOL_ADDRESS, state),
         validator_id: EVERSTAKE_POOL_ADDRESS.to_string(),

crates/gem_evm/src/everstake/state.rs

@@ -14,6 +14,7 @@ pub struct EverstakeAccountState {
     pub pending_balance: BigUint,
     pub pending_deposited_balance: BigUint,
     pub withdraw_request: WithdrawRequest,
+    pub restaked_reward: BigUint,
 }
 
 pub async fn get_everstake_account_state<C: Client + Clone>(
@@ -28,6 +29,7 @@ pub async fn get_everstake_account_state<C: Client + Clone>(
         create_call3(EVERSTAKE_ACCOUNTING_ADDRESS, IAccounting::pendingBalanceOfCall { account }),
         create_call3(EVERSTAKE_ACCOUNTING_ADDRESS, IAccounting::pendingDepositedBalanceOfCall { account }),
         create_call3(EVERSTAKE_ACCOUNTING_ADDRESS, IAccounting::withdrawRequestCall { staker }),
+        create_call3(EVERSTAKE_ACCOUNTING_ADDRESS, IAccounting::restakedRewardOfCall { account }),
     ];
 
     let call_count = calls.len();
@@ -40,12 +42,14 @@ pub async fn get_everstake_account_state<C: Client + Clone>(
     let pending_balance = decode_balance_result::<IAccounting::pendingBalanceOfCall>(&multicall_results[1]);
     let pending_deposited_balance = decode_balance_result::<IAccounting::pendingDepositedBalanceOfCall>(&multicall_results[2]);
     let withdraw_request = decode_call3_return::<IAccounting::withdrawRequestCall>(&multicall_results[3])?;
+    let restaked_reward = decode_balance_result::<IAccounting::restakedRewardOfCall>(&multicall_results[4]);
 
     Ok(EverstakeAccountState {
         deposited_balance,
         pending_balance,
         pending_deposited_balance,
         withdraw_request,
+        restaked_reward,
     })
 }
 

crates/gem_evm/src/provider/staking_ethereum.rs

@@ -42,12 +42,12 @@ impl<C: Client + Clone> EthereumClient<C> {
 
         let active_balance = state.deposited_balance;
         if active_balance > BigUint::zero() {
-            delegations.push(map_balance_to_delegation(&active_balance, DelegationState::Active));
+            delegations.push(map_balance_to_delegation(&active_balance, &state.restaked_reward, DelegationState::Active));
         }
 
         let pending_balance = state.pending_balance + state.pending_deposited_balance;
         if pending_balance > BigUint::zero() {
-            delegations.push(map_balance_to_delegation(&pending_balance, DelegationState::Activating));
+            delegations.push(map_balance_to_delegation(&pending_balance, &BigUint::zero(), DelegationState::Activating));
         }
 
         let mut withdraw_delegations = map_withdraw_request_to_delegations(&state.withdraw_request);
@@ -59,22 +59,23 @@ impl<C: Client + Clone> EthereumClient<C> {
     pub async fn get_ethereum_staking_balance(&self, address: &str) -> Result<Option<AssetBalance>, Box<dyn Error + Sync + Send>> {
         let delegations = self.get_ethereum_delegations(address).await?;
 
-        let staked = delegations
-            .iter()
-            .filter(|d| d.state == DelegationState::Active)
-            .fold(BigUint::zero(), |acc, d| acc + &d.balance);
-
-        let pending = delegations
-            .iter()
-            .filter(|d| {
-                d.state == DelegationState::Activating
-                    || d.state == DelegationState::Deactivating
-                    || d.state == DelegationState::Undelegating
-                    || d.state == DelegationState::AwaitingWithdrawal
-            })
-            .fold(BigUint::zero(), |acc, d| acc + &d.balance);
+        let mut staked = BigUint::zero();
+        let mut rewards = BigUint::zero();
+        let mut pending = BigUint::zero();
+        for delegation in &delegations {
+            match delegation.state {
+                DelegationState::Active => {
+                    staked += &delegation.balance;
+                    rewards += &delegation.rewards;
+                }
+                DelegationState::Activating | DelegationState::Deactivating | DelegationState::Undelegating | DelegationState::AwaitingWithdrawal => {
+                    pending += &delegation.balance;
+                }
+                _ => {}
+            }
+        }
 
-        let balance = Balance::stake_balance(staked, pending, None);
+        let balance = Balance::stake_balance(staked, pending, Some(rewards));
 
         Ok(Some(AssetBalance::new_balance(AssetId::from_chain(Chain::Ethereum), balance)))
     }
@@ -95,8 +96,8 @@ mod tests {
         println!("Delegations for address: {}", address);
         for delegation in &delegations {
             println!(
-                "Delegation - Validator: {}, Balance: {}, State: {:?}",
-                delegation.validator_id, delegation.balance, delegation.state
+                "Delegation - Validator: {}, Balance: {}, Rewards: {}, State: {:?}",
+                delegation.validator_id, delegation.balance, delegation.rewards, delegation.state
             );
         }
 

gemstone/src/models/transaction.rs

@@ -672,10 +672,7 @@ impl From<TransactionInputType> for GemTransactionInputType {
                 asset,
                 account_type: account_type.into(),
             },
-            TransactionInputType::Perpetual(asset, perpetual_type) => GemTransactionInputType::Perpetual {
-                asset,
-                perpetual_type: perpetual_type.into(),
-            },
+            TransactionInputType::Perpetual(asset, perpetual_type) => GemTransactionInputType::Perpetual { asset, perpetual_type },
         }
     }
 }
@@ -891,7 +888,7 @@ impl From<GemTransactionInputType> for TransactionInputType {
             GemTransactionInputType::Generic { asset, metadata, extra } => TransactionInputType::Generic(asset, metadata.into(), extra.into()),
             GemTransactionInputType::TransferNft { asset, nft_asset } => TransactionInputType::TransferNft(asset, nft_asset),
             GemTransactionInputType::Account { asset, account_type } => TransactionInputType::Account(asset, account_type.into()),
-            GemTransactionInputType::Perpetual { asset, perpetual_type } => TransactionInputType::Perpetual(asset, perpetual_type.into()),
+            GemTransactionInputType::Perpetual { asset, perpetual_type } => TransactionInputType::Perpetual(asset, perpetual_type),
         }
     }
 }