[Uniques V2] Atomic NFTs swap

frame/nfts/src/benchmarking.rs

@@ -458,5 +458,68 @@ benchmarks_instance_pallet! {
  }.into());
  }
 
+ 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 duration = T::BlockNumber::max_value();
+ }: _(SystemOrigin::Signed(caller.clone()), collection, item1, collection, item2, Some(price), Some(duration))
+ verify {
+ assert_last_event::<T, I>(Event::SwapCreated {
+ collection,
+ item: item1,
+ desired_collection: collection,
+ desired_item: item2,
+ price: Some(price),
+ 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 duration = T::BlockNumber::max_value();
+ let origin = SystemOrigin::Signed(caller.clone()).into();
+ Nfts::<T, I>::create_swap(origin, collection, item1, collection, item2, Some(price), Some(duration))?;
+ }: _(SystemOrigin::Signed(caller.clone()), collection, item1)
+ verify {
+ assert_last_event::<T, I>(Event::SwapCancelled {
+ collection,
+ item: item1,
+ desired_collection: collection,
+ desired_item: item2,
+ price: Some(price),
+ 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 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, item2, Some(price), Some(duration))?;
+ }: _(SystemOrigin::Signed(target.clone()), collection, item2, collection, item1, Some(price.clone()))
+ verify {
+ assert_last_event::<T, I>(Event::SwapClaimed {
+ send_collection: collection,
+ send_item: item2,
+ send_item_owner: target,
+ receive_collection: collection,
+ receive_item: item1,
+ receive_item_owner: caller,
+ price: Some(price),
+ 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,152 @@
+// 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(
+ sender: T::AccountId,
+ collection_id: T::CollectionId,
+ item_id: T::ItemId,
+ desired_collection_id: T::CollectionId,
+ desired_item_id: T::ItemId,
+ maybe_price: Option<ItemPrice<T, I>>,
+ maybe_duration: Option<<T as SystemConfig>::BlockNumber>,
+ ) -> DispatchResult {
+ let item = Item::<T, I>::get(&collection_id, &item_id).ok_or(Error::<T, I>::UnknownItem)?;
+ ensure!(item.owner == sender, Error::<T, I>::NoPermission);
+
+ Item::<T, I>::get(&desired_collection_id, &desired_item_id)
+ .ok_or(Error::<T, I>::UnknownItem)?;
+
+ let now = frame_system::Pallet::<T>::block_number();
+ let deadline = maybe_duration.map(|d| d.saturating_add(now));
+
+ PendingSwapOf::<T, I>::insert(
+ &collection_id,
+ &item_id,
+ PendingSwap {
+ desired_collection: desired_collection_id,
+ desired_item: desired_item_id,
+ price: maybe_price,
+ deadline,
+ },
+ );
+
+ Self::deposit_event(Event::SwapCreated {
+ collection: collection_id,
+ item: item_id,
+ desired_collection: desired_collection_id,
+ desired_item: desired_item_id,
+ price: maybe_price,
+ deadline,
+ });
+
+ Ok(())
+ }
+
+ pub fn do_cancel_swap(
+ sender: T::AccountId,
+ collection_id: T::CollectionId,
+ item_id: T::ItemId,
+ ) -> DispatchResult {
+ let item = Item::<T, I>::get(&collection_id, &item_id).ok_or(Error::<T, I>::UnknownItem)?;
+ let swap = PendingSwapOf::<T, I>::get(&collection_id, &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 {
+ ensure!(item.owner == sender, Error::<T, I>::NoPermission);
+ }
+
+ PendingSwapOf::<T, I>::remove(&collection_id, &item_id);
+
+ Self::deposit_event(Event::SwapCancelled {
+ collection: collection_id,
+ item: item_id,
+ desired_collection: swap.desired_collection,
+ desired_item: swap.desired_item,
+ price: swap.price,
+ deadline: swap.deadline,
+ });
+
+ Ok(())
+ }
+
+ pub fn do_claim_swap(
+ sender: T::AccountId,
+ send_collection_id: T::CollectionId,
+ send_item_id: T::ItemId,
+ receive_collection_id: T::CollectionId,
+ receive_item_id: T::ItemId,
+ maybe_receive_amount: Option<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 == sender, Error::<T, I>::NoPermission);
+ ensure!(swap.desired_collection == send_collection_id, Error::<T, I>::UnknownSwap);
+ ensure!(swap.desired_item == send_item_id, Error::<T, I>::UnknownSwap);
+ ensure!(swap.price == maybe_receive_amount, Error::<T, I>::UnknownSwap);
+
+ if let Some(deadline) = swap.deadline {
+ let now = frame_system::Pallet::<T>::block_number();
+ ensure!(deadline >= now, Error::<T, I>::DeadlineExpired);
+ }
+
+ if let Some(amount) = swap.price {
+ T::Currency::transfer(&receive_item.owner, &send_item.owner, amount, KeepAlive)?;
+ }
+
+ 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 {
+ send_collection: send_collection_id,
+ send_item: send_item_id,
+ send_item_owner: send_item.owner,
+ receive_collection: receive_collection_id,
+ receive_item: receive_item_id,
+ receive_item_owner: receive_item.owner,
+ price: swap.price,
+ deadline: swap.deadline,
+ });
+
+ Ok(())
+ }
+}

frame/nfts/src/features/mod.rs

@@ -0,0 +1,18 @@
+// 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.
+
+pub mod atomic_swap;

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,
@@ -124,6 +125,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);
@@ -214,6 +217,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(())