Use 'Items' and 'Collections' in uniques pallet (#11389)

* Rename class to collection * Use "assets collection" instead of "asset collection" * Rename 'instance' to 'asset' * Change "asset `collection`" to "`collection`" * A bit more clean up * Rename Asset to Item * Add a storage hack * Typos * fix compile * fmt * Fix * cargo run --quiet --profile=production --features=runtime-benchmarks --manifest-path=bin/node/cli/Cargo.toml -- benchmark pallet --chain=dev --steps=50 --repeat=20 --pallet=pallet_uniques --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./frame/uniques/src/weights.rs --template=./.maintain/frame-weight-template.hbs * Update frame/uniques/src/lib.rs * cargo run --quiet --profile=production --features=runtime-benchmarks --manifest-path=bin/node/cli/Cargo.toml -- benchmark pallet --chain=dev --steps=50 --repeat=20 --pallet=pallet_uniques --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./frame/uniques/src/weights.rs --template=./.maintain/frame-weight-template.hbs * Change 'items collection' to 'collection' * Apply suggestions Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com> Co-authored-by: Parity Bot <admin@parity.io>
2026-06-16 20:11:03 +00:00 · 2022-05-16 15:38:12 +02:00
parent 359849b169
commit ed7d1e7ac0
13 changed files with 1114 additions and 1076 deletions
@@ -15,7 +15,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-//! Assets pallet benchmarking.
+//! Uniques pallet benchmarking.

 #![cfg(feature = "runtime-benchmarks")]

@@ -36,32 +36,32 @@ use crate::Pallet as Uniques;

 const SEED: u32 = 0;

-fn create_class<T: Config<I>, I: 'static>(
-) -> (T::ClassId, T::AccountId, <T::Lookup as StaticLookup>::Source) {
+fn create_collection<T: Config<I>, I: 'static>(
+) -> (T::CollectionId, T::AccountId, <T::Lookup as StaticLookup>::Source) {
 	let caller: T::AccountId = whitelisted_caller();
 	let caller_lookup = T::Lookup::unlookup(caller.clone());
-	let class = T::Helper::class(0);
+	let collection = T::Helper::collection(0);
 	T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
 	assert!(Uniques::<T, I>::force_create(
 		SystemOrigin::Root.into(),
-		class,
+		collection,
 		caller_lookup.clone(),
 		false,
 	)
 	.is_ok());
-	(class, caller, caller_lookup)
+	(collection, caller, caller_lookup)
 }

