git.delta.rocks / unique-network / refs/commits / d430fcf340bb

412        // Basic collections412        // Basic collections
413        pub Collection get(fn collection) config(): map hasher(identity) CollectionId => CollectionType<T::AccountId>;413        pub Collection get(fn collection) config(): map hasher(identity) CollectionId => CollectionType<T::AccountId>;
414        pub AdminList get(fn admin_list_collection): map hasher(identity) CollectionId => Vec<T::AccountId>;414        pub AdminList get(fn admin_list_collection): map hasher(identity) CollectionId => Vec<T::AccountId>;
415        pub WhiteList get(fn white_list): map hasher(identity) CollectionId => Vec<T::AccountId>;415        pub WhiteList get(fn white_list): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => bool;
416416
417        /// Balance owner per collection map417        /// Balance owner per collection map
418        pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u128;418        pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u128;
438        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;438        pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;
439        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;439        pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;
440        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;440        pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;
441        pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 
442        pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(twox_64_concat) T::AccountId => bool; 
441    }443    }
442    add_extra_genesis {444    add_extra_genesis {
443        build(|config: &GenesisConfig<T>| {445        build(|config: &GenesisConfig<T>| {
627            <ItemListIndex>::remove(collection_id);629            <ItemListIndex>::remove(collection_id);
628            <AdminList<T>>::remove(collection_id);630            <AdminList<T>>::remove(collection_id);
629            <Collection<T>>::remove(collection_id);631            <Collection<T>>::remove(collection_id);
630            <WhiteList<T>>::remove(collection_id);632            <WhiteList<T>>::remove_prefix(collection_id);
631633
632            <NftItemList<T>>::remove_prefix(collection_id);634            <NftItemList<T>>::remove_prefix(collection_id);
633            <FungibleItemList<T>>::remove_prefix(collection_id);635            <FungibleItemList<T>>::remove_prefix(collection_id);
668            let sender = ensure_signed(origin)?;670            let sender = ensure_signed(origin)?;
669            Self::check_owner_or_admin_permissions(collection_id, sender)?;671            Self::check_owner_or_admin_permissions(collection_id, sender)?;
670672
671            let mut white_list_collection: Vec<T::AccountId>;673            <WhiteList<T>>::insert(collection_id, address, true);
672            if <WhiteList<T>>::contains_key(collection_id) {
673                white_list_collection = <WhiteList<T>>::get(collection_id);
674                if !white_list_collection.contains(&address.clone())
675                {
676                    white_list_collection.push(address.clone());
677                }674            
678            }
679            else {
680                white_list_collection = Vec::new();
681                white_list_collection.push(address.clone());
682            }
683
684            <WhiteList<T>>::insert(collection_id, white_list_collection);
685            Ok(())675            Ok(())
686        }676        }
687677
703            let sender = ensure_signed(origin)?;693            let sender = ensure_signed(origin)?;
704            Self::check_owner_or_admin_permissions(collection_id, sender)?;694            Self::check_owner_or_admin_permissions(collection_id, sender)?;
705695
706            if <WhiteList<T>>::contains_key(collection_id) {696            <WhiteList<T>>::remove(collection_id, address);
707                let mut white_list_collection = <WhiteList<T>>::get(collection_id);
708                if white_list_collection.contains(&address.clone())
709                {
710                    white_list_collection.retain(|i| *i != address.clone());
711                    <WhiteList<T>>::insert(collection_id, white_list_collection);
712                }
713            }
714697
715            Ok(())698            Ok(())
716        }699        }
1426            #[cfg(feature = "runtime-benchmarks")]1409            #[cfg(feature = "runtime-benchmarks")]
1427            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1410            <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());
14281411
1429            let mut is_owner = false;1412            Self::ensure_contract_owned(sender, &contract_address)?;
1430            if <ContractOwner<T>>::contains_key(contract_address.clone()) {
1431                let owner = <ContractOwner<T>>::get(&contract_address);
1432                is_owner = sender == owner;
1433            }
1434            ensure!(is_owner, Error::<T>::NoPermission);
14351413
1436            <ContractSelfSponsoring<T>>::insert(contract_address, enable);1414            <ContractSelfSponsoring<T>>::insert(contract_address, enable);
1437            Ok(())1415            Ok(())
1461            rate_limit: T::BlockNumber1439            rate_limit: T::BlockNumber
1462        ) -> DispatchResult {1440        ) -> DispatchResult {
1463            let sender = ensure_signed(origin)?;1441            let sender = ensure_signed(origin)?;
1464            let mut is_owner = false;1442            Self::ensure_contract_owned(sender, &contract_address)?;
1465            if <ContractOwner<T>>::contains_key(contract_address.clone()) {
1466                let owner = <ContractOwner<T>>::get(&contract_address);
1467                is_owner = sender == owner;
1468            }
1469            ensure!(is_owner, Error::<T>::NoPermission);
14701443
1471            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1444            <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);
1472            Ok(())1445            Ok(())
1473        }1446        }
14741447
1448        /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.
1449        /// 
1450        /// # Permissions
1451        /// 
1452        /// * Address that deployed smart contract.
1453        /// 
1454        /// # Arguments
1455        /// 
1456        /// -`contract_address`: Address of the contract.
1457        /// 
1458        /// - `enable`: .  
1475        #[weight = 0]1459        #[weight = 0]
1460        pub fn toggle_contract_white_list(
1461            origin,
1462            contract_address: T::AccountId,
1463            enable: bool
1464        ) -> DispatchResult {
1465            let sender = ensure_signed(origin)?;
1466            Self::ensure_contract_owned(sender, &contract_address)?;
1467
1468            <ContractWhiteListEnabled<T>>::insert(contract_address, enable);
1469            Ok(())
1470        }
1471        
1472        /// Add an address to smart contract white list.
1473        /// 
1474        /// # Permissions
1475        /// 
1476        /// * Address that deployed smart contract.
1477        /// 
1478        /// # Arguments
1479        /// 
1480        /// -`contract_address`: Address of the contract.
1481        ///
1482        /// -`account_address`: Address to add.
1483        #[weight = 0]
1484        pub fn add_to_contract_white_list(
1485            origin,
1486            contract_address: T::AccountId,
1487            account_address: T::AccountId
1488        ) -> DispatchResult {
1489            let sender = ensure_signed(origin)?;
1490            Self::ensure_contract_owned(sender, &contract_address)?;
1491            
1492            <ContractWhiteList<T>>::insert(contract_address, account_address, true);
1493            Ok(())
1494        }
1495
1496        /// Remove an address from smart contract white list.
1497        /// 
1498        /// # Permissions
1499        /// 
1500        /// * Address that deployed smart contract.
1501        /// 
1502        /// # Arguments
1503        /// 
1504        /// -`contract_address`: Address of the contract.
1505        ///
1506        /// -`account_address`: Address to remove.
1507        #[weight = 0]
1508        pub fn remove_from_contract_white_list(
1509            origin,
1510            contract_address: T::AccountId,
1511            account_address: T::AccountId
1512        ) -> DispatchResult {
1513            let sender = ensure_signed(origin)?;
1514            Self::ensure_contract_owned(sender, &contract_address)?;
1515            
1516            <ContractWhiteList<T>>::remove(contract_address, account_address);
1517            Ok(())
1518        }
1519
1520        #[weight = 0]
1476        pub fn set_collection_limits(1521        pub fn set_collection_limits(
1477            origin,1522            origin,
1478            collection_id: u32,1523            collection_id: u32,
18301875
1831    fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {1876    fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {
1832        let mes = Error::<T>::AddresNotInWhiteList;1877        let mes = Error::<T>::AddresNotInWhiteList;
1833        ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1878        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);
1834        let wl = <WhiteList<T>>::get(collection_id);
1835        ensure!(wl.contains(address), mes);
18361879
1837        Ok(())1880        Ok(())
1838    }1881    }
22502293
2251        Ok(())2294        Ok(())
2252    }2295    }
2296    
2297    fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {
2298        if <ContractOwner<T>>::contains_key(contract.clone()) {
2299            let owner = <ContractOwner<T>>::get(contract);
2300            ensure!(account == owner, Error::<T>::NoPermission);
2301        } else {
2302            fail!(Error::<T>::NoPermission);
2303        }
2304
2305        Ok(())
2306    }
2253}2307}
22542308
2255////////////////////////////////////////////////////////////////////////////////////////////////////2309////////////////////////////////////////////////////////////////////////////////////////////////////
2456            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {2510            Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {
24572511
2458                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());2512                let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());
2513
2514                let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())
2515                  && <ContractOwner<T>>::get(called_contract.clone()) == *who;
2516                let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());
2517                  
2518                if !owned_contract && white_list_enabled {
2519                    if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {
2520                        return Err(InvalidTransaction::Call.into());
2521                    }
2522                }
24592523
2460                let mut sponsor_transfer = false;2524                let mut sponsor_transfer = false;
2461                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2525                if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {

--- a/pallets/nft/src/tests.rs
+++ b/pallets/nft/src/tests.rs
@@ -960,7 +960,7 @@
 
         let origin1 = Origin::signed(1);
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
-        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);
+        assert_eq!(TemplateModule::white_list(collection_id, 2), true);
     });
 }
 
