[Uniques V2] Atomic NFTs swap

bin/node/runtime/src/lib.rs

@@ -1473,6 +1473,7 @@ parameter_types! {
 	pub const ValueLimit: u32 = 256;
 	pub const ApprovalsLimit: u32 = 20;
 	pub const MaxTips: u32 = 10;
+	pub const MaxDeadlineDuration: BlockNumber = 12 * 30 * DAYS;
 }
 
 impl pallet_uniques::Config for Runtime {
@@ -1512,6 +1513,7 @@ impl pallet_nfts::Config for Runtime {
 	type ValueLimit = ValueLimit;
 	type ApprovalsLimit = ApprovalsLimit;
 	type MaxTips = MaxTips;
+	type MaxDeadlineDuration = MaxDeadlineDuration;
 	type WeightInfo = pallet_nfts::weights::SubstrateWeight<Runtime>;
 	#[cfg(feature = "runtime-benchmarks")]
 	type Helper = ();

frame/nfts/src/benchmarking.rs

@@ -29,7 +29,7 @@ use frame_support::{
 	BoundedVec,
 };
 use frame_system::RawOrigin as SystemOrigin;
-use sp_runtime::traits::Bounded;
+use sp_runtime::traits::{Bounded, One};
 use sp_std::prelude::*;
 
 use crate::Pallet as Nfts;
@@ -476,5 +476,87 @@ benchmarks_instance_pallet! {
 		}
 	}
 
+	create_swap {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item1, ..) = mint_item::<T, I>(0);
+		let (item2, ..) = mint_item::<T, I>(1);
+		let price = ItemPrice::<T, I>::from(100u32);
+		let price_direction = PriceDirection::Receive;
+		let price_with_direction = PriceWithDirection { amount: price, direction: price_direction };
+		let duration = T::MaxDeadlineDuration::get();
+		frame_system::Pallet::<T>::set_block_number(One::one());
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item1, collection, Some(item2), Some(price_with_direction.clone()), duration)
+	verify {
+		let current_block = frame_system::Pallet::<T>::block_number();
+		assert_last_event::<T, I>(Event::SwapCreated {
+			offered_collection: collection,
+			offered_item: item1,
+			desired_collection: collection,
+			desired_item: Some(item2),
+			price: Some(price_with_direction),
+			deadline: current_block.saturating_add(duration),
+		}.into());
+	}
+
+	cancel_swap {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item1, ..) = mint_item::<T, I>(0);
+		let (item2, ..) = mint_item::<T, I>(1);
+		let price = ItemPrice::<T, I>::from(100u32);
+		let origin = SystemOrigin::Signed(caller.clone()).into();
+		let duration = T::MaxDeadlineDuration::get();
+		let price_direction = PriceDirection::Receive;
+		let price_with_direction = PriceWithDirection { amount: price, direction: price_direction };
+		frame_system::Pallet::<T>::set_block_number(One::one());
+		Nfts::<T, I>::create_swap(origin, collection, item1, collection, Some(item2), Some(price_with_direction.clone()), duration)?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item1)
+	verify {
+		assert_last_event::<T, I>(Event::SwapCancelled {
+			offered_collection: collection,
+			offered_item: item1,
+			desired_collection: collection,
+			desired_item: Some(item2),
+			price: Some(price_with_direction),
+			deadline: duration.saturating_add(One::one()),
+		}.into());
+	}
+
+	claim_swap {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item1, ..) = mint_item::<T, I>(0);
+		let (item2, ..) = mint_item::<T, I>(1);
+		let price = ItemPrice::<T, I>::from(0u32);
+		let price_direction = PriceDirection::Receive;
+		let price_with_direction = PriceWithDirection { amount: price, direction: price_direction };
+		let duration = T::MaxDeadlineDuration::get();
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+		let origin = SystemOrigin::Signed(caller.clone());
+		frame_system::Pallet::<T>::set_block_number(One::one());
+		Nfts::<T, I>::transfer(origin.clone().into(), collection, item2, target_lookup)?;
+		Nfts::<T, I>::create_swap(
+			origin.clone().into(),
+			collection,
+			item1,
+			collection,
+			Some(item2),
+			Some(price_with_direction.clone()),
+			duration,
+		)?;
+	}: _(SystemOrigin::Signed(target.clone()), collection, item2, collection, item1, Some(price_with_direction.clone()))
+	verify {
+		let current_block = frame_system::Pallet::<T>::block_number();
+		assert_last_event::<T, I>(Event::SwapClaimed {
+			sent_collection: collection,
+			sent_item: item2,
+			sent_item_owner: target,
+			received_collection: collection,
+			received_item: item1,
+			received_item_owner: caller,
+			price: Some(price_with_direction),
+			deadline: duration.saturating_add(One::one()),
+		}.into());
+	}
+
 	impl_benchmark_test_suite!(Nfts, crate::mock::new_test_ext(), crate::mock::Test);
 }

