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,
 }
 

--- a/pallets/evm-contract-helpers/src/eth.rs
+++ b/pallets/evm-contract-helpers/src/eth.rs
@@ -49,25 +49,25 @@
 	ContractSponsorSet {
 		/// Contract address of the affected collection.
 		#[indexed]
-		contract_address: address,
+		contract_address: Address,
 		/// New sponsor address.
-		sponsor: address,
+		sponsor: Address,
 	},
 
 	/// New sponsor was confirm.
 	ContractSponsorshipConfirmed {
 		/// Contract address of the affected collection.
 		#[indexed]
-		contract_address: address,
+		contract_address: Address,
 		/// New sponsor address.
-		sponsor: address,
+		sponsor: Address,
 	},
 
 	/// Collection sponsor was removed.
 	ContractSponsorRemoved {
 		/// Contract address of the affected collection.
 		#[indexed]
-		contract_address: address,
+		contract_address: Address,
 	},
 }
 
@@ -96,7 +96,7 @@
 	/// @dev Returns zero address if contract does not exists
 	/// @param contractAddress Contract to get owner of
 	/// @return address Owner of contract
-	fn contract_owner(&self, contract_address: address) -> Result<address> {
+	fn contract_owner(&self, contract_address: Address) -> Result<Address> {
 		Ok(<Owner<T>>::get(contract_address))
 	}
 
@@ -106,8 +106,8 @@
 	fn set_sponsor(
 		&mut self,
 		caller: caller,
-		contract_address: address,
-		sponsor: address,
+		contract_address: Address,
+		sponsor: Address,
 	) -> Result<()> {
 		self.recorder().consume_sload()?;
 		self.recorder().consume_sstore()?;
@@ -125,7 +125,7 @@
 	/// Set contract as self sponsored.
 	///
 	/// @param contractAddress Contract for which a self sponsoring is being enabled.
-	fn self_sponsored_enable(&mut self, caller: caller, contract_address: address) -> Result<()> {
+	fn self_sponsored_enable(&mut self, caller: caller, contract_address: Address) -> Result<()> {
 		self.recorder().consume_sload()?;
 		self.recorder().consume_sstore()?;
 
@@ -146,7 +146,7 @@
 	/// Remove sponsor.
 	///
 	/// @param contractAddress Contract for which a sponsorship is being removed.
-	fn remove_sponsor(&mut self, caller: caller, contract_address: address) -> Result<()> {
+	fn remove_sponsor(&mut self, caller: caller, contract_address: Address) -> Result<()> {
 		self.recorder().consume_sload()?;
 		self.recorder().consume_sstore()?;
 
@@ -161,7 +161,7 @@
 	/// @dev Caller must be same that set via [`setSponsor`].
 	///
 	/// @param contractAddress Сontract for which need to confirm sponsorship.
-	fn confirm_sponsorship(&mut self, caller: caller, contract_address: address) -> Result<()> {
+	fn confirm_sponsorship(&mut self, caller: caller, contract_address: Address) -> Result<()> {
 		self.recorder().consume_sload()?;
 		self.recorder().consume_sstore()?;
 
@@ -175,7 +175,7 @@
 	///
 	/// @param contractAddress The contract for which a sponsor is requested.
 	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
-	fn sponsor(&self, contract_address: address) -> Result<Option<eth::CrossAddress>> {
+	fn sponsor(&self, contract_address: Address) -> Result<Option<eth::CrossAddress>> {
 		Ok(match Pallet::<T>::get_sponsor(contract_address) {
 			Some(ref value) => Some(eth::CrossAddress::from_sub_cross_account::<T>(value)),
 			None => None,
@@ -186,7 +186,7 @@
 	///
 	/// @param contractAddress The contract for which the presence of a confirmed sponsor is checked.
 	/// @return **true** if contract has confirmed sponsor.
-	fn has_sponsor(&self, contract_address: address) -> Result<bool> {
+	fn has_sponsor(&self, contract_address: Address) -> Result<bool> {
 		Ok(Pallet::<T>::get_sponsor(contract_address).is_some())
 	}
 
@@ -194,21 +194,21 @@
 	///
 	/// @param contractAddress The contract for which the presence of a pending sponsor is checked.
 	/// @return **true** if contract has pending sponsor.
-	fn has_pending_sponsor(&self, contract_address: address) -> Result<bool> {
+	fn has_pending_sponsor(&self, contract_address: Address) -> Result<bool> {
 		Ok(match Sponsoring::<T>::get(contract_address) {
 			SponsorshipState::Disabled | SponsorshipState::Confirmed(_) => false,
 			SponsorshipState::Unconfirmed(_) => true,
 		})
 	}
 
-	fn sponsoring_enabled(&self, contract_address: address) -> Result<bool> {
+	fn sponsoring_enabled(&self, contract_address: Address) -> Result<bool> {
 		Ok(<Pallet<T>>::sponsoring_mode(contract_address) != SponsoringModeT::Disabled)
 	}
 
 	fn set_sponsoring_mode(
 		&mut self,
 		caller: caller,
-		contract_address: address,
+		contract_address: Address,
 		mode: SponsoringModeT,
 	) -> Result<()> {
 		self.recorder().consume_sload()?;
@@ -223,7 +223,7 @@
 	/// Get current contract sponsoring rate limit
 	/// @param contractAddress Contract to get sponsoring rate limit of
 	/// @return uint32 Amount of blocks between two sponsored transactions
-	fn sponsoring_rate_limit(&self, contract_address: address) -> Result<u32> {
+	fn sponsoring_rate_limit(&self, contract_address: Address) -> Result<u32> {
 		self.recorder().consume_sload()?;
 
 		Ok(<SponsoringRateLimit<T>>::get(contract_address)
@@ -240,7 +240,7 @@
 	fn set_sponsoring_rate_limit(
 		&mut self,
 		caller: caller,
-		contract_address: address,
+		contract_address: Address,
 		rate_limit: u32,
 	) -> Result<()> {
 		self.recorder().consume_sload()?;
@@ -260,7 +260,7 @@
 	fn set_sponsoring_fee_limit(
 		&mut self,
 		caller: caller,
-		contract_address: address,
+		contract_address: Address,
 		fee_limit: U256,
 	) -> Result<()> {
 		self.recorder().consume_sload()?;
@@ -276,7 +276,7 @@
 	/// @param contractAddress Contract to get sponsoring fee limit of
 	/// @return uint256 Maximum amount of fee that could be spent by single
 	///  transaction
-	fn sponsoring_fee_limit(&self, contract_address: address) -> Result<U256> {
+	fn sponsoring_fee_limit(&self, contract_address: Address) -> Result<U256> {
 		self.recorder().consume_sload()?;
 
 		Ok(get_sponsoring_fee_limit::<T>(contract_address))
@@ -287,7 +287,7 @@
 	/// @param contractAddress Contract to check allowlist of
 	/// @param user User to check
 	/// @return bool Is specified users exists in contract allowlist
-	fn allowed(&self, contract_address: address, user: address) -> Result<bool> {
+	fn allowed(&self, contract_address: Address, user: Address) -> Result<bool> {
 		self.0.consume_sload()?;
 		Ok(<Pallet<T>>::allowed(contract_address, user))
 	}
@@ -301,8 +301,8 @@
 	fn toggle_allowed(
 		&mut self,
 		caller: caller,
-		contract_address: address,
-		user: address,
+		contract_address: Address,
+		user: Address,
 		is_allowed: bool,
 	) -> Result<()> {
 		self.recorder().consume_sload()?;
@@ -320,7 +320,7 @@
 	///  in case of allowlist access enabled, only users from allowlist may call this contract
 	/// @param contractAddress Contract to get allowlist access of
 	/// @return bool Is specified contract has allowlist access enabled
-	fn allowlist_enabled(&self, contract_address: address) -> Result<bool> {
+	fn allowlist_enabled(&self, contract_address: Address) -> Result<bool> {
 		Ok(<AllowlistEnabled<T>>::get(contract_address))
 	}
 
@@ -330,7 +330,7 @@
 	fn toggle_allowlist(
 		&mut self,
 		caller: caller,
-		contract_address: address,
+		contract_address: Address,
 		enabled: bool,
 	) -> Result<()> {
 		self.recorder().consume_sload()?;
@@ -441,7 +441,7 @@
 	}
 }
 
-fn get_sponsoring_fee_limit<T: Config>(contract_address: address) -> U256 {
+fn get_sponsoring_fee_limit<T: Config>(contract_address: Address) -> U256 {
 	<SponsoringFeeLimit<T>>::get(contract_address)
 		.get(&0xffffffff)
 		.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())
 	}
 }

262	///  may be created and assigned without emitting Transfer.262	///  may be created and assigned without emitting Transfer.
263	Transfer {263	Transfer {
264		#[indexed]264		#[indexed]
265		from: address,265		from: Address,
266		#[indexed]266		#[indexed]
267		to: address,267		to: Address,
268		#[indexed]268		#[indexed]
269		token_id: U256,269		token_id: U256,
270	},270	},
271	/// @dev Not supported271	/// @dev Not supported
272	Approval {272	Approval {
273		#[indexed]273		#[indexed]
274		owner: address,274		owner: Address,
275		#[indexed]275		#[indexed]
276		approved: address,276		approved: Address,
277		#[indexed]277		#[indexed]
278		token_id: U256,278		token_id: U256,
279	},279	},
280	/// @dev Not supported280	/// @dev Not supported
281	#[allow(dead_code)]281	#[allow(dead_code)]
282	ApprovalForAll {282	ApprovalForAll {
283		#[indexed]283		#[indexed]
284		owner: address,284		owner: Address,
285		#[indexed]285		#[indexed]
286		operator: address,286		operator: Address,
287		approved: bool,287		approved: bool,
288	},288	},
289}289}
370	}370	}
371371
372	/// Not implemented372	/// Not implemented
373	fn token_of_owner_by_index(&self, _owner: address, _index: U256) -> Result<U256> {373	fn token_of_owner_by_index(&self, _owner: Address, _index: U256) -> Result<U256> {
374		// TODO: Not implemetable374		// TODO: Not implemetable
375		Err("not implemented".into())375		Err("not implemented".into())
376	}376	}
393	///  function throws for queries about the zero address.393	///  function throws for queries about the zero address.
394	/// @param owner An address for whom to query the balance394	/// @param owner An address for whom to query the balance
395	/// @return The number of RFTs owned by `owner`, possibly zero395	/// @return The number of RFTs owned by `owner`, possibly zero
396	fn balance_of(&self, owner: address) -> Result<U256> {396	fn balance_of(&self, owner: Address) -> Result<U256> {
397		self.consume_store_reads(1)?;397		self.consume_store_reads(1)?;
398		let owner = T::CrossAccountId::from_eth(owner);398		let owner = T::CrossAccountId::from_eth(owner);
399		let balance = <AccountBalance<T>>::get((self.id, owner));399		let balance = <AccountBalance<T>>::get((self.id, owner));
407	///  the tokens that are partially owned.407	///  the tokens that are partially owned.
408	/// @param tokenId The identifier for an RFT408	/// @param tokenId The identifier for an RFT
409	/// @return The address of the owner of the RFT409	/// @return The address of the owner of the RFT
410	fn owner_of(&self, token_id: U256) -> Result<address> {410	fn owner_of(&self, token_id: U256) -> Result<Address> {
411		self.consume_store_reads(2)?;411		self.consume_store_reads(2)?;
412		let token = token_id.try_into()?;412		let token = token_id.try_into()?;
413		let owner = <Pallet<T>>::token_owner(self.id, token);413		let owner = <Pallet<T>>::token_owner(self.id, token);
420	#[solidity(rename_selector = "safeTransferFrom")]420	#[solidity(rename_selector = "safeTransferFrom")]
421	fn safe_transfer_from_with_data(421	fn safe_transfer_from_with_data(
422		&mut self,422		&mut self,
423		_from: address,423		_from: Address,
424		_to: address,424		_to: Address,
425		_token_id: U256,425		_token_id: U256,
426		_data: bytes,426		_data: bytes,
427	) -> Result<()> {427	) -> Result<()> {
431431
432	/// @dev Not implemented432	/// @dev Not implemented
433	#[solidity(rename_selector = "safeTransferFrom")]433	#[solidity(rename_selector = "safeTransferFrom")]
434	fn safe_transfer_from(&mut self, _from: address, _to: address, _token_id: U256) -> Result<()> {434	fn safe_transfer_from(&mut self, _from: Address, _to: Address, _token_id: U256) -> Result<()> {
435		// TODO: Not implemetable435		// TODO: Not implemetable
436		Err("not implemented".into())436		Err("not implemented".into())
437	}437	}
450	fn transfer_from(450	fn transfer_from(
451		&mut self,451		&mut self,
452		caller: caller,452		caller: caller,
453		from: address,453		from: Address,
454		to: address,454		to: Address,
455		token_id: U256,455		token_id: U256,
456	) -> Result<()> {456	) -> Result<()> {
457		let caller = T::CrossAccountId::from_eth(caller);457		let caller = T::CrossAccountId::from_eth(caller);
472	}472	}
473473
474	/// @dev Not implemented474	/// @dev Not implemented
475	fn approve(&mut self, _caller: caller, _approved: address, _token_id: U256) -> Result<()> {475	fn approve(&mut self, _caller: caller, _approved: Address, _token_id: U256) -> Result<()> {
476		Err("not implemented".into())476		Err("not implemented".into())
477	}477	}
478478
484	fn set_approval_for_all(484	fn set_approval_for_all(
485		&mut self,485		&mut self,
486		caller: caller,486		caller: caller,
487		operator: address,487		operator: Address,
488		approved: bool,488		approved: bool,
489	) -> Result<()> {489	) -> Result<()> {
490		let caller = T::CrossAccountId::from_eth(caller);490		let caller = T::CrossAccountId::from_eth(caller);
496	}496	}
497497
498	/// @dev Not implemented498	/// @dev Not implemented
499	fn get_approved(&self, _token_id: U256) -> Result<address> {499	fn get_approved(&self, _token_id: U256) -> Result<Address> {
500		// TODO: Not implemetable500		// TODO: Not implemetable
501		Err("not implemented".into())501		Err("not implemented".into())
502	}502	}
503503
504	/// @notice Tells whether the given `owner` approves the `operator`.504	/// @notice Tells whether the given `owner` approves the `operator`.
505	#[weight(<SelfWeightOf<T>>::allowance_for_all())]505	#[weight(<SelfWeightOf<T>>::allowance_for_all())]
506	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {506	fn is_approved_for_all(&self, owner: Address, operator: Address) -> Result<bool> {
507		let owner = T::CrossAccountId::from_eth(owner);507		let owner = T::CrossAccountId::from_eth(owner);
508		let operator = T::CrossAccountId::from_eth(operator);508		let operator = T::CrossAccountId::from_eth(operator);
509509
570	/// @param to The new owner570	/// @param to The new owner
571	/// @return uint256 The id of the newly minted token571	/// @return uint256 The id of the newly minted token
572	#[weight(<SelfWeightOf<T>>::create_item())]572	#[weight(<SelfWeightOf<T>>::create_item())]
573	fn mint(&mut self, caller: caller, to: address) -> Result<U256> {573	fn mint(&mut self, caller: caller, to: Address) -> Result<U256> {
574		let token_id: U256 = <TokensMinted<T>>::get(self.id)574		let token_id: U256 = <TokensMinted<T>>::get(self.id)
575			.checked_add(1)575			.checked_add(1)
576			.ok_or("item id overflow")?576			.ok_or("item id overflow")?
586	/// @param tokenId ID of the minted RFT586	/// @param tokenId ID of the minted RFT
587	#[solidity(hide, rename_selector = "mint")]587	#[solidity(hide, rename_selector = "mint")]
588	#[weight(<SelfWeightOf<T>>::create_item())]588	#[weight(<SelfWeightOf<T>>::create_item())]
589	fn mint_check_id(&mut self, caller: caller, to: address, token_id: U256) -> Result<bool> {589	fn mint_check_id(&mut self, caller: caller, to: Address, token_id: U256) -> Result<bool> {
590		let caller = T::CrossAccountId::from_eth(caller);590		let caller = T::CrossAccountId::from_eth(caller);
591		let to = T::CrossAccountId::from_eth(to);591		let to = T::CrossAccountId::from_eth(to);
592		let token_id: u32 = token_id.try_into()?;592		let token_id: u32 = token_id.try_into()?;
630	fn mint_with_token_uri(630	fn mint_with_token_uri(
631		&mut self,631		&mut self,
632		caller: caller,632		caller: caller,
633		to: address,633		to: Address,
634		token_uri: string,634		token_uri: string,
635	) -> Result<U256> {635	) -> Result<U256> {
636		let token_id: U256 = <TokensMinted<T>>::get(self.id)636		let token_id: U256 = <TokensMinted<T>>::get(self.id)
652	fn mint_with_token_uri_check_id(652	fn mint_with_token_uri_check_id(
653		&mut self,653		&mut self,
654		caller: caller,654		caller: caller,
655		to: address,655		to: Address,
656		token_id: U256,656		token_id: U256,
657		token_uri: string,657		token_uri: string,
658	) -> Result<bool> {658	) -> Result<bool> {
800	/// @param to The new owner800	/// @param to The new owner
801	/// @param tokenId The RFT to transfer801	/// @param tokenId The RFT to transfer
802	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]802	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]
803	fn transfer(&mut self, caller: caller, to: address, token_id: U256) -> Result<()> {803	fn transfer(&mut self, caller: caller, to: Address, token_id: U256) -> Result<()> {
804		let caller = T::CrossAccountId::from_eth(caller);804		let caller = T::CrossAccountId::from_eth(caller);
805		let to = T::CrossAccountId::from_eth(to);805		let to = T::CrossAccountId::from_eth(to);
806		let token = token_id.try_into()?;806		let token = token_id.try_into()?;
883	/// @param tokenId The RFT to transfer883	/// @param tokenId The RFT to transfer
884	#[solidity(hide)]884	#[solidity(hide)]
885	#[weight(<SelfWeightOf<T>>::burn_from())]885	#[weight(<SelfWeightOf<T>>::burn_from())]
886	fn burn_from(&mut self, caller: caller, from: address, token_id: U256) -> Result<()> {886	fn burn_from(&mut self, caller: caller, from: Address, token_id: U256) -> Result<()> {
887		let caller = T::CrossAccountId::from_eth(caller);887		let caller = T::CrossAccountId::from_eth(caller);
888		let from = T::CrossAccountId::from_eth(from);888		let from = T::CrossAccountId::from_eth(from);
889		let token = token_id.try_into()?;889		let token = token_id.try_into()?;
944	/// @param tokenIds IDs of the minted RFTs944	/// @param tokenIds IDs of the minted RFTs
945	#[solidity(hide)]945	#[solidity(hide)]
946	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]946	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
947	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<U256>) -> Result<bool> {947	fn mint_bulk(&mut self, caller: caller, to: Address, token_ids: Vec<U256>) -> Result<bool> {
948		let caller = T::CrossAccountId::from_eth(caller);948		let caller = T::CrossAccountId::from_eth(caller);
949		let to = T::CrossAccountId::from_eth(to);949		let to = T::CrossAccountId::from_eth(to);
950		let mut expected_index = <TokensMinted<T>>::get(self.id)950		let mut expected_index = <TokensMinted<T>>::get(self.id)
990	fn mint_bulk_with_token_uri(990	fn mint_bulk_with_token_uri(
991		&mut self,991		&mut self,
992		caller: caller,992		caller: caller,
993		to: address,993		to: Address,
994		tokens: Vec<(U256, string)>,994		tokens: Vec<(U256, string)>,
995	) -> Result<bool> {995	) -> Result<bool> {
996		let key = key::url();996		let key = key::url();
1088	/// Returns EVM address for refungible token1088	/// Returns EVM address for refungible token
1089	///1089	///
1090	/// @param token ID of the token1090	/// @param token ID of the token
1091	fn token_contract_address(&self, token: U256) -> Result<address> {1091	fn token_contract_address(&self, token: U256) -> Result<Address> {
1092		Ok(T::EvmTokenAddressMapping::token_to_address(1092		Ok(T::EvmTokenAddressMapping::token_to_address(
1093			self.id,1093			self.id,
1094			token.try_into().map_err(|_| "token id overflow")?,1094			token.try_into().map_err(|_| "token id overflow")?,
1095		))1095		))
1096	}1096	}
10971097
1098	/// @notice Returns collection helper contract address1098	/// @notice Returns collection helper contract address
1099	fn collection_helper_address(&self) -> Result<address> {1099	fn collection_helper_address(&self) -> Result<Address> {
1100		Ok(T::ContractAddress::get())1100		Ok(T::ContractAddress::get())
1101	}1101	}
1102}1102}

--- 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!(