-fn add_class_metadata<T: Config<I>, I: 'static>(
+fn add_collection_metadata<T: Config<I>, I: 'static>(
 ) -> (T::AccountId, <T::Lookup as StaticLookup>::Source) {
-	let caller = Class::<T, I>::get(T::Helper::class(0)).unwrap().owner;
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
 	if caller != whitelisted_caller() {
 		whitelist_account!(caller);
 	}
 	let caller_lookup = T::Lookup::unlookup(caller.clone());
-	assert!(Uniques::<T, I>::set_class_metadata(
+	assert!(Uniques::<T, I>::set_collection_metadata(
 		SystemOrigin::Signed(caller.clone()).into(),
-		T::Helper::class(0),
+		T::Helper::collection(0),
 		vec![0; T::StringLimit::get() as usize].try_into().unwrap(),
 		false,
 	)
@@ -69,37 +69,37 @@ fn add_class_metadata<T: Config<I>, I: 'static>(
 	(caller, caller_lookup)
 }

-fn mint_instance<T: Config<I>, I: 'static>(
+fn mint_item<T: Config<I>, I: 'static>(
 	index: u16,
-) -> (T::InstanceId, T::AccountId, <T::Lookup as StaticLookup>::Source) {
-	let caller = Class::<T, I>::get(T::Helper::class(0)).unwrap().admin;
+) -> (T::ItemId, T::AccountId, <T::Lookup as StaticLookup>::Source) {
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().admin;
 	if caller != whitelisted_caller() {
 		whitelist_account!(caller);
 	}
 	let caller_lookup = T::Lookup::unlookup(caller.clone());
-	let instance = T::Helper::instance(index);
+	let item = T::Helper::item(index);
 	assert!(Uniques::<T, I>::mint(
 		SystemOrigin::Signed(caller.clone()).into(),
-		T::Helper::class(0),
-		instance,
+		T::Helper::collection(0),
+		item,
 		caller_lookup.clone(),
 	)
 	.is_ok());
-	(instance, caller, caller_lookup)
+	(item, caller, caller_lookup)
 }

-fn add_instance_metadata<T: Config<I>, I: 'static>(
-	instance: T::InstanceId,
+fn add_item_metadata<T: Config<I>, I: 'static>(
+	item: T::ItemId,
 ) -> (T::AccountId, <T::Lookup as StaticLookup>::Source) {
-	let caller = Class::<T, I>::get(T::Helper::class(0)).unwrap().owner;
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
 	if caller != whitelisted_caller() {
 		whitelist_account!(caller);
 	}
 	let caller_lookup = T::Lookup::unlookup(caller.clone());
 	assert!(Uniques::<T, I>::set_metadata(
 		SystemOrigin::Signed(caller.clone()).into(),
-		T::Helper::class(0),
-		instance,
+		T::Helper::collection(0),
+		item,
 		vec![0; T::StringLimit::get() as usize].try_into().unwrap(),
 		false,
 	)
@@ -107,10 +107,10 @@ fn add_instance_metadata<T: Config<I>, I: 'static>(
 	(caller, caller_lookup)
 }

-fn add_instance_attribute<T: Config<I>, I: 'static>(
-	instance: T::InstanceId,
+fn add_item_attribute<T: Config<I>, I: 'static>(
+	item: T::ItemId,
 ) -> (BoundedVec<u8, T::KeyLimit>, T::AccountId, <T::Lookup as StaticLookup>::Source) {
-	let caller = Class::<T, I>::get(T::Helper::class(0)).unwrap().owner;
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
 	if caller != whitelisted_caller() {
 		whitelist_account!(caller);
 	}
@@ -118,8 +118,8 @@ fn add_instance_attribute<T: Config<I>, I: 'static>(
 	let key: BoundedVec<_, _> = vec![0; T::KeyLimit::get() as usize].try_into().unwrap();
 	assert!(Uniques::<T, I>::set_attribute(
 		SystemOrigin::Signed(caller.clone()).into(),
-		T::Helper::class(0),
-		Some(instance),
+		T::Helper::collection(0),
+		Some(item),
 		key.clone(),
 		vec![0; T::ValueLimit::get() as usize].try_into().unwrap(),
 	)
@@ -137,24 +137,24 @@ fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::

 benchmarks_instance_pallet! {
 	create {
-		let class = T::Helper::class(0);
-		let origin = T::CreateOrigin::successful_origin(&class);
-		let caller = T::CreateOrigin::ensure_origin(origin.clone(), &class).unwrap();
+		let collection = T::Helper::collection(0);
+		let origin = T::CreateOrigin::successful_origin(&collection);
+		let caller = T::CreateOrigin::ensure_origin(origin.clone(), &collection).unwrap();
 		whitelist_account!(caller);
 		let admin = T::Lookup::unlookup(caller.clone());
 		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
-		let call = Call::<T, I>::create { class, admin };
+		let call = Call::<T, I>::create { collection, admin };
 	}: { call.dispatch_bypass_filter(origin)? }
 	verify {
-		assert_last_event::<T, I>(Event::Created { class: T::Helper::class(0), creator: caller.clone(), owner: caller }.into());
+		assert_last_event::<T, I>(Event::Created { collection: T::Helper::collection(0), creator: caller.clone(), owner: caller }.into());
 	}

 	force_create {
 		let caller: T::AccountId = whitelisted_caller();
 		let caller_lookup = T::Lookup::unlookup(caller.clone());
-	}: _(SystemOrigin::Root, T::Helper::class(0), caller_lookup, true)
+	}: _(SystemOrigin::Root, T::Helper::collection(0), caller_lookup, true)
 	verify {
-		assert_last_event::<T, I>(Event::ForceCreated { class: T::Helper::class(0), owner: caller }.into());
+		assert_last_event::<T, I>(Event::ForceCreated { collection: T::Helper::collection(0), owner: caller }.into());
 	}

 	destroy {
@@ -162,57 +162,57 @@ benchmarks_instance_pallet! {
 		let m in 0 .. 1_000;
 		let a in 0 .. 1_000;

-		let (class, caller, caller_lookup) = create_class::<T, I>();
-		add_class_metadata::<T, I>();
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		add_collection_metadata::<T, I>();
 		for i in 0..n {
-			mint_instance::<T, I>(i as u16);
+			mint_item::<T, I>(i as u16);
 		}
 		for i in 0..m {
-			add_instance_metadata::<T, I>(T::Helper::instance(i as u16));
+			add_item_metadata::<T, I>(T::Helper::item(i as u16));
 		}
 		for i in 0..a {
-			add_instance_attribute::<T, I>(T::Helper::instance(i as u16));
+			add_item_attribute::<T, I>(T::Helper::item(i as u16));
 		}
-		let witness = Class::<T, I>::get(class).unwrap().destroy_witness();
-	}: _(SystemOrigin::Signed(caller), class, witness)
+		let witness = Collection::<T, I>::get(collection).unwrap().destroy_witness();
+	}: _(SystemOrigin::Signed(caller), collection, witness)
 	verify {
-		assert_last_event::<T, I>(Event::Destroyed { class }.into());
+		assert_last_event::<T, I>(Event::Destroyed { collection }.into());
 	}

 	mint {
-		let (class, caller, caller_lookup) = create_class::<T, I>();
-		let instance = T::Helper::instance(0);
-	}: _(SystemOrigin::Signed(caller.clone()), class, instance, caller_lookup)
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let item = T::Helper::item(0);
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, caller_lookup)
 	verify {
-		assert_last_event::<T, I>(Event::Issued { class, instance, owner: caller }.into());
+		assert_last_event::<T, I>(Event::Issued { collection, item, owner: caller }.into());
 	}

 	burn {
-		let (class, caller, caller_lookup) = create_class::<T, I>();
-		let (instance, ..) = mint_instance::<T, I>(0);
-	}: _(SystemOrigin::Signed(caller.clone()), class, instance, Some(caller_lookup))
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, Some(caller_lookup))
 	verify {
-		assert_last_event::<T, I>(Event::Burned { class, instance, owner: caller }.into());
+		assert_last_event::<T, I>(Event::Burned { collection, item, owner: caller }.into());
 	}

 	transfer {
-		let (class, caller, caller_lookup) = create_class::<T, I>();
-		let (instance, ..) = mint_instance::<T, I>(0);
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);

 		let target: T::AccountId = account("target", 0, SEED);
 		let target_lookup = T::Lookup::unlookup(target.clone());
-	}: _(SystemOrigin::Signed(caller.clone()), class, instance, target_lookup)
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, target_lookup)
 	verify {
-		assert_last_event::<T, I>(Event::Transferred { class, instance, from: caller, to: target }.into());
+		assert_last_event::<T, I>(Event::Transferred { collection, item, from: caller, to: target }.into());
 	}

 	redeposit {
 		let i in 0 .. 5_000;
-		let (class, caller, caller_lookup) = create_class::<T, I>();
-		let instances = (0..i).map(|x| mint_instance::<T, I>(x as u16).0).collect::<Vec<_>>();
-		Uniques::<T, I>::force_asset_status(
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let items = (0..i).map(|x| mint_item::<T, I>(x as u16).0).collect::<Vec<_>>();
+		Uniques::<T, I>::force_item_status(
 			SystemOrigin::Root.into(),
-			class,
+			collection,
 			caller_lookup.clone(),
 			caller_lookup.clone(),
 			caller_lookup.clone(),
@@ -220,80 +220,80 @@ benchmarks_instance_pallet! {
 			true,
 			false,
 		)?;
-	}: _(SystemOrigin::Signed(caller.clone()), class, instances.clone())
+	}: _(SystemOrigin::Signed(caller.clone()), collection, items.clone())
 	verify {
-		assert_last_event::<T, I>(Event::Redeposited { class, successful_instances: instances }.into());
+		assert_last_event::<T, I>(Event::Redeposited { collection, successful_items: items }.into());
 	}

 	freeze {
-		let (class, caller, caller_lookup) = create_class::<T, I>();
-		let (instance, ..) = mint_instance::<T, I>(0);
-	}: _(SystemOrigin::Signed(caller.clone()), T::Helper::class(0), T::Helper::instance(0))
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+	}: _(SystemOrigin::Signed(caller.clone()), T::Helper::collection(0), T::Helper::item(0))
 	verify {
-		assert_last_event::<T, I>(Event::Frozen { class: T::Helper::class(0), instance: T::Helper::instance(0) }.into());
+		assert_last_event::<T, I>(Event::Frozen { collection: T::Helper::collection(0), item: T::Helper::item(0) }.into());
 	}

 	thaw {
-		let (class, caller, caller_lookup) = create_class::<T, I>();
-		let (instance, ..) = mint_instance::<T, I>(0);
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
 		Uniques::<T, I>::freeze(
 			SystemOrigin::Signed(caller.clone()).into(),
-			class,
-			instance,
+			collection,
+			item,
 		)?;
-	}: _(SystemOrigin::Signed(caller.clone()), class, instance)
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item)
 	verify {
-		assert_last_event::<T, I>(Event::Thawed { class, instance }.into());
+		assert_last_event::<T, I>(Event::Thawed { collection, item }.into());
 	}

