feat: get_pool_state in AUX contract

Author: DaveVodrazka

Scarb.toml

@@ -8,7 +8,7 @@ homepage = "https://github.com/CarmineOptions/protocol-cairo1"
 [dependencies]
 # openzeppelin = { git = "https://github.com/OpenZeppelin/cairo-contracts.git", commit = "841a073" }
 cubit = { git = "https://github.com/influenceth/cubit.git", commit = "b4590530d5aeae9aabd36740cc2a3d9e6adc5fde" }
-snforge_std = { git = "https://github.com/foundry-rs/starknet-foundry.git", tag = "v0.10.1"}
+snforge_std = { git = "https://github.com/foundry-rs/starknet-foundry.git", tag = "v0.10.1" }
 starknet = "=2.3.1"
 
 [[target.starknet-contract]]
@@ -20,11 +20,11 @@ test = 'snforge test'
 
 [[tool.snforge.fork]]
 name = "MAINNET"
-url = "https://starknet-mainnet.public.blastapi.io/rpc/v0_7"
+url = "https://starknet.api.onfinality.io/public"
 block_id.tag = "Latest"
 
 
 [[tool.snforge.fork]]
 name = "MAINNET_MISSING_TERMINAL_PRICE"
-url = "https://starknet-mainnet.public.blastapi.io/rpc/v0_7"
+url = "https://starknet.api.onfinality.io/public"
 block_id.number = "1366040"

src/aux_contract.cairo

@@ -1,11 +1,16 @@
 use starknet::ContractAddress;
 use carmine_protocol::types::option_::OptionWithPremia;
+use carmine_protocol::types::pool::{UserPoolInfo, PoolState};
 
 #[starknet::interface]
 trait IAuxContract<TContractState> {
     fn get_all_non_expired_options_with_premia(
         self: @TContractState, lpt_addr: ContractAddress
     ) -> Array<OptionWithPremia>;
+    fn get_user_pool_info(
+        self: @TContractState, user: ContractAddress, lpt_addr: ContractAddress
+    ) -> UserPoolInfo;
+    fn get_pool_state(self: @TContractState, lpt_addr: ContractAddress) -> PoolState;
 }
 
 #[starknet::contract]
@@ -19,10 +24,71 @@ mod AuxContract {
     use carmine_protocol::amm_interface::IAMM;
     use carmine_protocol::amm_interface::{IAMMDispatcher, IAMMDispatcherTrait};
 
+    use carmine_protocol::types::pool::{UserPoolInfo, PoolState};
+    use carmine_protocol::types::pool::{PoolInfo, Pool};
+    use carmine_protocol::erc20_interface::{IERC20Dispatcher, IERC20DispatcherTrait};
+    use cubit::f128::types::fixed::{Fixed, FixedTrait};
+
     use carmine_protocol::amm_core::constants::{
         TOKEN_USDC_ADDRESS, TOKEN_ETH_ADDRESS, TOKEN_WBTC_ADDRESS
     };
 
+
+    #[generate_trait]
+    impl PoolImpl of PoolTrait {
+        fn from_lpt_address(lpt_addr: ContractAddress, amm: IAMMDispatcher) -> Pool {
+            amm.get_pool_definition_from_lptoken_address(lpt_addr)
+        }
+
+        fn lpt_addr(self: Pool, amm: IAMMDispatcher) -> ContractAddress {
+            amm
+                .get_lptoken_address_for_given_option(
+                    self.quote_token_address, self.base_token_address, self.option_type
+                )
+        }
+
+        fn lpool_balance(self: Pool, amm: IAMMDispatcher) -> u256 {
+            amm.get_lpool_balance(self.lpt_addr(amm))
+        }
+
+        fn unlocked_capital(self: Pool, amm: IAMMDispatcher) -> u256 {
+            amm.get_unlocked_capital(self.lpt_addr(amm))
+        }
+
+        fn value_of_position(self: Pool, amm: IAMMDispatcher) -> Fixed {
+            amm.get_value_of_pool_position(self.lpt_addr(amm))
+        }
+
+        fn to_PoolInfo(self: Pool, amm: IAMMDispatcher) -> PoolInfo {
+            PoolInfo {
+                pool: self,
+                lptoken_address: self.lpt_addr(amm),
+                staked_capital: self.lpool_balance(amm),
+                unlocked_capital: self.unlocked_capital(amm),
+                value_of_pool_position: self.value_of_position(amm)
+            }
+        }
+    }
+    #[generate_trait]
+    impl PoolInfoImpl of PoolInfoTrait {
+        fn to_UserPoolInfo(
+            self: PoolInfo, user_address: ContractAddress, amm: IAMMDispatcher
+        ) -> UserPoolInfo {
+            let lptoken_balance = IERC20Dispatcher { contract_address: self.lptoken_address }
+                .balanceOf(user_address);
+
+            let stake_value = amm
+                .get_underlying_for_lptokens(self.lptoken_address, lptoken_balance);
+
+            UserPoolInfo {
+                value_of_user_stake: stake_value,
+                size_of_users_tokens: lptoken_balance,
+                pool_info: self
+            }
+        }
+    }
+
+
     #[storage]
     struct Storage {}
 
@@ -68,6 +134,27 @@ mod AuxContract {
 
             arr
         }
+
+        fn get_user_pool_info(
+            self: @ContractState, user: ContractAddress, lpt_addr: ContractAddress
+        ) -> UserPoolInfo {
+            let amm = IAMMDispatcher { contract_address: AMM_ADDR.try_into().unwrap() };
+            let pool_info = PoolTrait::from_lpt_address(lpt_addr, amm).to_PoolInfo(amm);
+            pool_info.to_UserPoolInfo(user, amm)
+        }
+
+        fn get_pool_state(self: @ContractState, lpt_addr: ContractAddress) -> PoolState {
+            let amm = IAMMDispatcher { contract_address: AMM_ADDR.try_into().unwrap() };
+            let locked = amm.get_pool_locked_capital(lpt_addr);
+            let unlocked = amm.get_unlocked_capital(lpt_addr);
+            let balance = amm.get_lpool_balance(lpt_addr);
+            let position = amm.get_value_of_pool_position(lpt_addr);
+            let value = amm
+                .get_lptokens_for_underlying(
+                    lpt_addr, 1000000000000000000
+                ); // 10**18 - get value of size 1
+
+            PoolState { locked, unlocked, balance, position, value, }
+        }
     }
 }
-

src/types/pool.cairo

@@ -84,3 +84,12 @@ struct UserPoolInfo {
     size_of_users_tokens: u256,
     pool_info: PoolInfo
 }
+
+#[derive(Drop, Serde)]
+struct PoolState {
+    locked: u256,
+    unlocked: u256,
+    balance: u256,
+    position: Fixed,
+    value: u256,
+}