Feature/precompile erc 721 transfer from

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

@@ -35,12 +35,42 @@ pub fn convert_asset_id_to_owner(value: U256) -> H160 {
 
 #[cfg(test)]
 mod tests {
-	use super::*;
+	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

@@ -13,6 +13,7 @@ pub mod traits;
 
 #[frame_support::pallet]
 pub mod pallet {
+
 	use crate::functions::convert_asset_id_to_owner;
 
 	use super::*;
@@ -60,13 +61,25 @@ pub mod pallet {
 	pub(super) type CollectionBaseURI<T: Config> =
 		StorageMap<_, Blake2_128Concat, CollectionId, BaseURI<T>, OptionQuery>;
 
+	/// Asset owner
+	#[pallet::storage]
+	pub(super) type AssetOwner<T: Config> =
+		StorageMap<_, Blake2_128Concat, U256, H160, OptionQuery>;
+
+	fn asset_owner<T: Config>(key: U256) -> H160 {
+		AssetOwner::<T>::get(key).unwrap_or_else(|| convert_asset_id_to_owner(key))
+	}
+
 	/// Pallet events
 	#[pallet::event]
 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
 	pub enum Event<T: Config> {
 		/// Collection created
 		/// parameters. [collection_id, who]
 		CollectionCreated { collection_id: CollectionId, who: T::AccountId },
+		/// Asset transferred to `who`
+		/// parameters. [asset_id_id, who]
+		AssetTransferred { asset_id: U256, receiver: H160 },
 	}
 
 	// Errors inform users that something went wrong.
@@ -75,16 +88,28 @@ pub mod pallet {
 	pub enum Error<T> {
 		/// Collection id overflow
 		CollectionIdOverflow,
-		/// Unexistent collection
-		UnexistentCollection,
+		/// Collection does not exist
+		CollectionDoesNotExist,
+		// NoPermission,
+		NoPermission,
+		// AssetDoesNotExist,
+		AssetDoesNotExist,
+		// CannotTransferSelf,
+		CannotTransferSelf,
+		// TransferToNullAddress,
+		TransferToNullAddress,
 	}
 
 	impl<T: Config> AsRef<[u8]> for Error<T> {
 		fn as_ref(&self) -> &[u8] {
 			match self {
 				Error::__Ignore(_, _) => b"__Ignore",
 				Error::CollectionIdOverflow => b"CollectionIdOverflow",
-				Error::UnexistentCollection => b"UnexistentCollection",
+				Error::CollectionDoesNotExist => b"CollectionDoesNotExist",
+				Error::NoPermission => b"NoPermission",
+				Error::AssetDoesNotExist => b"AssetDoesNotExist",
+				Error::CannotTransferSelf => b"CannotTransferSelf",
+				Error::TransferToNullAddress => b"TransferToNullAddress",
 			}
 		}
 	}
@@ -127,15 +152,32 @@ pub mod pallet {
 		type Error = Error<T>;
 
 		fn owner_of(collection_id: CollectionId, asset_id: U256) -> Result<H160, Self::Error> {
-			match CollectionBaseURI::<T>::get(collection_id) {
-				Some(_) => Ok(convert_asset_id_to_owner(asset_id)),
-				None => Err(Error::UnexistentCollection),
-			}
+			Pallet::<T>::collection_base_uri(collection_id).ok_or(Error::CollectionDoesNotExist)?;
+			Ok(asset_owner::<T>(asset_id))
+		}
+
+		fn transfer_from(
+			origin: H160,
+			collection_id: CollectionId,
+			from: H160,
+			to: H160,
+			asset_id: U256,
+		) -> 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!(from != to, Error::CannotTransferSelf);
+			ensure!(to != H160::zero(), Error::TransferToNullAddress);
+
+			AssetOwner::<T>::set(asset_id, Some(to.clone()));
+			Self::deposit_event(Event::AssetTransferred { asset_id, receiver: to });
+
+			Ok(())
 		}
 
 		fn token_uri(collection_id: CollectionId, asset_id: U256) -> Result<Vec<u8>, Self::Error> {
 			let base_uri = Pallet::<T>::collection_base_uri(collection_id)
-				.ok_or(Error::UnexistentCollection)?;
+				.ok_or(Error::CollectionDoesNotExist)?;
 
 			// concatenate base_uri with asset_id
 			let mut token_uri = base_uri.to_vec();

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

@@ -5,6 +5,7 @@ use sp_runtime::{
 	traits::{BlakeTwo256, IdentityLookup},
 	BuildStorage,
 };
+use sp_std::{boxed::Box, prelude::*};
 
 type Block = frame_system::mocking::MockBlock<Test>;
 type Nonce = u32;

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

@@ -1,16 +1,17 @@
 use core::str::FromStr;
 
 use crate::{
-	address_to_collection_id, collection_id_to_address, is_collection_address, mock::*,
-	CollectionError, Event,
+	address_to_collection_id, collection_id_to_address, is_collection_address, mock::*, AssetOwner,
+	CollectionBaseURI, CollectionError, Event,
 };
 use frame_support::assert_ok;
 use sp_core::H160;
 
-type AccountId = <Test as frame_system::Config>::AccountId;
 type BaseURI = crate::BaseURI<Test>;
+type AccountId = <Test as frame_system::Config>::AccountId;
 
 const ALICE: AccountId = 0x1234;
+const BOB: AccountId = 0x2234;
 
 #[test]
 fn base_uri_unexistent_collection_is_none() {
@@ -126,7 +127,8 @@ mod traits {
 		traits::{CollectionManager, Erc721},
 		Error, Event,
 	};
-	use frame_support::{assert_err, assert_ok};
+	use frame_support::{assert_err, assert_noop, assert_ok};
+	use sp_core::U256;
 
 	#[test]
 	fn base_uri_of_unexistent_collection_is_none() {
@@ -223,7 +225,7 @@ mod traits {
 	fn owner_of_asset_of_unexistent_collection_should_error() {
 		new_test_ext().execute_with(|| {
 			let result = <LivingAssetsModule as Erc721>::owner_of(0, 2.into());
-			assert_err!(result, Error::UnexistentCollection);
+			assert_err!(result, Error::CollectionDoesNotExist);
 		});
 	}
 
@@ -242,11 +244,122 @@ mod traits {
 		});
 	}
 
+	#[test]
+	fn caller_is_not_current_owner_should_fail() {
+		let asset_id = U256::from(5);
+		let sender = H160::from_str("0000000000000000000000000000000000000006").unwrap();
+		let receiver = H160::from_low_u64_be(BOB);
+		new_test_ext().execute_with(|| {
+			System::set_block_number(1);
+			assert!(AssetOwner::<Test>::get(asset_id).is_none());
+			CollectionBaseURI::<Test>::insert(1, BaseURI::default());
+			assert_noop!(
+				<LivingAssetsModule as Erc721>::transfer_from(
+					H160::from_low_u64_be(ALICE),
+					1,
+					sender,
+					receiver,
+					asset_id,
+				),
+				Error::<Test>::NoPermission
+			);
+		});
+	}
+
+	#[test]
+	fn sender_is_not_current_owner_should_fail() {
+		let asset_id = U256::from(5);
+		let sender = H160::from_str("0000000000000000000000000000000000000006").unwrap();
+		let receiver = H160::from_low_u64_be(BOB);
+		new_test_ext().execute_with(|| {
+			System::set_block_number(1);
+			assert!(AssetOwner::<Test>::get(asset_id).is_none());
+			CollectionBaseURI::<Test>::insert(1, BaseURI::default());
+			assert_noop!(
+				<LivingAssetsModule as Erc721>::transfer_from(
+					sender, 1, sender, receiver, asset_id,
+				),
+				Error::<Test>::NoPermission
+			);
+		});
+	}
+
+	#[test]
+	fn same_sender_and_receiver_should_fail() {
+		let asset_id = U256::from(5);
+		let sender = H160::from_str("0000000000000000000000000000000000000005").unwrap();
+		new_test_ext().execute_with(|| {
+			System::set_block_number(1);
+			assert!(AssetOwner::<Test>::get(asset_id).is_none());
+			CollectionBaseURI::<Test>::insert(1, BaseURI::default());
+			assert_noop!(
+				<LivingAssetsModule as Erc721>::transfer_from(sender, 1, sender, sender, asset_id,),
+				Error::<Test>::CannotTransferSelf
+			);
+		});
+	}
+
+	#[test]
+	fn receiver_is_the_zero_address_should_fail() {
+		let asset_id = U256::from(5);
+		let sender = H160::from_str("0000000000000000000000000000000000000005").unwrap();
+		let receiver = H160::from_str("0000000000000000000000000000000000000000").unwrap();
+		new_test_ext().execute_with(|| {
+			System::set_block_number(1);
+			assert!(AssetOwner::<Test>::get(asset_id).is_none());
+			CollectionBaseURI::<Test>::insert(1, BaseURI::default());
+			assert_noop!(
+				<LivingAssetsModule as Erc721>::transfer_from(
+					sender, 1, sender, receiver, asset_id,
+				),
+				Error::<Test>::TransferToNullAddress
+			);
+		});
+	}
+
+	#[test]
+	fn unexistent_collection_when_transfer_from_should_fail() {
+		let asset_id = U256::from(5);
+		let sender = H160::from_str("0000000000000000000000000000000000000005").unwrap();
+		let receiver = H160::from_low_u64_be(BOB);
+		new_test_ext().execute_with(|| {
+			System::set_block_number(1);
+			assert!(AssetOwner::<Test>::get(asset_id).is_none());
+			assert_noop!(
+				<LivingAssetsModule as Erc721>::transfer_from(
+					sender, 1, sender, receiver, asset_id,
+				),
+				Error::<Test>::CollectionDoesNotExist
+			);
+		});
+	}
+
+	#[test]
+	fn sucessful_transfer_from_trait_should_work() {
+		let asset_id = U256::from(
+			hex::decode("03C0F0f4ab324C46e55D02D0033343B4Be8A55532d").unwrap().as_slice(),
+		);
+		let sender = H160::from_str("C0F0f4ab324C46e55D02D0033343B4Be8A55532d").unwrap();
+		let receiver = H160::from_low_u64_be(BOB);
+		new_test_ext().execute_with(|| {
+			System::set_block_number(1);
+			CollectionBaseURI::<Test>::insert(1, BaseURI::default());
+			assert!(AssetOwner::<Test>::get(asset_id).is_none());
+			assert_eq!(<LivingAssetsModule as Erc721>::owner_of(1, asset_id).unwrap(), sender);
+			assert_ok!(<LivingAssetsModule as Erc721>::transfer_from(
+				sender, 1, sender, receiver, asset_id,
+			));
+			assert_eq!(AssetOwner::<Test>::get(asset_id).unwrap(), receiver);
+			assert_eq!(<LivingAssetsModule as Erc721>::owner_of(1, asset_id).unwrap(), receiver);
+			System::assert_last_event(Event::AssetTransferred { asset_id, receiver }.into());
+		});
+	}
+
 	#[test]
 	fn token_uri_of_unexistent_collection() {
 		new_test_ext().execute_with(|| {
 			let result = <LivingAssetsModule as Erc721>::token_uri(0, 2.into());
-			assert_err!(result, Error::UnexistentCollection);
+			assert_err!(result, Error::CollectionDoesNotExist);
 		});
 	}
 

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

@@ -72,11 +72,27 @@ pub trait Erc721 {
 	///
 	/// # Arguments
 	///
-	/// * `collection_id` - The unique identifier for the collection.
 	/// * `asset_id` - The unique identifier for the asset within the collection.
 	///
 	/// # Returns
 	///
 	/// A `Vec<u8>` representing the URI of the asset or an error if retrieval fails.
 	fn token_uri(collection_id: CollectionId, asset_id: U256) -> Result<Vec<u8>, Self::Error>;
+
+	/// Transfers the ownership of a asset from one address to another address
+	///
+	/// # Arguments
+	///
+	/// * `origin` - The caller's address.
+	/// * `collection_id` - The unique identifier for the collection.
+	/// * `from` - The current owner of the asset.
+	/// * `to` - The new owner.
+	/// * `asset_id` - The unique identifier for the asset within the collection.
+	fn transfer_from(
+		origin: H160,
+		collection_id: CollectionId,
+		from: H160,
+		to: H160,
+		asset_id: U256,
+	) -> Result<(), Self::Error>;
 }

precompile/erc721/contracts/IERC721.sol

@@ -9,4 +9,8 @@ interface IERC721 {
     function tokenURI(uint256 _tokenId) external view returns (string memory);
 
     function ownerOf(uint256 _tokenId) external view returns (address);
+
+    event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
+
+    function transferFrom(address _from, address _to, uint256 _tokenId) external;
 }