git.delta.rocks / unique-network / refs/commits / 2a441390261c

--- a/pallets/nft-charge-transaction/src/lib.rs
+++ b/pallets/nft-charge-transaction/src/lib.rs
@@ -135,6 +135,13 @@
 			.map(|i| (fee, i));
         }
 
+        // check errors
+        let error = <pallet_nft_transaction_payment::Module<T>>::check_error(who, call);
+        match error {
+            Err(error) => return Err(error),
+            Ok(error) => {}
+        };
+
         // Determine who is paying transaction fee based on ecnomic model
 		// Parse call to extract collection ID and access collection sponsor	
 		let sponsor = <pallet_nft_transaction_payment::Module<T>>::withdraw_type(who, call);

--- a/pallets/nft-transaction-payment/src/lib.rs
+++ b/pallets/nft-transaction-payment/src/lib.rs
@@ -31,6 +31,9 @@
 	traits::{ 
 		Hash, Dispatchable,
 	},
+	transaction_validity::{
+        InvalidTransaction, TransactionValidityError,
+    },
 };
 use pallet_contracts::chain_extension::UncheckedFrom;
 use sp_std::prelude::*;
@@ -85,6 +88,36 @@
 impl<T: Config> Module<T> 
 {
 
+	pub fn check_error(
+		who: &T::AccountId,
+		call: &T::Call
+	) -> Result<bool, TransactionValidityError> where 
+		T::Call: Dispatchable<Info=DispatchInfo>,
+		T::Call: IsSubType<pallet_nft::Call<T>>, 
+		T::Call: IsSubType<pallet_contracts::Call<T>>,
+		T::AccountId: AsRef<[u8]>,
+		T::AccountId: UncheckedFrom<T::Hash>
+		{
+
+			match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {
+				Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {
+	
+					let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());
+	
+					let owned_contract = pallet_nft::ContractOwner::<T>::get(called_contract.clone()).as_ref() == Some(who);
+					let white_list_enabled = pallet_nft::ContractWhiteListEnabled::<T>::contains_key(called_contract.clone());
+					  
+					if !owned_contract && white_list_enabled {
+						if !pallet_nft::ContractWhiteList::<T>::contains_key(called_contract.clone(), who) {
+							return Err(InvalidTransaction::Call.into());
+						}
+					}
+					Ok(true)
+				},
+				_ => { Ok(true) },
+			}
+		}
+
 	pub fn withdraw_type(
 		who: &T::AccountId,
 		call: &T::Call
@@ -366,160 +399,4 @@
 
 		None
 	}
