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

fixed some tests

Browse Source
This commit is contained in:
Bogdan Fazakas 2021-11-08 21:29:27 +02:00
parent 193c3bedd1
commit 7e766a585f
4 changed files with 147 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
src/factories/NFTFactory.ts
View File

@ -660,9 +660,9 @@ export class NFTFactory {
/**
* Estimate gas cost for createNftErcWithPool method
* @param address Caller address
* @param _NftCreateData input data for NFT Creation
* @param nftCreateData input data for NFT Creation
* @param ercParams input data for ERC20 Creation
* @param _PoolData input data for Pool Creation
* @param poolParams input data for Pool Creation
* @return {Promise<TransactionReceipt>} transaction receipt
*/
public async estGasCreateNftErcWithPool(
@ -690,9 +690,9 @@ export class NFTFactory {
* Creates a new NFT, then a ERC20, then a Pool, all in one call
* Use this carefully, because if Pool creation fails, you are still going to pay a lot of gas
* @param address Caller address
* @param _NftCreateData input data for NFT Creation
* @param _ErcCreateData input data for ERC20 Creation
* @param _PoolData input data for Pool Creation
* @param nftCreateData input data for NFT Creation
* @param ercParams input data for ERC20 Creation
* @param poolParams input data for Pool Creation
* @return {Promise<TransactionReceipt>} transaction receipt
*/
public async createNftErcWithPool(
@ -710,6 +710,10 @@ export class NFTFactory {
poolData
)
console.log('estGas', estGas)
console.log('ercCreateData', ercCreateData)
console.log('poolData', poolData)
// Invoke createToken function of the contract
const trxReceipt = await this.factory721.methods
.createNftErcWithPool(nftCreateData, ercCreateData, poolData)
@ -810,7 +814,7 @@ export class NFTFactory {
this.web3.utils.toWei(ercParams.cap),
this.web3.utils.toWei(ercParams.feeAmount)
],
bytes: []
bytess: []
}
}
@ -821,7 +825,7 @@ export class NFTFactory {
return {
fixedPriceAddress: freParams.fixedRateAddress,
address: [
addresses: [
freParams.baseTokenAddress,
freParams.owner,
freParams.marketFeeCollector,
@ -839,17 +843,6 @@ export class NFTFactory {
getPoolCreationParams(poolParams: PoolParams): any {
return {
ssParams: [
this.web3.utils.toWei(poolParams.rate),
poolParams.basetokenDecimals,
this.web3.utils.toWei(poolParams.vestingAmount),
poolParams.vestedBlocks,
this.web3.utils.toWei(poolParams.initialBasetokenLiquidity)
],
swapFees: [
poolParams.swapFeeLiquidityProvider,
poolParams.swapFeeMarketPlaceRunner
],
addresses: [
poolParams.ssContract,
poolParams.basetokenAddress,
@ -857,7 +850,15 @@ export class NFTFactory {
poolParams.publisherAddress,
poolParams.marketFeeCollector,
poolParams.poolTemplateAddress
]
],
ssParams: [
this.web3.utils.toWei(poolParams.rate),
poolParams.basetokenDecimals,
this.web3.utils.toWei(poolParams.vestingAmount),
poolParams.vestedBlocks,
this.web3.utils.toWei(poolParams.initialBasetokenLiquidity)
],
swapFees: [poolParams.swapFeeLiquidityProvider, poolParams.swapFeeMarketPlaceRunner]
}
}
}

8
test/unit/NFTFactory.test.ts
View File

@ -261,7 +261,7 @@ describe('NFT Factory test', () => {
it('#createNftErcWithFixedRate- should create an NFT, a datatoken and create a Fixed Rate Exchange', async () => {
// we prepare transaction parameters objects
const nftData:NFTCreateData = {
const nftData: NFTCreateData = {
name: '72120Bundle',
symbol: '72Bundle',
templateIndex: 1,
@ -270,7 +270,7 @@ describe('NFT Factory test', () => {
const ercParams: ErcCreateParams = {
templateIndex: 1,
minter: contracts.accounts[0],,
minter: contracts.accounts[0],
feeManager: user3,
mpFeeAddress: user2,
feeToken: '0x0000000000000000000000000000000000000000',
@ -280,9 +280,8 @@ describe('NFT Factory test', () => {
symbol: 'ERC20DT1Symbol'
}
const freParams: FixedRateParams = {
fixedRateAddress:contracts.fixedRateAddress,
fixedRateAddress: contracts.fixedRateAddress,
baseTokenAddress: contracts.daiAddress,
owner: contracts.accounts[0],
marketFeeCollector: contracts.accounts[0],
@ -372,6 +371,7 @@ describe('NFT Factory test', () => {
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)

128
test/unit/pools/Router.test.ts
View File

@ -13,8 +13,14 @@ import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/M
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 { LoggerInstance } from '../../../src/utils'
import { NFTFactory } from '../../../src/factories/NFTFactory'
import {
NFTFactory,
NFTCreateData,
ErcCreateParams,
PoolParams
} from '../../../src/factories/NFTFactory'
import { Router } from '../../../src/pools/Router'
import { BigNumber } from 'bignumber.js'
const { keccak256 } = require('@ethersproject/keccak256')
const web3 = new Web3('http://127.0.0.1:8545')
const communityCollector = '0xeE9300b7961e0a01d9f0adb863C7A227A07AaD75'
@ -172,45 +178,39 @@ describe('Router unit test', () => {
// CREATE A FIRST POOL
// we prepare transaction parameters objects
const nftData = {
const nftData: NFTCreateData = {
name: '72120Bundle',
symbol: '72Bundle',
templateIndex: 1,
baseURI: 'https://oceanprotocol.com/nft/'
}
const ercData = {
const ercParams: ErcCreateParams = {
templateIndex: 1,
strings: ['ERC20B1', 'ERC20DT1Symbol'],
addresses: [
contracts.accounts[0],
user3,
contracts.accounts[0],
'0x0000000000000000000000000000000000000000'
],
uints: [web3.utils.toWei('1000000'), 0],
bytess: []
minter: contracts.accounts[0],
feeManager: user3,
mpFeeAddress: contracts.accounts[0],
feeToken: '0x0000000000000000000000000000000000000000',
cap: '1000000',
feeAmount: '0',
name: 'ERC20B1',
symbol: 'ERC20DT1Symbol'
}
const poolData = {
addresses: [
contracts.sideStakingAddress,
contracts.daiAddress,
contracts.factory721Address,
contracts.accounts[0],
contracts.accounts[0],
contracts.poolTemplateAddress
],
ssParams: [
web3.utils.toWei('1'), // rate
18, // basetokenDecimals
web3.utils.toWei('10000'),
2500000, // vested blocks
web3.utils.toWei('2000') // baseToken initial pool liquidity
],
swapFees: [
1e15, //
1e15
]
const poolParams: PoolParams = {
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 nftFactory = new NFTFactory(
@ -222,8 +222,8 @@ describe('Router unit test', () => {
const txReceipt = await nftFactory.createNftErcWithPool(
contracts.accounts[0],
nftData,
ercData,
poolData
ercParams,
poolParams
)
const erc20Token = txReceipt.events.TokenCreated.returnValues.newTokenAddress
@ -231,52 +231,46 @@ describe('Router unit test', () => {
// CREATE A SECOND POOL
const nftData2 = {
const nftData2: NFTCreateData = {
name: '72120Bundle2',
symbol: '72Bundle2',
templateIndex: 1,
baseURI: 'https://oceanprotocol.com/nft2/'
}
const ercData2 = {
const ercParams2: ErcCreateParams = {
templateIndex: 1,
strings: ['ERC20B12', 'ERC20DT1Symbol2'],
addresses: [
contracts.accounts[0],
user3,
contracts.accounts[0],
'0x0000000000000000000000000000000000000000'
],
uints: [web3.utils.toWei('1000000'), 0],
bytess: []
minter: contracts.accounts[0],
feeManager: user3,
mpFeeAddress: contracts.accounts[0],
feeToken: '0x0000000000000000000000000000000000000000',
cap: '1000000',
feeAmount: '0',
name: 'ERC20B12',
symbol: 'ERC20DT1Symbol2'
}
const poolData2 = {
addresses: [
contracts.sideStakingAddress,
contracts.daiAddress,
contracts.factory721Address,
contracts.accounts[0],
contracts.accounts[0],
contracts.poolTemplateAddress
],
ssParams: [
web3.utils.toWei('1'), // rate
18, // basetokenDecimals
web3.utils.toWei('10000'),
2500000, // vested blocks
web3.utils.toWei('2000') // baseToken initial pool liquidity
],
swapFees: [
1e15, //
1e15
]
const poolParams2: PoolParams = {
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 txReceipt2 = await nftFactory.createNftErcWithPool(
contracts.accounts[0],
nftData2,
ercData2,
poolData2
ercParams2,
poolParams2
)
const erc20Token2 = txReceipt2.events.TokenCreated.returnValues.newTokenAddress

129
test/unit/pools/balancer/Pool.test.ts
View File

@ -15,7 +15,12 @@ import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/M
import PoolTemplate from '@oceanprotocol/contracts/artifacts/contracts/pools/balancer/BPool.sol/BPool.json'
import OPFCollector from '@oceanprotocol/contracts/artifacts/contracts/communityFee/OPFCommunityFeeCollector.sol/OPFCommunityFeeCollector.json'
import { LoggerInstance } from '../../../../src/utils'
import { NFTFactory } from '../../../../src/factories/NFTFactory'
import {
NFTFactory,
NFTCreateData,
ErcCreateParams,
PoolParams
} from '../../../../src/factories/NFTFactory'
import { Pool } from '../../../../src/pools/balancer/Pool'
const { keccak256 } = require('@ethersproject/keccak256')
const web3 = new Web3('http://127.0.0.1:8545')
@ -129,47 +134,41 @@ describe('Pool unit test', () => {
it('#create a pool', async () => {
// CREATE A POOL
// we prepare transaction parameters objects
const nftData = {
const nftData: NFTCreateData = {
name: '72120Bundle',
symbol: '72Bundle',
templateIndex: 1,
baseURI: 'https://oceanprotocol.com/nft/'
}
const ercData = {
const ercParams: ErcCreateParams = {
templateIndex: 1,
strings: ['ERC20B1', 'ERC20DT1Symbol'],
addresses: [
contracts.accounts[0],
user3,
contracts.accounts[0],
'0x0000000000000000000000000000000000000000'
],
uints: [web3.utils.toWei('1000000'), 0],
bytess: []
minter: contracts.accounts[0],
feeManager: user3,
mpFeeAddress: contracts.accounts[0],
feeToken: '0x0000000000000000000000000000000000000000',
cap: '1000000',
feeAmount: '0',
name: 'ERC20B1',
symbol: 'ERC20DT1Symbol'
}
const basetokenInitialLiq = await pool.amountToUnits(contracts.daiAddress, '2000')
const poolData = {
addresses: [
contracts.sideStakingAddress,
contracts.daiAddress,
contracts.factory721Address,
contracts.accounts[0],
contracts.accounts[0],
contracts.poolTemplateAddress
],
ssParams: [
web3.utils.toWei('1'), // rate
18, // basetokenDecimals
web3.utils.toWei('10000'),
2500000, // vested blocks
web3.utils.toWei('2000') // baseToken initial pool liquidity
],
swapFees: [
1e15, //
1e15
]
const poolParams: PoolParams = {
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 nftFactory = new NFTFactory(
@ -181,8 +180,8 @@ describe('Pool unit test', () => {
const txReceipt = await nftFactory.createNftErcWithPool(
contracts.accounts[0],
nftData,
ercData,
poolData
ercParams,
poolParams
)
erc20Token = txReceipt.events.TokenCreated.returnValues.newTokenAddress
@ -579,48 +578,44 @@ describe('Pool unit test', () => {
it('#create a pool', async () => {
// CREATE A POOL
// we prepare transaction parameters objects
const nftData = {
const nftData: NFTCreateData = {
name: '72120Bundle',
symbol: '72Bundle',
templateIndex: 1,
baseURI: 'https://oceanprotocol.com/nft/'
}
const ercData = {
const ercParams: ErcCreateParams = {
templateIndex: 1,
strings: ['ERC20B1', 'ERC20DT1Symbol'],
addresses: [
contracts.accounts[0],
user3,
contracts.accounts[0],
'0x0000000000000000000000000000000000000000'
],
uints: [web3.utils.toWei('1000000'), 0],
bytess: []
minter: contracts.accounts[0],
feeManager: user3,
mpFeeAddress: contracts.accounts[0],
feeToken: '0x0000000000000000000000000000000000000000',
cap: '1000000',
feeAmount: '0',
name: 'ERC20B1',
symbol: 'ERC20DT1Symbol'
}
const basetokenInitialLiq = Number(
await pool.amountToUnits(contracts.usdcAddress, '2000')
)
console.log(basetokenInitialLiq.toString())
const poolData = {
addresses: [
contracts.sideStakingAddress,
contracts.usdcAddress,
contracts.factory721Address,
contracts.accounts[0],
contracts.accounts[0],
contracts.poolTemplateAddress
],
ssParams: [
web3.utils.toWei('1'), // rate
await usdcContract.methods.decimals().call(), // basetokenDecimals
web3.utils.toWei('10000'),
2500000, // vested blocks
basetokenInitialLiq // baseToken initial pool liquidity
],
swapFees: [
1e15, //
1e15
]
const poolParams: PoolParams = {
ssContract: contracts.sideStakingAddress,
basetokenAddress: contracts.usdcAddress,
basetokenSender: contracts.factory721Address,
publisherAddress: contracts.accounts[0],
marketFeeCollector: contracts.accounts[0],
poolTemplateAddress: contracts.poolTemplateAddress,
rate: '1',
basetokenDecimals: await usdcContract.methods.decimals().call(),
vestingAmount: '10000',
vestedBlocks: 2500000,
initialBasetokenLiquidity: basetokenInitialLiq.toString(),
swapFeeLiquidityProvider: 1e15,
swapFeeMarketPlaceRunner: 1e15
}
const nftFactory = new NFTFactory(
@ -632,8 +627,8 @@ describe('Pool unit test', () => {
const txReceipt = await nftFactory.createNftErcWithPool(
contracts.accounts[0],
nftData,
ercData,
poolData
ercParams,
poolParams
)
erc20Token = txReceipt.events.TokenCreated.returnValues.newTokenAddress