chore: scarb fmt

Author: Darlington02

src/accountV3/accountV3.cairo

@@ -7,18 +7,20 @@ pub mod AccountV3 {
     // *************************************************************************
     //                             IMPORTS
     // *************************************************************************
-    use starknet::{ContractAddress, get_caller_address, get_tx_info, ClassHash, account::Call};
     use openzeppelin_introspection::src5::SRC5Component;
-
+    use starknet::account::Call;
+    use starknet::{ClassHash, ContractAddress, get_caller_address, get_tx_info};
     use token_bound_accounts::components::account::account::AccountComponent;
-    use token_bound_accounts::components::upgradeable::upgradeable::UpgradeableComponent;
     use token_bound_accounts::components::lockable::lockable::LockableComponent;
-    use token_bound_accounts::components::signatory::signatory::SignatoryComponent;
     use token_bound_accounts::components::permissionable::permissionable::PermissionableComponent;
-    use token_bound_accounts::interfaces::{
-        IUpgradeable::IUpgradeable, IExecutable::IExecutable, ILockable::ILockable,
-        ISignatory::ISignatory, IPermissionable::IPermissionable, IAccountV3::IAccountV3
-    };
+    use token_bound_accounts::components::signatory::signatory::SignatoryComponent;
+    use token_bound_accounts::components::upgradeable::upgradeable::UpgradeableComponent;
+    use token_bound_accounts::interfaces::IAccountV3::IAccountV3;
+    use token_bound_accounts::interfaces::IExecutable::IExecutable;
+    use token_bound_accounts::interfaces::ILockable::ILockable;
+    use token_bound_accounts::interfaces::IPermissionable::IPermissionable;
+    use token_bound_accounts::interfaces::ISignatory::ISignatory;
+    use token_bound_accounts::interfaces::IUpgradeable::IUpgradeable;
 
     // *************************************************************************
     //                             COMPONENTS
@@ -57,7 +59,7 @@ pub mod AccountV3 {
         #[substorage(v0)]
         permissionable: PermissionableComponent::Storage,
         #[substorage(v0)]
-        src5: SRC5Component::Storage
+        src5: SRC5Component::Storage,
     }
 
     // *************************************************************************
@@ -77,7 +79,7 @@ pub mod AccountV3 {
         #[flat]
         PermissionableEvent: PermissionableComponent::Event,
         #[flat]
-        SRC5Event: SRC5Component::Event
+        SRC5Event: SRC5Component::Event,
     }
 
     // *************************************************************************
@@ -98,7 +100,7 @@ pub mod AccountV3 {
         token_id: u256,
         registry: ContractAddress,
         implementation_hash: felt252,
-        salt: felt252
+        salt: felt252,
     ) {
         self.account.initializer(token_contract, token_id, registry, implementation_hash, salt);
     }
@@ -119,7 +121,7 @@ pub mod AccountV3 {
             operator: ContractAddress,
             from: ContractAddress,
             token_id: u256,
-            data: Span<felt252>
+            data: Span<felt252>,
         ) -> felt252 {
             let (_token_contract, _token_id, _chain_id) = self.account.token();
             let tx_info = get_tx_info().unbox();
@@ -144,7 +146,7 @@ pub mod AccountV3 {
             operator: ContractAddress,
             from: ContractAddress,
             token_id: u256,
-            data: Span<felt252>
+            data: Span<felt252>,
         ) -> felt252 {
             self.on_erc721_received(operator, from, token_id, data)
         }
@@ -171,7 +173,7 @@ pub mod AccountV3 {
         /// @param hash The message hash
         /// @param signature The signature to be validated
         fn is_valid_signature(
-            self: @ContractState, hash: felt252, signature: Span<felt252>
+            self: @ContractState, hash: felt252, signature: Span<felt252>,
         ) -> felt252 {
             self.signatory._is_valid_signature(hash, signature)
         }
@@ -253,7 +255,7 @@ pub mod AccountV3 {
         fn set_permission(
             ref self: ContractState,
             permissioned_addresses: Array<ContractAddress>,
-            permissions: Array<bool>
+            permissions: Array<bool>,
         ) {
             // set permissions
             self.permissionable._set_permission(permissioned_addresses, permissions)
@@ -263,7 +265,7 @@ pub mod AccountV3 {
         // @param owner tokenbound account owner
         // @param permissioned_address address to check permission for
         fn has_permission(
-            self: @ContractState, owner: ContractAddress, permissioned_address: ContractAddress
+            self: @ContractState, owner: ContractAddress, permissioned_address: ContractAddress,
         ) -> bool {
             self.permissionable._has_permission(owner, permissioned_address)
         }

src/components.cairo

@@ -1,6 +1,6 @@
 pub mod account;
 pub mod lockable;
 pub mod permissionable;
-pub mod upgradeable;
 pub mod presets;
 pub mod signatory;
+pub mod upgradeable;

src/components/account/account.cairo

@@ -3,19 +3,18 @@ pub mod AccountComponent {
     // *************************************************************************
     //                              IMPORTS
     // *************************************************************************
-    use starknet::storage::StoragePointerReadAccess;
-    use core::{
-        result::ResultTrait, hash::HashStateTrait, pedersen::PedersenTrait, num::traits::zero::Zero
-    };
-    use starknet::{
-        get_tx_info, get_contract_address, ContractAddress, account::Call,
-        syscalls::call_contract_syscall, storage::StoragePointerWriteAccess
-    };
-    use token_bound_accounts::utils::array_ext::ArrayExt;
-    use token_bound_accounts::interfaces::IAccount::{IAccount, TBA_INTERFACE_ID};
-
+    use core::hash::HashStateTrait;
+    use core::num::traits::zero::Zero;
+    use core::pedersen::PedersenTrait;
+    use core::result::ResultTrait;
     use openzeppelin_introspection::src5::SRC5Component;
-    use openzeppelin_introspection::src5::SRC5Component::{SRC5Impl, InternalImpl};
+    use openzeppelin_introspection::src5::SRC5Component::{InternalImpl, SRC5Impl};
+    use starknet::account::Call;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starknet::syscalls::call_contract_syscall;
+    use starknet::{ContractAddress, get_contract_address, get_tx_info};
+    use token_bound_accounts::interfaces::IAccount::{IAccount, TBA_INTERFACE_ID};
+    use token_bound_accounts::utils::array_ext::ArrayExt;
 
     // *************************************************************************
     //                              STORAGE
@@ -25,7 +24,7 @@ pub mod AccountComponent {
         account_token_contract: ContractAddress, // contract address of NFT
         account_token_id: u256, // token ID of NFT
         context: Context, // account deployment details
-        state: u256, // account state
+        state: u256 // account state
     }
 
     // *************************************************************************
@@ -35,7 +34,7 @@ pub mod AccountComponent {
     #[derive(Drop, starknet::Event)]
     pub enum Event {
         TBACreated: TBACreated,
-        TransactionExecuted: TransactionExecuted
+        TransactionExecuted: TransactionExecuted,
     }
 
     /// @notice Emitted exactly once when the account is initialized
@@ -46,7 +45,7 @@ pub mod AccountComponent {
         pub account_address: ContractAddress,
         pub parent_account: ContractAddress,
         pub token_contract: ContractAddress,
-        pub token_id: u256
+        pub token_id: u256,
     }
 
     /// @notice Emitted when the account executes a transaction
@@ -58,7 +57,7 @@ pub mod AccountComponent {
         pub hash: felt252,
         #[key]
         pub account_address: ContractAddress,
-        pub response: Span<Span<felt252>>
+        pub response: Span<Span<felt252>>,
     }
 
     // *************************************************************************
@@ -68,7 +67,7 @@ pub mod AccountComponent {
     struct Context {
         registry: ContractAddress,
         implementation_hash: felt252,
-        salt: felt252
+        salt: felt252,
     }
 
     // *************************************************************************
@@ -88,7 +87,7 @@ pub mod AccountComponent {
         TContractState,
         +HasComponent<TContractState>,
         +Drop<TContractState>,
-        impl SRC5: SRC5Component::HasComponent<TContractState>
+        impl SRC5: SRC5Component::HasComponent<TContractState>,
     > of IAccount<ComponentState<TContractState>> {
         /// @notice gets the NFT owner
         /// @param token_contract the contract address of the NFT
@@ -112,7 +111,7 @@ pub mod AccountComponent {
         // @notice check that account supports TBA interface
         // @param interface_id interface to be checked against
         fn supports_interface(
-            self: @ComponentState<TContractState>, interface_id: felt252
+            self: @ComponentState<TContractState>, interface_id: felt252,
         ) -> bool {
             get_dep_component!(self, SRC5).supports_interface(interface_id)
         }
@@ -126,7 +125,7 @@ pub mod AccountComponent {
         TContractState,
         +HasComponent<TContractState>,
         +Drop<TContractState>,
-        impl SRC5: SRC5Component::HasComponent<TContractState>
+        impl SRC5: SRC5Component::HasComponent<TContractState>,
     > of AccountPrivateTrait<TContractState> {
         /// @notice initializes the account by setting the initial token contract and token id
         fn initializer(
@@ -135,7 +134,7 @@ pub mod AccountComponent {
             token_id: u256,
             registry: ContractAddress,
             implementation_hash: felt252,
-            salt: felt252
+            salt: felt252,
         ) {
             let owner = self._get_owner(token_contract, token_id);
             assert(owner.is_non_zero(), Errors::UNAUTHORIZED);
@@ -159,16 +158,16 @@ pub mod AccountComponent {
                         account_address: get_contract_address(),
                         parent_account: owner,
                         token_contract,
-                        token_id
-                    }
+                        token_id,
+                    },
                 );
         }
 
         // @notice executes a transaction
         // @notice this should be called within an `execute` method in implementation contracts
         // @param calls an array of transactions to be executed
         fn _execute(
-            ref self: ComponentState<TContractState>, mut calls: Array<Call>
+            ref self: ComponentState<TContractState>, mut calls: Array<Call>,
         ) -> Array<Span<felt252>> {
             // update state
             self._update_state();
@@ -183,7 +182,7 @@ pub mod AccountComponent {
             let response = retdata.span();
             self
                 .emit(
-                    TransactionExecuted { hash, account_address: get_contract_address(), response }
+                    TransactionExecuted { hash, account_address: get_contract_address(), response },
                 );
             retdata
         }
@@ -207,12 +206,12 @@ pub mod AccountComponent {
         // Should work for contracts which implements CamelCase but not snake_case until starknet
         // v0.15.
         fn _get_owner(
-            self: @ComponentState<TContractState>, token_contract: ContractAddress, token_id: u256
+            self: @ComponentState<TContractState>, token_contract: ContractAddress, token_id: u256,
         ) -> ContractAddress {
             let mut calldata: Array<felt252> = ArrayTrait::new();
             Serde::serialize(@token_id, ref calldata);
             let mut res = call_contract_syscall(
-                token_contract, selector!("ownerOf"), calldata.span()
+                token_contract, selector!("ownerOf"), calldata.span(),
             );
             if (res.is_err()) {
                 res = call_contract_syscall(token_contract, selector!("owner_of"), calldata.span());
@@ -237,7 +236,7 @@ pub mod AccountComponent {
             token_id: u256,
             registry: ContractAddress,
             implementation: felt252,
-            salt: felt252
+            salt: felt252,
         ) -> bool {
             let constructor_calldata_hash = PedersenTrait::new(0)
                 .update(token_contract.into())
@@ -274,7 +273,7 @@ pub mod AccountComponent {
         /// @notice internal function for executing transactions
         /// @param calls An array of transactions to be executed
         fn _execute_calls(
-            ref self: ComponentState<TContractState>, mut calls: Array<Call>
+            ref self: ComponentState<TContractState>, mut calls: Array<Call>,
         ) -> Array<Span<felt252>> {
             let mut result: Array<Span<felt252>> = ArrayTrait::new();
             let mut calls = calls;
@@ -292,12 +291,12 @@ pub mod AccountComponent {
                                 let mut data = array!['multicall-failed', index];
                                 data.append_all(err.span());
                                 panic(data);
-                            }
+                            },
                         }
                     },
-                    Option::None(_) => { break (); }
+                    Option::None(_) => { break (); },
                 };
-            };
+            }
             result
         }
     }

src/components/lockable/lockable.cairo

@@ -3,20 +3,18 @@ pub mod LockableComponent {
     // *************************************************************************
     //                              IMPORTS
     // *************************************************************************
-    use starknet::storage::StoragePointerWriteAccess;
-    use starknet::storage::StoragePointerReadAccess;
-    use starknet::{ContractAddress, get_caller_address, get_block_timestamp};
-
+    use openzeppelin_introspection::src5::SRC5Component;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starknet::{ContractAddress, get_block_timestamp, get_caller_address};
     use token_bound_accounts::components::account::account::AccountComponent;
     use token_bound_accounts::components::account::account::AccountComponent::AccountPrivateImpl;
-    use openzeppelin_introspection::src5::SRC5Component;
 
     // *************************************************************************
     //                              STORAGE
     // *************************************************************************
     #[storage]
     pub struct Storage {
-        lock_until: u64
+        lock_until: u64,
     }
 
     // *************************************************************************
@@ -25,7 +23,7 @@ pub mod LockableComponent {
     #[event]
     #[derive(Drop, starknet::Event)]
     pub enum Event {
-        AccountLocked: AccountLocked
+        AccountLocked: AccountLocked,
     }
 
     /// @notice Emitted when the account is locked
@@ -66,15 +64,15 @@ pub mod LockableComponent {
         +HasComponent<TContractState>,
         +Drop<TContractState>,
         impl Account: AccountComponent::HasComponent<TContractState>,
-        impl SRC5: SRC5Component::HasComponent<TContractState>
+        impl SRC5: SRC5Component::HasComponent<TContractState>,
     > of LockablePrivateTrait<TContractState> {
         // @notice locks an account
         // @param lock_until time at which this account will no longer be locked
         fn _lock(ref self: ComponentState<TContractState>, lock_until: u64) {
             let current_timestamp = get_block_timestamp();
             // check that lock_until is not set in the past and is not greater than 1 year
             assert(
-                lock_until <= current_timestamp + YEAR_TO_SECONDS, Errors::EXCEEDS_MAX_LOCK_TIME
+                lock_until <= current_timestamp + YEAR_TO_SECONDS, Errors::EXCEEDS_MAX_LOCK_TIME,
             );
             assert(lock_until > current_timestamp, Errors::INVALID_LOCK_TIME);
 
@@ -91,8 +89,8 @@ pub mod LockableComponent {
                     AccountLocked {
                         account: get_caller_address(),
                         locked_at: current_timestamp,
-                        lock_until: lock_until
-                    }
+                        lock_until: lock_until,
+                    },
                 );
         }