Merge remote-tracking branch 'origin/feature/NFTPAR-373_chain_extensions' into feature/NFTPAR-366_upstream_updates

Signed-off-by: Yaroslav Bolyukin <iam@lach.pw>

Author: CertainLach

.devcontainer/Dockerfile

@@ -3,6 +3,9 @@ FROM mcr.microsoft.com/vscode/devcontainers/rust:0-1
 RUN apt-get update && export DEBIAN_FRONTEND=noninteractive && \
     apt-get -y install --no-install-recommends libssl-dev pkg-config libclang-dev clang
 
+RUN curl -L -o- https://github.com/WebAssembly/binaryen/releases/download/version_101/binaryen-version_101-x86_64-linux.tar.gz | \
+    tar xz --strip-components=1 -C /usr
+
 USER vscode
 
 RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.37.2/install.sh | bash && \
@@ -14,4 +17,4 @@ RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.37.2/install.sh | b
     rustup default nightly-2021-05-30 && \
     rustup target add wasm32-unknown-unknown && \
     rustup component add rustfmt clippy && \
-    cargo install cargo-expand cargo-edit
+    cargo install cargo-expand cargo-edit cargo-contract

runtime/src/chain_extension.rs

@@ -97,7 +97,7 @@ impl<C: Config> ChainExtension<C> for NFTExtension {
                 let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
 
                 pallet_nft::Module::<C>::transfer_internal(
-                    &C::CrossAccountId::from_sub(env.ext().caller().clone()),
+                    &C::CrossAccountId::from_sub(env.ext().address().clone()),
                     &C::CrossAccountId::from_sub(input.recipient),
                     &collection,
                     input.token_id,

smart_contracs/transfer/Cargo.toml

@@ -4,15 +4,17 @@ version = "0.1.0"
 authors = ["[Greg Zaitsev] <[your_email]>"]
 edition = "2018"
 
+[workspace]
+
 [dependencies]
-ink_primitives = { git = "https://github.com/usetech-llc/ink", branch = "unique", default-features = false }
-ink_metadata = { git = "https://github.com/usetech-llc/ink", branch = "unique", default-features = false, features = ["derive"], optional = true }
-ink_env = { git = "https://github.com/usetech-llc/ink", branch = "unique", default-features = false }
-ink_storage = { git = "https://github.com/usetech-llc/ink", branch = "unique", default-features = false }
-ink_lang = { git = "https://github.com/usetech-llc/ink", branch = "unique", default-features = false }
+ink_primitives = { default-features = false }
+ink_metadata = { default-features = false, features = ["derive"], optional = true }
+ink_env = { default-features = false }
+ink_storage = { default-features = false }
+ink_lang = { default-features = false }
 
-scale = { package = "parity-scale-codec", version = "1.3", default-features = false, features = ["derive"] }
-scale-info = { version = "0.4.1", default-features = false, features = ["derive"], optional = true }
+scale = { package = "parity-scale-codec", version = "2.1.1", default-features = false, features = ["derive"] }
+scale-info = { version = "0.6.0", default-features = false, features = ["derive"] }
 
 [lib]
 name = "nft_transfer"
@@ -28,6 +30,7 @@ std = [
     "ink_metadata/std",
     "ink_env/std",
     "ink_storage/std",
+    "ink_lang/std",
     "ink_primitives/std",
     "scale/std",
     "scale-info/std",

smart_contracs/transfer/lib.rs

@@ -1,4 +1,6 @@
 #![cfg_attr(not(feature = "std"), no_std)]
+extern crate alloc;
+use alloc::vec::Vec;
 
 use ink_lang as ink;
 use ink_env::{Environment, DefaultEnvironment};
@@ -36,18 +38,51 @@ impl ink_env::chain_extension::FromStatusCode for NftErrorCode {
     }
 }
 
+#[derive(scale::Encode, scale::Decode, scale_info::TypeInfo)]
+pub enum CreateItemData {
+    Nft {
+        const_data: Vec<u8>,
+        variable_data: Vec<u8>,
+    },
+    Fungible {
+        value: u128,
+    },
+    ReFungible {
+        const_data: Vec<u8>,
+        variable_data: Vec<u8>,
+        pieces: u128,
+    },
+}
+
+type DefaultAccountId = <DefaultEnvironment as Environment>::AccountId;
+
 #[ink::chain_extension]
 pub trait NftChainExtension {
     type ErrorCode = NftErrorCode;
 
     /// Transfer one NFT token from sender
     ///
     #[ink(extension = 0, returns_result = false)]
-    fn transfer(recipient: <DefaultEnvironment as Environment>::AccountId, collection_id: u32, token_id: u32, amount: u128);
+    fn transfer(recipient: DefaultAccountId, collection_id: u32, token_id: u32, amount: u128);
+    #[ink(extension = 1, returns_result = false)]
+    fn create_item(owner: DefaultAccountId, collection_id: u32, data: CreateItemData);
+    #[ink(extension = 2, returns_result = false)]
+    fn create_multiple_items(owner: DefaultAccountId, collection_id: u32, data: Vec<CreateItemData>);
+    #[ink(extension = 3, returns_result = false)]
+    fn approve(spender: DefaultAccountId, collection_id: u32, item_id: u32, amount: u128);
+    #[ink(extension = 4, returns_result = false)]
+    fn transfer_from(owner: DefaultAccountId, recipient: DefaultAccountId, collection_id: u32, item_id: u32, amount: u128);
+    #[ink(extension = 5, returns_result = false)]
+    fn set_variable_meta_data(collection_id: u32, item_id: u32, data: Vec<u8>);
+    #[ink(extension = 6, returns_result = false)]
+    fn toggle_white_list(collection_id: u32, address: DefaultAccountId, whitelisted: bool);
 }
 
-#[ink::contract(env = crate::NftEnvironment)]
+#[ink::contract(env = crate::NftEnvironment, dynamic_storage_allocator = true)]
 mod nft_transfer {
+    use alloc::vec::Vec;
+    // use ink_storage::Vec;
+    use crate::CreateItemData;
 
     #[ink(storage)]
     pub struct NftTransfer {
@@ -69,6 +104,42 @@ mod nft_transfer {
                 .extension()
                 .transfer(recipient, collection_id, token_id, amount);
         }
+        #[ink(message)]
+        pub fn create_item(&mut self, recipient: AccountId, collection_id: u32, data: CreateItemData) {
+            let _ = self.env()
+                .extension()
+                .create_item(recipient, collection_id, data);
+        }
+        #[ink(message)]
+        pub fn create_multiple_items(&mut self, owner: AccountId, collection_id: u32, data: Vec<CreateItemData>) {
+            let _ = self.env()
+                .extension()
+                .create_multiple_items(owner, collection_id, data);
+        }
+        #[ink(message)]
+        pub fn approve(&mut self, spender: AccountId, collection_id: u32, item_id: u32, amount: u128) {
+            let _ = self.env()
+                .extension()
+                .approve(spender, collection_id, item_id, amount);
+        }
+        #[ink(message)]
+        pub fn transfer_from(&mut self, owner: AccountId, recipient: AccountId, collection_id: u32, item_id: u32, amount: u128) {
+            let _ = self.env()
+                .extension()
+                .transfer_from(owner, recipient, collection_id, item_id, amount);
+        }
+        #[ink(message)]
+        pub fn set_variable_meta_data(&mut self, collection_id: u32, item_id: u32, data: Vec<u8>) {
+            let _ = self.env()
+                .extension()
+                .set_variable_meta_data(collection_id, item_id, data);
+        }
+        #[ink(message)]
+        pub fn toggle_white_list(&mut self, collection_id: u32, address: AccountId, whitelisted: bool) {
+            let _ = self.env()
+                .extension()
+                .toggle_white_list(collection_id, address, whitelisted);
+        }
 
     }
 

tests/src/contracts.test.ts

@@ -16,18 +16,24 @@ import {
 } from "./util/contracthelpers";
 
 import {
+  addToWhiteListExpectSuccess,
+  approveExpectSuccess,
   createCollectionExpectSuccess,
   createItemExpectSuccess,
+  enablePublicMintingExpectSuccess,
+  enableWhiteListExpectSuccess,
   getGenericResult,
-  normalizeAccountId
+  normalizeAccountId,
+  isWhitelisted,
+  transferFromExpectSuccess
 } from "./util/helpers";
 
 
 chai.use(chaiAsPromised);
 const expect = chai.expect;
 
 const value = 0;
-const gasLimit = 3000n * 1000000n;
+const gasLimit = 9000n * 1000000n;
 const marketContractAddress = '5CYN9j3YvRkqxewoxeSvRbhAym4465C57uMmX5j4yz99L5H6';
 
 describe('Contracts', () => {
@@ -54,8 +60,10 @@ describe('Contracts', () => {
       expect(newContractInstance.address.toString()).to.equal(marketContractAddress);
     });
   });
+});
 
-  it('Can transfer NFT using smart contract.', async () => {
+describe.only('Chain extensions', () => {
+  it('Transfer CE', async () => {
     await usingApi(async api => {
       const alice = privateKey("//Alice");
       const bob = privateKey("//Bob");
@@ -64,6 +72,9 @@ describe('Contracts', () => {
       const collectionId = await createCollectionExpectSuccess();
       const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
       const [contract, deployer] = await deployTransferContract(api);
+      const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, contract.address);
+      await submitTransactionAsync(alice, changeAdminTx);
+
       const tokenBefore: any = (await api.query.nft.nftItemList(collectionId, tokenId) as any).toJSON();
 
       // Transfer
@@ -78,4 +89,165 @@ describe('Contracts', () => {
       expect(tokenAfter.Owner).to.be.deep.equal(normalizeAccountId(bob.address));
     });
   });
+
+  it('Mint CE', async () => {
+    await usingApi(async api => {
+      const alice = privateKey('//Alice');
+      const bob = privateKey('//Bob');
+
+      const collectionId = await createCollectionExpectSuccess();
+      const [contract, deployer] = await deployTransferContract(api);
+      await enablePublicMintingExpectSuccess(alice, collectionId);
+      await enableWhiteListExpectSuccess(alice, collectionId);
+      await addToWhiteListExpectSuccess(alice, collectionId, contract.address);
+      await addToWhiteListExpectSuccess(alice, collectionId, bob.address);
+
+      const transferTx = contract.tx.createItem(value, gasLimit, bob.address, collectionId, { Nft: {const_data: '0x010203', variable_data: '0x020304' }});
+      const events = await submitTransactionAsync(alice, transferTx);
+      const result = getGenericResult(events);
+      expect(result.success).to.be.true;
+
+      const tokensAfter: any = (await api.query.nft.nftItemList.entries(collectionId) as any).map((kv: any) => kv[1].toJSON());
+      expect(tokensAfter).to.be.deep.equal([
+        {
+          Owner: bob.address,
+          ConstData: '0x010203',
+          VariableData: '0x020304',
+        },
+      ]);
+    });
+  });
+
+  it('Bulk mint CE', async () => {
+    await usingApi(async api => {
+      const alice = privateKey('//Alice');
+      const bob = privateKey('//Bob');
+
+      const collectionId = await createCollectionExpectSuccess();
+      const [contract, deployer] = await deployTransferContract(api);
+      await enablePublicMintingExpectSuccess(alice, collectionId);
+      await enableWhiteListExpectSuccess(alice, collectionId);
+      await addToWhiteListExpectSuccess(alice, collectionId, contract.address);
+      await addToWhiteListExpectSuccess(alice, collectionId, bob.address);
+
+      const transferTx = contract.tx.createMultipleItems(value, gasLimit, bob.address, collectionId, [
+        { Nft: { const_data: '0x010203', variable_data: '0x020304' } },
+        { Nft: { const_data: '0x010204', variable_data: '0x020305' } },
+        { Nft: { const_data: '0x010205', variable_data: '0x020306' } }
+      ]);
+      const events = await submitTransactionAsync(alice, transferTx);
+      const result = getGenericResult(events);
+      expect(result.success).to.be.true;
+
+      const tokensAfter: any = (await api.query.nft.nftItemList.entries(collectionId) as any)
+        .map((kv: any) => kv[1].toJSON())
+        .sort((a: any, b: any) => a.ConstData.localeCompare(b.ConstData));
+      expect(tokensAfter).to.be.deep.equal([
+        {
+          Owner: bob.address,
+          ConstData: '0x010203',
+          VariableData: '0x020304',
+        },
+        {
+          Owner: bob.address,
+          ConstData: '0x010204',
+          VariableData: '0x020305',
+        },
+        {
+          Owner: bob.address,
+          ConstData: '0x010205',
+          VariableData: '0x020306',
+        },
+      ]);
+    });
+  });
+
+  it('Approve CE', async () => {
+    await usingApi(async api => {
+      const alice = privateKey('//Alice');
+      const bob = privateKey('//Bob');
+      const charlie = privateKey('//Charlie');
+
+      const collectionId = await createCollectionExpectSuccess();
+      const [contract, deployer] = await deployTransferContract(api);
+      const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', contract.address.toString());
+
+      const transferTx = contract.tx.approve(value, gasLimit, bob.address, collectionId, tokenId, 1);
+      const events = await submitTransactionAsync(alice, transferTx);
+      const result = getGenericResult(events);
+      expect(result.success).to.be.true;
+
+      await transferFromExpectSuccess(collectionId, tokenId, bob, contract.address.toString(), charlie, 1, 'NFT');
+    });
+  });
+
+  it('TransferFrom CE', async () => {
+    await usingApi(async api => {
+      const alice = privateKey('//Alice');
+      const bob = privateKey('//Bob');
+      const charlie = privateKey('//Charlie');
+
+      const collectionId = await createCollectionExpectSuccess();
+      const [contract, deployer] = await deployTransferContract(api);
+      const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', bob.address);
+      await approveExpectSuccess(collectionId, tokenId, bob, contract.address.toString(), 1);
+
+      const transferTx = contract.tx.transferFrom(value, gasLimit, bob.address, charlie.address, collectionId, tokenId, 1);
+      const events = await submitTransactionAsync(alice, transferTx);
+      const result = getGenericResult(events);
+      expect(result.success).to.be.true;
+
+      const token: any = (await api.query.nft.nftItemList(collectionId, tokenId) as any).unwrap()
+      expect(token.Owner.toString()).to.be.equal(charlie.address);
+    });
+  });
+
+  it('SetVariableMetaData CE', async () => {
+    await usingApi(async api => {
+      const alice = privateKey('//Alice');
+
+      const collectionId = await createCollectionExpectSuccess();
+      const [contract, deployer] = await deployTransferContract(api);
+      const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', contract.address.toString());
+
+      const transferTx = contract.tx.setVariableMetaData(value, gasLimit, collectionId, tokenId, '0x121314');
+      const events = await submitTransactionAsync(alice, transferTx);
+      const result = getGenericResult(events);
+      expect(result.success).to.be.true;
+
+      const token: any = (await api.query.nft.nftItemList(collectionId, tokenId) as any).unwrap()
+      expect(token.VariableData.toString()).to.be.equal('0x121314');
+    });
+  });
+
+  it('ToggleWhiteList CE', async () => {
+    await usingApi(async api => {
+      const alice = privateKey('//Alice');
+      const bob = privateKey('//Bob');
+
+      const collectionId = await createCollectionExpectSuccess();
+      const [contract, deployer] = await deployTransferContract(api);
+      const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, contract.address);
+      await submitTransactionAsync(alice, changeAdminTx);      
+
+      expect(await isWhitelisted(collectionId, bob.address)).to.be.false;
+
+      {
+        const transferTx = contract.tx.toggleWhiteList(value, gasLimit, collectionId, bob.address, true);
+        const events = await submitTransactionAsync(alice, transferTx);
+        const result = getGenericResult(events);
+        expect(result.success).to.be.true;
+
+        expect(await isWhitelisted(collectionId, bob.address)).to.be.true;
+      }
+      {
+        const transferTx = contract.tx.toggleWhiteList(value, gasLimit, collectionId, bob.address, false);
+        const events = await submitTransactionAsync(alice, transferTx);
+        const result = getGenericResult(events);
+        expect(result.success).to.be.true;
+
+        expect(await isWhitelisted(collectionId, bob.address)).to.be.false;
+      }
+    });
+  });
 });