mirror of
https://github.com/oceanprotocol/ocean.js.git
synced 2024-11-26 20:39:05 +01:00
294 lines
12 KiB
TypeScript
294 lines
12 KiB
TypeScript
import { assert } from 'chai'
|
|
import { AbiItem } from 'web3-utils/types'
|
|
import { TestContractHandler } from '../../TestContractHandler'
|
|
import { FixedPricedContractHandler } from '../../FixedPriceContractHandler'
|
|
import { DataTokens } from '../../../src/datatokens/Datatokens'
|
|
import {
|
|
OceanFixedRateExchange,
|
|
FixedPricedExchange
|
|
} from '../../../src/exchange/FixRateExchange'
|
|
|
|
import Web3 from 'web3'
|
|
import factory from '@oceanprotocol/contracts/artifacts/DTFactory.json'
|
|
import datatokensTemplate from '@oceanprotocol/contracts/artifacts/DataTokenTemplate.json'
|
|
|
|
import BigNumber from 'bignumber.js'
|
|
import FixedRateExchangeContract = require('@oceanprotocol/contracts/artifacts/FixedRateExchange.json')
|
|
const web3 = new Web3('http://127.0.0.1:8545')
|
|
|
|
describe('FixedRateExchange flow', () => {
|
|
let oceanTokenAddress
|
|
let FixedRateExchangeAddress
|
|
let FixedRateClass
|
|
let oceandatatoken
|
|
let aliceExchangeId
|
|
let bob
|
|
let alice
|
|
let datatoken
|
|
let tokenAddress
|
|
|
|
let alicePoolAddress
|
|
let currentDtPrice
|
|
let owner
|
|
let contracts
|
|
|
|
let consoleDebug: false
|
|
let greatPool
|
|
const tokenAmount = '1000'
|
|
const transferAmount = '200'
|
|
const blob = 'http://localhost:8030/api/v1/services/consume'
|
|
describe('#test', () => {
|
|
before(async () => {
|
|
// deploy SFactory
|
|
const Contracts = new FixedPricedContractHandler(
|
|
FixedRateExchangeContract.abi as AbiItem[],
|
|
FixedRateExchangeContract.bytecode,
|
|
web3
|
|
)
|
|
await Contracts.getAccounts()
|
|
owner = Contracts.accounts[0]
|
|
|
|
await Contracts.deployContracts()
|
|
FixedRateExchangeAddress = Contracts.contractAddress
|
|
assert(FixedRateExchangeAddress !== null)
|
|
|
|
// deploy DT Factory
|
|
contracts = new TestContractHandler(
|
|
factory.abi as AbiItem[],
|
|
datatokensTemplate.abi as AbiItem[],
|
|
datatokensTemplate.bytecode,
|
|
factory.bytecode,
|
|
web3
|
|
)
|
|
await contracts.getAccounts()
|
|
owner = contracts.accounts[0]
|
|
alice = contracts.accounts[1]
|
|
bob = contracts.accounts[2]
|
|
await contracts.deployContracts(owner)
|
|
|
|
// initialize DataTokens
|
|
datatoken = new DataTokens(
|
|
contracts.factoryAddress,
|
|
factory.abi as AbiItem[],
|
|
datatokensTemplate.abi as AbiItem[],
|
|
web3
|
|
)
|
|
assert(datatoken !== null)
|
|
})
|
|
|
|
it('should create datatokens smart contract', async () => {
|
|
tokenAddress = await datatoken.create(blob, alice)
|
|
assert(tokenAddress !== null)
|
|
console.log('data Token address:' + tokenAddress)
|
|
})
|
|
it('Create a dummy OceanToken', async () => {
|
|
// Bob creates a Datatoken
|
|
oceandatatoken = new DataTokens(
|
|
contracts.factoryAddress,
|
|
factory.abi as AbiItem[],
|
|
datatokensTemplate.abi as AbiItem[],
|
|
web3
|
|
)
|
|
oceanTokenAddress = await oceandatatoken.create(blob, bob)
|
|
console.log('oceanTokenAddress:' + oceanTokenAddress)
|
|
})
|
|
|
|
it('should initialize FixedExchangeRate class', async () => {
|
|
FixedRateClass = new OceanFixedRateExchange(
|
|
web3,
|
|
FixedRateExchangeAddress,
|
|
FixedRateExchangeContract.abi,
|
|
oceanTokenAddress
|
|
)
|
|
assert(FixedRateClass !== null)
|
|
})
|
|
|
|
it('Alice mints 1000 tokens', async () => {
|
|
await datatoken.mint(tokenAddress, alice, tokenAmount)
|
|
})
|
|
it('Bob mints 1000 Ocean tokens', async () => {
|
|
await oceandatatoken.mint(oceanTokenAddress, bob, tokenAmount)
|
|
})
|
|
it('Alice should have 1000 tokens', async () => {
|
|
const balance = await datatoken.balance(tokenAddress, alice)
|
|
console.log(balance)
|
|
})
|
|
it('Bob should have 1000 ocean tokens', async () => {
|
|
const balance = await oceandatatoken.balance(oceanTokenAddress, bob)
|
|
console.log(balance)
|
|
})
|
|
it('Alice creates a new FixedRate Exchange with a rate of 0.5', async () => {
|
|
aliceExchangeId = await FixedRateClass.create(tokenAddress, '0.1', alice)
|
|
console.log(aliceExchangeId)
|
|
})
|
|
it('Alice allows Exchange to spend 1000 data tokens', async () => {
|
|
await datatoken.approve(tokenAddress, FixedRateExchangeAddress, tokenAmount, alice)
|
|
})
|
|
it('Bob allows Exchange to spend 1000 ocean tokens', async () => {
|
|
await oceandatatoken.approve(
|
|
oceanTokenAddress,
|
|
FixedRateExchangeAddress,
|
|
tokenAmount,
|
|
bob
|
|
)
|
|
})
|
|
it('Alice should aproved speding datatokens', async () => {
|
|
const balance = await datatoken.allowance(
|
|
tokenAddress,
|
|
alice,
|
|
FixedRateExchangeAddress
|
|
)
|
|
console.log(balance)
|
|
})
|
|
it('Bob should aproved speding oceantokens', async () => {
|
|
const balance = await oceandatatoken.allowance(
|
|
oceanTokenAddress,
|
|
bob,
|
|
FixedRateExchangeAddress
|
|
)
|
|
console.log(balance)
|
|
})
|
|
it('Bob should get the exchange details', async () => {
|
|
const exchangeDetails = await FixedRateClass.getExchange(aliceExchangeId)
|
|
console.log(exchangeDetails)
|
|
})
|
|
it('Bob should swap 1 DataToken', async () => {
|
|
const swapResult = await FixedRateClass.swap(aliceExchangeId, '1', bob)
|
|
console.log(swapResult)
|
|
})
|
|
/*
|
|
it('Alice creates a new OceanPool pool', async () => {
|
|
/// new pool with total DT = 45 , dt weight=90% with swap fee 2%
|
|
alicePoolAddress = await Pool.createDTPool(alice, tokenAddress, 45, 9, '0.02')
|
|
})
|
|
it('Get pool information', async () => {
|
|
const currentTokens = await Pool.getCurrentTokens(alice, alicePoolAddress)
|
|
assert(currentTokens.length === 2)
|
|
assert(currentTokens.includes(tokenAddress))
|
|
assert(currentTokens.includes(oceanTokenAddress))
|
|
})
|
|
it('Get pool swap fee', async () => {
|
|
const currentSwapFee = await Pool.getSwapFee(alice, alicePoolAddress)
|
|
assert(currentSwapFee === '0.02')
|
|
})
|
|
it('Get dtPrice from the pool ', async () => {
|
|
currentDtPrice = await Pool.getDTPrice(alice, alicePoolAddress)
|
|
assert(currentDtPrice > 0)
|
|
})
|
|
it('Get dtToken pool reserve ', async () => {
|
|
const currentDtReserve = await Pool.getDTReserve(alice, alicePoolAddress)
|
|
assert(currentDtReserve > 0)
|
|
})
|
|
it('Get Ocean pool reserve ', async () => {
|
|
const currentOceanReserve = await Pool.getOceanReserve(alice, alicePoolAddress)
|
|
assert(currentOceanReserve > 0)
|
|
})
|
|
it('Get total supply of pool tokens', async () => {
|
|
const totalSupply = await Pool.totalSupply(alicePoolAddress)
|
|
assert(totalSupply > 0)
|
|
})
|
|
it('Get amount of Ocean needed to buy 1 dtToken', async () => {
|
|
const requiredOcean = await Pool.getOceanNeeded(alice, alicePoolAddress, '1')
|
|
assert(requiredOcean > 0)
|
|
})
|
|
|
|
it('Bob should search for pools with this DT', async () => {
|
|
const pools = await Pool.searchPoolforDT(bob, tokenAddress)
|
|
assert(pools.length > 0)
|
|
greatPool = pools[0]
|
|
})
|
|
it('Bob should buy a DT ', async () => {
|
|
const maxPrice = parseFloat(currentDtPrice) * 2
|
|
await Pool.buyDT(bob, greatPool, '1', '2', String(maxPrice))
|
|
const bobDtBalance = await datatoken.balance(tokenAddress, bob)
|
|
const bobOceanBalance = await datatoken.balance(oceanTokenAddress, bob)
|
|
assert(bobDtBalance > 0)
|
|
assert(bobOceanBalance > 0)
|
|
})
|
|
it('Bob should add DT liquidity to pool ', async () => {
|
|
const currentDtReserve = await Pool.getDTReserve(bob, greatPool)
|
|
if (consoleDebug) console.log('currentDtReserve:' + currentDtReserve)
|
|
const bobDtBalance = await datatoken.balance(tokenAddress, bob)
|
|
if (consoleDebug) console.log('BOB DT Balance:' + bobDtBalance)
|
|
await Pool.addDTLiquidity(bob, greatPool, bobDtBalance)
|
|
|
|
const newbobDtBalance = await datatoken.balance(tokenAddress, bob)
|
|
|
|
const newDtReserve = await Pool.getDTReserve(bob, greatPool)
|
|
|
|
const sharesBalance = await Pool.sharesBalance(bob, greatPool)
|
|
if (consoleDebug) console.log('newDtReserve:' + newDtReserve)
|
|
if (consoleDebug) console.log('newbobDtBalance:' + newbobDtBalance)
|
|
if (consoleDebug) console.log('sharesBalance:' + sharesBalance)
|
|
assert(parseFloat(newbobDtBalance) < parseFloat(bobDtBalance))
|
|
assert(parseFloat(newDtReserve) > parseFloat(currentDtReserve))
|
|
assert(parseFloat(sharesBalance) > 0)
|
|
})
|
|
|
|
it('Bob should remove DT liquidity from pool ', async () => {
|
|
const currentDtReserve = await Pool.getDTReserve(bob, greatPool)
|
|
if (consoleDebug) console.log('currentDtReserve:' + currentDtReserve)
|
|
const bobDtBalance = await datatoken.balance(tokenAddress, bob)
|
|
if (consoleDebug) console.log('bobDtBalance:' + bobDtBalance)
|
|
const poolShares = await Pool.sharesBalance(bob, greatPool)
|
|
if (consoleDebug) console.log('poolShares:' + poolShares)
|
|
await Pool.removeDTLiquidity(bob, greatPool, '0.75', poolShares)
|
|
|
|
const newDtReserve = await Pool.getDTReserve(bob, greatPool)
|
|
if (consoleDebug) console.log('newDtReserve:' + newDtReserve)
|
|
const newbobDtBalance = await datatoken.balance(tokenAddress, bob)
|
|
if (consoleDebug) console.log('newbobDtBalance:' + newbobDtBalance)
|
|
const newpoolShares = await Pool.sharesBalance(bob, greatPool)
|
|
if (consoleDebug) console.log('newpoolShares:' + newpoolShares)
|
|
assert(parseFloat(newDtReserve) < parseFloat(currentDtReserve))
|
|
assert(parseFloat(bobDtBalance) < parseFloat(newbobDtBalance))
|
|
assert(parseFloat(poolShares) > parseFloat(newpoolShares))
|
|
})
|
|
|
|
it('Bob should add Ocean liquidity to pool ', async () => {
|
|
const currentDtReserve = await Pool.getOceanReserve(bob, greatPool)
|
|
const bobDtBalance = await datatoken.balance(oceanTokenAddress, bob)
|
|
if (consoleDebug) console.log('currentDtReserve:' + currentDtReserve)
|
|
if (consoleDebug) console.log('bobDtBalance:' + bobDtBalance)
|
|
|
|
await Pool.addOceanLiquidity(bob, greatPool, '1')
|
|
|
|
const newbobDtBalance = await datatoken.balance(oceanTokenAddress, bob)
|
|
|
|
const newDtReserve = await Pool.getOceanReserve(bob, greatPool)
|
|
|
|
const sharesBalance = await Pool.sharesBalance(bob, greatPool)
|
|
if (consoleDebug) console.log('newDtReserve:' + newDtReserve)
|
|
if (consoleDebug) console.log('newbobDtBalance:' + newbobDtBalance)
|
|
if (consoleDebug) console.log('sharesBalance:' + sharesBalance)
|
|
assert(parseFloat(newbobDtBalance) < parseFloat(bobDtBalance))
|
|
assert(parseFloat(newDtReserve) > parseFloat(currentDtReserve))
|
|
assert(parseFloat(sharesBalance) > 0)
|
|
})
|
|
|
|
it('Bob should remove Ocean liquidity from pool ', async () => {
|
|
const currentDtReserve = await Pool.getOceanReserve(bob, greatPool)
|
|
const bobDtBalance = await datatoken.balance(oceanTokenAddress, bob)
|
|
|
|
const poolShares = await Pool.sharesBalance(bob, greatPool)
|
|
if (consoleDebug) console.log('currentDtReserve:' + currentDtReserve)
|
|
if (consoleDebug) console.log('bobDtBalance:' + bobDtBalance)
|
|
if (consoleDebug) console.log('poolShares:' + poolShares)
|
|
|
|
await Pool.removeOceanLiquidity(bob, greatPool, '0.75', poolShares)
|
|
|
|
const newDtReserve = await Pool.getOceanReserve(bob, greatPool)
|
|
const newbobDtBalance = await datatoken.balance(oceanTokenAddress, bob)
|
|
const newpoolShares = await Pool.sharesBalance(bob, greatPool)
|
|
|
|
if (consoleDebug) console.log('newDtReserve:' + newDtReserve)
|
|
if (consoleDebug) console.log('newbobDtBalance:' + newbobDtBalance)
|
|
if (consoleDebug) console.log('newpoolShares:' + newpoolShares)
|
|
assert(parseFloat(newDtReserve) < parseFloat(currentDtReserve))
|
|
assert(parseFloat(bobDtBalance) < parseFloat(newbobDtBalance))
|
|
assert(parseFloat(poolShares) > parseFloat(newpoolShares))
|
|
})
|
|
*/
|
|
})
|
|
})
|