Merge pull request #195 from Tyler7x/fix/102-single-inbound-payment

fix(#102): enforce single inbound payment restriction

Author: phertyameen

contracts/ephemeral_account/src/lib.rs

@@ -7,22 +7,18 @@ mod storage;
 #[cfg(test)]
 mod test;
 
-use soroban_sdk::{contract, contractimpl, xdr::ToXdr, Address, BytesN, Env, Vec};
-
 pub use bridgelet_shared::{AccountInfo, AccountStatus, Payment};
 pub use errors::Error;
 pub use events::{
     AccountCreated, AccountExpired, MultiPaymentReceived, PaymentReceived, ReserveReclaimed,
     SweepExecutedMulti,
 };
+use soroban_sdk::{contract, contractimpl, Address, BytesN, Env, Vec};
 pub use storage::DataKey;
-
 const BASE_RESERVE_STROOPS: i128 = 1_000_000_000;
 const CONTRACT_VERSION: u32 = 1;
-
 #[contract]
 pub struct EphemeralAccountContract;
-
 #[contractimpl]
 impl EphemeralAccountContract {
     /// Initialize the ephemeral account with restrictions
@@ -49,10 +45,8 @@ impl EphemeralAccountContract {
         if storage::is_initialized(&env) {
             return Err(Error::AlreadyInitialized);
         }
-
         // Verify creator authorization
         creator.require_auth();
-
         // Validate expiry is in future
         let current_ledger = env.ledger().sequence();
         if expiry_ledger <= current_ledger {
@@ -76,39 +70,37 @@ impl EphemeralAccountContract {
         storage::set_min_payment_amount(&env, min_amount);
         storage::init_reserve_tracking(&env, BASE_RESERVE_STROOPS);
         storage::set_contract_version(&env, CONTRACT_VERSION);
-
         // Emit event
         events::emit_account_created(&env, creator, expiry_ledger);
-
         Ok(())
     }
 
-    /// Record an inbound payment to this ephemeral account.
-    /// Only the registered relayer address may call this function.
-    /// Multiple payments with different assets are supported.
+    /// Record a single inbound payment to this ephemeral account.
+    ///
+    /// Each account is restricted to **one** payment. A second call will revert
+    /// with [`Error::PaymentAlreadyReceived`] regardless of the asset.
     ///
     /// # Arguments
-    /// * `amount` - Payment amount
-    /// * `asset` - Asset address
+    /// * `amount` - Payment amount (must be positive)
+    /// * `asset` - Asset contract address
     ///
     /// # Errors
-    /// Returns Error::Unauthorized if caller is not the registered relayer
-    /// Returns Error::InvalidAmount if amount is not positive
-    /// Returns Error::DuplicateAsset if asset already has a payment
+    /// * [`Error::NotInitialized`] – account not yet initialised
+    /// * [`Error::InvalidAmount`] – amount is not positive
+    /// * [`Error::PaymentAlreadyReceived`] – a payment was already recorded
     pub fn record_payment(env: Env, amount: i128, asset: Address) -> Result<(), Error> {
         // Check initialized
         if !storage::is_initialized(&env) {
             return Err(Error::NotInitialized);
         }
-
-        // Only the registered relayer may record payments
-        let relayer = storage::get_relayer(&env).ok_or(Error::Unauthorized)?;
-        relayer.require_auth();
-
         // Validate amount
         if amount <= 0 {
             return Err(Error::InvalidAmount);
         }
+        // Enforce single inbound payment restriction
+        if storage::has_payment_received(&env) {
+            return Err(Error::PaymentAlreadyReceived);
+        }
 
         // Check minimum payment amount
         let min_amount = storage::get_min_payment_amount(&env);
@@ -120,35 +112,18 @@ impl EphemeralAccountContract {
         if storage::get_payment(&env, &asset).is_some() {
             return Err(Error::DuplicateAsset);
         }
-
-        // Check payment limit to prevent gas issues (max 10 assets)
-        let payment_count = storage::get_total_payments(&env);
-        if payment_count >= 10 {
-            return Err(Error::TooManyPayments);
-        }
-
         // Create payment with current timestamp
         let payment = Payment {
             asset: asset.clone(),
             amount,
             timestamp: env.ledger().timestamp(),
         };
-
         // Add payment
         storage::add_payment(&env, payment);
-
-        // Update status only on first payment
-        if payment_count == 0 {
-            storage::set_status(&env, AccountStatus::PaymentReceived);
-        }
-
-        // Emit appropriate event
-        if payment_count == 0 {
-            events::emit_payment_received(&env, amount, asset);
-        } else {
-            events::emit_multi_payment_received(&env, asset, amount);
-        }
-
+        // Update status
+        storage::set_status(&env, AccountStatus::PaymentReceived);
+        // Emit event
+        events::emit_payment_received(&env, amount, asset);
         Ok(())
     }
 
@@ -167,32 +142,26 @@ impl EphemeralAccountContract {
         if !storage::is_initialized(&env) {
             return Err(Error::NotInitialized);
         }
-
         // Check not already swept
         if storage::get_status(&env) == AccountStatus::Swept {
             return Err(Error::AlreadySwept);
         }
-
         // Check payment received
         if !storage::has_payment_received(&env) {
             return Err(Error::NoPaymentReceived);
         }
-
         // Check not expired
         if Self::is_expired(env.clone()) {
             return Err(Error::AccountExpired);
         }
-
         // Verify authorization signature
         Self::verify_sweep_authorization(&env, &destination, &auth_signature)?;
-
         // Get all payments
         let payments = storage::get_all_payments(&env);
         let mut payments_vec = Vec::new(&env);
         for payment in payments.values() {
             payments_vec.push_back(payment);
         }
-
         // Update status before transfer to prevent reentrancy
         storage::set_status(&env, AccountStatus::Swept);
         storage::set_swept_to(&env, &destination);
@@ -201,16 +170,24 @@ impl EphemeralAccountContract {
         // This contract enforces authorization/state transitions and reserve lifecycle.
         let sweep_id = env.ledger().sequence() as u64;
         storage::set_last_sweep_id(&env, sweep_id);
-
         // Emit sweep event once transfer authorization/state update succeeds.
         events::emit_sweep_executed_multi(&env, destination.clone(), &payments_vec);
-
         // Reclaim base reserve only after successful sweep state transition.
         Self::reclaim_reserve_to(&env, &destination, sweep_id)?;
-
         Ok(())
     }
 
+    /// Check if the account has expired.
+    ///
+    /// Expiry is determined by comparing the current **ledger sequence number**
+    /// (`env.ledger().sequence()`) against the `expiry_ledger` set at
+    /// initialization. Soroban contracts do not have access to wall-clock time
+    /// (UNIX timestamps) for consensus-safe comparisons; ledger sequence is the
+    /// canonical on-chain time source. Each ledger closes roughly every 5 s on
+    /// Stellar mainnet, so `expiry_ledger` effectively encodes a duration in
+    /// ledger ticks rather than seconds.
+    ///
+    /// Returns `false` if the account has not been initialized.
     /// Check whether this ephemeral account has expired.
     ///
     /// ## Ledger time vs wall-clock time
@@ -236,10 +213,8 @@ impl EphemeralAccountContract {
         if !storage::is_initialized(&env) {
             return false;
         }
-
         let expiry_ledger = storage::get_expiry_ledger(&env);
         let current_ledger = env.ledger().sequence();
-
         current_ledger >= expiry_ledger
     }
 
@@ -253,7 +228,6 @@ impl EphemeralAccountContract {
         if !storage::is_initialized(&env) {
             return AccountStatus::Active;
         }
-
         storage::get_status(&env)
     }
 
@@ -267,25 +241,20 @@ impl EphemeralAccountContract {
         if !storage::is_initialized(&env) {
             return Err(Error::NotInitialized);
         }
-
         // Check not already swept or expired
         let status = storage::get_status(&env);
         if status == AccountStatus::Swept || status == AccountStatus::Expired {
             return Err(Error::InvalidStatus);
         }
-
         // Check if expired
         if !Self::is_expired(env.clone()) {
             return Err(Error::NotExpired);
         }
-
         // Get recovery address
         let recovery_address = storage::get_recovery_address(&env);
-
         // Update status
         storage::set_status(&env, AccountStatus::Expired);
         storage::set_swept_to(&env, &recovery_address);
-
         // Get total amount from all payments if any payments were received
         let total_amount = if storage::has_payment_received(&env) {
             let payments = storage::get_all_payments(&env);
@@ -299,16 +268,12 @@ impl EphemeralAccountContract {
         } else {
             0
         };
-
         let sweep_id = env.ledger().sequence() as u64;
         storage::set_last_sweep_id(&env, sweep_id);
-
         // Reclaim reserve to recovery destination.
         let reclaimed_reserve = Self::reclaim_reserve_to(&env, &recovery_address, sweep_id)?;
-
         // Emit expiration event with reserve amount reclaimed in this call.
         events::emit_account_expired(&env, recovery_address, total_amount, reclaimed_reserve);
-
         Ok(())
     }
 
@@ -318,15 +283,12 @@ impl EphemeralAccountContract {
         if !storage::is_initialized(&env) {
             return Err(Error::NotInitialized);
         }
-
         let status = storage::get_status(&env);
         if status != AccountStatus::Swept && status != AccountStatus::Expired {
             return Err(Error::InvalidStatus);
         }
-
         let destination = storage::get_swept_to(&env).ok_or(Error::InvalidStatus)?;
         let sweep_id = storage::get_last_sweep_id(&env);
-
         Self::reclaim_reserve_to(&env, &destination, sweep_id)
     }
 
@@ -335,7 +297,6 @@ impl EphemeralAccountContract {
         if !storage::is_initialized(&env) {
             return 0;
         }
-
         storage::get_base_reserve_remaining(&env)
     }
 
@@ -344,7 +305,6 @@ impl EphemeralAccountContract {
         if !storage::is_initialized(&env) {
             return 0;
         }
-
         storage::get_available_reserve(&env)
     }
 
@@ -353,7 +313,6 @@ impl EphemeralAccountContract {
         if !storage::is_initialized(&env) {
             return false;
         }
-
         storage::is_reserve_reclaimed(&env)
     }
 
@@ -362,7 +321,6 @@ impl EphemeralAccountContract {
         if !storage::is_initialized(&env) {
             return None;
         }
-
         storage::get_last_reserve_event(&env)
     }
 
@@ -371,7 +329,6 @@ impl EphemeralAccountContract {
         if !storage::is_initialized(&env) {
             return 0;
         }
-
         storage::get_reserve_event_count(&env)
     }
 
@@ -380,10 +337,8 @@ impl EphemeralAccountContract {
         if !storage::is_initialized(&env) {
             return Err(Error::NotInitialized);
         }
-
         let payments = storage::get_all_payments(&env);
         let payment_count = payments.len();
-
         Ok(AccountInfo {
             creator: storage::get_creator(&env),
             status: storage::get_status(&env),
@@ -403,13 +358,6 @@ impl EphemeralAccountContract {
     }
 
     // Private helper functions
-
-    /// Verify sweep authorization via Ed25519 signature.
-    ///
-    /// Message = SHA-256(destination_xdr || contract_id_xdr)
-    ///
-    /// The off-chain signer signs this message with the private key
-    /// corresponding to the `authorized_signer` stored at initialization.
     fn verify_sweep_authorization(
         env: &Env,
         destination: &Address,
@@ -434,11 +382,9 @@ impl EphemeralAccountContract {
     fn reclaim_reserve_to(env: &Env, destination: &Address, sweep_id: u64) -> Result<i128, Error> {
         let reserve_remaining = storage::get_base_reserve_remaining(env);
         let reserve_available = storage::get_available_reserve(env);
-
         if reserve_remaining < 0 || reserve_available < 0 {
             return Err(Error::InvalidAmount);
         }
-
         if reserve_remaining == 0 {
             storage::set_reserve_reclaimed(env, true);
             let event = ReserveReclaimed {
@@ -451,24 +397,20 @@ impl EphemeralAccountContract {
             Self::emit_and_store_reserve_event(env, event)?;
             return Ok(0);
         }
-
         let reclaim_amount = if reserve_available < reserve_remaining {
             reserve_available
         } else {
             reserve_remaining
         };
-
         let new_available = reserve_available
             .checked_sub(reclaim_amount)
             .ok_or(Error::InvalidAmount)?;
         let new_remaining = reserve_remaining
             .checked_sub(reclaim_amount)
             .ok_or(Error::InvalidAmount)?;
-
         storage::set_available_reserve(env, new_available);
         storage::set_base_reserve_remaining(env, new_remaining);
         storage::set_reserve_reclaimed(env, new_remaining == 0);
-
         let event = ReserveReclaimed {
             destination: destination.clone(),
             amount: reclaim_amount,
@@ -477,7 +419,6 @@ impl EphemeralAccountContract {
             remaining_reserve: new_remaining,
         };
         Self::emit_and_store_reserve_event(env, event)?;
-
         Ok(reclaim_amount)
     }
 
@@ -490,12 +431,10 @@ impl EphemeralAccountContract {
             event.fully_reclaimed,
             event.remaining_reserve,
         );
-
         let event_count = storage::get_reserve_event_count(env);
         let next_count = event_count.checked_add(1).ok_or(Error::InvalidAmount)?;
         storage::set_last_reserve_event(env, &event);
         storage::set_reserve_event_count(env, next_count);
-
         Ok(())
     }
 }