-	freeze_class {
-		let (class, caller, caller_lookup) = create_class::<T, I>();
-	}: _(SystemOrigin::Signed(caller.clone()), class)
+	freeze_collection {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+	}: _(SystemOrigin::Signed(caller.clone()), collection)
 	verify {
-		assert_last_event::<T, I>(Event::ClassFrozen { class }.into());
+		assert_last_event::<T, I>(Event::CollectionFrozen { collection }.into());
 	}

-	thaw_class {
-		let (class, caller, caller_lookup) = create_class::<T, I>();
+	thaw_collection {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
 		let origin = SystemOrigin::Signed(caller.clone()).into();
-		Uniques::<T, I>::freeze_class(origin, class)?;
-	}: _(SystemOrigin::Signed(caller.clone()), class)
+		Uniques::<T, I>::freeze_collection(origin, collection)?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection)
 	verify {
-		assert_last_event::<T, I>(Event::ClassThawed { class }.into());
+		assert_last_event::<T, I>(Event::CollectionThawed { collection }.into());
 	}

 	transfer_ownership {
-		let (class, caller, _) = create_class::<T, I>();
+		let (collection, caller, _) = create_collection::<T, I>();
 		let target: T::AccountId = account("target", 0, SEED);
 		let target_lookup = T::Lookup::unlookup(target.clone());
 		T::Currency::make_free_balance_be(&target, T::Currency::minimum_balance());
 		let origin = SystemOrigin::Signed(target.clone()).into();
-		Uniques::<T, I>::set_accept_ownership(origin, Some(class))?;
-	}: _(SystemOrigin::Signed(caller), class, target_lookup)
+		Uniques::<T, I>::set_accept_ownership(origin, Some(collection))?;
+	}: _(SystemOrigin::Signed(caller), collection, target_lookup)
 	verify {
-		assert_last_event::<T, I>(Event::OwnerChanged { class, new_owner: target }.into());
+		assert_last_event::<T, I>(Event::OwnerChanged { collection, new_owner: target }.into());
 	}

 	set_team {
-		let (class, caller, _) = create_class::<T, I>();
+		let (collection, caller, _) = create_collection::<T, I>();
 		let target0 = T::Lookup::unlookup(account("target", 0, SEED));
 		let target1 = T::Lookup::unlookup(account("target", 1, SEED));
 		let target2 = T::Lookup::unlookup(account("target", 2, SEED));
-	}: _(SystemOrigin::Signed(caller), class, target0, target1, target2)
+	}: _(SystemOrigin::Signed(caller), collection, target0, target1, target2)
 	verify {
 		assert_last_event::<T, I>(Event::TeamChanged{
-			class,
+			collection,
 			issuer: account("target", 0, SEED),
 			admin: account("target", 1, SEED),
 			freezer: account("target", 2, SEED),
 		}.into());
 	}

