git.delta.rocks / unique-network / refs/commits / de3cc2908b88

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, Encode};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::{BlockId, BlockT, ProvideRuntimeApi, ApiExt};32use sp_blockchain::HeaderBackend;33use up_rpc::UniqueApi as UniqueRuntimeApi;34use app_promotion_rpc::AppPromotionApi as AppPromotionRuntimeApi;3536// RMRK37use rmrk_rpc::RmrkApi as RmrkRuntimeApi;38use up_data_structs::{39	RmrkCollectionId, RmrkNftId, RmrkBaseId, RmrkNftChild, RmrkThemeName, RmrkResourceId,40};4142pub use app_promotion_unique_rpc::AppPromotionApiServer;43pub use rmrk_unique_rpc::RmrkApiServer;4445#[rpc(server)]46#[async_trait]47pub trait UniqueApi<BlockHash, BlockNumber, CrossAccountId, AccountId> {48	/// Get tokens owned by account.49	#[method(name = "unique_accountTokens")]50	fn account_tokens(51		&self,52		collection: CollectionId,53		account: CrossAccountId,54		at: Option<BlockHash>,55	) -> Result<Vec<TokenId>>;5657	/// Get tokens contained within a collection.58	#[method(name = "unique_collectionTokens")]59	fn collection_tokens(60		&self,61		collection: CollectionId,62		at: Option<BlockHash>,63	) -> Result<Vec<TokenId>>;6465	/// Check if the token exists.66	#[method(name = "unique_tokenExists")]67	fn token_exists(68		&self,69		collection: CollectionId,70		token: TokenId,71		at: Option<BlockHash>,72	) -> Result<bool>;7374	/// Get the token owner.75	#[method(name = "unique_tokenOwner")]76	fn token_owner(77		&self,78		collection: CollectionId,79		token: TokenId,80		at: Option<BlockHash>,81	) -> Result<Option<CrossAccountId>>;8283	/// Returns 10 tokens owners in no particular order.84	#[method(name = "unique_tokenOwners")]85	fn token_owners(86		&self,87		collection: CollectionId,88		token: TokenId,89		at: Option<BlockHash>,90	) -> Result<Vec<CrossAccountId>>;9192	/// Get the topmost token owner in the hierarchy of a possibly nested token.93	#[method(name = "unique_topmostTokenOwner")]94	fn topmost_token_owner(95		&self,96		collection: CollectionId,97		token: TokenId,98		at: Option<BlockHash>,99	) -> Result<Option<CrossAccountId>>;100101	/// Get tokens nested directly into the token.102	#[method(name = "unique_tokenChildren")]103	fn token_children(104		&self,105		collection: CollectionId,106		token: TokenId,107		at: Option<BlockHash>,108	) -> Result<Vec<TokenChild>>;109110	/// Get collection properties, optionally limited to the provided keys.111	#[method(name = "unique_collectionProperties")]112	fn collection_properties(113		&self,114		collection: CollectionId,115		keys: Option<Vec<String>>,116		at: Option<BlockHash>,117	) -> Result<Vec<Property>>;118119	/// Get token properties, optionally limited to the provided keys.120	#[method(name = "unique_tokenProperties")]121	fn token_properties(122		&self,123		collection: CollectionId,124		token_id: TokenId,125		keys: Option<Vec<String>>,126		at: Option<BlockHash>,127	) -> Result<Vec<Property>>;128129	/// Get property permissions, optionally limited to the provided keys.130	#[method(name = "unique_propertyPermissions")]131	fn property_permissions(132		&self,133		collection: CollectionId,134		keys: Option<Vec<String>>,135		at: Option<BlockHash>,136	) -> Result<Vec<PropertyKeyPermission>>;137138	/// Get token data, including properties, optionally limited to the provided keys, and total pieces for an RFT.139	#[method(name = "unique_tokenData")]140	fn token_data(141		&self,142		collection: CollectionId,143		token_id: TokenId,144		keys: Option<Vec<String>>,145		at: Option<BlockHash>,146	) -> Result<TokenData<CrossAccountId>>;147148	/// Get the amount of distinctive tokens present in a collection.149	#[method(name = "unique_totalSupply")]150	fn total_supply(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<u32>;151152	/// Get the amount of any user tokens owned by an account.153	#[method(name = "unique_accountBalance")]154	fn account_balance(155		&self,156		collection: CollectionId,157		account: CrossAccountId,158		at: Option<BlockHash>,159	) -> Result<u32>;160161	/// Get the amount of a specific token owned by an account.162	#[method(name = "unique_balance")]163	fn balance(164		&self,165		collection: CollectionId,166		account: CrossAccountId,167		token: TokenId,168		at: Option<BlockHash>,169	) -> Result<String>;170171	/// Get the amount of currently possible sponsored transactions on a token for the fee to be taken off a sponsor.172	#[method(name = "unique_allowance")]173	fn allowance(174		&self,175		collection: CollectionId,176		sender: CrossAccountId,177		spender: CrossAccountId,178		token: TokenId,179		at: Option<BlockHash>,180	) -> Result<String>;181182	/// Get the list of admin accounts of a collection.183	#[method(name = "unique_adminlist")]184	fn adminlist(185		&self,186		collection: CollectionId,187		at: Option<BlockHash>,188	) -> Result<Vec<CrossAccountId>>;189190	/// Get the list of accounts allowed to operate within a collection.191	#[method(name = "unique_allowlist")]192	fn allowlist(193		&self,194		collection: CollectionId,195		at: Option<BlockHash>,196	) -> Result<Vec<CrossAccountId>>;197198	/// Check if a user is allowed to operate within a collection.199	#[method(name = "unique_allowed")]200	fn allowed(201		&self,202		collection: CollectionId,203		user: CrossAccountId,204		at: Option<BlockHash>,205	) -> Result<bool>;206207	/// Get the last token ID created in a collection.208	#[method(name = "unique_lastTokenId")]209	fn last_token_id(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<TokenId>;210211	/// Get collection info by the specified ID.212	#[method(name = "unique_collectionById")]213	fn collection_by_id(214		&self,215		collection: CollectionId,216		at: Option<BlockHash>,217	) -> Result<Option<RpcCollection<AccountId>>>;218219	/// Get chain stats about collections.220	#[method(name = "unique_collectionStats")]221	fn collection_stats(&self, at: Option<BlockHash>) -> Result<CollectionStats>;222223	/// Get the number of blocks until sponsoring a transaction is available.224	#[method(name = "unique_nextSponsored")]225	fn next_sponsored(226		&self,227		collection: CollectionId,228		account: CrossAccountId,229		token: TokenId,230		at: Option<BlockHash>,231	) -> Result<Option<u64>>;232233	/// Get effective collection limits. If not explicitly set, get the chain defaults.234	#[method(name = "unique_effectiveCollectionLimits")]235	fn effective_collection_limits(236		&self,237		collection_id: CollectionId,238		at: Option<BlockHash>,239	) -> Result<Option<CollectionLimits>>;240241	/// Get the total amount of pieces of an RFT.242	#[method(name = "unique_totalPieces")]243	fn total_pieces(244		&self,245		collection_id: CollectionId,246		token_id: TokenId,247		at: Option<BlockHash>,248	) -> Result<Option<String>>;249}250251mod app_promotion_unique_rpc {252	use super::*;253254	#[rpc(server)]255	#[async_trait]256	pub trait AppPromotionApi<BlockHash, BlockNumber, CrossAccountId, AccountId> {257		/// Returns the total amount of staked tokens.258		#[method(name = "appPromotion_totalStaked")]259		fn total_staked(260			&self,261			staker: Option<CrossAccountId>,262			at: Option<BlockHash>,263		) -> Result<String>;264265		///Returns the total amount of staked tokens per block when staked.266		#[method(name = "appPromotion_totalStakedPerBlock")]267		fn total_staked_per_block(268			&self,269			staker: CrossAccountId,270			at: Option<BlockHash>,271		) -> Result<Vec<(BlockNumber, String)>>;272273		/// Returns the total amount locked by staking tokens.274		#[method(name = "appPromotion_totalStakingLocked")]275		fn total_staking_locked(276			&self,277			staker: CrossAccountId,278			at: Option<BlockHash>,279		) -> Result<String>;280281		/// Returns the total amount of tokens pending withdrawal from staking.282		#[method(name = "appPromotion_pendingUnstake")]283		fn pending_unstake(284			&self,285			staker: Option<CrossAccountId>,286			at: Option<BlockHash>,287		) -> Result<String>;288289		/// Returns the total amount of tokens pending withdrawal from staking per block.290		#[method(name = "appPromotion_pendingUnstakePerBlock")]291		fn pending_unstake_per_block(292			&self,293			staker: CrossAccountId,294			at: Option<BlockHash>,295		) -> Result<Vec<(BlockNumber, String)>>;296	}297}298299mod rmrk_unique_rpc {300	use super::*;301302	#[rpc(server)]303	#[async_trait]304	pub trait RmrkApi<305		BlockHash,306		AccountId,307		CollectionInfo,308		NftInfo,309		ResourceInfo,310		PropertyInfo,311		BaseInfo,312		PartType,313		Theme,314	>315	{316		/// Get the latest created collection ID.317		#[method(name = "rmrk_lastCollectionIdx")]318		fn last_collection_idx(&self, at: Option<BlockHash>) -> Result<RmrkCollectionId>;319320		/// Get collection info by ID.321		#[method(name = "rmrk_collectionById")]322		fn collection_by_id(323			&self,324			id: RmrkCollectionId,325			at: Option<BlockHash>,326		) -> Result<Option<CollectionInfo>>;327328		/// Get NFT info by collection and NFT IDs.329		#[method(name = "rmrk_nftById")]330		fn nft_by_id(331			&self,332			collection_id: RmrkCollectionId,333			nft_id: RmrkNftId,334			at: Option<BlockHash>,335		) -> Result<Option<NftInfo>>;336337		/// Get tokens owned by an account in a collection.338		#[method(name = "rmrk_accountTokens")]339		fn account_tokens(340			&self,341			account_id: AccountId,342			collection_id: RmrkCollectionId,343			at: Option<BlockHash>,344		) -> Result<Vec<RmrkNftId>>;345346		/// Get tokens nested in an NFT - its direct children (not the children's children).347		#[method(name = "rmrk_nftChildren")]348		fn nft_children(349			&self,350			collection_id: RmrkCollectionId,351			nft_id: RmrkNftId,352			at: Option<BlockHash>,353		) -> Result<Vec<RmrkNftChild>>;354355		/// Get collection properties, created by the user - not the proxy-specific properties.356		#[method(name = "rmrk_collectionProperties")]357		fn collection_properties(358			&self,359			collection_id: RmrkCollectionId,360			filter_keys: Option<Vec<String>>,361			at: Option<BlockHash>,362		) -> Result<Vec<PropertyInfo>>;363364		/// Get NFT properties, created by the user - not the proxy-specific properties.365		#[method(name = "rmrk_nftProperties")]366		fn nft_properties(367			&self,368			collection_id: RmrkCollectionId,369			nft_id: RmrkNftId,370			filter_keys: Option<Vec<String>>,371			at: Option<BlockHash>,372		) -> Result<Vec<PropertyInfo>>;373374		/// Get data of resources of an NFT.375		#[method(name = "rmrk_nftResources")]376		fn nft_resources(377			&self,378			collection_id: RmrkCollectionId,379			nft_id: RmrkNftId,380			at: Option<BlockHash>,381		) -> Result<Vec<ResourceInfo>>;382383		/// Get the priority of a resource in an NFT.384		#[method(name = "rmrk_nftResourcePriority")]385		fn nft_resource_priority(386			&self,387			collection_id: RmrkCollectionId,388			nft_id: RmrkNftId,389			resource_id: RmrkResourceId,390			at: Option<BlockHash>,391		) -> Result<Option<u32>>;392393		/// Get base info by its ID.394		#[method(name = "rmrk_base")]395		fn base(&self, base_id: RmrkBaseId, at: Option<BlockHash>) -> Result<Option<BaseInfo>>;396397		/// Get all parts of a base.398		#[method(name = "rmrk_baseParts")]399		fn base_parts(&self, base_id: RmrkBaseId, at: Option<BlockHash>) -> Result<Vec<PartType>>;400401		/// Get the theme names belonging to a base.402		#[method(name = "rmrk_themeNames")]403		fn theme_names(404			&self,405			base_id: RmrkBaseId,406			at: Option<BlockHash>,407		) -> Result<Vec<RmrkThemeName>>;408409		/// Get theme info, including properties, optionally limited to the provided keys.410		#[method(name = "rmrk_themes")]411		fn theme(412			&self,413			base_id: RmrkBaseId,414			theme_name: String,415			filter_keys: Option<Vec<String>>,416			at: Option<BlockHash>,417		) -> Result<Option<Theme>>;418	}419}420421pub struct Unique<C, P> {422	client: Arc<C>,423	_marker: std::marker::PhantomData<P>,424}425426impl<C, P> Unique<C, P> {427	pub fn new(client: Arc<C>) -> Self {428		Self {429			client,430			_marker: Default::default(),431		}432	}433}434435pub struct AppPromotion<C, P> {436	client: Arc<C>,437	_marker: std::marker::PhantomData<P>,438}439440impl<C, P> AppPromotion<C, P> {441	pub fn new(client: Arc<C>) -> Self {442		Self {443			client,444			_marker: Default::default(),445		}446	}447}448449pub struct Rmrk<C, P> {450	client: Arc<C>,451	_marker: std::marker::PhantomData<P>,452}453454impl<C, P> Rmrk<C, P> {455	pub fn new(client: Arc<C>) -> Self {456		Self {457			client,458			_marker: Default::default(),459		}460	}461}462463macro_rules! pass_method {464	(465		$method_name:ident(466			$($(#[map(|$map_arg:ident| $map:expr)])? $name:ident: $ty:ty),* $(,)?467		) -> $result:ty $(=> $mapper:expr)?,468		//$runtime_name:ident $(<$($lt: tt),+>)*469		$runtime_api_macro:ident470		$(; changed_in $ver:expr, $changed_method_name:ident ($($changed_name:expr), * $(,)?) => $fixer:expr)*471	) => {472		fn $method_name(473			&self,474			$(475				$name: $ty,476			)*477			at: Option<<Block as BlockT>::Hash>,478		) -> Result<$result> {479			let api = self.client.runtime_api();480			let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash));481			let _api_version = if let Ok(Some(api_version)) =482				api.api_version::<$runtime_api_macro!()>(&at)483			{484				api_version485			} else {486				// unreachable for our runtime487				return Err(anyhow!("api is not available").into())488			};489490			let result = $(if _api_version < $ver {491				api.$changed_method_name(&at, $($changed_name),*).map(|r| r.map($fixer))492			} else)*493			{ api.$method_name(&at, $($((|$map_arg: $ty| $map))? ($name)),*) };494495			Ok(result496				.map_err(|e| anyhow!("unable to query: {e}"))?497				.map_err(|e| anyhow!("runtime error: {e:?}"))$(.map($mapper))??)498		}499	};500}501502macro_rules! unique_api {503	() => {504		dyn UniqueRuntimeApi<Block, BlockNumber, CrossAccountId, AccountId>505	};506}507508macro_rules! app_promotion_api {509	() => {510		dyn AppPromotionRuntimeApi<Block, BlockNumber, CrossAccountId, AccountId>511	};512}513514macro_rules! rmrk_api {515	() => {516		dyn RmrkRuntimeApi<Block, AccountId, CollectionInfo, NftInfo, ResourceInfo, PropertyInfo, BaseInfo, PartType, Theme>517	};518}519520#[allow(deprecated)]521impl<C, Block, BlockNumber, CrossAccountId, AccountId>522	UniqueApiServer<<Block as BlockT>::Hash, BlockNumber, CrossAccountId, AccountId>523	for Unique<C, Block>524where525	Block: BlockT,526	BlockNumber: Decode + Member + AtLeast32BitUnsigned,527	AccountId: Decode,528	C: 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,529	C::Api: UniqueRuntimeApi<Block, BlockNumber, CrossAccountId, AccountId>,530	CrossAccountId: pallet_evm::account::CrossAccountId<AccountId>,531{532	pass_method!(533		account_tokens(collection: CollectionId, account: CrossAccountId) -> Vec<TokenId>, unique_api534	);535	pass_method!(536		collection_tokens(collection: CollectionId) -> Vec<TokenId>, unique_api537	);538	pass_method!(539		token_exists(collection: CollectionId, token: TokenId) -> bool, unique_api540	);541	pass_method!(542		token_owner(collection: CollectionId, token: TokenId) -> Option<CrossAccountId>, unique_api543	);544	pass_method!(545		topmost_token_owner(collection: CollectionId, token: TokenId) -> Option<CrossAccountId>, unique_api546	);547	pass_method!(token_children(collection: CollectionId, token: TokenId) -> Vec<TokenChild>, unique_api);548	pass_method!(total_supply(collection: CollectionId) -> u32, unique_api);549	pass_method!(account_balance(collection: CollectionId, account: CrossAccountId) -> u32, unique_api);550	pass_method!(balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> String => |v| v.to_string(), unique_api);551	pass_method!(552		allowance(collection: CollectionId, sender: CrossAccountId, spender: CrossAccountId, token: TokenId) -> String => |v| v.to_string(),553		unique_api554	);555556	pass_method!(collection_properties(557		collection: CollectionId,558559		#[map(|keys| string_keys_to_bytes_keys(keys))]560		keys: Option<Vec<String>>561	) -> Vec<Property>, unique_api);562563	pass_method!(token_properties(564		collection: CollectionId,565		token_id: TokenId,566567		#[map(|keys| string_keys_to_bytes_keys(keys))]568		keys: Option<Vec<String>>569	) -> Vec<Property>, unique_api);570571	pass_method!(property_permissions(572		collection: CollectionId,573574		#[map(|keys| string_keys_to_bytes_keys(keys))]575		keys: Option<Vec<String>>576	) -> Vec<PropertyKeyPermission>, unique_api);577578	pass_method!(token_data(579		collection: CollectionId,580		token_id: TokenId,581582		#[map(|keys| string_keys_to_bytes_keys(keys))]583		keys: Option<Vec<String>>,584	) -> TokenData<CrossAccountId>, unique_api);585586	pass_method!(adminlist(collection: CollectionId) -> Vec<CrossAccountId>, unique_api);587	pass_method!(allowlist(collection: CollectionId) -> Vec<CrossAccountId>, unique_api);588	pass_method!(allowed(collection: CollectionId, user: CrossAccountId) -> bool, unique_api);589	pass_method!(last_token_id(collection: CollectionId) -> TokenId, unique_api);590	pass_method!(collection_by_id(collection: CollectionId) -> Option<RpcCollection<AccountId>>, unique_api);591	pass_method!(collection_stats() -> CollectionStats, unique_api);592	pass_method!(next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Option<u64>, unique_api);593	pass_method!(effective_collection_limits(collection_id: CollectionId) -> Option<CollectionLimits>, unique_api);594	pass_method!(total_pieces(collection_id: CollectionId, token_id: TokenId) -> Option<String> => |o| o.map(|number| number.to_string()) , unique_api);595	pass_method!(token_owners(collection: CollectionId, token: TokenId) -> Vec<CrossAccountId>, unique_api);596}597598impl<C, Block, BlockNumber, CrossAccountId, AccountId>599	app_promotion_unique_rpc::AppPromotionApiServer<600		<Block as BlockT>::Hash,601		BlockNumber,602		CrossAccountId,603		AccountId,604	> for AppPromotion<C, Block>605where606	Block: BlockT,607	BlockNumber: Decode + Member + AtLeast32BitUnsigned,608	AccountId: Decode,609	C: 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,610	C::Api: AppPromotionRuntimeApi<Block, BlockNumber, CrossAccountId, AccountId>,611	CrossAccountId: pallet_evm::account::CrossAccountId<AccountId>,612{613	pass_method!(total_staked(staker: Option<CrossAccountId>) -> String => |v| v.to_string(), app_promotion_api);614	pass_method!(total_staked_per_block(staker: CrossAccountId) -> Vec<(BlockNumber, String)> =>615		|v| v616		.into_iter()617		.map(|(b, a)| (b, a.to_string()))618		.collect::<Vec<_>>(), unique_api);619	pass_method!(total_staking_locked(staker: CrossAccountId) -> String => |v| v.to_string(), unique_api);620	pass_method!(pending_unstake(staker: Option<CrossAccountId>) -> String => |v| v.to_string(), unique_api);621	pass_method!(pending_unstake_per_block(staker: CrossAccountId) -> Vec<(BlockNumber, String)> =>622		|v| v623		.into_iter()624		.map(|(b, a)| (b, a.to_string()))625		.collect::<Vec<_>>(), unique_api);626}627628#[allow(deprecated)]629impl<630		C,631		Block,632		AccountId,633		CollectionInfo,634		NftInfo,635		ResourceInfo,636		PropertyInfo,637		BaseInfo,638		PartType,639		Theme,640	>641	rmrk_unique_rpc::RmrkApiServer<642		<Block as BlockT>::Hash,643		AccountId,644		CollectionInfo,645		NftInfo,646		ResourceInfo,647		PropertyInfo,648		BaseInfo,649		PartType,650		Theme,651	> for Rmrk<C, Block>652where653	C: Send + Sync + 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,654	C::Api: RmrkRuntimeApi<655		Block,656		AccountId,657		CollectionInfo,658		NftInfo,659		ResourceInfo,660		PropertyInfo,661		BaseInfo,662		PartType,663		Theme,664	>,665	AccountId: Decode + Encode,666	CollectionInfo: Decode,667	NftInfo: Decode,668	ResourceInfo: Decode,669	PropertyInfo: Decode,670	BaseInfo: Decode,671	PartType: Decode,672	Theme: Decode,673	Block: BlockT,674{675	pass_method!(last_collection_idx() -> RmrkCollectionId, rmrk_api);676	pass_method!(collection_by_id(id: RmrkCollectionId) -> Option<CollectionInfo>, rmrk_api);677	pass_method!(nft_by_id(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Option<NftInfo>, rmrk_api);678	pass_method!(account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Vec<RmrkNftId>, rmrk_api);679	pass_method!(nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Vec<RmrkNftChild>, rmrk_api);680	pass_method!(681		collection_properties(682			collection_id: RmrkCollectionId,683684			#[map(|keys| string_keys_to_bytes_keys(keys))]685			filter_keys: Option<Vec<String>>686		) -> Vec<PropertyInfo>,687		rmrk_api688	);689	pass_method!(690		nft_properties(691			collection_id: RmrkCollectionId,692			nft_id: RmrkNftId,693694			#[map(|keys| string_keys_to_bytes_keys(keys))]695			filter_keys: Option<Vec<String>>696		) -> Vec<PropertyInfo>,697		rmrk_api698	);699	pass_method!(nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Vec<ResourceInfo>, rmrk_api);700	pass_method!(nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Option<u32>, rmrk_api);701	pass_method!(base(base_id: RmrkBaseId) -> Option<BaseInfo>, rmrk_api);702	pass_method!(base_parts(base_id: RmrkBaseId) -> Vec<PartType>, rmrk_api);703	pass_method!(theme_names(base_id: RmrkBaseId) -> Vec<RmrkThemeName>, rmrk_api);704	pass_method!(705		theme(706			base_id: RmrkBaseId,707708			#[map(|n| n.into_bytes())]709			theme_name: String,710711			#[map(|keys| string_keys_to_bytes_keys(keys))]712			filter_keys: Option<Vec<String>>713		) -> Option<Theme>, rmrk_api);714}715716fn string_keys_to_bytes_keys(keys: Option<Vec<String>>) -> Option<Vec<Vec<u8>>> {717	keys.map(|keys| keys.into_iter().map(|key| key.into_bytes()).collect())718}