Merge pull request #97 from MisoShiru69/main

Indexer

Author: klembee

4-portfolio-management-yield-farming/indexer/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "indexer"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sbor = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.4.1" }
+scrypto = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.4.1" }
+
+[dev-dependencies]
+radix-engine = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.4.1" }
+
+[profile.release]
+opt-level = 's'     # Optimize for size.
+lto = true          # Enable Link Time Optimization.
+codegen-units = 1   # Reduce number of codegen units to increase optimizations.
+panic = 'abort'     # Abort on panic.
+strip = "debuginfo" # Strip debug info.
+
+[lib]
+crate-type = ["cdylib", "lib"]

4-portfolio-management-yield-farming/indexer/README.md

@@ -0,0 +1,43 @@
+use scrypto::prelude::*;
+
+blueprint! {
+    struct IndexPool {
+
+        //index pool vault that holds tokens
+        index_pool:Vault
+    }
+
+    impl IndexPool {
+
+        pub fn new(
+            resource_address:ResourceAddress
+        ) -> ComponentAddress {
+            let component = Self {
+                index_pool:Vault::new(resource_address)
+            }
+            .instantiate()
+            .globalize();
+            return component;
+        }
+
+        //Deposit tokens into index pool vault
+        pub fn deposit(&mut self, tokens:Bucket){
+            self.index_pool.put(tokens);
+        }
+
+        //Get blance of index pool vault
+        pub fn balance(&self) -> Decimal {
+            return self.index_pool.amount();
+        }
+
+        //Withdraws tokens from index pool vault
+        pub fn withdraw(&mut self, amount:Decimal) -> Bucket {
+            return self.index_pool.take(amount);
+        }
+
+        pub fn take_all(&mut self) -> Bucket {
+            return self.index_pool.take_all();
+        }
+
+    }
+}

4-portfolio-management-yield-farming/indexer/src/index_pool.rs

@@ -0,0 +1,8 @@
+mod oracle1;
+mod oracle2;
+mod indexer;
+mod index_pool;
+mod ociswap;
+mod oci_pools;
+mod radex;
+mod radex_pools;

4-portfolio-management-yield-farming/indexer/src/indexer.rs

@@ -0,0 +1,40 @@
+use scrypto::prelude::*;
+
+blueprint! {
+    
+    struct OciPool {
+
+        //Vault to hold liquidity for trading 
+        oci_pool:Vault
+    }
+
+    impl OciPool {
+
+        pub fn new(
+            resource_address:ResourceAddress
+        ) -> ComponentAddress {
+            let component = Self {
+                oci_pool:Vault::new(resource_address)
+            }
+            .instantiate()
+            .globalize();
+            return component;
+            
+        }
+
+        //Method to deposit funds into Ociswap pools
+        pub fn deposit(&mut self, tokens:Bucket){
+            self.oci_pool.put(tokens);
+        }
+
+        //Method to withdraw funds from Ociswap pools
+        pub fn withdraw(&mut self, token_amount:Decimal)->Bucket{
+            return self.oci_pool.take(token_amount);
+        }
+
+        //Method to get balance
+        pub fn balance(&self) -> Decimal {
+            return self.oci_pool.amount();
+        }
+    }
+}

4-portfolio-management-yield-farming/indexer/src/lib.rs