-	force_asset_status {
-		let (class, caller, caller_lookup) = create_class::<T, I>();
+	force_item_status {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
 		let origin = T::ForceOrigin::successful_origin();
-		let call = Call::<T, I>::force_asset_status {
-			class,
+		let call = Call::<T, I>::force_item_status {
+			collection,
 			owner: caller_lookup.clone(),
 			issuer: caller_lookup.clone(),
 			admin: caller_lookup.clone(),
@@ -303,98 +303,98 @@ benchmarks_instance_pallet! {
 		};
 	}: { call.dispatch_bypass_filter(origin)? }
 	verify {
-		assert_last_event::<T, I>(Event::AssetStatusChanged { class }.into());
+		assert_last_event::<T, I>(Event::ItemStatusChanged { collection }.into());
 	}

 	set_attribute {
 		let key: BoundedVec<_, _> = vec![0u8; T::KeyLimit::get() as usize].try_into().unwrap();
 		let value: BoundedVec<_, _> = vec![0u8; T::ValueLimit::get() as usize].try_into().unwrap();

-		let (class, caller, _) = create_class::<T, I>();
-		let (instance, ..) = mint_instance::<T, I>(0);
-		add_instance_metadata::<T, I>(instance);
-	}: _(SystemOrigin::Signed(caller), class, Some(instance), key.clone(), value.clone())
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		add_item_metadata::<T, I>(item);
+	}: _(SystemOrigin::Signed(caller), collection, Some(item), key.clone(), value.clone())
 	verify {
-		assert_last_event::<T, I>(Event::AttributeSet { class, maybe_instance: Some(instance), key, value }.into());
+		assert_last_event::<T, I>(Event::AttributeSet { collection, maybe_item: Some(item), key, value }.into());
 	}

 	clear_attribute {
-		let (class, caller, _) = create_class::<T, I>();
-		let (instance, ..) = mint_instance::<T, I>(0);
-		add_instance_metadata::<T, I>(instance);
-		let (key, ..) = add_instance_attribute::<T, I>(instance);
-	}: _(SystemOrigin::Signed(caller), class, Some(instance), key.clone())
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		add_item_metadata::<T, I>(item);
+		let (key, ..) = add_item_attribute::<T, I>(item);
+	}: _(SystemOrigin::Signed(caller), collection, Some(item), key.clone())
 	verify {
-		assert_last_event::<T, I>(Event::AttributeCleared { class, maybe_instance: Some(instance), key }.into());
+		assert_last_event::<T, I>(Event::AttributeCleared { collection, maybe_item: Some(item), key }.into());
 	}

 	set_metadata {
 		let data: BoundedVec<_, _> = vec![0u8; T::StringLimit::get() as usize].try_into().unwrap();

-		let (class, caller, _) = create_class::<T, I>();
-		let (instance, ..) = mint_instance::<T, I>(0);
-	}: _(SystemOrigin::Signed(caller), class, instance, data.clone(), false)
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+	}: _(SystemOrigin::Signed(caller), collection, item, data.clone(), false)
 	verify {
-		assert_last_event::<T, I>(Event::MetadataSet { class, instance, data, is_frozen: false }.into());
+		assert_last_event::<T, I>(Event::MetadataSet { collection, item, data, is_frozen: false }.into());
 	}

 	clear_metadata {
-		let (class, caller, _) = create_class::<T, I>();
-		let (instance, ..) = mint_instance::<T, I>(0);
-		add_instance_metadata::<T, I>(instance);
-	}: _(SystemOrigin::Signed(caller), class, instance)
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		add_item_metadata::<T, I>(item);
+	}: _(SystemOrigin::Signed(caller), collection, item)
 	verify {
-		assert_last_event::<T, I>(Event::MetadataCleared { class, instance }.into());
+		assert_last_event::<T, I>(Event::MetadataCleared { collection, item }.into());
 	}

