[Uniques V2] Atomic NFTs swap

frame/nfts/src/benchmarking.rs

@@ -476,5 +476,83 @@ 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 duration = T::BlockNumber::max_value();
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item1, collection, Some(item2), Some(price), Some(price_direction.clone()), Some(duration))
+	verify {
+		assert_last_event::<T, I>(Event::SwapCreated {
+			offered_collection: collection,
+			offered_item: item1,
+			desired_collection: collection,
+			desired_item: Some(item2),
+			price: Some(price),
+			price_direction: Some(price_direction),
+			deadline: Some(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::BlockNumber::max_value();
+		let price_direction = PriceDirection::Receive;
+		Nfts::<T, I>::create_swap(origin, collection, item1, collection, Some(item2), Some(price), Some(price_direction.clone()), Some(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),
+			price_direction: Some(price_direction),
+			deadline: Some(duration),
+		}.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 duration = T::BlockNumber::max_value();
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+		let origin = SystemOrigin::Signed(caller.clone());
+		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),
+			Some(price_direction.clone()),
+			Some(duration),
+		)?;
+	}: _(SystemOrigin::Signed(target.clone()), collection, item2, collection, item1, Some(price.clone()), Some(price_direction.clone()))
+	verify {
+		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),
+			price_direction: Some(price_direction),
+			deadline: Some(duration),
+		}.into());
+	}
+
 	impl_benchmark_test_suite!(Nfts, crate::mock::new_test_ext(), crate::mock::Test);
 }

frame/nfts/src/features/atomic_swap.rs

@@ -0,0 +1,190 @@
+// 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<ItemPrice<T, I>>,
+		maybe_price_direction: Option<PriceDirection>,
+		maybe_duration: Option<<T as SystemConfig>::BlockNumber>,
+	) -> DispatchResult {
+		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) => {
+				if !(Item::<T, I>::contains_key(&desired_collection_id, &desired_item_id)) {
+					return Err(Error::<T, I>::UnknownItem.into())
+				}
+			},
+			None =>
+				if !(Collection::<T, I>::contains_key(&desired_collection_id)) {
+					return Err(Error::<T, I>::UnknownCollection.into())
+				},
+		};
+
+		if maybe_price.is_some() && maybe_price_direction.is_none() {
+			return Err(Error::<T, I>::PriceDirectionNotSet.into())
+		}
+		if maybe_price.is_none() && maybe_price_direction.is_some() {
+			return Err(Error::<T, I>::PriceDirectionCannotBeSet.into())
+		}
+
+		let now = frame_system::Pallet::<T>::block_number();
+		let maybe_deadline = maybe_duration.map(|d| d.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,
+				price_direction: maybe_price_direction.clone(),
+				deadline: maybe_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,
+			price_direction: maybe_price_direction,
+			deadline: maybe_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 is_past_deadline = if let Some(deadline) = swap.deadline {
+			let now = frame_system::Pallet::<T>::block_number();
+			now > deadline
+		} else {
+			false
+		};
+
+		if !is_past_deadline {
+			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,
+			price_direction: swap.price_direction,
+			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,
+		maybe_price: Option<ItemPrice<T, I>>,
+		maybe_price_direction: Option<PriceDirection>,
+	) -> 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 == maybe_price &&
+				swap.price_direction == maybe_price_direction,
+			Error::<T, I>::UnknownSwap
+		);
+
+		if let Some(desired_item) = swap.desired_item {
+			ensure!(desired_item == send_item_id, Error::<T, I>::UnknownSwap);
+		}
+
+		if let Some(deadline) = swap.deadline {
+			let now = frame_system::Pallet::<T>::block_number();
+			ensure!(now <= deadline, Error::<T, I>::DeadlineExpired);
+		}
+
+		if let Some(amount) = swap.price {
+			match swap.price_direction {
+				Some(PriceDirection::Send) =>
+					T::Currency::transfer(&receive_item.owner, &send_item.owner, amount, KeepAlive)?,
+				Some(PriceDirection::Receive) =>
+					T::Currency::transfer(&send_item.owner, &receive_item.owner, 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,
+			price_direction: swap.price_direction,
+			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(())