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

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5996,34 +5996,34 @@
 [[package]]
 name = "pallet-scheduler"
 version = "3.0.0"
-source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.3#c94e0cdfe5556680dca1996004751eeb114755d7"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
  "frame-system",
  "log",
  "parity-scale-codec 2.1.3",
+ "serde",
+ "sp-core",
  "sp-io",
  "sp-runtime",
  "sp-std",
+ "substrate-test-utils",
+ "up-sponsorship",
 ]
 
 [[package]]
 name = "pallet-scheduler"
 version = "3.0.0"
+source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.3#c94e0cdfe5556680dca1996004751eeb114755d7"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
  "frame-system",
  "log",
  "parity-scale-codec 2.1.3",
- "serde",
- "sp-core",
  "sp-io",
  "sp-runtime",
  "sp-std",
- "substrate-test-utils",
- "up-sponsorship",
 ]
 
 [[package]]

--- a/crates/evm-coder-macros/src/solidity_interface.rs
+++ b/crates/evm-coder-macros/src/solidity_interface.rs
@@ -264,7 +264,7 @@
 			ReturnType::Type(_, ty) => ty,
 			_ => return Err(syn::Error::new(value.sig.output.span(), "interface method should return Result<value>\nif there is no value to return - specify void (which is alias to unit)")),
 		};
-		let result = parse_result_ok(&result)?;
+		let result = parse_result_ok(result)?;
 
 		let camel_name = info
 			.rename_selector
@@ -285,8 +285,8 @@
 		Ok(Self {
 			name: ident.clone(),
 			camel_name,
-			pascal_name: snake_ident_to_pascal(&ident),
-			screaming_name: snake_ident_to_screaming(&ident),
+			pascal_name: snake_ident_to_pascal(ident),
+			screaming_name: snake_ident_to_screaming(ident),
 			selector_str,
 			selector,
 			args,
@@ -433,7 +433,7 @@
 						found_error = true;
 					}
 				}
-				TraitItem::Method(method) => methods.push(Method::try_from(&method)?),
+				TraitItem::Method(method) => methods.push(Method::try_from(method)?),
 				_ => {}
 			}
 		}

--- a/crates/evm-coder-macros/src/to_log.rs
+++ b/crates/evm-coder-macros/src/to_log.rs
@@ -41,7 +41,7 @@
 impl Event {
 	fn try_from(variant: &Variant) -> syn::Result<Self> {
 		let name = &variant.ident;
-		let name_screaming = snake_ident_to_screaming(&name);
+		let name_screaming = snake_ident_to_screaming(name);
 
 		let named = match &variant.fields {
 			Fields::Named(named) => named,
@@ -54,7 +54,7 @@
 		};
 		let mut fields = Vec::new();
 		for field in &named.named {
-			fields.push(EventField::try_from(&field)?);
+			fields.push(EventField::try_from(field)?);
 		}
 		let mut selector_str = format!("{}(", name);
 		for (i, arg) in fields.iter().enumerate() {

--- a/crates/evm-coder/src/abi.rs
+++ b/crates/evm-coder/src/abi.rs
@@ -104,7 +104,7 @@
 	fn subresult(&mut self) -> Result<AbiReader<'i>> {
 		let offset = self.read_usize()?;
 		Ok(AbiReader {
-			buf: &self.buf,
+			buf: self.buf,
 			offset: offset + self.offset,
 		})
 	}
@@ -252,7 +252,7 @@
 impl_abi_writeable!(&str, string);
 impl AbiWrite for &string {
 	fn abi_write(&self, writer: &mut AbiWriter) {
-		writer.string(&self)
+		writer.string(self)
 	}
 }
 

--- a/node/cli/src/cli.rs
+++ b/node/cli/src/cli.rs
@@ -1,6 +1,4 @@
 use crate::chain_spec;
-use cumulus_client_cli;
-use sc_cli;
 use std::path::PathBuf;
 use structopt::StructOpt;
 

--- a/node/cli/src/command.rs
+++ b/node/cli/src/command.rs
@@ -120,8 +120,7 @@
 	}
 
 	fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
-		polkadot_cli::Cli::from_iter([RelayChainCli::executable_name().to_string()].iter())
-			.load_spec(id)
+		polkadot_cli::Cli::from_iter([RelayChainCli::executable_name()].iter()).load_spec(id)
 	}
 
 	fn native_runtime_version(chain_spec: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {
@@ -129,6 +128,7 @@
 	}
 }
 
