feat: add comprehensive unit tests for critical contract modules

- Add tests for emergency module (pause/resume, circuit breaker): 13 tests
- Add tests for liquidity module (pools, fees, AMM): 13 tests
- Add tests for audit module (records, compliance, queries): 10 tests
- Add tests for BFT consensus module (validators, proposals, voting): 14 tests
- Add tests for atomic swap module (validation, error paths): 8 tests
- Rewrite bridge tests from commented stubs to working tests: 15 tests
- Expose missing contract functions for testability (circuit breaker,
  audit queries, fee structure, liquidity checks)
- Export CircuitBreaker and BridgeFeeStructure types
- Update CI to run tests, clippy, and coverage reporting with tarpaulin

Total: 112 -> 185 passing tests (+73 new), 0 modules with zero coverage

Author: Wetshakat

.github/workflows/ci.yml

@@ -25,3 +25,47 @@ jobs:
 
       - name: Build WASM (release)
         run: cargo build --target wasm32-unknown-unknown --release
+
+      - name: Run tests
+        run: cargo test --workspace
+
+      - name: Clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+  coverage:
+    runs-on: ubuntu-latest
+    needs: rust
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install cargo-tarpaulin
+        run: cargo install cargo-tarpaulin
+
+      - name: Generate coverage report
+        run: |
+          cargo tarpaulin \
+            --workspace \
+            --out xml \
+            --out html \
+            --output-dir coverage \
+            --skip-clean \
+            --exclude-files "*/tests/*" "*/test_*" \
+            --timeout 300
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          files: coverage/cobertura.xml
+          fail_ci_if_error: false
+
+      - name: Upload coverage artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report
+          path: coverage/

contracts/teachlink/src/lib.rs

