mirror of
https://github.com/oceanprotocol/ocean.js.git
synced 2024-11-26 20:39:05 +01:00
406 lines
12 KiB
TypeScript
406 lines
12 KiB
TypeScript
import { assert, expect } from 'chai'
|
|
import { SHA256 } from 'crypto-js'
|
|
import { ethers, Signer } from 'ethers'
|
|
import { getTestConfig, getAddresses, provider } from '../config'
|
|
import {
|
|
Config,
|
|
ProviderInstance,
|
|
Aquarius,
|
|
NftFactory,
|
|
NftCreateData,
|
|
ZERO_ADDRESS,
|
|
Nft,
|
|
approve,
|
|
getEventFromTx
|
|
} from '../../src'
|
|
import {
|
|
ValidateMetadata,
|
|
DDO,
|
|
DatatokenCreateParams,
|
|
FreCreationParams,
|
|
DispenserCreationParams,
|
|
Files
|
|
} from '../../src/@types'
|
|
|
|
import { createAsset } from '../../src/utils'
|
|
function delay(interval: number) {
|
|
return it('should delay', (done) => {
|
|
setTimeout(() => done(), interval)
|
|
}).timeout(interval + 100)
|
|
}
|
|
|
|
describe('Publish tests', async () => {
|
|
let config: Config
|
|
let addresses: any
|
|
let aquarius: Aquarius
|
|
let providerUrl: any
|
|
let nft: Nft
|
|
let factory: NftFactory
|
|
let publisherAccount: Signer
|
|
let fixedPricedDID: string
|
|
let dispenserDID: string
|
|
|
|
const assetUrl: Files = {
|
|
datatokenAddress: '0x0',
|
|
nftAddress: '0x0',
|
|
files: [
|
|
{
|
|
type: 'url',
|
|
url: 'https://raw.githubusercontent.com/oceanprotocol/testdatasets/main/shs_dataset_test.txt',
|
|
method: 'GET'
|
|
}
|
|
]
|
|
}
|
|
|
|
const genericAsset: DDO = {
|
|
'@context': ['https://w3id.org/did/v1'],
|
|
id: '',
|
|
version: '4.1.0',
|
|
chainId: 4,
|
|
nftAddress: '0x0',
|
|
metadata: {
|
|
created: '2021-12-20T14:35:20Z',
|
|
updated: '2021-12-20T14:35:20Z',
|
|
type: 'dataset',
|
|
name: 'dataset-name',
|
|
description: 'Ocean protocol test dataset description',
|
|
author: 'oceanprotocol-team',
|
|
license: 'MIT',
|
|
tags: ['white-papers'],
|
|
additionalInformation: { 'test-key': 'test-value' },
|
|
links: ['http://data.ceda.ac.uk/badc/ukcp09/']
|
|
},
|
|
services: [
|
|
{
|
|
id: 'testFakeId',
|
|
type: 'access',
|
|
description: 'Download service',
|
|
files: '',
|
|
datatokenAddress: '0x0',
|
|
serviceEndpoint: 'http://172.15.0.4:8030',
|
|
timeout: 0
|
|
}
|
|
]
|
|
}
|
|
|
|
before(async () => {
|
|
publisherAccount = (await provider.getSigner(0)) as Signer
|
|
config = await getTestConfig(publisherAccount)
|
|
|
|
aquarius = new Aquarius(config.metadataCacheUri)
|
|
providerUrl = config.providerUri
|
|
|
|
addresses = getAddresses()
|
|
})
|
|
|
|
it('initialize test classes', async () => {
|
|
nft = new Nft(publisherAccount)
|
|
factory = new NftFactory(addresses.ERC721Factory, publisherAccount)
|
|
|
|
await approve(
|
|
publisherAccount,
|
|
config,
|
|
await publisherAccount.getAddress(),
|
|
addresses.MockDAI,
|
|
addresses.ERC721Factory,
|
|
'100000'
|
|
)
|
|
})
|
|
|
|
it('should publish a dataset with fixed price (create NFT + Datoken + fixed price) with an explicit empty Metadata Proof', async () => {
|
|
const fixedPriceDdo: DDO = { ...genericAsset }
|
|
|
|
const nftParams: NftCreateData = {
|
|
name: 'testNftFre',
|
|
symbol: 'TSTF',
|
|
templateIndex: 1,
|
|
tokenURI: '',
|
|
transferable: true,
|
|
owner: await publisherAccount.getAddress()
|
|
}
|
|
|
|
const datatokenParams: DatatokenCreateParams = {
|
|
templateIndex: 1,
|
|
cap: '100000',
|
|
feeAmount: '0',
|
|
paymentCollector: ZERO_ADDRESS,
|
|
feeToken: ZERO_ADDRESS,
|
|
minter: await publisherAccount.getAddress(),
|
|
mpFeeAddress: ZERO_ADDRESS
|
|
}
|
|
|
|
const fixedPriceParams: FreCreationParams = {
|
|
fixedRateAddress: addresses.FixedPrice,
|
|
baseTokenAddress: addresses.MockDAI,
|
|
owner: await publisherAccount.getAddress(),
|
|
marketFeeCollector: await publisherAccount.getAddress(),
|
|
baseTokenDecimals: 18,
|
|
datatokenDecimals: 18,
|
|
fixedRate: '1',
|
|
marketFee: '0',
|
|
allowedConsumer: await publisherAccount.getAddress(),
|
|
withMint: true
|
|
}
|
|
|
|
const bundleNFT = await factory.createNftWithDatatokenWithFixedRate(
|
|
nftParams,
|
|
datatokenParams,
|
|
fixedPriceParams
|
|
)
|
|
const trxReceipt = await bundleNFT.wait()
|
|
// events have been emitted
|
|
const nftCreatedEvent = getEventFromTx(trxReceipt, 'NFTCreated')
|
|
const tokenCreatedEvent = getEventFromTx(trxReceipt, 'TokenCreated')
|
|
expect(nftCreatedEvent.event === 'NFTCreated')
|
|
expect(tokenCreatedEvent.event === 'TokenCreated')
|
|
|
|
const nftAddress = nftCreatedEvent.args.newTokenAddress
|
|
const datatokenAddress = tokenCreatedEvent.args.newTokenAddress
|
|
assetUrl.datatokenAddress = datatokenAddress
|
|
assetUrl.nftAddress = nftAddress
|
|
|
|
fixedPriceDdo.services[0].files = await ProviderInstance.encrypt(
|
|
assetUrl,
|
|
config.chainId,
|
|
providerUrl
|
|
)
|
|
|
|
fixedPriceDdo.metadata.name = 'test-dataset-fixedPrice'
|
|
fixedPriceDdo.services[0].datatokenAddress = datatokenAddress
|
|
|
|
fixedPriceDdo.nftAddress = nftAddress
|
|
|
|
fixedPriceDdo.chainId = config.chainId
|
|
fixedPriceDdo.id =
|
|
'did:op:' +
|
|
SHA256(ethers.utils.getAddress(nftAddress) + config.chainId.toString(10))
|
|
|
|
fixedPricedDID = fixedPriceDdo.id
|
|
const isAssetValid: ValidateMetadata = await aquarius.validate(fixedPriceDdo)
|
|
assert(isAssetValid.valid === true, 'Published asset is not valid')
|
|
const encryptedResponse = await ProviderInstance.encrypt(
|
|
fixedPriceDdo,
|
|
config.chainId,
|
|
providerUrl
|
|
)
|
|
|
|
await nft.setMetadata(
|
|
nftAddress,
|
|
await publisherAccount.getAddress(),
|
|
0,
|
|
providerUrl,
|
|
'0x123',
|
|
'0x02',
|
|
encryptedResponse,
|
|
isAssetValid.hash,
|
|
[]
|
|
)
|
|
})
|
|
|
|
delay(19000)
|
|
|
|
it('should publish a dataset with fixed price (create NFT + Datoken + fixed price) using createAsset() fn', async () => {
|
|
const fixedPriceDdo: DDO = { ...genericAsset }
|
|
const ownerAddress = publisherAccount
|
|
const asset = await createAsset(
|
|
'test asset',
|
|
'TEST',
|
|
ownerAddress,
|
|
assetUrl,
|
|
'0x13a9813e7CE3fdc867C23Ef9c084570B7F2abdeC', // template 1 on dev network
|
|
fixedPriceDdo,
|
|
true, // encrypted ddo
|
|
providerUrl,
|
|
ZERO_ADDRESS, // provider fee token
|
|
addresses.ERC721Factory, // nft template factory
|
|
aquarius
|
|
)
|
|
|
|
console.log('Published asset, ddo id:', asset)
|
|
|
|
// const nftParams: NftCreateData = {
|
|
// name: 'testNftFre',
|
|
// symbol: 'TSTF',
|
|
// templateIndex: 1,
|
|
// tokenURI: '',
|
|
// transferable: true,
|
|
// owner: await publisherAccount.getAddress()
|
|
// }
|
|
|
|
// const datatokenParams: DatatokenCreateParams = {
|
|
// templateIndex: 1,
|
|
// cap: '100000',
|
|
// feeAmount: '0',
|
|
// paymentCollector: ZERO_ADDRESS,
|
|
// feeToken: ZERO_ADDRESS,
|
|
// minter: await publisherAccount.getAddress(),
|
|
// mpFeeAddress: ZERO_ADDRESS
|
|
// }
|
|
|
|
// const fixedPriceParams: FreCreationParams = {
|
|
// fixedRateAddress: addresses.FixedPrice,
|
|
// baseTokenAddress: addresses.MockDAI,
|
|
// owner: await publisherAccount.getAddress(),
|
|
// marketFeeCollector: await publisherAccount.getAddress(),
|
|
// baseTokenDecimals: 18,
|
|
// datatokenDecimals: 18,
|
|
// fixedRate: '1',
|
|
// marketFee: '0',
|
|
// allowedConsumer: await publisherAccount.getAddress(),
|
|
// withMint: true
|
|
// }
|
|
|
|
// const bundleNFT = await factory.createNftWithDatatokenWithFixedRate(
|
|
// nftParams,
|
|
// datatokenParams,
|
|
// fixedPriceParams
|
|
// )
|
|
// const trxReceipt = await bundleNFT.wait()
|
|
// // events have been emitted
|
|
// const nftCreatedEvent = getEventFromTx(trxReceipt, 'NFTCreated')
|
|
// const tokenCreatedEvent = getEventFromTx(trxReceipt, 'TokenCreated')
|
|
// expect(nftCreatedEvent.event === 'NFTCreated')
|
|
// expect(tokenCreatedEvent.event === 'TokenCreated')
|
|
|
|
// const nftAddress = nftCreatedEvent.args.newTokenAddress
|
|
// const datatokenAddress = tokenCreatedEvent.args.newTokenAddress
|
|
// assetUrl.datatokenAddress = datatokenAddress
|
|
// assetUrl.nftAddress = nftAddress
|
|
|
|
// fixedPriceDdo.services[0].files = await ProviderInstance.encrypt(
|
|
// assetUrl,
|
|
// config.chainId,
|
|
// providerUrl
|
|
// )
|
|
|
|
// fixedPriceDdo.metadata.name = 'test-dataset-fixedPrice'
|
|
// fixedPriceDdo.services[0].datatokenAddress = datatokenAddress
|
|
|
|
// fixedPriceDdo.nftAddress = nftAddress
|
|
|
|
// fixedPriceDdo.chainId = config.chainId
|
|
// fixedPriceDdo.id =
|
|
// 'did:op:' +
|
|
// SHA256(ethers.utils.getAddress(nftAddress) + config.chainId.toString(10))
|
|
|
|
// fixedPricedDID = fixedPriceDdo.id
|
|
// const isAssetValid: ValidateMetadata = await aquarius.validate(fixedPriceDdo)
|
|
// assert(isAssetValid.valid === true, 'Published asset is not valid')
|
|
// const encryptedResponse = await ProviderInstance.encrypt(
|
|
// fixedPriceDdo,
|
|
// config.chainId,
|
|
// providerUrl
|
|
// )
|
|
|
|
// await nft.setMetadata(
|
|
// nftAddress,
|
|
// await publisherAccount.getAddress(),
|
|
// 0,
|
|
// providerUrl,
|
|
// '0x123',
|
|
// '0x02',
|
|
// encryptedResponse,
|
|
// isAssetValid.hash,
|
|
// []
|
|
// )
|
|
})
|
|
|
|
it('should resolve the fixed price dataset', async () => {
|
|
const resolvedDDO = await aquarius.waitForAqua(fixedPricedDID)
|
|
assert(resolvedDDO, 'Cannot fetch DDO from Aquarius')
|
|
}).timeout(40000)
|
|
|
|
it('should publish a dataset with dispenser (create NFT + Datatoken + dispenser) with no defined MetadataProof', async () => {
|
|
const dispenserDdo: DDO = { ...genericAsset }
|
|
|
|
const nftParams: NftCreateData = {
|
|
name: 'testNftDispenser',
|
|
symbol: 'TSTD',
|
|
templateIndex: 1,
|
|
tokenURI: '',
|
|
transferable: true,
|
|
owner: await publisherAccount.getAddress()
|
|
}
|
|
|
|
const datatokenParams: DatatokenCreateParams = {
|
|
templateIndex: 1,
|
|
cap: '100000',
|
|
feeAmount: '0',
|
|
paymentCollector: ZERO_ADDRESS,
|
|
feeToken: ZERO_ADDRESS,
|
|
minter: await publisherAccount.getAddress(),
|
|
mpFeeAddress: ZERO_ADDRESS
|
|
}
|
|
|
|
const dispenserParams: DispenserCreationParams = {
|
|
dispenserAddress: addresses.Dispenser,
|
|
maxTokens: '1',
|
|
maxBalance: '1',
|
|
withMint: true,
|
|
allowedSwapper: ZERO_ADDRESS
|
|
}
|
|
|
|
const bundleNFT = await factory.createNftWithDatatokenWithDispenser(
|
|
nftParams,
|
|
datatokenParams,
|
|
dispenserParams
|
|
)
|
|
|
|
const trxReceipt = await bundleNFT.wait()
|
|
// events have been emitted
|
|
const nftCreatedEvent = getEventFromTx(trxReceipt, 'NFTCreated')
|
|
const tokenCreatedEvent = getEventFromTx(trxReceipt, 'TokenCreated')
|
|
expect(nftCreatedEvent.event === 'NFTCreated')
|
|
expect(tokenCreatedEvent.event === 'TokenCreated')
|
|
|
|
const nftAddress = nftCreatedEvent.args.newTokenAddress
|
|
const datatokenAddress = tokenCreatedEvent.args.newTokenAddress
|
|
assetUrl.datatokenAddress = datatokenAddress
|
|
assetUrl.nftAddress = nftAddress
|
|
|
|
const encryptedFiles = await ProviderInstance.encrypt(
|
|
assetUrl,
|
|
config.chainId,
|
|
providerUrl
|
|
)
|
|
dispenserDdo.metadata.name = 'test-dataset-dispenser'
|
|
dispenserDdo.services[0].files = await encryptedFiles
|
|
dispenserDdo.services[0].datatokenAddress = datatokenAddress
|
|
|
|
dispenserDdo.nftAddress = nftAddress
|
|
dispenserDdo.chainId = config.chainId
|
|
dispenserDdo.id =
|
|
'did:op:' +
|
|
SHA256(ethers.utils.getAddress(nftAddress) + config.chainId.toString(10))
|
|
dispenserDID = dispenserDdo.id
|
|
|
|
const isAssetValid: ValidateMetadata = await aquarius.validate(dispenserDdo)
|
|
assert(isAssetValid.valid === true, 'Published asset is not valid')
|
|
|
|
const encryptedDdo = await ProviderInstance.encrypt(
|
|
dispenserDdo,
|
|
config.chainId,
|
|
providerUrl
|
|
)
|
|
const encryptedResponse = await encryptedDdo
|
|
// this is publishing with any explicit metadataProofs
|
|
await nft.setMetadata(
|
|
nftAddress,
|
|
await publisherAccount.getAddress(),
|
|
0,
|
|
providerUrl,
|
|
'',
|
|
'0x02',
|
|
encryptedResponse,
|
|
isAssetValid.hash
|
|
)
|
|
})
|
|
|
|
delay(19000)
|
|
|
|
it('should resolve the free dataset', async () => {
|
|
const resolvedDDO = await aquarius.waitForAqua(dispenserDID)
|
|
assert(resolvedDDO, 'Cannot fetch DDO from Aquarius')
|
|
})
|
|
})
|