Merge pull request #127 from diogosequeira94/main

cadi team challenge submission

Author: postnutcIarity

smaller-challenges/cadi-team/Cargo.toml

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

smaller-challenges/cadi-team/src/lib.rs

@@ -0,0 +1,205 @@
+se scrypto::prelude::*;
+
+ blueprint! {
+     struct CadiTeamEscrow {
+         vaults: BTreeMap<ResourceSpecifier, Vault>,
+         obligation_non_fungible_resource: ResourceAddress,
+         is_escrow_fulfilled: bool
+     }
+
+     impl CadiTeamEscrow {
+         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 is invalid"
+             );
+             assert!(
+                 to_be_paid_by_party_1.validate().is_ok(),
+                 "Second resource is invalid"
+             );
+             assert_ne!(
+                 to_be_paid_by_party_1, to_be_paid_by_party_2,
+                 "they are not equal"
+             );
+
+             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_obligations: Bucket = ResourceBuilder::new_non_fungible()
+                .metadata("name", "Escrow Obligation")
+                .metadata("symbol", "ESCROW")
+                .metadata("description", "This resource describes the obligation of the two parties involved in the exchange")
+                .metadata("team-member-1-github-username", "andrealupini")
+                .metadata("team-member-2-github-username", "gitpck")
+                .metadata("team-member-1-github-username", "diogosequeira94")
+                .metadata("team-member-2-github-username", "ianmac2")
+                 .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_obligations.resource_address(),
+                 is_escrow_fulfilled: false
+             }
+             .instantiate()
+             .globalize();
+
+             (component_address, escrow_obligations)
+
+         }
+
+         pub fn deposit(&mut self, obligation_badge: Proof, mut funds: Bucket) -> Bucket {
+             /// First we need to make sure if the person passed the proper obligation badge (we have created)
+             let obligation_badge: ValidatedProof = obligation_badge
+                 .validate_proof(self.obligation_non_fungible_resource)
+                 .expect("Invalid badge");
+             /// After this lets get the data on the badge
+             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);
+             funds
+         }
+
+         pub fn withdraw(&mut self, obligation_badge: Proof) -> Bucket {
+             assert!(
+                 self.is_escrow_fulfilled(),
+                 "You can not withdraw your funds unless the  escrow is not concluded",
+             );
+
+             let obligation_badge: ValidatedProof = obligation_badge
+                 .validate_proof(self.obligation_non_fungible_resource)
+                 .expect("invalid badge provider");
+
+             let obligation: EscrowObligation = obligation_badge.non_fungible().data();
+             let vault: &mut Vault = self.vaults.get_mut(&obligation.amount_to_get).unwrap();
+             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 {
+                             ResourceSpecifier::Fungible {
+                                 resource_address,
+                                 amount,
+                             } => {
+                                 vault.resource_address() == *resource_address
+                                     && vault.amount() >= *amount
+                             }
+
+                             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(())
+                 }
+             }
+         }
+     }
+
+     pub fn resource_address(&self) -> ResourceAddress {
+         match self {
+             Self::Fungible {
+                 resource_address, ..
+             }
+             | Self::NonFungible {
+                 resource_address, ..
+             } => *resource_address,
+         }
+     }
+}

smaller-challenges/cadi-team/tests/lib.rs

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