Implement secure delivery confirmation and escrow release

contracts/delivery_contract/lib.rs

@@ -16,12 +16,20 @@ pub enum DeliveryStatus {
     Cancelled,
 }
 
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DeliveryMetadata {
+    pub recipient: Address,
+}
+
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct DeliveryRecord {
     pub sender: Address,
     pub driver: Option<Address>,
     pub status: DeliveryStatus,
+    pub metadata: DeliveryMetadata,
+    pub delivered_at: Option<u64>,
 }
 
 #[contracttype]
@@ -52,12 +60,14 @@ impl DeliveryContract {
         env.storage().instance().set(&DataKey::EscrowContract, &escrow);
     }
 
-    pub fn create_delivery(env: Env, sender: Address, delivery_id: DeliveryId) {
+    pub fn create_delivery(env: Env, sender: Address, recipient: Address, delivery_id: DeliveryId) {
         sender.require_auth();
         let record = DeliveryRecord {
             sender: sender.clone(),
             driver: None,
             status: DeliveryStatus::Pending,
+            metadata: DeliveryMetadata { recipient },
+            delivered_at: None,
         };
         env.storage().persistent().set(&DataKey::Delivery(delivery_id), &record);
     }
@@ -147,6 +157,53 @@ impl DeliveryContract {
         );
     }
 
