From fea7eca0a15bfbb9b74c275336220458dd3abdae Mon Sep 17 00:00:00 2001 From: mihaisc Date: Mon, 13 Dec 2021 11:01:57 -0800 Subject: [PATCH] Add setTokenURI and others (#1151) * add setTokenURI * est gas fix * add comments * delete old files * test --- src/factories/NFTFactory.ts | 7 +- src/tokens/NFT.ts | 49 +++++ src/utils/ContractParams.ts | 1 - test/unit/NFTFactory.test.ts | 385 ----------------------------------- test/unit/tokens/NFT.test.ts | 300 --------------------------- test/unit/tokens/Nft.test.ts | 5 + 6 files changed, 55 insertions(+), 692 deletions(-) delete mode 100644 test/unit/NFTFactory.test.ts delete mode 100644 test/unit/tokens/NFT.test.ts diff --git a/src/factories/NFTFactory.ts b/src/factories/NFTFactory.ts index aa87a7c4..592213b2 100644 --- a/src/factories/NFTFactory.ts +++ b/src/factories/NFTFactory.ts @@ -605,12 +605,7 @@ export class NftFactory { ): Promise { const ercCreateData = getErcCreationParams(ercParams, this.web3) - const estGas = await this.estGasCreateNftWithErc( - address, - nftCreateData, - ercCreateData - ) - + const estGas = await this.estGasCreateNftWithErc(address, nftCreateData, ercParams) // Invoke createToken function of the contract const trxReceipt = await this.factory721.methods .createNftWithErc(nftCreateData, ercCreateData) diff --git a/src/tokens/NFT.ts b/src/tokens/NFT.ts index 1c6f6859..98355471 100644 --- a/src/tokens/NFT.ts +++ b/src/tokens/NFT.ts @@ -1021,4 +1021,53 @@ export class Nft { const data = await nftContract.methods.getData(key).call() return data } + + /** Estimate gas cost for setTokenURI method + * @param nftAddress erc721 contract adress + * @param address user adress + * @param data input data for TokenURI + * @return {Promise} transaction receipt + */ + public async estSetTokenURI( + nftAddress: string, + address: string, + data: string + ): Promise { + const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress) + + const gasLimitDefault = this.GASLIMIT_DEFAULT + let estGas + try { + estGas = await nftContract.methods + .setTokenURI('1', data) + .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas)) + } catch (e) { + estGas = gasLimitDefault + console.log('eerr', e) + } + + return estGas + } + + /** set TokenURI on an nft + * @param nftAddress erc721 contract adress + * @param address user adress + * @param data input data for TokenURI + * @return {Promise} transaction receipt + */ + public async setTokenURI( + nftAddress: string, + address: string, + data: string + ): Promise { + const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress) + + const estGas = await this.estSetTokenURI(nftAddress, address, data) + const trxReceipt = await nftContract.methods.setTokenURI('1', data).send({ + from: address, + gas: estGas + 1, + gasPrice: await getFairGasPrice(this.web3) + }) + return trxReceipt + } } diff --git a/src/utils/ContractParams.ts b/src/utils/ContractParams.ts index e80b2e73..4948e7c8 100644 --- a/src/utils/ContractParams.ts +++ b/src/utils/ContractParams.ts @@ -8,7 +8,6 @@ export function getErcCreationParams(ercParams: Erc20CreateParams, web3: Web3): if (!ercParams.name || !ercParams.symbol) { ;({ name, symbol } = generateDtName()) } - return { templateIndex: ercParams.templateIndex, strings: [ercParams.name || name, ercParams.symbol || symbol], diff --git a/test/unit/NFTFactory.test.ts b/test/unit/NFTFactory.test.ts deleted file mode 100644 index c551088e..00000000 --- a/test/unit/NFTFactory.test.ts +++ /dev/null @@ -1,385 +0,0 @@ -import { assert, expect } from 'chai' -import { AbiItem } from 'web3-utils/types' -import { TestContractHandler } from '../TestContractHandler' -import Web3 from 'web3' -import ERC721Factory from '@oceanprotocol/contracts/artifacts/contracts/ERC721Factory.sol/ERC721Factory.json' -import ERC721Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC721Template.sol/ERC721Template.json' -import SideStaking from '@oceanprotocol/contracts/artifacts/contracts/pools/ssContracts/SideStaking.sol/SideStaking.json' -import Router from '@oceanprotocol/contracts/artifacts/contracts/pools/FactoryRouter.sol/FactoryRouter.json' -import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json' -import Dispenser from '@oceanprotocol/contracts/artifacts/contracts/pools/dispenser/Dispenser.sol/Dispenser.json' -import FixedRate from '@oceanprotocol/contracts/artifacts/contracts/pools/fixedRate/FixedRateExchange.sol/FixedRateExchange.json' -import OPFCommunityFeeCollector from '@oceanprotocol/contracts/artifacts/contracts/communityFee/OPFCommunityFeeCollector.sol/OPFCommunityFeeCollector.json' -import PoolTemplate from '@oceanprotocol/contracts/artifacts/contracts/pools/balancer/BPool.sol/BPool.json' -import { NftFactory, NftCreateData, TokenOrder } from '../../src/factories/NFTFactory' -import { - FreCreationParams, - Erc20CreateParams, - PoolCreationParams -} from '../../src/interfaces' - -const web3 = new Web3('http://127.0.0.1:8545') - -describe('Nft Factory test', () => { - let factoryOwner: string - let nftOwner: string - let user1: string - let user2: string - let user3: string - let contracts: TestContractHandler - let nftFactory: NftFactory - let dtAddress: string - let dtAddress2: string - let nftAddress: string - - it('should deploy contracts', async () => { - contracts = new TestContractHandler( - web3, - ERC721Template.abi as AbiItem[], - ERC20Template.abi as AbiItem[], - PoolTemplate.abi as AbiItem[], - ERC721Factory.abi as AbiItem[], - Router.abi as AbiItem[], - SideStaking.abi as AbiItem[], - FixedRate.abi as AbiItem[], - Dispenser.abi as AbiItem[], - OPFCommunityFeeCollector.abi as AbiItem[], - - ERC721Template.bytecode, - ERC20Template.bytecode, - PoolTemplate.bytecode, - ERC721Factory.bytecode, - Router.bytecode, - SideStaking.bytecode, - FixedRate.bytecode, - Dispenser.bytecode, - OPFCommunityFeeCollector.bytecode - ) - await contracts.getAccounts() - factoryOwner = contracts.accounts[0] - nftOwner = contracts.accounts[1] - user1 = contracts.accounts[2] - user2 = contracts.accounts[3] - user3 = contracts.accounts[4] - - await contracts.deployContracts(factoryOwner, Router.abi as AbiItem[]) - - console.log( - 'address', - contracts.factory721Address, - contracts.poolTemplateAddress, - contracts.routerAddress, - contracts.fixedRateAddress, - contracts.dispenserAddress, - contracts.sideStakingAddress, - contracts.template721Address, - contracts.template20Address - ) - const daiContract = new web3.eth.Contract( - contracts.MockERC20.options.jsonInterface, - contracts.daiAddress - ) - await daiContract.methods - .approve(contracts.factory721Address, web3.utils.toWei('10000')) - .send({ from: contracts.accounts[0] }) - }) - - it('should initiate NFTFactory instance', async () => { - nftFactory = new NftFactory(contracts.factory721Address, web3) - }) - - it('#getCurrentNFTCount - should return actual nft count (0)', async () => { - const nftCount = await nftFactory.getCurrentNFTCount() - expect(nftCount).to.equal('0') - }) - - it('#getCurrentTokenCount - should return actual token count (0)', async () => { - const tokenCount = await nftFactory.getCurrentTokenCount() - expect(tokenCount).to.equal('0') - }) - it('#getOwner - should return actual owner', async () => { - const owner = await nftFactory.getOwner() - assert(owner === contracts.accounts[0]) - }) - it('#getCurrentNFTTemplateCount - should return actual nft template count (1)', async () => { - const nftTemplateCount = await nftFactory.getCurrentNFTTemplateCount() - expect(nftTemplateCount).to.equal('1') - }) - it('#getCurrentTokenTemplateCount - should return actual token template count (1)', async () => { - const tokenTemplateCount = await nftFactory.getCurrentTokenTemplateCount() - expect(tokenTemplateCount).to.equal('1') - }) - it('#getNFTTemplate - should return NFT template struct', async () => { - const nftTemplate = await nftFactory.getNFTTemplate(1) - assert(nftTemplate.isActive === true) - assert(nftTemplate.templateAddress === contracts.template721Address) - }) - it('#getTokenTemplate - should return Token template struct', async () => { - const tokenTemplate = await nftFactory.getTokenTemplate(1) - assert(tokenTemplate.isActive === true) - assert(tokenTemplate.templateAddress === contracts.template20Address) - }) - it('#addNFTTemplate - should add NFT template if factory owner', async () => { - await nftFactory.addNFTTemplate(contracts.accounts[0], contracts.fixedRateAddress) // contracts.fixedRateAddress it's just a dummy contract in this case - const nftTemplateCount = await nftFactory.getCurrentNFTTemplateCount() - expect(nftTemplateCount).to.equal('2') - const nftTemplate = await nftFactory.getNFTTemplate(2) - assert(nftTemplate.isActive === true) - assert(nftTemplate.templateAddress === contracts.fixedRateAddress) - }) - it('#disableNFTTemplate - should disable NFT template if factory owner', async () => { - let nftTemplate = await nftFactory.getNFTTemplate(2) - assert(nftTemplate.isActive === true) - await nftFactory.disableNFTTemplate(contracts.accounts[0], 2) // owner disables template index = 2 - - nftTemplate = await nftFactory.getNFTTemplate(2) - assert(nftTemplate.isActive === false) - }) - it('#reactivateNFTTemplate - should disable NFT template if factory owner', async () => { - let nftTemplate = await nftFactory.getNFTTemplate(2) - assert(nftTemplate.isActive === false) - await nftFactory.reactivateNFTTemplate(contracts.accounts[0], 2) // owner reactivates template index = 2 - - nftTemplate = await nftFactory.getNFTTemplate(2) - assert(nftTemplate.isActive === true) - }) - it('#addTokenTemplate - should add Datatoken template if factory owner', async () => { - await nftFactory.addTokenTemplate(contracts.accounts[0], contracts.fixedRateAddress) // contracts.fixedRateAddress it's just a dummy contract in this case - const tokenTemplateCount = await nftFactory.getCurrentTokenTemplateCount() - expect(tokenTemplateCount).to.equal('2') - const nftTemplate = await nftFactory.getTokenTemplate(2) - assert(nftTemplate.isActive === true) - assert(nftTemplate.templateAddress === contracts.fixedRateAddress) - }) - - it('#disableTokenTemplate - should disable Token template if factory owner', async () => { - let tokenTemplate = await nftFactory.getTokenTemplate(2) - assert(tokenTemplate.isActive === true) - await nftFactory.disableTokenTemplate(contracts.accounts[0], 2) // owner disables template index = 2 - - tokenTemplate = await nftFactory.getTokenTemplate(2) - assert(tokenTemplate.isActive === false) - }) - it('#reactivateTokenTemplate - should disable Token template if factory owner', async () => { - let tokenTemplate = await nftFactory.getTokenTemplate(2) - assert(tokenTemplate.isActive === false) - await nftFactory.reactivateTokenTemplate(contracts.accounts[0], 2) // owner reactivates template index = 2 - - tokenTemplate = await nftFactory.getTokenTemplate(2) - assert(tokenTemplate.isActive === true) - }) - - it('#createNftwithErc - should create an NFT and a Datatoken ', async () => { - // we prepare transaction parameters objects - const nftData: NftCreateData = { - name: '72120Bundle', - symbol: '72Bundle', - templateIndex: 1, - tokenURI: 'https://oceanprotocol.com/nft/' - } - - const ercParams: Erc20CreateParams = { - templateIndex: 1, - minter: contracts.accounts[0], - feeManager: user3, - mpFeeAddress: user2, - feeToken: '0x0000000000000000000000000000000000000000', - cap: '10000', - feeAmount: '0', - name: 'ERC20B1', - symbol: 'ERC20DT1Symbol' - } - - const txReceipt = await nftFactory.createNftWithErc( - contracts.accounts[0], - nftData, - ercParams - ) - - // EVENTS HAVE BEEN EMITTED - expect(txReceipt.events.NFTCreated.event === 'NFTCreated') - expect(txReceipt.events.TokenCreated.event === 'TokenCreated') - - // stored for later use in startMultipleTokenOrder test - nftAddress = txReceipt.events.NFTCreated.returnValues.newTokenAddress - dtAddress = txReceipt.events.TokenCreated.returnValues.newTokenAddress - }) - - it('#createNftErcWithPool- should create an NFT, a Datatoken and a pool DT/DAI', async () => { - // we prepare transaction parameters objects - const nftData: NftCreateData = { - name: '72120Bundle', - symbol: '72Bundle', - templateIndex: 1, - tokenURI: 'https://oceanprotocol.com/nft/' - } - - const ercParams: Erc20CreateParams = { - templateIndex: 1, - minter: user2, - feeManager: user3, - mpFeeAddress: user2, - feeToken: '0x0000000000000000000000000000000000000000', - cap: '1000000', - feeAmount: '0', - name: 'ERC20B1', - symbol: 'ERC20DT1Symbol' - } - - const poolParams: PoolCreationParams = { - ssContract: contracts.sideStakingAddress, - basetokenAddress: contracts.daiAddress, - basetokenSender: contracts.factory721Address, - publisherAddress: contracts.accounts[0], - marketFeeCollector: contracts.accounts[0], - poolTemplateAddress: contracts.poolTemplateAddress, - rate: '1', - basetokenDecimals: 18, - vestingAmount: '10000', - vestedBlocks: 2500000, - initialBasetokenLiquidity: '2000', - swapFeeLiquidityProvider: 1e15, - swapFeeMarketPlaceRunner: 1e15 - } - - const txReceipt = await nftFactory.createNftErcWithPool( - contracts.accounts[0], - nftData, - ercParams, - poolParams - ) - - // EVENTS HAVE BEEN EMITTED - expect(txReceipt.events.NFTCreated.event === 'NFTCreated') - expect(txReceipt.events.TokenCreated.event === 'TokenCreated') - expect(txReceipt.events.NewPool.event === 'NewPool') - }) - - it('#createNftErcWithFixedRate- should create an NFT, a datatoken and create a Fixed Rate Exchange', async () => { - // we prepare transaction parameters objects - const nftData: NftCreateData = { - name: '72120Bundle', - symbol: '72Bundle', - templateIndex: 1, - tokenURI: 'https://oceanprotocol.com/nft/' - } - - const ercParams: Erc20CreateParams = { - templateIndex: 1, - minter: contracts.accounts[0], - feeManager: user3, - mpFeeAddress: user2, - feeToken: '0x0000000000000000000000000000000000000000', - cap: '1000000', - feeAmount: '0', - name: 'ERC20B1', - symbol: 'ERC20DT1Symbol' - } - - const freParams: FreCreationParams = { - fixedRateAddress: contracts.fixedRateAddress, - baseTokenAddress: contracts.daiAddress, - owner: contracts.accounts[0], - marketFeeCollector: contracts.accounts[0], - baseTokenDecimals: 18, - dataTokenDecimals: 18, - fixedRate: '1', - marketFee: 1e15, - allowedConsumer: contracts.accounts[0], - withMint: false - } - - const txReceipt = await nftFactory.createNftErcWithFixedRate( - contracts.accounts[0], - nftData, - ercParams, - freParams - ) - - // EVENTS HAVE BEEN EMITTED - expect(txReceipt.events.NFTCreated.event === 'NFTCreated') - expect(txReceipt.events.TokenCreated.event === 'TokenCreated') - expect(txReceipt.events.NewFixedRate.event === 'NewFixedRate') - - // stored for later use in startMultipleTokenOrder test - dtAddress2 = txReceipt.events.TokenCreated.returnValues.newTokenAddress - }) - - it('#startMultipleTokenOrder- should succed to start multiple orders', async () => { - const consumer = user2 // could be different user - const dtAmount = web3.utils.toWei('1') - const serviceIndex = 1 // dummy index - const consumeFeeAddress = user3 // marketplace fee Collector - const consumeFeeAmount = '0' // fee to be collected on top, requires approval - const consumeFeeToken = contracts.daiAddress // token address for the feeAmount, in this case DAI - - // we reuse a DT created in a previous test - const dtContract = new web3.eth.Contract(ERC20Template.abi as AbiItem[], dtAddress) - expect(await dtContract.methods.balanceOf(user2).call()).to.equal('0') - - // dt owner mint dtAmount to user2 - await dtContract.methods.mint(user2, dtAmount).send({ from: contracts.accounts[0] }) - - // user2 approves NFTFactory to move his dtAmount - await dtContract.methods - .approve(contracts.factory721Address, dtAmount) - .send({ from: user2 }) - - // we reuse another DT created in a previous test - const dtContract2 = new web3.eth.Contract(ERC20Template.abi as AbiItem[], dtAddress2) - expect(await dtContract2.methods.balanceOf(user2).call()).to.equal('0') - - // dt owner mint dtAmount to user2 - await dtContract2.methods.mint(user2, dtAmount).send({ from: contracts.accounts[0] }) - // user2 approves NFTFactory to move his dtAmount - await dtContract2.methods - .approve(contracts.factory721Address, dtAmount) - .send({ from: user2 }) - - // we check user2 has enought DTs - expect(await dtContract.methods.balanceOf(user2).call()).to.equal(dtAmount) - expect(await dtContract2.methods.balanceOf(user2).call()).to.equal(dtAmount) - - const orders: TokenOrder[] = [ - { - tokenAddress: dtAddress, - consumer: consumer, - amount: dtAmount, - serviceIndex: serviceIndex, - providerFeeAddress: consumeFeeAddress, - providerFeeToken: consumeFeeToken, - providerFeeAmount: consumeFeeAmount - }, - { - tokenAddress: dtAddress2, - consumer: consumer, - amount: dtAmount, - serviceIndex: serviceIndex, - providerFeeAddress: consumeFeeAddress, - providerFeeToken: consumeFeeToken, - providerFeeAmount: consumeFeeAmount - } - ] - - await nftFactory.startMultipleTokenOrder(user2, orders) - - // we check user2 has no more DTs - expect(await dtContract.methods.balanceOf(user2).call()).to.equal('0') - expect(await dtContract2.methods.balanceOf(user2).call()).to.equal('0') - }) - - it('#checkDatatoken - should confirm if DT is from the factory', async () => { - assert((await nftFactory.checkDatatoken(dtAddress)) === true) - assert((await nftFactory.checkDatatoken(dtAddress2)) === true) - assert((await nftFactory.checkDatatoken(user2)) === false) - assert((await nftFactory.checkDatatoken(nftAddress)) === false) - }) - - it('#checkNFT - should return nftAddress if from the factory, or address(0) if not', async () => { - assert( - (await nftFactory.checkNFT(dtAddress)) === - '0x0000000000000000000000000000000000000000' - ) - assert((await nftFactory.checkNFT(nftAddress)) === nftAddress) - }) -}) diff --git a/test/unit/tokens/NFT.test.ts b/test/unit/tokens/NFT.test.ts deleted file mode 100644 index 9a74b0c7..00000000 --- a/test/unit/tokens/NFT.test.ts +++ /dev/null @@ -1,300 +0,0 @@ -import { assert } from 'chai' -import Web3 from 'web3' -import PoolTemplate from '@oceanprotocol/contracts/artifacts/contracts/pools/balancer/BPool.sol/BPool.json' -import ERC721Factory from '@oceanprotocol/contracts/artifacts/contracts/ERC721Factory.sol/ERC721Factory.json' -import ERC721Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC721Template.sol/ERC721Template.json' -import SideStaking from '@oceanprotocol/contracts/artifacts/contracts/pools/ssContracts/SideStaking.sol/SideStaking.json' -import Router from '@oceanprotocol/contracts/artifacts/contracts/pools/FactoryRouter.sol/FactoryRouter.json' -import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json' -import Dispenser from '@oceanprotocol/contracts/artifacts/contracts/pools/dispenser/Dispenser.sol/Dispenser.json' -import FixedRate from '@oceanprotocol/contracts/artifacts/contracts/pools/fixedRate/FixedRateExchange.sol/FixedRateExchange.json' -import OPFCollector from '@oceanprotocol/contracts/artifacts/contracts/communityFee/OPFCommunityFeeCollector.sol/OPFCommunityFeeCollector.json' -import { TestContractHandler } from '../../TestContractHandler' -import { NftFactory, NftCreateData } from '../../../src/factories/NFTFactory' -import { Nft } from '../../../src/tokens/NFT' -import { AbiItem } from 'web3-utils' - -const web3 = new Web3('http://127.0.0.1:8545') - -describe('NFT', () => { - let nftOwner: string - let user1: string - let user2: string - let user3: string - let contractHandler: TestContractHandler - let nftDatatoken: Nft - let nftFactory: NftFactory - let nftAddress: string - - const nftName = 'NFTName' - const nftSymbol = 'NFTSymbol' - const publishMarketFeeAdress = '0xeE9300b7961e0a01d9f0adb863C7A227A07AaD75' - const oceanAddress = '0x967da4048cd07ab37855c090aaf366e4ce1b9f48' - - it('should deploy contracts', async () => { - contractHandler = new TestContractHandler( - web3, - ERC721Template.abi as AbiItem[], - ERC20Template.abi as AbiItem[], - PoolTemplate.abi as AbiItem[], - ERC721Factory.abi as AbiItem[], - Router.abi as AbiItem[], - SideStaking.abi as AbiItem[], - FixedRate.abi as AbiItem[], - Dispenser.abi as AbiItem[], - OPFCollector.abi as AbiItem[], - - ERC721Template.bytecode, - ERC20Template.bytecode, - PoolTemplate.bytecode, - ERC721Factory.bytecode, - Router.bytecode, - SideStaking.bytecode, - FixedRate.bytecode, - Dispenser.bytecode, - OPFCollector.bytecode - ) - await contractHandler.getAccounts() - nftOwner = contractHandler.accounts[0] - user1 = contractHandler.accounts[1] - user2 = contractHandler.accounts[2] - user3 = contractHandler.accounts[3] - await contractHandler.deployContracts(nftOwner, Router.abi as AbiItem[]) - }) - - it('should initialize NFTFactory instance and create a new NFT', async () => { - nftFactory = new NftFactory( - contractHandler.factory721Address, - web3, - ERC721Factory.abi as AbiItem[] - ) - const nftData: NftCreateData = { - name: nftName, - symbol: nftSymbol, - templateIndex: 1, - tokenURI: 'https://oceanprotocol.com/nft/' - } - - nftAddress = await nftFactory.createNFT(nftOwner, nftData) - nftDatatoken = new Nft(web3, ERC721Template.abi as AbiItem[]) - }) - - it('#createERC20 - should create a new ERC20 DT from NFT contract', async () => { - const erc20Address = await nftDatatoken.createErc20( - nftAddress, - nftOwner, - nftOwner, - user1, - user2, - '0x0000000000000000000000000000000000000000', - '0', - '10000', - nftName, - nftSymbol, - 1 - ) - assert(erc20Address !== null) - }) - - // Manager - it('#addManager - should add a new Manager', async () => { - assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).manager === false) - - await nftDatatoken.addManager(nftAddress, nftOwner, user1) - - assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).manager === true) - }) - - it('#addManager - should fail to add a new Manager, if NOT NFT Owner', async () => { - try { - await nftDatatoken.addManager(nftAddress, user1, user1) - } catch (e) { - assert(e.message === 'Caller is not NFT Owner') - } - }) - - it('#removeManager - should remove a Manager', async () => { - assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).manager === true) - - await nftDatatoken.removeManager(nftAddress, nftOwner, user1) - - assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).manager === false) - }) - - it('#removeManager - should fail to remove a new Manager, if NOT NFT Owner', async () => { - try { - await nftDatatoken.removeManager(nftAddress, user1, nftOwner) - } catch (e) { - assert(e.message === 'Caller is not NFT Owner') - } - }) - - // ERC20Deployer - it('#addERC20Deployer -should add ERC20deployer if Manager', async () => { - assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === false) - - await nftDatatoken.addErc20Deployer(nftAddress, nftOwner, user1) - - assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === true) - }) - - it('#addERC20Deployer - should fail to add ERC20deployer if NOT Manager', async () => { - try { - await nftDatatoken.addErc20Deployer(nftAddress, user1, user1) - } catch (e) { - assert( - e.message === - 'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: NOT MANAGER' - ) - } - }) - - it('#removeERC20Deployer - remove ERC20deployer if Manager', async () => { - assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === true) - - await nftDatatoken.removeErc20Deployer(nftAddress, nftOwner, user1) - - assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === false) - }) - - it('#removeERC20Deployer - should fail and remove ERC20deployer if NOT Manager', async () => { - try { - await nftDatatoken.removeErc20Deployer(nftAddress, user1, user1) - } catch (e) { - assert( - e.message === - 'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: Not enough permissions to remove from ERC20List' - ) - } - }) - - // MetadataUpdate - it('#addMetadataUpdate - should add to remove Metadata Updater if Manager', async () => { - assert( - (await nftDatatoken.getNftPermissions(nftAddress, user1)).updateMetadata === false - ) - - await nftDatatoken.addMetadataUpdater(nftAddress, nftOwner, user1) - - assert( - (await nftDatatoken.getNftPermissions(nftAddress, user1)).updateMetadata === true - ) - }) - - it('#addMetadataUpdate - should fail to add Metadata Updater if NOT Manager', async () => { - try { - await nftDatatoken.addMetadataUpdater(nftAddress, user1, user1) - } catch (e) { - assert( - e.message === - 'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: NOT MANAGER' - ) - } - }) - - it('#removeMetadataUpdate - remove Metadata Updater if Manager', async () => { - assert( - (await nftDatatoken.getNftPermissions(nftAddress, user1)).updateMetadata === true - ) - - await nftDatatoken.removeMetadataUpdater(nftAddress, nftOwner, user1) - - assert( - (await nftDatatoken.getNftPermissions(nftAddress, user1)).updateMetadata === false - ) - }) - - it('#removeMetadataUpdate - should fail to remove Metadata Updater if NOT Manager', async () => { - try { - await nftDatatoken.removeMetadataUpdater(nftAddress, user1, user1) - } catch (e) { - assert( - e.message === - 'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: Not enough permissions to remove from metadata list' - ) - } - }) - - // StoreUpdater - it('#addStoreUpdater - should add to remove Store Updater if Manager', async () => { - assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).store === false) - - await nftDatatoken.addStoreUpdater(nftAddress, nftOwner, user1) - - assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).store === true) - }) - - it('#addStoreUpdater - should fail to add Store Updater if NOT Manager', async () => { - try { - await nftDatatoken.addStoreUpdater(nftAddress, user1, user1) - } catch (e) { - assert( - e.message === - 'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: NOT MANAGER' - ) - } - }) - - it('#removeStoreUpdater - remove Metadata Updater if Manager', async () => { - assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).store === true) - - await nftDatatoken.removeStoreUpdater(nftAddress, nftOwner, user1) - - assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).store === false) - }) - - it('#removeStoreUpdater - should fail to remove Metadata Updater if NOT Manager', async () => { - try { - await nftDatatoken.removeStoreUpdater(nftAddress, user1, user1) - } catch (e) { - assert( - e.message === - 'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: Not enough permissions to remove from 725StoreList' - ) - } - }) - - // Transfer test - it('#transferNFT - should fail to transfer the NFT and clean all permissions, if NOT NFT Owner', async () => { - assert((await nftDatatoken.getNftOwner(nftAddress)) !== user1) - - try { - await nftDatatoken.transferNft(nftAddress, user1, user1, 1) - } catch (e) { - assert(e.message === 'Caller is not NFT Owner') - } - }) - - it('#transferNFT - should transfer the NFT and clean all permissions, set new owner as manager', async () => { - await nftDatatoken.addManager(nftAddress, nftOwner, user2) - await nftDatatoken.addErc20Deployer(nftAddress, user2, user1) - assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === true) - - assert((await nftDatatoken.getNftOwner(nftAddress)) === nftOwner) - await nftDatatoken.transferNft(nftAddress, nftOwner, user1, 1) - assert((await nftDatatoken.getNftOwner(nftAddress)) === user1) - - // console.log(await nftDatatoken.isErc20Deployer(nftAddress, user1)) - // assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === false) - }) - - // Clear permisions - it('#cleanPermissions - should fail to cleanPermissions if NOT NFTOwner', async () => { - try { - await nftDatatoken.cleanPermissions(nftAddress, user1) - } catch (e) { - assert(e.message === 'Caller is not NFT Owner') - } - }) - - it('#cleanPermissions - should cleanPermissions if NFTOwner', async () => { - await nftDatatoken.addManager(nftAddress, user1, user1) - await nftDatatoken.addErc20Deployer(nftAddress, user1, user2) - assert((await nftDatatoken.isErc20Deployer(nftAddress, user2)) === true) - - await nftDatatoken.cleanPermissions(nftAddress, user1) - - assert((await nftDatatoken.isErc20Deployer(nftAddress, user2)) === false) - assert((await nftDatatoken.getNftPermissions(nftAddress, nftOwner)).manager === false) - }) -}) diff --git a/test/unit/tokens/Nft.test.ts b/test/unit/tokens/Nft.test.ts index 9a74b0c7..e8f9919a 100644 --- a/test/unit/tokens/Nft.test.ts +++ b/test/unit/tokens/Nft.test.ts @@ -297,4 +297,9 @@ describe('NFT', () => { assert((await nftDatatoken.isErc20Deployer(nftAddress, user2)) === false) assert((await nftDatatoken.getNftPermissions(nftAddress, nftOwner)).manager === false) }) + + it('#setTokenURI - should update TokenURI', async () => { + const tx = await nftDatatoken.setTokenURI(nftAddress, user1, 'test') + assert(tx.events.TokenURIUpdate) + }) })