git.delta.rocks / unique-network / refs/commits / 369a51ded768

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617// Original License18use std::sync::Arc;1920use codec::Decode;21use jsonrpsee::{22	core::{RpcResult as Result},23	proc_macros::rpc,24};25use anyhow::anyhow;26use sp_runtime::traits::{AtLeast32BitUnsigned, Member};27use up_data_structs::{28	RpcCollection, CollectionId, CollectionStats, CollectionLimits, TokenId, Property,29	PropertyKeyPermission, TokenData, TokenChild,30};31use sp_api::{BlockT, ProvideRuntimeApi, ApiExt};32use sp_blockchain::HeaderBackend;33use up_rpc::UniqueApi as UniqueRuntimeApi;34use app_promotion_rpc::AppPromotionApi as AppPromotionRuntimeApi;3536pub use app_promotion_unique_rpc::AppPromotionApiServer;3738#[cfg(feature = "pov-estimate")]39pub mod pov_estimate;4041#[rpc(server)]42#[async_trait]43pub trait UniqueApi<BlockHash, CrossAccountId, AccountId> {44	/// Get tokens owned by account.45	#[method(name = "unique_accountTokens")]46	fn account_tokens(47		&self,48		collection: CollectionId,49		account: CrossAccountId,50		at: Option<BlockHash>,51	) -> Result<Vec<TokenId>>;5253	/// Get tokens contained within a collection.54	#[method(name = "unique_collectionTokens")]55	fn collection_tokens(56		&self,57		collection: CollectionId,58		at: Option<BlockHash>,59	) -> Result<Vec<TokenId>>;6061	/// Check if the token exists.62	#[method(name = "unique_tokenExists")]63	fn token_exists(64		&self,65		collection: CollectionId,66		token: TokenId,67		at: Option<BlockHash>,68	) -> Result<bool>;6970	/// Get the token owner.71	#[method(name = "unique_tokenOwner")]72	fn token_owner(73		&self,74		collection: CollectionId,75		token: TokenId,76		at: Option<BlockHash>,77	) -> Result<Option<CrossAccountId>>;7879	/// Returns 10 tokens owners in no particular order.80	#[method(name = "unique_tokenOwners")]81	fn token_owners(82		&self,83		collection: CollectionId,84		token: TokenId,85		at: Option<BlockHash>,86	) -> Result<Vec<CrossAccountId>>;8788	/// Get the topmost token owner in the hierarchy of a possibly nested token.89	#[method(name = "unique_topmostTokenOwner")]90	fn topmost_token_owner(91		&self,92		collection: CollectionId,93		token: TokenId,94		at: Option<BlockHash>,95	) -> Result<Option<CrossAccountId>>;9697	/// Get tokens nested directly into the token.98	#[method(name = "unique_tokenChildren")]99	fn token_children(100		&self,101		collection: CollectionId,102		token: TokenId,103		at: Option<BlockHash>,104	) -> Result<Vec<TokenChild>>;105106	/// Get collection properties, optionally limited to the provided keys.107	#[method(name = "unique_collectionProperties")]108	fn collection_properties(109		&self,110		collection: CollectionId,111		keys: Option<Vec<String>>,112		at: Option<BlockHash>,113	) -> Result<Vec<Property>>;114115	/// Get token properties, optionally limited to the provided keys.116	#[method(name = "unique_tokenProperties")]117	fn token_properties(118		&self,119		collection: CollectionId,120		token_id: TokenId,121		keys: Option<Vec<String>>,122		at: Option<BlockHash>,123	) -> Result<Vec<Property>>;124125	/// Get property permissions, optionally limited to the provided keys.126	#[method(name = "unique_propertyPermissions")]127	fn property_permissions(128		&self,129		collection: CollectionId,130		keys: Option<Vec<String>>,131		at: Option<BlockHash>,132	) -> Result<Vec<PropertyKeyPermission>>;133134	/// Get token data, including properties, optionally limited to the provided keys, and total pieces for an RFT.135	#[method(name = "unique_tokenData")]136	fn token_data(137		&self,138		collection: CollectionId,139		token_id: TokenId,140		keys: Option<Vec<String>>,141		at: Option<BlockHash>,142	) -> Result<TokenData<CrossAccountId>>;143144	/// Get the amount of distinctive tokens present in a collection.145	#[method(name = "unique_totalSupply")]146	fn total_supply(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<u32>;147148	/// Get the amount of any user tokens owned by an account.149	#[method(name = "unique_accountBalance")]150	fn account_balance(151		&self,152		collection: CollectionId,153		account: CrossAccountId,154		at: Option<BlockHash>,155	) -> Result<u32>;156157	/// Get the amount of a specific token owned by an account.158	#[method(name = "unique_balance")]159	fn balance(160		&self,161		collection: CollectionId,162		account: CrossAccountId,163		token: TokenId,164		at: Option<BlockHash>,165	) -> Result<String>;166167	/// Get the amount of currently possible sponsored transactions on a token for the fee to be taken off a sponsor.168	#[method(name = "unique_allowance")]169	fn allowance(170		&self,171		collection: CollectionId,172		sender: CrossAccountId,173		spender: CrossAccountId,174		token: TokenId,175		at: Option<BlockHash>,176	) -> Result<String>;177178	/// Get the list of admin accounts of a collection.179	#[method(name = "unique_adminlist")]180	fn adminlist(181		&self,182		collection: CollectionId,183		at: Option<BlockHash>,184	) -> Result<Vec<CrossAccountId>>;185186	/// Get the list of accounts allowed to operate within a collection.187	#[method(name = "unique_allowlist")]188	fn allowlist(189		&self,190		collection: CollectionId,191		at: Option<BlockHash>,192	) -> Result<Vec<CrossAccountId>>;193194	/// Check if a user is allowed to operate within a collection.195	#[method(name = "unique_allowed")]196	fn allowed(197		&self,198		collection: CollectionId,199		user: CrossAccountId,200		at: Option<BlockHash>,201	) -> Result<bool>;202203	/// Get the last token ID created in a collection.204	#[method(name = "unique_lastTokenId")]205	fn last_token_id(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<TokenId>;206207	/// Get collection info by the specified ID.208	#[method(name = "unique_collectionById")]209	fn collection_by_id(210		&self,211		collection: CollectionId,212		at: Option<BlockHash>,213	) -> Result<Option<RpcCollection<AccountId>>>;214215	/// Get chain stats about collections.216	#[method(name = "unique_collectionStats")]217	fn collection_stats(&self, at: Option<BlockHash>) -> Result<CollectionStats>;218219	/// Get the number of blocks until sponsoring a transaction is available.220	#[method(name = "unique_nextSponsored")]221	fn next_sponsored(222		&self,223		collection: CollectionId,224		account: CrossAccountId,225		token: TokenId,226		at: Option<BlockHash>,227	) -> Result<Option<u64>>;228229	/// Get effective collection limits. If not explicitly set, get the chain defaults.230	#[method(name = "unique_effectiveCollectionLimits")]231	fn effective_collection_limits(232		&self,233		collection_id: CollectionId,234		at: Option<BlockHash>,235	) -> Result<Option<CollectionLimits>>;236237	/// Get the total amount of pieces of an RFT.238	#[method(name = "unique_totalPieces")]239	fn total_pieces(240		&self,241		collection_id: CollectionId,242		token_id: TokenId,243		at: Option<BlockHash>,244	) -> Result<Option<String>>;245246	/// Get whether an operator is approved by a given owner.247	#[method(name = "unique_allowanceForAll")]248	fn allowance_for_all(249		&self,250		collection: CollectionId,251		owner: CrossAccountId,252		operator: CrossAccountId,253		at: Option<BlockHash>,254	) -> Result<bool>;255}256257mod app_promotion_unique_rpc {258	use super::*;259260	#[rpc(server)]261	#[async_trait]262	pub trait AppPromotionApi<BlockHash, BlockNumber, CrossAccountId, AccountId> {263		/// Returns the total amount of staked tokens.264		#[method(name = "appPromotion_totalStaked")]265		fn total_staked(266			&self,267			staker: Option<CrossAccountId>,268			at: Option<BlockHash>,269		) -> Result<String>;270271		///Returns the total amount of staked tokens per block when staked.272		#[method(name = "appPromotion_totalStakedPerBlock")]273		fn total_staked_per_block(274			&self,275			staker: CrossAccountId,276			at: Option<BlockHash>,277		) -> Result<Vec<(BlockNumber, String)>>;278279		/// Returns the total amount of tokens pending withdrawal from staking.280		#[method(name = "appPromotion_pendingUnstake")]281		fn pending_unstake(282			&self,283			staker: Option<CrossAccountId>,284			at: Option<BlockHash>,285		) -> Result<String>;286287		/// Returns the total amount of tokens pending withdrawal from staking per block.288		#[method(name = "appPromotion_pendingUnstakePerBlock")]289		fn pending_unstake_per_block(290			&self,291			staker: CrossAccountId,292			at: Option<BlockHash>,293		) -> Result<Vec<(BlockNumber, String)>>;294	}295}296297#[macro_export]298macro_rules! define_struct_for_server_api {299	($name:ident { $($arg:ident: $arg_ty:ty),+ $(,)? }) => {300		pub struct $name<Client, Block: BlockT> {301			$($arg: $arg_ty),+,302			_marker: std::marker::PhantomData<Block>,303		}304305		impl<Client, Block: BlockT> $name<Client, Block> {306			pub fn new($($arg: $arg_ty),+) -> Self {307				Self {308					$($arg),+,309					_marker: Default::default(),310				}311			}312		}313	};314}315316define_struct_for_server_api! {317	Unique {318		client: Arc<Client>319	}320}321322define_struct_for_server_api! {323	AppPromotion {324		client: Arc<Client>325	}326}327328macro_rules! pass_method {329	(330		$method_name:ident(331			$($(#[map = $map:expr])? $name:ident: $ty:ty),* $(,)?332		) -> $result:ty $(=> $mapper:expr)?,333		//$runtime_name:ident $(<$($lt: tt),+>)*334		$runtime_api_macro:ident335		$(; changed_in $ver:expr, $changed_method_name:ident ($($changed_name:expr), * $(,)?) => $fixer:expr)*336	) => {337		fn $method_name(338			&self,339			$(340				$name: $ty,341			)*342			at: Option<<Block as BlockT>::Hash>,343		) -> Result<$result> {344			let api = self.client.runtime_api();345			let at = at.unwrap_or_else(|| self.client.info().best_hash);346			let _api_version = if let Ok(Some(api_version)) =347				api.api_version::<$runtime_api_macro!()>(at)348			{349				api_version350			} else {351				// unreachable for our runtime352				return Err(anyhow!("api is not available").into())353			};354355			let result = $(if _api_version < $ver {356				api.$changed_method_name(at, $($changed_name),*).map(|r| r.and_then($fixer))357			} else)*358			{ api.$method_name(at, $($($map)? ($name)),*) };359360			Ok(result361				.map_err(|e| anyhow!("unable to query: {e}"))?362				.map_err(|e| anyhow!("runtime error: {e:?}"))$(.map($mapper))??)363		}364	};365}366367macro_rules! unique_api {368	() => {369		dyn UniqueRuntimeApi<Block, CrossAccountId, AccountId>370	};371}372373macro_rules! app_promotion_api {374	() => {375		dyn AppPromotionRuntimeApi<Block, BlockNumber, CrossAccountId, AccountId>376	};377}378379#[allow(deprecated)]380impl<C, Block, CrossAccountId, AccountId>381	UniqueApiServer<<Block as BlockT>::Hash, CrossAccountId, AccountId> for Unique<C, Block>382where383	Block: BlockT,384	AccountId: Decode,385	C: 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,386	C::Api: UniqueRuntimeApi<Block, CrossAccountId, AccountId>,387	CrossAccountId: pallet_evm::account::CrossAccountId<AccountId>,388{389	pass_method!(390		account_tokens(collection: CollectionId, account: CrossAccountId) -> Vec<TokenId>, unique_api391	);392	pass_method!(393		collection_tokens(collection: CollectionId) -> Vec<TokenId>, unique_api394	);395	pass_method!(396		token_exists(collection: CollectionId, token: TokenId) -> bool, unique_api397	);398	pass_method!(399		token_owner(collection: CollectionId, token: TokenId) -> Option<CrossAccountId>, unique_api400	);401	pass_method!(402		topmost_token_owner(collection: CollectionId, token: TokenId) -> Option<CrossAccountId>, unique_api403	);404	pass_method!(token_children(collection: CollectionId, token: TokenId) -> Vec<TokenChild>, unique_api);405	pass_method!(total_supply(collection: CollectionId) -> u32, unique_api);406	pass_method!(account_balance(collection: CollectionId, account: CrossAccountId) -> u32, unique_api);407	pass_method!(balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> String => |v| v.to_string(), unique_api);408	pass_method!(409		allowance(collection: CollectionId, sender: CrossAccountId, spender: CrossAccountId, token: TokenId) -> String => |v| v.to_string(),410		unique_api411	);412413	pass_method!(collection_properties(414		collection: CollectionId,415416		#[map = string_keys_to_bytes_keys]417		keys: Option<Vec<String>>418	) -> Vec<Property>, unique_api);419420	pass_method!(token_properties(421		collection: CollectionId,422		token_id: TokenId,423424		#[map = string_keys_to_bytes_keys]425		keys: Option<Vec<String>>426	) -> Vec<Property>, unique_api);427428	pass_method!(property_permissions(429		collection: CollectionId,430431		#[map = string_keys_to_bytes_keys]432		keys: Option<Vec<String>>433	) -> Vec<PropertyKeyPermission>, unique_api);434435	fn token_data(436		&self,437		collection: CollectionId,438		token_id: TokenId,439		keys: Option<Vec<String>>,440		at: Option<<Block as BlockT>::Hash>,441	) -> Result<TokenData<CrossAccountId>> {442		token_data_internal(self.client.clone(), collection, token_id, keys, at)443	}444445	pass_method!(adminlist(collection: CollectionId) -> Vec<CrossAccountId>, unique_api);446	pass_method!(allowlist(collection: CollectionId) -> Vec<CrossAccountId>, unique_api);447	pass_method!(allowed(collection: CollectionId, user: CrossAccountId) -> bool, unique_api);448	pass_method!(last_token_id(collection: CollectionId) -> TokenId, unique_api);449	pass_method!(450		collection_by_id(collection: CollectionId) -> Option<RpcCollection<AccountId>>, unique_api;451		changed_in 3, collection_by_id_before_version_3(collection) => |value| {452			use sp_runtime::DispatchError;453454			if let Some(bytes) = value {455				Ok(Some(detect_type_and_decode_collection(bytes.as_slice())456				.map_err(|_| DispatchError::Other("API Error: UniqueApi_collection_by_id"))?))457			} else {458				Ok(None)459			}460		}461	);462	pass_method!(collection_stats() -> CollectionStats, unique_api);463	pass_method!(next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Option<u64>, unique_api);464	pass_method!(effective_collection_limits(collection_id: CollectionId) -> Option<CollectionLimits>, unique_api);465	pass_method!(total_pieces(collection_id: CollectionId, token_id: TokenId) -> Option<String> => |o| o.map(|number| number.to_string()) , unique_api);466	pass_method!(token_owners(collection: CollectionId, token: TokenId) -> Vec<CrossAccountId>, unique_api);467	pass_method!(allowance_for_all(collection: CollectionId, owner: CrossAccountId, operator: CrossAccountId) -> bool, unique_api);468}469470impl<C, Block, BlockNumber, CrossAccountId, AccountId>471	app_promotion_unique_rpc::AppPromotionApiServer<472		<Block as BlockT>::Hash,473		BlockNumber,474		CrossAccountId,475		AccountId,476	> for AppPromotion<C, Block>477where478	Block: BlockT,479	BlockNumber: Decode + Member + AtLeast32BitUnsigned,480	AccountId: Decode,481	C: 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,482	CrossAccountId: pallet_evm::account::CrossAccountId<AccountId>,483	C::Api: AppPromotionRuntimeApi<Block, BlockNumber, CrossAccountId, AccountId>,484{485	pass_method!(total_staked(staker: Option<CrossAccountId>) -> String => |v| v.to_string(), app_promotion_api);486	pass_method!(total_staked_per_block(staker: CrossAccountId) -> Vec<(BlockNumber, String)> =>487		|v| v488		.into_iter()489		.map(|(b, a)| (b, a.to_string()))490		.collect::<Vec<_>>(), app_promotion_api);491	pass_method!(pending_unstake(staker: Option<CrossAccountId>) -> String => |v| v.to_string(), app_promotion_api);492	pass_method!(pending_unstake_per_block(staker: CrossAccountId) -> Vec<(BlockNumber, String)> =>493		|v| v494		.into_iter()495		.map(|(b, a)| (b, a.to_string()))496		.collect::<Vec<_>>(), app_promotion_api);497}498499fn token_data_internal<Block, Client, AccountId, CrossAccountId>(500	client: Arc<Client>,501	collection: CollectionId,502	token_id: TokenId,503	keys: Option<Vec<String>>,504	at: Option<<Block as BlockT>::Hash>,505) -> Result<TokenData<CrossAccountId>>506where507	AccountId: Decode,508	Block: BlockT,509	Client: ProvideRuntimeApi<Block> + HeaderBackend<Block>,510	Client::Api: UniqueRuntimeApi<Block, CrossAccountId, AccountId>,511	CrossAccountId: pallet_evm::account::CrossAccountId<AccountId>,512{513	let api = client.runtime_api();514	let at = at.unwrap_or_else(|| client.info().best_hash);515	let api_version = if let Ok(Some(api_version)) =516		api.api_version::<dyn UniqueRuntimeApi<Block, CrossAccountId, AccountId>>(at)517	{518		api_version519	} else {520		return Err(anyhow!("api is not available").into());521	};522	let result = if api_version >= 3 {523		api.token_data(at, collection, token_id, string_keys_to_bytes_keys(keys))524	} else {525		#[allow(deprecated)]526		api.token_data_before_version_3(at, collection, token_id, string_keys_to_bytes_keys(keys))527			.map(528				|r: sc_service::Result<529					up_data_structs::TokenDataVersion1<CrossAccountId>,530					sp_runtime::DispatchError,531				>| r.map(|value| value.into()),532			)533			.or_else(|_| {534				Ok(api535					.token_owner(at, collection, token_id)?536					.map(|owner| TokenData {537						properties: Vec::new(),538						owner,539						pieces: 0,540					}))541			})542	};543	Ok(result544		.map_err(|e| anyhow!("unable to query: {e}"))?545		.map_err(|e| anyhow!("runtime error: {e:?}"))?)546}547548fn string_keys_to_bytes_keys(keys: Option<Vec<String>>) -> Option<Vec<Vec<u8>>> {549	keys.map(|keys| keys.into_iter().map(|key| key.into_bytes()).collect())550}551552fn decode_collection_from_bytes<T: codec::Decode>(553	bytes: &[u8],554) -> core::result::Result<T, codec::Error> {555	let mut reader = codec::IoReader(bytes);556	T::decode(&mut reader)557}558559fn detect_type_and_decode_collection<AccountId: Decode>(560	bytes: &[u8],561) -> core::result::Result<RpcCollection<AccountId>, codec::Error> {562	use up_data_structs::{CollectionVersion1, RpcCollectionVersion1};563564	decode_collection_from_bytes::<RpcCollection<AccountId>>(bytes)565		.or_else(|_| {566			decode_collection_from_bytes::<RpcCollectionVersion1<AccountId>>(bytes)567				.map(|col| col.into())568		})569		.or_else(|_| {570			decode_collection_from_bytes::<CollectionVersion1<AccountId>>(bytes)571				.map(|col| col.into())572		})573}574575#[cfg(test)]576mod tests {577	use super::*;578	use codec::IoReader;579	use hex_literal::hex;580	use up_data_structs::{CollectionVersion1, RawEncoded};581582	const ENCODED_COLLECTION_V1: [u8; 180] = hex!("aab94a1ee784bc17f68d76d4d48d736916ca6ff6315b8c1fa1175726c8345a390000285000720069006d00610020004c00690076006500d04500730065006d00700069006f00200064006900200063007200650061007a0069006f006e006500200064006900200075006e00610020006e0075006f0076006100200063006f006c006c0065007a0069006f006e00650020006400690020004e004600540021000c464e5400000000000000000000000000000000");583	const ENCODED_RPC_COLLECTION_V2: [u8; 618] = hex!("d00dcc24bf66750d3809aa26884b930ec8a3094d6f6f19fdc62020b2fbec013400604d0069006e007400460065007300740020002d002000460075006e006e007900200061006e0069006d0061006c0073008c430072006f00730073006f0076006500720020006200650074007700650065006e00200061006e0069006d0061006c00730020002d00200066006f0072002000660075006e00104d46464100000000000000000000010001000100000004385f6f6c645f636f6e7374446174610001000c5c5f6f6c645f636f6e73744f6e436861696e536368656d6139047b226e6573746564223a7b226f6e436861696e4d65746144617461223a7b226e6573746564223a7b224e46544d657461223a7b226669656c6473223a7b22697066734a736f6e223a7b226964223a312c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d2c2248656164223a7b226964223a322c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d2c22426f6479223a7b226964223a332c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d2c225461696c223a7b226964223a342c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d7d7d7d7d7d7d485f6f6c645f736368656d6156657273696f6e18556e69717565685f6f6c645f7661726961626c654f6e436861696e536368656d6111017b22636f6c6c656374696f6e436f766572223a22516d53557a7139354c357a556777795a584d3731576a3762786b36557048515468633162536965347766706e5435227d000000");584585	#[test]586	fn decoding_collection_v1() {587		decode_collection_from_bytes::<CollectionVersion1<[u8; 32]>>(588			ENCODED_COLLECTION_V1.as_slice(),589		)590		.unwrap();591	}592593	#[test]594	fn detecting_and_decoding_collection_v1() {595		detect_type_and_decode_collection::<[u8; 32]>(ENCODED_COLLECTION_V1.as_slice()).unwrap();596	}597598	#[test]599	fn decoding_rpc_collection_v2() {600		decode_collection_from_bytes::<RpcCollection<[u8; 32]>>(601			ENCODED_RPC_COLLECTION_V2.as_slice(),602		)603		.unwrap();604	}605606	#[test]607	fn detecting_decoding_rpc_collection_v2() {608		detect_type_and_decode_collection::<[u8; 32]>(ENCODED_RPC_COLLECTION_V2.as_slice())609			.unwrap();610	}611612	#[test]613	fn rpc_collection_supports_decoding_through_vec() {614		let mut bytes = IoReader(ENCODED_RPC_COLLECTION_V2.as_slice());615		let vec = RawEncoded::decode(&mut bytes).unwrap();616		println!("{:?}", vec.len());617		let mut bytes = IoReader(vec.as_slice());618		RpcCollection::<[u8; 32]>::decode(&mut bytes).unwrap();619	}620}