git.delta.rocks / unique-network / refs/commits / 314a48de54b9

--- a/crates/evm-coder/procedural/src/to_log.rs
+++ b/crates/evm-coder/procedural/src/to_log.rs
@@ -231,7 +231,7 @@
 
 			#[automatically_derived]
 			impl ::evm_coder::events::ToLog for #name {
-				fn to_log(&self, contract: address) -> ::ethereum::Log {
+				fn to_log(&self, contract: Address) -> ::ethereum::Log {
 					use ::evm_coder::events::ToTopic;
 					use ::evm_coder::abi::AbiWrite;
 					let mut writer = ::evm_coder::abi::AbiWriter::new();

--- a/crates/evm-coder/src/abi/test.rs
+++ b/crates/evm-coder/src/abi/test.rs
@@ -101,7 +101,7 @@
 
 #[test]
 fn encode_decode_vec_tuple_address_uint256() {
-	test_impl::<Vec<(address, U256)>>(
+	test_impl::<Vec<(Address, U256)>>(
         0x1ACF2D55,
         vec![
             (

--- a/crates/evm-coder/src/events.rs
+++ b/crates/evm-coder/src/events.rs
@@ -53,7 +53,7 @@
 	}
 }
 
-impl ToTopic for address {
+impl ToTopic for Address {
 	fn to_topic(&self) -> H256 {
 		let mut out = [0u8; 32];
 		out[12..32].copy_from_slice(&self.0);

--- a/crates/evm-coder/src/lib.rs
+++ b/crates/evm-coder/src/lib.rs
@@ -131,7 +131,7 @@
 	use alloc::{vec::Vec};
 	use primitive_types::{U256, H160, H256};
 
-	pub type address = H160;
+	pub type Address = H160;
 	pub type bytes4 = [u8; 4];
 	pub type topic = H256;
 
@@ -147,7 +147,7 @@
 	/// Makes function payable
 	pub type value = U256;
 	/// Makes function caller-sensitive
-	pub type caller = address;
+	pub type caller = Address;
 	//#endregion
 
 	/// Ethereum typed call message, similar to solidity

--- a/crates/evm-coder/tests/log.rs
+++ b/crates/evm-coder/tests/log.rs
@@ -23,14 +23,14 @@
 enum ERC721Log {
 	Transfer {
 		#[indexed]
-		from: address,
+		from: Address,
 		#[indexed]
-		to: address,
+		to: Address,
 		value: U256,
 	},
 	Eee {
 		#[indexed]
-		aaa: address,
+		aaa: Address,
 		bbb: U256,
 	},
 }

--- a/crates/evm-coder/tests/solidity_generation.rs
+++ b/crates/evm-coder/tests/solidity_generation.rs
@@ -25,25 +25,25 @@
 		unreachable!()
 	}
 	/// Get balance of specified owner
-	fn balance_of(&self, _owner: address) -> Result<U256> {
+	fn balance_of(&self, _owner: Address) -> Result<U256> {
 		unreachable!()
 	}
-	fn transfer(&mut self, _caller: caller, _to: address, _value: U256) -> Result<bool> {
+	fn transfer(&mut self, _caller: caller, _to: Address, _value: U256) -> Result<bool> {
 		unreachable!()
 	}
 	fn transfer_from(
 		&mut self,
 		_caller: caller,
-		_from: address,
-		_to: address,
+		_from: Address,
+		_to: Address,
 		_value: U256,
 	) -> Result<bool> {
 		unreachable!()
 	}
-	fn approve(&mut self, _caller: caller, _spender: address, _value: U256) -> Result<bool> {
+	fn approve(&mut self, _caller: caller, _spender: Address, _value: U256) -> Result<bool> {
 		unreachable!()
 	}
-	fn allowance(&self, _owner: address, _spender: address) -> Result<U256> {
+	fn allowance(&self, _owner: Address, _spender: Address) -> Result<U256> {
 		unreachable!()
 	}
 }

--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -43,30 +43,30 @@
 	CollectionCreated {
 		/// Collection owner.
 		#[indexed]
-		owner: address,
+		owner: Address,
 
 		/// Collection ID.
 		#[indexed]
-		collection_id: address,
+		collection_id: Address,
 	},
 	/// The collection has been destroyed.
 	CollectionDestroyed {
 		/// Collection ID.
 		#[indexed]
-		collection_id: address,
+		collection_id: Address,
 	},
 	/// The collection has been changed.
 	CollectionChanged {
 		/// Collection ID.
 		#[indexed]
-		collection_id: address,
+		collection_id: Address,
 	},
 
 	/// The token has been changed.
 	TokenChanged {
 		/// Collection ID.
 		#[indexed]
-		collection_id: address,
+		collection_id: Address,
 		/// Token ID.
 		token_id: U256,
 	},
@@ -208,7 +208,7 @@
 	///
 	/// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.
 	#[solidity(hide)]
-	fn set_collection_sponsor(&mut self, caller: caller, sponsor: address) -> Result<()> {
+	fn set_collection_sponsor(&mut self, caller: caller, sponsor: Address) -> Result<()> {
 		self.consume_store_reads_and_writes(1, 1)?;
 
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -351,7 +351,7 @@
 	}
 
 	/// Get contract address.
-	fn contract_address(&self) -> Result<address> {
+	fn contract_address(&self) -> Result<Address> {
 		Ok(crate::eth::collection_id_to_address(self.id))
 	}
 
@@ -388,7 +388,7 @@
 	/// Add collection admin.
 	/// @param newAdmin Address of the added administrator.
 	#[solidity(hide)]
-	fn add_collection_admin(&mut self, caller: caller, new_admin: address) -> Result<()> {
+	fn add_collection_admin(&mut self, caller: caller, new_admin: Address) -> Result<()> {
 		self.consume_store_reads_and_writes(2, 2)?;
 
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -401,7 +401,7 @@
 	///
 	/// @param admin Address of the removed administrator.
 	#[solidity(hide)]
-	fn remove_collection_admin(&mut self, caller: caller, admin: address) -> Result<()> {
+	fn remove_collection_admin(&mut self, caller: caller, admin: Address) -> Result<()> {
 		self.consume_store_reads_and_writes(2, 2)?;
 
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -437,7 +437,7 @@
 		&mut self,
 		caller: caller,
 		enable: bool,
-		collections: Vec<address>,
+		collections: Vec<Address>,
 	) -> Result<()> {
 		self.consume_store_reads_and_writes(1, 1)?;
 
@@ -526,7 +526,7 @@
 	///
 	/// @param user Address of a trusted user.
 	#[solidity(hide)]
-	fn add_to_collection_allow_list(&mut self, caller: caller, user: address) -> Result<()> {
+	fn add_to_collection_allow_list(&mut self, caller: caller, user: Address) -> Result<()> {
 		self.consume_store_writes(1)?;
 
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -555,7 +555,7 @@
 	///
 	/// @param user Address of a removed user.
 	#[solidity(hide)]
-	fn remove_from_collection_allow_list(&mut self, caller: caller, user: address) -> Result<()> {
+	fn remove_from_collection_allow_list(&mut self, caller: caller, user: Address) -> Result<()> {
 		self.consume_store_writes(1)?;
 
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -599,7 +599,7 @@
 	/// @param user account to verify
 	/// @return "true" if account is the owner or admin
 	#[solidity(hide, rename_selector = "isOwnerOrAdmin")]
-	fn is_owner_or_admin_eth(&self, user: address) -> Result<bool> {
+	fn is_owner_or_admin_eth(&self, user: Address) -> Result<bool> {
 		let user = T::CrossAccountId::from_eth(user);
 		Ok(self.is_owner_or_admin(&user))
 	}
@@ -640,7 +640,7 @@
 	/// @dev Owner can be changed only by current owner
 	/// @param newOwner new owner account
 	#[solidity(hide, rename_selector = "changeCollectionOwner")]
-	fn set_owner(&mut self, caller: caller, new_owner: address) -> Result<()> {
+	fn set_owner(&mut self, caller: caller, new_owner: Address) -> Result<()> {
 		self.consume_store_writes(1)?;
 
 		let caller = T::CrossAccountId::from_eth(caller);

--- a/pallets/common/src/eth.rs
+++ b/pallets/common/src/eth.rs
@@ -18,7 +18,7 @@
 
 use alloc::format;
 use sp_std::{vec, vec::Vec};
-use evm_coder::{AbiCoder, types::address};
+use evm_coder::{AbiCoder, types::Address};
 pub use pallet_evm::{Config, account::CrossAccountId};
 use sp_core::{H160, U256};
 use up_data_structs::CollectionId;
@@ -30,7 +30,7 @@
 ];
 
 /// Maps the ethereum address of the collection in substrate.
-pub fn map_eth_to_id(eth: &H160) -> Option<CollectionId> {
+pub fn map_eth_to_id(eth: &Address) -> Option<CollectionId> {
 	if eth[0..16] != ETH_COLLECTION_PREFIX {
 		return None;
 	}
@@ -40,7 +40,7 @@
 }
 
 /// Maps the substrate collection id in ethereum.
-pub fn collection_id_to_address(id: CollectionId) -> H160 {
+pub fn collection_id_to_address(id: CollectionId) -> Address {
 	let mut out = [0; 20];
 	out[0..16].copy_from_slice(&ETH_COLLECTION_PREFIX);
 	out[16..20].copy_from_slice(&u32::to_be_bytes(id.0));
@@ -48,7 +48,7 @@
 }
 
 /// Check if the ethereum address is a collection.
-pub fn is_collection(address: &H160) -> bool {
+pub fn is_collection(address: &Address) -> bool {
 	address[0..16] == ETH_COLLECTION_PREFIX
 }
 
@@ -66,7 +66,7 @@
 /// Cross account struct
 #[derive(Debug, Default, AbiCoder)]
 pub struct CrossAddress {
-	pub(crate) eth: address,
+	pub(crate) eth: Address,
 	pub(crate) sub: U256,
 }
 

49	ContractSponsorSet {49	ContractSponsorSet {
50		/// Contract address of the affected collection.50		/// Contract address of the affected collection.
51		#[indexed]51		#[indexed]
52		contract_address: address,52		contract_address: Address,
53		/// New sponsor address.53		/// New sponsor address.
54		sponsor: address,54		sponsor: Address,
55	},55	},
5656
57	/// New sponsor was confirm.57	/// New sponsor was confirm.
58	ContractSponsorshipConfirmed {58	ContractSponsorshipConfirmed {
59		/// Contract address of the affected collection.59		/// Contract address of the affected collection.
60		#[indexed]60		#[indexed]
61		contract_address: address,61		contract_address: Address,
62		/// New sponsor address.62		/// New sponsor address.
63		sponsor: address,63		sponsor: Address,
64	},64	},
6565
66	/// Collection sponsor was removed.66	/// Collection sponsor was removed.
67	ContractSponsorRemoved {67	ContractSponsorRemoved {
68		/// Contract address of the affected collection.68		/// Contract address of the affected collection.
69		#[indexed]69		#[indexed]
70		contract_address: address,70		contract_address: Address,
71	},71	},
72}72}
7373
96	/// @dev Returns zero address if contract does not exists96	/// @dev Returns zero address if contract does not exists
97	/// @param contractAddress Contract to get owner of97	/// @param contractAddress Contract to get owner of
98	/// @return address Owner of contract98	/// @return address Owner of contract
99	fn contract_owner(&self, contract_address: address) -> Result<address> {99	fn contract_owner(&self, contract_address: Address) -> Result<Address> {
100		Ok(<Owner<T>>::get(contract_address))100		Ok(<Owner<T>>::get(contract_address))
101	}101	}
102102
106	fn set_sponsor(106	fn set_sponsor(
107		&mut self,107		&mut self,
108		caller: caller,108		caller: caller,
109		contract_address: address,109		contract_address: Address,
110		sponsor: address,110		sponsor: Address,
111	) -> Result<()> {111	) -> Result<()> {
112		self.recorder().consume_sload()?;112		self.recorder().consume_sload()?;
113		self.recorder().consume_sstore()?;113		self.recorder().consume_sstore()?;
125	/// Set contract as self sponsored.125	/// Set contract as self sponsored.
126	///126	///
127	/// @param contractAddress Contract for which a self sponsoring is being enabled.127	/// @param contractAddress Contract for which a self sponsoring is being enabled.
128	fn self_sponsored_enable(&mut self, caller: caller, contract_address: address) -> Result<()> {128	fn self_sponsored_enable(&mut self, caller: caller, contract_address: Address) -> Result<()> {
129		self.recorder().consume_sload()?;129		self.recorder().consume_sload()?;
130		self.recorder().consume_sstore()?;130		self.recorder().consume_sstore()?;
131131
146	/// Remove sponsor.146	/// Remove sponsor.
147	///147	///
148	/// @param contractAddress Contract for which a sponsorship is being removed.148	/// @param contractAddress Contract for which a sponsorship is being removed.
149	fn remove_sponsor(&mut self, caller: caller, contract_address: address) -> Result<()> {149	fn remove_sponsor(&mut self, caller: caller, contract_address: Address) -> Result<()> {
150		self.recorder().consume_sload()?;150		self.recorder().consume_sload()?;
151		self.recorder().consume_sstore()?;151		self.recorder().consume_sstore()?;
152152
161	/// @dev Caller must be same that set via [`setSponsor`].161	/// @dev Caller must be same that set via [`setSponsor`].
162	///162	///
163	/// @param contractAddress Сontract for which need to confirm sponsorship.163	/// @param contractAddress Сontract for which need to confirm sponsorship.
164	fn confirm_sponsorship(&mut self, caller: caller, contract_address: address) -> Result<()> {164	fn confirm_sponsorship(&mut self, caller: caller, contract_address: Address) -> Result<()> {
165		self.recorder().consume_sload()?;165		self.recorder().consume_sload()?;
166		self.recorder().consume_sstore()?;166		self.recorder().consume_sstore()?;
167167
175	///175	///
176	/// @param contractAddress The contract for which a sponsor is requested.176	/// @param contractAddress The contract for which a sponsor is requested.
177	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.177	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
178	fn sponsor(&self, contract_address: address) -> Result<Option<eth::CrossAddress>> {178	fn sponsor(&self, contract_address: Address) -> Result<Option<eth::CrossAddress>> {
179		Ok(match Pallet::<T>::get_sponsor(contract_address) {179		Ok(match Pallet::<T>::get_sponsor(contract_address) {
180			Some(ref value) => Some(eth::CrossAddress::from_sub_cross_account::<T>(value)),180			Some(ref value) => Some(eth::CrossAddress::from_sub_cross_account::<T>(value)),
181			None => None,181			None => None,
186	///186	///
187	/// @param contractAddress The contract for which the presence of a confirmed sponsor is checked.187	/// @param contractAddress The contract for which the presence of a confirmed sponsor is checked.
188	/// @return **true** if contract has confirmed sponsor.188	/// @return **true** if contract has confirmed sponsor.
189	fn has_sponsor(&self, contract_address: address) -> Result<bool> {189	fn has_sponsor(&self, contract_address: Address) -> Result<bool> {
190		Ok(Pallet::<T>::get_sponsor(contract_address).is_some())190		Ok(Pallet::<T>::get_sponsor(contract_address).is_some())
191	}191	}
192192
193	/// Check tat contract has pending sponsor.193	/// Check tat contract has pending sponsor.
194	///194	///
195	/// @param contractAddress The contract for which the presence of a pending sponsor is checked.195	/// @param contractAddress The contract for which the presence of a pending sponsor is checked.
196	/// @return **true** if contract has pending sponsor.196	/// @return **true** if contract has pending sponsor.
197	fn has_pending_sponsor(&self, contract_address: address) -> Result<bool> {197	fn has_pending_sponsor(&self, contract_address: Address) -> Result<bool> {
198		Ok(match Sponsoring::<T>::get(contract_address) {198		Ok(match Sponsoring::<T>::get(contract_address) {
199			SponsorshipState::Disabled | SponsorshipState::Confirmed(_) => false,199			SponsorshipState::Disabled | SponsorshipState::Confirmed(_) => false,
200			SponsorshipState::Unconfirmed(_) => true,200			SponsorshipState::Unconfirmed(_) => true,
201		})201		})
202	}202	}
203203
204	fn sponsoring_enabled(&self, contract_address: address) -> Result<bool> {204	fn sponsoring_enabled(&self, contract_address: Address) -> Result<bool> {
205		Ok(<Pallet<T>>::sponsoring_mode(contract_address) != SponsoringModeT::Disabled)205		Ok(<Pallet<T>>::sponsoring_mode(contract_address) != SponsoringModeT::Disabled)
206	}206	}
207207
208	fn set_sponsoring_mode(208	fn set_sponsoring_mode(
209		&mut self,209		&mut self,
210		caller: caller,210		caller: caller,
211		contract_address: address,211		contract_address: Address,
212		mode: SponsoringModeT,212		mode: SponsoringModeT,
213	) -> Result<()> {213	) -> Result<()> {
214		self.recorder().consume_sload()?;214		self.recorder().consume_sload()?;
223	/// Get current contract sponsoring rate limit223	/// Get current contract sponsoring rate limit
224	/// @param contractAddress Contract to get sponsoring rate limit of224	/// @param contractAddress Contract to get sponsoring rate limit of
225	/// @return uint32 Amount of blocks between two sponsored transactions225	/// @return uint32 Amount of blocks between two sponsored transactions
226	fn sponsoring_rate_limit(&self, contract_address: address) -> Result<u32> {226	fn sponsoring_rate_limit(&self, contract_address: Address) -> Result<u32> {
227		self.recorder().consume_sload()?;227		self.recorder().consume_sload()?;
228228
229		Ok(<SponsoringRateLimit<T>>::get(contract_address)229		Ok(<SponsoringRateLimit<T>>::get(contract_address)
240	fn set_sponsoring_rate_limit(240	fn set_sponsoring_rate_limit(
241		&mut self,241		&mut self,
242		caller: caller,242		caller: caller,
243		contract_address: address,243		contract_address: Address,
244		rate_limit: u32,244		rate_limit: u32,
245	) -> Result<()> {245	) -> Result<()> {
246		self.recorder().consume_sload()?;246		self.recorder().consume_sload()?;
260	fn set_sponsoring_fee_limit(260	fn set_sponsoring_fee_limit(
261		&mut self,261		&mut self,
262		caller: caller,262		caller: caller,
263		contract_address: address,263		contract_address: Address,
264		fee_limit: U256,264		fee_limit: U256,
265	) -> Result<()> {265	) -> Result<()> {
266		self.recorder().consume_sload()?;266		self.recorder().consume_sload()?;
276	/// @param contractAddress Contract to get sponsoring fee limit of276	/// @param contractAddress Contract to get sponsoring fee limit of
277	/// @return uint256 Maximum amount of fee that could be spent by single277	/// @return uint256 Maximum amount of fee that could be spent by single
278	///  transaction278	///  transaction
279	fn sponsoring_fee_limit(&self, contract_address: address) -> Result<U256> {279	fn sponsoring_fee_limit(&self, contract_address: Address) -> Result<U256> {
280		self.recorder().consume_sload()?;280		self.recorder().consume_sload()?;
281281
282		Ok(get_sponsoring_fee_limit::<T>(contract_address))282		Ok(get_sponsoring_fee_limit::<T>(contract_address))
287	/// @param contractAddress Contract to check allowlist of287	/// @param contractAddress Contract to check allowlist of
288	/// @param user User to check288	/// @param user User to check
289	/// @return bool Is specified users exists in contract allowlist289	/// @return bool Is specified users exists in contract allowlist
290	fn allowed(&self, contract_address: address, user: address) -> Result<bool> {290	fn allowed(&self, contract_address: Address, user: Address) -> Result<bool> {
291		self.0.consume_sload()?;291		self.0.consume_sload()?;
292		Ok(<Pallet<T>>::allowed(contract_address, user))292		Ok(<Pallet<T>>::allowed(contract_address, user))
293	}293	}
301	fn toggle_allowed(301	fn toggle_allowed(
302		&mut self,302		&mut self,
303		caller: caller,303		caller: caller,
304		contract_address: address,304		contract_address: Address,
305		user: address,305		user: Address,
306		is_allowed: bool,306		is_allowed: bool,
307	) -> Result<()> {307	) -> Result<()> {
308		self.recorder().consume_sload()?;308		self.recorder().consume_sload()?;
320	///  in case of allowlist access enabled, only users from allowlist may call this contract320	///  in case of allowlist access enabled, only users from allowlist may call this contract
321	/// @param contractAddress Contract to get allowlist access of321	/// @param contractAddress Contract to get allowlist access of
322	/// @return bool Is specified contract has allowlist access enabled322	/// @return bool Is specified contract has allowlist access enabled
323	fn allowlist_enabled(&self, contract_address: address) -> Result<bool> {323	fn allowlist_enabled(&self, contract_address: Address) -> Result<bool> {
324		Ok(<AllowlistEnabled<T>>::get(contract_address))324		Ok(<AllowlistEnabled<T>>::get(contract_address))
325	}325	}
326326
330	fn toggle_allowlist(330	fn toggle_allowlist(
331		&mut self,331		&mut self,
332		caller: caller,332		caller: caller,
333		contract_address: address,333		contract_address: Address,
334		enabled: bool,334		enabled: bool,
335	) -> Result<()> {335	) -> Result<()> {
336		self.recorder().consume_sload()?;336		self.recorder().consume_sload()?;
441	}441	}
442}442}
443443
444fn get_sponsoring_fee_limit<T: Config>(contract_address: address) -> U256 {444fn get_sponsoring_fee_limit<T: Config>(contract_address: Address) -> U256 {
445	<SponsoringFeeLimit<T>>::get(contract_address)445	<SponsoringFeeLimit<T>>::get(contract_address)
446		.get(&0xffffffff)446		.get(&0xffffffff)
447		.cloned()447		.cloned()

--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -43,16 +43,16 @@
 pub enum ERC20Events {
 	Transfer {
 		#[indexed]
-		from: address,
+		from: Address,
 		#[indexed]
-		to: address,
+		to: Address,
 		value: U256,
 	},
 	Approval {
 		#[indexed]
-		owner: address,
+		owner: Address,
 		#[indexed]
-		spender: address,
+		spender: Address,
 		value: U256,
 	},
 }
@@ -79,14 +79,14 @@
 			unreachable!()
 		})
 	}
-	fn balance_of(&self, owner: address) -> Result<U256> {
+	fn balance_of(&self, owner: Address) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		let owner = T::CrossAccountId::from_eth(owner);
 		let balance = <Balance<T>>::get((self.id, owner));
 		Ok(balance.into())
 	}
 	#[weight(<SelfWeightOf<T>>::transfer())]
-	fn transfer(&mut self, caller: caller, to: address, amount: U256) -> Result<bool> {
+	fn transfer(&mut self, caller: caller, to: Address, amount: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -102,8 +102,8 @@
 	fn transfer_from(
 		&mut self,
 		caller: caller,
-		from: address,
-		to: address,
+		from: Address,
+		to: Address,
 		amount: U256,
 	) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -119,7 +119,7 @@
 		Ok(true)
 	}
 	#[weight(<SelfWeightOf<T>>::approve())]
-	fn approve(&mut self, caller: caller, spender: address, amount: U256) -> Result<bool> {
+	fn approve(&mut self, caller: caller, spender: Address, amount: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let spender = T::CrossAccountId::from_eth(spender);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -128,7 +128,7 @@
 			.map_err(dispatch_to_evm::<T>)?;
 		Ok(true)
 	}
-	fn allowance(&self, owner: address, spender: address) -> Result<U256> {
+	fn allowance(&self, owner: Address, spender: Address) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		let owner = T::CrossAccountId::from_eth(owner);
 		let spender = T::CrossAccountId::from_eth(spender);
@@ -137,7 +137,7 @@
 	}
 
 	/// @notice Returns collection helper contract address
-	fn collection_helper_address(&self) -> Result<address> {
+	fn collection_helper_address(&self) -> Result<Address> {
 		Ok(T::ContractAddress::get())
 	}
 }
@@ -148,7 +148,7 @@
 	/// @param to account that will receive minted tokens
 	/// @param amount amount of tokens to mint
 	#[weight(<SelfWeightOf<T>>::create_item())]
-	fn mint(&mut self, caller: caller, to: address, amount: U256) -> Result<bool> {
+	fn mint(&mut self, caller: caller, to: Address, amount: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -214,7 +214,7 @@
 	/// @param amount The amount that will be burnt.
 	#[solidity(hide)]
 	#[weight(<SelfWeightOf<T>>::burn_from())]
-	fn burn_from(&mut self, caller: caller, from: address, amount: U256) -> Result<bool> {
+	fn burn_from(&mut self, caller: caller, from: Address, amount: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = T::CrossAccountId::from_eth(from);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -254,7 +254,7 @@
 	/// Mint tokens for multiple accounts.
 	/// @param amounts array of pairs of account address and amount
 	#[weight(<SelfWeightOf<T>>::create_multiple_items_ex(amounts.len() as u32))]
-	fn mint_bulk(&mut self, caller: caller, amounts: Vec<(address, U256)>) -> Result<bool> {
+	fn mint_bulk(&mut self, caller: caller, amounts: Vec<(Address, U256)>) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let budget = self
 			.recorder

--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -261,9 +261,9 @@
 	///  any transfer, the approved address for that NFT (if any) is reset to none.
 	Transfer {
 		#[indexed]
-		from: address,
+		from: Address,
 		#[indexed]
-		to: address,
+		to: Address,
 		#[indexed]
 		token_id: U256,
 	},
@@ -273,9 +273,9 @@
 	///  address for that NFT (if any) is reset to none.
 	Approval {
 		#[indexed]
-		owner: address,
+		owner: Address,
 		#[indexed]
-		approved: address,
+		approved: Address,
 		#[indexed]
 		token_id: U256,
 	},
@@ -284,9 +284,9 @@
 	#[allow(dead_code)]
 	ApprovalForAll {
 		#[indexed]
-		owner: address,
+		owner: Address,
 		#[indexed]
-		operator: address,
+		operator: Address,
 		approved: bool,
 	},
 }
@@ -373,7 +373,7 @@
 	}
 
 	/// @dev Not implemented
-	fn token_of_owner_by_index(&self, _owner: address, _index: U256) -> Result<U256> {
+	fn token_of_owner_by_index(&self, _owner: Address, _index: U256) -> Result<U256> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
@@ -396,7 +396,7 @@
 	///  function throws for queries about the zero address.
 	/// @param owner An address for whom to query the balance
 	/// @return The number of NFTs owned by `owner`, possibly zero
-	fn balance_of(&self, owner: address) -> Result<U256> {
+	fn balance_of(&self, owner: Address) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		let owner = T::CrossAccountId::from_eth(owner);
 		let balance = <AccountBalance<T>>::get((self.id, owner));
@@ -407,7 +407,7 @@
 	///  about them do throw.
 	/// @param tokenId The identifier for an NFT
 	/// @return The address of the owner of the NFT
-	fn owner_of(&self, token_id: U256) -> Result<address> {
+	fn owner_of(&self, token_id: U256) -> Result<Address> {
 		self.consume_store_reads(1)?;
 		let token: TokenId = token_id.try_into()?;
 		Ok(*<TokenData<T>>::get((self.id, token))
@@ -419,8 +419,8 @@
 	#[solidity(rename_selector = "safeTransferFrom")]
 	fn safe_transfer_from_with_data(
 		&mut self,
-		_from: address,
-		_to: address,
+		_from: Address,
+		_to: Address,
 		_token_id: U256,
 		_data: bytes,
 	) -> Result<()> {
@@ -428,7 +428,7 @@
 		Err("not implemented".into())
 	}
 	/// @dev Not implemented
-	fn safe_transfer_from(&mut self, _from: address, _to: address, _token_id: U256) -> Result<()> {
+	fn safe_transfer_from(&mut self, _from: Address, _to: Address, _token_id: U256) -> Result<()> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
@@ -446,8 +446,8 @@
 	fn transfer_from(
 		&mut self,
 		caller: caller,
-		from: address,
-		to: address,
+		from: Address,
+		to: Address,
 		token_id: U256,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -470,7 +470,7 @@
 	/// @param approved The new approved NFT controller
 	/// @param tokenId The NFT to approve
 	#[weight(<SelfWeightOf<T>>::approve())]
-	fn approve(&mut self, caller: caller, approved: address, token_id: U256) -> Result<()> {
+	fn approve(&mut self, caller: caller, approved: Address, token_id: U256) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let approved = T::CrossAccountId::from_eth(approved);
 		let token = token_id.try_into()?;
@@ -488,7 +488,7 @@
 	fn set_approval_for_all(
 		&mut self,
 		caller: caller,
-		operator: address,
+		operator: Address,
 		approved: bool,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -500,14 +500,14 @@
 	}
 
 	/// @dev Not implemented
-	fn get_approved(&self, _token_id: U256) -> Result<address> {
+	fn get_approved(&self, _token_id: U256) -> Result<Address> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
 
 	/// @notice Tells whether the given `owner` approves the `operator`.
 	#[weight(<SelfWeightOf<T>>::allowance_for_all())]
-	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {
+	fn is_approved_for_all(&self, owner: Address, operator: Address) -> Result<bool> {
 		let owner = T::CrossAccountId::from_eth(owner);
 		let operator = T::CrossAccountId::from_eth(operator);
 
@@ -539,7 +539,7 @@
 	/// @param to The new owner
 	/// @return uint256 The id of the newly minted token
 	#[weight(<SelfWeightOf<T>>::create_item())]
-	fn mint(&mut self, caller: caller, to: address) -> Result<U256> {
+	fn mint(&mut self, caller: caller, to: Address) -> Result<U256> {
 		let token_id: U256 = <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
 			.ok_or("item id overflow")?
@@ -555,7 +555,7 @@
 	/// @param tokenId ID of the minted NFT
 	#[solidity(hide, rename_selector = "mint")]
 	#[weight(<SelfWeightOf<T>>::create_item())]
-	fn mint_check_id(&mut self, caller: caller, to: address, token_id: U256) -> Result<bool> {
+	fn mint_check_id(&mut self, caller: caller, to: Address, token_id: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let token_id: u32 = token_id.try_into()?;
@@ -594,7 +594,7 @@
 	fn mint_with_token_uri(
 		&mut self,
 		caller: caller,
-		to: address,
+		to: Address,
 		token_uri: string,
 	) -> Result<U256> {
 		let token_id: U256 = <TokensMinted<T>>::get(self.id)
@@ -616,7 +616,7 @@
 	fn mint_with_token_uri_check_id(
 		&mut self,
 		caller: caller,
-		to: address,
+		to: Address,
 		token_id: U256,
 		token_uri: string,
 	) -> Result<bool> {
@@ -784,7 +784,7 @@
 	/// @param to The new owner
 	/// @param tokenId The NFT to transfer
 	#[weight(<SelfWeightOf<T>>::transfer())]
-	fn transfer(&mut self, caller: caller, to: address, token_id: U256) -> Result<()> {
+	fn transfer(&mut self, caller: caller, to: Address, token_id: U256) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let token = token_id.try_into()?;
@@ -853,7 +853,7 @@
 	/// @param tokenId The NFT to transfer
 	#[solidity(hide)]
 	#[weight(<SelfWeightOf<T>>::burn_from())]
-	fn burn_from(&mut self, caller: caller, from: address, token_id: U256) -> Result<()> {
+	fn burn_from(&mut self, caller: caller, from: Address, token_id: U256) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = T::CrossAccountId::from_eth(from);
 		let token = token_id.try_into()?;
@@ -907,7 +907,7 @@
 	/// @param tokenIds IDs of the minted NFTs
 	#[solidity(hide)]
 	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
-	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<U256>) -> Result<bool> {
+	fn mint_bulk(&mut self, caller: caller, to: Address, token_ids: Vec<U256>) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let mut expected_index = <TokensMinted<T>>::get(self.id)
@@ -947,7 +947,7 @@
 	fn mint_bulk_with_token_uri(
 		&mut self,
 		caller: caller,
-		to: address,
+		to: Address,
 		tokens: Vec<(U256, string)>,
 	) -> Result<bool> {
 		let key = key::url();
@@ -1035,7 +1035,7 @@
 	}
 
 	/// @notice Returns collection helper contract address
-	fn collection_helper_address(&self) -> Result<address> {
+	fn collection_helper_address(&self) -> Result<Address> {
 		Ok(T::ContractAddress::get())
 	}
 }

--- a/pallets/refungible/src/erc.rs
+++ b/pallets/refungible/src/erc.rs
@@ -262,18 +262,18 @@
 	///  may be created and assigned without emitting Transfer.
 	Transfer {
 		#[indexed]
-		from: address,
+		from: Address,
 		#[indexed]
-		to: address,
+		to: Address,
 		#[indexed]
 		token_id: U256,
 	},
 	/// @dev Not supported
 	Approval {
 		#[indexed]
-		owner: address,
+		owner: Address,
 		#[indexed]
-		approved: address,
+		approved: Address,
 		#[indexed]
 		token_id: U256,
 	},
@@ -281,9 +281,9 @@
 	#[allow(dead_code)]
 	ApprovalForAll {
 		#[indexed]
-		owner: address,
+		owner: Address,
 		#[indexed]
-		operator: address,
+		operator: Address,
 		approved: bool,
 	},
 }
@@ -370,7 +370,7 @@
 	}
 
 	/// Not implemented
-	fn token_of_owner_by_index(&self, _owner: address, _index: U256) -> Result<U256> {
+	fn token_of_owner_by_index(&self, _owner: Address, _index: U256) -> Result<U256> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
@@ -393,7 +393,7 @@
 	///  function throws for queries about the zero address.
 	/// @param owner An address for whom to query the balance
 	/// @return The number of RFTs owned by `owner`, possibly zero
-	fn balance_of(&self, owner: address) -> Result<U256> {
+	fn balance_of(&self, owner: Address) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		let owner = T::CrossAccountId::from_eth(owner);
 		let balance = <AccountBalance<T>>::get((self.id, owner));
@@ -407,7 +407,7 @@
 	///  the tokens that are partially owned.
 	/// @param tokenId The identifier for an RFT
 	/// @return The address of the owner of the RFT
-	fn owner_of(&self, token_id: U256) -> Result<address> {
+	fn owner_of(&self, token_id: U256) -> Result<Address> {
 		self.consume_store_reads(2)?;
 		let token = token_id.try_into()?;
 		let owner = <Pallet<T>>::token_owner(self.id, token);
@@ -420,8 +420,8 @@
 	#[solidity(rename_selector = "safeTransferFrom")]
 	fn safe_transfer_from_with_data(
 		&mut self,
-		_from: address,
-		_to: address,
+		_from: Address,
+		_to: Address,
 		_token_id: U256,
 		_data: bytes,
 	) -> Result<()> {
@@ -431,7 +431,7 @@
 
 	/// @dev Not implemented
 	#[solidity(rename_selector = "safeTransferFrom")]
-	fn safe_transfer_from(&mut self, _from: address, _to: address, _token_id: U256) -> Result<()> {
+	fn safe_transfer_from(&mut self, _from: Address, _to: Address, _token_id: U256) -> Result<()> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
@@ -450,8 +450,8 @@
 	fn transfer_from(
 		&mut self,
 		caller: caller,
-		from: address,
-		to: address,
+		from: Address,
+		to: Address,
 		token_id: U256,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -472,7 +472,7 @@
 	}
 
 	/// @dev Not implemented
-	fn approve(&mut self, _caller: caller, _approved: address, _token_id: U256) -> Result<()> {
+	fn approve(&mut self, _caller: caller, _approved: Address, _token_id: U256) -> Result<()> {
 		Err("not implemented".into())
 	}
 
@@ -484,7 +484,7 @@
 	fn set_approval_for_all(
 		&mut self,
 		caller: caller,
-		operator: address,
+		operator: Address,
 		approved: bool,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -496,14 +496,14 @@
 	}
 
 	/// @dev Not implemented
-	fn get_approved(&self, _token_id: U256) -> Result<address> {
+	fn get_approved(&self, _token_id: U256) -> Result<Address> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
 
 	/// @notice Tells whether the given `owner` approves the `operator`.
 	#[weight(<SelfWeightOf<T>>::allowance_for_all())]
-	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {
+	fn is_approved_for_all(&self, owner: Address, operator: Address) -> Result<bool> {
 		let owner = T::CrossAccountId::from_eth(owner);
 		let operator = T::CrossAccountId::from_eth(operator);
 
@@ -570,7 +570,7 @@
 	/// @param to The new owner
 	/// @return uint256 The id of the newly minted token
 	#[weight(<SelfWeightOf<T>>::create_item())]
-	fn mint(&mut self, caller: caller, to: address) -> Result<U256> {
+	fn mint(&mut self, caller: caller, to: Address) -> Result<U256> {
 		let token_id: U256 = <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
 			.ok_or("item id overflow")?
@@ -586,7 +586,7 @@
 	/// @param tokenId ID of the minted RFT
 	#[solidity(hide, rename_selector = "mint")]
 	#[weight(<SelfWeightOf<T>>::create_item())]
-	fn mint_check_id(&mut self, caller: caller, to: address, token_id: U256) -> Result<bool> {
+	fn mint_check_id(&mut self, caller: caller, to: Address, token_id: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let token_id: u32 = token_id.try_into()?;
@@ -630,7 +630,7 @@
 	fn mint_with_token_uri(
 		&mut self,
 		caller: caller,
-		to: address,
+		to: Address,
 		token_uri: string,
 	) -> Result<U256> {
 		let token_id: U256 = <TokensMinted<T>>::get(self.id)
@@ -652,7 +652,7 @@
 	fn mint_with_token_uri_check_id(
 		&mut self,
 		caller: caller,
-		to: address,
+		to: Address,
 		token_id: U256,
 		token_uri: string,
 	) -> Result<bool> {
@@ -800,7 +800,7 @@
 	/// @param to The new owner
 	/// @param tokenId The RFT to transfer
 	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]
-	fn transfer(&mut self, caller: caller, to: address, token_id: U256) -> Result<()> {
+	fn transfer(&mut self, caller: caller, to: Address, token_id: U256) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let token = token_id.try_into()?;
@@ -883,7 +883,7 @@
 	/// @param tokenId The RFT to transfer
 	#[solidity(hide)]
 	#[weight(<SelfWeightOf<T>>::burn_from())]
-	fn burn_from(&mut self, caller: caller, from: address, token_id: U256) -> Result<()> {
+	fn burn_from(&mut self, caller: caller, from: Address, token_id: U256) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = T::CrossAccountId::from_eth(from);
 		let token = token_id.try_into()?;
@@ -944,7 +944,7 @@
 	/// @param tokenIds IDs of the minted RFTs
 	#[solidity(hide)]
 	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
-	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<U256>) -> Result<bool> {
+	fn mint_bulk(&mut self, caller: caller, to: Address, token_ids: Vec<U256>) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let mut expected_index = <TokensMinted<T>>::get(self.id)
@@ -990,7 +990,7 @@
 	fn mint_bulk_with_token_uri(
 		&mut self,
 		caller: caller,
-		to: address,
+		to: Address,
 		tokens: Vec<(U256, string)>,
 	) -> Result<bool> {
 		let key = key::url();
@@ -1088,7 +1088,7 @@
 	/// Returns EVM address for refungible token
 	///
 	/// @param token ID of the token
-	fn token_contract_address(&self, token: U256) -> Result<address> {
+	fn token_contract_address(&self, token: U256) -> Result<Address> {
 		Ok(T::EvmTokenAddressMapping::token_to_address(
 			self.id,
 			token.try_into().map_err(|_| "token id overflow")?,
@@ -1096,7 +1096,7 @@
 	}
 
 	/// @notice Returns collection helper contract address
-	fn collection_helper_address(&self) -> Result<address> {
+	fn collection_helper_address(&self) -> Result<Address> {
 		Ok(T::ContractAddress::get())
 	}
 }

--- a/pallets/refungible/src/erc_token.rs
+++ b/pallets/refungible/src/erc_token.rs
@@ -52,7 +52,7 @@
 
 #[solidity_interface(name = ERC1633)]
 impl<T: Config> RefungibleTokenHandle<T> {
-	fn parent_token(&self) -> Result<address> {
+	fn parent_token(&self) -> Result<Address> {
 		Ok(collection_id_to_address(self.id))
 	}
 
@@ -69,18 +69,18 @@
 	/// of burning tokens the transfer is to 0.
 	Transfer {
 		#[indexed]
-		from: address,
+		from: Address,
 		#[indexed]
-		to: address,
+		to: Address,
 		value: U256,
 	},
 	/// @dev This event is emitted when the amount of tokens (value) is approved
 	/// by the owner to be used by the spender.
 	Approval {
 		#[indexed]
-		owner: address,
+		owner: Address,
 		#[indexed]
-		spender: address,
+		spender: Address,
 		value: U256,
 	},
 }
@@ -118,7 +118,7 @@
 	/// @dev Gets the balance of the specified address.
 	/// @param owner The address to query the balance of.
 	/// @return An uint256 representing the amount owned by the passed address.
-	fn balance_of(&self, owner: address) -> Result<U256> {
+	fn balance_of(&self, owner: Address) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		let owner = T::CrossAccountId::from_eth(owner);
 		let balance = <Balance<T>>::get((self.id, self.1, owner));
@@ -129,7 +129,7 @@
 	/// @param to The address to transfer to.
 	/// @param amount The amount to be transferred.
 	#[weight(<CommonWeights<T>>::transfer())]
-	fn transfer(&mut self, caller: caller, to: address, amount: U256) -> Result<bool> {
+	fn transfer(&mut self, caller: caller, to: Address, amount: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let to = T::CrossAccountId::from_eth(to);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -150,8 +150,8 @@
 	fn transfer_from(
 		&mut self,
 		caller: caller,
-		from: address,
-		to: address,
+		from: Address,
+		to: Address,
 		amount: U256,
 	) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -175,7 +175,7 @@
 	/// @param spender The address which will spend the funds.
 	/// @param amount The amount of tokens to be spent.
 	#[weight(<SelfWeightOf<T>>::approve())]
-	fn approve(&mut self, caller: caller, spender: address, amount: U256) -> Result<bool> {
+	fn approve(&mut self, caller: caller, spender: Address, amount: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let spender = T::CrossAccountId::from_eth(spender);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
@@ -189,7 +189,7 @@
 	/// @param owner address The address which owns the funds.
 	/// @param spender address The address which will spend the funds.
 	/// @return A uint256 specifying the amount of tokens still available for the spender.
-	fn allowance(&self, owner: address, spender: address) -> Result<U256> {
+	fn allowance(&self, owner: Address, spender: Address) -> Result<U256> {
 		self.consume_store_reads(1)?;
 		let owner = T::CrossAccountId::from_eth(owner);
 		let spender = T::CrossAccountId::from_eth(spender);
@@ -209,7 +209,7 @@
 	/// @param amount The amount that will be burnt.
 	#[weight(<SelfWeightOf<T>>::burn_from())]
 	#[solidity(hide)]
-	fn burn_from(&mut self, caller: caller, from: address, amount: U256) -> Result<bool> {
+	fn burn_from(&mut self, caller: caller, from: Address, amount: U256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let from = T::CrossAccountId::from_eth(from);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;

--- a/pallets/unique/src/eth/mod.rs
+++ b/pallets/unique/src/eth/mod.rs
@@ -93,7 +93,7 @@
 	collection_mode: CollectionMode,
 	description: string,
 	token_prefix: string,
-) -> Result<address> {
+) -> Result<Address> {
 	let (caller, name, description, token_prefix) =
 		convert_data::<T>(caller, name, description, token_prefix)?;
 	let data = CreateCollectionData {
@@ -154,7 +154,7 @@
 		name: string,
 		description: string,
 		token_prefix: string,
-	) -> Result<address> {
+	) -> Result<Address> {
 		let (caller, name, description, token_prefix) =
 			convert_data::<T>(caller, name, description, token_prefix)?;
 		let data = CreateCollectionData {
@@ -193,7 +193,7 @@
 		name: string,
 		description: string,
 		token_prefix: string,
-	) -> Result<address> {
+	) -> Result<Address> {
 		create_collection_internal::<T>(
 			caller,
 			value,
@@ -213,7 +213,7 @@
 		name: string,
 		description: string,
 		token_prefix: string,
-	) -> Result<address> {
+	) -> Result<Address> {
 		create_collection_internal::<T>(
 			caller,
 			value,
@@ -234,7 +234,7 @@
 		decimals: u8,
 		description: string,
 		token_prefix: string,
-	) -> Result<address> {
+	) -> Result<Address> {
 		create_collection_internal::<T>(
 			caller,
 			value,
@@ -249,7 +249,7 @@
 	fn make_collection_metadata_compatible(
 		&mut self,
 		caller: caller,
-		collection: address,
+		collection: Address,
 		base_uri: string,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -334,7 +334,7 @@
 	}
 
 	#[weight(<SelfWeightOf<T>>::destroy_collection())]
-	fn destroy_collection(&mut self, caller: caller, collection_address: address) -> Result<()> {
+	fn destroy_collection(&mut self, caller: caller, collection_address: Address) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 
 		let collection_id = pallet_common::eth::map_eth_to_id(&collection_address)
@@ -346,7 +346,7 @@
 	/// Check if a collection exists
 	/// @param collectionAddress Address of the collection in question
 	/// @return bool Does the collection exist?
-	fn is_collection_exist(&self, _caller: caller, collection_address: address) -> Result<bool> {
+	fn is_collection_exist(&self, _caller: caller, collection_address: Address) -> Result<bool> {
 		if let Some(id) = pallet_common::eth::map_eth_to_id(&collection_address) {
 			let collection_id = id;
 			return Ok(<CollectionById<T>>::contains_key(collection_id));
@@ -366,14 +366,14 @@
 	/// Returns address of a collection.
 	/// @param collectionId  - CollectionId  of the collection
 	/// @return eth mirror address of the collection
-	fn collection_address(&self, collection_id: u32) -> Result<address> {
+	fn collection_address(&self, collection_id: u32) -> Result<Address> {
 		Ok(collection_id_to_address(collection_id.into()))
 	}
 
 	/// Returns collectionId of a collection.
 	/// @param collectionAddress  - Eth address of the collection
 	/// @return collectionId of the collection
-	fn collection_id(&self, collection_address: address) -> Result<u32> {
+	fn collection_id(&self, collection_address: Address) -> Result<u32> {
 		map_eth_to_id(&collection_address)
 			.map(|id| id.0)
 			.ok_or(Error::Revert(format!(