precompile erc 721 only owner_of

Cargo.toml

@@ -222,6 +222,7 @@ pallet-bridge-relayers = { git = "https://github.com/freeverseio/parity-bridges-
 # LAOS pallets
 pallet-living-assets-ownership = { path = "./pallets/living-assets-ownership", default-features = false }
 pallet-evm-living-assets-ownership = { path = "./precompile/living-assets", default-features = false }
+pallet-evm-erc721 = { path = "./precompile/erc721", default-features = false }
 
 # Utils
 precompile-utils = { path = "./precompile/utils", default-features = false }

pallets/living-assets-ownership/Cargo.toml

@@ -12,6 +12,7 @@ edition = "2021"
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
+hex-literal = { workspace = true, optional = true}
 parity-scale-codec = { workspace = true, features = ["derive"] }
 scale-info = { workspace = true, features = ["derive"] }
 
@@ -20,9 +21,11 @@ frame-benchmarking = { workspace = true, optional = true }
 frame-support = { workspace = true }
 frame-system = { workspace = true }
 sp-arithmetic = { workspace = true }
+sp-core = { workspace = true }
 
 [dev-dependencies]
 serde = { workspace = true }
+hex = { version = "0.4.3" }
 
 # Substrate
 sp-core = { workspace = true }
@@ -42,7 +45,8 @@ std = [
 	"frame-benchmarking/std",
 	"frame-support/std",
 	"frame-system/std",
-	"sp-arithmetic/std"
+	"sp-arithmetic/std",
+	"sp-core/std",
 ]
 try-runtime = [
 	"frame-system/try-runtime",

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

@@ -1,6 +1,7 @@
 //! 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]
@@ -23,3 +24,22 @@ 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 super::*;
+
+	#[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);
+	}
+}

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

@@ -4,15 +4,19 @@
 /// Learn more about FRAME and the core library of Substrate FRAME pallets:
 /// <https://docs.substrate.io/reference/frame-pallets/>
 pub use pallet::*;
+use sp_core::H160;
 
 mod functions;
 pub mod traits;
 
 #[frame_support::pallet]
 pub mod pallet {
+	use crate::functions::convert_asset_id_to_owner;
+
 	use super::*;
 	use frame_support::pallet_prelude::{OptionQuery, ValueQuery, *};
 	use frame_system::pallet_prelude::*;
+	use sp_core::{H160, U256};
 
 	/// Collection id type
 	/// TODO: use 256 bits
@@ -83,6 +87,89 @@ pub mod pallet {
 			Self::do_create_collection(owner)
 		}
 	}
+
+	impl<T: Config> traits::Erc721 for Pallet<T> {
+		fn owner_of(collection_id: CollectionId, asset_id: U256) -> Result<H160, &'static str> {
+			match OwnerOfCollection::<T>::get(collection_id) {
+				Some(_) => Ok(convert_asset_id_to_owner(asset_id)),
+				None => Err("Collection does not exist"),
+			}
+		}
+	}
+}
+
+/// `ASSET_PRECOMPILE_ADDRESS_PREFIX` is a predefined prefix used to identify collection addresses.
+///
+/// All addresses that start with this prefix are considered as collection addresses.
+/// Since `CollectionId` is represented as a `u64`, it leaves these bits free to be
+/// utilized for such a prefix.
+///
+/// Usage of this prefix provides a consistent and recognizable pattern for distinguishing
+/// collection addresses from other types of addresses in the system.
+pub const ASSET_PRECOMPILE_ADDRESS_PREFIX: &[u8] = &[0xff; 12];
+
+/// Enum representing possible errors related to collections.
+#[derive(Debug, PartialEq)]
+pub enum CollectionError {
+	/// Error indicating that the provided address does not have the correct prefix.
+	InvalidPrefix,
+}
+
+/// Converts a `CollectionId` into an `H160` address format.
+///
+/// This function takes the given `CollectionId`, which is assumed to be a `u64`,
+/// and maps it into an `H160` address, prepending it with the `ASSET_PRECOMPILE_ADDRESS_PREFIX`.
+///
+/// # Arguments
+///
+/// * `collection_id`: The ID of the collection to be converted.
+///
+/// # Returns
+///
+/// * An `H160` representation of the collection ID.
+pub fn collection_id_to_address(collection_id: CollectionId) -> H160 {
+	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() {
+		bytes[i] = *byte;
+	}
+	H160(bytes)
+}
+
+/// Converts an `H160` address into a `CollectionId` format.
+///
+/// This function takes the given `H160` address, checks for the correct prefix, and extracts
+/// the `CollectionId` from it. If the prefix is incorrect, it returns a `CollectionError::InvalidPrefix` error.
+///
+/// # Arguments
+///
+/// * `address`: The `H160` address to be converted.
+///
+/// # Returns
+///
+/// * A `Result` which is either the `CollectionId` or an error indicating the address is invalid.
+pub fn address_to_collection_id(address: H160) -> Result<CollectionId, CollectionError> {
+	if &address.0[0..12] != ASSET_PRECOMPILE_ADDRESS_PREFIX {
+		return Err(CollectionError::InvalidPrefix);
+	}
+	let id_bytes: [u8; 8] = address.0[12..].try_into().unwrap();
+	Ok(CollectionId::from_be_bytes(id_bytes))
+}
+
+/// Checks if a given `H160` address is a collection address.
+///
+/// This function examines the prefix of the given `H160` address to determine if it is a
+/// collection address, based on the `ASSET_PRECOMPILE_ADDRESS_PREFIX`.
+///
+/// # Arguments
+///
+/// * `address`: The `H160` address to be checked.
+///
+/// # Returns
+///
+/// * A boolean indicating if the address is a collection address.
+pub fn is_collection_address(address: H160) -> bool {
+	&address.to_fixed_bytes()[0..12] == ASSET_PRECOMPILE_ADDRESS_PREFIX
 }
 
 #[cfg(test)]

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

