:rotating_light: Fixing linter warnings

crates/bolt-lang/attribute/system/src/lib.rs

@@ -190,7 +190,6 @@ impl SystemTransform {
         }).unwrap());
     }
 
-
     fn add_set_data_function(content: &mut Vec<syn::Item>) {
         let set_data = bolt_utils::instructions::generate_set_data();
         content.push(syn::parse2(set_data.function).unwrap());

crates/bolt-lang/src/account.rs

@@ -9,7 +9,9 @@ impl<T: Discriminator, const P0: u128, const P1: u128> Discriminator for BoltAcc
     const DISCRIMINATOR: &'static [u8] = T::DISCRIMINATOR;
 }
 
-impl<T: anchor_lang::AccountDeserialize, const P0: u128, const P1: u128> anchor_lang::AccountDeserialize for BoltAccount<T, P0, P1> {
+impl<T: anchor_lang::AccountDeserialize, const P0: u128, const P1: u128>
+    anchor_lang::AccountDeserialize for BoltAccount<T, P0, P1>
+{
     fn try_deserialize(data: &mut &[u8]) -> Result<Self> {
         Ok(BoltAccount(T::try_deserialize(data)?))
     }
@@ -19,32 +21,47 @@ impl<T: anchor_lang::AccountDeserialize, const P0: u128, const P1: u128> anchor_
     }
 }
 
