mirror of
https://github.com/oceanprotocol/ocean-subgraph.git
synced 2024-12-02 05:57:29 +01:00
468 lines
14 KiB
TypeScript
468 lines
14 KiB
TypeScript
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]
|
|
|
|
const chain = await web3.eth.getChainId()
|
|
// create the files encrypted string
|
|
let providerResponse = await ProviderInstance.encrypt(
|
|
assetUrl,
|
|
chain,
|
|
providerUrl
|
|
)
|
|
ddo.services[0].files = await providerResponse
|
|
ddo.services[0].datatokenAddress = datatokenAddress
|
|
// update ddo and set the right did
|
|
ddo.nftAddress = erc721Address
|
|
ddo.id =
|
|
'did:op:' +
|
|
SHA256(web3.utils.toChecksumAddress(erc721Address) + chain.toString(10))
|
|
|
|
providerResponse = await ProviderInstance.encrypt(ddo, chain, 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()
|
|
)
|
|
const chain = await web3.eth.getChainId()
|
|
// create the files encrypted string
|
|
let providerResponse = await ProviderInstance.encrypt(
|
|
assetUrl,
|
|
chain,
|
|
providerUrl
|
|
)
|
|
ddo.services[0].files = await providerResponse
|
|
ddo.services[0].datatokenAddress = datatokenAddress
|
|
// update ddo and set the right did
|
|
ddo.nftAddress = erc721Address
|
|
ddo.id =
|
|
'did:op:' +
|
|
SHA256(web3.utils.toChecksumAddress(erc721Address) + chain.toString(10))
|
|
|
|
providerResponse = await ProviderInstance.encrypt(ddo, chain, 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'
|
|
)
|
|
})
|
|
})
|