-	set_class_metadata {
+	set_collection_metadata {
 		let data: BoundedVec<_, _> = vec![0u8; T::StringLimit::get() as usize].try_into().unwrap();

-		let (class, caller, _) = create_class::<T, I>();
-	}: _(SystemOrigin::Signed(caller), class, data.clone(), false)
+		let (collection, caller, _) = create_collection::<T, I>();
+	}: _(SystemOrigin::Signed(caller), collection, data.clone(), false)
 	verify {
-		assert_last_event::<T, I>(Event::ClassMetadataSet { class, data, is_frozen: false }.into());
+		assert_last_event::<T, I>(Event::CollectionMetadataSet { collection, data, is_frozen: false }.into());
 	}

-	clear_class_metadata {
-		let (class, caller, _) = create_class::<T, I>();
-		add_class_metadata::<T, I>();
-	}: _(SystemOrigin::Signed(caller), class)
+	clear_collection_metadata {
+		let (collection, caller, _) = create_collection::<T, I>();
+		add_collection_metadata::<T, I>();
+	}: _(SystemOrigin::Signed(caller), collection)
 	verify {
-		assert_last_event::<T, I>(Event::ClassMetadataCleared { class }.into());
+		assert_last_event::<T, I>(Event::CollectionMetadataCleared { collection }.into());
 	}

 	approve_transfer {
-		let (class, caller, _) = create_class::<T, I>();
-		let (instance, ..) = mint_instance::<T, I>(0);
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
 		let delegate: T::AccountId = account("delegate", 0, SEED);
 		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
-	}: _(SystemOrigin::Signed(caller.clone()), class, instance, delegate_lookup)
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, delegate_lookup)
 	verify {
-		assert_last_event::<T, I>(Event::ApprovedTransfer { class, instance, owner: caller, delegate }.into());
+		assert_last_event::<T, I>(Event::ApprovedTransfer { collection, item, owner: caller, delegate }.into());
 	}

 	cancel_approval {
-		let (class, caller, _) = create_class::<T, I>();
-		let (instance, ..) = mint_instance::<T, I>(0);
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
 		let delegate: T::AccountId = account("delegate", 0, SEED);
 		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
 		let origin = SystemOrigin::Signed(caller.clone()).into();
-		Uniques::<T, I>::approve_transfer(origin, class, instance, delegate_lookup.clone())?;
-	}: _(SystemOrigin::Signed(caller.clone()), class, instance, Some(delegate_lookup))
+		Uniques::<T, I>::approve_transfer(origin, collection, item, delegate_lookup.clone())?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, Some(delegate_lookup))
 	verify {
-		assert_last_event::<T, I>(Event::ApprovalCancelled { class, instance, owner: caller, delegate }.into());
+		assert_last_event::<T, I>(Event::ApprovalCancelled { collection, item, owner: caller, delegate }.into());
 	}

 	set_accept_ownership {
 		let caller: T::AccountId = whitelisted_caller();
 		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
-		let class = T::Helper::class(0);
-	}: _(SystemOrigin::Signed(caller.clone()), Some(class))
+		let collection = T::Helper::collection(0);
+	}: _(SystemOrigin::Signed(caller.clone()), Some(collection))
 	verify {
 		assert_last_event::<T, I>(Event::OwnershipAcceptanceChanged {
 			who: caller,
-			maybe_class: Some(class),
+			maybe_collection: Some(collection),
 		}.into());
 	}