oceanprotocol/ocean.js
1
0
Fork 0
mirror of https://github.com/oceanprotocol/ocean.js.git synced 2024-11-26 20:39:05 +01:00
Code Releases Activity

add Router tests

Browse Source
This commit is contained in:
alexcos20 2023-03-01 11:12:29 +02:00
parent a149748ef7
commit c32c4d753e
1 changed files with 124 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

238
test/unit/Router.test.ts
View File

@ -1,8 +1,6 @@
/*
import { assert, expect } from 'chai' 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 MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/MockERC20Decimals.sol/MockERC20Decimals.json'
import { getTestConfig, provider } from '../config'
import { ethers, Signer } from 'ethers' import { ethers, Signer } from 'ethers'
import { import {
NftFactory, NftFactory,
@ -12,15 +10,17 @@ import {
approve, approve,
ZERO_ADDRESS, ZERO_ADDRESS,
Datatoken, Datatoken,
Config Config,
amountToUnits,
getEventFromTx
} from '../../src' } from '../../src'
import { DatatokenCreateParams, FreCreationParams, Operation } from '../../src/@types' import { DatatokenCreateParams, FreCreationParams, Operation } from '../../src/@types'
describe('Router unit test', () => { describe('Router unit test', () => {
let factoryOwner: string let factoryOwner: Signer
let user1: string let user1: Signer
let user2: string let user2: Signer
let contracts: Addresses let addresses: any
let router: Router let router: Router
let config: Config let config: Config
@ -35,109 +35,97 @@ describe('Router unit test', () => {
const FEE_ZERO = '0' const FEE_ZERO = '0'
const DAI_AMOUNT = '100' // 100 DAI const DAI_AMOUNT = '100' // 100 DAI
const CAP_AMOUNT = '1000000' const CAP_AMOUNT = '1000000'
const AMOUNTS_IN = web3.utils.toWei('1') const AMOUNTS_IN = ethers.utils.parseUnits('1')
const AMOUNTS_OUT = web3.utils.toWei('0.1') const AMOUNTS_OUT = ethers.utils.parseUnits('0.1')
const MAX_PRICE = web3.utils.toWei('10') const MAX_PRICE = ethers.utils.parseUnits('10')
const SWAP_MARKET_FEE = web3.utils.toWei('0.1') const SWAP_MARKET_FEE = ethers.utils.parseUnits('0.1')
let NFT_DATA: NftCreateData
const NFT_DATA: NftCreateData = { let ERC_PARAMS: DatatokenCreateParams
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
}
before(async () => { before(async () => {
const accounts = await web3.eth.getAccounts() factoryOwner = (await provider.getSigner(0)) as Signer
factoryOwner = accounts[0] user1 = (await provider.getSigner(1)) as Signer
user1 = accounts[1] user2 = (await provider.getSigner(2)) as Signer
user2 = accounts[2] config = await getTestConfig(factoryOwner as Signer)
addresses = await getAddresses()
NFT_DATA.owner = factoryOwner NFT_DATA = {
ERC_PARAMS.minter = factoryOwner name: NFT_NAME,
ERC_PARAMS.paymentCollector = user2 symbol: NFT_SYMBOL,
ERC_PARAMS.mpFeeAddress = factoryOwner 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 () => { it('should deploy contracts', async () => {
contracts = await deployContracts(web3, factoryOwner)
await approve( await approve(
web3,
config,
factoryOwner, factoryOwner,
contracts.daiAddress, config,
contracts.nftFactoryAddress, await factoryOwner.getAddress(),
web3.utils.toWei('100000') addresses.MockDAI,
addresses.ERC721Factory,
await amountToUnits(factoryOwner, addresses.MockDAI, '100000', 18)
) )
}) })
it('should initiate Router instance', async () => { 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 () => { it('#getOwner - should return actual owner', async () => {
const owner = await router.getOwner() const owner = await router.getOwner()
assert(owner === factoryOwner) assert(owner === (await factoryOwner.getAddress()))
}) })
it('#getNFTFactory - should return NFT Factory address', async () => { it('#getNFTFactory - should return NFT Factory address', async () => {
const factory = await router.getNFTFactory() const factory = await router.getNFTFactory()
assert(factory === contracts.nftFactoryAddress) assert(factory === addresses.ERC721Factory)
}) })
it('#isOceanTokens - should return true if in oceanTokens list', async () => { it('#isOceanTokens - should return true if in oceanTokens list', async () => {
expect(await router.isApprovedToken(contracts.oceanAddress)).to.equal(true) expect(await router.isApprovedToken(addresses.Ocean)).to.equal(true)
expect(await router.isApprovedToken(contracts.daiAddress)).to.equal(false) expect(await router.isApprovedToken(addresses.MockDAI)).to.equal(false)
}) })
it('#isFixedPrice - should return true if in fixedPrice list', async () => { it('#isFixedPrice - should return true if in fixedPrice list', async () => {
expect(await router.isFixedPrice(contracts.fixedRateAddress)).to.equal(true) expect(await router.isFixedPrice(addresses.FixedPrice)).to.equal(true)
expect(await router.isFixedPrice(contracts.daiAddress)).to.equal(false) expect(await router.isFixedPrice(addresses.MockDAI)).to.equal(false)
}) })
it('#buyDatatokenBatch - should buy multiple DT in one call', async () => { it('#buyDatatokenBatch - should buy multiple DT in one call', async () => {
// APPROVE DAI // APPROVE DAI
const daiContract = new web3.eth.Contract( const daiContract = new Datatoken(factoryOwner)
MockERC20.abi as AbiItem[], await daiContract.transfer(addresses.MockDAI, await user1.getAddress(), DAI_AMOUNT)
contracts.daiAddress
)
await daiContract.methods
.transfer(user1, web3.utils.toWei(DAI_AMOUNT))
.send({ from: factoryOwner })
await approve( await approve(
web3,
config,
user1, user1,
contracts.daiAddress, config,
contracts.routerAddress, await user1.getAddress(),
addresses.MockDAI,
addresses.Router,
DAI_AMOUNT DAI_AMOUNT
) )
// CREATE A FIRST FRE // CREATE A FIRST FRE
const freParams: FreCreationParams = { const freParams: FreCreationParams = {
fixedRateAddress: contracts.fixedRateAddress, fixedRateAddress: addresses.FixedPrice,
baseTokenAddress: contracts.daiAddress, baseTokenAddress: addresses.MockDAI,
owner: factoryOwner, owner: await factoryOwner.getAddress(),
marketFeeCollector: user2, marketFeeCollector: await user2.getAddress(),
baseTokenDecimals: 18, baseTokenDecimals: 18,
datatokenDecimals: 18, datatokenDecimals: 18,
fixedRate: RATE, fixedRate: RATE,
@ -146,60 +134,83 @@ describe('Router unit test', () => {
withMint: false withMint: false
} }
const nftFactory = new NftFactory(contracts.nftFactoryAddress, web3) const nftFactory = new NftFactory(addresses.ERC721Factory, factoryOwner)
const txReceipt = await nftFactory.createNftWithDatatokenWithFixedRate( const tx = await nftFactory.createNftWithDatatokenWithFixedRate(
factoryOwner,
NFT_DATA, NFT_DATA,
ERC_PARAMS, ERC_PARAMS,
freParams 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) const datatoken = new Datatoken(factoryOwner)
await datatoken.mint(datatokenAddress, factoryOwner, '1000', factoryOwner) await datatoken.mint(
await approve(
web3,
config,
factoryOwner,
datatokenAddress, datatokenAddress,
contracts.fixedRateAddress, await factoryOwner.getAddress(),
'1000',
await factoryOwner.getAddress()
)
await approve(
factoryOwner,
config,
await factoryOwner.getAddress(),
datatokenAddress,
addresses.FixedPrice,
DATATOKEN_AMMOUNT DATATOKEN_AMMOUNT
) )
// CREATE A SECOND FRE // CREATE A SECOND FRE
const txReceipt2 = await nftFactory.createNftWithDatatokenWithFixedRate( const tx2 = await nftFactory.createNftWithDatatokenWithFixedRate(
factoryOwner,
NFT_DATA, NFT_DATA,
ERC_PARAMS, ERC_PARAMS,
freParams 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 datatoken.mint(
await approve(
web3,
config,
factoryOwner,
datatoken2Address, datatoken2Address,
contracts.fixedRateAddress, await factoryOwner.getAddress(),
'1000',
await factoryOwner.getAddress()
)
await approve(
factoryOwner,
config,
await factoryOwner.getAddress(),
datatoken2Address,
addresses.FixedPrice,
DATATOKEN_AMMOUNT DATATOKEN_AMMOUNT
) )
// user1 has no dt1 // 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 // 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 // we now can prepare the Operations objects
// operation: 0 - swapExactAmountIn // 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 exchangeIds: freId1, // used only for FixedRate or Dispenser, but needs to be filled even for pool
source: fre1, // pool Address source: fre1, // pool Address
operation: 2, // swapExactAmountIn operation: 2, // swapExactAmountIn
tokenIn: contracts.daiAddress, tokenIn: addresses.MockDAI,
amountsIn: AMOUNTS_IN, // when swapExactAmountIn is EXACT amount IN amountsIn: AMOUNTS_IN.toString(), // when swapExactAmountIn is EXACT amount IN
tokenOut: datatokenAddress, tokenOut: datatokenAddress,
amountsOut: AMOUNTS_OUT, // when swapExactAmountIn is MIN amount OUT amountsOut: AMOUNTS_OUT.toString(), // when swapExactAmountIn is MIN amount OUT
maxPrice: MAX_PRICE, // max price (only for pools), maxPrice: MAX_PRICE.toString(), // max price (only for pools),
swapMarketFee: SWAP_MARKET_FEE, swapMarketFee: SWAP_MARKET_FEE.toString(),
marketFeeAddress: factoryOwner marketFeeAddress: await factoryOwner.getAddress()
} }
const operations2: Operation = { const operations2: Operation = {
exchangeIds: freId2, // used only for FixedRate or Dispenser, but needs to be filled even for pool exchangeIds: freId2, // used only for FixedRate or Dispenser, but needs to be filled even for pool
source: fre2, // pool Address source: fre2, // pool Address
operation: 2, // swapExactAmountIn operation: 2, // swapExactAmountIn
tokenIn: contracts.daiAddress, tokenIn: addresses.MockDAI,
amountsIn: AMOUNTS_IN, // when swapExactAmountIn is EXACT amount IN amountsIn: AMOUNTS_IN.toString(), // when swapExactAmountIn is EXACT amount IN
tokenOut: datatokenAddress, tokenOut: datatokenAddress,
amountsOut: AMOUNTS_OUT, // when swapExactAmountIn is MIN amount OUT amountsOut: AMOUNTS_OUT.toString(), // when swapExactAmountIn is MIN amount OUT
maxPrice: MAX_PRICE, // max price (only for pools), maxPrice: MAX_PRICE.toString(), // max price (only for pools),
swapMarketFee: SWAP_MARKET_FEE, swapMarketFee: SWAP_MARKET_FEE.toString(),
marketFeeAddress: factoryOwner marketFeeAddress: await factoryOwner.getAddress()
} }
await router.buyDatatokenBatch(user1, [operations1, operations2]) await router.buyDatatokenBatch([operations1, operations2])
// user1 got his dts // user1 got his dts
expect(+(await balance(web3, datatokenAddress, user1))).gt(0) expect(+(await balance(user1, datatokenAddress, await user1.getAddress()))).gt(0)
expect(+(await balance(web3, datatoken2Address, user1))).gt(0) expect(+(await balance(user1, datatoken2Address, await user1.getAddress()))).gt(0)
}) })
}) })
*/