diff --git a/quicklendx-contracts/docs/contracts/bidding.md b/quicklendx-contracts/docs/contracts/bidding.md
new file mode 100644
index 00000000..3eeee54e
--- /dev/null
+++ b/quicklendx-contracts/docs/contracts/bidding.md
@@ -0,0 +1,245 @@
+# Bidding Documentation
+
+## Overview
+
+This document describes the bidding mechanism in the QuickLendX protocol, focusing on bid validation rules and protocol minimum enforcement as implemented in issue #719.
+
+## Bid Validation
+
+### Bid Structure
+
+A bid in QuickLendX contains the following key components:
+
+```rust
+pub struct Bid {
+    pub bid_id: BytesN<32>,           // Unique identifier for the bid
+    pub invoice_id: BytesN<32>,        // Associated invoice
+    pub investor: Address,               // Investor address
+    pub bid_amount: i128,              // Amount being bid
+    pub expected_return: i128,           // Expected return for investor
+    pub timestamp: u64,                // Bid creation time
+    pub expiration_timestamp: u64,       // Bid expiration time
+    pub status: BidStatus,              // Current bid status
+}
+```
+
+### Bid Status Lifecycle
+
+```rust
+pub enum BidStatus {
+    Placed,     // Bid is active and can be accepted
+    Withdrawn,  // Bid was withdrawn by investor
+    Accepted,    // Bid was accepted and investment created
+    Expired,     // Bid expired without acceptance
+}
+```
+
+## Protocol Minimum Enforcement
+
+### Minimum Bid Calculation
+
+The protocol enforces a minimum bid amount using both absolute and percentage-based constraints:
+
+```rust
+let percent_min = invoice.amount
+    .saturating_mul(limits.min_bid_bps as i128)
+    .saturating_div(10_000);
+
+let effective_min_bid = if percent_min > limits.min_bid_amount {
+    percent_min                    // Use percentage minimum if higher
+} else {
+    limits.min_bid_amount           // Use absolute minimum otherwise
+};
+```
+
+### Protocol Limits
+
+The protocol maintains configurable minimum bid parameters:
+
+```rust
+pub struct ProtocolLimits {
+    pub min_bid_amount: i128,    // Absolute minimum bid amount
+    pub min_bid_bps: u32,       // Minimum bid as percentage (basis points)
+    // ... other limits
+}
+```
+
+**Default Values:**
+- `min_bid_amount`: 10 (smallest unit)
+- `min_bid_bps`: 100 (1% of invoice amount)
+
+### Validation Rules
+
+#### 1. Amount Validation
+- **Non-zero**: Bid amount must be > 0
+- **Minimum Enforcement**: Must meet or exceed `effective_min_bid`
+- **Invoice Cap**: Cannot exceed total invoice amount
+
+#### 2. Invoice Status Validation
+- **Verified Only**: Invoice must be in `Verified` status
+- **Not Expired**: Invoice due date must be in the future
+
+#### 3. Ownership Validation
+- **No Self-Bidding**: Business cannot bid on own invoices
+- **Authorization**: Only verified investors can place bids
+
+#### 4. Investor Capacity
+- **Investment Limits**: Total active bids cannot exceed investor's verified limit
+- **Risk Assessment**: Bid amount considered against investor's risk profile
+
+#### 5. Bid Protection
+- **Single Active Bid**: One investor cannot have multiple active bids on same invoice
+- **Expiration Handling**: Expired bids are automatically cleaned up
+
+## Bid Placement Flow
+
+### 1. Pre-Validation
+```rust
+validate_bid(env, invoice, bid_amount, expected_return, investor)?;
+```
+
+### 2. Bid Creation
+```rust
+let bid_id = BidStorage::generate_unique_bid_id(env);
+let bid = Bid {
+    bid_id,
+    invoice_id,
+    investor,
+    bid_amount,
+    expected_return,
+    timestamp: env.ledger().timestamp(),
+    expiration_timestamp: env.ledger().timestamp() + bid_ttl_seconds,
+    status: BidStatus::Placed,
+};
+```
+
+### 3. Storage
+```rust
+BidStorage::store_bid(env, &bid);
+BidStorage::add_bid_to_invoice_index(env, &invoice_id, &bid_id);
+BidStorage::add_bid_to_investor_index(env, &investor, &bid_id);
+```
+
+## Bid Selection and Ranking
+
+### Best Bid Selection
+The protocol selects the best bid based on:
+
+1. **Profit Priority**: Higher expected return (profit = expected_return - bid_amount)
+2. **Return Amount**: Higher expected return if profit equal
+3. **Bid Amount**: Higher bid amount if profit and return equal
+4. **Timestamp**: Newer bids preferred (deterministic tiebreaker)
+5. **Bid ID**: Final stable tiebreaker
+
+### Ranking Algorithm
+```rust
+pub fn compare_bids(bid1: &Bid, bid2: &Bid) -> Ordering {
+    let profit1 = bid1.expected_return.saturating_sub(bid1.bid_amount);
+    let profit2 = bid2.expected_return.saturating_sub(bid2.bid_amount);
+    
+    // Compare by profit, then return, then amount, then timestamp, then bid_id
+    // This ensures reproducible ranking across all validators
+}
+```
+
+## Security Considerations
+
+### Reentrancy Protection
+- All bid modifications require proper authorization
+- State transitions are atomic
+- External calls minimized during validation
+
+### Access Control
+- **Investor Authorization**: `investor.require_auth()` for bid placement
+- **Business Authorization**: `business.require_auth()` for invoice operations
+- **Admin Authorization**: `AdminStorage::require_admin()` for protocol changes
+
+### Input Validation
+- **Amount Bounds**: Prevents overflow and underflow
+- **Timestamp Validation**: Ensures logical time progression
+- **Address Validation**: Prevents invalid address usage
+
+## Gas Optimization
+
+### Efficient Storage
+- **Indexed Storage**: Fast lookup by invoice, investor, and status
+- **Batch Operations**: Multiple bids processed in single transaction
+- **Cleanup Routines**: Automatic removal of expired bids
+
+### Minimal Computations
+- **Saturating Arithmetic**: Prevents overflow without expensive checks
+- **Lazy Evaluation**: Calculations deferred until needed
+- **Constants**: Pre-computed values where possible
+
+## Testing Coverage
+
+### Unit Tests
+- **Validation Logic**: All validation rules tested
+- **Edge Cases**: Boundary conditions and error scenarios
+- **Protocol Limits**: Custom limit configurations tested
+- **Integration Tests**: End-to-end bid placement flows
+
+### Test Coverage Requirements
+- **95% Coverage**: All bid validation paths tested
+- **Error Paths**: All error conditions validated
+- **Success Paths**: All valid bid scenarios covered
+- **Edge Cases**: Boundary values and special conditions
+
+## Event Emission
+
+### Bid Events
+```rust
+// Events emitted during bid lifecycle
+emit_bid_placed(env, &bid_id, &invoice_id, &investor, bid_amount);
+emit_bid_accepted(env, &bid_id, &invoice_id, &investor, bid_amount);
+emit_bid_withdrawn(env, &bid_id, &invoice_id, &investor, bid_amount);
+emit_bid_expired(env, &bid_id, &invoice_id, &investor, bid_amount);
+```
+
+### Audit Trail
+- All bid state transitions are logged
+- Timestamps recorded for all operations
+- Authorization verified for all state changes
+
+## Configuration
+
+### Bid TTL (Time-To-Live)
+- **Default**: 7 days from placement
+- **Configuration**: Set by admin via `set_bid_ttl`
+- **Cleanup**: Automatic expiration and status updates
+
+### Maximum Active Bids
+- **Default**: 10 per investor
+- **Purpose**: Prevents spam and manages risk
+- **Enforcement**: Checked during bid placement
+
+## Migration Notes
+
+### Backward Compatibility
+- Existing bids remain valid under previous rules
+- New protocol limits apply to future bids
+- Storage format unchanged for existing data
+
+### Upgrade Path
+- Protocol limits can be updated by admin
+- Bid validation logic can be enhanced without breaking changes
+- New bid statuses can be added via enum extension
+
+## Best Practices
+
+### For Investors
+- **Due Diligence**: Verify invoice details before bidding
+- **Risk Management**: Don't exceed investment capacity
+- **Timing**: Place bids well before expiration
+- **Monitoring**: Track active bids and their status
+
+### For Businesses
+- **Verification**: Ensure invoice is verified before expecting bids
+- **Terms**: Clear payment terms and due dates
+- **Communication**: Respond to appropriate bids promptly
+
+### For Protocol Developers
+- **Validation**: Centralize bid validation logic
+- **Testing**: Comprehensive test coverage for all scenarios
+- **Documentation**: Clear NatSpec comments for all functions
+- **Security**: Regular security audits of bid logic
diff --git a/quicklendx-contracts/docs/contracts/invoice-lifecycle.md b/quicklendx-contracts/docs/contracts/invoice-lifecycle.md
new file mode 100644
index 00000000..9b60c834
--- /dev/null
+++ b/quicklendx-contracts/docs/contracts/invoice-lifecycle.md
@@ -0,0 +1,190 @@
+# Invoice Lifecycle Documentation
+
+## Overview
+
+This document describes the complete lifecycle of invoices and investments in the QuickLendX protocol, focusing on terminal state transitions and their side effects.
+
+## Investment Terminal States
+
+### Investment Status Enum
+
+The `InvestmentStatus` enum defines the possible states of an investment:
+
+```rust
+pub enum InvestmentStatus {
+    Active,     // Investment is currently active and funded
+    Withdrawn,  // Investment funds were withdrawn (terminal)
+    Completed,  // Investment completed successfully (terminal)
+    Defaulted,  // Investment defaulted due to non-payment (terminal)
+    Refunded,   // Investment was refunded due to cancellation (terminal)
+}
+```
+
+### Valid State Transitions
+
+| From State | To State(s) | Trigger | Side Effects |
+|------------|-------------|---------|--------------|
+| **Active** | Completed | Full invoice settlement | - Investment marked as completed<br>- Removed from active index<br>- Settlement events emitted |
+| **Active** | Withdrawn | Investment withdrawal | - Investment marked as withdrawn<br>- Removed from active index<br>- Escrow refunded if applicable |
+| **Active** | Defaulted | Invoice default | - Investment marked as defaulted<br>- Removed from active index<br>- Default events emitted |
+| **Active** | Refunded | Invoice cancellation | - Investment marked as refunded<br>- Removed from active index<br>- Escrow refunded |
+| **Withdrawn** | *(none)* | - | Terminal state - no further transitions |
+| **Completed** | *(none)* | - | Terminal state - no further transitions |
+| **Defaulted** | *(none)* | - | Terminal state - no further transitions |
+| **Refunded** | *(none)* | - | Terminal state - no further transitions |
+
+### Terminal State Invariants
+
+Once an investment reaches a terminal state, the following invariants are maintained:
+
+1. **Immutability**: Terminal states cannot transition to any other state
+2. **Active Index Cleanup**: Terminal investments are removed from the active investment index
+3. **Storage Persistence**: Investment records remain in storage for audit purposes
+4. **Event Emission**: Appropriate events are emitted for terminal transitions
+
+## Invoice-Investment Relationship
+
+### Invoice States and Investment Impact
+
+| Invoice State | Investment Impact | Allowed Transitions |
+|---------------|------------------|---------------------|
+| **Pending** | No investment | → Verified, Cancelled |
+| **Verified** | No investment | → Funded, Cancelled |
+| **Funded** | Investment Active | → Paid, Defaulted, Refunded |
+| **Paid** | Investment Completed | *(terminal)* |
+| **Defaulted** | Investment Defaulted | *(terminal)* |
+| **Cancelled** | Investment Refunded | *(terminal)* |
+| **Refunded** | Investment Refunded | *(terminal)* |
+
+### Bid Acceptance and Investment Creation
+
+When a bid is accepted:
+1. Escrow is created and funded
+2. Investment record is created with `Active` status
+3. Investment is added to active index
+4. Invoice state transitions to `Funded`
+
+### Settlement Flow
+
+During invoice settlement:
+1. Payment processing validates sufficient funds
+2. Escrow is released to business (if held)
+3. Investor receives expected return
+4. Platform fees are calculated and routed
+5. Investment transitions to `Completed`
+6. Invoice transitions to `Paid`
+
+## Security Considerations
+
+### State Transition Validation
+
+All state transitions are validated through `InvestmentStatus::validate_transition()`:
+
+```rust
+pub fn validate_transition(
+    from: &InvestmentStatus,
+    to: &InvestmentStatus,
+) -> Result<(), QuickLendXError>
+```
+
+This function ensures:
+- Only valid transitions are allowed
+- Terminal states cannot be changed
+- Active state can only transition to terminal states
+
+### Active Investment Index
+
+The protocol maintains an index of all active investments to:
+- Enable efficient queries for active investments
+- Prevent orphaned active investments
+- Support investment limit calculations
+
+### Storage Invariants
+
+The `validate_no_orphan_investments()` function ensures:
+- All investments in the active index have `Active` status
+- No terminal investments remain in the active index
+- Index consistency is maintained
+
+## Event Emission
+
+### Terminal State Events
+
+Each terminal transition emits specific events:
+
+- **Completed**: `inv_setlf` (invoice settled final)
+- **Withdrawn**: `esc_ref` (escrow refunded)
+- **Defaulted**: Default handling events
+- **Refunded**: `esc_ref` (escrow refunded)
+
+### Audit Trail
+
+All state transitions are logged with:
+- Timestamp
+- Previous and new states
+- Associated entities (invoice, investment, investor)
+- Authorization information
+
+## Testing Coverage
+
+### Test Suite
+
+The `test_investment_terminal_states.rs` module provides comprehensive testing:
+
+1. **Completion Flow**: Tests Active → Completed transition
+2. **Withdrawal Flow**: Tests Active → Withdrawn transition
+3. **Default Flow**: Tests Active → Defaulted transition
+4. **Refund Flow**: Tests Active → Refunded transition
+5. **Invalid Transitions**: Tests rejection of invalid state changes
+6. **State Immutability**: Tests terminal state preservation
+7. **Storage Invariants**: Tests index consistency and cleanup
+
+### Coverage Requirements
+
+- **95% test coverage** for investment state transitions
+- **All terminal states** tested with positive and negative cases
+- **Storage invariants** validated after each transition
+- **Event emission** verified for all transitions
+- **Error conditions** tested for invalid transitions
+
+## Implementation Notes
+
+### NatSpec Documentation
+
+All public functions include NatSpec-style comments:
+
+```rust
+/// @notice Validates investment state transition
+/// @dev Ensures only valid transitions are allowed
+/// @param from Current investment status
+/// @param to Target investment status
+/// @return Success if transition is valid
+/// @error InvalidStatus if transition is not allowed
+pub fn validate_transition(/* ... */) -> Result<(), QuickLendXError>
+```
+
+### Error Handling
+
+- `InvalidStatus`: Returned for invalid state transitions
+- `StorageKeyNotFound`: Returned when investment doesn't exist
+- `OperationNotAllowed`: Returned for unauthorized operations
+
+### Gas Optimization
+
+- Active index cleanup happens during state transitions
+- Storage updates are batched when possible
+- Event emission is minimized for gas efficiency
+
+## Migration Considerations
+
+### Backward Compatibility
+
+- Existing investment records are preserved
+- State transition logic is additive
+- No breaking changes to public interfaces
+
+### Upgrade Path
+
+- New terminal states can be added via enum extension
+- Transition validation can be enhanced without breaking changes
+- Storage format remains stable
diff --git a/quicklendx-contracts/src/test_bid_validation.rs b/quicklendx-contracts/src/test_bid_validation.rs
new file mode 100644
index 00000000..a15c846c
--- /dev/null
+++ b/quicklendx-contracts/src/test_bid_validation.rs
@@ -0,0 +1,413 @@
+//! Bid validation tests for QuickLendX protocol.
+//!
+//! Test suite validates that bid validation enforces protocol minimums
+//! consistently as required by issue #719.
+//!
+//! ## Test Coverage
+//!
+//! - **Protocol Minimum Enforcement**: Tests that bids respect both absolute and percentage minimums
+//! - **Bid Amount Validation**: Tests various bid amounts against invoice amounts
+//! - **Edge Cases**: Tests boundary conditions and error scenarios
+//! - **Integration Tests**: Tests bid validation with actual bid placement
+//!
+//! Run: `cargo test test_bid_validation`
+
+use super::*;
+use crate::bid::BidStatus;
+use crate::invoice::{InvoiceCategory, InvoiceStatus};
+use crate::protocol_limits::{ProtocolLimits, ProtocolLimitsContract};
+use crate::verification::validate_bid;
+use soroban_sdk::{
+    symbol_short,
+    testutils::{Address as _, Events, Ledger},
+    Address, BytesN, Env, String, Vec,
+};
+
+/// Helper to create a verified invoice for testing
+fn create_verified_invoice_for_bid_tests(
+    env: &Env,
+    client: &QuickLendXContractClient<'static>,
+    business: &Address,
+    amount: i128,
+    currency: &Address,
+) -> BytesN<32> {
+    // Create and verify invoice
+    let due_date = env.ledger().timestamp() + 86_400 * 30; // 30 days
+    let invoice_id = client.store_invoice(
+        business,
+        &amount,
+        currency,
+        &due_date,
+        &String::from_str(env, "Test invoice for bid validation"),
+        &InvoiceCategory::Services,
+        &Vec::new(env),
+    );
+    
+    // Verify invoice
+    client.verify_invoice(&invoice_id);
+    invoice_id
+}
+
+/// Helper to setup investor for testing
+fn setup_investor_for_bid_tests(
+    env: &Env,
+    client: &QuickLendXContractClient<'static>,
+    investor: &Address,
+    investment_limit: i128,
+) {
+    client.submit_investor_kyc(investor, &String::from_str(env, "Investor KYC"));
+    client.verify_investor(investor, &investment_limit);
+}
+
+/// Helper to get current protocol limits
+fn get_protocol_limits_for_test(env: &Env) -> ProtocolLimits {
+    ProtocolLimitsContract::get_protocol_limits(env)
+}
+
+#[test]
+fn test_bid_validation_enforces_absolute_minimum() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    let admin = Address::generate(&env);
+    client.set_admin(&admin);
+    
+    // Setup test addresses
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = Address::generate(&env);
+    
+    // Setup investor with high limit
+    setup_investor_for_bid_tests(&env, &client, &investor, 10_000i128);
+    
+    // Create verified invoice
+    let invoice_amount = 1_000i128;
+    let invoice_id = create_verified_invoice_for_bid_tests(&env, &client, &business, invoice_amount, &currency);
+    
+    // Get current protocol limits
+    let limits = get_protocol_limits_for_test(&env);
+    
+    // Test 1: Bid below absolute minimum should fail
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), limits.min_bid_amount - 1, invoice_amount + 100, &investor);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvalidAmount);
+    
+    // Test 2: Bid exactly at absolute minimum should pass
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), limits.min_bid_amount, invoice_amount + 100, &investor);
+    assert!(result.is_ok());
+    
+    // Test 3: Bid above absolute minimum should pass
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), limits.min_bid_amount + 100, invoice_amount + 200, &investor);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_bid_validation_enforces_percentage_minimum() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    let admin = Address::generate(&env);
+    client.set_admin(&admin);
+    
+    // Setup test addresses
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = Address::generate(&env);
+    
+    // Setup investor with high limit
+    setup_investor_for_bid_tests(&env, &client, &investor, 10_000i128);
+    
+    // Create verified invoice
+    let invoice_amount = 5_000i128; // Larger amount to test percentage
+    let invoice_id = create_verified_invoice_for_bid_tests(&env, &client, &business, invoice_amount, &currency);
+    
+    // Get current protocol limits
+    let limits = get_protocol_limits_for_test(&env);
+    
+    // Calculate percentage-based minimum
+    let percent_min = invoice_amount
+        .saturating_mul(limits.min_bid_bps as i128)
+        .saturating_div(10_000);
+    
+    // Test 1: Bid below percentage minimum should fail
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), percent_min - 1, invoice_amount + 500, &investor);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvalidAmount);
+    
+    // Test 2: Bid exactly at percentage minimum should pass
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), percent_min, invoice_amount + 500, &investor);
+    assert!(result.is_ok());
+    
+    // Test 3: Bid above percentage minimum should pass
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), percent_min + 100, invoice_amount + 600, &investor);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_bid_validation_uses_higher_minimum() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    let admin = Address::generate(&env);
+    client.set_admin(&admin);
+    
+    // Setup test addresses
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = Address::generate(&env);
+    
+    // Setup investor with high limit
+    setup_investor_for_bid_tests(&env, &client, &investor, 10_000i128);
+    
+    // Create verified invoice with amount that makes percentage minimum higher than absolute
+    let invoice_amount = 2_000i128; // 2% = 40, which is > default min_bid_amount (10)
+    let invoice_id = create_verified_invoice_for_bid_tests(&env, &client, &business, invoice_amount, &currency);
+    
+    // Get current protocol limits
+    let limits = get_protocol_limits_for_test(&env);
+    
+    // Calculate percentage-based minimum
+    let percent_min = invoice_amount
+        .saturating_mul(limits.min_bid_bps as i128)
+        .saturating_div(10_000);
+    
+    // Test: Bid should use percentage minimum (40) since it's higher than absolute minimum (10)
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), 30, invoice_amount + 200, &investor);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvalidAmount);
+    
+    // Test: Bid at percentage minimum should pass
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), percent_min, invoice_amount + 200, &investor);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_bid_validation_with_custom_protocol_limits() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    let admin = Address::generate(&env);
+    client.set_admin(&admin);
+    
+    // Setup test addresses
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = Address::generate(&env);
+    
+    // Setup investor with high limit
+    setup_investor_for_bid_tests(&env, &client, &investor, 10_000i128);
+    
+    // Create verified invoice
+    let invoice_amount = 1_000i128;
+    let invoice_id = create_verified_invoice_for_bid_tests(&env, &client, &business, invoice_amount, &currency);
+    
+    // Update protocol limits to custom values
+    let custom_min_bid_amount = 50i128; // Higher than default
+    let custom_min_bid_bps = 500u32; // 5%
+    client.update_protocol_limits(
+        admin,
+        100i128, // min_invoice_amount
+        custom_min_bid_amount,
+        custom_min_bid_bps,
+        365, // max_due_date_days
+        604800, // grace_period_seconds (7 days)
+        100, // max_invoices_per_business
+    );
+    
+    // Get updated protocol limits
+    let limits = get_protocol_limits_for_test(&env);
+    assert_eq!(limits.min_bid_amount, custom_min_bid_amount);
+    assert_eq!(limits.min_bid_bps, custom_min_bid_bps);
+    
+    // Test 1: Bid below new absolute minimum should fail
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), custom_min_bid_amount - 1, invoice_amount + 100, &investor);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvalidAmount);
+    
+    // Test 2: Bid below new percentage minimum should fail
+    let percent_min = invoice_amount
+        .saturating_mul(custom_min_bid_bps as i128)
+        .saturating_div(10_000);
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), percent_min - 1, invoice_amount + 100, &investor);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvalidAmount);
+    
+    // Test 3: Bid at new absolute minimum should pass
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), custom_min_bid_amount, invoice_amount + 100, &investor);
+    assert!(result.is_ok());
+    
+    // Test 4: Bid at new percentage minimum should pass
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), percent_min, invoice_amount + 100, &investor);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_bid_validation_edge_cases() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    let admin = Address::generate(&env);
+    client.set_admin(&admin);
+    
+    // Setup test addresses
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = Address::generate(&env);
+    
+    // Setup investor with high limit
+    setup_investor_for_bid_tests(&env, &client, &investor, 10_000i128);
+    
+    // Create verified invoice
+    let invoice_amount = 1_000i128;
+    let invoice_id = create_verified_invoice_for_bid_tests(&env, &client, &business, invoice_amount, &currency);
+    
+    // Test 1: Zero bid amount should fail
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), 0, invoice_amount + 100, &investor);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvalidAmount);
+    
+    // Test 2: Negative bid amount should fail
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), -100, invoice_amount + 100, &investor);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvalidAmount);
+    
+    // Test 3: Bid amount exceeding invoice amount should fail
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), invoice_amount + 1, invoice_amount + 100, &investor);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvoiceAmountInvalid);
+    
+    // Test 4: Expected return less than or equal to bid amount should fail
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), invoice_amount, invoice_amount, &investor);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvalidAmount);
+    
+    // Test 5: Valid bid should pass
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), 100, invoice_amount + 100, &investor);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_bid_validation_integration_with_place_bid() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    let admin = Address::generate(&env);
+    client.set_admin(&admin);
+    
+    // Setup test addresses
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = Address::generate(&env);
+    
+    // Setup investor with high limit
+    setup_investor_for_bid_tests(&env, &client, &investor, 10_000i128);
+    
+    // Create verified invoice
+    let invoice_amount = 1_000i128;
+    let invoice_id = create_verified_invoice_for_bid_tests(&env, &client, &business, invoice_amount, &currency);
+    
+    // Get current protocol limits
+    let limits = get_protocol_limits_for_test(&env);
+    let percent_min = invoice_amount
+        .saturating_mul(limits.min_bid_bps as i128)
+        .saturating_div(10_000);
+    let effective_min = if percent_min > limits.min_bid_amount {
+        percent_min
+    } else {
+        limits.min_bid_amount
+    };
+    
+    // Test 1: Place bid below minimum should fail
+    let result = client.place_bid(&investor, &invoice_id, &(effective_min - 1), &(invoice_amount + 100));
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvalidAmount);
+    
+    // Test 2: Place bid at minimum should succeed
+    let bid_id = client.place_bid(&investor, &invoice_id, &effective_min, &(invoice_amount + 100));
+    assert!(bid_id != BytesN::from_array(&env, &[0; 32]));
+    
+    // Verify bid was created and has correct amount
+    let bid = client.get_bid(&bid_id);
+    assert_eq!(bid.bid_amount, effective_min);
+    assert_eq!(bid.status, BidStatus::Placed);
+    
+    // Test 3: Place second bid from same investor should fail (active bid protection)
+    let result = client.place_bid(&investor, &invoice_id, &(effective_min + 100), &(invoice_amount + 200));
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::OperationNotAllowed);
+}
+
+#[test]
+fn test_bid_validation_with_invoice_status_checks() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    let admin = Address::generate(&env);
+    client.set_admin(&admin);
+    
+    // Setup test addresses
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = Address::generate(&env);
+    
+    // Setup investor with high limit
+    setup_investor_for_bid_tests(&env, &client, &investor, 10_000i128);
+    
+    // Create invoice but don't verify it
+    let invoice_amount = 1_000i128;
+    let due_date = env.ledger().timestamp() + 86_400 * 30;
+    let invoice_id = client.store_invoice(
+        business,
+        &invoice_amount,
+        &currency,
+        &due_date,
+        &String::from_str(env, "Unverified invoice"),
+        &InvoiceCategory::Services,
+        &Vec::new(env),
+    );
+    
+    // Get current protocol limits
+    let limits = get_protocol_limits_for_test(&env);
+    let valid_bid_amount = limits.min_bid_amount + 100;
+    
+    // Test 1: Bid on unverified invoice should fail
+    let result = validate_bid(&env, &client.get_invoice(&invoice_id), valid_bid_amount, invoice_amount + 100, &investor);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvalidStatus);
+    
+    // Test 2: Bid on expired invoice should fail
+    let mut invoice = client.get_invoice(&invoice_id);
+    invoice.status = InvoiceStatus::Verified;
+    invoice.due_date = env.ledger().timestamp() - 1000; // Past due date
+    let result = validate_bid(&env, &invoice, valid_bid_amount, invoice_amount + 100, &investor);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvalidStatus);
+    
+    // Test 3: Business bidding on own invoice should fail
+    invoice.status = InvoiceStatus::Verified;
+    invoice.due_date = env.ledger().timestamp() + 1000; // Future due date
+    let result = validate_bid(&env, &invoice, valid_bid_amount, invoice_amount + 100, &business);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::Unauthorized);
+}
diff --git a/quicklendx-contracts/src/test_escrow_consistency.rs b/quicklendx-contracts/src/test_escrow_consistency.rs
new file mode 100644
index 00000000..7a17cf4a
--- /dev/null
+++ b/quicklendx-contracts/src/test_escrow_consistency.rs
@@ -0,0 +1,458 @@
+//! Escrow detail-status consistency tests for QuickLendX protocol.
+//!
+//! Test suite ensures that status field matches detailed escrow record
+//! across all terminal states as required by issue #731.
+//!
+//! ## Test Coverage
+//!
+//! - **Status Consistency**: Tests that get_escrow_status matches escrow.status
+//! - **Detail Completeness**: Tests that get_escrow_details returns complete escrow record
+//! - **Terminal State Coverage**: Tests all escrow states (Held, Released, Refunded)
+//! - **Edge Cases**: Tests error conditions and missing escrow scenarios
+//! - **Integration Tests**: Tests consistency during actual escrow operations
+//!
+//! Run: `cargo test test_escrow_consistency`
+
+use super::*;
+use crate::invoice::{InvoiceCategory, InvoiceStatus};
+use crate::payments::{create_escrow, release_escrow, refund_escrow, EscrowStatus};
+use soroban_sdk::{
+    symbol_short,
+    testutils::{Address as _, Events, Ledger},
+    token, Address, BytesN, Env, String, Vec,
+};
+
+/// Helper to create a funded invoice with escrow for testing
+fn create_funded_invoice_with_escrow_for_tests(
+    env: &Env,
+    client: &QuickLendXContractClient<'static>,
+    business: &Address,
+    investor: &Address,
+    invoice_amount: i128,
+    escrow_amount: i128,
+) -> (BytesN<32>, BytesN<32>) {
+    // Setup business KYC and verification
+    client.submit_kyc_application(business, &String::from_str(env, "Business KYC"));
+    let admin = Address::generate(env);
+    client.verify_business(&admin, business);
+    
+    // Setup investor KYC and verification
+    client.submit_investor_kyc(investor, &String::from_str(env, "Investor KYC"));
+    client.verify_investor(&admin, investor, &(escrow_amount * 2));
+    
+    // Create and verify invoice
+    let currency = Address::generate(env);
+    let due_date = env.ledger().timestamp() + 86_400 * 30;
+    let invoice_id = client.store_invoice(
+        business,
+        &invoice_amount,
+        &currency,
+        &due_date,
+        &String::from_str(env, "Test invoice for escrow consistency"),
+        &InvoiceCategory::Services,
+        &Vec::new(env),
+    );
+    client.verify_invoice(&invoice_id);
+    
+    // Create bid and accept to create escrow
+    let bid_id = client.place_bid(investor, &invoice_id, &escrow_amount, &(invoice_amount + 100));
+    client.accept_bid(&invoice_id, &bid_id);
+    
+    (invoice_id, bid_id)
+}
+
+/// Helper to get escrow status and details for consistency checking
+fn get_escrow_status_and_details(
+    env: &Env,
+    client: &QuickLendXContractClient<'static>,
+    invoice_id: &BytesN<32>,
+) -> (EscrowStatus, crate::payments::Escrow) {
+    let status = client.get_escrow_status(invoice_id).unwrap();
+    let details = client.get_escrow_details(invoice_id).unwrap();
+    (status, details)
+}
+
+#[test]
+fn test_escrow_status_consistency_held_state() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    
+    // Create funded invoice with escrow
+    let (invoice_id, _bid_id) = create_funded_invoice_with_escrow_for_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        1000i128,
+        1000i128,
+    );
+    
+    // Test: Status and details should be consistent for Held state
+    let (status, details) = get_escrow_status_and_details(&env, &client, &invoice_id);
+    
+    assert_eq!(status, EscrowStatus::Held);
+    assert_eq!(details.status, EscrowStatus::Held);
+    assert_eq!(details.invoice_id, invoice_id);
+    assert_eq!(details.investor, investor);
+    assert_eq!(details.business, business);
+    assert_eq!(details.amount, 1000i128);
+    assert!(details.created_at > 0);
+}
+
+#[test]
+fn test_escrow_status_consistency_released_state() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    
+    // Create funded invoice with escrow
+    let (invoice_id, _bid_id) = create_funded_invoice_with_escrow_for_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        1000i128,
+        1000i128,
+    );
+    
+    // Release escrow
+    client.release_escrow_funds(&invoice_id);
+    
+    // Test: Status and details should be consistent for Released state
+    let (status, details) = get_escrow_status_and_details(&env, &client, &invoice_id);
+    
+    assert_eq!(status, EscrowStatus::Released);
+    assert_eq!(details.status, EscrowStatus::Released);
+    assert_eq!(details.invoice_id, invoice_id);
+    assert_eq!(details.investor, investor);
+    assert_eq!(details.business, business);
+    assert_eq!(details.amount, 1000i128);
+    assert!(details.created_at > 0);
+}
+
+#[test]
+fn test_escrow_status_consistency_refunded_state() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    
+    // Create funded invoice with escrow
+    let (invoice_id, _bid_id) = create_funded_invoice_with_escrow_for_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        1000i128,
+        1000i128,
+    );
+    
+    // Refund escrow
+    client.refund_escrow_funds(&invoice_id, investor);
+    
+    // Test: Status and details should be consistent for Refunded state
+    let (status, details) = get_escrow_status_and_details(&env, &client, &invoice_id);
+    
+    assert_eq!(status, EscrowStatus::Refunded);
+    assert_eq!(details.status, EscrowStatus::Refunded);
+    assert_eq!(details.invoice_id, invoice_id);
+    assert_eq!(details.investor, investor);
+    assert_eq!(details.business, business);
+    assert_eq!(details.amount, 1000i128);
+    assert!(details.created_at > 0);
+}
+
+#[test]
+fn test_escrow_status_consistency_multiple_operations() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    
+    // Create funded invoice with escrow
+    let (invoice_id, _bid_id) = create_funded_invoice_with_escrow_for_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        1000i128,
+        1000i128,
+    );
+    
+    // Test: Initial state should be Held
+    let (status1, details1) = get_escrow_status_and_details(&env, &client, &invoice_id);
+    assert_eq!(status1, EscrowStatus::Held);
+    assert_eq!(details1.status, EscrowStatus::Held);
+    
+    // Release escrow
+    client.release_escrow_funds(&invoice_id);
+    
+    // Test: Status should be Released after release
+    let (status2, details2) = get_escrow_status_and_details(&env, &client, &invoice_id);
+    assert_eq!(status2, EscrowStatus::Released);
+    assert_eq!(details2.status, EscrowStatus::Released);
+    
+    // Verify details are consistent across operations
+    assert_eq!(details1.invoice_id, details2.invoice_id);
+    assert_eq!(details1.investor, details2.investor);
+    assert_eq!(details1.business, details2.business);
+    assert_eq!(details1.amount, details2.amount);
+    assert_eq!(details1.created_at, details2.created_at);
+}
+
+#[test]
+fn test_escrow_status_error_missing_escrow() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    // Test non-existent invoice ID
+    let fake_invoice_id = BytesN::from_array(&env, &[1; 32]);
+    
+    // Both functions should return StorageKeyNotFound error
+    let status_result = client.get_escrow_status(&fake_invoice_id);
+    assert!(status_result.is_err());
+    assert_eq!(status_result.unwrap_err(), QuickLendXError::StorageKeyNotFound);
+    
+    let details_result = client.get_escrow_details(&fake_invoice_id);
+    assert!(details_result.is_err());
+    assert_eq!(details_result.unwrap_err(), QuickLendXError::StorageKeyNotFound);
+}
+
+#[test]
+fn test_escrow_status_consistency_with_real_token_transfers() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = Address::generate(&env);
+    
+    // Setup real token with initial balances
+    let token_admin = Address::generate(&env);
+    let token_contract = env.register_stellar_asset_contract_v2(token_admin);
+    let token_client = token::Client::new(&env, &token_contract);
+    
+    let initial_balance = 10_000i128;
+    token_client.mint(&business, &initial_balance);
+    token_client.mint(&investor, &initial_balance);
+    token_client.mint(&contract_id, &1i128);
+    
+    let expiration = env.ledger().sequence() + 1000;
+    token_client.approve(&business, &contract_id, &initial_balance, &expiration);
+    token_client.approve(&investor, &contract_id, &initial_balance, &expiration);
+    
+    // Create and verify invoice
+    let due_date = env.ledger().timestamp() + 86_400 * 30;
+    let invoice_id = client.store_invoice(
+        &business,
+        &1000i128,
+        &currency,
+        &due_date,
+        &String::from_str(&env, "Test invoice with real escrow"),
+        &InvoiceCategory::Services,
+        &Vec::new(&env),
+    );
+    client.verify_invoice(&invoice_id);
+    
+    // Setup and verify investor
+    client.submit_investor_kyc(&investor, &String::from_str(&env, "Investor KYC"));
+    let admin = Address::generate(&env);
+    client.verify_investor(&admin, &investor, &5000i128);
+    
+    // Place bid and accept to create real escrow
+    let bid_id = client.place_bid(&investor, &invoice_id, &1000i128, &1200i128);
+    client.accept_bid(&invoice_id, &bid_id);
+    
+    // Test: Real escrow should be created and consistent
+    let (status, details) = get_escrow_status_and_details(&env, &client, &invoice_id);
+    
+    assert_eq!(status, EscrowStatus::Held);
+    assert_eq!(details.status, EscrowStatus::Held);
+    assert_eq!(details.invoice_id, invoice_id);
+    assert_eq!(details.investor, investor);
+    assert_eq!(details.business, business);
+    assert_eq!(details.amount, 1000i128);
+    assert!(details.created_at > 0);
+    
+    // Verify actual token transfers occurred
+    assert_eq!(token_client.balance(&investor), initial_balance - 1000i128);
+    assert_eq!(token_client.balance(&contract_id), 1000i128);
+}
+
+#[test]
+fn test_escrow_status_consistency_state_transitions() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    
+    // Create funded invoice with escrow
+    let (invoice_id, _bid_id) = create_funded_invoice_with_escrow_for_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        1000i128,
+        1000i128,
+    );
+    
+    // Test state transitions and consistency at each step
+    let mut previous_details: Option<crate::payments::Escrow> = None;
+    
+    // Initial: Held state
+    let (status1, details1) = get_escrow_status_and_details(&env, &client, &invoice_id);
+    assert_eq!(status1, EscrowStatus::Held);
+    assert_eq!(details1.status, EscrowStatus::Held);
+    previous_details = Some(details1.clone());
+    
+    // After release: Released state
+    client.release_escrow_funds(&invoice_id);
+    let (status2, details2) = get_escrow_status_and_details(&env, &client, &invoice_id);
+    assert_eq!(status2, EscrowStatus::Released);
+    assert_eq!(details2.status, EscrowStatus::Released);
+    
+    // Verify only status changed, other fields remained same
+    if let Some(prev) = previous_details {
+        assert_eq!(prev.invoice_id, details2.invoice_id);
+        assert_eq!(prev.investor, details2.investor);
+        assert_eq!(prev.business, details2.business);
+        assert_eq!(prev.amount, details2.amount);
+        assert_eq!(prev.created_at, details2.created_at);
+    }
+    
+    // Test that Released cannot be released again (idempotency)
+    let result = client.release_escrow_funds(&invoice_id);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), QuickLendXError::InvalidStatus);
+}
+
+#[test]
+fn test_escrow_status_consistency_edge_cases() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    
+    // Create funded invoice with escrow
+    let (invoice_id, _bid_id) = create_funded_invoice_with_escrow_for_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        1000i128,
+        1000i128,
+    );
+    
+    // Test 1: Details should match status immediately after creation
+    let (status, details) = get_escrow_status_and_details(&env, &client, &invoice_id);
+    assert_eq!(status, EscrowStatus::Held);
+    assert_eq!(details.status, EscrowStatus::Held);
+    
+    // Test 2: Timestamp should be reasonable (not zero, not in future)
+    let current_time = env.ledger().timestamp();
+    assert!(details.created_at > 0);
+    assert!(details.created_at <= current_time);
+    
+    // Test 3: All required fields should be present
+    assert!(!details.invoice_id.is_zero());
+    assert!(!details.investor.is_zero());
+    assert!(!details.business.is_zero());
+    assert!(details.amount > 0);
+    assert!(!details.currency.is_zero());
+    
+    // Test 4: Fields should be consistent with each other
+    // (This would require additional validation logic in a real implementation)
+    // For now, we test that the basic consistency holds
+}
+
+#[test]
+fn test_escrow_status_consistency_with_multiple_invoices() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    
+    // Create two invoices with escrows
+    let (invoice_id1, _bid_id1) = create_funded_invoice_with_escrow_for_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        1000i128,
+        1000i128,
+    );
+    
+    let (invoice_id2, _bid_id2) = create_funded_invoice_with_escrow_for_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        2000i128,
+        2000i128,
+    );
+    
+    // Release first escrow
+    client.release_escrow_funds(&invoice_id1);
+    
+    // Test: Each escrow should have consistent status/details independently
+    let (status1, details1) = get_escrow_status_and_details(&env, &client, &invoice_id1);
+    let (status2, details2) = get_escrow_status_and_details(&env, &client, &invoice_id2);
+    
+    // First escrow should be Released
+    assert_eq!(status1, EscrowStatus::Released);
+    assert_eq!(details1.status, EscrowStatus::Released);
+    
+    // Second escrow should still be Held
+    assert_eq!(status2, EscrowStatus::Held);
+    assert_eq!(details2.status, EscrowStatus::Held);
+    
+    // Verify escrows are independent
+    assert_ne!(details1.invoice_id, details2.invoice_id);
+    assert_ne!(details1.amount, details2.amount);
+}
diff --git a/quicklendx-contracts/src/test_investment_terminal_states.rs b/quicklendx-contracts/src/test_investment_terminal_states.rs
new file mode 100644
index 00000000..54bfd1a0
--- /dev/null
+++ b/quicklendx-contracts/src/test_investment_terminal_states.rs
@@ -0,0 +1,506 @@
+//! Investment terminal state transition tests for QuickLendX protocol.
+//!
+//! Test suite validates allowed transitions into terminal investment statuses
+//! and matching invoice side effects as required by issue #717.
+//!
+//! ## Terminal States Tested
+//! - **Completed**: Investment successfully settled with full payment
+//! - **Withdrawn**: Investment funds withdrawn by investor  
+//! - **Defaulted**: Investment defaulted due to non-payment
+//! - **Refunded**: Investment refunded due to invoice cancellation
+//!
+//! ## Coverage Matrix
+//! | Test | From → To | Invoice Impact | Events | Storage Invariants |
+//! |------|-----------|----------------|--------|-------------------|
+//! | test_investment_completion_flow | Active → Completed | Paid | Settlement events | Active index cleaned |
+//! | test_investment_withdrawal_flow | Active → Withdrawn | Funded → Cancelled | Withdrawal events | Active index cleaned |
+//! | test_investment_default_flow | Active → Defaulted | Defaulted | Default events | Active index cleaned |
+//! | test_investment_refund_flow | Active → Refunded | Refunded | Refund events | Active index cleaned |
+//! | test_invalid_terminal_transitions | Terminal → Active | Rejected | - | Error validation |
+//! | test_terminal_state_immutability | Completed → * | Rejected | - | State preservation |
+//!
+//! Run: `cargo test test_investment_terminal_states`
+
+use super::*;
+use crate::investment::{InvestmentStatus, InvestmentStorage};
+use crate::invoice::{InvoiceCategory, InvoiceStatus};
+use crate::settlement::settle_invoice;
+use soroban_sdk::{
+    symbol_short,
+    testutils::{Address as _, Events, Ledger},
+    token, Address, BytesN, Env, String, Vec,
+};
+
+/// Helper to create a fully funded invoice with investment for terminal state testing
+fn setup_funded_investment_for_terminal_tests(
+    env: &Env,
+    client: &QuickLendXContractClient<'static>,
+    business: &Address,
+    investor: &Address,
+    currency: &Address,
+    invoice_amount: i128,
+    investment_amount: i128,
+) -> (BytesN<32>, BytesN<32>) {
+    let admin = Address::generate(env);
+    client.set_admin(&admin);
+
+    // Setup business KYC and verification
+    client.submit_kyc_application(business, &String::from_str(env, "Business KYC data"));
+    client.verify_business(&admin, business);
+
+    // Create and verify invoice
+    let due_date = env.ledger().timestamp() + 86_400 * 30; // 30 days
+    let invoice_id = client.store_invoice(
+        business,
+        &invoice_amount,
+        currency,
+        &due_date,
+        &String::from_str(env, "Test invoice for terminal states"),
+        &InvoiceCategory::Services,
+        &Vec::new(env),
+    );
+    client.verify_invoice(&invoice_id);
+
+    // Setup investor KYC and verification
+    client.submit_investor_kyc(investor, &String::from_str(env, "Investor KYC data"));
+    client.verify_investor(&admin, investor, &investment_amount);
+
+    // Place and accept bid to create investment
+    let bid_id = client.place_bid(investor, &invoice_id, &investment_amount, &invoice_amount);
+    client.accept_bid(&invoice_id, &bid_id);
+
+    (invoice_id, bid_id)
+}
+
+/// Helper to get investment by invoice ID for testing
+fn get_investment_by_invoice(
+    env: &Env,
+    invoice_id: &BytesN<32>,
+) -> crate::investment::Investment {
+    InvestmentStorage::get_investment_by_invoice(env, invoice_id)
+        .expect("Investment should exist for funded invoice")
+}
+
+/// Helper to verify investment is in active index
+fn investment_is_in_active_index(env: &Env, investment_id: &BytesN<32>) -> bool {
+    let active_ids = InvestmentStorage::get_active_investment_ids(env);
+    active_ids.iter().any(|id| id == investment_id)
+}
+
+/// Test investment completion flow (Active → Completed)
+#[test]
+fn test_investment_completion_flow() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = init_currency_for_test(&env, &contract_id, &business, &investor);
+    
+    let invoice_amount = 1000i128;
+    let investment_amount = 1000i128;
+    
+    // Setup funded investment
+    let (invoice_id, _bid_id) = setup_funded_investment_for_terminal_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        &currency,
+        invoice_amount,
+        investment_amount,
+    );
+    
+    // Verify initial state
+    let investment = get_investment_by_invoice(&env, &invoice_id);
+    assert_eq!(investment.status, InvestmentStatus::Active);
+    assert!(investment_is_in_active_index(&env, &investment.investment_id));
+    
+    // Settle invoice to trigger investment completion
+    client.settle_invoice(&invoice_id, &invoice_amount);
+    
+    // Verify terminal state
+    let updated_investment = get_investment_by_invoice(&env, &invoice_id);
+    assert_eq!(updated_investment.status, InvestmentStatus::Completed);
+    
+    // Verify active index cleanup
+    assert!(!investment_is_in_active_index(&env, &investment.investment_id));
+    
+    // Verify invoice state
+    let invoice = client.get_invoice(&invoice_id);
+    assert_eq!(invoice.status, InvoiceStatus::Paid);
+    
+    // Verify settlement events
+    assert!(has_event_with_topic(&env, symbol_short!("inv_setlf"))); // Invoice settled final
+}
+
+/// Test investment withdrawal flow (Active → Withdrawn)  
+#[test]
+fn test_investment_withdrawal_flow() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = init_currency_for_test(&env, &contract_id, &business, &investor);
+    
+    let invoice_amount = 1000i128;
+    let investment_amount = 1000i128;
+    
+    // Setup funded investment
+    let (invoice_id, bid_id) = setup_funded_investment_for_terminal_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        &currency,
+        invoice_amount,
+        investment_amount,
+    );
+    
+    // Verify initial state
+    let investment = get_investment_by_invoice(&env, &invoice_id);
+    assert_eq!(investment.status, InvestmentStatus::Active);
+    assert!(investment_is_in_active_index(&env, &investment.investment_id));
+    
+    // Withdraw bid before acceptance (this should transition to Withdrawn)
+    // Note: In current implementation, bid withdrawal happens before investment creation
+    // For this test, we'll simulate a direct investment withdrawal scenario
+    
+    // Cancel invoice to trigger investment withdrawal path
+    client.cancel_invoice(&invoice_id);
+    
+    // Verify investment state after cancellation (should be terminal)
+    let updated_investment = InvestmentStorage::get_investment_by_invoice(&env, &invoice_id);
+    if let Some(inv) = updated_investment {
+        // Investment should be in a terminal state after invoice cancellation
+        assert!(matches!(
+            inv.status,
+            InvestmentStatus::Refunded | InvestmentStatus::Withdrawn
+        ));
+        assert!(!investment_is_in_active_index(&env, &investment.investment_id));
+    }
+    
+    // Verify invoice state
+    let invoice = client.get_invoice(&invoice_id);
+    assert_eq!(invoice.status, InvoiceStatus::Cancelled);
+}
+
+/// Test investment default flow (Active → Defaulted)
+#[test]
+fn test_investment_default_flow() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = init_currency_for_test(&env, &contract_id, &business, &investor);
+    
+    let invoice_amount = 1000i128;
+    let investment_amount = 1000i128;
+    
+    // Setup funded investment with short due date for default testing
+    let (invoice_id, _bid_id) = setup_funded_investment_for_terminal_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        &currency,
+        invoice_amount,
+        investment_amount,
+    );
+    
+    // Verify initial state
+    let investment = get_investment_by_invoice(&env, &invoice_id);
+    assert_eq!(investment.status, InvestmentStatus::Active);
+    assert!(investment_is_in_active_index(&env, &investment.investment_id));
+    
+    // Advance time past due date + grace period to trigger default
+    let current_time = env.ledger().timestamp();
+    let grace_period = client.get_grace_period_seconds();
+    let default_time = current_time + 86_400 * 32 + grace_period; // Past due + grace
+    env.ledger().set_timestamp(default_time);
+    
+    // Trigger default handling (this would normally be done by a keeper/automation)
+    // For this test, we'll manually mark as defaulted to verify the transition
+    client.update_invoice_status(&invoice_id, &InvoiceStatus::Defaulted);
+    
+    // Verify investment defaulted state
+    let updated_investment = get_investment_by_invoice(&env, &invoice_id);
+    assert_eq!(updated_investment.status, InvestmentStatus::Defaulted);
+    
+    // Verify active index cleanup
+    assert!(!investment_is_in_active_index(&env, &investment.investment_id));
+    
+    // Verify invoice state
+    let invoice = client.get_invoice(&invoice_id);
+    assert_eq!(invoice.status, InvoiceStatus::Defaulted);
+}
+
+/// Test investment refund flow (Active → Refunded)
+#[test]
+fn test_investment_refund_flow() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = init_currency_for_test(&env, &contract_id, &business, &investor);
+    
+    let invoice_amount = 1000i128;
+    let investment_amount = 1000i128;
+    
+    // Setup funded investment
+    let (invoice_id, _bid_id) = setup_funded_investment_for_terminal_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        &currency,
+        invoice_amount,
+        investment_amount,
+    );
+    
+    // Verify initial state
+    let investment = get_investment_by_invoice(&env, &invoice_id);
+    assert_eq!(investment.status, InvestmentStatus::Active);
+    assert!(investment_is_in_active_index(&env, &investment.investment_id));
+    
+    // Refund escrow to trigger investment refund
+    client.refund_escrow_funds(&invoice_id);
+    
+    // Verify investment refunded state
+    let updated_investment = get_investment_by_invoice(&env, &invoice_id);
+    assert_eq!(updated_investment.status, InvestmentStatus::Refunded);
+    
+    // Verify active index cleanup
+    assert!(!investment_is_in_active_index(&env, &investment.investment_id));
+    
+    // Verify invoice state
+    let invoice = client.get_invoice(&invoice_id);
+    assert_eq!(invoice.status, InvoiceStatus::Refunded);
+    
+    // Verify refund events
+    assert!(has_event_with_topic(&env, symbol_short!("esc_ref"))); // Escrow refunded
+}
+
+/// Test invalid terminal state transitions (should fail)
+#[test]
+fn test_invalid_terminal_transitions() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = init_currency_for_test(&env, &contract_id, &business, &investor);
+    
+    let invoice_amount = 1000i128;
+    let investment_amount = 1000i128;
+    
+    // Setup and complete investment first
+    let (invoice_id, _bid_id) = setup_funded_investment_for_terminal_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        &currency,
+        invoice_amount,
+        investment_amount,
+    );
+    
+    // Complete the investment
+    client.settle_invoice(&invoice_id, &invoice_amount);
+    
+    // Verify investment is Completed
+    let investment = get_investment_by_invoice(&env, &invoice_id);
+    assert_eq!(investment.status, InvestmentStatus::Completed);
+    
+    // Attempting to transition back to Active should fail
+    // This would be tested through direct storage manipulation in a real scenario
+    // For now, we verify the state validation function works correctly
+    
+    // Test that validate_transition rejects invalid moves
+    let result = InvestmentStatus::validate_transition(
+        &InvestmentStatus::Completed,
+        &InvestmentStatus::Active,
+    );
+    assert!(result.is_err());
+    
+    let result = InvestmentStatus::validate_transition(
+        &InvestmentStatus::Withdrawn,
+        &InvestmentStatus::Active,
+    );
+    assert!(result.is_err());
+    
+    let result = InvestmentStatus::validate_transition(
+        &InvestmentStatus::Defaulted,
+        &InvestmentStatus::Completed,
+    );
+    assert!(result.is_err());
+}
+
+/// Test terminal state immutability (terminal states cannot change)
+#[test]
+fn test_terminal_state_immutability() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = init_currency_for_test(&env, &contract_id, &business, &investor);
+    
+    let invoice_amount = 1000i128;
+    let investment_amount = 1000i128;
+    
+    // Test all terminal states are immutable
+    let terminal_states = vec![
+        InvestmentStatus::Completed,
+        InvestmentStatus::Withdrawn,
+        InvestmentStatus::Defaulted,
+        InvestmentStatus::Refunded,
+    ];
+    
+    for terminal_state in terminal_states {
+        // Verify all terminal-to-terminal transitions are rejected
+        for other_terminal in &[
+            InvestmentStatus::Completed,
+            InvestmentStatus::Withdrawn,
+            InvestmentStatus::Defaulted,
+            InvestmentStatus::Refunded,
+        ] {
+            if terminal_state != *other_terminal {
+                let result = InvestmentStatus::validate_transition(&terminal_state, other_terminal);
+                assert!(result.is_err(), "Terminal state {:?} should not transition to {:?}", terminal_state, other_terminal);
+            }
+        }
+        
+        // Verify terminal-to-active transition is rejected
+        let result = InvestmentStatus::validate_transition(&terminal_state, &InvestmentStatus::Active);
+        assert!(result.is_err(), "Terminal state {:?} should not transition to Active", terminal_state);
+    }
+}
+
+/// Test investment storage invariants during terminal transitions
+#[test]
+fn test_investment_storage_invariants() {
+    let env = Env::default();
+    env.mock_all_auths();
+    env.ledger().set_timestamp(1_000_000);
+    
+    let contract_id = env.register(QuickLendXContract, ());
+    let client = QuickLendXContractClient::new(&env, &contract_id);
+    
+    let business = Address::generate(&env);
+    let investor = Address::generate(&env);
+    let currency = init_currency_for_test(&env, &contract_id, &business, &investor);
+    
+    let invoice_amount = 1000i128;
+    let investment_amount = 1000i128;
+    
+    // Setup funded investment
+    let (invoice_id, _bid_id) = setup_funded_investment_for_terminal_tests(
+        &env,
+        &client,
+        &business,
+        &investor,
+        &currency,
+        invoice_amount,
+        investment_amount,
+    );
+    
+    // Verify initial invariants
+    let investment = get_investment_by_invoice(&env, &invoice_id);
+    assert_eq!(investment.status, InvestmentStatus::Active);
+    assert!(investment_is_in_active_index(&env, &investment.investment_id));
+    
+    // Verify no orphan investments exist
+    assert!(InvestmentStorage::validate_no_orphan_investments(&env));
+    
+    // Complete investment
+    client.settle_invoice(&invoice_id, &invoice_amount);
+    
+    // Verify post-transition invariants
+    assert!(!investment_is_in_active_index(&env, &investment.investment_id));
+    assert!(InvestmentStorage::validate_no_orphan_investments(&env));
+    
+    // Verify investment still exists in storage but is terminal
+    let final_investment = get_investment_by_invoice(&env, &invoice_id);
+    assert_eq!(final_investment.status, InvestmentStatus::Completed);
+}
+
+/// Helper function to get grace period from protocol limits
+fn get_grace_period(env: &Env, client: &QuickLendXContractClient) -> u64 {
+    client.get_grace_period_seconds()
+}
+
+/// Helper function from test_settlement.rs - included here for completeness
+fn init_currency_for_test(
+    env: &Env,
+    contract_id: &Address,
+    business: &Address,
+    investor: &Address,
+) -> Address {
+    let token_admin = Address::generate(env);
+    let currency = env
+        .register_stellar_asset_contract_v2(token_admin.clone())
+        .address();
+    let token_client = token::Client::new(env, &currency);
+    let sac_client = token::StellarAssetClient::new(env, &currency);
+    let initial_balance = 10_000i128;
+
+    sac_client.mint(business, &initial_balance);
+    sac_client.mint(investor, &initial_balance);
+    sac_client.mint(contract_id, &1i128);
+
+    let expiration = env.ledger().sequence() + 1_000;
+    token_client.approve(business, contract_id, &initial_balance, &expiration);
+    token_client.approve(investor, contract_id, &initial_balance, &expiration);
+
+    currency
+}
+
+/// Helper function from test_settlement.rs - included here for completeness
+fn has_event_with_topic(env: &Env, topic: soroban_sdk::Symbol) -> bool {
+    use soroban_sdk::xdr::{ContractEventBody, ScVal};
+
+    let topic_str = topic.to_string();
+    let events = env.events().all();
+
+    for event in events.events() {
+        if let ContractEventBody::V0(v0) = &event.body {
+            for candidate in v0.topics.iter() {
+                if let ScVal::Symbol(symbol) = candidate {
+                    if symbol.0.as_slice() == topic_str.as_bytes() {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    false
+}
diff --git a/quicklendx-contracts/src/verification.rs b/quicklendx-contracts/src/verification.rs
index 287df101..294b6f8f 100644
--- a/quicklendx-contracts/src/verification.rs
+++ b/quicklendx-contracts/src/verification.rs
@@ -646,6 +646,20 @@ pub fn normalize_tag(env: &Env, tag: &String) -> Result<String, QuickLendXError>
     Ok(trimmed)
 }
 
+/// @notice Validate a bid against protocol rules and business constraints
+/// @dev Enforces minimum bid amounts (both absolute and percentage-based),
+///      invoice status checks, ownership validation, and investor capacity limits
+/// @param env The contract environment
+/// @param invoice The invoice being bid on
+/// @param bid_amount The amount being bid
+/// @param expected_return The expected return amount for the investor
+/// @param investor The address of the bidding investor
+/// @return Success if bid passes all validation rules
+/// @error InvalidAmount if bid amount is below minimum or exceeds invoice amount
+/// @error InvalidStatus if invoice is not in Verified state or is past due date
+/// @error Unauthorized if business tries to bid on own invoice
+/// @error OperationNotAllowed if investor already has an active bid on this invoice
+/// @error InsufficientCapacity if bid exceeds investor's remaining investment capacity
 pub fn validate_bid(
     env: &Env,
     invoice: &Invoice,
@@ -675,9 +689,18 @@ pub fn validate_bid(
 
     // 4. Protocol limits and bid size validation
     let limits = ProtocolLimitsContract::get_protocol_limits(env.clone());
-    let _limits = ProtocolLimitsContract::get_protocol_limits(env.clone());
-    let min_bid_amount = invoice.amount / 100; // 1% min bid
-    if bid_amount < min_bid_amount {
+    
+    // Calculate minimum bid amount using both absolute minimum and percentage-based minimum
+    let percent_min = invoice.amount
+        .saturating_mul(limits.min_bid_bps as i128)
+        .saturating_div(10_000);
+    let effective_min_bid = if percent_min > limits.min_bid_amount {
+        percent_min
+    } else {
+        limits.min_bid_amount
+    };
+    
+    if bid_amount < effective_min_bid {
         return Err(QuickLendXError::InvalidAmount);
     }