frame/nfts/src/features/atomic_swap.rs

@@ -0,0 +1,175 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::*;
+use frame_support::{
+	pallet_prelude::*,
+	traits::{Currency, ExistenceRequirement::KeepAlive},
+};
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	pub fn do_create_swap(
+		caller: T::AccountId,
+		offered_collection_id: T::CollectionId,
+		offered_item_id: T::ItemId,
+		desired_collection_id: T::CollectionId,
+		maybe_desired_item_id: Option<T::ItemId>,
+		maybe_price: Option<PriceWithDirection<ItemPrice<T, I>>>,
+		duration: <T as SystemConfig>::BlockNumber,
+	) -> DispatchResult {
+		ensure!(duration <= T::MaxDeadlineDuration::get(), Error::<T, I>::WrongDuration);
+
+		let item = Item::<T, I>::get(&offered_collection_id, &offered_item_id)
+			.ok_or(Error::<T, I>::UnknownItem)?;
+		ensure!(item.owner == caller, Error::<T, I>::NoPermission);
+
+		match maybe_desired_item_id {
+			Some(desired_item_id) => ensure!(
+				Item::<T, I>::contains_key(&desired_collection_id, &desired_item_id),
+				Error::<T, I>::UnknownItem
+			),
+			None => ensure!(
+				Collection::<T, I>::contains_key(&desired_collection_id),
+				Error::<T, I>::UnknownCollection
+			),
+		};
+
+		let now = frame_system::Pallet::<T>::block_number();
+		let deadline = duration.saturating_add(now);
+
+		PendingSwapOf::<T, I>::insert(
+			&offered_collection_id,
+			&offered_item_id,
+			PendingSwap {
+				desired_collection: desired_collection_id,
+				desired_item: maybe_desired_item_id,
+				price: maybe_price.clone(),
+				deadline,
+			},
+		);
+
+		Self::deposit_event(Event::SwapCreated {
+			offered_collection: offered_collection_id,
+			offered_item: offered_item_id,
+			desired_collection: desired_collection_id,
+			desired_item: maybe_desired_item_id,
+			price: maybe_price,
+			deadline,
+		});
+
+		Ok(())
+	}
+
+	pub fn do_cancel_swap(
+		caller: T::AccountId,
+		offered_collection_id: T::CollectionId,
+		offered_item_id: T::ItemId,
+	) -> DispatchResult {
+		let swap = PendingSwapOf::<T, I>::get(&offered_collection_id, &offered_item_id)
+			.ok_or(Error::<T, I>::UnknownSwap)?;
+
+		let now = frame_system::Pallet::<T>::block_number();
+		if swap.deadline > now {
+			let item = Item::<T, I>::get(&offered_collection_id, &offered_item_id)
+				.ok_or(Error::<T, I>::UnknownItem)?;
+			ensure!(item.owner == caller, Error::<T, I>::NoPermission);
+		}
+
+		PendingSwapOf::<T, I>::remove(&offered_collection_id, &offered_item_id);
+
+		Self::deposit_event(Event::SwapCancelled {
+			offered_collection: offered_collection_id,
+			offered_item: offered_item_id,
+			desired_collection: swap.desired_collection,
+			desired_item: swap.desired_item,
+			price: swap.price,
+			deadline: swap.deadline,
+		});
+
+		Ok(())
+	}
+
+	pub fn do_claim_swap(
+		caller: T::AccountId,
+		send_collection_id: T::CollectionId,
+		send_item_id: T::ItemId,
+		receive_collection_id: T::CollectionId,
+		receive_item_id: T::ItemId,
+		witness_price: Option<PriceWithDirection<ItemPrice<T, I>>>,
+	) -> DispatchResult {
+		let send_item = Item::<T, I>::get(&send_collection_id, &send_item_id)
+			.ok_or(Error::<T, I>::UnknownItem)?;
+		let receive_item = Item::<T, I>::get(&receive_collection_id, &receive_item_id)
+			.ok_or(Error::<T, I>::UnknownItem)?;
+		let swap = PendingSwapOf::<T, I>::get(&receive_collection_id, &receive_item_id)
+			.ok_or(Error::<T, I>::UnknownSwap)?;
+
+		ensure!(send_item.owner == caller, Error::<T, I>::NoPermission);
+		ensure!(
+			swap.desired_collection == send_collection_id && swap.price == witness_price,
+			Error::<T, I>::UnknownSwap
+		);
+
+		if let Some(desired_item) = swap.desired_item {
+			ensure!(desired_item == send_item_id, Error::<T, I>::UnknownSwap);
+		}
+
+		let now = frame_system::Pallet::<T>::block_number();
+		ensure!(now <= swap.deadline, Error::<T, I>::DeadlineExpired);
+
+		if let Some(ref price) = swap.price {
+			match price.direction {
+				PriceDirection::Send => T::Currency::transfer(
+					&receive_item.owner,
+					&send_item.owner,
+					price.amount,
+					KeepAlive,
+				)?,
+				PriceDirection::Receive => T::Currency::transfer(
+					&send_item.owner,
+					&receive_item.owner,
+					price.amount,
+					KeepAlive,
+				)?,
+			};
+		}
+
+		// This also removes the swap.
+		Self::do_transfer(send_collection_id, send_item_id, receive_item.owner.clone(), |_, _| {
+			Ok(())
+		})?;
+		Self::do_transfer(
+			receive_collection_id,
+			receive_item_id,
+			send_item.owner.clone(),
+			|_, _| Ok(()),
+		)?;
+
+		Self::deposit_event(Event::SwapClaimed {
+			sent_collection: send_collection_id,
+			sent_item: send_item_id,
+			sent_item_owner: send_item.owner,
+			received_collection: receive_collection_id,
+			received_item: receive_item_id,
+			received_item_owner: receive_item.owner,
+			price: swap.price,
+			deadline: swap.deadline,
+		});
+
+		Ok(())
+	}
+}