+    pub fn confirm_delivery(
+        env: Env,
+        recipient: Address,
+        delivery_id: DeliveryId,
+    ) {
+        recipient.require_auth();
+
+        let key = DataKey::Delivery(delivery_id);
+        let mut delivery: DeliveryRecord = env
+            .storage()
+            .persistent()
+            .get(&key)
+            .unwrap_or_else(|| panic!("DeliveryNotFound"));
+
+        if recipient != delivery.metadata.recipient {
+            panic!("NotAuthorized");
+        }
+
+        if delivery.status != DeliveryStatus::InTransit {
+            panic!("InvalidState");
+        }
+
+        let escrow_address: Address = env
+            .storage()
+            .instance()
+            .get(&DataKey::EscrowContract)
+            .unwrap_or_else(|| panic!("EscrowNotConfigured"));
+
+        use soroban_sdk::IntoVal;
+        let _: () = env.invoke_contract(
+            &escrow_address,
+            &soroban_sdk::Symbol::new(&env, "release_escrow"),
+            soroban_sdk::vec![&env, delivery_id.into_val(&env)],
+        );
+
+        delivery.status = DeliveryStatus::Delivered;
+        delivery.delivered_at = Some(env.ledger().timestamp());
+
+        env.storage().persistent().set(&key, &delivery);
+        env.storage().persistent().extend_ttl(&key, 518400, 518400);
+
+        env.events().publish(
+            (soroban_sdk::Symbol::new(&env, "delivery_confirmed"),),
+            (delivery_id, recipient),
+        );
+    }
+
     fn is_admin(env: &Env, caller: &Address) -> bool {
         if let Some(admin) = env.storage().instance().get::<_, Address>(&DataKey::Admin) {
             admin == *caller

contracts/delivery_contract/test.rs

@@ -1,5 +1,6 @@
 #![cfg(test)]
-
+extern crate std;
+
 use super::*;
 use soroban_sdk::{testutils::{Address as _, Events}, Address, Env, Symbol, TryFromVal};
 
@@ -25,12 +26,14 @@ fn test_successful_assignment_by_admin() {
 
     let delivery_id = 1;
     let sender = Address::generate(&env);
-    client.create_delivery(&sender, &delivery_id);
+    let recipient = Address::generate(&env);
+    client.create_delivery(&sender, &recipient, &delivery_id);
 
     client.assign_driver(&admin, &delivery_id, &driver);
 
     // Verify events
     let events = env.events().all();
+    std::println!("EVENTS LEN: {}", events.len());
     let last_event = events.last().unwrap();
 
     assert_eq!(
@@ -62,7 +65,8 @@ fn test_successful_self_assignment_by_driver() {
 
     let delivery_id = 2;
     let sender = Address::generate(&env);
-    client.create_delivery(&sender, &delivery_id);
+    let recipient = Address::generate(&env);
+    client.create_delivery(&sender, &recipient, &delivery_id);
 
     client.assign_driver(&driver, &delivery_id, &driver);
 
@@ -85,7 +89,8 @@ fn test_unauthorized_caller_rejected() {
 
     let delivery_id = 3;
     let sender = Address::generate(&env);
-    client.create_delivery(&sender, &delivery_id);
+    let recipient = Address::generate(&env);
+    client.create_delivery(&sender, &recipient, &delivery_id);
 
     client.assign_driver(&unauthorized, &delivery_id, &driver);
 }
@@ -97,7 +102,8 @@ fn test_assignment_when_status_not_pending() {
 
     let delivery_id = 4;
     let sender = Address::generate(&env);
-    client.create_delivery(&sender, &delivery_id);
+    let recipient = Address::generate(&env);
+    client.create_delivery(&sender, &recipient, &delivery_id);
 
     // First assignment changes status to Active
     client.assign_driver(&admin, &delivery_id, &driver);
@@ -129,7 +135,8 @@ fn test_cancel_delivery_pending() {
 
     let delivery_id = 10;
     let sender = Address::generate(&env);
-    client.create_delivery(&sender, &delivery_id);
+    let recipient = Address::generate(&env);
+    client.create_delivery(&sender, &recipient, &delivery_id);
 
     client.cancel_delivery(&sender, &delivery_id);
 
@@ -144,6 +151,7 @@ fn test_cancel_delivery_pending() {
     assert_eq!(delivery.status, DeliveryStatus::Cancelled);
 
     let events = env.events().all();
+    std::println!("EVENTS LEN: {}", events.len());
     let last_event = events.last().unwrap();
     let topic0: Symbol = Symbol::try_from_val(&env, &last_event.1.get(0).unwrap()).unwrap();
     assert_eq!(topic0, Symbol::new(&env, "delivery_cancelled"));
@@ -157,7 +165,8 @@ fn test_cancel_delivery_active() {
 
     let delivery_id = 11;
     let sender = Address::generate(&env);
-    client.create_delivery(&sender, &delivery_id);
+    let recipient = Address::generate(&env);
+    client.create_delivery(&sender, &recipient, &delivery_id);
     client.assign_driver(&admin, &delivery_id, &driver);
 
     client.cancel_delivery(&sender, &delivery_id);
@@ -182,7 +191,8 @@ fn test_cancel_delivery_unauthorized() {
 
     let delivery_id = 12;
     let sender = Address::generate(&env);
-    client.create_delivery(&sender, &delivery_id);
+    let recipient = Address::generate(&env);
+    client.create_delivery(&sender, &recipient, &delivery_id);
 
     client.cancel_delivery(&unauthorized, &delivery_id);
 }
@@ -196,7 +206,8 @@ fn test_cancel_delivery_invalid_state() {
 
     let delivery_id = 13;
     let sender = Address::generate(&env);
-    client.create_delivery(&sender, &delivery_id);
+    let recipient = Address::generate(&env);
+    client.create_delivery(&sender, &recipient, &delivery_id);
 
     client.cancel_delivery(&sender, &delivery_id); // Now Cancelled
 
@@ -213,7 +224,8 @@ fn test_cancel_delivery_escrow_failure() {
 
     let delivery_id = 999; // trigger failure in mock
     let sender = Address::generate(&env);
-    client.create_delivery(&sender, &delivery_id);
+    let recipient = Address::generate(&env);
+    client.create_delivery(&sender, &recipient, &delivery_id);
 
     client.cancel_delivery(&sender, &delivery_id);
 }

test_script.py

@@ -0,0 +1,12 @@
+import re
+
+with open('contracts/delivery_contract/test.rs', 'r') as f:
+    content = f.read()
+
+content = content.replace(
+    'let events = env.events().all();\n    let last_event = events.last().unwrap();',
+    'let events = env.events().all();\n    println!("EVENTS LEN: {}", events.len());\n    let last_event = events.last().unwrap();'
+)
+
+with open('contracts/delivery_contract/test.rs', 'w') as f:
+    f.write(content)