-impl<T: anchor_lang::AccountSerialize, const P0: u128, const P1: u128> anchor_lang::AccountSerialize for BoltAccount<T, P0, P1> {
+impl<T: anchor_lang::AccountSerialize, const P0: u128, const P1: u128> anchor_lang::AccountSerialize
+    for BoltAccount<T, P0, P1>
+{
     fn try_serialize<W: std::io::Write>(&self, writer: &mut W) -> Result<()> {
         self.0.try_serialize(writer)
     }
 }
 
-impl<T: anchor_lang::Owner, const P0: u128, const P1: u128> anchor_lang::Owner for BoltAccount<T, P0, P1> {
+impl<T: anchor_lang::Owner, const P0: u128, const P1: u128> anchor_lang::Owner
+    for BoltAccount<T, P0, P1>
+{
     fn owner() -> Pubkey {
         pubkey_from_array([P0, P1])
     }
 }
 
-impl<'info, T: anchor_lang::ToAccountInfos<'info>, const P0: u128, const P1: u128> anchor_lang::ToAccountInfos<'info> for BoltAccount<T, P0, P1> {
+impl<'info, T: anchor_lang::ToAccountInfos<'info>, const P0: u128, const P1: u128>
+    anchor_lang::ToAccountInfos<'info> for BoltAccount<T, P0, P1>
+{
     fn to_account_infos(&self) -> Vec<AccountInfo<'info>> {
         self.0.to_account_infos()
     }
 }
 
-impl<'info, T: anchor_lang::ToAccountMetas, const P0: u128, const P1: u128> anchor_lang::ToAccountMetas for BoltAccount<T, P0, P1> {
+impl<T: anchor_lang::ToAccountMetas, const P0: u128, const P1: u128> anchor_lang::ToAccountMetas
+    for BoltAccount<T, P0, P1>
+{
     fn to_account_metas(&self, is_signer: Option<bool>) -> Vec<AccountMeta> {
         self.0.to_account_metas(is_signer)
     }
 }
 
-impl<'info, T: anchor_lang::ToAccountInfos<'info> + anchor_lang::ToAccountInfo<'info> + anchor_lang::AccountSerialize + anchor_lang::AccountsExit<'info>, const P0: u128, const P1: u128> anchor_lang::AccountsExit<'info>
-    for BoltAccount<T, P0, P1>
+impl<
+        'info,
+        T: anchor_lang::ToAccountInfos<'info>
+            + anchor_lang::ToAccountInfo<'info>
+            + anchor_lang::AccountSerialize
+            + anchor_lang::AccountsExit<'info>,
+        const P0: u128,
+        const P1: u128,
+    > anchor_lang::AccountsExit<'info> for BoltAccount<T, P0, P1>
 {
     fn exit(&self, _program_id: &Pubkey) -> Result<()> {
         let info = self.0.to_account_info();
@@ -56,7 +73,6 @@ impl<'info, T: anchor_lang::ToAccountInfos<'info> + anchor_lang::ToAccountInfo<'
     }
 }
 
-
 impl<T, const P0: u128, const P1: u128> std::ops::Deref for BoltAccount<T, P0, P1> {
     type Target = T;
 
@@ -72,11 +88,15 @@ impl<T, const P0: u128, const P1: u128> std::ops::DerefMut for BoltAccount<T, P0
 }
 
 #[cfg(feature = "idl-build")]
-impl<T: anchor_lang::IdlBuild, const P0: u128, const P1: u128> anchor_lang::IdlBuild for BoltAccount<T, P0, P1> {
+impl<T: anchor_lang::IdlBuild, const P0: u128, const P1: u128> anchor_lang::IdlBuild
+    for BoltAccount<T, P0, P1>
+{
     fn create_type() -> Option<anchor_lang::idl::types::IdlTypeDef> {
         T::create_type()
     }
-    fn insert_types(types: &mut std::collections::BTreeMap<String, anchor_lang::idl::types::IdlTypeDef>) {
+    fn insert_types(
+        types: &mut std::collections::BTreeMap<String, anchor_lang::idl::types::IdlTypeDef>,
+    ) {
         T::insert_types(types);
     }
     fn get_full_path() -> String {
@@ -87,20 +107,16 @@ impl<T: anchor_lang::IdlBuild, const P0: u128, const P1: u128> anchor_lang::IdlB
 pub const fn pubkey_p0(key: Pubkey) -> u128 {
     let bytes = key.to_bytes();
     u128::from_le_bytes([
-        bytes[0], bytes[1], bytes[2], bytes[3],
-        bytes[4], bytes[5], bytes[6], bytes[7],
-        bytes[8], bytes[9], bytes[10], bytes[11],
-        bytes[12], bytes[13], bytes[14], bytes[15],
+        bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7], bytes[8],
+        bytes[9], bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15],
     ])
 }
 
 pub const fn pubkey_p1(key: Pubkey) -> u128 {
     let bytes = key.to_bytes();
     u128::from_le_bytes([
-        bytes[16], bytes[17], bytes[18], bytes[19],
-        bytes[20], bytes[21], bytes[22], bytes[23],
-        bytes[24], bytes[25], bytes[26], bytes[27],
-        bytes[28], bytes[29], bytes[30], bytes[31],
+        bytes[16], bytes[17], bytes[18], bytes[19], bytes[20], bytes[21], bytes[22], bytes[23],
+        bytes[24], bytes[25], bytes[26], bytes[27], bytes[28], bytes[29], bytes[30], bytes[31],
     ])
 }
 
@@ -111,5 +127,9 @@ pub const fn pubkey_from_u128s(p0: u128, p1: u128) -> Pubkey {
 pub const fn pubkey_from_array(array: [u128; 2]) -> Pubkey {
     let p0 = array[0].to_le_bytes();
     let p1 = array[1].to_le_bytes();
-    Pubkey::new_from_array([p0[0], p0[1], p0[2], p0[3], p0[4], p0[5], p0[6], p0[7], p0[8], p0[9], p0[10], p0[11], p0[12], p0[13], p0[14], p0[15], p1[0], p1[1], p1[2], p1[3], p1[4], p1[5], p1[6], p1[7], p1[8], p1[9], p1[10], p1[11], p1[12], p1[13], p1[14], p1[15]])
+    Pubkey::new_from_array([
+        p0[0], p0[1], p0[2], p0[3], p0[4], p0[5], p0[6], p0[7], p0[8], p0[9], p0[10], p0[11],
+        p0[12], p0[13], p0[14], p0[15], p1[0], p1[1], p1[2], p1[3], p1[4], p1[5], p1[6], p1[7],
+        p1[8], p1[9], p1[10], p1[11], p1[12], p1[13], p1[14], p1[15],
+    ])
 }

crates/bolt-lang/src/bpf_writer.rs

@@ -1,5 +1,4 @@
 /// Implementation from Anchor.
-
 use solana_program::program_memory::sol_memcpy;
 use std::cmp;
 use std::io::{self, Write};

crates/bolt-lang/src/cpi.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 use crate::BoltError;
 
 #[inline(always)]
-pub fn checker<'info>(cpi_auth: &AccountInfo<'info>) -> Result<()> {
+pub fn checker(cpi_auth: &AccountInfo<'_>) -> Result<()> {
     if !cpi_auth.is_signer || cpi_auth.key != crate::world::World::cpi_auth_address() {
         return Err(BoltError::InvalidCaller.into());
     }

crates/bolt-lang/src/instructions/mod.rs

@@ -2,4 +2,4 @@ mod set_owner;
 pub use set_owner::*;
 
 mod set_data;
-pub use set_data::*;
+pub use set_data::*;

crates/bolt-lang/src/instructions/set_data.rs

@@ -1,7 +1,11 @@
 use crate::prelude::*;
 
 #[inline(always)]
-pub fn set_data<'info>(cpi_auth: AccountInfo<'info>, buffer: AccountInfo<'info>, component: AccountInfo<'info>) -> Result<()> {
+pub fn set_data<'info>(
+    cpi_auth: AccountInfo<'info>,
+    buffer: AccountInfo<'info>,
+    component: AccountInfo<'info>,
+) -> Result<()> {
     crate::cpi::checker(&cpi_auth)?;
     let buffer_data = buffer.try_borrow_data()?;
     component.realloc(buffer_data.len(), false)?;

crates/bolt-lang/src/instructions/set_owner.rs

@@ -1,6 +1,10 @@
 use crate::prelude::*;
 
-pub fn set_owner<'info>(cpi_auth: AccountInfo<'info>, component: AccountInfo<'info>, owner: Pubkey) -> Result<()> {
+pub fn set_owner<'info>(
+    cpi_auth: AccountInfo<'info>,
+    component: AccountInfo<'info>,
+    owner: Pubkey,
+) -> Result<()> {
     crate::cpi::checker(&cpi_auth)?;
     component.realloc(0, false)?;
     component.assign(&owner);

crates/bolt-lang/src/lib.rs

@@ -8,14 +8,14 @@ pub use anchor_lang::{
     AccountDeserialize, AccountSerialize, AnchorDeserialize, AnchorSerialize, Bumps, Result,
 };
 
-pub mod instructions;
 pub mod bpf_writer;
+pub mod instructions;
 pub use instructions::*;
 
-pub mod cpi;
 pub mod account;
-pub use session_keys;
+pub mod cpi;
 pub use account::BoltAccount;
+pub use session_keys;
 
 pub use bolt_attribute_bolt_arguments::arguments;
 pub use bolt_attribute_bolt_component::component;

crates/bolt-lang/utils/src/instructions/mod.rs

@@ -8,5 +8,5 @@ use proc_macro2::TokenStream;
 
 pub struct InstructionGeneration {
     pub function: TokenStream,
-    pub accounts: TokenStream
-}
+    pub accounts: TokenStream,
+}

crates/bolt-lang/utils/src/instructions/set_data.rs

@@ -1,5 +1,5 @@
-use quote::quote;
 use crate::instructions::InstructionGeneration;
+use quote::quote;
 
 pub fn generate_set_data() -> InstructionGeneration {
     InstructionGeneration {
@@ -22,6 +22,6 @@ pub fn generate_set_data() -> InstructionGeneration {
                 #[account(mut)]
                 pub component: UncheckedAccount<'info>,
             }
-        }
+        },
     }
-}
+}

crates/bolt-lang/utils/src/instructions/set_owner.rs

@@ -1,5 +1,5 @@
-use quote::quote;
 use crate::instructions::InstructionGeneration;
+use quote::quote;
 
 /// Generate the set owner function and struct.
 pub fn generate_set_owner() -> InstructionGeneration {

crates/bolt-lang/utils/src/lib.rs

@@ -1,2 +1,2 @@
+pub mod instructions;
 pub mod metadata;
-pub mod instructions;

crates/programs/bolt-system/src/lib.rs

@@ -44,4 +44,4 @@ pub struct SetOwner<'info> {
     /// CHECK: This is a component account.
     #[account(mut)]
     pub component: UncheckedAccount<'info>,
-}
+}

