Merge pull request #340 from devkryssie/feat/bridge-multisig-validation-203

feat(bridge): add multi-signature validator enforcement for cross-chain transactions

Author: LaGodxy

contracts/bridge/src/lib.rs

@@ -44,6 +44,10 @@ mod bridge {
         /// Bridge operators
         bridge_operators: Vec<AccountId>,
 
+        /// Registered validators for multi-signature cross-chain transactions.
+        /// Only accounts in this set may sign bridge requests (issue #203).
+        validators: Vec<AccountId>,
+
         /// Request counter
         request_counter: u64,
 
@@ -163,6 +167,7 @@ mod bridge {
                 verified_transactions: Mapping::default(),
                 cross_chain_trades: Mapping::default(),
                 bridge_operators: vec![caller],
+                validators: Vec::new(),
                 request_counter: 0,
                 transaction_counter: 0,
                 cross_chain_trade_counter: 0,
@@ -272,8 +277,8 @@ mod bridge {
         pub fn sign_bridge_request(&mut self, request_id: u64, approve: bool) -> Result<(), Error> {
             let caller = self.env().caller();
 
-            // Check if caller is a bridge operator
-            if !self.bridge_operators.contains(&caller) {
+            // Check if caller is a registered validator (issue #203: only validators may sign)
+            if !self.validators.contains(&caller) {
                 return Err(Error::Unauthorized);
             }
 
@@ -688,6 +693,39 @@ mod bridge {
             self.bridge_operators.clone()
         }
 
+        /// Adds a validator (admin only). Only validators may sign bridge requests (issue #203).
+        #[ink(message)]
+        pub fn add_validator(&mut self, validator: AccountId) -> Result<(), Error> {
+            if self.env().caller() != self.admin {
+                return Err(Error::Unauthorized);
+            }
+            if !self.validators.contains(&validator) {
+                self.validators.push(validator);
+            }
+            Ok(())
+        }
+
+        /// Removes a validator (admin only).
+        #[ink(message)]
+        pub fn remove_validator(&mut self, validator: AccountId) -> Result<(), Error> {
+            if self.env().caller() != self.admin {
+                return Err(Error::Unauthorized);
+            }
+            self.validators.retain(|v| v != &validator);
+            Ok(())
+        }
+
+        /// Returns all registered validators.
+        #[ink(message)]
+        pub fn get_validators(&self) -> Vec<AccountId> {
+            self.validators.clone()
+        }
+
+        /// Returns whether an account is a registered validator.
+        #[ink(message)]
+        pub fn is_validator(&self, account: AccountId) -> bool {
+            self.validators.contains(&account)
+        }
         /// Updates bridge configuration (admin only)
         #[ink(message)]
         pub fn update_config(&mut self, config: BridgeConfig) -> Result<(), Error> {

contracts/bridge/src/tests.rs

@@ -41,7 +41,10 @@ mod tests {
         let mut bridge = setup_bridge();
         let accounts = test::default_accounts::<DefaultEnvironment>();
 
+        // Register alice as a validator before signing (issue #203)
         test::set_caller::<DefaultEnvironment>(accounts.alice);
+        bridge.add_validator(accounts.alice).expect("admin can add validator");
+
         let metadata = PropertyMetadata {
             location: String::from("Test Property"),
             size: 1000,
@@ -54,9 +57,71 @@ mod tests {
             .initiate_bridge_multisig(1, 2, accounts.bob, 2, Some(50), metadata)
             .expect("Bridge initiation should succeed in test");
 
+        test::set_caller::<DefaultEnvironment>(accounts.alice);
+        let result = bridge.sign_bridge_request(request_id, true);
+        assert!(result.is_ok());
+    }
+
+    #[ink::test]
+    fn test_non_validator_cannot_sign() {
+        let mut bridge = setup_bridge();
         let accounts = test::default_accounts::<DefaultEnvironment>();
+
         test::set_caller::<DefaultEnvironment>(accounts.alice);
+        let metadata = PropertyMetadata {
+            location: String::from("Test Property"),
+            size: 1000,
+            legal_description: String::from("Test"),
+            valuation: 100000,
+            documents_url: String::from("ipfs://test"),
+        };
+        let request_id = bridge
+            .initiate_bridge_multisig(1, 2, accounts.bob, 2, Some(50), metadata)
+            .expect("initiation should succeed");
+
+        // bob is a bridge operator but NOT a validator — must be rejected
+        bridge.add_bridge_operator(accounts.bob).expect("admin can add operator");
+        test::set_caller::<DefaultEnvironment>(accounts.bob);
         let result = bridge.sign_bridge_request(request_id, true);
+        assert_eq!(result, Err(Error::Unauthorized));
+    }
+
+    #[ink::test]
+    fn test_threshold_enforced_at_execution() {
+        let mut bridge = setup_bridge();
+        let accounts = test::default_accounts::<DefaultEnvironment>();
+
+        // Register two validators
+        test::set_caller::<DefaultEnvironment>(accounts.alice);
+        bridge.add_validator(accounts.alice).expect("add validator alice");
+        bridge.add_validator(accounts.bob).expect("add validator bob");
+        bridge.add_bridge_operator(accounts.bob).expect("add operator bob");
+
+        let metadata = PropertyMetadata {
+            location: String::from("Test Property"),
+            size: 1000,
+            legal_description: String::from("Test"),
+            valuation: 100000,
+            documents_url: String::from("ipfs://test"),
+        };
+        let request_id = bridge
+            .initiate_bridge_multisig(1, 2, accounts.charlie, 2, Some(50), metadata)
+            .expect("initiation should succeed");
+
+        // Only one signature — execution must fail
+        test::set_caller::<DefaultEnvironment>(accounts.alice);
+        bridge.sign_bridge_request(request_id, true).expect("alice signs");
+
+        test::set_caller::<DefaultEnvironment>(accounts.alice);
+        let result = bridge.execute_bridge(request_id);
+        assert_eq!(result, Err(Error::InvalidRequest)); // status not Locked yet
+
+        // Second signature — now threshold met, execution succeeds
+        test::set_caller::<DefaultEnvironment>(accounts.bob);
+        bridge.sign_bridge_request(request_id, true).expect("bob signs");
+
+        test::set_caller::<DefaultEnvironment>(accounts.alice);
+        let result = bridge.execute_bridge(request_id);
         assert!(result.is_ok());
     }