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

821 lines
22 KiB
TypeScript
Raw Normal View History

import {
VeOcean,
VeAllocate,
NftFactory,
calculateEstimatedGas,
sendTx,
approve,
ConfigHelper,
sleep,
VeFeeDistributor
} from '@oceanprotocol/lib'
import { AbiItem } from 'web3-utils'
import { HttpProvider } from 'web3-providers-http'
import { assert } from 'chai'
import Web3 from 'web3'
import { homedir } from 'os'
import fs from 'fs'
import { fetch } from 'cross-fetch'
import veDelegation from '@oceanprotocol/contracts/artifacts/contracts/ve/veDelegation.vy/veDelegation.json'
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 subgraphUrl =
'http://127.0.0.1:9000/subgraphs/name/oceanprotocol/ocean-subgraph'
function evmMine() {
const provider = web3.currentProvider as HttpProvider
return new Promise((resolve, reject) => {
provider.send(
{
jsonrpc: '2.0',
method: 'evm_mine',
id: new Date().getTime()
},
(error, result) => {
if (error) {
return reject(error)
}
return resolve(result)
}
)
})
}
function evmIncreaseTime(seconds) {
const provider = web3.currentProvider as HttpProvider
return new Promise((resolve, reject) => {
provider.send(
{
method: 'evm_increaseTime',
params: [seconds],
jsonrpc: '2.0',
id: new Date().getTime()
},
(error, result) => {
if (error) {
return reject(error)
}
return evmMine().then(() => resolve(result))
}
)
})
}
async function getTotalLockedOcean() {
const initialQuery = {
query: `query{
globalStatistics{
totalOceanLocked
}
}`
}
const initialResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(initialQuery)
})
const data = (await initialResponse.json()).data.globalStatistics
if (data.length == 0) return 0
return data[0].totalOceanLocked
}
const minAbi = [
{
constant: false,
inputs: [
{ name: 'to', type: 'address' },
{ name: 'value', type: 'uint256' }
],
name: 'mint',
outputs: [{ name: '', type: 'bool' }],
payable: false,
stateMutability: 'nonpayable',
type: 'function'
}
] as AbiItem[]
describe('veOcean tests', async () => {
let nftFactory
let veOcean: VeOcean
let delegateContract
let veAllocate: VeAllocate
let veFeeDistributor: VeFeeDistributor
let ownerAccount: string
let Alice: string
let Bob: string
let nft1, nft2, nft3
let chainId
const configHelper = new ConfigHelper()
const config = configHelper.getConfig('development')
before(async () => {
const accounts = await web3.eth.getAccounts()
chainId = await web3.eth.getChainId()
ownerAccount = accounts[0]
Alice = accounts[1]
Bob = accounts[2]
delegateContract = new web3.eth.Contract(
veDelegation.abi as AbiItem[],
addresses.veDelegation
)
const tokenContract = new web3.eth.Contract(minAbi, addresses.Ocean)
const estGas = await calculateEstimatedGas(
ownerAccount,
tokenContract.methods.mint,
Alice,
web3.utils.toWei('100000')
)
await sendTx(
ownerAccount,
estGas,
web3,
1,
tokenContract.methods.mint,
Alice,
web3.utils.toWei('100000')
)
await sendTx(
ownerAccount,
estGas,
web3,
1,
tokenContract.methods.mint,
Bob,
web3.utils.toWei('100000')
)
veOcean = new VeOcean(addresses.veOCEAN, web3)
veAllocate = new VeAllocate(addresses.veAllocate, web3)
nftFactory = new NftFactory(addresses.ERC721Factory, web3)
veFeeDistributor = new VeFeeDistributor(addresses.veFeeDistributor, web3)
})
it('Alice should lock 100 Ocean', async () => {
// since we can only lock once, we test if tx fails or not
// so if there is already a lock, skip it
const totalOceanLockedBefore = await getTotalLockedOcean()
let currentBalance = await veOcean.getLockedAmount(Alice)
let currentLock = await veOcean.lockEnd(Alice)
const amount = '100'
await approve(
web3,
config,
Alice,
addresses.Ocean,
addresses.veOCEAN,
amount
)
const timestamp = Math.floor(Date.now() / 1000)
const unlockTime = timestamp + 7 * 86400
if (parseInt(currentBalance) > 0 || currentLock > 0) {
// we already have some locked tokens, so our transaction should fail
try {
await veOcean.lockTokens(Alice, amount, unlockTime)
assert(false, 'This should fail!')
} catch (e) {
// do nothing
}
} else {
await veOcean.lockTokens(Alice, amount, unlockTime)
}
currentBalance = await veOcean.getLockedAmount(Alice)
currentLock = await veOcean.lockEnd(Alice)
await sleep(2000)
const totalOceanLockedAfter = await getTotalLockedOcean()
assert(
parseFloat(totalOceanLockedAfter) > parseFloat(totalOceanLockedBefore),
'After (' +
totalOceanLockedAfter +
') shold be higher then ' +
totalOceanLockedBefore
)
assert(
parseFloat(totalOceanLockedAfter) ==
parseFloat(totalOceanLockedBefore + amount),
'Invalid totalOceanLockedAfter (' + totalOceanLockedAfter + ')'
)
const initialQuery = {
query: `query {
veOCEANs(id:"${Alice.toLowerCase()}"){
id,
lockedAmount,
unlockTime
}
}`
}
const initialResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(initialQuery)
})
const info = (await initialResponse.json()).data.veOCEANs
assert(info[0].id === Alice.toLowerCase())
assert(info[0].lockedAmount === currentBalance)
assert(info[0].unlockTime === currentLock)
})
it('Alice should increase the lock time', async () => {
const currentLock = await veOcean.lockEnd(Alice)
const newLock = parseInt(String(currentLock)) + 7 * 86400
await veOcean.increaseUnlockTime(Alice, newLock)
const newCurrentLock = await veOcean.lockEnd(Alice)
await sleep(2000)
const initialQuery = {
query: `query {
veOCEANs(id:"${Alice.toLowerCase()}"){
id,
lockedAmount,
unlockTime
}
}`
}
const initialResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(initialQuery)
})
const info = (await initialResponse.json()).data.veOCEANs
assert(
info[0].unlockTime === newCurrentLock,
'Expected lock ' +
newCurrentLock +
' to equal subgraph value ' +
info[0].unlockTime
)
})
it('Alice should increase the locked amount', async () => {
const amount = '200'
await approve(
web3,
config,
Alice,
addresses.Ocean,
addresses.veOCEAN,
amount
)
await veOcean.increaseAmount(Alice, amount)
const newCurrentBalance = await veOcean.getLockedAmount(Alice)
const newCurrentLock = await veOcean.lockEnd(Alice)
await sleep(2000)
const initialQuery = {
query: `query {
veOCEANs(id:"${Alice.toLowerCase()}"){
id,
lockedAmount,
unlockTime
}
}`
}
const initialResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(initialQuery)
})
const info = (await initialResponse.json()).data.veOCEANs
assert(
info[0].unlockTime === newCurrentLock,
'Expected lock ' +
newCurrentLock +
' to equal subgraph value ' +
info[0].unlockTime
)
assert(
info[0].lockedAmount === newCurrentBalance,
'Expected balance ' +
newCurrentBalance +
' to equal subgraph value ' +
info[0].lockedAmount
)
})
it('Alice should publish 3 NFTs', async () => {
// publish 3 nfts
nft1 = await nftFactory.createNFT(Alice, {
name: 'testNft1',
symbol: 'TSTF1',
templateIndex: 1,
tokenURI: '',
transferable: true,
owner: Alice
})
nft2 = await nftFactory.createNFT(Alice, {
name: 'testNft2',
symbol: 'TSTF2',
templateIndex: 1,
tokenURI: '',
transferable: true,
owner: Alice
})
nft3 = await nftFactory.createNFT(Alice, {
name: 'testNft3',
symbol: 'TSTF3',
templateIndex: 1,
tokenURI: '',
transferable: true,
owner: Alice
})
})
it('Alice should allocate 10% to NFT1', async () => {
await veAllocate.setAllocation(Alice, '1000', nft1, chainId)
const newTotalAllocation = await veAllocate.getTotalAllocation(Alice)
await sleep(2000)
let initialQuery = {
query: `query {
veAllocateUsers(id:"${Alice.toLowerCase()}"){
id,
allocatedTotal
}
}`
}
let initialResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(initialQuery)
})
let info = (await initialResponse.json()).data.veAllocateUsers
assert(
info[0].allocatedTotal === newTotalAllocation,
'Expected totalAllocation ' +
newTotalAllocation +
' to equal subgraph value ' +
info[0].allocatedTotal
)
initialQuery = {
query: `query {
veAllocations(
where: {allocationUser:"${Alice.toLowerCase()}", chainId:"${chainId}", nftAddress:"${nft1.toLowerCase()}"}
){
id,
allocated
}
}`
}
initialResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(initialQuery)
})
info = (await initialResponse.json()).data.veAllocations
assert(
info[0].allocated === '1000',
'Expected totalAllocation 1000 to equal subgraph value ' +
info[0].allocatedTotal
)
})
it('Alice should allocate 10% to NFT2 and 20% to NFT3', async () => {
await veAllocate.setBatchAllocation(
Alice,
['1000', '2000'],
[nft2, nft3],
[chainId, chainId]
)
const totalAllocation = await veAllocate.getTotalAllocation(Alice)
await sleep(2000)
let initialQuery = {
query: `query {
veAllocateUsers(id:"${Alice.toLowerCase()}"){
id,
allocatedTotal
}
}`
}
let initialResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(initialQuery)
})
let info = (await initialResponse.json()).data.veAllocateUsers
assert(
info[0].allocatedTotal === totalAllocation,
'Expected totalAllocation ' +
totalAllocation +
' to equal subgraph value ' +
info[0].allocatedTotal
)
initialQuery = {
query: `query {
veAllocations(
where: {allocationUser:"${Alice.toLowerCase()}", chainId:"${chainId}", nftAddress:"${nft2.toLowerCase()}"}
){
id,
allocated
}
}`
}
initialResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(initialQuery)
})
info = (await initialResponse.json()).data.veAllocations
assert(
info[0].allocated === '1000',
'Expected totalAllocation 1000 to equal subgraph value ' +
info[0].allocatedTotal
)
initialQuery = {
query: `query {
veAllocations(
where: {allocationUser:"${Alice.toLowerCase()}", chainId:"${chainId}", nftAddress:"${nft3.toLowerCase()}"}
){
id,
allocated
}
}`
}
initialResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(initialQuery)
})
info = (await initialResponse.json()).data.veAllocations
assert(
info[0].allocated === '2000',
'Expected totalAllocation 1000 to equal subgraph value ' +
info[0].allocatedTotal
)
})
it('Alice should advance chain one day', async () => {
await evmIncreaseTime(60 * 60 * 24)
})
it('Alice should add ocean rewards to feeDistrib', async () => {
// mint 10 ocean and send them to feeDistrib
let tokenContract = new web3.eth.Contract(minAbi, addresses.Ocean)
let estGas = await calculateEstimatedGas(
ownerAccount,
tokenContract.methods.mint,
addresses.veFeeDistributor,
web3.utils.toWei('10')
)
await sendTx(
ownerAccount,
estGas,
web3,
1,
tokenContract.methods.mint,
addresses.veFeeDistributor,
web3.utils.toWei('10')
)
const minAbiFee = [
{
name: 'checkpoint_token',
outputs: [],
inputs: [],
stateMutability: 'nonpayable',
type: 'function',
gas: 820723
},
{
name: 'checkpoint_total_supply',
outputs: [],
inputs: [],
stateMutability: 'nonpayable',
type: 'function',
gas: 10592405
}
] as AbiItem[]
tokenContract = new web3.eth.Contract(minAbiFee, addresses.veFeeDistributor)
estGas = await calculateEstimatedGas(
ownerAccount,
tokenContract.methods.checkpoint_token
)
await sendTx(
ownerAccount,
estGas,
web3,
1,
tokenContract.methods.checkpoint_token
)
estGas = await calculateEstimatedGas(
ownerAccount,
tokenContract.methods.checkpoint_total_supply
)
await sendTx(
ownerAccount,
estGas,
web3,
1,
tokenContract.methods.checkpoint_total_supply
)
})
it('Alice should advance chain 7 day', async () => {
await evmIncreaseTime(60 * 60 * 24 * 7)
})
it('Alice should add again ocean rewards to feeDistrib', async () => {
// mint 20 ocean and send them to feeDistrib
let tokenContract = new web3.eth.Contract(minAbi, addresses.Ocean)
let estGas = await calculateEstimatedGas(
ownerAccount,
tokenContract.methods.mint,
addresses.veFeeDistributor,
web3.utils.toWei('20')
)
await sendTx(
ownerAccount,
estGas,
web3,
1,
tokenContract.methods.mint,
addresses.veFeeDistributor,
web3.utils.toWei('20')
)
const minAbiFee = [
{
name: 'checkpoint_token',
outputs: [],
inputs: [],
stateMutability: 'nonpayable',
type: 'function',
gas: 820723
},
{
name: 'checkpoint_total_supply',
outputs: [],
inputs: [],
stateMutability: 'nonpayable',
type: 'function',
gas: 10592405
}
] as AbiItem[]
tokenContract = new web3.eth.Contract(minAbiFee, addresses.veFeeDistributor)
estGas = await calculateEstimatedGas(
ownerAccount,
tokenContract.methods.checkpoint_token
)
await sendTx(
ownerAccount,
estGas,
web3,
1,
tokenContract.methods.checkpoint_token
)
estGas = await calculateEstimatedGas(
ownerAccount,
tokenContract.methods.checkpoint_total_supply
)
await sendTx(
ownerAccount,
estGas,
web3,
1,
tokenContract.methods.checkpoint_total_supply
)
})
it('Alice should advance chain 7 day', async () => {
await evmIncreaseTime(60 * 60 * 24 * 7)
})
it('Alice should claim rewards', async () => {
await veFeeDistributor.claim(Alice)
})
it('Alice should withdraw locked tokens', async () => {
await evmIncreaseTime(60 * 60 * 24 * 7)
const totalOceanLockedBefore = await getTotalLockedOcean()
await veOcean.withdraw(Alice)
await sleep(2000)
const totalOceanLockedAfter = await getTotalLockedOcean()
assert(
parseFloat(totalOceanLockedAfter) < parseFloat(totalOceanLockedBefore),
'After (' +
totalOceanLockedAfter +
') shold be lower then ' +
totalOceanLockedBefore
)
})
it('Alice should lock 100 Ocean and Delegate them to Bob', async () => {
// since we can only lock once, we test if tx fails or not
// so if there is already a lock, skip it
let currentBalance = await veOcean.getLockedAmount(Alice)
let currentLock = await veOcean.lockEnd(Alice)
const amount = '100'
await approve(
web3,
config,
Alice,
addresses.Ocean,
addresses.veOCEAN,
amount
)
const timestamp = Math.floor(Date.now() / 1000)
const unlockTime = timestamp + 30 * 86400
if (parseInt(currentBalance) > 0 || currentLock > 0) {
// we already have some locked tokens, so our transaction should fail
try {
await veOcean.lockTokens(Alice, amount, unlockTime)
assert(false, 'This should fail!')
} catch (e) {
// do nothing
}
} else {
await veOcean.lockTokens(Alice, amount, unlockTime)
}
currentBalance = await veOcean.getLockedAmount(Alice)
currentLock = await veOcean.lockEnd(Alice)
await sleep(2000)
const initialQuery = {
query: `query {
veOCEANs(id:"${Alice.toLowerCase()}"){
id,
lockedAmount,
unlockTime
}
}`
}
await sleep(2000)
const initialResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(initialQuery)
})
await sleep(2000)
const info = (await initialResponse.json()).data.veOCEANs
assert(info[0].id === Alice.toLowerCase(), 'ID is incorrect')
assert(info[0].lockedAmount === currentBalance, 'LockedAmount is incorrect')
assert(info[0].unlockTime === currentLock, 'Unlock time is not correct')
const lockTime = await veOcean.lockEnd(Alice)
const extLockTime = Number(lockTime) + 31556926
await delegateContract.methods.setApprovalForAll(Alice, true).send({
from: Alice
})
await veOcean.increaseUnlockTime(Alice, extLockTime)
2023-04-28 08:36:56 +02:00
const initalBoostExpiry = extLockTime - 100000
let estGas = await calculateEstimatedGas(
Alice,
delegateContract.methods.create_boost,
Alice,
Bob,
2023-04-28 08:36:56 +02:00
5000,
0,
2023-04-28 08:36:56 +02:00
initalBoostExpiry,
0
)
const tx3 = await sendTx(
Alice,
estGas,
web3,
1,
delegateContract.methods.create_boost,
Alice,
Bob,
2023-04-28 08:36:56 +02:00
5000,
0,
2023-04-28 08:36:56 +02:00
initalBoostExpiry,
0
)
assert(tx3, 'Transaction failed')
assert(tx3.events.DelegateBoost, 'No Delegate boost event')
2023-04-28 08:36:56 +02:00
const tokenId = tx3.events.DelegateBoost.returnValues._token_id
await evmIncreaseTime(60)
// extend boost
estGas = await calculateEstimatedGas(
Alice,
delegateContract.methods.extend_boost,
tokenId,
10000,
extLockTime,
0
)
2023-04-28 08:36:56 +02:00
const tx4 = await sendTx(
Alice,
estGas,
web3,
1,
delegateContract.methods.extend_boost,
tokenId,
10000,
extLockTime,
0
)
assert(tx4, 'Transaction failed')
assert(tx4.events.ExtendBoost, 'No ExtendBoost event')
await evmIncreaseTime(60)
// burn it
estGas = await calculateEstimatedGas(
Alice,
delegateContract.methods.cancel_boost,
tokenId
)
const tx5 = await sendTx(
Alice,
estGas,
web3,
1,
delegateContract.methods.cancel_boost,
tokenId
)
assert(tx5, 'Transaction failed')
assert(tx5.events.BurnBoost, 'No BurnBoost event')
await sleep(3000)
const delegateQuery = {
2023-04-28 08:36:56 +02:00
query: `query{
veDelegations(where:{delegator:"${Alice.toLowerCase()}"}){
id
delegator {
id
2023-04-28 08:36:56 +02:00
}
receiver{
id
2023-04-28 08:36:56 +02:00
}
amount
tokenId
cancelTime
expireTime
2023-04-28 08:36:56 +02:00
updates(orderBy:timestamp orderDirection:asc){
id
block
timestamp
tx
sender
amount
cancelTime
expireTime
type
}
}
2023-04-28 08:36:56 +02:00
}`
}
const delegateResponse = await fetch(subgraphUrl, {
method: 'POST',
body: JSON.stringify(delegateQuery)
})
2023-04-28 08:36:56 +02:00
const resp = await delegateResponse.json()
const delegations = resp.data.veDelegations
assert(delegations.length > 0, 'No veDelegations')
assert(
delegations[0].tokenId.toLowerCase() ==
tx3.events.DelegateBoost.returnValues._token_id.toLowerCase(),
'Invalid tokenID'
)
assert(delegations[0].amount == '0', 'Invalid amount, should be 0')
assert(delegations[0].updates.length > 0, 'No updates')
// check updates. first is create boost
assert(
delegations[0].updates[0].type == 0,
'Invalid type. should be createBoost'
)
assert(
delegations[0].updates[0].cancelTime ==
tx3.events.DelegateBoost.returnValues._cancel_time,
'Invalid cancelTime'
)
assert(
delegations[0].updates[0].expireTime ==
tx3.events.DelegateBoost.returnValues._expire_time,
'Invalid expireTime'
)
assert(
web3.utils.toWei(delegations[0].updates[0].amount) ==
2023-04-28 08:36:56 +02:00
tx3.events.DelegateBoost.returnValues._amount,
'Invalid amount'
)
// check extend boos update
assert(
delegations[0].updates[1].type == 1,
'Invalid type. should be extend Boost'
)
assert(
delegations[0].updates[1].cancelTime ==
tx4.events.ExtendBoost.returnValues._cancel_time,
'Invalid cancelTime for extend boost'
)
assert(
delegations[0].updates[1].expireTime ==
tx4.events.ExtendBoost.returnValues._expire_time,
'Invalid expireTime for extend boost'
)
assert(
web3.utils.toWei(delegations[0].updates[1].amount) ==
2023-04-28 08:36:56 +02:00
tx4.events.ExtendBoost.returnValues._amount,
'Invalid amount for extend boost'
)
// check burn
assert(delegations[0].updates[2].type == 2, 'Invalid type. should be burn')
})
})