git.delta.rocks / unique-network / refs/commits / 8bbc7539fcb3

difftreelog

CORE-178

str-mv2022-04-08parent: #219f5f0.patch.diff
in: master

7 files changed

modifiedclient/rpc/src/lib.rsdiffbeforeafterboth
before · client/rpc/src/lib.rs
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/>.1617use std::sync::Arc;1819use codec::Decode;20use jsonrpc_core::{Error as RpcError, ErrorCode, Result};21use jsonrpc_derive::rpc;22use up_data_structs::{Collection, CollectionId, CollectionStats, TokenId};23use sp_api::{BlockId, BlockT, ProvideRuntimeApi, ApiExt};24use sp_blockchain::HeaderBackend;25use up_rpc::UniqueApi as UniqueRuntimeApi;2627#[rpc]28pub trait UniqueApi<BlockHash, CrossAccountId, AccountId> {29	#[rpc(name = "unique_accountTokens")]30	fn account_tokens(31		&self,32		collection: CollectionId,33		account: CrossAccountId,34		at: Option<BlockHash>,35	) -> Result<Vec<TokenId>>;36	#[rpc(name = "unique_tokenExists")]37	fn token_exists(38		&self,39		collection: CollectionId,40		token: TokenId,41		at: Option<BlockHash>,42	) -> Result<bool>;4344	#[rpc(name = "unique_tokenOwner")]45	fn token_owner(46		&self,47		collection: CollectionId,48		token: TokenId,49		at: Option<BlockHash>,50	) -> Result<Option<CrossAccountId>>;51	#[rpc(name = "unique_constMetadata")]52	fn const_metadata(53		&self,54		collection: CollectionId,55		token: TokenId,56		at: Option<BlockHash>,57	) -> Result<Vec<u8>>;58	#[rpc(name = "unique_variableMetadata")]59	fn variable_metadata(60		&self,61		collection: CollectionId,62		token: TokenId,63		at: Option<BlockHash>,64	) -> Result<Vec<u8>>;6566	#[rpc(name = "unique_collectionTokens")]67	fn collection_tokens(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<u32>;68	#[rpc(name = "unique_accountBalance")]69	fn account_balance(70		&self,71		collection: CollectionId,72		account: CrossAccountId,73		at: Option<BlockHash>,74	) -> Result<u32>;75	#[rpc(name = "unique_balance")]76	fn balance(77		&self,78		collection: CollectionId,79		account: CrossAccountId,80		token: TokenId,81		at: Option<BlockHash>,82	) -> Result<String>;83	#[rpc(name = "unique_allowance")]84	fn allowance(85		&self,86		collection: CollectionId,87		sender: CrossAccountId,88		spender: CrossAccountId,89		token: TokenId,90		at: Option<BlockHash>,91	) -> Result<String>;9293	#[rpc(name = "unique_adminlist")]94	fn adminlist(95		&self,96		collection: CollectionId,97		at: Option<BlockHash>,98	) -> Result<Vec<CrossAccountId>>;99	#[rpc(name = "unique_allowlist")]100	fn allowlist(101		&self,102		collection: CollectionId,103		at: Option<BlockHash>,104	) -> Result<Vec<CrossAccountId>>;105	#[rpc(name = "unique_allowed")]106	fn allowed(107		&self,108		collection: CollectionId,109		user: CrossAccountId,110		at: Option<BlockHash>,111	) -> Result<bool>;112	#[rpc(name = "unique_lastTokenId")]113	fn last_token_id(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<TokenId>;114	#[rpc(name = "unique_collectionById")]115	fn collection_by_id(116		&self,117		collection: CollectionId,118		at: Option<BlockHash>,119	) -> Result<Option<Collection<AccountId>>>;120	#[rpc(name = "unique_collectionStats")]121	fn collection_stats(&self, at: Option<BlockHash>) -> Result<CollectionStats>;122}123124pub struct Unique<C, P> {125	client: Arc<C>,126	_marker: std::marker::PhantomData<P>,127}128129impl<C, P> Unique<C, P> {130	pub fn new(client: Arc<C>) -> Self {131		Self {132			client,133			_marker: Default::default(),134		}135	}136}137138pub enum Error {139	RuntimeError,140}141142impl From<Error> for i64 {143	fn from(e: Error) -> i64 {144		match e {145			Error::RuntimeError => 1,146		}147	}148}149150macro_rules! pass_method {151	(152		$method_name:ident($($name:ident: $ty:ty),* $(,)?) -> $result:ty $(=> $mapper:expr)?153		$(; changed_in $ver:expr, $changed_method_name:ident ($($changed_name:expr), * $(,)?) => $fixer:expr)*154	) => {155		fn $method_name(156			&self,157			$(158				$name: $ty,159			)*160			at: Option<<Block as BlockT>::Hash>,161		) -> Result<$result> {162			let api = self.client.runtime_api();163			let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash));164			let _api_version = if let Ok(Some(api_version)) =165				api.api_version::<dyn UniqueRuntimeApi<Block, CrossAccountId, AccountId>>(&at)166			{167				api_version168			} else {169				// unreachable for our runtime170				return Err(RpcError {171					code: ErrorCode::InvalidParams,172					message: "Api is not available".into(),173					data: None,174				})175			};176177			let result = $(if _api_version < $ver {178				api.$changed_method_name(&at, $($changed_name),*).map(|r| r.map($fixer))179			} else)*180			{ api.$method_name(&at, $($name),*) };181182			let result = result.map_err(|e| RpcError {183				code: ErrorCode::ServerError(Error::RuntimeError.into()),184				message: "Unable to query".into(),185				data: Some(format!("{:?}", e).into()),186			})?;187			result.map_err(|e| RpcError {188				code: ErrorCode::InvalidParams,189				message: "Runtime returned error".into(),190				data: Some(format!("{:?}", e).into()),191			})$(.map($mapper))?192		}193	};194}195196#[allow(deprecated)]197impl<C, Block, CrossAccountId, AccountId>198	UniqueApi<<Block as BlockT>::Hash, CrossAccountId, AccountId> for Unique<C, Block>199where200	Block: BlockT,201	AccountId: Decode,202	C: 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,203	C::Api: UniqueRuntimeApi<Block, CrossAccountId, AccountId>,204	CrossAccountId: pallet_common::account::CrossAccountId<AccountId>,205{206	pass_method!(account_tokens(collection: CollectionId, account: CrossAccountId) -> Vec<TokenId>);207	pass_method!(token_exists(collection: CollectionId, token: TokenId) -> bool);208	pass_method!(209		token_owner(collection: CollectionId, token: TokenId) -> Option<CrossAccountId>;210		changed_in 2, token_owner_before_version_2(collection, token) => |u| Some(u)211	);212	pass_method!(const_metadata(collection: CollectionId, token: TokenId) -> Vec<u8>);213	pass_method!(variable_metadata(collection: CollectionId, token: TokenId) -> Vec<u8>);214	pass_method!(collection_tokens(collection: CollectionId) -> u32);215	pass_method!(account_balance(collection: CollectionId, account: CrossAccountId) -> u32);216	pass_method!(balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> String => |v| v.to_string());217	pass_method!(allowance(collection: CollectionId, sender: CrossAccountId, spender: CrossAccountId, token: TokenId) -> String => |v| v.to_string());218219	pass_method!(adminlist(collection: CollectionId) -> Vec<CrossAccountId>);220	pass_method!(allowlist(collection: CollectionId) -> Vec<CrossAccountId>);221	pass_method!(allowed(collection: CollectionId, user: CrossAccountId) -> bool);222	pass_method!(last_token_id(collection: CollectionId) -> TokenId);223	pass_method!(collection_by_id(collection: CollectionId) -> Option<Collection<AccountId>>);224	pass_method!(collection_stats() -> CollectionStats);225}
modifiedpallets/unique/src/lib.rsdiffbeforeafterboth
--- a/pallets/unique/src/lib.rs
+++ b/pallets/unique/src/lib.rs
@@ -69,7 +69,7 @@
 
 mod eth;
 mod sponsorship;
