mirror of
https://github.com/oceanprotocol/ocean.js.git
synced 2024-11-26 20:39:05 +01:00
faa7de3601
* added order helper method using contracts calls * fixes consume fees & lint * cleanup * update order helper method to be more generic * fix all warnings
926 lines
26 KiB
TypeScript
926 lines
26 KiB
TypeScript
import { assert, expect } from 'chai'
|
|
import { provider, getAddresses } from '../config'
|
|
import { ethers, Signer } from 'ethers'
|
|
import {
|
|
NftFactory,
|
|
NftCreateData,
|
|
Datatoken,
|
|
Nft,
|
|
OrderParams,
|
|
DispenserParams,
|
|
ZERO_ADDRESS,
|
|
signHash,
|
|
getEventFromTx,
|
|
amountToUnits
|
|
} from '../../src'
|
|
import { ProviderFees, FreCreationParams, FreOrderParams } from '../../src/@types'
|
|
|
|
describe('Datatoken', () => {
|
|
let nftOwner: Signer
|
|
let user1: Signer
|
|
let user2: Signer
|
|
let user3: Signer
|
|
let datatokenDeployer: Signer
|
|
let nftDatatoken: Nft
|
|
let datatoken: Datatoken
|
|
let nftFactory: NftFactory
|
|
let nftAddress: string
|
|
let datatokenAddress: string
|
|
let exchangeId: string
|
|
let freParams: FreCreationParams
|
|
let addresses: any
|
|
|
|
const nftData: NftCreateData = {
|
|
name: 'NFTName',
|
|
symbol: 'NFTSymbol',
|
|
templateIndex: 1,
|
|
tokenURI: 'https://oceanprotocol.com/nft/',
|
|
transferable: true,
|
|
owner: null
|
|
}
|
|
|
|
before(async () => {
|
|
nftOwner = (await provider.getSigner(0)) as Signer
|
|
user1 = (await provider.getSigner(1)) as Signer
|
|
user2 = (await provider.getSigner(2)) as Signer
|
|
user3 = (await provider.getSigner(3)) as Signer
|
|
datatokenDeployer = (await provider.getSigner(4)) as Signer
|
|
|
|
addresses = await getAddresses()
|
|
|
|
freParams = {
|
|
fixedRateAddress: addresses.FixedPrice,
|
|
baseTokenAddress: addresses.MockDAI,
|
|
owner: await nftOwner.getAddress(),
|
|
marketFeeCollector: await nftOwner.getAddress(),
|
|
baseTokenDecimals: 18,
|
|
datatokenDecimals: 18,
|
|
fixedRate: await amountToUnits(nftOwner, null, '1', 18),
|
|
marketFee: await amountToUnits(nftOwner, null, '0.01', 18)
|
|
}
|
|
})
|
|
|
|
it('should initialize NFTFactory instance and create a new NFT', async () => {
|
|
nftFactory = new NftFactory(addresses.ERC721Factory, nftOwner, 8996)
|
|
|
|
nftData.owner = await nftOwner.getAddress()
|
|
nftAddress = await nftFactory.createNFT(nftData)
|
|
nftDatatoken = new Nft(nftOwner, 8996)
|
|
})
|
|
|
|
it('#createDatatoken - should create a new ERC20 Datatoken from NFT contract', async () => {
|
|
await nftDatatoken.addDatatokenDeployer(
|
|
nftAddress,
|
|
await nftOwner.getAddress(),
|
|
await datatokenDeployer.getAddress()
|
|
)
|
|
datatokenAddress = await nftDatatoken.createDatatoken(
|
|
nftAddress,
|
|
await nftOwner.getAddress(),
|
|
await nftOwner.getAddress(),
|
|
await user1.getAddress(),
|
|
await user2.getAddress(),
|
|
ZERO_ADDRESS,
|
|
'0',
|
|
'10000',
|
|
'ERC20B1',
|
|
'ERC20DT1Symbol'
|
|
)
|
|
assert(datatokenAddress)
|
|
})
|
|
|
|
it('should initialize DT20 Instance', async () => {
|
|
datatoken = new Datatoken(user1, 8996)
|
|
assert(datatoken)
|
|
})
|
|
|
|
it('#mint - should fail to mint DT20, if NOT Minter', async () => {
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user1.getAddress()))
|
|
.minter === false
|
|
)
|
|
try {
|
|
await datatoken.mint(
|
|
datatokenAddress,
|
|
await user1.getAddress(),
|
|
'10',
|
|
await user1.getAddress()
|
|
)
|
|
assert(false)
|
|
} catch (e) {
|
|
assert(e.message === 'Caller is not Minter')
|
|
}
|
|
})
|
|
|
|
it('#addMinter - should add user1 as minter, if user has DatatokenDeployer permission', async () => {
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(
|
|
nftAddress,
|
|
await nftOwner.getAddress()
|
|
)) === true
|
|
)
|
|
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(nftAddress, await user1.getAddress())) ===
|
|
false
|
|
)
|
|
|
|
await nftDatatoken.addDatatokenDeployer(
|
|
nftAddress,
|
|
await nftOwner.getAddress(),
|
|
await user1.getAddress()
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user1.getAddress()))
|
|
.minter === false
|
|
)
|
|
|
|
await datatoken.addMinter(
|
|
datatokenAddress,
|
|
await nftOwner.getAddress(),
|
|
await user1.getAddress()
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user1.getAddress()))
|
|
.minter === true
|
|
)
|
|
})
|
|
|
|
it('#addMinter - should FAIL TO add user1 as minter, if user has DatatokenDeployer permission', async () => {
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(nftAddress, await user3.getAddress())) ===
|
|
false
|
|
)
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user2.getAddress()))
|
|
.minter === false
|
|
)
|
|
|
|
try {
|
|
await datatoken.addMinter(
|
|
datatokenAddress,
|
|
await user3.getAddress(),
|
|
await user2.getAddress()
|
|
)
|
|
assert(false)
|
|
} catch (e) {
|
|
assert(e.message === 'Caller is not DatatokenDeployer')
|
|
}
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user2.getAddress()))
|
|
.minter === false
|
|
)
|
|
})
|
|
|
|
it('#mint - should mint ERC20 Datatoken to user1, if Minter', async () => {
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await nftOwner.getAddress()))
|
|
.minter === true
|
|
)
|
|
await datatoken.mint(
|
|
datatokenAddress,
|
|
await nftOwner.getAddress(),
|
|
'10',
|
|
await user1.getAddress()
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.balance(datatokenAddress, await user1.getAddress())) === '10.0'
|
|
)
|
|
})
|
|
|
|
it('#createFixedRate - should create FRE for the ERC20 Datatoken', async () => {
|
|
const freTx = await datatoken.createFixedRate(
|
|
datatokenAddress,
|
|
await nftOwner.getAddress(),
|
|
freParams
|
|
)
|
|
const trxReceipt = await freTx.wait()
|
|
const freCreatedEvent = getEventFromTx(trxReceipt, 'NewFixedRate')
|
|
|
|
assert(freCreatedEvent !== null)
|
|
|
|
// fixedRateAddress = freCreatedEvent.args.ad
|
|
exchangeId = freCreatedEvent?.args?.exchangeId
|
|
})
|
|
|
|
it('#createFixedRate - should FAIL create FRE if NOT DatatokenDeployer', async () => {
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(nftAddress, await user3.getAddress())) ===
|
|
false
|
|
)
|
|
try {
|
|
await datatoken.createFixedRate(
|
|
datatokenAddress,
|
|
await user3.getAddress(),
|
|
freParams
|
|
)
|
|
assert(false)
|
|
} catch (e) {
|
|
assert(e.message === 'User is not Datatoken Deployer')
|
|
}
|
|
})
|
|
|
|
it('#createDispenser - method creates a dispenser for the ERC20 Datatoken', async () => {
|
|
const dispenserParams: DispenserParams = {
|
|
maxTokens: await amountToUnits(nftOwner, null, '10', 18),
|
|
maxBalance: await amountToUnits(nftOwner, null, '100', 18)
|
|
}
|
|
|
|
const dispenser = await datatoken.createDispenser(
|
|
datatokenAddress,
|
|
await nftOwner.getAddress(),
|
|
addresses.Dispenser,
|
|
dispenserParams
|
|
)
|
|
assert(dispenser)
|
|
})
|
|
|
|
it('#createDispenser - should FAIL to create a Dispenser if not Datatoken Deployer', async () => {
|
|
const dispenserParams: DispenserParams = {
|
|
maxTokens: await amountToUnits(nftOwner, null, '10', 18),
|
|
maxBalance: await amountToUnits(nftOwner, null, '100', 18)
|
|
}
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(nftAddress, await user3.getAddress())) ===
|
|
false
|
|
)
|
|
try {
|
|
await datatoken.createDispenser(
|
|
datatokenAddress,
|
|
await user2.getAddress(),
|
|
addresses.Dispenser,
|
|
dispenserParams
|
|
)
|
|
assert(false)
|
|
} catch (e) {
|
|
assert(e.message === 'User is not Datatoken Deployer')
|
|
}
|
|
})
|
|
|
|
it('#removeMinter - should FAIL to remove user1 as minter, if caller is NOT DatatokenDeployer', async () => {
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(nftAddress, await user2.getAddress())) ===
|
|
false
|
|
)
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user1.getAddress()))
|
|
.minter === true
|
|
)
|
|
|
|
try {
|
|
await datatoken.removeMinter(
|
|
datatokenAddress,
|
|
await user2.getAddress(),
|
|
await user1.getAddress()
|
|
)
|
|
assert(false)
|
|
} catch (e) {
|
|
assert(e.message === 'Caller is not DatatokenDeployer')
|
|
}
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user1.getAddress()))
|
|
.minter === true
|
|
)
|
|
})
|
|
|
|
it('#removeMinter - should remove user1 as minter, if nftDatatoken has DatatokenDeployer permission', async () => {
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(
|
|
nftAddress,
|
|
await nftOwner.getAddress()
|
|
)) === true
|
|
)
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user1.getAddress()))
|
|
.minter === true
|
|
)
|
|
|
|
await datatoken.removeMinter(
|
|
datatokenAddress,
|
|
await nftOwner.getAddress(),
|
|
await user1.getAddress()
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user1.getAddress()))
|
|
.minter === false
|
|
)
|
|
})
|
|
|
|
it('#addPaymentManager - should FAIL TO add user2 as paymentManager, if caller is NOT DatatokenDeployer', async () => {
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(nftAddress, await user2.getAddress())) ===
|
|
false
|
|
)
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user3.getAddress()))
|
|
.paymentManager === false
|
|
)
|
|
|
|
try {
|
|
await datatoken.addPaymentManager(
|
|
datatokenAddress,
|
|
await user2.getAddress(),
|
|
await user3.getAddress()
|
|
)
|
|
assert(false)
|
|
} catch (e) {
|
|
assert(e.message === 'Caller is not DatatokenDeployer')
|
|
}
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user3.getAddress()))
|
|
.paymentManager === false
|
|
)
|
|
})
|
|
|
|
it('#addPaymentManager - should add user2 as paymentManager, if caller has DatatokenDeployer permission', async () => {
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(
|
|
nftAddress,
|
|
await nftOwner.getAddress()
|
|
)) === true
|
|
)
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user2.getAddress()))
|
|
.paymentManager === false
|
|
)
|
|
|
|
await datatoken.addPaymentManager(
|
|
datatokenAddress,
|
|
await nftOwner.getAddress(),
|
|
await user2.getAddress()
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user2.getAddress()))
|
|
.paymentManager === true
|
|
)
|
|
})
|
|
|
|
it('#removePaymentManager - should FAIL TO remove user2 as paymentManager, if nftDatatoken has DatatokenDeployer permission', async () => {
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(nftAddress, await user3.getAddress())) ===
|
|
false
|
|
)
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user2.getAddress()))
|
|
.paymentManager === true
|
|
)
|
|
try {
|
|
await datatoken.removePaymentManager(
|
|
datatokenAddress,
|
|
await user3.getAddress(),
|
|
await user2.getAddress()
|
|
)
|
|
assert(false)
|
|
} catch (e) {
|
|
assert(e.message === 'Caller is not DatatokenDeployer')
|
|
}
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user2.getAddress()))
|
|
.paymentManager === true
|
|
)
|
|
})
|
|
|
|
it('#removePaymentManager - should remove user2 as paymentManager, if Caller has DatatokenDeployer permission', async () => {
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(
|
|
nftAddress,
|
|
await nftOwner.getAddress()
|
|
)) === true
|
|
)
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user2.getAddress()))
|
|
.paymentManager === true
|
|
)
|
|
|
|
await datatoken.removePaymentManager(
|
|
datatokenAddress,
|
|
await nftOwner.getAddress(),
|
|
await user2.getAddress()
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user2.getAddress()))
|
|
.paymentManager === false
|
|
)
|
|
})
|
|
|
|
it('#setPaymentCollector - should fail to set a new paymentCollector, if NOT PAYMENT Manager, NFT OWNER OR ERC 20 DEPLOYER', async () => {
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user2.getAddress()))
|
|
.paymentManager === false
|
|
)
|
|
|
|
try {
|
|
await datatoken.setPaymentCollector(
|
|
datatokenAddress,
|
|
await user3.getAddress(),
|
|
await user2.getAddress()
|
|
)
|
|
assert(false)
|
|
} catch (e) {
|
|
assert(e.message === 'Caller is not Fee Manager, owner or Datatoken Deployer')
|
|
}
|
|
})
|
|
|
|
it('#setPaymentCollector - should set a new paymentCollector, if PAYMENT MANAGER', async () => {
|
|
assert(
|
|
(await datatoken.getPaymentCollector(datatokenAddress)) ===
|
|
(await user1.getAddress())
|
|
)
|
|
|
|
await datatoken.addPaymentManager(
|
|
datatokenAddress,
|
|
await nftOwner.getAddress(),
|
|
await user1.getAddress()
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user1.getAddress()))
|
|
.paymentManager === true
|
|
)
|
|
|
|
await datatoken.setPaymentCollector(
|
|
datatokenAddress,
|
|
await user1.getAddress(),
|
|
await user3.getAddress()
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPaymentCollector(datatokenAddress)) ===
|
|
(await user3.getAddress())
|
|
)
|
|
})
|
|
|
|
it('#setPaymentCollector - should set a new paymentCollector, if NFT OWNER', async () => {
|
|
assert((await nftDatatoken.getNftOwner(nftAddress)) === (await nftOwner.getAddress()))
|
|
|
|
await datatoken.setPaymentCollector(
|
|
datatokenAddress,
|
|
await nftOwner.getAddress(),
|
|
await user2.getAddress()
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPaymentCollector(datatokenAddress)) ===
|
|
(await user2.getAddress())
|
|
)
|
|
})
|
|
|
|
it('#setPaymentCollector - should set a new paymentCollector, if ERC 20 DEPLOYER', async () => {
|
|
assert(
|
|
(
|
|
await nftDatatoken.getNftPermissions(
|
|
nftAddress,
|
|
await datatokenDeployer.getAddress()
|
|
)
|
|
).deployERC20 === true
|
|
)
|
|
|
|
await datatoken.setPaymentCollector(
|
|
datatokenAddress,
|
|
await datatokenDeployer.getAddress(),
|
|
await user3.getAddress()
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPaymentCollector(datatokenAddress)) ===
|
|
(await user3.getAddress())
|
|
)
|
|
})
|
|
|
|
it('#startOrder- user2 should create an order for DT ', async () => {
|
|
assert(
|
|
(await datatoken.balance(datatokenAddress, await user1.getAddress())) === '10.0',
|
|
'User1 does not hold 10 datatokens'
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.balance(datatokenAddress, await user2.getAddress())) === '0.0',
|
|
'User2 does not hold 0 datatokens'
|
|
)
|
|
|
|
const providerData = JSON.stringify({ timeout: 0 })
|
|
const providerFeeToken = ZERO_ADDRESS
|
|
const providerFeeAmount = '0'
|
|
const providerValidUntil = '0'
|
|
|
|
const message = ethers.utils.solidityKeccak256(
|
|
['bytes', 'address', 'address', 'uint256', 'uint256'],
|
|
[
|
|
ethers.utils.hexlify(ethers.utils.toUtf8Bytes(providerData)),
|
|
await user3.getAddress(),
|
|
providerFeeToken,
|
|
providerFeeAmount,
|
|
providerValidUntil
|
|
]
|
|
)
|
|
|
|
const { v, r, s } = await signHash(user3, message)
|
|
|
|
const providerFees: ProviderFees = {
|
|
providerFeeAddress: await user3.getAddress(),
|
|
providerFeeToken,
|
|
providerFeeAmount,
|
|
v,
|
|
r,
|
|
s,
|
|
providerData: ethers.utils.hexlify(ethers.utils.toUtf8Bytes(providerData)),
|
|
validUntil: providerValidUntil
|
|
}
|
|
const order = await datatoken.startOrder(
|
|
datatokenAddress,
|
|
await user2.getAddress(),
|
|
1,
|
|
providerFees
|
|
)
|
|
assert(order !== null)
|
|
|
|
assert(
|
|
(await datatoken.balance(datatokenAddress, await user1.getAddress())) === '9.0',
|
|
'Invalid user balance, DT was not substracted'
|
|
)
|
|
assert(
|
|
(await datatoken.balance(
|
|
datatokenAddress,
|
|
await datatoken.getPaymentCollector(datatokenAddress)
|
|
)) === '0.97',
|
|
'Invalid publisher reward, we should have 1 DT'
|
|
)
|
|
})
|
|
|
|
it('#reuseOrder- user2 should user should succeed to call reuseOrder on a using a previous txId ', async () => {
|
|
const providerData = JSON.stringify({ timeout: 0 })
|
|
const providerFeeToken = ZERO_ADDRESS
|
|
const providerFeeAmount = '0'
|
|
const providerValidUntil = '0'
|
|
|
|
const message = ethers.utils.solidityKeccak256(
|
|
['bytes', 'address', 'address', 'uint256', 'uint256'],
|
|
[
|
|
ethers.utils.hexlify(ethers.utils.toUtf8Bytes(providerData)),
|
|
await user3.getAddress(),
|
|
providerFeeToken,
|
|
providerFeeAmount,
|
|
providerValidUntil
|
|
]
|
|
)
|
|
|
|
const { v, r, s } = await signHash(user3, message)
|
|
|
|
const providerFees: ProviderFees = {
|
|
providerFeeAddress: await user3.getAddress(),
|
|
providerFeeToken,
|
|
providerFeeAmount,
|
|
v,
|
|
r,
|
|
s,
|
|
providerData: ethers.utils.hexlify(ethers.utils.toUtf8Bytes(providerData)),
|
|
validUntil: providerValidUntil
|
|
}
|
|
|
|
const order = await datatoken.startOrder(
|
|
datatokenAddress,
|
|
await user2.getAddress(),
|
|
1,
|
|
providerFees
|
|
)
|
|
|
|
assert(order.blockHash, ' Failed to start order')
|
|
const tx = await datatoken.reuseOrder(datatokenAddress, order.blockHash, providerFees)
|
|
const reusedTx = await tx.wait()
|
|
|
|
const orderReusedTx = getEventFromTx(reusedTx, 'OrderReused')
|
|
const providerFeeTx = getEventFromTx(reusedTx, 'ProviderFee')
|
|
|
|
expect(orderReusedTx.event === 'OrderReused')
|
|
expect(providerFeeTx.event === 'ProviderFee')
|
|
})
|
|
|
|
it('#buyFromDispenserAndOrder- Enterprise method', async () => {
|
|
const providerData = JSON.stringify({ timeout: 0 })
|
|
const providerFeeToken = ZERO_ADDRESS
|
|
const providerFeeAmount = '0'
|
|
const providerValidUntil = '0'
|
|
const message = ethers.utils.solidityKeccak256(
|
|
['bytes', 'address', 'address', 'uint256', 'uint256'],
|
|
[
|
|
ethers.utils.hexlify(ethers.utils.toUtf8Bytes(providerData)),
|
|
await user3.getAddress(),
|
|
providerFeeToken,
|
|
providerFeeAmount,
|
|
providerValidUntil
|
|
]
|
|
)
|
|
|
|
const { v, r, s } = await signHash(user3, message)
|
|
|
|
const providerFees: ProviderFees = {
|
|
providerFeeAddress: await user3.getAddress(),
|
|
providerFeeToken,
|
|
providerFeeAmount,
|
|
v,
|
|
r,
|
|
s,
|
|
providerData: ethers.utils.hexlify(ethers.utils.toUtf8Bytes(providerData)),
|
|
validUntil: providerValidUntil
|
|
}
|
|
|
|
const consumeMarketFee = {
|
|
consumeMarketFeeAddress: ZERO_ADDRESS,
|
|
consumeMarketFeeToken: ZERO_ADDRESS,
|
|
consumeMarketFeeAmount: '0'
|
|
}
|
|
const order: OrderParams = {
|
|
consumer: await user1.getAddress(),
|
|
serviceIndex: 1,
|
|
_providerFee: providerFees,
|
|
_consumeMarketFee: consumeMarketFee
|
|
}
|
|
const buyFromDispenseTx = await datatoken.buyFromDispenserAndOrder(
|
|
datatokenAddress,
|
|
order,
|
|
addresses.Dispenser
|
|
)
|
|
assert(buyFromDispenseTx)
|
|
})
|
|
|
|
it('#buyFromFreAndOrder - Enterprise method ', async () => {
|
|
const providerData = JSON.stringify({ timeout: 0 })
|
|
const providerFeeToken = ZERO_ADDRESS
|
|
const providerFeeAmount = '0'
|
|
const providerValidUntil = '0'
|
|
|
|
const message = ethers.utils.solidityKeccak256(
|
|
['bytes', 'address', 'address', 'uint256', 'uint256'],
|
|
[
|
|
ethers.utils.hexlify(ethers.utils.toUtf8Bytes(providerData)),
|
|
await user3.getAddress(),
|
|
providerFeeToken,
|
|
providerFeeAmount,
|
|
providerValidUntil
|
|
]
|
|
)
|
|
|
|
const { v, r, s } = await signHash(user3, message)
|
|
|
|
const providerFees: ProviderFees = {
|
|
providerFeeAddress: await user1.getAddress(),
|
|
providerFeeToken,
|
|
providerFeeAmount,
|
|
v,
|
|
r,
|
|
s,
|
|
providerData: ethers.utils.hexlify(ethers.utils.toUtf8Bytes(providerData)),
|
|
validUntil: providerValidUntil
|
|
}
|
|
|
|
const consumeMarketFee = {
|
|
consumeMarketFeeAddress: ZERO_ADDRESS,
|
|
consumeMarketFeeToken: ZERO_ADDRESS,
|
|
consumeMarketFeeAmount: '0'
|
|
}
|
|
const order: OrderParams = {
|
|
consumer: await user1.getAddress(),
|
|
serviceIndex: 1,
|
|
_providerFee: providerFees,
|
|
_consumeMarketFee: consumeMarketFee
|
|
}
|
|
|
|
const fre: FreOrderParams = {
|
|
exchangeContract: addresses.FixedPrice,
|
|
exchangeId,
|
|
maxBaseTokenAmount: '1',
|
|
baseTokenAddress: addresses.MockDAI,
|
|
baseTokenDecimals: 18,
|
|
swapMarketFee: '0.1',
|
|
marketFeeAddress: ZERO_ADDRESS
|
|
}
|
|
|
|
const buyTx = await datatoken.buyFromFreAndOrder(datatokenAddress, order, fre)
|
|
assert(buyTx)
|
|
})
|
|
|
|
it('#cleanPermissions - should FAIL to clean permissions at Datatoken level, if NOT NFT Owner', async () => {
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await nftOwner.getAddress()))
|
|
.minter === true
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPaymentCollector(datatokenAddress)) ===
|
|
(await user3.getAddress())
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user1.getAddress()))
|
|
.paymentManager === true
|
|
)
|
|
|
|
try {
|
|
await datatoken.cleanPermissions(datatokenAddress, await user2.getAddress())
|
|
assert(false)
|
|
} catch (e) {
|
|
assert(e.message === 'Caller is NOT Nft Owner')
|
|
}
|
|
|
|
assert(
|
|
(await datatoken.getPaymentCollector(datatokenAddress)) ===
|
|
(await user3.getAddress())
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await nftOwner.getAddress()))
|
|
.minter === true
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user1.getAddress()))
|
|
.paymentManager === true
|
|
)
|
|
})
|
|
|
|
it('#cleanPermissions - should clean permissions at Datatoken level', async () => {
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await nftOwner.getAddress()))
|
|
.minter === true
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPaymentCollector(datatokenAddress)) ===
|
|
(await user3.getAddress())
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user1.getAddress()))
|
|
.paymentManager === true
|
|
)
|
|
|
|
datatoken = new Datatoken(nftOwner, 8996)
|
|
await datatoken.cleanPermissions(datatokenAddress, await nftOwner.getAddress())
|
|
|
|
assert(
|
|
(await datatoken.getPaymentCollector(datatokenAddress)) ===
|
|
(await nftOwner.getAddress())
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await nftOwner.getAddress()))
|
|
.minter === false
|
|
)
|
|
|
|
assert(
|
|
(await datatoken.getPermissions(datatokenAddress, await user1.getAddress()))
|
|
.paymentManager === false
|
|
)
|
|
})
|
|
|
|
it('#getNFTAddress - should succeed to get the parent NFT address', async () => {
|
|
const address = await datatoken.getNFTAddress(datatokenAddress)
|
|
assert(address, 'Not able to get the parent NFT address')
|
|
})
|
|
|
|
it('#setData - should set a value into 725Y standard, if Caller has ERC20Deployer permission', async () => {
|
|
const data = 'SomeData'
|
|
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(
|
|
nftAddress,
|
|
await nftOwner.getAddress()
|
|
)) === true
|
|
)
|
|
|
|
await datatoken.setData(datatokenAddress, await nftOwner.getAddress(), data)
|
|
|
|
assert((await nftDatatoken.getData(nftAddress, datatokenAddress)) === data)
|
|
})
|
|
|
|
it('#setData - should FAIL to set a value into 725Y standard, if Caller has NOT ERC20Deployer permission', async () => {
|
|
const data = 'NewData'
|
|
const OldData = 'SomeData'
|
|
assert(
|
|
(await nftDatatoken.isDatatokenDeployer(nftAddress, await user3.getAddress())) ===
|
|
false
|
|
)
|
|
|
|
try {
|
|
await datatoken.setData(datatokenAddress, await user3.getAddress(), data)
|
|
assert(false)
|
|
} catch (e) {
|
|
assert(e.message === 'User is not Datatoken Deployer')
|
|
}
|
|
assert((await nftDatatoken.getData(nftAddress, datatokenAddress)) === OldData)
|
|
})
|
|
|
|
it('#getDecimals - should return the number of decimals of the datatoken', async () => {
|
|
const decimals = await datatoken.getDecimals(datatokenAddress)
|
|
assert(decimals === 18)
|
|
})
|
|
|
|
it('#getSymbol - should return the symbbol of the datatoken', async () => {
|
|
const symbol = await datatoken.getSymbol(datatokenAddress)
|
|
assert(symbol === 'ERC20DT1Symbol')
|
|
})
|
|
|
|
it('#getName - should return the name of the datatoken', async () => {
|
|
const name = await datatoken.getName(datatokenAddress)
|
|
assert(name === 'ERC20B1')
|
|
})
|
|
|
|
it('#transfer - we can transfer the datatoken', async () => {
|
|
datatoken = new Datatoken(user1, 8996)
|
|
const balance1before = await datatoken.balance(
|
|
datatokenAddress,
|
|
await user1.getAddress()
|
|
)
|
|
const balance2before = await datatoken.balance(
|
|
datatokenAddress,
|
|
await user2.getAddress()
|
|
)
|
|
|
|
await datatoken.transfer(datatokenAddress, await user2.getAddress(), '1')
|
|
|
|
const balance1after = await datatoken.balance(
|
|
datatokenAddress,
|
|
await user1.getAddress()
|
|
)
|
|
const balance2after = await datatoken.balance(
|
|
datatokenAddress,
|
|
await user2.getAddress()
|
|
)
|
|
|
|
assert(+balance1after === +balance1before - 1)
|
|
assert(+balance2after === +balance2before + 1)
|
|
})
|
|
|
|
it('#setPublishingMarketFee - User should not be able to set the Publishing Market Fee', async () => {
|
|
const originalPublishingMarketFee = await datatoken.getPublishingMarketFee(
|
|
datatokenAddress
|
|
)
|
|
try {
|
|
await datatoken.setPublishingMarketFee(
|
|
datatokenAddress,
|
|
await user1.getAddress(),
|
|
addresses.MockDAI,
|
|
ethers.utils.parseUnits('10').toString(),
|
|
await user1.getAddress()
|
|
)
|
|
} catch (e) {
|
|
assert(e.message === 'Caller is not the Publishing Market Fee Address')
|
|
}
|
|
const newPublishingMarketFee = await datatoken.getPublishingMarketFee(
|
|
datatokenAddress
|
|
)
|
|
|
|
assert(
|
|
newPublishingMarketFee.publishMarketFeeAddress ===
|
|
originalPublishingMarketFee.publishMarketFeeAddress
|
|
)
|
|
assert(
|
|
newPublishingMarketFee.publishMarketFeeToken ===
|
|
originalPublishingMarketFee.publishMarketFeeToken
|
|
)
|
|
assert(
|
|
newPublishingMarketFee.publishMarketFeeAmount ===
|
|
originalPublishingMarketFee.publishMarketFeeAmount
|
|
)
|
|
})
|
|
|
|
it('#setPublishingMarketFee - Marketplace fee address should be able to set the Publishing Market Fee', async () => {
|
|
datatoken = new Datatoken(user2, 8996)
|
|
|
|
const originalPublishingMarketFee = await datatoken.getPublishingMarketFee(
|
|
datatokenAddress
|
|
)
|
|
try {
|
|
await datatoken.setPublishingMarketFee(
|
|
datatokenAddress,
|
|
await user2.getAddress(),
|
|
addresses.MockDAI,
|
|
ethers.utils.parseUnits('10').toString(),
|
|
await user2.getAddress()
|
|
)
|
|
} catch (e) {
|
|
console.log('Error:', e)
|
|
}
|
|
const newPublishingMarketFee = await datatoken.getPublishingMarketFee(
|
|
datatokenAddress
|
|
)
|
|
|
|
assert(newPublishingMarketFee !== originalPublishingMarketFee)
|
|
assert(newPublishingMarketFee.publishMarketFeeAddress === (await user2.getAddress()))
|
|
|
|
assert(
|
|
newPublishingMarketFee.publishMarketFeeAmount ===
|
|
ethers.utils.parseUnits('10').toString()
|
|
)
|
|
assert(newPublishingMarketFee.publishMarketFeeToken === addresses.MockDAI)
|
|
})
|
|
})
|