crates/programs/world/src/lib.rs

@@ -3,7 +3,8 @@ use anchor_lang::{prelude::*, system_program};
 use error::WorldError;
 use std::collections::BTreeSet;
 
-static CPI_AUTH_ADDRESS: Pubkey = Pubkey::from_str_const("B2f2y3QTBv346wE6nWKor72AUhUvFF6mPk7TWCF2QVhi");
+static CPI_AUTH_ADDRESS: Pubkey =
+    Pubkey::from_str_const("B2f2y3QTBv346wE6nWKor72AUhUvFF6mPk7TWCF2QVhi");
 
 #[cfg(not(feature = "no-entrypoint"))]
 use solana_security_txt::security_txt;
@@ -376,7 +377,7 @@ pub mod world {
     }
 }
 
-#[allow(clippy::type_complexity)]
+#[allow(clippy::type_complexity, clippy::too_many_arguments)]
 fn apply_impl<'info>(
     buffer: &AccountInfo<'info>,
     buffer_bump: u8,
@@ -422,25 +423,39 @@ fn apply_impl<'info>(
         // BoltMetadata.authority is the last 32 bytes of the serialized component
         let start = 8; // Skip the discriminator
         let mut key_bytes = [0u8; 32];
-        key_bytes.copy_from_slice(&data_ref[start..start+32]);
+        key_bytes.copy_from_slice(&data_ref[start..start + 32]);
         let component_authority = Pubkey::new_from_array(key_bytes);
 
         let unix_timestamp = Clock::get()?.unix_timestamp;
         if let Some(session_token) = session_token {
             if component_authority == ID {
-                require!(unix_timestamp < session_token.valid_until, session_keys::SessionError::InvalidToken);
+                require!(
+                    unix_timestamp < session_token.valid_until,
+                    session_keys::SessionError::InvalidToken
+                );
             } else {
                 let validity_ctx = session_keys::ValidityChecker {
                     session_token: session_token.clone(),
                     session_signer: authority.clone(),
-                    authority: component_authority.clone(),
+                    authority: component_authority,
                     target_program: ID,
                 };
-                require!(session_token.validate(validity_ctx)?, session_keys::SessionError::InvalidToken);
-                require_eq!(component_authority, session_token.authority, session_keys::SessionError::InvalidToken);
+                require!(
+                    session_token.validate(validity_ctx)?,
+                    session_keys::SessionError::InvalidToken
+                );
+                require_eq!(
+                    component_authority,
+                    session_token.authority,
+                    session_keys::SessionError::InvalidToken
+                );
             }
         } else {
-            require!(component_authority == ID || (component_authority == *authority.key && authority.is_signer), WorldError::InvalidAuthority);
+            require!(
+                component_authority == ID
+                    || (component_authority == *authority.key && authority.is_signer),
+                WorldError::InvalidAuthority
+            );
         }
     }
 
