quick linting changes

target_chains/stylus/contracts/wormhole/README.md

@@ -23,7 +23,7 @@ contract Counter {
 
 To set up more minimal example that still uses the Stylus SDK, use `cargo stylus new --minimal <YOUR_PROJECT_NAME>` under [OffchainLabs/cargo-stylus](https://github.com/OffchainLabs/cargo-stylus).
 
-## Quick Start 
+## Quick Start
 
 Install [Rust](https://www.rust-lang.org/tools/install), and then install the Stylus CLI tool with Cargo
 
@@ -127,7 +127,6 @@ Estimated gas for deployment: 1874876
 
 The above only estimates gas for the deployment tx by default. To estimate gas for activation, first deploy your program using `--mode=deploy-only`, and then run `cargo stylus deploy` with the `--estimate-gas` flag, `--mode=activate-only`, and specify `--activate-program-address`.
 
-
 Here's how to deploy:
 
 ```bash

target_chains/stylus/contracts/wormhole/licenses/Apache-2.0

@@ -198,4 +198,4 @@
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
-   limitations under the License.
+   limitations under the License.

target_chains/stylus/contracts/wormhole/licenses/COPYRIGHT.md

@@ -2,4 +2,4 @@
 
 Copyright 2023 YOUR COMPANY
 
-Except as otherwise noted (below and/or in individual files), this project is licensed under the Apache License, Version 2.0 ([`LICENSE-APACHE`](Apache-2.0) or http://www.apache.org/licenses/LICENSE-2.0) or the MIT license, ([`LICENSE-MIT`](MIT) or http://opensource.org/licenses/MIT), at your option.
+Except as otherwise noted (below and/or in individual files), this project is licensed under the Apache License, Version 2.0 ([`LICENSE-APACHE`](Apache-2.0) or http://www.apache.org/licenses/LICENSE-2.0) or the MIT license, ([`LICENSE-MIT`](MIT) or http://opensource.org/licenses/MIT), at your option.

target_chains/stylus/contracts/wormhole/licenses/MIT

@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

target_chains/stylus/contracts/wormhole/src/lib.rs

@@ -324,7 +324,7 @@ impl WormholeContract {
         let guardian_set = self.get_guardian_set_internal(vm.guardian_set_index)
             .ok_or(WormholeError::InvalidGuardianSetIndex)?;
 
-        if vm.guardian_set_index != self.current_guardian_set_index.get().try_into().unwrap_or(0u32) 
+        if vm.guardian_set_index != self.current_guardian_set_index.get().try_into().unwrap_or(0u32)
             && guardian_set.expiration_time > 0 {
                 return Err(WormholeError::GuardianSetExpired)
         }
@@ -334,7 +334,7 @@ impl WormholeContract {
         if vm.signatures.len() < required_signatures as usize {
             return Err(WormholeError::InsufficientSignatures);
         }
-        
+
         let mut last_guardian_index: Option<u8> = None;
 
         for signature in &vm.signatures {
@@ -348,16 +348,16 @@ impl WormholeContract {
             if signature.guardian_index as usize >= guardian_set.keys.len() {
                 return Err(WormholeError::InvalidGuardianIndex);
             }
-            
+
             let guardian_address = guardian_set.keys[signature.guardian_index as usize];
-            
+
             match self.verify_signature(&vm.hash, &signature.signature, guardian_address) {
                 Ok(true) => {},
                 Ok(false) => return Err(WormholeError::InvalidSignature.into()),
                 Err(e) => return Err(e),
             }
         }
-        
+
         Ok(())
     }
 
@@ -398,7 +398,7 @@ impl WormholeContract {
         hash: &FixedBytes<32>,
         signature: &FixedBytes<65>,
         guardian_address: Address,
-    ) -> Result<bool, WormholeError> {        
+    ) -> Result<bool, WormholeError> {
         // Check length
         if signature.len() != 65 {
             return Err(WormholeError::InvalidSignature);
@@ -414,7 +414,7 @@ impl WormholeContract {
             _ => return Err(WormholeError::InvalidSignature),
         };
         // let recid = RecoveryId::try_from(signature[64] as i32).map_err(|_| WormholeError::InvalidSignature)?;
-        
+
         let recoverable_sig = RecoverableSignature::from_compact(&signature[..64], recid)
             .map_err(|_| WormholeError::InvalidSignature)?;
 
@@ -426,7 +426,7 @@ impl WormholeContract {
             .map_err(|_| WormholeError::InvalidSignature)?;
 
         let pubkey: &[u8; 65] = &pubkey_orig.serialize_uncompressed();
-        
+
         let address: [u8; 32] = Keccak256::new_with_prefix(&pubkey[1..]).finalize().into();
         let address: [u8; 20] = address[address.len() - 20..].try_into().map_err(|_| WormholeError::InvalidAddressLength)?;
 
@@ -509,7 +509,7 @@ mod tests {
     const CHAIN_ID: u16 = 60051;
     const GOVERNANCE_CHAIN_ID: u16 = 1;
     const GOVERNANCE_CONTRACT: U256 = U256::from_limbs([4, 0, 0, 0]);
-    
+
     fn test_guardian_secret1() -> SecretKey {
         SecretKey::from_slice(&[
             0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
@@ -600,7 +600,7 @@ mod tests {
         }
         let pos = pos % real_data.len();
         let pos2 = (pos + 1) % real_data.len();
-        
+
         real_data[pos] = real_data[pos].wrapping_add(random1).wrapping_add(1);
         real_data[pos2] = real_data[pos2].wrapping_add(random2).wrapping_add(1);
         real_data
@@ -625,7 +625,7 @@ mod tests {
     fn create_test_vm_with_emitter(guardian_set_index: u32, signatures: Vec<GuardianSignature>, emitter: Address) -> VerifiedVM {
         let mut emitter_bytes = [0u8; 32];
         emitter_bytes[12..32].copy_from_slice(emitter.as_slice());
-        
+
         VerifiedVM {
             version: 1,
             guardian_set_index,
@@ -695,7 +695,7 @@ mod tests {
     #[motsu::test]
     fn test_get_guardian_set_works() {
         let contract = deploy_with_mainnet_guardian_set0();
-        
+
         let set0 = contract.get_guardian_set_internal(0).unwrap();
         assert_eq!(set0.keys, guardian_set0());
         assert_eq!(set0.expiration_time, 0);
@@ -720,7 +720,7 @@ mod tests {
     fn test_verify_vm_invalid_guardian_set() {
         let contract = deploy_with_test_guardian();
         let vm = create_test_vm(999, vec![]);
-        
+
         let result = contract.verify_vm(&vm);
         assert!(matches!(result, Err(WormholeError::InvalidGuardianSetIndex)));
     }
@@ -729,7 +729,7 @@ mod tests {
     fn test_verify_vm_insufficient_signatures() {
         let contract = deploy_with_test_guardian();
         let vm = create_test_vm(0, vec![]);
-        
+
         let result = contract.verify_vm(&vm);
         assert!(matches!(result, Err(WormholeError::InsufficientSignatures)));
     }
@@ -743,14 +743,14 @@ mod tests {
             Address::from([0x34u8; 20]),
         ];
         contract.store_guardian_set(0, guardians, 0).unwrap();
-        
+
         let signatures = vec![
             create_guardian_signature(2),
             create_guardian_signature(1), // Out of order - should trigger error
             create_guardian_signature(0),
         ];
         let vm = create_test_vm(0, signatures); // Use guardian set 0
-        
+
         let result = contract.verify_vm(&vm);
         assert!(matches!(result, Err(WormholeError::InvalidSignature)));
     }
@@ -762,7 +762,7 @@ mod tests {
             create_guardian_signature(5),
         ];
         let vm = create_test_vm(0, signatures);
-        
+
         let result = contract.verify_vm(&vm);
         assert!(matches!(result, Err(WormholeError::InvalidGuardianIndex)));
     }
@@ -794,7 +794,7 @@ mod tests {
     fn test_rejects_empty_guardian_set() {
         let mut contract = WormholeContract::default();
         let empty_guardians: Vec<Address> = vec![];
-        
+
         let result = contract.store_guardian_set(0, empty_guardians, 0);
         assert!(result.is_err());
     }
@@ -802,7 +802,7 @@ mod tests {
     #[motsu::test]
     fn test_rejects_invalid_guardian_set_index() {
         let contract = deploy_with_test_guardian();
-        
+
         let result = contract.get_guardian_set_internal(999);
         assert!(result.is_none());
     }
@@ -810,7 +810,7 @@ mod tests {
     #[motsu::test]
     fn test_submit_guardian_set_rejects_invalid_emitter() {
         let contract = deploy_with_test_guardian();
-        
+
         let vm = create_test_vm_with_emitter(0, vec![], Address::from([0x99u8; 20]));
         let result = contract.verify_vm(&vm);
         assert!(result.is_err());
@@ -819,7 +819,7 @@ mod tests {
     #[motsu::test]
     fn test_submit_guardian_set_rejects_wrong_index() {
         let contract = deploy_with_mainnet_guardian_set0();
-        
+
         let vm = create_test_vm(2, vec![]); // Skip index 1
         let result = contract.verify_vm(&vm);
         assert!(matches!(result, Err(WormholeError::InvalidGuardianSetIndex)));
@@ -829,7 +829,7 @@ mod tests {
     fn test_deploy_rejects_empty_guardian_set() {
         let mut contract = WormholeContract::default();
         let empty_guardians: Vec<Address> = vec![];
-        
+
         let result = contract.initialize(empty_guardians, 1, 1, Address::default());
         assert!(result.is_err());
     }
@@ -838,7 +838,7 @@ mod tests {
     fn test_submit_guardian_set_rejects_empty() {
         let mut contract = WormholeContract::default();
         let empty_guardians: Vec<Address> = vec![];
-        
+
         let result = contract.store_guardian_set(0, empty_guardians, 0);
         assert!(result.is_err());
     }
@@ -846,7 +846,7 @@ mod tests {
     #[motsu::test]
     fn test_rejects_corrupted_vm_data() {
         let _contract = deploy_with_mainnet_guardians();
-        
+
         for i in 0..10 {
             let corrupted_data = corrupted_vm(vec![1, 0, 0, 1, 0, 0], i, i as u8, (i * 2) as u8);
             let result = WormholeContract::parse_vm_static(&corrupted_data);
@@ -857,7 +857,7 @@ mod tests {
     #[motsu::test]
     fn test_parse_and_verify_vm_rejects_corrupted_vm() {
         let contract = deploy_with_mainnet_guardians();
-        
+
         for i in 0..5 {
             let base_vm = vec![1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
             let corrupted_data = corrupted_vm(base_vm, i, i as u8, (i * 3) as u8);
@@ -869,10 +869,10 @@ mod tests {
     #[motsu::test]
     fn test_submit_guardian_set_rejects_non_governance() {
         let contract = deploy_with_mainnet_guardian_set0();
-        
+
         let mut vm = create_test_vm(0, vec![]);
         vm.emitter_chain_id = 999; // Wrong chain
-        
+
         let result = contract.verify_vm(&vm);
         assert!(result.is_err());
     }
@@ -884,9 +884,9 @@ mod tests {
             test_guardian_address1(),
             test_guardian_address2(),
         ];
-        
+
         contract.store_guardian_set(0, guardians.clone(), 0).unwrap();
-        
+
         let retrieved_set = contract.get_guardian_set_internal(0).unwrap();
         assert_eq!(retrieved_set.keys, guardians);
         assert_eq!(retrieved_set.expiration_time, 0);
@@ -910,13 +910,13 @@ mod tests {
     #[motsu::test]
     fn test_multiple_guardian_sets() {
         let mut contract = WormholeContract::default();
-        
+
         contract.store_guardian_set(0, guardian_set0(), 0).unwrap();
         contract.store_guardian_set(4, guardian_set4(), 0).unwrap();
-        
+
         let set0 = contract.get_guardian_set_internal(0).unwrap();
         let set4 = contract.get_guardian_set_internal(4).unwrap();
-        
+
         assert_eq!(set0.keys, guardian_set0());
         assert_eq!(set4.keys, guardian_set4());
     }
@@ -954,7 +954,7 @@ mod tests {
     #[motsu::test]
     fn test_chain_id_governance_values() {
         let contract = deploy_with_mainnet_guardians();
-        
+
         assert_eq!(contract.get_chain_id().unwrap(), CHAIN_ID);
         assert_eq!(contract.get_governance_chain_id().unwrap(), GOVERNANCE_CHAIN_ID);
         assert_eq!(contract.get_governance_contract().unwrap(), Address::from_slice(&GOVERNANCE_CONTRACT.to_be_bytes::<32>()[12..32]));
@@ -963,7 +963,7 @@ mod tests {
     #[motsu::test]
     fn test_governance_action_consumed() {
         let contract = deploy_with_mainnet_guardians();
-        
+
         let test_hash = vec![0u8; 32];
         assert_eq!(contract.governance_action_is_consumed(test_hash), false);
     }