+#[allow(clippy::borrowed_box)]
 fn extract_genesis_wasm(chain_spec: &Box<dyn sc_service::ChainSpec>) -> Result<Vec<u8>> {
 	let mut storage = chain_spec.build_storage()?;
 
@@ -189,7 +189,7 @@
 			runner.sync_run(|config| {
 				let polkadot_cli = RelayChainCli::new(
 					&config,
-					[RelayChainCli::executable_name().to_string()]
+					[RelayChainCli::executable_name()]
 						.iter()
 						.chain(cli.relaychain_args.iter()),
 				);
@@ -275,7 +275,7 @@
 
 				let polkadot_cli = RelayChainCli::new(
 					&config,
-					[RelayChainCli::executable_name().to_string()]
+					[RelayChainCli::executable_name()]
 						.iter()
 						.chain(cli.relaychain_args.iter()),
 				);

--- a/node/cli/src/service.rs
+++ b/node/cli/src/service.rs
@@ -141,7 +141,7 @@
 
 	let (client, backend, keystore_container, task_manager) =
 		sc_service::new_full_parts::<Block, RuntimeApi, Executor>(
-			&config,
+			config,
 			telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),
 		)?;
 	let client = Arc::new(client);

--- a/pallets/contract-helpers/src/lib.rs
+++ b/pallets/contract-helpers/src/lib.rs
@@ -213,7 +213,7 @@
 					Ok(Some((who.clone(), *code_hash, salt.clone())))
 				}
 				Some(pallet_contracts::Call::instantiate_with_code(_, _, code, _, salt)) => {
-					let code_hash = &T::Hashing::hash(&code);
+					let code_hash = &T::Hashing::hash(code);
 					Ok(Some((who.clone(), *code_hash, salt.clone())))
 				}
 				_ => Ok(None),

--- a/pallets/nft/src/eth/erc_impl.rs
+++ b/pallets/nft/src/eth/erc_impl.rs
@@ -114,7 +114,7 @@
 		let to = T::CrossAccountId::from_eth(to);
 		let token_id = token_id.try_into().map_err(|_| "token_id overflow")?;
 
-		<Module<T>>::transfer_from_internal(&caller, &from, &to, &self, token_id, 1)
+		<Module<T>>::transfer_from_internal(&caller, &from, &to, self, token_id, 1)
 			.map_err(|_| "transferFrom error")?;
 		Ok(())
 	}
@@ -130,7 +130,7 @@
 		let approved = T::CrossAccountId::from_eth(approved);
 		let token_id = token_id.try_into().map_err(|_| "token_id overflow")?;
 
-		<Module<T>>::approve_internal(&caller, &approved, &self, token_id, 1)
+		<Module<T>>::approve_internal(&caller, &approved, self, token_id, 1)
 			.map_err(|_| "approve internal")?;
 		Ok(())
 	}
@@ -176,7 +176,7 @@
 		let to = T::CrossAccountId::from_eth(to);
 		let token_id = token_id.try_into().map_err(|_| "amount overflow")?;
 
-		<Module<T>>::transfer_internal(&caller, &to, &self, token_id, 1)
+		<Module<T>>::transfer_internal(&caller, &to, self, token_id, 1)
 			.map_err(|_| "transfer error")?;
 		Ok(())
 	}
@@ -226,7 +226,7 @@
 		let to = T::CrossAccountId::from_eth(to);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
 
-		<Module<T>>::transfer_internal(&caller, &to, &self, 1, amount)
+		<Module<T>>::transfer_internal(&caller, &to, self, 1, amount)
 			.map_err(|_| "transfer error")?;
 		Ok(true)
 	}
@@ -242,7 +242,7 @@
 		let to = T::CrossAccountId::from_eth(to);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
 