@@ -1,5 +1,13 @@
-use crate::{mock::*, traits::CollectionManager, Event};
+use core::str::FromStr;
+
+use crate::{
+	address_to_collection_id, collection_id_to_address, is_collection_address,
+	mock::*,
+	traits::{CollectionManager, Erc721},
+	CollectionError, Event,
+};
 use frame_support::assert_ok;
+use sp_core::H160;
 
 type AccountId = <Test as frame_system::Config>::AccountId;
 
@@ -107,3 +115,61 @@ fn living_assets_ownership_trait_id_of_new_collection_should_be_consecutive() {
 		);
 	});
 }
+
+#[test]
+fn erc721_owner_of_asset_of_unexistent_collection() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(
+			<LivingAssetsModule as Erc721>::owner_of(0, 2.into()),
+			Err("Collection does not exist")
+		);
+	});
+}
+
+#[test]
+fn erc721_owner_of_asset_of_collection() {
+	new_test_ext().execute_with(|| {
+		let collection_id =
+			<LivingAssetsModule as CollectionManager<AccountId>>::create_collection(ALICE).unwrap();
+		assert_eq!(
+			<LivingAssetsModule as Erc721>::owner_of(collection_id, 2.into()).unwrap(),
+			H160::from_low_u64_be(0x0000000000000002)
+		);
+	});
+}
+
+#[test]
+fn test_collection_id_to_address() {
+	let collection_id = 5;
+	let expected_address = H160::from_str("ffffffffffffffffffffffff0000000000000005").unwrap();
+	assert_eq!(collection_id_to_address(collection_id), expected_address);
+}
+
+#[test]
+fn invalid_collection_address_should_error() {
+	let address = H160::from_str("8000000000000000000000000000000000000005").unwrap();
+	let error = address_to_collection_id(address).unwrap_err();
+	assert_eq!(error, CollectionError::InvalidPrefix);
+}
+
+#[test]
+fn valid_collection_address_should_return_collection_id() {
+	let address = H160::from_str("ffffffffffffffffffffffff0000000000000005").unwrap();
+	let collection_id = address_to_collection_id(address).unwrap();
+	assert_eq!(collection_id, 5);
+}
+
+#[test]
+fn test_is_collection_address_valid() {
+	let collection_id = 1234567890;
+	let address = collection_id_to_address(collection_id);
+
+	assert!(is_collection_address(address));
+}
+
+#[test]
+fn test_is_collection_address_invalid() {
+	let invalid_address = H160([0u8; 20]);
+
+	assert!(!is_collection_address(invalid_address));
+}

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

@@ -1,3 +1,5 @@
+use sp_core::{H160, U256};
+
 use crate::CollectionId;
 
 /// The `CollectionManager` trait provides an interface for managing collections in a
@@ -25,3 +27,22 @@ pub trait CollectionManager<AccountId> {
 	/// Create collection
 	fn create_collection(owner: AccountId) -> Result<CollectionId, &'static str>;
 }
+
+/// `Erc721` Trait
+///
+/// This trait provides an interface for handling ERC721 tokens, a standard for non-fungible tokens on the blockchain.
+pub trait Erc721 {
+	/// Retrieves the owner of a specific asset in a collection.
+	///
+	/// # Parameters
+	///
+	/// * `collection_id`: An identifier for the collection to which the asset belongs.
+	/// * `asset_id`: The unique identifier for the asset within the specified collection.
+	///
+	/// # Returns
+	///
+	/// * A `Result` which is:
+	///   - `Ok(H160)`: Returns the Ethereum address (`H160`) of the owner of the asset.
+	///   - `Err(&'static str)`: Returns an error message if the asset owner could not be determined.
+	fn owner_of(collection_id: CollectionId, asset_id: U256) -> Result<H160, &'static str>;
+}

precompile/erc721/Cargo.toml

@@ -0,0 +1,55 @@
+[package]
+name = "pallet-evm-erc721"
+version = "0.0.1"
+edition = "2021"
+
+[dependencies]
+parity-scale-codec = { workspace = true, features = [
+	"derive",
+] }
+scale-info = { workspace = true, features = [
+	"derive",
+] }
+
+# Frontier
+fp-evm = { workspace = true }
+pallet-evm = { workspace = true }
+
+# Substrate
+frame-support = { workspace = true }
+sp-arithmetic = { workspace = true }
+sp-core = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
+
+# Local pallet
+pallet-living-assets-ownership = { workspace = true }
+
+# Utils
+precompile-utils = { workspace = true }
+precompile-utils-macro = { workspace = true }
+
+num_enum = { workspace = true }
+
+[dev-dependencies]
+evm = { workspace = true }
+hex = { version = "0.4.3" }
+precompile-utils = { workspace = true, features = ["testing"]}
+
+[features]
+default = ["std"]
+std = [
+	# Frontier
+	"fp-evm/std",
+	"pallet-evm/std",
+	"sp-core/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"pallet-living-assets-ownership/std",
+	"num_enum/std",
+	"frame-support/std",
+	"sp-arithmetic/std",
+	"precompile-utils/std",
+	"parity-scale-codec/std",
+	"scale-info/std",
+]

precompile/erc721/contracts/IERC721.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+// derived from OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)
+pragma solidity >=0.8.3;
+
+interface IERC721 {
+    /**
+     * @dev See {IERC721Metadata-tokenURI}.
+     */
+    function tokenURI(uint256 _tokenId) external view returns (string memory);
+
+    function ownerOf(uint256 _tokenId) external view returns (address);
+}