Merge pull request #47 from walterthesmart/fix-issues-5-32

feat(contract): Implement pausable functionality and advanced querying for merchants/invoices

Author: codebestia

contracts/shade/src/components/invoice.rs

@@ -1,8 +1,8 @@
 use crate::components::merchant;
 use crate::errors::ContractError;
 use crate::events;
-use crate::types::{DataKey, Invoice, InvoiceStatus};
-use soroban_sdk::{panic_with_error, Address, Env, String};
+use crate::types::{DataKey, Invoice, InvoiceFilter, InvoiceStatus};
+use soroban_sdk::{panic_with_error, Address, Env, String, Vec};
 
 pub fn create_invoice(
     env: &Env,
@@ -71,3 +71,62 @@ pub fn get_invoice(env: &Env, invoice_id: u64) -> Invoice {
         .get(&DataKey::Invoice(invoice_id))
         .unwrap_or_else(|| panic_with_error!(env, ContractError::InvoiceNotFound))
 }
+
+pub fn get_invoices(env: &Env, filter: InvoiceFilter) -> Vec<Invoice> {
+    let invoice_count: u64 = env
+        .storage()
+        .persistent()
+        .get(&DataKey::InvoiceCount)
+        .unwrap_or(0);
+
+    let mut invoices: Vec<Invoice> = Vec::new(env);
+
+    for i in 1..=invoice_count {
+        if let Some(invoice) = env
+            .storage()
+            .persistent()
+            .get::<_, Invoice>(&DataKey::Invoice(i))
+        {
+            let mut matches = true;
+
+            if let Some(status) = filter.status {
+                if invoice.status as u32 != status {
+                    matches = false;
+                }
+            }
+
+            if let Some(merchant) = &filter.merchant {
+                if let Some(merchant_id) = env
+                    .storage()
+                    .persistent()
+                    .get::<_, u64>(&DataKey::MerchantId(merchant.clone()))
+                {
+                    if invoice.merchant_id != merchant_id {
+                        matches = false;
+                    }
+                } else {
+                    // Merchant not found means no invoices for it
+                    matches = false;
+                }
+            }
+
+            if let Some(min_amount) = filter.min_amount {
+                if invoice.amount < min_amount as i128 {
+                    matches = false;
+                }
+            }
+
+            if let Some(max_amount) = filter.max_amount {
+                if invoice.amount > max_amount as i128 {
+                    matches = false;
+                }
+            }
+
+            if matches {
+                invoices.push_back(invoice);
+            }
+        }
+    }
+
+    invoices
+}

contracts/shade/src/components/merchant.rs

@@ -1,7 +1,7 @@
 use crate::errors::ContractError;
 use crate::events;
-use crate::types::{DataKey, Merchant};
-use soroban_sdk::{panic_with_error, Address, Env};
+use crate::types::{DataKey, Merchant, MerchantFilter};
+use soroban_sdk::{panic_with_error, Address, Env, Vec};
 
 pub fn register_merchant(env: &Env, merchant: &Address) {
     merchant.require_auth();
@@ -74,3 +74,41 @@ pub fn is_merchant(env: &Env, merchant: &Address) -> bool {
         .persistent()
         .has(&DataKey::MerchantId(merchant.clone()))
 }
+
+pub fn get_merchants(env: &Env, filter: MerchantFilter) -> Vec<Merchant> {
+    let merchant_count: u64 = env
+        .storage()
+        .persistent()
+        .get(&DataKey::MerchantCount)
+        .unwrap_or(0);
+
+    let mut merchants: Vec<Merchant> = Vec::new(env);
+
+    for i in 1..=merchant_count {
+        if let Some(merchant) = env
+            .storage()
+            .persistent()
+            .get::<_, Merchant>(&DataKey::Merchant(i))
+        {
+            let mut matches = true;
+
+            if let Some(active) = filter.is_active {
+                if merchant.active != active {
+                    matches = false;
+                }
+            }
+
+            if let Some(verified) = filter.is_verified {
+                if merchant.verified != verified {
+                    matches = false;
+                }
+            }
+
+            if matches {
+                merchants.push_back(merchant);
+            }
+        }
+    }
+
+    merchants
+}

contracts/shade/src/components/mod.rs

@@ -2,4 +2,5 @@ pub mod admin;
 pub mod core;
 pub mod invoice;
 pub mod merchant;
+pub mod pausable;
 pub mod reentrancy;

contracts/shade/src/components/pausable.rs

@@ -0,0 +1,52 @@
+use crate::components::core;
+use crate::errors::ContractError;
+use crate::events;
+use crate::types::DataKey;
+use soroban_sdk::{panic_with_error, Address, Env};
+
+pub fn pause(env: &Env, admin: &Address) {
+    admin.require_auth();
+
+    if core::get_admin(env) != admin.clone() {
+        panic_with_error!(env, ContractError::NotAuthorized);
+    }
+
+    assert_not_paused(env);
+
+    env.storage().persistent().set(&DataKey::Paused, &true);
+
+    events::publish_contract_paused_event(env, admin.clone(), env.ledger().timestamp());
+}
+
+pub fn unpause(env: &Env, admin: &Address) {
+    admin.require_auth();
+
+    if core::get_admin(env) != admin.clone() {
+        panic_with_error!(env, ContractError::NotAuthorized);
+    }
+
+    assert_paused(env);
+
+    env.storage().persistent().set(&DataKey::Paused, &false);
+
+    events::publish_contract_unpaused_event(env, admin.clone(), env.ledger().timestamp());
+}
+
+pub fn is_paused(env: &Env) -> bool {
+    env.storage()
+        .persistent()
+        .get(&DataKey::Paused)
+        .unwrap_or(false)
+}
+
+pub fn assert_paused(env: &Env) {
+    if !is_paused(env) {
+        panic_with_error!(env, ContractError::ContractNotPaused);
+    }
+}
+
+pub fn assert_not_paused(env: &Env) {
+    if is_paused(env) {
+        panic_with_error!(env, ContractError::ContractPaused);
+    }
+}

contracts/shade/src/errors.rs

@@ -12,4 +12,6 @@ pub enum ContractError {
     MerchantNotFound = 6,
     InvalidAmount = 7,
     InvoiceNotFound = 8,
+    ContractPaused = 9,
+    ContractNotPaused = 10,
 }

contracts/shade/src/events.rs

@@ -74,3 +74,23 @@ pub fn publish_invoice_created_event(
     }
     .publish(env);
 }
+
+#[contractevent]
+pub struct ContractPausedEvent {
+    pub admin: Address,
+    pub timestamp: u64,
+}
+
+pub fn publish_contract_paused_event(env: &Env, admin: Address, timestamp: u64) {
+    ContractPausedEvent { admin, timestamp }.publish(env);
+}
+
+#[contractevent]
+pub struct ContractUnpausedEvent {
+    pub admin: Address,
+    pub timestamp: u64,
+}
+
+pub fn publish_contract_unpaused_event(env: &Env, admin: Address, timestamp: u64) {
+    ContractUnpausedEvent { admin, timestamp }.publish(env);
+}

contracts/shade/src/interface.rs

@@ -1,5 +1,5 @@
-use crate::types::{Invoice, Merchant};
-use soroban_sdk::{contracttrait, Address, Env, String};
+use crate::types::{Invoice, InvoiceFilter, Merchant, MerchantFilter};
+use soroban_sdk::{contracttrait, Address, Env, String, Vec};
 
 #[contracttrait]
 pub trait ShadeTrait {
@@ -10,6 +10,7 @@ pub trait ShadeTrait {
     fn is_accepted_token(env: Env, token: Address) -> bool;
     fn register_merchant(env: Env, merchant: Address);
     fn get_merchant(env: Env, merchant_id: u64) -> Merchant;
+    fn get_merchants(env: Env, filter: MerchantFilter) -> Vec<Merchant>;
     fn is_merchant(env: Env, merchant: Address) -> bool;
     fn create_invoice(
         env: Env,
@@ -19,4 +20,9 @@ pub trait ShadeTrait {
         token: Address,
     ) -> u64;
     fn get_invoice(env: Env, invoice_id: u64) -> Invoice;
+    fn get_invoices(env: Env, filter: InvoiceFilter) -> Vec<Invoice>;
+
+    fn pause(env: Env, admin: Address);
+    fn unpause(env: Env, admin: Address);
+    fn is_paused(env: Env) -> bool;
 }

contracts/shade/src/shade.rs

@@ -1,12 +1,12 @@
 use crate::components::{
     admin as admin_component, core as core_component, invoice as invoice_component,
-    merchant as merchant_component,
+    merchant as merchant_component, pausable as pausable_component,
 };
 use crate::errors::ContractError;
 use crate::events;
 use crate::interface::ShadeTrait;
-use crate::types::{ContractInfo, DataKey, Invoice, Merchant};
-use soroban_sdk::{contract, contractimpl, panic_with_error, Address, Env, String};
+use crate::types::{ContractInfo, DataKey, Invoice, InvoiceFilter, Merchant, MerchantFilter};
+use soroban_sdk::{contract, contractimpl, panic_with_error, Address, Env, String, Vec};
 
 #[contract]
 pub struct Shade;
@@ -32,10 +32,12 @@ impl ShadeTrait for Shade {
     }
 
     fn add_accepted_token(env: Env, admin: Address, token: Address) {
+        pausable_component::assert_not_paused(&env);
         admin_component::add_accepted_token(&env, &admin, &token);
     }
 
     fn remove_accepted_token(env: Env, admin: Address, token: Address) {
+        pausable_component::assert_not_paused(&env);
         admin_component::remove_accepted_token(&env, &admin, &token);
     }
 
@@ -44,13 +46,18 @@ impl ShadeTrait for Shade {
     }
 
     fn register_merchant(env: Env, merchant: Address) {
+        pausable_component::assert_not_paused(&env);
         merchant_component::register_merchant(&env, &merchant);
     }
 
     fn get_merchant(env: Env, merchant_id: u64) -> Merchant {
         merchant_component::get_merchant(&env, merchant_id)
     }
 
+    fn get_merchants(env: Env, filter: MerchantFilter) -> Vec<Merchant> {
+        merchant_component::get_merchants(&env, filter)
+    }
+
     fn is_merchant(env: Env, merchant: Address) -> bool {
         merchant_component::is_merchant(&env, &merchant)
     }
@@ -62,10 +69,27 @@ impl ShadeTrait for Shade {
         amount: i128,
         token: Address,
     ) -> u64 {
+        pausable_component::assert_not_paused(&env);
         invoice_component::create_invoice(&env, &merchant, &description, amount, &token)
     }
 
     fn get_invoice(env: Env, invoice_id: u64) -> Invoice {
         invoice_component::get_invoice(&env, invoice_id)
     }
+
+    fn get_invoices(env: Env, filter: InvoiceFilter) -> Vec<Invoice> {
+        invoice_component::get_invoices(&env, filter)
+    }
+
+    fn pause(env: Env, admin: Address) {
+        pausable_component::pause(&env, &admin);
+    }
+
+    fn unpause(env: Env, admin: Address) {
+        pausable_component::unpause(&env, &admin);
+    }
+
+    fn is_paused(env: Env) -> bool {
+        pausable_component::is_paused(&env)
+    }
 }

contracts/shade/src/types.rs

@@ -50,10 +50,27 @@ pub struct Invoice {
 }
 
 #[contracttype]
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[repr(u32)]
 pub enum InvoiceStatus {
-    Pending,
-    Paid,
-    Cancelled,
-    Refunded,
+    Pending = 0,
+    Paid = 1,
+    Cancelled = 2,
+    Refunded = 3,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct MerchantFilter {
+    pub is_active: Option<bool>,
+    pub is_verified: Option<bool>,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct InvoiceFilter {
+    pub status: Option<u32>,
+    pub merchant: Option<Address>,
+    pub min_amount: Option<u128>,
+    pub max_amount: Option<u128>,
 }