git.delta.rocks / unique-network / refs/commits / 251ea62d352e

difftreelog

fix unbroke ink contract build substrate v0.9.8

Yaroslav Bolyukin2021-08-06parent: #d49b9b4.patch.diff
in: master

7 files changed

modifiedCargo.lockdiffbeforeafterboth
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4935,12 +4935,15 @@
 name = "nft-data-structs"
 version = "0.9.0"
 dependencies = [
+ "derivative",
  "frame-support",
  "frame-system",
+ "max-encoded-len",
  "parity-scale-codec",
  "serde",
  "sp-core",
  "sp-runtime",
+ "sp-std",
 ]
 
 [[package]]
@@ -4999,6 +5002,7 @@
  "cumulus-primitives-core",
  "cumulus-primitives-timestamp",
  "cumulus-primitives-utility",
+ "derivative",
  "fp-rpc",
  "frame-benchmarking",
  "frame-executive",
@@ -5007,6 +5011,7 @@
  "frame-system-benchmarking",
  "frame-system-rpc-runtime-api",
  "hex-literal",
+ "max-encoded-len",
  "nft-data-structs",
  "pallet-aura",
  "pallet-balances",
modifiedpallets/nft/src/lib.rsdiffbeforeafterboth
--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -1675,8 +1675,8 @@
 			CreateItemData::NFT(data) => {
 				let item = NftItemType {
 					owner: owner.clone(),
-					const_data: data.const_data,
-					variable_data: data.variable_data,
+					const_data: data.const_data.into_inner(),
+					variable_data: data.variable_data.into_inner(),
 				};
 
 				Self::add_nft_item(collection, item)?;
@@ -1692,8 +1692,8 @@
 
 				let item = ReFungibleItemType {
 					owner: owner_list,
-					const_data: data.const_data,
-					variable_data: data.variable_data,
+					const_data: data.const_data.into_inner(),
+					variable_data: data.variable_data.into_inner(),
 				};
 
 				Self::add_refungible_item(collection, item)?;
modifiedprimitives/nft/Cargo.tomldiffbeforeafterboth
--- a/primitives/nft/Cargo.toml
+++ b/primitives/nft/Cargo.toml
@@ -9,20 +9,25 @@
 version = '0.9.0'
 
 [dependencies]
-codec = { package = "parity-scale-codec", version = "2.0.0", default-features = false, features = ['derive'] }
+codec = { package = "parity-scale-codec", version = "2.2.0", default-features = false, features = ['derive'] }
 serde = { version = "1.0.119", features = ['derive'], default-features = false }
+max-encoded-len = { default-features = false, features = ['derive'], version = '3.0.0', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
 frame-support = { default-features = false, version = '3.0.0', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
 frame-system = { default-features = false, version = '3.0.0', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
 sp-core = { version = "3.0.0", default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
+sp-std = { version = "3.0.0", default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
 sp-runtime = { version = "3.0.0", default-features = false, git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
+derivative = "2.2.0"
 
 [features]
 default = ["std"]
 std = [
   "serde/std",
   "codec/std",
+  "max-encoded-len/std",
   "frame-system/std",
   "frame-support/std",
   "sp-runtime/std",
   "sp-core/std",
+  "sp-std/std",
 ]
\ No newline at end of file
modifiedprimitives/nft/src/lib.rsdiffbeforeafterboth
44
5use sp_runtime::sp_std::prelude::Vec;5use sp_runtime::sp_std::prelude::Vec;
6use codec::{Decode, Encode};6use codec::{Decode, Encode};
7use max_encoded_len::MaxEncodedLen;
7pub use frame_support::{8pub use frame_support::{
8	construct_runtime, decl_event, decl_module, decl_storage, decl_error,9	BoundedVec, construct_runtime, decl_event, decl_module, decl_storage, decl_error,
9	dispatch::DispatchResult,10	dispatch::DispatchResult,
10	ensure, fail, parameter_types,11	ensure, fail, parameter_types,
11	traits::{12	traits::{
19	},20	},
20	StorageValue, transactional,21	StorageValue, transactional,
21};22};
23use derivative::Derivative;
2224
23pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;25pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;
24pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;26pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;
25pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;27pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;
26pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;28pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;
29
30// TODO: Somehow use ChainLimits for BoundedVec len calculation?
31// Do we need ChainLimits anyway, if we can change them via forkless upgrades?
32parameter_types! {
33pub const MaxDataSize: u32 = 2048;
34// TODO: This limit isn't checked for substrate create_multiple_items call
35pub const MaxItemsPerBatch: u32 = 200;
36}
2737
28pub type CollectionId = u32;38pub type CollectionId = u32;
29pub type TokenId = u32;39pub type TokenId = u32;
30pub type DecimalPoints = u8;40pub type DecimalPoints = u8;
3141
32#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]42#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, Serialize, Deserialize)]
33#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
34pub enum CollectionMode {43pub enum CollectionMode {
35	Invalid,44	Invalid,
36	NFT,45	NFT,
60	fn resolve(who: &AccountId, call: &Call) -> Option<AccountId>;69	fn resolve(who: &AccountId, call: &Call) -> Option<AccountId>;
61}70}
6271
63#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]72#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, Serialize, Deserialize)]
64#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
65pub enum AccessMode {73pub enum AccessMode {
66	Normal,74	Normal,
67	WhiteList,75	WhiteList,
72	}80	}
73}81}
7482
75#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]83#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, Serialize, Deserialize)]
76#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
77pub enum SchemaVersion {84pub enum SchemaVersion {
78	ImageURL,85	ImageURL,
79	Unique,86	Unique,
84	}91	}
85}92}
8693
87#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]94#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
88#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
89pub struct Ownership<AccountId> {95pub struct Ownership<AccountId> {
90	pub owner: AccountId,96	pub owner: AccountId,
91	pub fraction: u128,97	pub fraction: u128,
92}98}
9399
94#[derive(Encode, Decode, Debug, Clone, PartialEq)]100#[derive(Encode, Decode, Debug, Clone, PartialEq, Serialize, Deserialize)]
95#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
96pub enum SponsorshipState<AccountId> {101pub enum SponsorshipState<AccountId> {
97	/// The fees are applied to the transaction sender102	/// The fees are applied to the transaction sender
98	Disabled,103	Disabled,
147	pub transfers_enabled: bool,152	pub transfers_enabled: bool,
148}153}
149154
150#[derive(Encode, Decode, Debug, Clone, PartialEq)]155#[derive(Encode, Decode, Debug, Clone, PartialEq, Serialize, Deserialize)]
151#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
152pub struct NftItemType<AccountId> {156pub struct NftItemType<AccountId> {
153	pub owner: AccountId,157	pub owner: AccountId,
154	pub const_data: Vec<u8>,158	pub const_data: Vec<u8>,
155	pub variable_data: Vec<u8>,159	pub variable_data: Vec<u8>,
156}160}
157161
158#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]162#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
159#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
160pub struct FungibleItemType {163pub struct FungibleItemType {
161	pub value: u128,164	pub value: u128,
162}165}
163166
164#[derive(Encode, Decode, Debug, Clone, PartialEq)]167#[derive(Encode, Decode, Debug, Clone, PartialEq, Serialize, Deserialize)]
165#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
166pub struct ReFungibleItemType<AccountId> {168pub struct ReFungibleItemType<AccountId> {
167	pub owner: Vec<Ownership<AccountId>>,169	pub owner: Vec<Ownership<AccountId>>,
168	pub const_data: Vec<u8>,170	pub const_data: Vec<u8>,
169	pub variable_data: Vec<u8>,171	pub variable_data: Vec<u8>,
170}172}
171173
172#[derive(Encode, Decode, Debug, Clone, PartialEq)]174#[derive(Encode, Decode, Debug, Clone, PartialEq, Serialize, Deserialize)]
173#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
174pub struct CollectionLimits<BlockNumber: Encode + Decode> {175pub struct CollectionLimits<BlockNumber: Encode + Decode> {
175	pub account_token_ownership_limit: u32,176	pub account_token_ownership_limit: u32,
176	pub sponsored_data_size: u32,177	pub sponsored_data_size: u32,
200	}201	}
201}202}
202203
203#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]204#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
204#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
205pub struct ChainLimits {205pub struct ChainLimits {
206	pub collection_numbers_limit: u32,206	pub collection_numbers_limit: u32,
207	pub account_token_ownership_limit: u32,207	pub account_token_ownership_limit: u32,
219	pub const_on_chain_schema_limit: u32,219	pub const_on_chain_schema_limit: u32,
220}220}
221
222/// BoundedVec doesn't supports serde
223mod bounded_serde {
224	use core::convert::TryFrom;
225	use frame_support::{BoundedVec, traits::Get};
226	use serde::{
227		ser::{self, Serialize},
228		de::{self, Deserialize, Error},
229	};
230	use sp_std::vec::Vec;
231
232	pub fn serialize<D, V, S>(value: &BoundedVec<V, S>, serializer: D) -> Result<D::Ok, D::Error>
233	where
234		D: ser::Serializer,
235		V: Serialize,
236	{
237		let vec: &Vec<_> = &value;
238		vec.serialize(serializer)
239	}
240
241	pub fn deserialize<'de, D, V, S>(deserializer: D) -> Result<BoundedVec<V, S>, D::Error>
242	where
243		D: de::Deserializer<'de>,
244		V: de::Deserialize<'de>,
245		S: Get<u32>,
246	{
247		// TODO: Implement custom visitor, which will limit vec size at parse time? Will serde only be used by chainspec?
248		let vec = <Vec<V>>::deserialize(deserializer)?;
249		let len = vec.len();
250		TryFrom::try_from(vec).map_err(|_| D::Error::invalid_length(len, &"lesser size"))
251	}
252}
221253
222#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]254#[derive(
255	Encode, Decode, MaxEncodedLen, Default, Derivative, Clone, PartialEq, Serialize, Deserialize,
256)]
223#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]257#[derivative(Debug)]
224pub struct CreateNftData {258pub struct CreateNftData {
259	#[serde(with = "bounded_serde")]
260	#[derivative(Debug="ignore")]
225	pub const_data: Vec<u8>,261	pub const_data: BoundedVec<u8, MaxDataSize>,
262	#[serde(with = "bounded_serde")]
263	#[derivative(Debug="ignore")]
226	pub variable_data: Vec<u8>,264	pub variable_data: BoundedVec<u8, MaxDataSize>,
227}265}
228266
229#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]267#[derive(
230#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]268	Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, Serialize, Deserialize,
269)]
231pub struct CreateFungibleData {270pub struct CreateFungibleData {
232	pub value: u128,271	pub value: u128,
233}272}
234273
235#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]274#[derive(
275	Encode, Decode, MaxEncodedLen, Default, Derivative, Clone, PartialEq, Serialize, Deserialize,
276)]
236#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]277#[derivative(Debug)]
237pub struct CreateReFungibleData {278pub struct CreateReFungibleData {
279	#[serde(with = "bounded_serde")]
280	#[derivative(Debug="ignore")]
238	pub const_data: Vec<u8>,281	pub const_data: BoundedVec<u8, MaxDataSize>,
282	#[serde(with = "bounded_serde")]
283	#[derivative(Debug="ignore")]
239	pub variable_data: Vec<u8>,284	pub variable_data: BoundedVec<u8, MaxDataSize>,
240	pub pieces: u128,285	pub pieces: u128,
241}286}
242287
243#[derive(Encode, Decode, Debug, Clone, PartialEq)]288#[derive(Encode, Decode, MaxEncodedLen, Debug, Clone, PartialEq, Serialize, Deserialize)]
244#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
245pub enum CreateItemData {289pub enum CreateItemData {
246	NFT(CreateNftData),290	NFT(CreateNftData),
247	Fungible(CreateFungibleData),291	Fungible(CreateFungibleData),
modifiedruntime/Cargo.tomldiffbeforeafterboth
--- a/runtime/Cargo.toml
+++ b/runtime/Cargo.toml
@@ -31,6 +31,7 @@
 ]
 std = [
     'codec/std',
+    'max-encoded-len/std',
     'cumulus-pallet-aura-ext/std',
     'cumulus-pallet-parachain-system/std',
     'cumulus-pallet-xcm/std',
@@ -378,6 +379,8 @@
 # local dependencies
 
 [dependencies]
+max-encoded-len = { default-features = false, features = ['derive'], version = '3.0.0', git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }
+derivative = "2.2.0"
 pallet-nft = { path = '../pallets/nft', default-features = false, version = '3.0.0' }
 pallet-inflation = { path = '../pallets/inflation', default-features = false, version = '3.0.0' }
 nft-data-structs = { path = '../primitives/nft', default-features = false, version = '0.9.0' }
modifiedruntime/src/chain_extension.rsdiffbeforeafterboth
--- a/runtime/src/chain_extension.rs
+++ b/runtime/src/chain_extension.rs
@@ -6,6 +6,8 @@
 //
 
 use codec::{Decode, Encode};
+use max_encoded_len::MaxEncodedLen;
+use derivative::Derivative;
 
 pub use pallet_contracts::chain_extension::RetVal;
 use pallet_contracts::chain_extension::{
@@ -19,61 +21,63 @@
 pub use pallet_nft::*;
 use pallet_nft::CrossAccountId;
 use nft_data_structs::*;
-
-use crate::Vec;
 
 /// Create item parameters
-#[derive(Debug, PartialEq, Encode, Decode)]
-pub struct NFTExtCreateItem<E: Ext> {
-	pub owner: <E::T as SysConfig>::AccountId,
+#[derive(Debug, PartialEq, Encode, Decode, MaxEncodedLen)]
+pub struct NFTExtCreateItem<AccountId> {
+	pub owner: AccountId,
 	pub collection_id: u32,
 	pub data: CreateItemData,
 }
 
 /// Transfer parameters
-#[derive(Debug, PartialEq, Encode, Decode)]
-pub struct NFTExtTransfer<E: Ext> {
-	pub recipient: <E::T as SysConfig>::AccountId,
+#[derive(Debug, PartialEq, Encode, Decode, MaxEncodedLen)]
+pub struct NFTExtTransfer<AccountId> {
+	pub recipient: AccountId,
 	pub collection_id: u32,
 	pub token_id: u32,
 	pub amount: u128,
 }
 
-#[derive(Debug, PartialEq, Encode, Decode)]
-pub struct NFTExtCreateMultipleItems<E: Ext> {
-	pub owner: <E::T as SysConfig>::AccountId,
+#[derive(Derivative, PartialEq, Encode, Decode, MaxEncodedLen)]
+#[derivative(Debug)]
+pub struct NFTExtCreateMultipleItems<AccountId> {
+	pub owner: AccountId,
 	pub collection_id: u32,
-	pub data: Vec<CreateItemData>,
+	#[derivative(Debug = "ignore")]
+	pub data: BoundedVec<CreateItemData, MaxItemsPerBatch>,
 }
 
-#[derive(Debug, PartialEq, Encode, Decode)]
-pub struct NFTExtApprove<E: Ext> {
-	pub spender: <E::T as SysConfig>::AccountId,
+#[derive(Debug, PartialEq, Encode, Decode, MaxEncodedLen)]
+pub struct NFTExtApprove<AccountId> {
+	pub spender: AccountId,
 	pub collection_id: u32,
 	pub item_id: u32,
 	pub amount: u128,
 }
 
-#[derive(Debug, PartialEq, Encode, Decode)]
-pub struct NFTExtTransferFrom<E: Ext> {
-	pub owner: <E::T as SysConfig>::AccountId,
-	pub recipient: <E::T as SysConfig>::AccountId,
+#[derive(Debug, PartialEq, Encode, Decode, MaxEncodedLen)]
+pub struct NFTExtTransferFrom<AccountId> {
+	pub owner: AccountId,
+	pub recipient: AccountId,
 	pub collection_id: u32,
 	pub item_id: u32,
 	pub amount: u128,
 }
 
-#[derive(Debug, PartialEq, Encode, Decode)]
+#[derive(Derivative, PartialEq, Encode, Decode, MaxEncodedLen)]
+#[derivative(Debug)]
 pub struct NFTExtSetVariableMetaData {
 	pub collection_id: u32,
 	pub item_id: u32,
-	pub data: Vec<u8>,
+	#[derivative(Debug = "ignore")]
+	pub data: BoundedVec<u8, MaxDataSize>,
 }
 
-#[derive(Debug, PartialEq, Encode, Decode)]
-pub struct NFTExtToggleWhiteList<E: Ext> {
+#[derive(Debug, PartialEq, Encode, Decode, MaxEncodedLen)]
+pub struct NFTExtToggleWhiteList<AccountId> {
 	pub collection_id: u32,
-	pub address: <E::T as SysConfig>::AccountId,
+	pub address: AccountId,
 	pub whitelisted: bool,
 }
 
@@ -82,6 +86,8 @@
 
 pub type NftWeightInfoOf<C> = <C as pallet_nft::Config>::WeightInfo;
 
+pub type AccountIdOf<C> = <C as SysConfig>::AccountId;
+
 impl<C: Config + pallet_contracts::Config> ChainExtension<C> for NFTExtension {
 	fn call<E: Ext>(func_id: u32, env: Environment<E, InitState>) -> Result<RetVal, DispatchError>
 	where
@@ -93,7 +99,7 @@
 		match func_id {
 			0 => {
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtTransfer<E> = env.read_as()?;
+				let input: NFTExtTransfer<AccountIdOf<C>> = env.read_as()?;
 				env.charge_weight(NftWeightInfoOf::<C>::transfer())?;
 
 				let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
@@ -106,13 +112,13 @@
 					input.amount,
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			1 => {
 				// Create Item
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtCreateItem<E> = env.read_as()?;
+				let input: NFTExtCreateItem<AccountIdOf<C>> = env.read_as()?;
 				env.charge_weight(NftWeightInfoOf::<C>::create_item(input.data.data_size()))?;
 
 				let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
@@ -124,13 +130,13 @@
 					input.data,
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			2 => {
 				// Create multiple items
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtCreateMultipleItems<E> = env.read_as()?;
+				let input: NFTExtCreateMultipleItems<AccountIdOf<C>> = env.read_as()?;
 				env.charge_weight(NftWeightInfoOf::<C>::create_item(
 					input.data.iter().map(|i| i.data_size()).sum(),
 				))?;
@@ -141,16 +147,16 @@
 					&C::CrossAccountId::from_sub(env.ext().address().clone()),
 					&collection,
 					&C::CrossAccountId::from_sub(input.owner),
-					input.data,
+					input.data.into_inner(),
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			3 => {
 				// Approve
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtApprove<E> = env.read_as()?;
+				let input: NFTExtApprove<AccountIdOf<C>> = env.read_as()?;
 				env.charge_weight(NftWeightInfoOf::<C>::approve())?;
 
 				let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
@@ -163,13 +169,13 @@
 					input.amount,
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			4 => {
 				// Transfer from
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtTransferFrom<E> = env.read_as()?;
+				let input: NFTExtTransferFrom<AccountIdOf<C>> = env.read_as()?;
 				env.charge_weight(NftWeightInfoOf::<C>::transfer_from())?;
 
 				let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
@@ -183,7 +189,7 @@
 					input.amount,
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			5 => {
@@ -198,16 +204,16 @@
 					&C::CrossAccountId::from_sub(env.ext().address().clone()),
 					&collection,
 					input.item_id,
-					input.data,
+					input.data.into_inner(),
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			6 => {
 				// Toggle whitelist
 				let mut env = env.buf_in_buf_out();
-				let input: NFTExtToggleWhiteList<E> = env.read_as()?;
+				let input: NFTExtToggleWhiteList<AccountIdOf<C>> = env.read_as()?;
 				env.charge_weight(NftWeightInfoOf::<C>::add_to_white_list())?;
 
 				let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
@@ -219,7 +225,7 @@
 					input.whitelisted,
 				)?;
 
-				pallet_nft::Module::<C>::submit_logs(collection)?;
+				collection.submit_logs()?;
 				Ok(RetVal::Converging(0))
 			}
 			_ => Err(DispatchError::Other("unknown chain_extension func_id")),
modifiedruntime/src/lib.rsdiffbeforeafterboth
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -72,7 +72,6 @@
 use sp_runtime::{
 	traits::{Dispatchable},
 };
-// use pallet_contracts::chain_extension::UncheckedFrom;
 
 // pub use pallet_timestamp::Call as TimestampCall;
 pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;
@@ -419,7 +418,7 @@
 	type DepositPerStorageItem = DepositPerStorageItem;
 	type RentFraction = RentFraction;
 	type SurchargeReward = SurchargeReward;
-	type WeightPrice = pallet_transaction_payment::Module<Self>;
+	type WeightPrice = pallet_transaction_payment::Pallet<Self>;
 	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;
 	type ChainExtension = NFTExtension;
 	type DeletionQueueDepth = DeletionQueueDepth;