-pub use sponsorship::UniqueSponsorshipHandler;
+pub use sponsorship::{UniqueSponsorshipHandler, UniqueSponsorshipPredict};
 pub use eth::sponsoring::UniqueEthSponsorshipHandler;
 
 pub use eth::UniqueErcSupport;
@@ -84,6 +84,12 @@
 pub mod weights;
 use weights::WeightInfo;
 
+pub trait SponsorshipPredict<T: Config> {
+	fn predict(collection: CollectionId, account: T::CrossAccountId, token: TokenId) -> Option<u64>
+	where
+		u64: From<<T as frame_system::Config>::BlockNumber>;
+}
+
 decl_error! {
 	/// Error for non-fungible-token module.
 	pub enum Error for Module<T: Config> {
modifiedpallets/unique/src/sponsorship.rsdiffbeforeafterboth
--- a/pallets/unique/src/sponsorship.rs
+++ b/pallets/unique/src/sponsorship.rs
@@ -301,3 +301,80 @@
 		}
 	}
 }
+
+use crate::SponsorshipPredict;
+use up_data_structs::SponsorshipState;
+pub struct UniqueSponsorshipPredict<T>(PhantomData<T>);
+
+impl<T> SponsorshipPredict<T> for UniqueSponsorshipPredict<T>
+where
+	T: Config,
+{
+	fn predict(collection_id: CollectionId, who: T::CrossAccountId, token: TokenId) -> Option<u64>
+	where
+		u64: From<<T as frame_system::Config>::BlockNumber>,
+	{
+		let collection = <CollectionHandle<T>>::try_get(collection_id).ok()?;
+
+		// preliminary sponsoring correctness check
+		match collection.sponsorship {
+			SponsorshipState::Disabled | SponsorshipState::Unconfirmed(_) => return None,
+			_ => (),
+		}
+
+		// sponsor timeout
+		let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;
+		let limit = collection
+			.limits
+			.sponsor_transfer_timeout(match collection.mode {
+				CollectionMode::NFT => NFT_SPONSOR_TRANSFER_TIMEOUT,
+				CollectionMode::Fungible(_) => FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
+				CollectionMode::ReFungible => REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
+			});
+
+		let last_tx_block = match collection.mode {
+			CollectionMode::NFT => <NftTransferBasket<T>>::get(collection.id, token),
+			CollectionMode::Fungible(_) => {
+				<FungibleTransferBasket<T>>::get(collection.id, who.as_sub())
+			}
+			CollectionMode::ReFungible => {
+				<ReFungibleTransferBasket<T>>::get((collection.id, token, who.as_sub()))
+			}
+		};
+
+		if let Some(last_tx_block) = last_tx_block {
+			let timeout = last_tx_block + limit.into();
+			if block_number < timeout {
+				return Some((timeout - block_number).into());
+			}
+			return Some(0);
+		}
+
+		let token_exists = match collection.mode {
+			CollectionMode::NFT => {
+				<pallet_nonfungible::TokenData<T>>::contains_key((collection.id, token))
+			}
+			CollectionMode::Fungible(_) => true,
+			CollectionMode::ReFungible => {
+				<pallet_refungible::TotalSupply<T>>::contains_key((collection.id, token))
+			}
+		};
+
+		if token_exists {
+			Some(0)
+		} else {
+			None
+		}
+
+		// // existance check
+		// match collection.mode {
+		// 	CollectionMode::NFT => <NftTransferBasket<T>>::get(collection.id, token),
+		// 	CollectionMode::Fungible(_) => {
+		// 		<FungibleTransferBasket<T>>::get(collection.id, who.as_sub())
+		// 	}
+		// 	CollectionMode::ReFungible => {
+		// 		<ReFungibleTransferBasket<T>>::get((collection.id, token, who.as_sub()))
+		// 	}
+		// };
+	}
+}
modifiedprimitives/rpc/src/lib.rsdiffbeforeafterboth
--- a/primitives/rpc/src/lib.rs
+++ b/primitives/rpc/src/lib.rs
@@ -59,5 +59,6 @@
 		fn last_token_id(collection: CollectionId) -> Result<TokenId>;
 		fn collection_by_id(collection: CollectionId) -> Result<Option<Collection<AccountId>>>;
 		fn collection_stats() -> Result<CollectionStats>;