@@ -0,0 +1,126 @@
+use scrypto::prelude::*;
+use crate::oracle1::*;
+use crate::oci_pools::*;
+
+blueprint! {
+    struct Ociswap {
+
+        //Hashmap to store resource address to token vaults
+        oci_pool:HashMap<ResourceAddress, OciPool>,
+
+        //This stores the ocracle component address
+        oracle1_address:Option<ComponentAddress>,
+    }
+
+    impl Ociswap {
+        
+        pub fn new() -> ComponentAddress{
+            let component = Self {
+                oci_pool:HashMap::new(),
+                oracle1_address:None,
+                }
+                .instantiate()
+                .globalize();
+                return component;
+        }
+        
+        //Create a pool of tokens which will be used to trade with on Ociswap
+        pub fn create_pool(&mut self, token_address:ResourceAddress) {
+            //Uses the oci pool blueprint to create an ociswap pool component
+            let new_oci_pool:ComponentAddress = OciPool::new(token_address);
+
+            //Update hashmap with resource address and oci pool component
+            self.oci_pool.insert(token_address, new_oci_pool.into());
+        }
+
+        //Add tokens to the created pools
+        pub fn add_liquidity(&mut self, token:Bucket) {
+
+            //Get the tokens resource address
+            let token_address = token.resource_address();
+
+            //Get the component from the oci pool hashmap using the tokens resource address
+            let token_address:&OciPool = self.oci_pool.get(&token_address).unwrap();
+
+            //Deposit tokens into component's vault 
+            token_address.deposit(token);
+        }
+
+        //Remove tokens from liquidity pools
+        pub fn remove_liquidity(&mut self, token_amount:Decimal, token_address:ResourceAddress)->Bucket {
+
+            //Get the component from the oci pool hashmap using the tokens resource address
+            let token_component:&OciPool = self.oci_pool.get(&token_address).unwrap();
+
+            //Withdraw tokens from component's vault 
+            let return_bucket:Bucket = token_component.withdraw(token_amount);
+
+            return return_bucket;
+        }
+
+
+
+        //Swap tokens by providing a bucket of tokens and the resource address wanted token 
+        pub fn swap(&mut self, token1:Bucket, token2_address:ResourceAddress ) -> Bucket{
+
+            //Determine how many tokens are in the bucket
+            let token1_amount:Decimal = token1.amount();
+
+            //Determing the resource address
+            let token1_address:ResourceAddress = token1.resource_address();
+
+            //Get the componet from the oci pool hashmap using the resource address of the deposited token
+            let oci_pool_address1:&OciPool = self.oci_pool.get(&token1_address).unwrap();
+
+            //Deposit the token into the oci pool component
+            oci_pool_address1.deposit(token1);
+
+            //Get the component from the oci pool hashmap using the resource address of the wanted token
+            let oci_pool_address2:&OciPool = self.oci_pool.get(&token2_address).unwrap();
+
+            //Get the Oracle component
+            let oracle1_component_address:ComponentAddress  = self.oracle1_address.unwrap();
+            let oracle1_compoent:Oracle1 = oracle1_component_address.into();
+
+            //Get the price of deposited token
+            let oracle1_price1:Decimal = oracle1_compoent.get_price(token1_address).into();
+            info!("[NOTE] The price of {:?} is {} USD",borrow_resource_manager!(token1_address).metadata(), oracle1_price1);
+
+            //Get the price of the wanted token
+            let oracle_price2:Decimal = oracle1_compoent.get_price(token2_address.into());
+            info!("[NOTE] The price of {:?} is {} USD",borrow_resource_manager!(token2_address).metadata(), oracle_price2);
+
+            //Calculate the amount of the wanted token based on the price of the tokens
+            let return_amount:Decimal = (token1_amount * oracle1_price1) / oracle_price2;
+            info!("[CALC] {} tokens X ${} per token = ${}",token1_amount, oracle1_price1, (token1_amount * oracle1_price1));
+            info!("[CALC] ${} / ${} per token = {} tokens",(token1_amount * oracle1_price1), oracle_price2, return_amount);
+            info!("[FINAL] {} {:?} has been deposited",return_amount, borrow_resource_manager!(token2_address).metadata());
+            info!("------------------------------------------------------------------------------------");
+
+            //Withdraw wanted token from the Ociswap pool component
+            let return_bucket:Bucket = oci_pool_address2.withdraw(return_amount);
+
+            //Returned swapped token to user
+            return return_bucket;
+        }
+
+        //Assign Oracle component address
+        pub fn oracle1_address(&mut self, oracle1_address:ComponentAddress){
+            self.oracle1_address = Some(oracle1_address);
+            info!("{}", self.oracle1_address.unwrap());
+        }
+
+        //This method shows the balance of the liquidity pools
+        pub fn show_liquidity_pool(&self){
+            info!("LIQUIDITY POOL BALANCES");
+            for (resource_address, component_address) in &self.oci_pool {
+                let oci_pool_component:&OciPool = component_address;
+                let balance = oci_pool_component.balance();
+                info!("TOKEN:[{:?}] *** TOKEN BALANCE: {} ",borrow_resource_manager!(*resource_address).metadata(), balance);
+            }
+        }
+    }
+}
+
+        
+

4-portfolio-management-yield-farming/indexer/src/oci_pools.rs

@@ -0,0 +1,34 @@
+use scrypto::prelude::*;
+
+blueprint! {
+    struct Oracle1 {
+
+        //Hashmap used to store token prices
+        token_price: HashMap<ResourceAddress, Decimal>,
+
+    }
+
+    impl Oracle1 {
+        
+        pub fn new() -> ComponentAddress{
+
+            let component = Self {
+                token_price: HashMap::new(),
+                }
+                .instantiate()
+                .globalize();
+                return component;
+        }
+
+        //Method used to set token prices
+        pub fn set_price(&mut self, token_address:ResourceAddress, price:Decimal) {
+            self.token_price.insert(token_address, price);
+        }
+
+        //Method used to get token prices
+        pub fn get_price(&self, token_address: ResourceAddress) -> Decimal{
+            let token_price:Decimal = *self.token_price.get(&token_address).unwrap();
+            return token_price;
+        }
+    }  
+}

4-portfolio-management-yield-farming/indexer/src/ociswap.rs

@@ -0,0 +1,34 @@
+use scrypto::prelude::*;
+
+blueprint! {
+    struct Oracle2 {
+
+        //Hashmap used to store token prices
+        token_price: HashMap<ResourceAddress, Decimal>,
+
+    }
+
+    impl Oracle2 {
+        
+        pub fn new() -> ComponentAddress{
+
+            let component = Self {
+                token_price: HashMap::new(),
+                }
+                .instantiate()
+                .globalize();
+                return component;
+        }
+
+        //Method used to set token prices
+        pub fn set_price(&mut self, token_address:ResourceAddress, price:Decimal) {
+            self.token_price.insert(token_address, price);
+        }
+
+        //Method used to get token prices
+        pub fn get_price(&self, token_address: ResourceAddress) -> Decimal{
+            let token_price:Decimal = *self.token_price.get(&token_address).unwrap();
+            return token_price;
+        }
+    }  
+}