Merge pull request #107 from aus87/main

XRDao

Author: klembee

5-DAO/xrdao/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "xrdao"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sbor = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.5.0" }
+scrypto = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.5.0" }
+
+[dev-dependencies]
+transaction = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.5.0" }
+radix-engine = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.5.0" }
+scrypto-unit = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.5.0" }
+
+[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.
+overflow-checks = true # Panic in the case of an overflow.
+
+[lib]
+crate-type = ["cdylib", "lib"]

5-DAO/xrdao/src/lib.rs

@@ -0,0 +1,71 @@
+/// **This submission does not need to be judged due to being incomplete***
+/// 
+/// XRDao protocol is built for medium to long term XRD holders and XRD altcoin
+/// investors that are interested in a sustainable rewards structure.  XRDao is the main
+/// component where most of the interactions take place.  This blueprint allows users to mint 
+/// XRDao which is pegged 1:1 to XRD.  The XRDao token has a small tax taken for every trade, 
+/// transfer, mint, or burn starting at .5% and can change from governance vote.  A percent of platform 
+/// fees (which also can change via governanve vote) go towards buying protocol owned liquidity from the 
+/// radiswap component.  The rest of platform fees collected are distributed to users of XRDao
+/// that make successful trades and strategies  when investing through the platform. Future investment
+/// choices will be added along with altcoin investing such as staking to trustworthy validators, loaning
+/// funds to a lending platform for interest.  In order to use XRDao, a user would send XRD
+/// to the platform and mint XRDao token.  The exchange rate for minting and burning XRDao always remains
+/// 1:1 minus the buy/sell fee.  The user would then use these XRDao tokens to pick investment options
+/// just as they would with XRD, but the platform would be making the actual trades/stakes for you.
+/// When a user makes a successful trade, Repuation (rep) tokens are awarded for the amount of xrd earned.
+/// 
+/// For example:
+///     User 1 has 100 xrd and mints 99.5 xrdao, 
+///     User 1 invests 99.5 xrdao into oci,
+///     Oci goes 2x up in price relative to xrd,
+///     User 1 exits oci position
+///     User 1 sends xrdao to burn in return for xrd
+/// 
+/// User 1 now has 198.005 xrdao tokens that can be burned and exchanged for xrd minus the burn fee, as
+/// well as 1.495 Rep. Rep is a soulbound token created by the XRDao platform to signify who is most profitable
+/// for the platform.  It can't be bought, sold, or traded, but it can be earned and minted for good behavior
+/// or removed and burned for bad behavior.  Users are catagorized into Rank by the amount of rep they hold 
+/// into the following ranks:
+///     
+///    President, Highest rep, linear relationship between xrdao and voting power, top 1% of users, 3x reward multiplier
+///    VicePresident, x = y^1.1 voting power, top 10% of users, 1.67x reward multiplier
+///    Senator, x = y^1.2 voting power, top 30% of users, 1.25x reward multiplier
+///    Governor, x = y^1.3 voting power, top 50% of users, 1x reward multiplier
+///    Citizen, x = y^1.5 voting power, top 75% of users, .925x reward multiplier
+///    Pleb,  Lowest rep, quadratic relationship, x = y^2 voting power, top 100% of users, 0x reward multiplier
+/// 
+/// As you can see, different ranks give different curves to determine voting power and different shares of the
+/// fees generated from the platform.  The more money you make, the more rep you earn, the more fees you acrue.
+/// You might be asking yourself, why wouldnt these users just invest themselves and avoid platform fees
+/// alltogether?  XRDao harneses sustainable revenues from market volatility.  When the protocol buys liquidity
+/// from radiswap for XRDao-XRD, XRD volatility will generate price differences between the two tokens in the pool.
+/// When there is ever a price difference above the fee that is being charged (.5%) there will be a profitable
+/// arbitration opportunity within the pool.  Whether an arbitrage bot or a user makes it, fees are then
+/// generated from that trade and go back to buying more liquidity and rewarding each user based on reputation. 
+/// Reputation is basically earning a share of xrd market volatility combined with platform fees.
+/// 
+/// The majority of my work here is to the xrdaouser and xrdao components.  Tokentax is a start of an attempt to 
+/// design a component that a token must pass through in order to extract taxes from dex transactions.  My 
+/// understanding is this feature doesnt current work at the resource level, but hopefully it will in the
+/// future. Radiswap is instantiated to trade and provide liquidity for XRDao-XRD token.
+/// 
+/// 
+/// XRDaoProposal is a copy paste from the Liquidity DAO scrypto examples that I am in process of modifying to fit
+/// my own purposes.  This component is for creating voting proposals that must be funded and voted on.   Vote weight is calculated by
+/// total xrdao tokens held on the platform and the curve associated with the user's Rank.  Proposals can be challenge
+/// any proposal they deem harmful to the platform by voting with reputation instead of xrdao token balance.
+/// When voting with rep, you stake your rep tokens on the correct outcome of the proposal.  Those on the losing side
+/// of the vote forfeit their tokens to the winning side.  This way the voters with the most conviction on the best 
+/// outcome will be willing to risk their earning power from the platform on the outcome.
+/// 
+/// written by Austin
+/// @aus877 on twitter
+/// @aus87 on telegram
+
+
+mod radiswap;
+mod xrdao;  
+mod xrdaousers;
+mod xrdaoproposal;
+mod tokentax;

5-DAO/xrdao/src/radiswap.rs

@@ -0,0 +1,199 @@
+use scrypto::prelude::*;
+
+blueprint! {
+    struct Radiswap {
+        /// The resource address of LP token.
+        lp_resource_address: ResourceAddress,
+        /// LP tokens mint badge.
+        lp_mint_badge: Vault,
+        /// The reserve for token A.
+        a_pool: Vault,
+        /// The reserve for token B.
+        b_pool: Vault,
+        /// The fee to apply for every swap
+        fee: Decimal,
+        /// The standard (Uniswap-like) DEX follows the X*Y=K rule. Since we enable a user defined 'lp_initial_supply', we need to store this value to recover incase all liquidity is removed from the system.
+        /// Adding and removing liquidity does not change this ratio, this ratio is only changed upon swaps.
+        lp_per_asset_ratio: Decimal,
+    }
+
+    impl Radiswap {
+        /// Creates a Radiswap component for token pair A/B and returns the component address
+        /// along with the initial LP tokens.
+        pub fn instantiate_pool(
+            a_tokens: Bucket,
+            b_tokens: Bucket,
+            lp_initial_supply: Decimal,
+            lp_symbol: String,
+            lp_name: String,
+            lp_url: String,
+            fee: Decimal,
+        ) -> (ComponentAddress, Bucket) {
+            // Check arguments
+            assert!(
+                !a_tokens.is_empty() && !b_tokens.is_empty(),
+                "You must pass in an initial supply of each token"
+            );
+            assert!(
+                fee >= dec!("0") && fee <= dec!("1"),
+                "Invalid fee in thousandths"
+            );
+
+            // Instantiate our LP token and mint an initial supply of them
+            let lp_mint_badge = ResourceBuilder::new_fungible()
+                .divisibility(DIVISIBILITY_NONE)
+                .metadata("name", "LP Token Mint Auth")
+                .initial_supply(1);
+            let lp_resource_address = ResourceBuilder::new_fungible()
+                .divisibility(DIVISIBILITY_MAXIMUM)
+                .metadata("symbol", lp_symbol)
+                .metadata("name", lp_name)
+                .metadata("url", lp_url)
+                .mintable(rule!(require(lp_mint_badge.resource_address())), LOCKED)
+                .burnable(rule!(require(lp_mint_badge.resource_address())), LOCKED)
+                .no_initial_supply();
+
+            let lp_tokens = lp_mint_badge.authorize(|| {
+                borrow_resource_manager!(lp_resource_address).mint(lp_initial_supply)
+            });
+
+            // ratio = initial supply / (x * y) = initial supply / k
+            let lp_per_asset_ratio = lp_initial_supply / (a_tokens.amount() * b_tokens.amount());
+
+            // Instantiate our Radiswap component
+            let radiswap = Self {
+                lp_resource_address,
+                lp_mint_badge: Vault::with_bucket(lp_mint_badge),
+                a_pool: Vault::with_bucket(a_tokens),
+                b_pool: Vault::with_bucket(b_tokens),
+                fee,
+                lp_per_asset_ratio,
+            }
+            .instantiate()
+            .globalize();
+
+            // Return the new Radiswap component, as well as the initial supply of LP tokens
+            (radiswap, lp_tokens)
+        }
+
+        /// Adds liquidity to this pool and return the LP tokens representing pool shares
+        /// along with any remainder.
+        pub fn add_liquidity(&mut self, mut a_tokens: Bucket, mut b_tokens: Bucket) -> (Bucket, Bucket) {
+            // Get the resource manager of the lp tokens
+            let lp_resource_manager = borrow_resource_manager!(self.lp_resource_address);
+
+            // Differentiate LP calculation based on whether pool is empty or not.
+            let (supply_to_mint, remainder) = if lp_resource_manager.total_supply() == 0.into() {
+                // Set initial LP tokens based on previous LP per K ratio.
+                let supply_to_mint =
+                    self.lp_per_asset_ratio * a_tokens.amount() * b_tokens.amount();
+                self.a_pool.put(a_tokens.take(a_tokens.amount()));
+                self.b_pool.put(b_tokens);
+                (supply_to_mint, a_tokens)
+            } else {
+                // The ratio of added liquidity in existing liquidty.
+                let a_ratio = a_tokens.amount() / self.a_pool.amount();
+                let b_ratio = b_tokens.amount() / self.b_pool.amount();
+
+                let (actual_ratio, remainder) = if a_ratio <= b_ratio {
+                    // We will claim all input token A's, and only the correct amount of token B
+                    self.a_pool.put(a_tokens);
+                    self.b_pool
+                        .put(b_tokens.take(self.b_pool.amount() * a_ratio));
+                    (a_ratio, b_tokens)
+                } else {
+                    // We will claim all input token B's, and only the correct amount of token A
+                    self.b_pool.put(b_tokens);
+                    self.a_pool
+                        .put(a_tokens.take(self.a_pool.amount() * b_ratio));
+                    (b_ratio, a_tokens)
+                };
+                (
+                    lp_resource_manager.total_supply() * actual_ratio,
+                    remainder,
+                )
+            };
+
+            // Mint LP tokens according to the share the provider is contributing
+            let lp_tokens = self.lp_mint_badge.authorize(|| {
+                lp_resource_manager.mint(supply_to_mint)
+            });
+
+            // Return the LP tokens along with any remainder
+            (lp_tokens, remainder)
+        }
+
+        /// Removes liquidity from this pool.
+        pub fn remove_liquidity(&mut self, lp_tokens: Bucket) -> (Bucket, Bucket) {
+            assert!(
+                self.lp_resource_address == lp_tokens.resource_address(),
+                "Wrong token type passed in"
+            );
+
+            // Get the resource manager of the lp tokens
+            let lp_resource_manager = borrow_resource_manager!(self.lp_resource_address);
+
+            // Calculate the share based on the input LP tokens.
+            let share = lp_tokens.amount() / lp_resource_manager.total_supply();
+
+            // Withdraw the correct amounts of tokens A and B from reserves
+            let a_withdrawn = self.a_pool.take(self.a_pool.amount() * share);
+            let b_withdrawn = self.b_pool.take(self.b_pool.amount() * share);
+
+            // Burn the LP tokens received
+            self.lp_mint_badge.authorize(|| {
+                lp_tokens.burn();
+            });
+
+            // Return the withdrawn tokens
+            (a_withdrawn, b_withdrawn)
+        }
+
+        /// Swaps token A for B, or vice versa.
+        pub fn swap(&mut self, input_tokens: Bucket) -> Bucket {
+            // Get the resource manager of the lp tokens
+            let lp_resource_manager = borrow_resource_manager!(self.lp_resource_address);
+            
+            // Calculate the swap fee
+            let fee_amount = input_tokens.amount() * self.fee;
+
+            let output_tokens = if input_tokens.resource_address() == self.a_pool.resource_address() {
+                // Calculate how much of token B we will return
+                let b_amount = self.b_pool.amount()
+                    - self.a_pool.amount() * self.b_pool.amount()
+                        / (input_tokens.amount() - fee_amount + self.a_pool.amount());
+
+                // Put the input tokens into our pool
+                self.a_pool.put(input_tokens);
+
+                // Return the tokens owed
+                self.b_pool.take(b_amount)
+            } else {
+                // Calculate how much of token A we will return
+                let a_amount = self.a_pool.amount()
+                    - self.a_pool.amount() * self.b_pool.amount()
+                        / (input_tokens.amount() - fee_amount + self.b_pool.amount());
+
+                // Put the input tokens into our pool
+                self.b_pool.put(input_tokens);
+
+                // Return the tokens owed
+                self.a_pool.take(a_amount)
+            };
+
+            // Accrued fees change the raio
+            self.lp_per_asset_ratio =
+                lp_resource_manager.total_supply() / (self.a_pool.amount() * self.b_pool.amount());
+
+            output_tokens
+        }
+
+        /// Returns the resource addresses of the pair.
+        pub fn get_pair(&self) -> (ResourceAddress, ResourceAddress) {
+            (
+                self.a_pool.resource_address(),
+                self.b_pool.resource_address(),
+            )
+        }
+    }
+}

5-DAO/xrdao/src/tokentax.rs

@@ -0,0 +1,58 @@
+/// **This submission does not need to be judged due to being incomplete***
+/// 
+/// 
+use scrypto::prelude::*;
+
+blueprint! {
+    struct TokenTax {
+        /// The resource address of token to be taxed
+        resource_address: ResourceAddress,
+        tax: Decimal,
+        tax_vault: Vault,
+    }
+
+    impl TokenTax {
+        /// Creates a Radiswap component for token pair A/B and returns the component address
+        /// along with the initial LP tokens.
+        pub fn new_token_tax(resource_address: ResourceAddress, tax: Decimal, tax_vault: Vault) -> (ComponentAddress, Bucket) {
+            
+            // Check arguments
+            assert!(tax >= dec!("0") && fee <= dec!("1"), "Invalid fee decimal");
+
+            let admin_badge = ResourceBuilder::new_fungible()
+                .divisibility(DIVISIBILITY_NONE)
+                .metadata("name", "TokenTax Admin")
+                .initial_supply(1);
+
+            // Instantiate our Radiswap component
+            let component = Self {
+                admin_badge: admin_badge.resource_address(),
+                admin_vault: Vault::with_bucket(admin_badge),
+                resource_address: resource_address.resource_address(),
+                tax: tax,
+                tax_vault: Vault::new(resource_address),
+            }
+            component.instantiate();
+            component.globalize()
+
+        }
+
+        pub fn take_tax() {
+            /// take in bucket of token
+            /// assert token address matches token address from component
+            /// take tax from bucket, put in xrd_fees_collected vault in xrdao component
+            /// pass remainder back to user
+            /// present admin badge to allow the portion sent back to user to be used in trade/swap/transfer
+        }
+
+        pub fn collect_taxes() {
+            /// require xrdao_access_badge to call this method only
+            /// takes all collected taxes and puts them in xrd_fees_collected in xrdao component
+            taxes = self.tax_vault.empty();
+            taxes // returns bucket of all collected fees
+
+        }
+
+
+    }
+}