-}
-
-// type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;
-
-// /// Require the transactor pay for themselves and maybe include a tip to gain additional priority
-// /// in the queue.
-// #[derive(Encode, Decode, Clone, Eq, PartialEq)]
-// pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);
-
-// impl<T: Config + Send + Sync> sp_std::fmt::Debug 
-//     for ChargeTransactionPayment<T>
-// {
-// 	#[cfg(feature = "std")]
-// 	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
-// 		write!(f, "ChargeTransactionPayment<{:?}>", self.0)
-// 	}
-// 	#[cfg(not(feature = "std"))]
-// 	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
-// 		Ok(())
-// 	}
-// }
-
-// impl<T: Config> ChargeTransactionPayment<T>
-// where
-// 	T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<pallet_nft::Call<T>> + IsSubType<pallet_contracts::Call<T>>,
-//     BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,
-//     T::AccountId: AsRef<[u8]>,
-//     T::AccountId: UncheckedFrom<T::Hash>,
-// {
-//     fn traditional_fee(
-//         len: usize,
-//         info: &DispatchInfoOf<T::Call>,
-//         tip: BalanceOf<T>,
-//     ) -> BalanceOf<T>
-//     where
-//         T::Call: Dispatchable<Info = DispatchInfo>,
-//     {
-//         <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)
-//     }
-
-// 	fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {
-//         let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);
-//         let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);
-//         let len_saturation = max_block_length as u64 / (len as u64).max(1);
-//         let coefficient: BalanceOf<T> = weight_saturation
-//             .min(len_saturation)
-//             .saturated_into::<BalanceOf<T>>();
-//         final_fee
-//             .saturating_mul(coefficient)
-//             .saturated_into::<TransactionPriority>()
-//     }
-
-//     fn withdraw_fee(
-//         &self,
-//         who: &T::AccountId,
-//         call: &T::Call,
-//         info: &DispatchInfoOf<T::Call>,
-//         len: usize,
-// 	) -> Result<
-// 		(
-// 			BalanceOf<T>,
-// 			<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,
-// 		),
-// 		TransactionValidityError,
-// 	> {
-//         let tip = self.0;
-
-//         let fee = Self::traditional_fee(len, info, tip);
-
-//         // Only mess with balances if fee is not zero.
-//         if fee.is_zero() {
-//             return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)
-// 			.map(|i| (fee, i));
-//         }
-
-//         // Determine who is paying transaction fee based on ecnomic model
-// 		// Parse call to extract collection ID and access collection sponsor
-		
-// 		let sponsor = pallet_nft_transaction_payment::<T>::withdraw_type(who, call);
-// 		//let sponsor = Self::Module::<T>::withdraw_type(who, call);;
-// 		// <pallet_nft_transaction_payment::Module<T>>::withdraw_type(who, call);
-
-//         let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());
-
-// 		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)
-// 			.map(|i| (fee, i))
-//     }
-// }
-
-
-// impl<T: Config + Send + Sync> SignedExtension
-//     for ChargeTransactionPayment<T>
-// where
-//     BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,
-// 	T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<pallet_nft::Call<T>> + IsSubType<pallet_contracts::Call<T>>,
-//     T::AccountId: AsRef<[u8]>,
-//     T::AccountId: UncheckedFrom<T::Hash>,
-// {
-//     const IDENTIFIER: &'static str = "ChargeTransactionPayment";
-//     type AccountId = T::AccountId;
-//     type Call = T::Call;
-//     type AdditionalSigned = ();
-//     type Pre = (
-//         // tip
-//         BalanceOf<T>,
-//         // who pays fee
-//         Self::AccountId,
-// 		// imbalance resulting from withdrawing the fee
-// 		<<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,
-//     );
-//     fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
-//         Ok(())
-//     }
-
-//     fn validate(
-//         &self,
-//         who: &Self::AccountId,
-//         call: &Self::Call,
-//         info: &DispatchInfoOf<Self::Call>,
-//         len: usize,
-//     ) -> TransactionValidity {
-// 		let (fee, _) = self.withdraw_fee(who, call, info, len)?;
-// 		Ok(ValidTransaction {
-// 			priority: Self::get_priority(len, info, fee),
-// 			..Default::default()
-// 		})
-//     }
-
-//     fn pre_dispatch(
-//         self,
-//         who: &Self::AccountId,
-//         call: &Self::Call,
-//         info: &DispatchInfoOf<Self::Call>,
-//         len: usize,
-//     ) -> Result<Self::Pre, TransactionValidityError> {
-//         let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;
-//         Ok((self.0, who.clone(), imbalance))
-//     }
-
-//     fn post_dispatch(
-//         pre: Self::Pre,
-//         info: &DispatchInfoOf<Self::Call>,
-//         post_info: &PostDispatchInfoOf<Self::Call>,
-//         len: usize,
-//         _result: &DispatchResult,
-//     ) -> Result<(), TransactionValidityError> {
-// 		let (tip, who, imbalance) = pre;
-// 		let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(
-// 			len as u32,
-// 			info,
-// 			post_info,
-// 			tip,
-// 		);
-// 		<T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;
-// 		Ok(())
-//     }
-// }
\ No newline at end of file
+}
\ No newline at end of file

--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -32,10 +32,11 @@
 
 use frame_system::{self as system, ensure_signed, ensure_root};
 use sp_runtime::sp_std::prelude::Vec;
