git.delta.rocks / unique-network / refs/commits / 54d73b995f4b

--- a/doc/application_development.md
+++ b/doc/application_development.md
@@ -101,10 +101,9 @@
 -   Owner: Address, initial owner of the NFT
 
 ##### Events
-
--   ItemCreated
-    -   ItemId: Identifier of newly created NFT, which is unique within the Collection, so the NFT is uniquely
-        identified with a pair of values: CollectionId and ItemId.
+ItemCreated
+ItemId: Identifier of newly created NFT, which is unique within the Collection, so the NFT is uniquely identified with a pair of values: CollectionId and ItemId.
+Recipient: Address, owner of newly created item
 
 #### BurnItem
 

--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -495,7 +495,9 @@
         /// * collection_id: Id of the collection where item was created.
         /// 
         /// * item_id: Id of an item. Unique within the collection.
-        ItemCreated(CollectionId, TokenId),
+        ///
+        /// * recipient: Owner of newly created item 
+        ItemCreated(CollectionId, TokenId, AccountId),
 
         /// Collection item was burned.
         /// 
@@ -505,6 +507,19 @@
         /// 
         /// item_id: Identifier of burned NFT.
         ItemDestroyed(CollectionId, TokenId),
+
+        /// Item was transferred
+        ///
+        /// * collection_id: Id of collection to which item is belong
+        ///
+        /// * item_id: Id of an item
+        ///
+        /// * sender: Original owner of item
+        ///
+        /// * recipient: New owner of item
+        ///
+        /// * amount: Always 1 for NFT
+        Transfer(CollectionId, TokenId, AccountId, AccountId, u128),
     }
 );
 
@@ -1556,12 +1571,14 @@
 
         match target_collection.mode
         {
-            CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,
+            CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,
             CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,
-            CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,
+            CollectionMode::ReFungible  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,
             _ => ()
         };
 
+        Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));
+
         Ok(())
     }
 
@@ -1635,7 +1652,7 @@
         {
             CreateItemData::NFT(data) => {
                 let item = NftItemType {
-                    owner,
+                    owner: owner.clone(),
                     const_data: data.const_data,
                     variable_data: data.variable_data
                 };
@@ -1660,7 +1677,7 @@
         };
 
         // call event
-        Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));
+        Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id), owner));
 
         Ok(())
     }

--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -36,6 +36,16 @@
   success: boolean;
   collectionId: number;
   itemId: number;
+  recipient: string;
+}
+
+interface TransferResult {
+  success: boolean;
+  collectionId: number;
+  itemId: number;
+  sender: string;
+  recipient: string;
+  value: bigint;
 }
 
 interface IReFungibleOwner {
@@ -94,6 +104,7 @@
   let success = false;
   let collectionId: number = 0;
   let itemId: number = 0;
+  let recipient: string = '';
   events.forEach(({ phase, event: { data, method, section } }) => {
     // console.log(`    ${phase}: ${section}.${method}:: ${data}`);
     if (method == 'ExtrinsicSuccess') {
@@ -101,13 +112,40 @@
     } else if ((section == 'nft') && (method == 'ItemCreated')) {
       collectionId = parseInt(data[0].toString());
       itemId = parseInt(data[1].toString());
+      recipient = data[2].toString();
     }
   });
   const result: CreateItemResult = {
     success,
     collectionId,
     itemId,
+    recipient,
+  };
+  return result;
+}
+
+export function getTransferResult(events: EventRecord[]): TransferResult {
+  const result: TransferResult = {
+    success: false,
+    collectionId: 0,
+    itemId: 0,
+    sender: '',
+    recipient: '',
+    value: 0n,
   };
+
+  events.forEach(({event: {data, method, section}}) => {
+    if (method === 'ExtrinsicSuccess') {
+      result.success = true;
+    } else if (section === 'nft' && method === 'Transfer') {
+      result.collectionId = +data[0].toString();
+      result.itemId = +data[1].toString();
+      result.sender = data[2].toString();
+      result.recipient = data[3].toString();
+      result.value = BigInt(data[4].toString());
+    }
+  });
+
   return result;
 }
 
@@ -620,9 +658,14 @@
     }
     const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);
     const events = await submitTransactionAsync(sender, transferTx);
-    const result = getCreateItemResult(events);
+    const result = getTransferResult(events);
     // tslint:disable-next-line:no-unused-expression
     expect(result.success).to.be.true;
+    expect(result.collectionId).to.be.equal(collectionId);
+    expect(result.itemId).to.be.equal(tokenId);
+    expect(result.sender).to.be.equal(sender.address);
+    expect(result.recipient).to.be.equal(recipient.address);
+    expect(result.value.toString()).to.be.equal(value.toString());
     if (type === 'NFT') {
       const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;
       expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);
@@ -736,6 +779,7 @@
     }
     expect(collectionId).to.be.equal(result.collectionId);
     expect(BItemCount).to.be.equal(result.itemId);
+    expect(owner).to.be.equal(result.recipient);
     newItemId = result.itemId;
   });
   return newItemId;