+		fn next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<Option<u64>>;
 	}
 }
modifiedruntime/common/src/runtime_apis.rsdiffbeforeafterboth
--- a/runtime/common/src/runtime_apis.rs
+++ b/runtime/common/src/runtime_apis.rs
@@ -69,6 +69,13 @@
                 fn collection_stats() -> Result<CollectionStats, DispatchError> {
                     Ok(<pallet_common::Pallet<Runtime>>::collection_stats())
                 }
+                fn next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<Option<u64>, DispatchError> {
+                    Ok(<pallet_unique::UniqueSponsorshipPredict<Runtime> as
+                            pallet_unique::SponsorshipPredict<Runtime>>::predict(
+                        collection,
+                        account,
+                        token))
+                }
             }
 
             impl sp_api::Core<Block> for Runtime {
modifiedtests/src/interfaces/augment-api-rpc.tsdiffbeforeafterboth
--- a/tests/src/interfaces/augment-api-rpc.ts
+++ b/tests/src/interfaces/augment-api-rpc.ts
@@ -619,6 +619,10 @@
        * Get token variable metadata
        **/
       variableMetadata: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Bytes>>;
+      /**
+       * nextSponsored transaction
+       **/
+      nextSponsored: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array,  account: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<u64>>>;
     };
     web3: {
       /**
modifiedtests/src/interfaces/unique/definitions.tsdiffbeforeafterboth
--- a/tests/src/interfaces/unique/definitions.ts
+++ b/tests/src/interfaces/unique/definitions.ts
@@ -55,5 +55,6 @@
     collectionById: fun('Get collection by specified id', [collectionParam], 'Option<UpDataStructsCollection>'),
     collectionStats: fun('Get collection stats', [], 'UpDataStructsCollectionStats'),
     allowed: fun('Check if user is allowed to use collection', [collectionParam, crossAccountParam()], 'bool'),
+    nextSponsored: fun('Check if user is allowed to use collection', [collectionParam, crossAccountParam(), tokenParam], 'Option<u64>'),
   },
 };