@@ -975,7 +975,7 @@
 
         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), collection_id, 2));
         assert_ok!(TemplateModule::add_to_white_list(origin2.clone(), collection_id, 3));
-        assert_eq!(TemplateModule::white_list(collection_id)[0], 3);
+        assert_eq!(TemplateModule::white_list(collection_id, 3), true);
     });
 }
 
@@ -1035,8 +1035,7 @@
         
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
         assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
-        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);
-        assert_eq!(TemplateModule::white_list(collection_id).len(), 1);
+        assert_eq!(TemplateModule::white_list(collection_id, 2), true);
     });
 }
 
@@ -1054,7 +1053,7 @@
             collection_id,
             2
         ));
-        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);
+        assert_eq!(TemplateModule::white_list(collection_id, 2), false);
     });
 }
 
@@ -1075,7 +1074,7 @@
             collection_id,
             3
         ));
-        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);
+        assert_eq!(TemplateModule::white_list(collection_id, 3), false);
     });
 }
 
@@ -1093,7 +1092,7 @@
             TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),
             Error::<Test>::NoPermission
         );
-        assert_eq!(TemplateModule::white_list(collection_id)[0], 2);
+        assert_eq!(TemplateModule::white_list(collection_id, 2), true);
     });
 }
 
@@ -1125,7 +1124,7 @@
             TemplateModule::remove_from_white_list(origin2.clone(), collection_id, 2),
             Error::<Test>::CollectionNotFound
         );
