2020-12-02 11:07:09 +01:00
|
|
|
import { BigInt, BigDecimal } from '@graphprotocol/graph-ts'
|
2021-02-09 11:13:31 +01:00
|
|
|
import { OrderStarted, Transfer } from '../@types/templates/DataToken/DataToken'
|
2020-11-26 07:38:08 +01:00
|
|
|
|
2021-02-09 11:13:31 +01:00
|
|
|
import { Datatoken, TokenBalance, TokenOrder } from '../@types/schema'
|
2020-11-26 07:38:08 +01:00
|
|
|
import {
|
2020-12-02 11:07:09 +01:00
|
|
|
tokenToDecimal,
|
|
|
|
updateTokenBalance,
|
|
|
|
ZERO_BD,
|
2020-12-09 11:54:13 +01:00
|
|
|
MINUS_1_BD,
|
|
|
|
saveTokenTransaction
|
2020-12-11 11:37:09 +01:00
|
|
|
} from '../helpers'
|
2020-11-26 07:38:08 +01:00
|
|
|
|
|
|
|
/************************************
|
|
|
|
********** Pool Controls ***********
|
|
|
|
************************************/
|
|
|
|
|
|
|
|
export function handleTransfer(event: Transfer): void {
|
2020-12-11 11:37:09 +01:00
|
|
|
const tokenId = event.address.toHex()
|
2020-11-26 07:38:08 +01:00
|
|
|
|
2020-12-11 11:37:09 +01:00
|
|
|
const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
|
2020-11-26 07:38:08 +01:00
|
|
|
|
2020-12-11 11:37:09 +01:00
|
|
|
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)
|
2020-11-26 07:38:08 +01:00
|
|
|
let tokenBalanceFrom = TokenBalance.load(tokenBalanceFromId)
|
|
|
|
let tokenBalanceTo = TokenBalance.load(tokenBalanceToId)
|
2020-11-26 12:10:45 +01:00
|
|
|
let oldBalanceFrom = BigDecimal.fromString('0.0')
|
|
|
|
let oldBalanceTo = BigDecimal.fromString('0.0')
|
2020-11-26 07:38:08 +01:00
|
|
|
|
2021-01-19 12:16:03 +01:00
|
|
|
const isMint = tokenShareFrom == ZERO_ADDRESS
|
|
|
|
const isBurn = tokenShareTo == ZERO_ADDRESS
|
2020-12-02 12:09:22 +01:00
|
|
|
|
2020-12-11 11:37:09 +01:00
|
|
|
const datatoken = Datatoken.load(tokenId)
|
2020-11-26 07:38:08 +01:00
|
|
|
|
|
|
|
if (isMint) {
|
|
|
|
tokenBalanceTo = TokenBalance.load(tokenBalanceToId)
|
2020-12-11 11:37:09 +01:00
|
|
|
oldBalanceTo = tokenBalanceTo == null ? ZERO_BD : tokenBalanceTo.balance
|
2020-12-02 11:07:09 +01:00
|
|
|
datatoken.supply = datatoken.supply.plus(amount)
|
|
|
|
updateTokenBalance(tokenBalanceToId, tokenId, tokenShareTo, amount)
|
2020-11-26 07:38:08 +01:00
|
|
|
} else if (isBurn) {
|
|
|
|
tokenBalanceFrom = TokenBalance.load(tokenBalanceFromId)
|
2020-12-11 11:37:09 +01:00
|
|
|
oldBalanceFrom =
|
|
|
|
tokenBalanceFrom == null ? ZERO_BD : tokenBalanceFrom.balance
|
2020-12-02 11:07:09 +01:00
|
|
|
datatoken.supply = datatoken.supply.minus(amount)
|
2020-12-11 11:37:09 +01:00
|
|
|
updateTokenBalance(
|
|
|
|
tokenBalanceFromId,
|
|
|
|
tokenId,
|
|
|
|
tokenShareFrom,
|
|
|
|
amount.times(MINUS_1_BD)
|
|
|
|
)
|
2020-11-26 07:38:08 +01:00
|
|
|
} else {
|
|
|
|
tokenBalanceFrom = TokenBalance.load(tokenBalanceFromId)
|
2020-12-11 11:37:09 +01:00
|
|
|
oldBalanceFrom =
|
|
|
|
tokenBalanceFrom == null ? ZERO_BD : tokenBalanceFrom.balance
|
2020-12-02 11:07:09 +01:00
|
|
|
datatoken.supply = datatoken.supply.minus(amount)
|
2020-12-11 11:37:09 +01:00
|
|
|
updateTokenBalance(
|
|
|
|
tokenBalanceFromId,
|
|
|
|
tokenId,
|
|
|
|
tokenShareFrom,
|
|
|
|
amount.times(MINUS_1_BD)
|
|
|
|
)
|
2020-11-26 07:38:08 +01:00
|
|
|
|
|
|
|
tokenBalanceTo = TokenBalance.load(tokenBalanceToId)
|
2020-12-11 11:37:09 +01:00
|
|
|
oldBalanceTo = tokenBalanceTo == null ? ZERO_BD : tokenBalanceTo.balance
|
2020-12-02 11:07:09 +01:00
|
|
|
datatoken.supply = datatoken.supply.plus(amount)
|
|
|
|
updateTokenBalance(tokenBalanceToId, tokenId, tokenShareTo, amount)
|
2020-11-26 07:38:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (
|
2021-01-19 14:02:15 +01:00
|
|
|
tokenBalanceTo != null &&
|
2020-12-11 11:37:09 +01:00
|
|
|
tokenBalanceTo.balance.notEqual(ZERO_BD) &&
|
|
|
|
oldBalanceTo.equals(ZERO_BD)
|
2020-11-26 07:38:08 +01:00
|
|
|
) {
|
2020-12-02 12:09:22 +01:00
|
|
|
datatoken.holderCount += BigInt.fromI32(1)
|
2020-11-26 07:38:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (
|
2021-01-19 14:02:15 +01:00
|
|
|
tokenBalanceFrom != null &&
|
2020-12-11 11:37:09 +01:00
|
|
|
tokenBalanceFrom.balance.equals(ZERO_BD) &&
|
|
|
|
oldBalanceFrom.notEqual(ZERO_BD)
|
2020-11-26 07:38:08 +01:00
|
|
|
) {
|
2020-12-02 12:09:22 +01:00
|
|
|
datatoken.holderCount -= BigInt.fromI32(1)
|
2020-11-26 07:38:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
datatoken.save()
|
2020-12-02 11:07:09 +01:00
|
|
|
saveTokenTransaction(event, 'Transfer')
|
2020-11-26 07:38:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export function handleOrderStarted(event: OrderStarted): void {
|
2020-12-11 11:37:09 +01:00
|
|
|
const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
|
|
|
|
const tokenId = event.address.toHex()
|
|
|
|
const datatoken = Datatoken.load(tokenId)
|
2020-11-26 12:10:45 +01:00
|
|
|
if (datatoken == null) return
|
|
|
|
|
2020-12-11 11:37:09 +01:00
|
|
|
const payer = event.params.payer.toHex()
|
2020-11-26 12:10:45 +01:00
|
|
|
// let feeCollector = event.params.mrktFeeCollector
|
|
|
|
// let marketFee = event.params.marketFee
|
2020-12-11 11:37:09 +01:00
|
|
|
const tx = event.transaction.hash
|
|
|
|
const orderId = tokenId
|
|
|
|
.concat('-')
|
|
|
|
.concat(payer)
|
|
|
|
.concat('-')
|
|
|
|
.concat(tx.toHexString())
|
2020-11-26 12:10:45 +01:00
|
|
|
let order = TokenOrder.load(orderId)
|
|
|
|
if (order == null) {
|
2020-12-11 11:37:09 +01:00
|
|
|
order = new TokenOrder(orderId)
|
2020-11-26 12:10:45 +01:00
|
|
|
}
|
|
|
|
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()
|
2020-12-11 11:37:09 +01:00
|
|
|
if (
|
|
|
|
event.params.mrktFeeCollector != null &&
|
2021-01-19 14:02:15 +01:00
|
|
|
event.params.mrktFeeCollector.toHex() != ZERO_ADDRESS
|
2020-12-11 11:37:09 +01:00
|
|
|
) {
|
|
|
|
order.marketFeeCollector = event.params.mrktFeeCollector.toHexString()
|
2020-11-26 12:10:45 +01:00
|
|
|
}
|
|
|
|
order.marketFee = tokenToDecimal(event.params.marketFee.toBigDecimal(), 18)
|
|
|
|
order.tx = tx
|
|
|
|
|
|
|
|
order.save()
|
2020-12-02 11:07:09 +01:00
|
|
|
|
|
|
|
datatoken.orderCount = datatoken.orderCount.plus(BigInt.fromI32(1))
|
2020-11-26 12:10:45 +01:00
|
|
|
datatoken.save()
|
2020-12-02 11:07:09 +01:00
|
|
|
|
|
|
|
saveTokenTransaction(event, 'OrderStarted')
|
2020-11-26 07:38:08 +01:00
|
|
|
}
|