From c32c4d753e1539fe60f30a5f482d76f58df5829a Mon Sep 17 00:00:00 2001 From: alexcos20 Date: Wed, 1 Mar 2023 11:12:29 +0200 Subject: [PATCH] add Router tests --- test/unit/Router.test.ts | 238 ++++++++++++++++++++------------------- 1 file changed, 124 insertions(+), 114 deletions(-) diff --git a/test/unit/Router.test.ts b/test/unit/Router.test.ts index d8ae88be..3b027dd3 100644 --- a/test/unit/Router.test.ts +++ b/test/unit/Router.test.ts @@ -1,8 +1,6 @@ -/* import { assert, expect } from 'chai' -import { deployContracts, Addresses } from '../TestContractHandler' +import { getTestConfig, provider, getAddresses } from '../config' import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/MockERC20Decimals.sol/MockERC20Decimals.json' -import { getTestConfig, provider } from '../config' import { ethers, Signer } from 'ethers' import { NftFactory, @@ -12,15 +10,17 @@ import { approve, ZERO_ADDRESS, Datatoken, - Config + Config, + amountToUnits, + getEventFromTx } from '../../src' import { DatatokenCreateParams, FreCreationParams, Operation } from '../../src/@types' describe('Router unit test', () => { - let factoryOwner: string - let user1: string - let user2: string - let contracts: Addresses + let factoryOwner: Signer + let user1: Signer + let user2: Signer + let addresses: any let router: Router let config: Config @@ -35,109 +35,97 @@ describe('Router unit test', () => { const FEE_ZERO = '0' const DAI_AMOUNT = '100' // 100 DAI const CAP_AMOUNT = '1000000' - const AMOUNTS_IN = web3.utils.toWei('1') - const AMOUNTS_OUT = web3.utils.toWei('0.1') - const MAX_PRICE = web3.utils.toWei('10') - const SWAP_MARKET_FEE = web3.utils.toWei('0.1') - - const NFT_DATA: NftCreateData = { - name: NFT_NAME, - symbol: NFT_SYMBOL, - templateIndex: 1, - tokenURI: NFT_TOKEN_URI, - transferable: true, - owner: factoryOwner - } - - const ERC_PARAMS: DatatokenCreateParams = { - templateIndex: 1, - minter: factoryOwner, - paymentCollector: user2, - mpFeeAddress: factoryOwner, - feeToken: ZERO_ADDRESS, - cap: CAP_AMOUNT, - feeAmount: FEE_ZERO, - name: DATATOKEN_NAME, - symbol: DATATOKEN_SYMBOL - } + const AMOUNTS_IN = ethers.utils.parseUnits('1') + const AMOUNTS_OUT = ethers.utils.parseUnits('0.1') + const MAX_PRICE = ethers.utils.parseUnits('10') + const SWAP_MARKET_FEE = ethers.utils.parseUnits('0.1') + let NFT_DATA: NftCreateData + let ERC_PARAMS: DatatokenCreateParams before(async () => { - const accounts = await web3.eth.getAccounts() - factoryOwner = accounts[0] - user1 = accounts[1] - user2 = accounts[2] + factoryOwner = (await provider.getSigner(0)) as Signer + user1 = (await provider.getSigner(1)) as Signer + user2 = (await provider.getSigner(2)) as Signer + config = await getTestConfig(factoryOwner as Signer) + addresses = await getAddresses() - NFT_DATA.owner = factoryOwner - ERC_PARAMS.minter = factoryOwner - ERC_PARAMS.paymentCollector = user2 - ERC_PARAMS.mpFeeAddress = factoryOwner + NFT_DATA = { + name: NFT_NAME, + symbol: NFT_SYMBOL, + templateIndex: 1, + tokenURI: NFT_TOKEN_URI, + transferable: true, + owner: await factoryOwner.getAddress() + } - config = await getTestConfig(web3) + ERC_PARAMS = { + templateIndex: 1, + minter: await factoryOwner.getAddress(), + paymentCollector: await user2.getAddress(), + mpFeeAddress: await factoryOwner.getAddress(), + feeToken: ZERO_ADDRESS, + cap: CAP_AMOUNT, + feeAmount: FEE_ZERO, + name: DATATOKEN_NAME, + symbol: DATATOKEN_SYMBOL + } }) it('should deploy contracts', async () => { - contracts = await deployContracts(web3, factoryOwner) - await approve( - web3, - config, factoryOwner, - contracts.daiAddress, - contracts.nftFactoryAddress, - web3.utils.toWei('100000') + config, + await factoryOwner.getAddress(), + addresses.MockDAI, + addresses.ERC721Factory, + await amountToUnits(factoryOwner, addresses.MockDAI, '100000', 18) ) }) it('should initiate Router instance', async () => { - router = new Router(contracts.routerAddress, web3) + router = new Router(addresses.Router, user1) }) it('#getOwner - should return actual owner', async () => { const owner = await router.getOwner() - assert(owner === factoryOwner) + assert(owner === (await factoryOwner.getAddress())) }) it('#getNFTFactory - should return NFT Factory address', async () => { const factory = await router.getNFTFactory() - assert(factory === contracts.nftFactoryAddress) + assert(factory === addresses.ERC721Factory) }) it('#isOceanTokens - should return true if in oceanTokens list', async () => { - expect(await router.isApprovedToken(contracts.oceanAddress)).to.equal(true) - expect(await router.isApprovedToken(contracts.daiAddress)).to.equal(false) + expect(await router.isApprovedToken(addresses.Ocean)).to.equal(true) + expect(await router.isApprovedToken(addresses.MockDAI)).to.equal(false) }) it('#isFixedPrice - should return true if in fixedPrice list', async () => { - expect(await router.isFixedPrice(contracts.fixedRateAddress)).to.equal(true) - expect(await router.isFixedPrice(contracts.daiAddress)).to.equal(false) + expect(await router.isFixedPrice(addresses.FixedPrice)).to.equal(true) + expect(await router.isFixedPrice(addresses.MockDAI)).to.equal(false) }) it('#buyDatatokenBatch - should buy multiple DT in one call', async () => { // APPROVE DAI - const daiContract = new web3.eth.Contract( - MockERC20.abi as AbiItem[], - contracts.daiAddress - ) - - await daiContract.methods - .transfer(user1, web3.utils.toWei(DAI_AMOUNT)) - .send({ from: factoryOwner }) + const daiContract = new Datatoken(factoryOwner) + await daiContract.transfer(addresses.MockDAI, await user1.getAddress(), DAI_AMOUNT) await approve( - web3, - config, user1, - contracts.daiAddress, - contracts.routerAddress, + config, + await user1.getAddress(), + addresses.MockDAI, + addresses.Router, DAI_AMOUNT ) // CREATE A FIRST FRE const freParams: FreCreationParams = { - fixedRateAddress: contracts.fixedRateAddress, - baseTokenAddress: contracts.daiAddress, - owner: factoryOwner, - marketFeeCollector: user2, + fixedRateAddress: addresses.FixedPrice, + baseTokenAddress: addresses.MockDAI, + owner: await factoryOwner.getAddress(), + marketFeeCollector: await user2.getAddress(), baseTokenDecimals: 18, datatokenDecimals: 18, fixedRate: RATE, @@ -146,60 +134,83 @@ describe('Router unit test', () => { withMint: false } - const nftFactory = new NftFactory(contracts.nftFactoryAddress, web3) - const txReceipt = await nftFactory.createNftWithDatatokenWithFixedRate( - factoryOwner, + const nftFactory = new NftFactory(addresses.ERC721Factory, factoryOwner) + const tx = await nftFactory.createNftWithDatatokenWithFixedRate( NFT_DATA, ERC_PARAMS, freParams ) + const trxReceipt = await tx.wait() + // events have been emitted + const nftCreatedEvent = getEventFromTx(trxReceipt, 'NFTCreated') + const TokenCreatedEvent = getEventFromTx(trxReceipt, 'TokenCreated') + const NewFixedRateEvent = getEventFromTx(trxReceipt, 'NewFixedRate') - const datatokenAddress = txReceipt.events.TokenCreated.returnValues.newTokenAddress + expect(nftCreatedEvent.event === 'NFTCreated') + const datatokenAddress = TokenCreatedEvent.args.newTokenAddress - const fre1 = txReceipt.events.NewFixedRate.returnValues.exchangeContract + const fre1 = NewFixedRateEvent.args.exchangeContract - const freId1 = txReceipt.events.NewFixedRate.returnValues.exchangeId + const freId1 = NewFixedRateEvent.args.exchangeId - const datatoken = new Datatoken(web3) - await datatoken.mint(datatokenAddress, factoryOwner, '1000', factoryOwner) - await approve( - web3, - config, - factoryOwner, + const datatoken = new Datatoken(factoryOwner) + await datatoken.mint( datatokenAddress, - contracts.fixedRateAddress, + await factoryOwner.getAddress(), + '1000', + await factoryOwner.getAddress() + ) + await approve( + factoryOwner, + config, + await factoryOwner.getAddress(), + datatokenAddress, + addresses.FixedPrice, DATATOKEN_AMMOUNT ) // CREATE A SECOND FRE - const txReceipt2 = await nftFactory.createNftWithDatatokenWithFixedRate( - factoryOwner, + const tx2 = await nftFactory.createNftWithDatatokenWithFixedRate( NFT_DATA, ERC_PARAMS, freParams ) + const trxReceipt2 = await tx.wait() + // events have been emitted + const nftCreatedEvent2 = getEventFromTx(trxReceipt2, 'NFTCreated') + const TokenCreatedEvent2 = getEventFromTx(trxReceipt2, 'TokenCreated') + const NewFixedRateEvent2 = getEventFromTx(trxReceipt2, 'NewFixedRate') - const datatoken2Address = txReceipt2.events.TokenCreated.returnValues.newTokenAddress + const datatoken2Address = TokenCreatedEvent2.args.newTokenAddress - const fre2 = txReceipt2.events.NewFixedRate.returnValues.exchangeContract + const fre2 = NewFixedRateEvent2.args.exchangeContract - const freId2 = txReceipt2.events.NewFixedRate.returnValues.exchangeId + const freId2 = NewFixedRateEvent2.args.exchangeId - await datatoken.mint(datatoken2Address, factoryOwner, '1000', factoryOwner) - await approve( - web3, - config, - factoryOwner, + await datatoken.mint( datatoken2Address, - contracts.fixedRateAddress, + await factoryOwner.getAddress(), + '1000', + await factoryOwner.getAddress() + ) + await approve( + factoryOwner, + config, + await factoryOwner.getAddress(), + datatoken2Address, + addresses.FixedPrice, DATATOKEN_AMMOUNT ) // user1 has no dt1 - expect(await balance(web3, datatokenAddress, user1)).to.equal('0') + expect(await balance(user1, datatokenAddress, await user1.getAddress())).to.equal( + '0.0' + ) // user1 has no dt2 - expect(await balance(web3, datatoken2Address, user1)).to.equal('0') + expect(await balance(user1, datatoken2Address, await user1.getAddress())).to.equal( + '0.0' + ) // we now can prepare the Operations objects // operation: 0 - swapExactAmountIn @@ -210,33 +221,32 @@ describe('Router unit test', () => { exchangeIds: freId1, // used only for FixedRate or Dispenser, but needs to be filled even for pool source: fre1, // pool Address operation: 2, // swapExactAmountIn - tokenIn: contracts.daiAddress, - amountsIn: AMOUNTS_IN, // when swapExactAmountIn is EXACT amount IN + tokenIn: addresses.MockDAI, + amountsIn: AMOUNTS_IN.toString(), // when swapExactAmountIn is EXACT amount IN tokenOut: datatokenAddress, - amountsOut: AMOUNTS_OUT, // when swapExactAmountIn is MIN amount OUT - maxPrice: MAX_PRICE, // max price (only for pools), - swapMarketFee: SWAP_MARKET_FEE, - marketFeeAddress: factoryOwner + amountsOut: AMOUNTS_OUT.toString(), // when swapExactAmountIn is MIN amount OUT + maxPrice: MAX_PRICE.toString(), // max price (only for pools), + swapMarketFee: SWAP_MARKET_FEE.toString(), + marketFeeAddress: await factoryOwner.getAddress() } const operations2: Operation = { exchangeIds: freId2, // used only for FixedRate or Dispenser, but needs to be filled even for pool source: fre2, // pool Address operation: 2, // swapExactAmountIn - tokenIn: contracts.daiAddress, - amountsIn: AMOUNTS_IN, // when swapExactAmountIn is EXACT amount IN + tokenIn: addresses.MockDAI, + amountsIn: AMOUNTS_IN.toString(), // when swapExactAmountIn is EXACT amount IN tokenOut: datatokenAddress, - amountsOut: AMOUNTS_OUT, // when swapExactAmountIn is MIN amount OUT - maxPrice: MAX_PRICE, // max price (only for pools), - swapMarketFee: SWAP_MARKET_FEE, - marketFeeAddress: factoryOwner + amountsOut: AMOUNTS_OUT.toString(), // when swapExactAmountIn is MIN amount OUT + maxPrice: MAX_PRICE.toString(), // max price (only for pools), + swapMarketFee: SWAP_MARKET_FEE.toString(), + marketFeeAddress: await factoryOwner.getAddress() } - await router.buyDatatokenBatch(user1, [operations1, operations2]) + await router.buyDatatokenBatch([operations1, operations2]) // user1 got his dts - expect(+(await balance(web3, datatokenAddress, user1))).gt(0) - expect(+(await balance(web3, datatoken2Address, user1))).gt(0) + expect(+(await balance(user1, datatokenAddress, await user1.getAddress()))).gt(0) + expect(+(await balance(user1, datatoken2Address, await user1.getAddress()))).gt(0) }) }) -*/ \ No newline at end of file