ocean-subgraph/test/integration/SimplePublishConsume.test.ts

461 lines
14 KiB
TypeScript
Raw Normal View History

import {
Datatoken,
DatatokenCreateParams,
ProviderInstance,
ProviderFees,
Nft,
NftFactory,
NftCreateData,
getHash,
sleep,
ZERO_ADDRESS,
signHash
} from '@oceanprotocol/lib'
import { assert } from 'chai'
import Web3 from 'web3'
import { SHA256 } from 'crypto-js'
import { homedir } from 'os'
import fs from 'fs'
import { fetch } from 'cross-fetch'
const data = JSON.parse(
fs.readFileSync(
process.env.ADDRESS_FILE ||
`${homedir}/.ocean/ocean-contracts/artifacts/address.json`,
'utf8'
)
)
const addresses = data.development
const web3 = new Web3('http://127.0.0.1:8545')
const providerUrl = 'http://172.15.0.4:8030'
const subgraphUrl =
'http://127.0.0.1:9000/subgraphs/name/oceanprotocol/ocean-subgraph'
const assetUrl = [
{
type: 'url',
url: 'https://raw.githubusercontent.com/oceanprotocol/testdatasets/main/shs_dataset_test.txt',
method: 'GET'
}
]
const ddo = {
'@context': ['https://w3id.org/did/v1'],
id: 'did:op:efba17455c127a885ec7830d687a8f6e64f5ba559f8506f8723c1f10f05c049c',
version: '4.0.0',
chainId: 4,
nftAddress: '0x0',
metadata: {
created: '2021-12-20T14:35:20Z',
updated: '2021-12-20T14:35:20Z',
type: 'dataset',
name: 'dfgdfgdg',
description: 'd dfgd fgd dfg dfgdfgd dfgdf',
tags: [''],
author: 'dd',
license: 'https://market.oceanprotocol.com/terms',
additionalInformation: {
termsAndConditions: true
}
},
services: [
{
id: 'notAnId',
type: 'access',
files: '',
datatokenAddress: '0xa15024b732A8f2146423D14209eFd074e61964F3',
serviceEndpoint: 'https://providerv4.rinkeby.oceanprotocol.com',
timeout: 0
}
]
}
describe('Simple Publish & consume test', async () => {
let datatokenAddress: string
let datatoken: Datatoken
let nft: Nft
let Factory: NftFactory
let accounts: string[]
let publisherAccount: string
let newOwnerAccount: string
let user1: string
let user2: string
let user3: string
let user4: string
before(async () => {
nft = new Nft(web3)
Factory = new NftFactory(addresses.ERC721Factory, web3)
accounts = await web3.eth.getAccounts()
publisherAccount = accounts[0]
newOwnerAccount = accounts[1].toLowerCase()
user1 = accounts[2]
user2 = accounts[3]
user3 = accounts[4]
user4 = accounts[5]
})
it('should publish a dataset (create NFT + ERC20)', async () => {
// const consumerAccount = accounts[1]
const nftParams: NftCreateData = {
name: 'testNFT',
symbol: 'TST',
templateIndex: 1,
tokenURI: '',
transferable: true,
owner: publisherAccount
}
const erc20Params: DatatokenCreateParams = {
templateIndex: 1,
cap: '100000',
feeAmount: '0',
paymentCollector: '0x0000000000000000000000000000000000000000',
feeToken: '0x0000000000000000000000000000000000000000',
minter: publisherAccount,
mpFeeAddress: '0x0000000000000000000000000000000000000000'
}
const result = await Factory.createNftWithDatatoken(
publisherAccount,
nftParams,
erc20Params
)
const erc721Address = result.events.NFTCreated.returnValues[0]
datatokenAddress = result.events.TokenCreated.returnValues[0]
// create the files encrypted string
let providerResponse = await ProviderInstance.encrypt(assetUrl, providerUrl)
ddo.services[0].files = await providerResponse
ddo.services[0].datatokenAddress = datatokenAddress
// update ddo and set the right did
ddo.nftAddress = erc721Address
const chain = await web3.eth.getChainId()
ddo.id =
'did:op:' +
SHA256(web3.utils.toChecksumAddress(erc721Address) + chain.toString(10))
providerResponse = await ProviderInstance.encrypt(ddo, providerUrl)
const encryptedResponse = await providerResponse
const metadataHash = getHash(JSON.stringify(ddo))
await nft.setMetadata(
erc721Address,
publisherAccount,
0,
providerUrl,
'',
'0x2',
encryptedResponse,
'0x' + metadataHash
)
// graph tests here
await sleep(2000)
const graphNftToken = erc721Address.toLowerCase()
const query = {
query: `query {
nft(id:"${graphNftToken}"){symbol,id}}`
}
const response = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(query)
})
const queryResult = await response.json()
assert(queryResult.data.nft.id === graphNftToken)
})
it('should publish and transfer an NFT', async () => {
const nftParams: NftCreateData = {
name: 'testNFT',
symbol: 'TST',
templateIndex: 1,
tokenURI: '',
transferable: true,
owner: publisherAccount
}
const erc20Params: DatatokenCreateParams = {
templateIndex: 1,
cap: '100000',
feeAmount: '0',
paymentCollector: '0x0000000000000000000000000000000000000000',
feeToken: '0x0000000000000000000000000000000000000000',
minter: publisherAccount,
mpFeeAddress: '0x0000000000000000000000000000000000000000'
}
const result = await Factory.createNftWithDatatoken(
publisherAccount,
nftParams,
erc20Params
)
await sleep(2000)
const erc721Address = result.events.NFTCreated.returnValues[0]
const datatokenAddress = result.events.TokenCreated.returnValues[0]
const graphNftToken = erc721Address.toLowerCase()
const queryOriginalOwner = {
query: `query {
nft(id:"${graphNftToken}"){symbol,id,owner{id}}}`
}
const initialResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(queryOriginalOwner)
})
const initialResult = await initialResponse.json()
// Checking original owner account has been set correctly
assert(
initialResult.data.nft.owner.id.toLowerCase() ===
publisherAccount.toLowerCase()
)
// create the files encrypted string
let providerResponse = await ProviderInstance.encrypt(assetUrl, providerUrl)
ddo.services[0].files = await providerResponse
ddo.services[0].datatokenAddress = datatokenAddress
// update ddo and set the right did
ddo.nftAddress = erc721Address
const chain = await web3.eth.getChainId()
ddo.id =
'did:op:' +
SHA256(web3.utils.toChecksumAddress(erc721Address) + chain.toString(10))
providerResponse = await ProviderInstance.encrypt(ddo, providerUrl)
const encryptedResponse = await providerResponse
const metadataHash = getHash(JSON.stringify(ddo))
await nft.setMetadata(
erc721Address,
publisherAccount,
0,
providerUrl,
'',
'0x2',
encryptedResponse,
'0x' + metadataHash
)
await sleep(2000)
// Transfer the NFT
await nft.transferNft(graphNftToken, publisherAccount, newOwnerAccount)
await sleep(2000)
const query2 = {
query: `query {
nft(id:"${graphNftToken}"){symbol,id,owner{id}, transferable}}`
}
const response = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(query2)
})
const queryResult = await response.json()
assert(queryResult.data.nft.owner.id === newOwnerAccount)
})
it('should save provider fees after startOrder is called', async () => {
datatoken = new Datatoken(web3, 8996)
await datatoken.mint(datatokenAddress, publisherAccount, '100', user1)
const user1Balance = await datatoken.balance(datatokenAddress, user1)
assert(user1Balance === '100', 'user1 has no datatokens')
const providerData = JSON.stringify({ timeout: 0 })
const providerFeeToken = ZERO_ADDRESS
const providerFeeAmount = '10000'
const providerValidUntil = '0'
const message = web3.utils.soliditySha3(
{ t: 'bytes', v: web3.utils.toHex(web3.utils.asciiToHex(providerData)) },
{ t: 'address', v: user3 },
{ t: 'address', v: providerFeeToken },
{ t: 'uint256', v: providerFeeAmount },
{ t: 'uint256', v: providerValidUntil }
)
const { v, r, s } = await signHash(web3, message, user3)
const setProviderFee: ProviderFees = {
providerFeeAddress: user3,
providerFeeToken,
providerFeeAmount,
v,
r,
s,
providerData: web3.utils.toHex(web3.utils.asciiToHex(providerData)),
validUntil: providerValidUntil
}
const orderTx = await datatoken.startOrder(
datatokenAddress,
user1,
user2,
1,
setProviderFee
)
const orderId = `${orderTx.transactionHash.toLowerCase()}-${datatokenAddress.toLowerCase()}-${user1.toLowerCase()}`
const query = {
query: `query {order(id:"${orderId}"){id, providerFee, lastPriceToken{id}}}`
}
await sleep(2000)
const response = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(query)
})
const queryResult = await response.json()
const providerFeeJSON = JSON.parse(queryResult.data.order.providerFee)
const lastPriceToken = queryResult.data.order.lastPriceToken.id
assert(lastPriceToken === ZERO_ADDRESS, 'Wrong lastPriceToken')
assert(
providerFeeJSON.providerFeeAddress.toLowerCase() ===
setProviderFee.providerFeeAddress.toLowerCase(),
'Wrong providerFeeAddress set'
)
assert(
providerFeeJSON.providerFeeAmount.toLowerCase() ===
setProviderFee.providerFeeAmount.toLowerCase(),
'Wrong providerFeeAmount set'
)
assert(
providerFeeJSON.providerFeeToken.toLowerCase() ===
setProviderFee.providerFeeToken.toLowerCase(),
'Wrong providerFeeToken set'
)
})
it('should save provider fees after calling reuseOrder on a using a previous txId', async () => {
await datatoken.mint(datatokenAddress, publisherAccount, '100', user4)
const user4Balance = await datatoken.balance(datatokenAddress, user4)
assert(user4Balance === '100', 'publisherAccount has no datatokens')
const providerData = JSON.stringify({ timeout: 0 })
const providerFeeToken = ZERO_ADDRESS
let providerFeeAmount = '90'
let providerValidUntil = '0'
let message = web3.utils.soliditySha3(
{ t: 'bytes', v: web3.utils.toHex(web3.utils.asciiToHex(providerData)) },
{ t: 'address', v: user3 },
{ t: 'address', v: providerFeeToken },
{ t: 'uint256', v: providerFeeAmount },
{ t: 'uint256', v: providerValidUntil }
)
let { v, r, s } = await signHash(web3, message, user3)
const setInitialProviderFee: ProviderFees = {
providerFeeAddress: user3,
providerFeeToken,
providerFeeAmount,
v,
r,
s,
providerData: web3.utils.toHex(web3.utils.asciiToHex(providerData)),
validUntil: providerValidUntil
}
const orderTx = await datatoken.startOrder(
datatokenAddress,
user4,
user2,
1,
setInitialProviderFee
)
assert(orderTx.transactionHash, 'Failed to start order')
// Check initial provider fee has been set correctly
const orderId = `${orderTx.transactionHash.toLowerCase()}-${datatokenAddress.toLowerCase()}-${user4.toLowerCase()}`
const initialQuery = {
query: `query {order(id:"${orderId}"){id, providerFee, lastPriceToken{id}}}`
}
await sleep(2000)
const initialResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(initialQuery)
})
const initialQueryResult = await initialResponse.json()
const initialProviderFeeJSON = JSON.parse(
initialQueryResult.data.order.providerFee
)
const lastPriceToken = initialQueryResult.data.order.lastPriceToken.id
assert(lastPriceToken === ZERO_ADDRESS, 'Wrong initial lastPriceToken set')
assert(
initialProviderFeeJSON.providerFeeAddress.toLowerCase() ===
setInitialProviderFee.providerFeeAddress.toLowerCase(),
'Wrong initial providerFeeAddress set'
)
assert(
initialProviderFeeJSON.providerFeeAmount.toLowerCase() ===
setInitialProviderFee.providerFeeAmount.toLowerCase(),
'Wrong initial providerFeeAmount set'
)
assert(
initialProviderFeeJSON.providerFeeToken.toLowerCase() ===
setInitialProviderFee.providerFeeToken.toLowerCase(),
'Wrong initial providerFeeToken set'
)
providerFeeAmount = '990000'
providerValidUntil = '10000'
message = web3.utils.soliditySha3(
{ t: 'bytes', v: web3.utils.toHex(web3.utils.asciiToHex(providerData)) },
{ t: 'address', v: user3 },
{ t: 'address', v: providerFeeToken },
{ t: 'uint256', v: providerFeeAmount },
{ t: 'uint256', v: providerValidUntil }
)
const msgResult = await signHash(web3, message, user3)
v = msgResult.v
r = msgResult.r
s = msgResult.s
const setNewProviderFee: ProviderFees = {
providerFeeAddress: user3,
providerFeeToken,
providerFeeAmount,
v,
r,
s,
providerData: web3.utils.toHex(web3.utils.asciiToHex(providerData)),
validUntil: providerValidUntil
}
const reusedOrder = await datatoken.reuseOrder(
datatokenAddress,
user2,
orderTx.transactionHash,
setNewProviderFee
)
assert(reusedOrder.events.OrderReused.event === 'OrderReused')
assert(reusedOrder.events.ProviderFee.event === 'ProviderFee')
sleep(4000)
// Check the new provider fee has been set in OrderReuse
const reuseQuery = {
query: `query {orderReuse(id:"${reusedOrder.transactionHash}"){id, providerFee}}`
}
await sleep(2000)
const response = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(reuseQuery)
})
const reuseQueryResult = await response.json()
const reuseProviderFeeJSON = JSON.parse(
reuseQueryResult.data.orderReuse.providerFee
)
assert(
reuseProviderFeeJSON.providerFeeAddress.toLowerCase() ===
setNewProviderFee.providerFeeAddress.toLowerCase(),
'New providerFeeAddress set in reuse order is wrong'
)
assert(
reuseProviderFeeJSON.providerFeeAmount.toLowerCase() ===
setNewProviderFee.providerFeeAmount.toLowerCase(),
'New providerFeeAmount set in reuse order is wrong'
)
assert(
reuseProviderFeeJSON.providerFeeToken.toLowerCase() ===
setNewProviderFee.providerFeeToken.toLowerCase(),
'New providerFeeToken set in reuse order is wrong'
)
})
})