@@ -140,9 +140,10 @@ pub use assessment::{
 pub use errors::{BridgeError, EscrowError, MobilePlatformError, RewardsError};
 pub use types::{
     AlertConditionType, AlertRule, ArbitratorProfile, AtomicSwap, AuditRecord, BackupManifest,
-    BackupSchedule, BridgeMetrics, BridgeProposal, BridgeTransaction, CachedBridgeSummary,
-    ChainConfig, ChainMetrics, ComplianceReport, ConsensusState, ContentMetadata, ContentToken,
-    ContentTokenParameters, ContentType, CrossChainMessage, CrossChainPacket, DashboardAnalytics,
+    BackupSchedule, BridgeFeeStructure, BridgeMetrics, BridgeProposal, BridgeTransaction,
+    CachedBridgeSummary, ChainConfig, ChainMetrics, CircuitBreaker, ComplianceReport,
+    ConsensusState, ContentMetadata, ContentToken, ContentTokenParameters, ContentType,
+    Contribution, ContributionType, CrossChainMessage, CrossChainPacket, DashboardAnalytics,
     DisputeOutcome, EmergencyState, Escrow, EscrowMetrics, EscrowParameters, EscrowRole,
     EscrowSigner, EscrowStatus, LiquidityPool, MultiChainAsset, NotificationChannel,
     NotificationContent, NotificationPreference, NotificationSchedule, NotificationTemplate,
@@ -509,6 +510,16 @@ impl TeachLinkBridge {
         liquidity::LiquidityManager::get_available_liquidity(&env, chain_id)
     }
 
+    /// Get fee structure
+    pub fn get_fee_structure(env: Env) -> BridgeFeeStructure {
+        liquidity::LiquidityManager::get_fee_structure(&env)
+    }
+
+    /// Check if pool has sufficient liquidity
+    pub fn has_sufficient_liquidity(env: Env, chain_id: u32, amount: i128) -> bool {
+        liquidity::LiquidityManager::has_sufficient_liquidity(&env, chain_id, amount)
+    }
+
     // ========== Message Passing Functions ==========
 
     /// Send a cross-chain packet
@@ -642,6 +653,51 @@ impl TeachLinkBridge {
         emergency::EmergencyManager::get_emergency_state(&env)
     }
 
+    /// Check circuit breaker for a transaction
+    pub fn check_circuit_breaker(
+        env: Env,
+        chain_id: u32,
+        amount: i128,
+    ) -> Result<(), BridgeError> {
+        emergency::EmergencyManager::check_circuit_breaker(&env, chain_id, amount)
+    }
+
+    /// Reset circuit breaker for a chain
+    pub fn reset_circuit_breaker(
+        env: Env,
+        chain_id: u32,
+        resetter: Address,
+    ) -> Result<(), BridgeError> {
+        emergency::EmergencyManager::reset_circuit_breaker(&env, chain_id, resetter)
+    }
+
+    /// Get circuit breaker state
+    pub fn get_circuit_breaker(env: Env, chain_id: u32) -> Option<CircuitBreaker> {
+        emergency::EmergencyManager::get_circuit_breaker(&env, chain_id)
+    }
+
+    /// Get all paused chains
+    pub fn get_paused_chains(env: Env) -> Vec<u32> {
+        emergency::EmergencyManager::get_paused_chains(&env)
+    }
+
+    /// Update circuit breaker limits
+    pub fn update_circuit_breaker_limits(
+        env: Env,
+        chain_id: u32,
+        max_daily_volume: i128,
+        max_transaction_amount: i128,
+        updater: Address,
+    ) -> Result<(), BridgeError> {
+        emergency::EmergencyManager::update_circuit_breaker_limits(
+            &env,
+            chain_id,
+            max_daily_volume,
+            max_transaction_amount,
+            updater,
+        )
+    }
+
     // ========== Audit and Compliance Functions ==========
 
     /// Create an audit record
@@ -674,6 +730,66 @@ impl TeachLinkBridge {
         audit::AuditManager::get_compliance_report(&env, report_id)
     }
 
+    /// Get audit record count
+    pub fn get_audit_count(env: Env) -> u64 {
+        audit::AuditManager::get_audit_count(&env)
+    }
+
+    /// Get audit records by operation type
+    pub fn get_audit_records_by_type(
+        env: Env,
+        operation_type: types::OperationType,
+    ) -> Vec<AuditRecord> {
+        audit::AuditManager::get_audit_records_by_type(&env, operation_type)
+    }
+
+    /// Get audit records by operator
+    pub fn get_audit_records_by_operator(env: Env, operator: Address) -> Vec<AuditRecord> {
+        audit::AuditManager::get_audit_records_by_operator(&env, operator)
+    }
+
+    /// Get audit records by time range
+    pub fn get_audit_records_by_time(
+        env: Env,
+        start_time: u64,
+        end_time: u64,
+    ) -> Vec<AuditRecord> {
+        audit::AuditManager::get_audit_records_by_time(&env, start_time, end_time)
+    }
+
+    /// Get recent audit records
+    pub fn get_recent_audit_records(env: Env, count: u32) -> Vec<AuditRecord> {
+        audit::AuditManager::get_recent_audit_records(&env, count)
+    }
+
+    /// Clear old audit records
+    pub fn clear_old_records(env: Env, before_timestamp: u64, admin: Address) -> Result<u32, BridgeError> {
+        audit::AuditManager::clear_old_records(&env, before_timestamp, admin)
+    }
+
+    /// Log bridge operation
+    pub fn log_bridge_operation(
+        env: Env,
+        is_outgoing: bool,
+        operator: Address,
+        amount: i128,
+        chain_id: u32,
+        tx_hash: Bytes,
+    ) -> Result<u64, BridgeError> {
+        audit::AuditManager::log_bridge_operation(&env, is_outgoing, operator, amount, chain_id, tx_hash)
+    }
+
+    /// Log emergency operation
+    pub fn log_emergency_operation(
+        env: Env,
+        is_pause: bool,
+        operator: Address,
+        reason: Bytes,
+        tx_hash: Bytes,
+    ) -> Result<u64, BridgeError> {
+        audit::AuditManager::log_emergency_operation(&env, is_pause, operator, reason, tx_hash)
+    }
+
     // ========== Atomic Swap Functions ==========
 
     /// Initiate an atomic swap

contracts/teachlink/test_snapshots/bridge/tests/complete_bridge_rejects_replay_when_nonce_already_processed.1.json

@@ -0,0 +1,124 @@
+{
+  "generators": {
+    "address": 4,
+    "nonce": 0,
+    "mux_id": 0
+  },
+  "auth": [
+    [],
+    []
+  ],
+  "ledger": {
+    "protocol_version": 25,
+    "sequence_number": 0,
+    "timestamp": 0,
+    "network_id": "0000000000000000000000000000000000000000000000000000000000000000",
+    "base_reserve": 0,
+    "min_persistent_entry_ttl": 4096,
+    "min_temp_entry_ttl": 16,
+    "max_entry_ttl": 6312000,
+    "ledger_entries": [
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_data": {
+              "ext": "v0",
+              "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
+              "key": {
+                "symbol": "nonce"
+              },
+              "durability": "persistent",
+              "val": {
+                "map": [
+                  {
+                    "key": {
+                      "u64": "7"
+                    },
+                    "val": {
+                      "bool": true
+                    }
+                  }
+                ]
+              }
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      },
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_data": {
+              "ext": "v0",
+              "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
+              "key": "ledger_key_contract_instance",
+              "durability": "persistent",
+              "val": {
+                "contract_instance": {
+                  "executable": {
+                    "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+                  },
+                  "storage": [
+                    {
+                      "key": {
+                        "symbol": "min_valid"
+                      },
+                      "val": {
+                        "u32": 1
+                      }
+                    },
+                    {
+                      "key": {
+                        "symbol": "token"
+                      },
+                      "val": {
+                        "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT4"
+                      }
+                    },
+                    {
+                      "key": {
+                        "symbol": "validtor"
+                      },
+                      "val": {
+                        "map": [
+                          {
+                            "key": {
+                              "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M"
+                            },
+                            "val": {
+                              "bool": true
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      },
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_code": {
+              "ext": "v0",
+              "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+              "code": ""
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      }
+    ]
+  },
+  "events": []
+}

contracts/teachlink/test_snapshots/bridge/tests/mark_bridge_failed_requires_existing_tx.1.json

@@ -0,0 +1,61 @@
+{
+  "generators": {
+    "address": 1,
+    "nonce": 0,
+    "mux_id": 0
+  },
+  "auth": [
+    [],
+    []
+  ],
+  "ledger": {
+    "protocol_version": 25,
+    "sequence_number": 0,
+    "timestamp": 0,
+    "network_id": "0000000000000000000000000000000000000000000000000000000000000000",
+    "base_reserve": 0,
+    "min_persistent_entry_ttl": 4096,
+    "min_temp_entry_ttl": 16,
+    "max_entry_ttl": 6312000,
+    "ledger_entries": [
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_data": {
+              "ext": "v0",
+              "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
+              "key": "ledger_key_contract_instance",
+              "durability": "persistent",
+              "val": {
+                "contract_instance": {
+                  "executable": {
+                    "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+                  },
+                  "storage": null
+                }
+              }
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      },
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_code": {
+              "ext": "v0",
+              "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+              "code": ""
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      }
+    ]
+  },
+  "events": []
+}