169 lines
5.1 KiB
TypeScript
169 lines
5.1 KiB
TypeScript
import { BigInt, BigDecimal } from '@graphprotocol/graph-ts'
|
|
import { OrderStarted, Transfer } from '../@types/templates/DataToken/DataToken'
|
|
|
|
import {
|
|
Datatoken,
|
|
Global,
|
|
PoolFactory,
|
|
TokenBalance,
|
|
TokenOrder,
|
|
User
|
|
} from '../@types/schema'
|
|
import {
|
|
tokenToDecimal,
|
|
updateTokenBalance,
|
|
ZERO_BD,
|
|
MINUS_1_BD,
|
|
saveTokenTransaction,
|
|
getGlobalStats
|
|
} from '../helpers'
|
|
|
|
/************************************
|
|
********** Pool Controls ***********
|
|
************************************/
|
|
|
|
export function handleTransfer(event: Transfer): void {
|
|
const tokenId = event.address.toHex()
|
|
|
|
const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
|
|
|
|
const amount = tokenToDecimal(event.params.value.toBigDecimal(), 18)
|
|
const tokenShareFrom = event.params.from.toHex()
|
|
const tokenShareTo = event.params.to.toHex()
|
|
const tokenBalanceFromId = tokenId.concat('-').concat(tokenShareFrom)
|
|
const tokenBalanceToId = tokenId.concat('-').concat(tokenShareTo)
|
|
let tokenBalanceFrom = TokenBalance.load(tokenBalanceFromId)
|
|
let tokenBalanceTo = TokenBalance.load(tokenBalanceToId)
|
|
let oldBalanceFrom = BigDecimal.fromString('0.0')
|
|
let oldBalanceTo = BigDecimal.fromString('0.0')
|
|
|
|
const isMint = tokenShareFrom == ZERO_ADDRESS
|
|
const isBurn = tokenShareTo == ZERO_ADDRESS
|
|
|
|
const datatoken = Datatoken.load(tokenId)
|
|
|
|
if (isMint) {
|
|
tokenBalanceTo = TokenBalance.load(tokenBalanceToId)
|
|
oldBalanceTo = tokenBalanceTo == null ? ZERO_BD : tokenBalanceTo.balance
|
|
datatoken.supply = datatoken.supply.plus(amount)
|
|
updateTokenBalance(tokenBalanceToId, tokenId, tokenShareTo, amount)
|
|
} else if (isBurn) {
|
|
tokenBalanceFrom = TokenBalance.load(tokenBalanceFromId)
|
|
oldBalanceFrom =
|
|
tokenBalanceFrom == null ? ZERO_BD : tokenBalanceFrom.balance
|
|
datatoken.supply = datatoken.supply.minus(amount)
|
|
updateTokenBalance(
|
|
tokenBalanceFromId,
|
|
tokenId,
|
|
tokenShareFrom,
|
|
amount.times(MINUS_1_BD)
|
|
)
|
|
} else {
|
|
tokenBalanceFrom = TokenBalance.load(tokenBalanceFromId)
|
|
oldBalanceFrom =
|
|
tokenBalanceFrom == null ? ZERO_BD : tokenBalanceFrom.balance
|
|
datatoken.supply = datatoken.supply.minus(amount)
|
|
updateTokenBalance(
|
|
tokenBalanceFromId,
|
|
tokenId,
|
|
tokenShareFrom,
|
|
amount.times(MINUS_1_BD)
|
|
)
|
|
|
|
tokenBalanceTo = TokenBalance.load(tokenBalanceToId)
|
|
oldBalanceTo = tokenBalanceTo == null ? ZERO_BD : tokenBalanceTo.balance
|
|
datatoken.supply = datatoken.supply.plus(amount)
|
|
updateTokenBalance(tokenBalanceToId, tokenId, tokenShareTo, amount)
|
|
}
|
|
|
|
if (
|
|
tokenBalanceTo != null &&
|
|
tokenBalanceTo.balance.notEqual(ZERO_BD) &&
|
|
oldBalanceTo.equals(ZERO_BD)
|
|
) {
|
|
datatoken.holderCount += BigInt.fromI32(1)
|
|
}
|
|
|
|
if (
|
|
tokenBalanceFrom != null &&
|
|
tokenBalanceFrom.balance.equals(ZERO_BD) &&
|
|
oldBalanceFrom.notEqual(ZERO_BD)
|
|
) {
|
|
datatoken.holderCount -= BigInt.fromI32(1)
|
|
}
|
|
|
|
datatoken.save()
|
|
saveTokenTransaction(event, 'Transfer')
|
|
}
|
|
|
|
export function handleOrderStarted(event: OrderStarted): void {
|
|
const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
|
|
const tokenId = event.address.toHex()
|
|
const datatoken = Datatoken.load(tokenId)
|
|
if (datatoken == null) return
|
|
|
|
const payer = event.params.payer.toHex()
|
|
// let feeCollector = event.params.mrktFeeCollector
|
|
// let marketFee = event.params.marketFee
|
|
const tx = event.transaction.hash
|
|
const orderId = tokenId
|
|
.concat('-')
|
|
.concat(payer)
|
|
.concat('-')
|
|
.concat(tx.toHexString())
|
|
let order = TokenOrder.load(orderId)
|
|
if (order == null) {
|
|
order = new TokenOrder(orderId)
|
|
}
|
|
order.datatokenId = tokenId
|
|
order.amount = tokenToDecimal(event.params.amount.toBigDecimal(), 18)
|
|
order.consumer = event.params.consumer.toHex()
|
|
order.payer = payer
|
|
order.serviceId = event.params.serviceId.toI32()
|
|
order.timestamp = event.params.timestamp.toI32()
|
|
if (
|
|
event.params.mrktFeeCollector != null &&
|
|
event.params.mrktFeeCollector.toHex() != ZERO_ADDRESS
|
|
) {
|
|
order.marketFeeCollector = event.params.mrktFeeCollector.toHexString()
|
|
}
|
|
order.marketFee = tokenToDecimal(event.params.marketFee.toBigDecimal(), 18)
|
|
order.tx = tx
|
|
order.block = event.block.number.toI32()
|
|
|
|
order.save()
|
|
|
|
datatoken.orderVolume = datatoken.orderVolume.plus(order.amount)
|
|
datatoken.orderCount = datatoken.orderCount.plus(BigInt.fromI32(1))
|
|
|
|
datatoken.save()
|
|
|
|
saveTokenTransaction(event, 'OrderStarted')
|
|
|
|
let factory = PoolFactory.load('1')
|
|
|
|
if (factory == null) {
|
|
factory = new PoolFactory('1')
|
|
factory.totalOceanLiquidity = ZERO_BD
|
|
factory.totalSwapVolume = ZERO_BD
|
|
factory.totalSwapFee = ZERO_BD
|
|
factory.totalValueLocked = ZERO_BD
|
|
factory.orderCount = BigInt.fromI32(0)
|
|
factory.poolCount = 0
|
|
factory.finalizedPoolCount = 0
|
|
}
|
|
|
|
factory.orderCount = factory.orderCount.plus(BigInt.fromI32(1))
|
|
factory.totalOrderVolume = factory.totalOrderVolume.plus(order.amount)
|
|
factory.save()
|
|
|
|
const user = User.load(datatoken.minter)
|
|
user.nrSales = user.nrSales + 1
|
|
user.save()
|
|
|
|
const gStats: Global | null = getGlobalStats()
|
|
gStats.orderCount = factory.orderCount
|
|
gStats.totalOrderVolume = factory.totalOrderVolume
|
|
gStats.save()
|
|
}
|