function verifyECDSA(
    bytes32 msgHash,
    bytes calldata signatures
) internal view returns (bool) {
    require(
        signatures.length % 65 == 0,
        "Signature length must be a multiple of 65"
    );

    uint256 len = signatures.length;
    uint256 m = 0;
    for (uint256 i = 0; i < len; i += 65) {
        bytes memory sig = signatures[i:i + 65];
        if (
            validators[msgHash.recover(sig)] && ++m >= required_validators
        ) {
            return true;
        }
    }

    return false;
}
fn check_chakra_signatures(
    self: @ContractState, message_hash: felt252, signatures: Array<(felt252, felt252, bool)>
){
    let mut pass_count = 0;
    let mut i = 0;
    loop {
        if i > signatures.len()-1{
            break;
        }
        let (r,s,y) = * signatures.at(i);

        let pub_key: felt252 = recover_public_key(message_hash,r,s,y).unwrap();
        if self.chakra_validators_pubkey.read(pub_key) > 0{
            pass_count += 1;
        }
        i += 1;
    };
    assert(pass_count >= self.required_validators_num.read(), 'Not enough validate signatures');
}
+ mapping (bytes32 msgHash => mapping(address validator => bool usedSig)) public isSignatureUsed;

  function verifyECDSA(
      bytes32 msgHash,
      bytes calldata signatures
  ) internal view returns (bool) {
      require(
          signatures.length % 65 == 0,
          "Signature length must be a multiple of 65"
      );

      uint256 len = signatures.length;
      uint256 m = 0;
      for (uint256 i = 0; i < len; i += 65) {
          bytes memory sig = signatures[i:i + 65];

+         address validator = msgHash.recover(sig);
          if (
-             validators[msgHash.recover(sig)] && ++m >= required_validators
+             !isSignatureUsed[msgHash][validator] && validators[validator]
          ) {
+             isSignatureUsed[msgHash][validator] = true;
+             m++;
          }

+         if (m >= required_validators) {
+             return true;
+         }
      }

      return false;
  }
fn check_chakra_signatures(
    self: @ContractState, 
    message_hash: felt252, 
    signatures: Array<(felt252, felt252, bool)>
) {
    let mut pass_count = 0;
    let mut i = 0;
    
    // A set-like structure to keep track of processed public keys.
+   let mut processed_pub_keys: LegacyMap<felt252, u8> = LegacyMap::new();
    
    loop {
        if i > signatures.len() - 1 {
            break;
        }
        
        let (r, s, y) = *signatures.at(i);
        let pub_key: felt252 = recover_public_key(message_hash, r, s, y).unwrap();
-       if self.chakra_validators_pubkey.read(pub_key) > 0{
+       if processed_pub_keys.get(pub_key) == 0 && self.chakra_validators_pubkey.read(pub_key) > 0 {
            pass_count += 1;
+           processed_pub_keys.append(pub_key);
        }
        
        i += 1;
    }
    
    assert(pass_count >= self.required_validators_num.read(), 'Not enough valid signatures');
}