+use core::ops::{Deref, DerefMut};
 use nft_data_structs::{
     MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,
 	AccessMode, ChainLimits, Collection, CreateItemData, CollectionLimits,
-    CollectionId, CollectionMode, CollectionHandle, TokenId, 
+    CollectionId, CollectionMode, TokenId, 
     SchemaVersion, SponsorshipState, Ownership,
     NftItemType, FungibleItemType, ReFungibleItemType
 };
@@ -164,7 +165,25 @@
 	}
 }
 
-// + pallet_transaction_payment::Config  + pallet_nft_transaction_payment::Config + pallet_contracts::Config
+pub struct CollectionHandle<T: frame_system::Config> {
+    pub id: CollectionId,
+    pub collection: Collection<T>,
+}
+
+impl<T: frame_system::Config> Deref for CollectionHandle<T> {
+    type Target = Collection<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.collection
+    }
+}
+
+impl<T: frame_system::Config> DerefMut for CollectionHandle<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.collection
+    }
+}
+
 
 
 pub trait Config: system::Config + Sized {

--- a/pallets/scheduler/src/lib.rs
+++ b/pallets/scheduler/src/lib.rs
@@ -102,7 +102,7 @@
 	/// Not strictly enforced, but used for weight estimation.
 	type MaxScheduledPerBlock: Get<u32>;
 
-	/// TODO
+	/// Sponsoring function
 	type Sponsoring: SponsoringResolve<Self::AccountId, <Self as Config>::Call>;
 
 	/// Weight information for extrinsics in this pallet.
@@ -230,8 +230,7 @@
 		///     - Write: Agenda
 		/// - Will use base weight of 25 which should be good for up to 30 scheduled calls
 		/// # </weight>
-		// #[weight = <T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get())]
-		#[weight = 0]
+		#[weight = <T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get())]
 		fn schedule(origin,
 			when: T::BlockNumber,
 			maybe_periodic: Option<schedule::Period<T::BlockNumber>>,
@@ -367,7 +366,7 @@
 			}
 			queued.sort_by_key(|(_, s)| s.priority);
 			let base_weight: Weight = T::DbWeight::get().reads_writes(1, 2); // Agenda + Agenda(next)
-			let mut total_weight: Weight = <T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get());
+			let mut total_weight: Weight = 0;
 			queued.into_iter()
 				.enumerate()
 				.scan(base_weight, |cumulative_weight, (order, (index, s))| {
@@ -407,7 +406,7 @@
 						).into();
 						let sender = ensure_signed(origin).unwrap_or(T::AccountId::default());
 						let who_will_pay = T::Sponsoring::resolve(&sender, &s.call.clone()).unwrap_or(
-							T::AccountId::default());
+							sender);
 						let sponsor = T::PalletsOrigin::from(system::RawOrigin::Signed(who_will_pay));
 						let r = s.call.clone().dispatch(sponsor.into());
 						let maybe_id = s.maybe_id.clone();

1313
14// Pallets that must always be present14// Pallets that must always be present
15const requiredPallets = [15const requiredPallets = [
16  'nft', 'inflation', 'balances', 'contracts', 'randomnesscollectiveflip', 'system', 'timestamp', 'transactionpayment', 'treasury', 'vesting'16  'nft', 'inflation', 'balances', 'contracts', 'randomnesscollectiveflip', 'system', 'timestamp', 'transactionpayment', 'treasury', 'vesting',
17  'scheduler', 'nftpayment', 'charging'
17];18];
1819
19// Pallets that depend on consensus and governance configuration20// Pallets that depend on consensus and governance configuration

--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -5,7 +5,7 @@
 
 import { ApiPromise, Keyring } from '@polkadot/api';
 import { Enum, Struct } from '@polkadot/types/codec';
-import type { AccountId, EventRecord } from '@polkadot/types/interfaces';
+import type { AccountId, BlockNumber, Call, EventRecord } from '@polkadot/types/interfaces';
 import { u128 } from '@polkadot/types/primitive';
 import { IKeyringPair } from '@polkadot/types/types';
 import { BigNumber } from 'bignumber.js';
