solana: run `cargo fmt`

solana/bridge/cpi_poster/src/lib.rs

@@ -1,4 +1,3 @@
-
 #![feature(adt_const_params)]
 #![allow(non_upper_case_globals)]
 #![allow(incomplete_features)]

solana/bridge/program/src/accounts/bridge.rs

@@ -41,8 +41,8 @@ impl Owned for BridgeData {
 #[cfg(feature = "cpi")]
 impl Owned for BridgeData {
     fn owner(&self) -> AccountOwner {
-        use std::str::FromStr;
         use solana_program::pubkey::Pubkey;
+        use std::str::FromStr;
         AccountOwner::Other(Pubkey::from_str(env!("BRIDGE_ADDRESS")).unwrap())
     }
 }

solana/bridge/program/src/accounts/posted_message.rs

@@ -87,7 +87,7 @@ impl BorshSerialize for PostedMessageData {
 impl BorshDeserialize for PostedMessageData {
     fn deserialize(buf: &mut &[u8]) -> std::io::Result<Self> {
         if buf.len() < 3 {
-            return Err(Error::new(InvalidData, "Not enough bytes"))
+            return Err(Error::new(InvalidData, "Not enough bytes"));
         }
 
         let expected = b"msg";
@@ -157,7 +157,7 @@ impl BorshSerialize for PostedMessageUnreliableData {
 impl BorshDeserialize for PostedMessageUnreliableData {
     fn deserialize(buf: &mut &[u8]) -> std::io::Result<Self> {
         if buf.len() < 3 {
-            return Err(Error::new(InvalidData, "Not enough bytes"))
+            return Err(Error::new(InvalidData, "Not enough bytes"));
         }
 
         let expected = b"msu";

solana/bridge/program/src/accounts/sequence.rs

@@ -5,8 +5,8 @@ use borsh::{
 use solana_program::pubkey::Pubkey;
 use solitaire::{
     processors::seeded::Seeded,
-    AccountState,
     AccountOwner,
+    AccountState,
     Data,
     Owned,
 };

solana/bridge/program/tests/common.rs

@@ -16,8 +16,8 @@ use solana_program::{
 };
 use solana_program_test::{
     BanksClient,
-    ProgramTest,
     BanksClientError,
+    ProgramTest,
 };
 use solana_sdk::{
     commitment_config::CommitmentLevel,
@@ -69,8 +69,8 @@ pub async fn execute<T: Signers>(
 }
 
 mod helpers {
-    use solana_program_test::processor;
     use super::*;
+    use solana_program_test::processor;
 
     /// Initialize the test environment, spins up a solana-test-validator in the background so that
     /// each test has a fresh environment to work within.
@@ -79,11 +79,7 @@ mod helpers {
             .unwrap_or_else(|_| "Bridge1p5gheXUvJ6jGWGeCsgPKgnE3YgdGKRVCMY9o".to_string())
             .parse::<Pubkey>()
             .unwrap();
-        let builder = ProgramTest::new(
-            "bridge",
-            program,
-            processor!(instruction::solitaire),
-        );
+        let builder = ProgramTest::new("bridge", program, processor!(instruction::solitaire));
 
         let (client, payer, _) = builder.start().await;
 
@@ -244,7 +240,7 @@ mod helpers {
 
         let message: &Keypair = match message {
             Some(keypair) => keypair,
-            None => new_message_pair
+            None => new_message_pair,
         };
 
         // Capture the resulting message, later functions will need this.

solana/bridge/program/tests/integration.rs

@@ -159,7 +159,10 @@ async fn bridge_messages() {
         assert_eq!(posted_message.message.nonce, nonce);
         assert_eq!(posted_message.message.sequence, sequence);
         assert_eq!(posted_message.message.emitter_chain, 1);
-        assert_eq!(&posted_message.message.emitter_address, emitter.pubkey().as_ref());
+        assert_eq!(
+            &posted_message.message.emitter_address,
+            emitter.pubkey().as_ref()
+        );
         assert_eq!(posted_message.message.payload, message);
         assert_eq!(
             posted_message.message.emitter_address,
@@ -203,7 +206,10 @@ async fn bridge_messages() {
         assert_eq!(posted_message.message.nonce, nonce);
         assert_eq!(posted_message.message.sequence, sequence);
         assert_eq!(posted_message.message.emitter_chain, 1);
-        assert_eq!(&posted_message.message.emitter_address, emitter.pubkey().as_ref());
+        assert_eq!(
+            &posted_message.message.emitter_address,
+            emitter.pubkey().as_ref()
+        );
         assert_eq!(posted_message.message.payload, message);
         assert_eq!(
             posted_message.message.emitter_address,
@@ -244,7 +250,10 @@ async fn bridge_messages() {
     assert_eq!(posted_message.message.nonce, nonce);
     assert_eq!(posted_message.message.sequence, sequence);
     assert_eq!(posted_message.message.emitter_chain, 1);
-    assert_eq!(&posted_message.message.emitter_address, emitter.pubkey().as_ref());
+    assert_eq!(
+        &posted_message.message.emitter_address,
+        emitter.pubkey().as_ref()
+    );
     assert_eq!(posted_message.message.payload, message);
     assert_eq!(
         posted_message.message.emitter_address,
@@ -286,7 +295,10 @@ async fn bridge_messages() {
     assert_eq!(posted_message.message.nonce, nonce);
     assert_eq!(posted_message.message.sequence, sequence);
     assert_eq!(posted_message.message.emitter_chain, 1);
-    assert_eq!(&posted_message.message.emitter_address, emitter.pubkey().as_ref());
+    assert_eq!(
+        &posted_message.message.emitter_address,
+        emitter.pubkey().as_ref()
+    );
     assert_eq!(posted_message.message.payload, message);
     assert_eq!(
         posted_message.message.emitter_address,
@@ -703,7 +715,10 @@ async fn guardian_set_change() {
     assert_eq!(posted_message.message.nonce, nonce);
     assert_eq!(posted_message.message.sequence, sequence);
     assert_eq!(posted_message.message.emitter_chain, 1);
-    assert_eq!(&posted_message.message.emitter_address, emitter.pubkey().as_ref());
+    assert_eq!(
+        &posted_message.message.emitter_address,
+        emitter.pubkey().as_ref()
+    );
     assert_eq!(posted_message.message.payload, message);
     assert_eq!(
         posted_message.message.emitter_address,
@@ -762,7 +777,10 @@ async fn guardian_set_change() {
     assert_eq!(posted_message.message.nonce, nonce);
     assert_eq!(posted_message.message.sequence, sequence);
     assert_eq!(posted_message.message.emitter_chain, 1);
-    assert_eq!(&posted_message.message.emitter_address, emitter.pubkey().as_ref());
+    assert_eq!(
+        &posted_message.message.emitter_address,
+        emitter.pubkey().as_ref()
+    );
     assert_eq!(posted_message.message.payload, message);
     assert_eq!(
         posted_message.message.emitter_address,
@@ -949,11 +967,18 @@ async fn set_fees() {
     let emitter = Keypair::new();
     let nonce = rand::thread_rng().gen();
     let message = [0u8; 32].to_vec();
-    assert!(
-        common::post_message(client, program, payer, &emitter, None, nonce, message.clone(), 50)
-            .await
-            .is_err()
-    );
+    assert!(common::post_message(
+        client,
+        program,
+        payer,
+        &emitter,
+        None,
+        nonce,
+        message.clone(),
+        50
+    )
+    .await
+    .is_err());
     common::sync(client, payer).await;
 
     assert_eq!(
@@ -1017,7 +1042,10 @@ async fn set_fees() {
     assert_eq!(posted_message.message.nonce, nonce);
     assert_eq!(posted_message.message.sequence, sequence);
     assert_eq!(posted_message.message.emitter_chain, 1);
-    assert_eq!(&posted_message.message.emitter_address, emitter.pubkey().as_ref());
+    assert_eq!(
+        &posted_message.message.emitter_address,
+        emitter.pubkey().as_ref()
+    );
     assert_eq!(posted_message.message.payload, message);
     assert_eq!(
         posted_message.message.emitter_address,
@@ -1143,10 +1171,18 @@ async fn free_fees() {
     let sequence = context.seq.next(emitter.pubkey().to_bytes());
     let nonce = rand::thread_rng().gen();
     let message = [0u8; 32].to_vec();
-    let _message_key =
-        common::post_message(client, program, payer, &emitter, None, nonce, message.clone(), 0)
-            .await
-            .unwrap();
+    let _message_key = common::post_message(
+        client,
+        program,
+        payer,
+        &emitter,
+        None,
+        nonce,
+        message.clone(),
+        0,
+    )
+    .await
+    .unwrap();
 
     let (vaa, body, _body_hash) =
         common::generate_vaa(&emitter, message.clone(), nonce, sequence, 0, 1);
@@ -1186,7 +1222,10 @@ async fn free_fees() {
     assert_eq!(posted_message.message.nonce, nonce);
     assert_eq!(posted_message.message.sequence, sequence);
     assert_eq!(posted_message.message.emitter_chain, 1);
-    assert_eq!(&posted_message.message.emitter_address, emitter.pubkey().as_ref());
+    assert_eq!(
+        &posted_message.message.emitter_address,
+        emitter.pubkey().as_ref()
+    );
     assert_eq!(posted_message.message.payload, message);
     assert_eq!(
         posted_message.message.emitter_address,

solana/bridge/program_stub/src/lib.rs

@@ -1,4 +1,3 @@
-
 #![feature(adt_const_params)]
 #![allow(non_upper_case_globals)]
 #![allow(incomplete_features)]

solana/migration/src/lib.rs

@@ -1,5 +1,4 @@
 #![allow(incomplete_features)]
-
 #![feature(adt_const_params)]
 
 use api::{

solana/modules/nft_bridge/program/src/lib.rs

@@ -1,4 +1,3 @@
-
 #![feature(adt_const_params)]
 #![allow(incomplete_features)]
 #![deny(unused_must_use)]

solana/modules/nft_bridge/program/tests/common.rs

@@ -1,6 +1,4 @@
-use borsh::{
-    BorshDeserialize,
-};
+use borsh::BorshDeserialize;
 use byteorder::{
     BigEndian,
     WriteBytesExt,

solana/modules/token_bridge/program/src/messages.rs

@@ -377,7 +377,7 @@ mod tests {
         PayloadAssetMeta,
         PayloadGovernanceRegisterChain,
         PayloadTransfer,
-        PayloadTransferWithPayload
+        PayloadTransferWithPayload,
     };
     use bridge::{
         DeserializePayload,
@@ -465,7 +465,7 @@ mod tests {
         let mut to = [0u8; 32];
         rand::thread_rng().fill_bytes(&mut to);
         let payload = vec![0u8; 10];
-        
+
         let transfer_original = PayloadTransferWithPayload {
             amount: U256::from(1003),
             token_address,
@@ -473,14 +473,12 @@ mod tests {
             to,
             to_chain: 1,
             from_address,
-            payload
+            payload,
         };
-        
+
         let data = transfer_original.try_to_vec().unwrap();
-        let transfer_deser = PayloadTransferWithPayload::deserialize(
-            &mut data.as_slice()
-        ).unwrap();
-        
+        let transfer_deser = PayloadTransferWithPayload::deserialize(&mut data.as_slice()).unwrap();
+
         assert_eq!(transfer_original, transfer_deser);
     }
 }

solana/modules/token_bridge/program/tests/common.rs

@@ -1,6 +1,4 @@
-use borsh::{
-    BorshDeserialize,
-};
+use borsh::BorshDeserialize;
 use byteorder::{
     BigEndian,
     WriteBytesExt,
@@ -11,17 +9,15 @@ use libsecp256k1::{
 };
 use sha3::Digest;
 use solana_program::{
-    instruction::{
-        Instruction,
-    },
+    instruction::Instruction,
     program_pack::Pack,
     pubkey::Pubkey,
     system_instruction,
 };
 use solana_program_test::{
     BanksClient,
-    ProgramTest,
     BanksClientError,
+    ProgramTest,
 };
 use solana_sdk::{
     commitment_config::CommitmentLevel,
@@ -48,9 +44,7 @@ use token_bridge::{
     types::*,
 };
 
-use solitaire::{
-    processors::seeded::Seeded,
-};
+use solitaire::processors::seeded::Seeded;
 
 pub use helpers::*;
 
@@ -73,17 +67,15 @@ pub async fn execute<T: Signers>(
 mod helpers {
     use super::*;
     use bridge::{
-        accounts::{
-            FeeCollector,
-        },
+        accounts::FeeCollector,
         types::ConsistencyLevel,
         PostVAAData,
     };
     use solana_program_test::processor;
     use token_bridge::{
         CompleteNativeData,
-        CompleteWrappedData,
         CompleteNativeWithPayloadData,
+        CompleteWrappedData,
         CreateWrappedData,
         RegisterChainData,
         TransferNativeData,
@@ -94,13 +86,12 @@ mod helpers {
         PayloadAssetMeta,
         PayloadGovernanceRegisterChain,
         PayloadTransfer,
-        PayloadTransferWithPayload
+        PayloadTransferWithPayload,
     };
 
     /// Generate `count` secp256k1 private keys, along with their ethereum-styled public key
     /// encoding: 0x0123456789ABCDEF01234
     pub fn generate_keys(count: u8) -> (Vec<[u8; 20]>, Vec<SecretKey>) {
-
         let mut rng = rand::thread_rng();
 
         // Generate Guardian Keys
@@ -140,11 +131,7 @@ mod helpers {
         );
 
         let mut builder = ProgramTest::new("bridge", program, processor!(bridge::solitaire));
-        builder.add_program(
-            "spl_token_metadata",
-            spl_token_metadata::id(),
-            None,
-        );
+        builder.add_program("spl_token_metadata", spl_token_metadata::id(), None);
         builder.add_program(
             "token_bridge",
             token_program,
@@ -533,11 +520,11 @@ mod helpers {
             CompleteNativeWithPayloadData {},
         )
         .expect("Could not create Complete Native With Payload instruction");
-        
+
         for account in instruction.accounts.iter().enumerate() {
             println!("{}: {}", account.0, account.1.pubkey);
         }
-        
+
         execute(
             client,
             payer,

solana/modules/token_bridge/program/tests/integration.rs

@@ -40,7 +40,7 @@ use token_bridge::{
         PayloadAssetMeta,
         PayloadGovernanceRegisterChain,
         PayloadTransfer,
-        PayloadTransferWithPayload
+        PayloadTransferWithPayload,
     },
     types::Config,
 };
@@ -559,7 +559,7 @@ async fn transfer_native_with_payload_in() {
         ref guardian_keys,
         ..
     } = context;
-    
+
     // Do an initial transfer so that the bridge account has some native tokens. This also creates
     // the custody account.
     let message = &Keypair::new();
@@ -576,7 +576,7 @@ async fn transfer_native_with_payload_in() {
     )
     .await
     .unwrap();
-    
+
     let nonce = rand::thread_rng().gen();
     let from_address = Keypair::new().pubkey().to_bytes();
     let payload: Vec<u8> = vec![1, 2, 3];
@@ -587,23 +587,23 @@ async fn transfer_native_with_payload_in() {
         to: token_authority.pubkey().to_bytes(),
         to_chain: CHAIN_ID_SOLANA,
         from_address,
-        payload
+        payload,
     };
     let message = payload.try_to_vec().unwrap();
 
     let (vaa, body, _) = common::generate_vaa([0u8; 32], CHAIN_ID_ETH, message, nonce, 1);
     let signature_set = common::verify_signatures(client, &bridge, payer, body, guardian_keys, 0)
-    .await
-    .unwrap();
+        .await
+        .unwrap();
     common::post_vaa(client, bridge, payer, signature_set, vaa.clone())
-    .await
-    .unwrap();
+        .await
+        .unwrap();
     let msg_derivation_data = &PostedVAADerivationData {
         payload_hash: body.to_vec(),
     };
     let message_key =
-    PostedVAA::<'_, { AccountState::MaybeInitialized }>::key(msg_derivation_data, &bridge);
-    
+        PostedVAA::<'_, { AccountState::MaybeInitialized }>::key(msg_derivation_data, &bridge);
+
     common::complete_native_with_payload(
         client,
         token_bridge,

solana/modules/token_bridge/token-metadata/src/utils.rs

@@ -1,12 +1,6 @@
-use crate::state::{
-    Key,
-};
-use borsh::{
-    BorshDeserialize,
-};
-use solana_program::{
-    borsh::try_from_slice_unchecked,
-};
+use crate::state::Key;
+use borsh::BorshDeserialize;
+use solana_program::borsh::try_from_slice_unchecked;
 
 pub fn try_from_slice_checked<T: BorshDeserialize>(
     data: &[u8],

solana/solitaire/program/src/processors/seeded.rs

@@ -10,9 +10,7 @@ use crate::{
     Result,
     SolitaireError,
 };
-use borsh::{
-    BorshSerialize,
-};
+use borsh::BorshSerialize;
 use solana_program::{
     entrypoint::ProgramResult,
     instruction::Instruction,

solana/solitaire/program/src/types/layers.rs

@@ -5,11 +5,9 @@
 //! the transparent repr layout. When each layer is removed the data can be transmuted safely to
 //! the layer below, allowing for optimized recursion.
 
-use std::{
-    ops::{
-        Deref,
-        DerefMut,
-    },
+use std::ops::{
+    Deref,
+    DerefMut,
 };
 
 #[repr(transparent)]