first

Author: MisoShiru69

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,76 @@
+use scrypto::prelude::*;
+
+#[derive(NonFungibleData)]
+pub struct LoanDue {
+    pub amount_due: Decimal,
+}
+
+blueprint! {
+    struct FlashLoan {
+        loan_vault: Vault,
+        auth_vault: Vault,
+        transient_resource_address: ResourceAddress,
+    }
+
+    impl FlashLoan {
+        pub fn new(initial_liquidity: Bucket) -> ComponentAddress {
+
+            let auth_token = ResourceBuilder::new_fungible()
+                .metadata("name", "Flash Loan Auth")
+                .initial_supply(1);
+
+            // Define a "transient" resource which can never be deposited once created.
+            let address = ResourceBuilder::new_non_fungible()
+                .metadata(
+                    "name",
+                    "Promise token for BasicFlashLoan - must be returned to be burned!",
+                )
+                .mintable(rule!(require(auth_token.resource_address())), LOCKED)
+                .burnable(rule!(require(auth_token.resource_address())), LOCKED)
+                .restrict_deposit(rule!(deny_all), LOCKED)
+                .no_initial_supply();
+
+            Self {
+                loan_vault: Vault::with_bucket(initial_liquidity),
+                auth_vault: Vault::with_bucket(auth_token),
+                transient_resource_address: address,
+            }
+            .instantiate()
+            .globalize()
+        }
+
+        pub fn take_loan(&mut self, loan_amount: Decimal) -> (Bucket, Bucket) {
+            assert!(
+                loan_amount <= self.loan_vault.amount(),
+                "Not enough liquidity to supply this loan!"
+            );
+            let amount_due = loan_amount * dec!("1.001");
+
+            let loan_terms = self.auth_vault.authorize(|| {
+                borrow_resource_manager!(self.transient_resource_address).mint_non_fungible(
+                    &NonFungibleId::random(),
+                    LoanDue {
+                        amount_due: amount_due,
+                    },
+                )
+            });
+            (self.loan_vault.take(loan_amount), loan_terms)
+        }
+
+        pub fn repay_loan(&mut self, loan_repayment: Bucket, loan_terms: Bucket) {
+            assert!(
+                loan_terms.resource_address() == self.transient_resource_address,
+                "Incorrect resource passed in for loan terms"
+            );
+
+            let terms: LoanDue = loan_terms.non_fungible().data();
+            assert!(
+                loan_repayment.amount() >= terms.amount_due,
+                "Insufficient repayment given for your loan!"
+            );
+
+            self.loan_vault.put(loan_repayment);
+            self.auth_vault.authorize(|| loan_terms.burn());
+        }
+    }
+}

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

@@ -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();
+        }
+
+    }
+}