Merge pull request #126 from J-Son89/main

Lisboa

Author: postnutcIarity

smaller-challenges/escrow/.gitignore renamed to smaller-challenges/escrow-alfacinhas/.gitignore

@@ -0,0 +1,24 @@
+[package]
+name = "escrow"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sbor = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.6.0" }
+scrypto = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.6.0" }
+
+[dev-dependencies]
+transaction = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.6.0" }
+radix-engine = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.6.0" }
+scrypto-unit = { git = "https://github.com/radixdlt/radixdlt-scrypto", tag = "v0.6.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"]

smaller-challenges/escrow-alfacinhas/Cargo.toml

@@ -0,0 +1,224 @@
+use scrypto::prelude::*;
+
+blueprint! {
+    struct Escrow {
+        vaults: BTreeMap<ResourceSpecifier, Vault>,
+
+        /// verify that the NFT badges presented to the component match this [`ResourceAddress`].
+        obligation_non_fungible_resource: ResourceAddress,
+        is_escrow_fulfilled: bool
+    }
+
+    impl Escrow {
+       
+        pub fn instantiate_escrow(
+            to_be_paid_by_party_1: ResourceSpecifier,
+            to_be_paid_by_party_2: ResourceSpecifier,
+        ) -> (ComponentAddress, Bucket) {
+            assert!(to_be_paid_by_party_1.validate().is_ok(), 
+            "first resource specifier is not valid");
+
+            assert!(to_be_paid_by_party_2.validate().is_ok(), 
+            "second resource specifier is not valid");
+
+            assert_ne!(to_be_paid_by_party_1,to_be_paid_by_party_2,"resources can not be the same");
+            
+            let party_1_obligation: EscrowObligation = EscrowObligation {
+                amount_to_pay: to_be_paid_by_party_1.clone(),
+                amount_to_get: to_be_paid_by_party_2.clone()
+            };
+
+            let party_2_obligation: EscrowObligation = EscrowObligation {
+                amount_to_pay: to_be_paid_by_party_2.clone(),
+                amount_to_get: to_be_paid_by_party_1.clone()
+            };
+
+            let escrow_obligation: Bucket = ResourceBuilder::new_non_fungible()
+            .metadata("name", "Escrow Obligation")
+            .metadata("symbol", "ESCROW")
+            .metadata("description", "obligation of two parties")
+            .metadata("team-member-1-github-username", "lucas-r-oliveira")
+            .metadata("team-member-2-github-username", "toastiixd")
+            .metadata("team-member-3-github-username", "J-Son89")
+            .metadata("team-member-4-github-username", "aschenkuttel")
+            .initial_supply([
+                (
+                    NonFungibleId:: from_u32(1),
+                    party_1_obligation
+                ),
+                (
+                    NonFungibleId:: from_u32(2),
+                    party_2_obligation
+                ),
+            ]);
+
+            let mut vaults: BTreeMap<ResourceSpecifier, Vault> = BTreeMap:: new();
+            vaults.insert (
+                to_be_paid_by_party_1.clone(),
+                Vault::new(to_be_paid_by_party_1.resource_address())
+            );
+            vaults.insert(
+                to_be_paid_by_party_2.clone(),
+                Vault::new(to_be_paid_by_party_2.resource_address())
+            );
+
+            let component_address: ComponentAddress = Self {
+                vaults,
+                obligation_non_fungible_resource: escrow_obligation.resource_address(),
+                is_escrow_fulfilled: false
+            }
+            .instantiate()
+            .globalize();
+
+            (component_address, escrow_obligation)
+        }
+
+        
+        pub fn deposit(&mut self, obligation_badge: Proof, mut funds: Bucket) -> (Bucket, Option<Bucket> ){
+            let obligation_badge: ValidatedProof = obligation_badge
+            .validate_proof(self.obligation_non_fungible_resource)
+            .expect("Invalid badge provided");
+
+            let obligation: EscrowObligation = obligation_badge.non_fungible().data();
+            let vault: &mut Vault =  self.vaults.get_mut(&obligation.amount_to_pay).unwrap();
+
+            let funds_to_deposit: Bucket = match obligation.amount_to_pay {
+                ResourceSpecifier::Fungible { amount, .. } => funds.take(amount),
+                ResourceSpecifier::NonFungible {non_fungible_ids, ..} => funds.take_non_fungibles(&non_fungible_ids)
+            };
+
+            vault.put(funds_to_deposit);
+
+            if self.is_escrow_fulfilled() {
+                let obligation: EscrowObligation = obligation_badge.non_fungible().data();
+
+                let vault: &mut Vault =  self.vaults.get_mut(&obligation.amount_to_get).unwrap();
+    
+                return (funds, Some(vault.take_all()));
+            }
+
+            (funds, None)
+        }
+
+        
+        pub fn withdraw(&mut self, obligation_badge: Proof) -> Bucket {
+            assert!(self.is_escrow_fulfilled(),"escrow not fulfilled");
+
+
+            let obligation_badge: ValidatedProof = obligation_badge
+            .validate_proof(self.obligation_non_fungible_resource)
+            .expect("Invalid badge provided");
+
+            let obligation: EscrowObligation = obligation_badge.non_fungible().data();
+
+            let vault: &mut Vault =  self.vaults.get_mut(&obligation.amount_to_get).unwrap();
+
+            return vault.take_all();
+        }
+
+       
+        pub fn is_escrow_fulfilled(&mut self) -> bool {
+            if self.is_escrow_fulfilled {
+                self.is_escrow_fulfilled
+            } else {
+                self.is_escrow_fulfilled = self.vaults
+                    .iter()
+                    .map(|(resource_specifier, vault)| {
+                        match resource_specifier {
+                            // If this is a fungible resource specifier, then check that the resource
+                            // address and the amount both match.
+                            ResourceSpecifier::Fungible {
+                                resource_address,
+                                amount,
+                            } => {
+                                vault.resource_address() == *resource_address
+                                    && vault.amount() >= *amount
+                            }
+
+                            // If this is a non-fungible resource specifier then check that the resource
+                            // address matches and that the set of non-fungible ids in the specifier is
+                            // a subset of those in the vault.
+                            ResourceSpecifier::NonFungible {
+                                resource_address,
+                                non_fungible_ids,
+                            } => {
+                                vault.resource_address() == *resource_address
+                                    && vault
+                                        .non_fungible_ids()
+                                        .iter()
+                                        .all(|x| non_fungible_ids.contains(x))
+                            }
+                        }
+                    })
+                    .all(|x| x);
+                self.is_escrow_fulfilled
+            }
+            
+        }
+    }
+}
+
+#[derive(Debug, NonFungibleData)]
+pub struct EscrowObligation {
+    /// The amount of tokens which this party needs to pay to the other party.
+    amount_to_pay: ResourceSpecifier,
+    /// The amount of tokens paid by the other party to this party.
+    amount_to_get: ResourceSpecifier,
+}
+
+
+#[derive(Debug, TypeId, Encode, Decode, Describe, Ord, PartialOrd, Eq, PartialEq, Clone)]
+pub enum ResourceSpecifier {
+    /// A variant used to specify the amount of a fungible resource through the [`ResourceAddress`]
+    /// of the resource the amount of that resource as a [`Decimal`].
+    Fungible {
+        resource_address: ResourceAddress,
+        amount: Decimal,
+    },
+    /// A variant used to specify non-fungible of that resource based on the [`ResourceAddress`] of
+    /// the resource and a set of the [`NonFungibleId`]s being specified by the enum.
+    NonFungible {
+        resource_address: ResourceAddress,
+        non_fungible_ids: BTreeSet<NonFungibleId>,
+    },
+}
+
+impl ResourceSpecifier {
+   
+    pub fn validate(&self) -> Result<(), ()> {
+        match self {
+            Self::Fungible { amount, .. } => {
+                if *amount <= Decimal::zero() {
+                    Err(())
+                } else {
+                    Ok(())
+                }
+            }
+            Self::NonFungible {
+                non_fungible_ids, ..
+            } => {
+                if non_fungible_ids.is_empty() {
+                    Err(())
+                } else {
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    /// Gets the resource address of the specified resource.
+    ///
+    /// # Returns
+    ///
+    /// [`ResourceAddress`] - The resource address of the specified resource.
+    pub fn resource_address(&self) -> ResourceAddress {
+        match self {
+            Self::Fungible {
+                resource_address, ..
+            }
+            | Self::NonFungible {
+                resource_address, ..
+            } => *resource_address,
+        }
+    }
+}

smaller-challenges/escrow-alfacinhas/src/lib.rs

@@ -0,0 +1,16 @@
+CALL_METHOD 
+    ComponentAddress("${account1}") 
+    "lock_fee" 
+    Decimal("100");
+
+CALL_FUNCTION
+    PackageAddress("${package}")
+    "Escrow"
+    "instantiate_escrow"
+    Enum("Fungible", ResourceAddress("${token1}"), Decimal("20"))
+    Enum("Fungible", ResourceAddress("${token2}"), Decimal("300"));
+
+CALL_METHOD
+    ComponentAddress("${account1}") 
+    "deposit_batch" 
+    Expression("ENTIRE_WORKTOP");

smaller-challenges/escrow-alfacinhas/transactions/1-escrow_component_setup.rtm

@@ -0,0 +1,15 @@
+CALL_METHOD 
+    ComponentAddress("${account1}") 
+    "lock_fee" 
+    Decimal("100");
+
+CALL_METHOD
+    ComponentAddress("${account1}") 
+    "withdraw_by_ids" 
+    Set<NonFungibleId>(NonFungibleId("0902000000"))
+    ResourceAddress("${obligation_nft}");
+
+CALL_METHOD 
+    ComponentAddress("${account2}") 
+    "deposit_batch" 
+    Expression("ENTIRE_WORKTOP");