Refactor use generic AccountId type

Cargo.toml

@@ -13,6 +13,7 @@ members = [
 [workspace.dependencies]
 parity-scale-codec = { version = "3.2.2", default-features = false, features = ["derive"] }
 hex-literal = "0.4.1"
+hex = { version = "0.4.3", default-features = false }
 scale-info = { version = "2.7.0", default-features = false, features = ["derive"] }
 smallvec = "1.10.0"
 num_enum = { version = "0.5.3", default-features = false }

pallets/living-assets-ownership/src/functions.rs

@@ -1,7 +1,6 @@
 //! Contains helper and utility functions of the pallet
 use super::*;
 use frame_support::sp_runtime::traits::One;
-use sp_core::{H160, U256};
 
 impl<T: Config> Pallet<T> {
 	/// See [Self::create_collection]
@@ -25,52 +24,3 @@ impl<T: Config> Pallet<T> {
 		Ok(collection_id)
 	}
 }
-
-pub fn convert_asset_id_to_owner(value: U256) -> H160 {
-	let mut bytes = [0u8; 20];
-	let value_bytes: [u8; 32] = value.into();
-	bytes.copy_from_slice(&value_bytes[value_bytes.len() - 20..]);
-	H160::from(bytes)
-}
-
-#[cfg(test)]
-mod tests {
-	use crate::{functions::convert_asset_id_to_owner, H160, U256};
-
-	#[test]
-	fn check_convert_asset_id_to_owner() {
-		let value = U256::from(5);
-		let expected_address = H160::from_low_u64_be(5);
-		assert_eq!(convert_asset_id_to_owner(value), expected_address);
-	}
-
-	#[test]
-	fn check_two_assets_same_owner() {
-		// create two different assets
-		let asset1 = U256::from(
-			hex::decode("01C0F0f4ab324C46e55D02D0033343B4Be8A55532d").unwrap().as_slice(),
-		);
-		let asset2 = U256::from(
-			hex::decode("03C0F0f4ab324C46e55D02D0033343B4Be8A55532d").unwrap().as_slice(),
-		);
-		assert_ne!(asset1, asset2);
-
-		// check asset in decimal format
-		assert_eq!(
-			U256::from_str_radix("01C0F0f4ab324C46e55D02D0033343B4Be8A55532d", 16).unwrap(),
-			U256::from_dec_str("2563001357829637001682277476112176020532353127213").unwrap()
-		);
-		assert_eq!(
-			U256::from_str_radix("03C0F0f4ab324C46e55D02D0033343B4Be8A55532d", 16).unwrap(),
-			U256::from_dec_str("5486004632491442838089647141544742059844218213165").unwrap()
-		);
-
-		let mut owner = [0u8; 20];
-		owner.copy_from_slice(
-			hex::decode("C0F0f4ab324C46e55D02D0033343B4Be8A55532d").unwrap().as_slice(),
-		);
-		let expected_address = H160::from(owner);
-		assert_eq!(convert_asset_id_to_owner(asset1), expected_address);
-		assert_eq!(convert_asset_id_to_owner(asset2), expected_address);
-	}
-}

pallets/living-assets-ownership/src/lib.rs

@@ -5,23 +5,22 @@
 /// <https://docs.substrate.io/reference/frame-pallets/>
 pub use pallet::*;
 use parity_scale_codec::alloc::string::ToString;
-use sp_core::{H160, U256};
+use sp_core::H160;
 use sp_std::vec::Vec;
-
 mod functions;
 pub mod traits;
 
 #[frame_support::pallet]
 pub mod pallet {
 
-	use crate::functions::convert_asset_id_to_owner;
-
 	use super::*;
+	use crate::traits::{AccountMapping, AssetIdToAddress};
 	use frame_support::{
 		pallet_prelude::{OptionQuery, ValueQuery, *},
 		BoundedVec,
 	};
 	use frame_system::pallet_prelude::*;
+	use sp_core::{H160, U256};
 
 	/// Collection id type
 	pub type CollectionId = u64;
@@ -39,7 +38,7 @@ pub mod pallet {
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
 		/// Specifies the advised maximum length for a Base URI.
-		//s
+		///
 		/// The URI standard (RFC 3986) doesn't dictates a limit for the length of URIs.
 		/// However it seems the max supported length in browsers is 2,048 characters.
 		///
@@ -48,6 +47,14 @@ pub mod pallet {
 		/// (which takes up 33 characters).
 		#[pallet::constant]
 		type BaseURILimit: Get<u32>;
+
+		/// Type alias for implementing the `AccountMapping` trait for a given account ID type.
+		/// This allows you to define custom logic for converting between account IDs and H160 addresses.
+		type AccountMapping: traits::AccountMapping<Self::AccountId>;
+
+		/// Type alias for implementing the `AssetIdToAddress` trait for a given account ID type.
+		/// This allows you to specify which account should initially own each new asset.
+		type AssetIdToAddress: traits::AssetIdToAddress<Self::AccountId>;
 	}
 
 	/// Collection counter
@@ -64,10 +71,10 @@ pub mod pallet {
 	/// Asset owner
 	#[pallet::storage]
 	pub(super) type AssetOwner<T: Config> =
-		StorageMap<_, Blake2_128Concat, U256, H160, OptionQuery>;
+		StorageMap<_, Blake2_128Concat, U256, T::AccountId, OptionQuery>;
 
-	fn asset_owner<T: Config>(key: U256) -> H160 {
-		AssetOwner::<T>::get(key).unwrap_or_else(|| convert_asset_id_to_owner(key))
+	fn asset_owner<T: Config>(key: U256) -> T::AccountId {
+		AssetOwner::<T>::get(key).unwrap_or_else(|| T::AssetIdToAddress::initial_owner(key))
 	}
 
 	/// Pallet events
@@ -79,7 +86,7 @@ pub mod pallet {
 		CollectionCreated { collection_id: CollectionId, who: T::AccountId },
 		/// Asset transferred to `who`
 		/// parameters. [asset_id_id, who]
-		AssetTransferred { asset_id: U256, receiver: H160 },
+		AssetTransferred { asset_id: U256, receiver: T::AccountId },
 	}
 
 	// Errors inform users that something went wrong.
@@ -153,7 +160,7 @@ pub mod pallet {
 
 		fn owner_of(collection_id: CollectionId, asset_id: U256) -> Result<H160, Self::Error> {
 			Pallet::<T>::collection_base_uri(collection_id).ok_or(Error::CollectionDoesNotExist)?;
-			Ok(asset_owner::<T>(asset_id))
+			Ok(T::AccountMapping::into_h160(asset_owner::<T>(asset_id)))
 		}
 
 		fn transfer_from(
@@ -165,10 +172,14 @@ pub mod pallet {
 		) -> Result<(), Self::Error> {
 			Pallet::<T>::collection_base_uri(collection_id).ok_or(Error::CollectionDoesNotExist)?;
 			ensure!(origin == from, Error::NoPermission);
-			ensure!(asset_owner::<T>(asset_id) == from, Error::NoPermission);
+			ensure!(
+				T::AccountMapping::into_h160(asset_owner::<T>(asset_id)) == from,
+				Error::NoPermission
+			);
 			ensure!(from != to, Error::CannotTransferSelf);
 			ensure!(to != H160::zero(), Error::TransferToNullAddress);
 
+			let to = T::AccountMapping::into_account_id(to.clone());
 			AssetOwner::<T>::set(asset_id, Some(to.clone()));
 			Self::deposit_event(Event::AssetTransferred { asset_id, receiver: to });
 
@@ -217,7 +228,10 @@ pub enum CollectionError {
 /// # Returns
 ///
 /// * An `H160` representation of the collection ID.
-pub fn collection_id_to_address(collection_id: CollectionId) -> H160 {
+pub fn collection_id_to_address(collection_id: CollectionId) -> H160
+// where
+// 	T::AccountId: From<[u8; 20]>,
+{
 	let mut bytes = [0u8; 20];
 	bytes[12..20].copy_from_slice(&collection_id.to_be_bytes());
 	for (i, byte) in ASSET_PRECOMPILE_ADDRESS_PREFIX.iter().enumerate() {

pallets/living-assets-ownership/src/mock.rs

@@ -1,6 +1,6 @@
-use crate as pallet_livingassets_ownership;
+use crate::{self as pallet_livingassets_ownership, traits};
 use frame_support::traits::{ConstU16, ConstU64};
-use sp_core::{ConstU32, H256};
+use sp_core::{ConstU32, H160, H256, U256};
 use sp_runtime::{
 	traits::{BlakeTwo256, IdentityLookup},
 	BuildStorage,
@@ -9,6 +9,7 @@ use sp_std::{boxed::Box, prelude::*};
 
 type Block = frame_system::mocking::MockBlock<Test>;
 type Nonce = u32;
+type AccountId = u64;
 
 // Configure a mock runtime to test the pallet.
 frame_support::construct_runtime!(
@@ -30,7 +31,7 @@ impl frame_system::Config for Test {
 	type Hash = H256;
 	type Nonce = Nonce;
 	type Hashing = BlakeTwo256;
-	type AccountId = u64;
+	type AccountId = AccountId;
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type RuntimeEvent = RuntimeEvent;
 	type BlockHashCount = ConstU64<250>;
@@ -48,6 +49,28 @@ impl frame_system::Config for Test {
 impl pallet_livingassets_ownership::Config for Test {
 	type RuntimeEvent = RuntimeEvent;
 	type BaseURILimit = ConstU32<256>;
+	type AccountMapping = MockAccountMapping;
+	type AssetIdToAddress = MockAssetIdToAddress;
+}
+
+pub struct MockAccountMapping;
+impl traits::AccountMapping<AccountId> for MockAccountMapping {
+	fn into_h160(account_id: AccountId) -> H160 {
+		H160::from_low_u64_be(account_id)
+	}
+	fn into_account_id(account_id: H160) -> AccountId {
+		H160::to_low_u64_be(&account_id)
+	}
+}
+
+pub struct MockAssetIdToAddress;
+impl traits::AssetIdToAddress<AccountId> for MockAssetIdToAddress {
+	fn initial_owner(asset_id: U256) -> AccountId {
+		let mut first_eight_bytes = [0u8; 8];
+		let asset_id_bytes: [u8; 32] = asset_id.into();
+		first_eight_bytes.copy_from_slice(&asset_id_bytes[asset_id_bytes.len() - 8..]);
+		u64::from_be_bytes(first_eight_bytes).into()
+	}
 }
 
 // Build genesis storage according to the mock runtime.

pallets/living-assets-ownership/src/tests.rs

@@ -1,9 +1,8 @@
-use core::str::FromStr;
-
 use crate::{
 	address_to_collection_id, collection_id_to_address, is_collection_address, mock::*, AssetOwner,
 	CollectionBaseURI, CollectionError, Event,
 };
+use core::str::FromStr;
 use frame_support::assert_ok;
 use sp_core::H160;
 
@@ -339,7 +338,7 @@ mod traits {
 		let asset_id = U256::from(
 			hex::decode("03C0F0f4ab324C46e55D02D0033343B4Be8A55532d").unwrap().as_slice(),
 		);
-		let sender = H160::from_str("C0F0f4ab324C46e55D02D0033343B4Be8A55532d").unwrap();
+		let sender = H160::from_str("0000000000000000000000003343b4be8a55532d").unwrap();
 		let receiver = H160::from_low_u64_be(BOB);
 		new_test_ext().execute_with(|| {
 			System::set_block_number(1);
@@ -349,9 +348,9 @@ mod traits {
 			assert_ok!(<LivingAssetsModule as Erc721>::transfer_from(
 				sender, 1, sender, receiver, asset_id,
 			));
-			assert_eq!(AssetOwner::<Test>::get(asset_id).unwrap(), receiver);
+			assert_eq!(AssetOwner::<Test>::get(asset_id).unwrap(), BOB);
 			assert_eq!(<LivingAssetsModule as Erc721>::owner_of(1, asset_id).unwrap(), receiver);
-			System::assert_last_event(Event::AssetTransferred { asset_id, receiver }.into());
+			System::assert_last_event(Event::AssetTransferred { asset_id, receiver: BOB }.into());
 		});
 	}
 

pallets/living-assets-ownership/src/traits.rs

@@ -96,3 +96,44 @@ pub trait Erc721 {
 		asset_id: U256,
 	) -> Result<(), Self::Error>;
 }
+
+/// A trait defining the mapping between a generic account ID and an H160 address.
+/// This is useful for compatibility with Ethereum-like networks.
+pub trait AccountMapping<AccountId> {
+	/// Converts a generic account ID into an H160 address.
+	///
+	/// # Arguments
+	///
+	/// * `account_id` - The generic account ID to convert.
+	///
+	/// # Returns
+	///
+	/// Returns the H160 address corresponding to the input account ID.
+	fn into_h160(account_id: AccountId) -> H160;
+
+	/// Converts an H160 address into a generic account ID.
+	///
+	/// # Arguments
+	///
+	/// * `account_id` - The H160 address to convert.
+	///
+	/// # Returns
+	///
+	/// Returns the generic account ID corresponding to the input H160 address.
+	fn into_account_id(account_id: H160) -> AccountId;
+}
+
+/// A trait for associating a given asset ID to an initial account ID.
+/// Useful for specifying which account should initially own a new asset.
+pub trait AssetIdToAddress<AccountId> {
+	/// Determines the initial owner of an asset given its ID.
+	///
+	/// # Arguments
+	///
+	/// * `asset_id` - The asset ID to query for its initial owner.
+	///
+	/// # Returns
+	///
+	/// Returns the account ID of the initial owner of the asset.
+	fn initial_owner(asset_id: U256) -> AccountId;
+}

runtime/Cargo.toml

@@ -17,6 +17,7 @@ substrate-wasm-builder = { workspace = true, optional = true }
 [dependencies]
 parity-scale-codec = { workspace = true, features = ["derive"] }
 hex-literal = { workspace = true, optional = true }
+hex = { workspace = true }
 scale-info = { workspace = true, features = ["derive"] }
 smallvec = { workspace = true }
 

runtime/src/lib.rs

@@ -6,6 +6,7 @@
 #[cfg(feature = "std")]
 include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
 
+mod tests;
 mod weights;
 pub mod xcm_config;
 use parity_scale_codec as codec;
@@ -28,7 +29,7 @@ use sp_runtime::{
 		IdentifyAccount, PostDispatchInfoOf, UniqueSaturatedInto, Verify,
 	},
 	transaction_validity::{TransactionSource, TransactionValidity, TransactionValidityError},
-	ApplyExtrinsicResult, ConsensusEngineId,
+	AccountId32, ApplyExtrinsicResult, ConsensusEngineId, MultiSignature,
 };
 
 use sp_std::prelude::*;
@@ -469,6 +470,8 @@ impl pallet_collator_selection::Config for Runtime {
 impl pallet_living_assets_ownership::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type BaseURILimit = ConstU32<2015>;
+	type AccountMapping = AccountMapping;
+	type AssetIdToAddress = AssetIdToAddress;
 }
 
 impl pallet_sudo::Config for Runtime {
@@ -477,6 +480,34 @@ impl pallet_sudo::Config for Runtime {
 	type WeightInfo = ();
 }
 
+pub struct AccountMapping;
+impl pallet_living_assets_ownership::traits::AccountMapping<AccountId> for AccountMapping {
+	fn into_h160(account_id: AccountId) -> H160 {
+		let mut bytes = [0u8; 20];
+		let account_id_bytes: [u8; 32] = account_id.into();
+		bytes.copy_from_slice(&account_id_bytes[account_id_bytes.len() - 20..]);
+		H160::from(bytes)
+	}
+	fn into_account_id(account_id: H160) -> AccountId {
+		let mut data = [0u8; 32];
+		data[12..].copy_from_slice(&account_id.0);
+		AccountId32::from(data)
+	}
+}
+
+pub struct AssetIdToAddress;
+impl pallet_living_assets_ownership::traits::AssetIdToAddress<AccountId> for AssetIdToAddress {
+	fn initial_owner(asset_id: U256) -> AccountId {
+		let mut bytes = [0u8; 20];
+		let asset_id_bytes: [u8; 32] = asset_id.into();
+		bytes.copy_from_slice(&asset_id_bytes[asset_id_bytes.len() - 20..]);
+		let owner = H160::from(bytes);
+		<AccountMapping as pallet_living_assets_ownership::traits::AccountMapping<AccountId>>::into_account_id(
+			owner,
+		)
+	}
+}
+
 // Frontier
 
 impl pallet_evm_chain_id::Config for Runtime {}