Merge pull request #1 from radixdlt/main

Merge from Main repo

Author: yetininoliviercoulibaly

.gitignore

@@ -1,5 +1,6 @@
 # Visual studio code
 .vscode
+.history
 
 # macOS folder attributes
 .DS_Store
@@ -10,4 +11,8 @@ Cargo.lock
 **/*.rs.bk
 
 # Flamegraph profiles
-flamegraph.svg
+flamegraph.svg
+3-lending/LendingDApp/node_modules
+3-lending/LendingDApp/public/lending_dapp.wasm
+3-lending/LendingDApp/public/loan_application.wasm
+3-lending/LendingDApp/TODO.md

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "3-lending/rai-test/RAI-Scrypto-Lending-Platform-PTE"]
+	path = 3-lending/rai-test/RAI-Scrypto-Lending-Platform-PTE
+	url = [email protected]:dekentz/RAI-Scrypto-Lending-Platform-PTE.git

1-exchanges/RaDEX/Cargo.toml

@@ -4,11 +4,11 @@ version = "0.2.0"
 edition = "2021"
 
 [dependencies]
-sbor = { path = "/Users/omarabdulla/radix/radixdlt-scrypto/sbor" }
-scrypto = { path = "/Users/omarabdulla/radix/radixdlt-scrypto/scrypto" }
+sbor = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.4.0" }
+scrypto = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.4.0" }
 
 [dev-dependencies]
-radix-engine = { path = "/Users/omarabdulla/radix/radixdlt-scrypto/radix-engine" }
+radix-engine = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.4.0" }
 
 [profile.release]
 opt-level = 's'     # Optimize for size.
@@ -18,3 +18,4 @@ panic = 'abort'     # Abort on panic.
 
 [lib]
 crate-type = ["cdylib", "lib"]
+

1-exchanges/dexianswap/src/pmm.rs

@@ -382,10 +382,10 @@ blueprint! {
                 sqrt = Decimal::one();
             }
             else {
-                sqrt = Decimal::one();  // sqrt( Decimal::one() + ki * delta / v1  )
+                sqrt = ((Decimal::one() + ki * delta / v1) as f64).sqrt().floor() as Decimal;
             }
 
-            return v1 * (Decimal::one() + sqrt - Decimal::one() / (Decimal(2) * k))
+            return v1 * (Decimal::one() + sqrt - Decimal::one() / (Decimal(2) * k));
         }
 
         fn solve_quadratic_function_for_trade(
@@ -432,7 +432,8 @@ blueprint! {
                 b_abs = b_abs - part2;
             }
 
-            let square_root = Decimal::one(); //sqrt(b_abs * b_abs  + Decimal(4) * (Decimal::one() - k) * v0 * v0 * k);
+            // let square_root = sqrt(b_abs * b_abs  + Decimal(4) * (Decimal::one() - k) * v0 * v0 * k);
+            let square_root = ((b_abs * b_abs  + Decimal(4) * (Decimal::one() - k) * v0 * v0 * k) as f64).sqrt().floor() as Decimal;
 
             let denominator = Decimal(2) * (Decimal::one() - k);
             let mut numerator:Decimal = Decimal::zero();

2-oracles/DexianOracle/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "DexianOracle"
+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"]

2-oracles/DexianOracle/readme.md

@@ -0,0 +1,76 @@
+# DeXianOracle
+
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+## Basic Request Model
+
+![Basic Request Model](res/basic_req_model.png)
+
+#### roles
+###### Consumer
+The `Consumer` is the Radix Engine component that consumes/uses data from the oracle. It make a request to send a certain data consumption request to an explicit oracle component, which also carries some parameter data that can be passed back.
+
+###### OracleComponent
+The `oracle` component, which is the hub of the entire architecture, is responsible for logged consumer requests, managing authorizations and revocations to data providers, as well as accepting data pushed by data providers and initiating callbacks to connected consumers while delivering the data they need, such as: prices, contest results, etc.
+
+It implements permission management through the badge design pattern, and the address with the specified badge can only push data to the `oracle`.
+
+###### DataProvider
+The data provider, which is the functional unit that feeds data from the off-chain data to the on-chain `oracle`, needs to present a specific badge before pushing the data inside the `oracle` component.
+
+#### process
+1. Request with callback
+
+Spend some `XRD`, call Oracle's `request_price` method, and wait for the callback.
+
+2. Oracle request
+3. Feed
+4. Fulfil oracle request
+
+The data provider calls `feed_price` to push the price to the `oracle` and trigger a callback.
+
+5. callback
+
+Callback as requested by the caller of 'request_price`
+
+
+## Decentralized Model
+
+![Decentralized Request Model](res/decentrailized_model.png)
+
+It directly calls `get_price` to get the corresponding price and the epoch (timestamp) when the price was generated.
+
+
+
+## Test (command line)
+
+``` shell
+resim reset
+result=$(resim new-account)
+export user_account=$(echo $result|grep "Account component address: "|awk -F ": " '{print $2}'|awk -F " " '{print $1}')
+export user_account_private=$(echo $result|grep "Account component address: "|awk -F "Private key: " '{print $2}')
+
+result=$(resim publish ".")
+export pkg=$(echo $result | awk -F ": " '{print $2}')
+
+result=$(resim call-function $pkg DeXianOracle new 20)
+export comp=$(echo $result | awk -F "Component: " '{print $2}' | awk -F " " '{print $1}')
+export badge=$(echo $result | awk -F "Resource: " '{print $2}' | awk -F " " '{print $1}')
+
+resim run transactions/user_account_feed.rtm
+
+result=$(resim new-account)
+export user_account2=$(echo $result|grep "Account component address: "|awk -F ": " '{print $2}'|awk -F " " '{print $1}')
+export user_account2_private=$(echo $result|grep "Account component address: "|awk -F "Private key: " '{print $2}')
+
+resim  set-default-account $user_account2 $user_account2_private
+
+resim call-method $comp 'get_price' 'XRD/USD'
+
+resim  set-default-account $user_account $user_account_private
+
+resim run transactions/user_account2_request.rtm 
+
+
+```
+

2-oracles/DexianOracle/res/basic_req_model.png

@@ -0,0 +1,163 @@
+use scrypto::prelude::*;
+
+blueprint! {
+    struct DeXianOracle {
+         /// This is just a reular admin badge, for register/remove DataProvider
+         admin_badge: ResourceAddress,
+        
+         // /// DataProvider badge ResourceDef
+         // dataprovider_badge_def: ResourceDef,
+         // minter
+         callback_minter: Vault,
+        
+         // /// DataProvider badge ResourceDef
+         // dataprovider_badge_def: ResourceDef,
+         
+         /// callbacks
+         callback_vaults: Vault,
+
+         /// callback that have not yet been triggered 
+         unfilful_vec: Vec<NonFungibleId>,
+ 
+         /// fee
+         fee: Decimal,
+ 
+         /// oracle (price, epoch_at) for XRD/USD
+         price_map: HashMap<String, (Decimal, u64)>,
+ 
+         /// balance(fee) vault
+         vault: Vault 
+    }
+    
+    impl DeXianOracle {
+        pub fn new(
+            fee: Decimal
+        ) -> (ComponentAddress, Bucket) {
+            assert!( fee > Decimal::zero(), "invalid fee value.");
+
+            let admin_badge : Bucket = ResourceBuilder::new_fungible()
+                .metadata("name","DeXianOracle Admin Badge").metadata("symbol","DXADM")
+                .initial_supply(Decimal::ONE);
+            
+            let minter_badge = ResourceBuilder::new_fungible()
+                .divisibility(DIVISIBILITY_NONE)
+                .initial_supply(Decimal::ONE);
+            
+            let callback_bucket = ResourceBuilder::new_non_fungible()
+                .metadata("name", "DeXianOracle Callback").metadata("symbol", "DXCB")
+                .mintable(rule!(require(admin_badge.resource_address())), LOCKED)
+                .burnable(rule!(require(admin_badge.resource_address())), LOCKED)
+                .no_initial_supply();
+            
+            let component = Self {
+                admin_badge: admin_badge.resource_address(),
+                price_map: HashMap::new(),
+                vault: Vault::new(RADIX_TOKEN),
+                callback_vaults: Vault::new(callback_bucket),
+                unfilful_vec: Vec::new(),
+                callback_minter: Vault::with_bucket(minter_badge),
+                fee
+            }.instantiate();
+
+            let access_rules = AccessRules::new()
+                .method("feed_price", rule!(require(admin_badge.resource_address())))
+                .method("withdraw_fee", rule!(require(admin_badge.resource_address())))
+                .method("request_price", rule!(allow_all))
+                .method("get_price", rule!(allow_all));
+                // .method("register_dataprovider", rule(!require(admin_badge.resource_address())))
+                // .method("remove_dataprovider", rule(!require(admin_badge.resource_address())));
+
+            (component.add_access_check(access_rules).globalize(), admin_badge)
+
+        }
+
+        pub fn feed_price(&mut self, pair: String, price: String) -> bool {
+            let epoch_at = Runtime::current_epoch();
+            let dec_price = Decimal::from(price.clone());
+            self.price_map.insert(pair.clone(), (dec_price, epoch_at));
+            self.filfull_request(&pair, price.clone(), epoch_at);
+            true
+        }
+
+        pub fn get_price(&self, pair:String) -> (Decimal, u64){
+            assert!(self.price_map.contains_key(&pair), "the pair not exists!");
+            *self.price_map.get(&pair).unwrap()
+        }
+
+        pub fn request_price(&mut self,  fee: Bucket,  pair: String, component: ComponentAddress, 
+            method: String, arg: String) -> NonFungibleId {
+            assert!(fee.amount() >= self.fee, "Fees are lower than required!");
+            self.vault.put(fee);
+
+            let callback_id = NonFungibleId::random();
+            let callback_data = CallbackData::new_instance(callback_id.clone(), component, method, pair, args!(arg));
+
+            let callback = self.callback_minter.authorize(|| {
+                let rm = borrow_resource_manager!(self.callback_vaults.resource_address());
+                rm.mint_non_fungible(&callback_id, callback_data)
+            });
+            // Store the Callback NFR inside this component
+            self.callback_vaults.put(callback);
+            self.unfilful_vec.push(callback_id.clone());
+            callback_id
+        }
+
+        pub fn withdraw_fee(&mut self, amount: Decimal) -> Bucket{
+            assert!(self.vault.amount () < amount, "balance insufficient!");
+
+            self.vault.take(amount)
+        }
+
+        fn filfull_request(&mut self, pair: &String, price: String, epoch_at: u64) {
+            let mut i = 0;
+            while i < self.unfilful_vec.len() {
+                if self.callback_vaults.non_fungible_ids().contains(&self.unfilful_vec[i]){
+                    let callback = self.callback_vaults.take_non_fungible(&self.unfilful_vec[i]);
+                    let callback_data = callback.non_fungible::<CallbackData>().data();
+                    if callback_data.pair.eq(pair) {
+                        callback_data.call(&price, epoch_at);
+                        self.unfilful_vec.remove(i);
+                    }
+                    i += 1;
+                }                
+            }
+        }
+    }
+}
+
+#[derive(NonFungibleData)]
+pub struct CallbackData {
+    /// request id
+    pub id: NonFungibleId,
+
+    pub pair: String,
+
+    /// The target component of the callback
+    pub component: ComponentAddress,
+
+    /// The target method of the callback
+    pub method: String,
+
+    /// The args that should be passed to the target method
+    pub args: Vec<Vec<u8>>,
+}
+
+impl CallbackData {
+    
+    pub fn new_instance(id: NonFungibleId, component: ComponentAddress,
+        method: String, pair: String, args: Vec<Vec<u8>>
+        ) -> Self {
+        
+        Self {
+            args: args.to_vec(),
+            pair,
+            id,
+            component,
+            method
+        }
+    }
+
+    pub fn call(&self, price: &String, epoch_at: u64){
+        Runtime::call_method(self.component, &self.method, args![price.clone(), epoch_at, self.args.to_vec()]);
+    }
+}

2-oracles/DexianOracle/res/decentrailized_model.png

@@ -0,0 +1,32 @@
+use radix_engine::ledger::*;
+use radix_engine::transaction::*;
+use scrypto::prelude::*;
+
+#[test]
+fn test_hello() {
+    // Set up environment.
+    let mut ledger = InMemorySubstateStore::with_bootstrap();
+    let mut executor = TransactionExecutor::new(&mut ledger, false);
+    let (pk, sk, account) = executor.new_account();
+    let package = executor.publish_package(compile_package!()).unwrap();
+
+    // Test the `instantiate_hello` function.
+    let transaction1 = TransactionBuilder::new()
+        .call_function(package, "Hello", "instantiate_hello", args![])
+        .build(executor.get_nonce([pk]))
+        .sign([&sk]);
+    let receipt1 = executor.validate_and_execute(&transaction1).unwrap();
+    println!("{:?}\n", receipt1);
+    assert!(receipt1.result.is_ok());
+
+    // Test the `free_token` method.
+    let component = receipt1.new_component_addresses[0];
+    let transaction2 = TransactionBuilder::new()
+        .call_method(component, "free_token", args![])
+        .call_method_with_all_resources(account, "deposit_batch")
+        .build(executor.get_nonce([pk]))
+        .sign([&sk]);
+    let receipt2 = executor.validate_and_execute(&transaction2).unwrap();
+    println!("{:?}\n", receipt2);
+    assert!(receipt2.result.is_ok());
+}

2-oracles/DexianOracle/src/lib.rs

@@ -0,0 +1,13 @@
+CALL_METHOD 
+    ComponentAddress("${user_account}")
+    "withdraw_by_amount"
+    Decimal("20")
+    ResourceAddress("030000000000000000000000000000000000000000000000000004");
+
+CALL_METHOD
+    ComponentAddress("${user_account}")
+    "create_proof"
+    ResourceAddress("${badge}");
+
+TAKE_FROM_WORKTOP_BY_AMOUNT Decimal("20") ResourceAddress("030000000000000000000000000000000000000000000000000004") Bucket("request_fee");
+CALL_METHOD ComponentAddress("${comp}") "request_price" Bucket("request_fee") "XRD/USD" ComponentAddress("${user_account}") "deposit_batch" "xxx";

2-oracles/DexianOracle/tests/lib.rs

@@ -0,0 +1,7 @@
+CALL_METHOD 
+    ComponentAddress("${user_account}") 
+    "create_proof" 
+    ResourceAddress("${badge}");
+
+
+CALL_METHOD ComponentAddress("${comp}") "feed_price" "XRD/USD" "0.0813";