@@ -491,17 +506,15 @@ fn apply_impl<'info>(
             *bolt_system.key,
         )?;
 
-        bolt_system::cpi::set_data(
-            CpiContext::new_with_signer(
-                bolt_system.to_account_info(),
-                bolt_system::cpi::accounts::SetData {
-                    cpi_auth: cpi_auth.to_account_info(),
-                    buffer: buffer.to_account_info(),
-                    component: component.to_account_info(),
-                },
-                &[World::cpi_auth_seeds().as_slice()],
-            ),
-        )?;
+        bolt_system::cpi::set_data(CpiContext::new_with_signer(
+            bolt_system.to_account_info(),
+            bolt_system::cpi::accounts::SetData {
+                cpi_auth: cpi_auth.to_account_info(),
+                buffer: buffer.to_account_info(),
+                component: component.to_account_info(),
+            },
+            &[World::cpi_auth_seeds().as_slice()],
+        ))?;
     }
 
     bolt_system::cpi::bolt_execute(
@@ -515,7 +528,7 @@ fn apply_impl<'info>(
             let mut data = buffer.try_borrow_mut_data()?;
             data.copy_from_slice(component.try_borrow_data()?.as_ref());
         }
-        
+
         bolt_system::cpi::set_owner(
             CpiContext::new_with_signer(
                 bolt_system.to_account_info(),
@@ -527,22 +540,20 @@ fn apply_impl<'info>(
             ),
             program.key(),
         )?;
-        
+
         if *component.owner != program.key() {
             return Err(WorldError::InvalidComponentOwner.into());
         }
 
-        bolt_component::cpi::set_data(
-            CpiContext::new_with_signer(
-                program.to_account_info(),
-                bolt_component::cpi::accounts::SetData {
-                    cpi_auth: cpi_auth.to_account_info(),
-                    buffer: buffer.to_account_info(),
-                    component: component.to_account_info(),
-                },
-                &[World::cpi_auth_seeds().as_slice()],
-            ),
-        )?;
+        bolt_component::cpi::set_data(CpiContext::new_with_signer(
+            program.to_account_info(),
+            bolt_component::cpi::accounts::SetData {
+                cpi_auth: cpi_auth.to_account_info(),
+                buffer: buffer.to_account_info(),
+                component: component.to_account_info(),
+            },
+            &[World::cpi_auth_seeds().as_slice()],
+        ))?;
     }
 
     buffer.realloc(0, false)?;