-        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);
+        assert_eq!(TemplateModule::white_list(collection_id, 2), false);
     });
 }
 
@@ -1149,7 +1148,7 @@
             collection_id,
             2
         ));
-        assert_eq!(TemplateModule::white_list(collection_id).len(), 0);
+        assert_eq!(TemplateModule::white_list(collection_id, 2), false);
     });
 }
 

--- a/tests/src/contracts.test.ts
+++ b/tests/src/contracts.test.ts
@@ -1,16 +1,15 @@
-//
-// This file is subject to the terms and conditions defined in
-// file 'LICENSE', which is part of this source code package.
-//
-
-import { ApiPromise } from "@polkadot/api";
-import { expect } from "chai";
-import { default as usingApi, submitTransactionAsync } from "./substrate/substrate-api";
+import chai from "chai";
+import chaiAsPromised from 'chai-as-promised';
+import usingApi, { submitTransactionAsync, submitTransactionExpectFailAsync } from "./substrate/substrate-api";
 import fs from "fs";
-import { Abi, BlueprintPromise, CodePromise } from "@polkadot/api-contract";
+import { Abi, BlueprintPromise as Blueprint, CodePromise, ContractPromise as Contract } from "@polkadot/api-contract";
 import { IKeyringPair } from "@polkadot/types/types";
-import { Keyring } from "@polkadot/api";
+import { ApiPromise, Keyring } from "@polkadot/api";
 import { ApiTypes, SubmittableExtrinsic } from "@polkadot/api/types";
+import privateKey from "./substrate/privateKey";
+
+chai.use(chaiAsPromised);
+const expect = chai.expect;
 import { BigNumber } from 'bignumber.js';
 import { findUnusedAddress } from './util/helpers'
 
@@ -18,8 +17,8 @@
 const gasLimit = 3000n * 1000000n;
 const endowment = `1000000000000000`;
 