-		<Module<T>>::transfer_from_internal(&caller, &from, &to, &self, 1, amount)
+		<Module<T>>::transfer_from_internal(&caller, &from, &to, self, 1, amount)
 			.map_err(|_| "transferFrom error")?;
 		Ok(true)
 	}
@@ -251,7 +251,7 @@
 		let spender = T::CrossAccountId::from_eth(spender);
 		let amount = amount.try_into().map_err(|_| "amount overflow")?;
 
-		<Module<T>>::approve_internal(&caller, &spender, &self, 1, amount)
+		<Module<T>>::approve_internal(&caller, &spender, self, 1, amount)
 			.map_err(|_| "approve internal")?;
 		Ok(true)
 	}

--- a/pallets/nft/src/eth/mod.rs
+++ b/pallets/nft/src/eth/mod.rs
@@ -108,7 +108,7 @@
 			.unwrap_or(false)
 	}
 	fn get_code(target: &H160) -> Option<Vec<u8>> {
-		map_eth_to_id(&target)
+		map_eth_to_id(target)
 			.and_then(<CollectionById<T>>::get)
 			.map(|collection| {
 				match collection.mode {
@@ -127,7 +127,7 @@
 		input: &[u8],
 		value: U256,
 	) -> Option<PrecompileOutput> {
-		let mut collection = map_eth_to_id(&target)
+		let mut collection = map_eth_to_id(target)
 			.and_then(|id| <CollectionHandle<T>>::get_with_gas_limit(id, gas_limit))?;
 		let (method_id, input) = AbiReader::new_call(input).unwrap();
 		let result = call_internal(&mut collection, *source, method_id, input, value);

--- a/pallets/nft/src/eth/sponsoring.rs
+++ b/pallets/nft/src/eth/sponsoring.rs
@@ -132,10 +132,10 @@
 	) -> Result<Self::LiquidityInfo, pallet_evm::Error<T>> {
 		let mut who_pays_fee = *who;
 		if let WithdrawReason::Call { target, input } = &reason {
-			if let Some(collection_id) = crate::eth::map_eth_to_id(&target) {
+			if let Some(collection_id) = crate::eth::map_eth_to_id(target) {
 				if let Some(collection) = <CollectionById<T>>::get(collection_id) {
 					if let Some(sponsor) = collection.sponsorship.sponsor() {
-						if try_sponsor(who, collection_id, &collection, &input).is_ok() {
+						if try_sponsor(who, collection_id, &collection, input).is_ok() {
 							who_pays_fee =
 								T::EvmBackwardsAddressMapping::from_account_id(sponsor.clone());
 						}

1232		) -> DispatchResult {1232		) -> DispatchResult {
1233			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1233			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1234			let mut target_collection = Self::get_collection(collection_id)?;1234			let mut target_collection = Self::get_collection(collection_id)?;
1235			Self::check_owner_permissions(&target_collection, &sender.as_sub())?;1235			Self::check_owner_permissions(&target_collection, sender.as_sub())?;
1236			let old_limits = &target_collection.limits;1236			let old_limits = &target_collection.limits;
1237			let chain_limits = ChainLimit::get();1237			let chain_limits = ChainLimit::get();
12381238
1267		owner: &T::CrossAccountId,1267		owner: &T::CrossAccountId,
1268		data: CreateItemData,1268		data: CreateItemData,
1269	) -> DispatchResult {1269	) -> DispatchResult {
1270		Self::can_create_items_in_collection(&collection, &sender, &owner, 1)?;1270		Self::can_create_items_in_collection(collection, sender, owner, 1)?;
1271		Self::validate_create_item_args(&collection, &data)?;1271		Self::validate_create_item_args(collection, &data)?;
1272		Self::create_item_no_validation(&collection, owner, data)?;1272		Self::create_item_no_validation(collection, owner, data)?;
12731273
1274		Ok(())1274		Ok(())
1275	}1275	}
1283	) -> DispatchResult {1283	) -> DispatchResult {
1284		target_collection.consume_gas(2000000)?;1284		target_collection.consume_gas(2000000)?;
1285		// Limits check1285		// Limits check
1286		Self::is_correct_transfer(target_collection, &recipient)?;1286		Self::is_correct_transfer(target_collection, recipient)?;
12871287
1288		// Transfer permissions check1288		// Transfer permissions check
1289		ensure!(1289		ensure!(
1290			Self::is_item_owner(&sender, target_collection, item_id)1290			Self::is_item_owner(sender, target_collection, item_id)
1291				|| Self::is_owner_or_admin_permissions(target_collection, &sender),1291				|| Self::is_owner_or_admin_permissions(target_collection, sender),
1292			Error::<T>::NoPermission1292			Error::<T>::NoPermission
1293		);1293		);
12941294
1295		if target_collection.access == AccessMode::WhiteList {1295		if target_collection.access == AccessMode::WhiteList {
1296			Self::check_white_list(target_collection, &sender)?;1296			Self::check_white_list(target_collection, sender)?;
1297			Self::check_white_list(target_collection, &recipient)?;1297			Self::check_white_list(target_collection, recipient)?;
1298		}1298		}
12991299
1300		match target_collection.mode {1300		match target_collection.mode {
1305				recipient.clone(),1305				recipient.clone(),
1306			)?,1306			)?,
1307			CollectionMode::Fungible(_) => {1307			CollectionMode::Fungible(_) => {
1308				Self::transfer_fungible(target_collection, value, &sender, &recipient)?1308				Self::transfer_fungible(target_collection, value, sender, recipient)?
1309			}1309			}
1310			CollectionMode::ReFungible => Self::transfer_refungible(1310			CollectionMode::ReFungible => Self::transfer_refungible(
1311				target_collection,1311				target_collection,
1336		amount: u128,1336		amount: u128,
1337	) -> DispatchResult {1337	) -> DispatchResult {
1338		collection.consume_gas(2000000)?;1338		collection.consume_gas(2000000)?;
1339		Self::token_exists(&collection, item_id)?;1339		Self::token_exists(collection, item_id)?;
13401340
1341		// Transfer permissions check1341		// Transfer permissions check
1342		let bypasses_limits = collection.limits.owner_can_transfer1342		let bypasses_limits = collection.limits.owner_can_transfer
1343			&& Self::is_owner_or_admin_permissions(&collection, &sender);1343			&& Self::is_owner_or_admin_permissions(collection, sender);
13441344
1345		let allowance_limit = if bypasses_limits {1345		let allowance_limit = if bypasses_limits {
1346			None1346			None
1347		} else if let Some(amount) = Self::owned_amount(&sender, &collection, item_id) {1347		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id) {
1348			Some(amount)1348			Some(amount)
1349		} else {1349		} else {
1350			fail!(Error::<T>::NoPermission);1350			fail!(Error::<T>::NoPermission);
1351		};1351		};
13521352
1353		if collection.access == AccessMode::WhiteList {1353		if collection.access == AccessMode::WhiteList {
1354			Self::check_white_list(&collection, &sender)?;1354			Self::check_white_list(collection, sender)?;
1355			Self::check_white_list(&collection, &spender)?;1355			Self::check_white_list(collection, spender)?;
1356		}1356		}
13571357
1358		let allowance: u128 = amount1358		let allowance: u128 = amount
1412			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));1412			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));
14131413
1414		// Limits check1414		// Limits check
1415		Self::is_correct_transfer(&collection, &recipient)?;1415		Self::is_correct_transfer(collection, recipient)?;
14161416
1417		// Transfer permissions check1417		// Transfer permissions check
1418		ensure!(1418		ensure!(
1419			approval >= amount1419			approval >= amount
1420				|| (collection.limits.owner_can_transfer1420				|| (collection.limits.owner_can_transfer
1421					&& Self::is_owner_or_admin_permissions(&collection, &sender)),1421					&& Self::is_owner_or_admin_permissions(collection, sender)),
1422			Error::<T>::NoPermission1422			Error::<T>::NoPermission
1423		);1423		);
14241424
1425		if collection.access == AccessMode::WhiteList {1425		if collection.access == AccessMode::WhiteList {
1426			Self::check_white_list(&collection, &sender)?;1426			Self::check_white_list(collection, sender)?;
1427			Self::check_white_list(&collection, &recipient)?;1427			Self::check_white_list(collection, recipient)?;
1428		}1428		}
14291429
1430		// Reduce approval by transferred amount or remove if remaining approval drops to 01430		// Reduce approval by transferred amount or remove if remaining approval drops to 0
14411441
1442		match collection.mode {1442		match collection.mode {
1443			CollectionMode::NFT => {1443			CollectionMode::NFT => {
1444				Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1444				Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?
1445			}1445			}
1446			CollectionMode::Fungible(_) => {1446			CollectionMode::Fungible(_) => {
1447				Self::transfer_fungible(&collection, amount, &from, &recipient)?1447				Self::transfer_fungible(collection, amount, from, recipient)?
1448			}1448			}
1449			CollectionMode::ReFungible => Self::transfer_refungible(1449			CollectionMode::ReFungible => Self::transfer_refungible(
1450				&collection,1450				collection,
1451				item_id,1451				item_id,
1452				amount,1452				amount,
1453				from.clone(),1453				from.clone(),
1473		item_id: TokenId,1473		item_id: TokenId,
1474		data: Vec<u8>,1474		data: Vec<u8>,
1475	) -> DispatchResult {1475	) -> DispatchResult {
1476		Self::token_exists(&collection, item_id)?;1476		Self::token_exists(collection, item_id)?;
14771477
1478		ensure!(1478		ensure!(
1479			ChainLimit::get().custom_data_limit >= data.len() as u32,1479			ChainLimit::get().custom_data_limit >= data.len() as u32,
14821482
1483		// Modify permissions check1483		// Modify permissions check
1484		ensure!(1484		ensure!(
1485			Self::is_item_owner(&sender, &collection, item_id)1485			Self::is_item_owner(sender, collection, item_id)
1486				|| Self::is_owner_or_admin_permissions(&collection, &sender),1486				|| Self::is_owner_or_admin_permissions(collection, sender),
1487			Error::<T>::NoPermission1487			Error::<T>::NoPermission
1488		);1488		);
14891489
1490		match collection.mode {1490		match collection.mode {
1491			CollectionMode::NFT => Self::set_nft_variable_data(&collection, item_id, data)?,1491			CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,
1492			CollectionMode::ReFungible => {1492			CollectionMode::ReFungible => {
1493				Self::set_re_fungible_variable_data(&collection, item_id, data)?1493				Self::set_re_fungible_variable_data(collection, item_id, data)?
1494			}1494			}
1495			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1495			CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),
1496			_ => fail!(Error::<T>::UnexpectedCollectionType),1496			_ => fail!(Error::<T>::UnexpectedCollectionType),
1506		items_data: Vec<CreateItemData>,1506		items_data: Vec<CreateItemData>,
1507	) -> DispatchResult {1507	) -> DispatchResult {
1508		Self::can_create_items_in_collection(1508		Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;
1509			&collection,
1510			&sender,
1511			&owner,
1512			items_data.len() as u32,
1513		)?;
15141509
1515		for data in &items_data {1510		for data in &items_data {
1516			Self::validate_create_item_args(&collection, data)?;1511			Self::validate_create_item_args(collection, data)?;
1517		}1512		}
1518		for data in &items_data {1513		for data in &items_data {
1519			Self::create_item_no_validation(&collection, owner, data.clone())?;1514			Self::create_item_no_validation(collection, owner, data.clone())?;
1520		}1515		}
15211516
1522		Ok(())1517		Ok(())
1529		value: u128,1524		value: u128,
1530	) -> DispatchResult {1525	) -> DispatchResult {
1531		ensure!(1526		ensure!(
1532			Self::is_item_owner(&sender, &collection, item_id)1527			Self::is_item_owner(sender, collection, item_id)
1533				|| (collection.limits.owner_can_transfer1528				|| (collection.limits.owner_can_transfer
1534					&& Self::is_owner_or_admin_permissions(&collection, &sender)),1529					&& Self::is_owner_or_admin_permissions(collection, sender)),
1535			Error::<T>::NoPermission1530			Error::<T>::NoPermission
1536		);1531		);
15371532
1538		if collection.access == AccessMode::WhiteList {1533		if collection.access == AccessMode::WhiteList {
1539			Self::check_white_list(&collection, &sender)?;1534			Self::check_white_list(collection, sender)?;
1540		}1535		}
15411536
1542		match collection.mode {1537		match collection.mode {
1543			CollectionMode::NFT => Self::burn_nft_item(&collection, item_id)?,1538			CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,
1544			CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &collection, value)?,1539			CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,
1545			CollectionMode::ReFungible => {1540			CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,
1546				Self::burn_refungible_item(&collection, item_id, &sender)?
1547			}
1548			_ => (),1541			_ => (),
1549		};1542		};
15501543
1557		address: &T::CrossAccountId,1550		address: &T::CrossAccountId,
1558		whitelisted: bool,1551		whitelisted: bool,
1559	) -> DispatchResult {1552	) -> DispatchResult {
1560		Self::check_owner_or_admin_permissions(&collection, &sender)?;1553		Self::check_owner_or_admin_permissions(collection, sender)?;
15611554
1562		if whitelisted {1555		if whitelisted {
1563			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);1556			<WhiteList<T>>::insert(collection.id, address.as_sub(), true);
1610			Error::<T>::AccountTokenLimitExceeded1603			Error::<T>::AccountTokenLimitExceeded
1611		);1604		);
16121605
1613		if !Self::is_owner_or_admin_permissions(collection, &sender) {1606		if !Self::is_owner_or_admin_permissions(collection, sender) {
1614			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1607			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);
1615			Self::check_white_list(collection, owner)?;1608			Self::check_white_list(collection, owner)?;
1616			Self::check_white_list(collection, sender)?;1609			Self::check_white_list(collection, sender)?;
1691				Self::add_nft_item(collection, item)?;1684				Self::add_nft_item(collection, item)?;
1692			}1685			}
1693			CreateItemData::Fungible(data) => {1686			CreateItemData::Fungible(data) => {
1694				Self::add_fungible_item(collection, &owner, data.value)?;1687				Self::add_fungible_item(collection, owner, data.value)?;
1695			}1688			}
1696			CreateItemData::ReFungible(data) => {1689			CreateItemData::ReFungible(data) => {
1697				let owner_list = vec![Ownership {1690				let owner_list = vec![Ownership {
1934		subject: &T::CrossAccountId,1927		subject: &T::CrossAccountId,
1935	) -> bool {1928	) -> bool {
1936		*subject.as_sub() == collection.owner1929		*subject.as_sub() == collection.owner
1937			|| <AdminList<T>>::get(collection.id).contains(&subject)1930			|| <AdminList<T>>::get(collection.id).contains(subject)
1938	}1931	}
19391932
1940	fn check_owner_or_admin_permissions(1933	fn check_owner_or_admin_permissions(
1979	) -> bool {1972	) -> bool {
1980		match target_collection.mode {1973		match target_collection.mode {
1981			CollectionMode::Fungible(_) => true,1974			CollectionMode::Fungible(_) => true,
1982			_ => Self::owned_amount(&subject, target_collection, item_id).is_some(),1975			_ => Self::owned_amount(subject, target_collection, item_id).is_some(),
1983		}1976		}
1984	}1977	}
19851978

--- a/pallets/nft/src/sponsorship.rs
+++ b/pallets/nft/src/sponsorship.rs
@@ -179,14 +179,14 @@
 {
 	fn get_sponsor(who: &T::AccountId, call: &C) -> Option<T::AccountId> {
 		match IsSubType::<Call<T>>::is_sub_type(call)? {
-			Call::create_item(collection_id, _owner, _properties) => {
-				Self::withdraw_create_item(who, collection_id, &_properties)
+			Call::create_item(collection_id, _owner, properties) => {
+				Self::withdraw_create_item(who, collection_id, properties)
 			}
 			Call::transfer(_new_owner, collection_id, item_id, _value) => {
 				Self::withdraw_transfer(who, collection_id, item_id)
 			}
 			Call::set_variable_meta_data(collection_id, item_id, data) => {
-				Self::withdraw_set_variable_meta_data(collection_id, item_id, &data)
+				Self::withdraw_set_variable_meta_data(collection_id, item_id, data)
 			}
 			_ => None,
 		}