@@ -17,6 +17,8 @@
 import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';
 import { ICollectionInterface } from '../types';
 import { hexToStr, strToUTF16, utf16ToStr } from './util';
+import { Compact, Option, Raw, Vec } from '@polkadot/types/codec';
+// import { AccountId, AccountIdOf, AccountIndex, Address, AssetId, Balance, BalanceOf, Block, BlockNumber, Call, ChangesTrieConfiguration, Consensus, ConsensusEngineId, Digest, DigestItem, DispatchClass, DispatchInfo, DispatchInfoTo190, EcdsaSignature, Ed25519Signature, Extrinsic, ExtrinsicEra, ExtrinsicPayload, ExtrinsicPayloadUnknown, ExtrinsicPayloadV1, ExtrinsicPayloadV2, ExtrinsicPayloadV3, ExtrinsicPayloadV4, ExtrinsicSignatureV1, ExtrinsicSignatureV2, ExtrinsicSignatureV3, ExtrinsicSignatureV4, ExtrinsicUnknown, ExtrinsicV1, ExtrinsicV2, ExtrinsicV3, ExtrinsicV4, Hash, Header, ImmortalEra, Index, Justification, KeyTypeId, KeyValue, LockIdentifier, LookupSource, LookupTarget, Moment, MortalEra, MultiSignature, Origin, Perbill, Percent, Permill, Perquintill, Phantom, PhantomData, PreRuntime, Seal, SealV0, Signature, SignedBlock, SignerPayload, Sr25519Signature, ValidatorId, Weight, WeightMultiplier } from '@polkadot/types/interfaces/runtime';
 
 chai.use(chaiAsPromised);
 const expect = chai.expect;
@@ -702,6 +704,54 @@
   });
 }
 
+async function getBlockNumber(api: ApiPromise): Promise<number> {
+  return new Promise<number>(async (resolve, reject) => {
+    const unsubscribe = await api.rpc.chain.subscribeNewHeads((head) => {
+        unsubscribe();
+        resolve(head.number.toNumber());
+    });
+  });
+}
+
+export async function
+scheduleTransferExpectSuccess(collectionId: number,
+                      tokenId: number,
+                      sender: IKeyringPair,
+                      recipient: IKeyringPair,
+                      value: number | bigint = 1,
+                      type: string = 'NFT') {
+  await usingApi(async (api: ApiPromise) => {
+    let balanceBefore = new BN(0);
+
+
+    let blockNumber: number | undefined = await getBlockNumber(api);
+    let expectedBlockNumber = blockNumber + 2;
+
+    expect(blockNumber).to.be.greaterThan(0);
+    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value); 
+    const scheduleTx = await api.tx.scheduler.schedule(expectedBlockNumber, null, 0, transferTx);
+
+    const events = await submitTransactionAsync(sender, scheduleTx);
+
+    const sponsorBalanceBefore = new BigNumber((await api.query.system.account(sender.address)).data.free.toString());
+    const recipientBalanceBefore = new BigNumber((await api.query.system.account(recipient.address)).data.free.toString());
+
+    const nftItemDataBefore = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;
+    expect(nftItemDataBefore.Owner.toString()).to.be.equal(sender.address);
+
+    // sleep for 2 blocks
+    await new Promise(resolve => setTimeout(resolve, 6000 * 2));
+
+    const sponsorBalanceAfter = new BigNumber((await api.query.system.account(sender.address)).data.free.toString());
+    const recipientBalanceAfter = new BigNumber((await api.query.system.account(recipient.address)).data.free.toString());
+
+    const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;
+    expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);
+    expect(recipientBalanceAfter.toNumber()).to.be.equal(recipientBalanceBefore.toNumber());
+  });
+}
+
+
 export async function
 transferExpectSuccess(collectionId: number,
                       tokenId: number,