-function deployBlueprint(alice: IKeyringPair, code: CodePromise): Promise<BlueprintPromise> {
-  return new Promise<BlueprintPromise>(async (resolve, reject) => {
+function deployBlueprint(alice: IKeyringPair, code: CodePromise): Promise<Blueprint> {
+  return new Promise<Blueprint>(async (resolve, reject) => {
     const unsub = await code
       .createBlueprint()
       .signAndSend(alice, (result) => {
@@ -32,7 +31,7 @@
   });
 }
 
-function deployContract(alice: IKeyringPair, blueprint: BlueprintPromise) : Promise<any> {
+function deployContract(alice: IKeyringPair, blueprint: Blueprint) : Promise<any> {
   return new Promise<any>(async (resolve, reject) => {
     const initValue = true;
 
@@ -62,39 +61,112 @@
   return deployer;
 }
 
-describe('Contracts smoke test', () => {
+async function deployFlipper(api: ApiPromise): Promise<[Contract, IKeyringPair]> {
+  const metadata = JSON.parse(fs.readFileSync('./src/flipper/metadata.json').toString('utf-8'));
+  const abi = new Abi(metadata);
+
+  const deployer = await prepareDeployer(api);
+
+  const wasm = fs.readFileSync('./src/flipper/flipper.wasm');
+
+  const code = new CodePromise(api, abi, wasm);
+
+  const blueprint = await deployBlueprint(deployer, code);
+  const contract = (await deployContract(deployer, blueprint))['contract'] as Contract;
+
+  const initialGetResponse = await getFlipValue(contract, deployer);
+  expect(initialGetResponse).to.be.true;
+
+  return [contract, deployer];
+}
+
+async function getFlipValue(contract: Contract, deployer: IKeyringPair) {
+  const result = await contract.query.get(deployer.address, value, gasLimit);
+
+  if(!result.result.isSuccess) {
+    throw `Failed to get flipper value`;
+  }
+  return (result.result.asSuccess.data[0] == 0x00) ? false : true;
+}
+
+describe('Contracts', () => {
   it(`Can deploy smart contract Flipper, instantiate it and call it's get and flip messages.`, async () => {
     await usingApi(async api => {
-      const deployer = await prepareDeployer(api);
+      const [contract, deployer] = await deployFlipper(api);
+      const initialGetResponse = await getFlipValue(contract, deployer);
+
+      const bob = privateKey("//Bob");
+      const flip = contract.exec('flip', value, gasLimit);
+      await submitTransactionAsync(bob, flip);
+
+      const afterFlipGetResponse = await getFlipValue(contract, deployer);
+      expect(afterFlipGetResponse).not.to.be.eq(initialGetResponse, 'Flipping should change value.');
+    });
+  });
+
+  it(`Whitelisted account can call contract.`, async () => {
+    await usingApi(async api => {
+      const bob = privateKey("//Bob");
       
-      const wasm = fs.readFileSync('./src/flipper/flipper.wasm');
-      
-      const metadata = JSON.parse(fs.readFileSync('./src/flipper/metadata.json').toString('utf-8'));
-      const abi = new Abi(metadata);
+      const [contract, deployer] = await deployFlipper(api);
+      const consoleError = console.error;
+      console.error = (...data: any[]) => {
+      };
 
-      const code = new CodePromise(api, abi, wasm);
+      let expectedFlipValue = await getFlipValue(contract, deployer);
 
-      const blueprint = await deployBlueprint(deployer, code);
-      const contract = (await deployContract(deployer, blueprint))['contract'];
+      const flip = contract.exec('flip', value, gasLimit);
+      await submitTransactionAsync(bob, flip);
+      expectedFlipValue = !expectedFlipValue;
+      const afterFlip = await getFlipValue(contract,deployer);
+      expect(afterFlip).to.be.eq(expectedFlipValue, `Anyone can call new contract.`);
 
-      const getFlipValue = async () => {
-        const result = await contract.query.get(deployer.address, value, gasLimit);
+      const deployerCanFlip = async () => {
+        expectedFlipValue = !expectedFlipValue;
+        const deployerFlip = contract.exec('flip', value, gasLimit);
+        await submitTransactionAsync(deployer, deployerFlip);
+        const aliceFlip1Response = await getFlipValue(contract, deployer);
+        expect(aliceFlip1Response).to.be.eq(expectedFlipValue, `Deployer always can flip.`);
+      };
+      await deployerCanFlip();
 
-        if(!result.result.isSuccess) {
-          throw `Failed to get flipper value`;
-        }
-        return (result.result.asSuccess.data[0] == 0x00) ? false : true;
-      }
+      const enableWhiteListTx = api.tx.nft.toggleContractWhiteList(contract.address, true);
+      const enableResult = await submitTransactionAsync(deployer, enableWhiteListTx);
+      const flipWithEnabledWhiteList = contract.exec('flip', value, gasLimit);
+      await expect(submitTransactionExpectFailAsync(bob, flipWithEnabledWhiteList)).to.be.rejected;
+      const flipValueAfterEnableWhiteList = await getFlipValue(contract, deployer);
+      expect(flipValueAfterEnableWhiteList).to.be.eq(expectedFlipValue, `Enabling whitelist doesn't make it possible to call contract for everyone.`);
 
-      const initialGetResponse = await getFlipValue();
-      expect(initialGetResponse).to.be.true;
+      await deployerCanFlip();
 
-      const flip = contract.exec('flip', value, gasLimit);
-      await submitTransactionAsync(deployer, flip);
+      const addBobToWhiteListTx = api.tx.nft.addToContractWhiteList(contract.address, bob.address);
+      const addBobResult = await submitTransactionAsync(deployer, addBobToWhiteListTx);
+      const flipWithWhitelistedBob = contract.exec('flip', value, gasLimit);
+      await submitTransactionAsync(bob, flipWithWhitelistedBob);
+      expectedFlipValue = !expectedFlipValue;
+      const flipAfterWhiteListed = await getFlipValue(contract,deployer);
+      expect(flipAfterWhiteListed).to.be.eq(expectedFlipValue, `Bob was whitelisted, now he can flip.`);
 
-      const afterFlipGetResponse = await getFlipValue();
+      await deployerCanFlip();
 
-      expect(afterFlipGetResponse).to.be.false;
+      const removeBobFromWhiteListTx = api.tx.nft.removeFromContractWhiteList(contract.address, bob.address);
+      const removeBobResult = await submitTransactionAsync(deployer, removeBobFromWhiteListTx);
+      const bobRemoved = contract.exec('flip', value, gasLimit);
+      await expect(submitTransactionExpectFailAsync(bob, bobRemoved)).to.be.rejected;
+      const afterBobRemoved = await getFlipValue(contract, deployer);
+      expect(afterBobRemoved).to.be.eq(expectedFlipValue, `Bob can't call contract, now when he is removeed from white list.`);
+
+      await deployerCanFlip();
+
+      const disableWhiteListTx = api.tx.nft.toggleContractWhiteList(contract.address, false);
+      const disableWhiteListResult = await submitTransactionAsync(deployer, disableWhiteListTx);
+      const whiteListDisabledFlip = contract.exec('flip', value, gasLimit);
+      await submitTransactionAsync(bob, whiteListDisabledFlip);
+      expectedFlipValue = !expectedFlipValue;
+      const afterWhiteListDisabled = await getFlipValue(contract,deployer);
+      expect(afterWhiteListDisabled).to.be.eq(expectedFlipValue, `Anyone can call contract with disabled whitelist.`);
+
+      console.error = consoleError;
     });
   });
 

--- a/tests/src/createItem.test.ts
+++ b/tests/src/createItem.test.ts
@@ -8,7 +8,7 @@
   createItemExpectSuccess
 } from './util/helpers';
 
-describe.only('integration test: ext. createItem():', () => {
+describe('integration test: ext. createItem():', () => {
   it('Create new item in NFT collection', async () => {
     const createMode = 'NFT';
     const newCollectionID = await createCollectionExpectSuccess('0', '0', '0', createMode);

--- a/tests/src/substrate/substrate-api.ts
+++ b/tests/src/substrate/substrate-api.ts
@@ -56,3 +56,25 @@
     }
   });
 }
+
+export function submitTransactionExpectFailAsync(sender: IKeyringPair, transaction: SubmittableExtrinsic<ApiTypes>): Promise<EventRecord[]> {
+  return new Promise(async function(resolve, reject) {
+    try {
+      await transaction.signAndSend(sender, ({ events = [], status }) => {
+        if (status.isReady) {
+          // nothing to do
+          // console.log(`Current tx status is Ready`);
+        } else if (status.isBroadcast) {
+          // nothing to do
+          // console.log(`Current tx status is Broadcast`);
+        } else if (status.isInBlock || status.isFinalized) {
+          resolve(events);
+        } else {
+          reject("Transaction failed");
+        }
+      });
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
\ No newline at end of file