frame/nfts/src/features/mod.rs

@@ -15,4 +15,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+pub mod atomic_swap;
 pub mod buy_sell;

frame/nfts/src/functions.rs

@@ -56,6 +56,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 
 		Item::<T, I>::insert(&collection, &item, &details);
 		ItemPriceOf::<T, I>::remove(&collection, &item);
+		PendingSwapOf::<T, I>::remove(&collection, &item);
 
 		Self::deposit_event(Event::Transferred {
 			collection,
@@ -129,6 +130,8 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			ItemMetadataOf::<T, I>::remove_prefix(&collection, None);
 			#[allow(deprecated)]
 			ItemPriceOf::<T, I>::remove_prefix(&collection, None);
+			#[allow(deprecated)]
+			PendingSwapOf::<T, I>::remove_prefix(&collection, None);
 			CollectionMetadataOf::<T, I>::remove(&collection);
 			#[allow(deprecated)]
 			Attribute::<T, I>::remove_prefix((&collection,), None);
@@ -219,6 +222,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		Item::<T, I>::remove(&collection, &item);
 		Account::<T, I>::remove((&owner, &collection, &item));
 		ItemPriceOf::<T, I>::remove(&collection, &item);
+		PendingSwapOf::<T, I>::remove(&collection, &item);
 
 		Self::deposit_event(Event::Burned { collection, item, owner });
 		Ok(())