194 lines
5.1 KiB
TypeScript
194 lines
5.1 KiB
TypeScript
import { Address, BigDecimal, ethereum } from '@graphprotocol/graph-ts'
|
|
import {
|
|
Pool,
|
|
PoolShares,
|
|
PoolToken,
|
|
PoolTransaction
|
|
} from '../../@types/schema'
|
|
import { BPool } from '../../@types/templates/BPool/BPool'
|
|
import { PoolTransactionType } from './constants'
|
|
import { gweiToEth, weiToDecimal } from './generic'
|
|
|
|
export function getPoolSharesId(
|
|
poolAddress: string,
|
|
userAddress: string
|
|
): string {
|
|
return `${poolAddress}-${userAddress}`
|
|
}
|
|
|
|
export function getPoolTransaction(
|
|
event: ethereum.Event,
|
|
userAddress: string,
|
|
type: PoolTransactionType
|
|
): PoolTransaction {
|
|
let poolTx = PoolTransaction.load(event.transaction.hash.toHex())
|
|
|
|
// create pool transaction and fill basic fields
|
|
if (poolTx === null) {
|
|
poolTx = new PoolTransaction(event.transaction.hash.toHex())
|
|
|
|
poolTx.user = userAddress
|
|
poolTx.pool = event.address.toHex()
|
|
poolTx.type = type
|
|
|
|
poolTx.timestamp = event.block.timestamp.toI32()
|
|
poolTx.tx = event.transaction.hash
|
|
poolTx.block = event.block.number.toI32()
|
|
|
|
poolTx.gasPrice = gweiToEth(event.transaction.gasPrice.toBigDecimal())
|
|
poolTx.gasLimit = event.transaction.gasLimit.toBigDecimal()
|
|
}
|
|
|
|
return poolTx
|
|
}
|
|
|
|
export function getPoolShares(
|
|
poolAddress: string,
|
|
userAddress: string
|
|
): PoolShares {
|
|
let poolShares = PoolShares.load(getPoolSharesId(poolAddress, userAddress))
|
|
if (poolShares === null) {
|
|
poolShares = new PoolShares(getPoolSharesId(poolAddress, userAddress))
|
|
}
|
|
return poolShares
|
|
}
|
|
|
|
export function getPool(poolAddress: string): Pool {
|
|
const pool = Pool.load(poolAddress)
|
|
if (pool === null) {
|
|
// what now?
|
|
throw new Error(`Didn't find pool with address ${poolAddress} `)
|
|
}
|
|
return pool
|
|
}
|
|
|
|
export function getPoolTokenId(
|
|
poolAddress: string,
|
|
tokenAddress: string
|
|
): string {
|
|
return `${poolAddress}-${tokenAddress}`
|
|
}
|
|
|
|
export function getPoolToken(
|
|
poolAddress: string,
|
|
tokenAddress: string
|
|
): PoolToken {
|
|
let poolToken = PoolToken.load(getPoolTokenId(poolAddress, tokenAddress))
|
|
if (poolToken === null) {
|
|
poolToken = new PoolToken(getPoolTokenId(poolAddress, tokenAddress))
|
|
// TODO: add data to pooltoken
|
|
}
|
|
|
|
return poolToken
|
|
}
|
|
|
|
export function calcSpotPrice(
|
|
poolAddress: string,
|
|
baseTokenAddress: string,
|
|
datatokenAddress: string,
|
|
baseTokenDecimals: i32
|
|
): BigDecimal {
|
|
const poolContract = BPool.bind(Address.fromString(poolAddress))
|
|
// tokenIn is always the baseToken and tokenOut is the datatoken because we want the spot price to be in baseToken eg: 1 DT = 0.5 OCEAN
|
|
const weiPrice = poolContract.try_getSpotPrice(
|
|
Address.fromString(baseTokenAddress),
|
|
Address.fromString(datatokenAddress)
|
|
).reverted
|
|
const price = weiToDecimal(weiPrice, baseTokenDecimals)
|
|
|
|
return price
|
|
}
|
|
|
|
|
|
export function getPoolSnapshotId(poolAddress: string, timestamp: i32): string {
|
|
const dayTimestamp = timestamp - (timestamp % DAY) // Todays Timestamp
|
|
return `${poolAddress}-${dayTimestamp}`
|
|
}
|
|
|
|
export function createPoolSnapshot(poolId: string, timestamp: i32): void {
|
|
log.warning('Start create Pool Snapshot: {} {}', [
|
|
poolId,
|
|
timestamp.toString()
|
|
])
|
|
const dayTimestamp = timestamp - (timestamp % DAY) // Todays Timestamp
|
|
|
|
const pool = PoolEntity.load(poolId)
|
|
|
|
log.warning('got pool {} {}', [pool.id, poolId])
|
|
// Save pool snapshot
|
|
const snapshotId = poolId + '-' + dayTimestamp.toString()
|
|
|
|
log.warning('Creatnig Pool Snapshot with id {} {} {}', [
|
|
snapshotId,
|
|
pool.totalShares.toString(),
|
|
pool.totalSwapFee.toString()
|
|
])
|
|
const snapshot = new PoolSnapshot(snapshotId)
|
|
|
|
snapshot.pool = poolId
|
|
|
|
snapshot.totalShares = pool.totalShares
|
|
snapshot.swapVolume = ZERO_BD
|
|
snapshot.swapFees = pool.totalSwapFee
|
|
snapshot.timestamp = dayTimestamp
|
|
snapshot.save()
|
|
}
|
|
|
|
export function saveSwapToSnapshot(
|
|
poolAddress: string,
|
|
timestamp: i32,
|
|
volume: BigDecimal,
|
|
fees: BigDecimal
|
|
): void {
|
|
const dayTimestamp = timestamp - (timestamp % DAY) // Todays timestamp
|
|
|
|
// Save pool snapshot
|
|
const snapshotId = poolAddress + '-' + dayTimestamp.toString()
|
|
const snapshot = PoolSnapshot.load(snapshotId)
|
|
|
|
if (!snapshot) {
|
|
return
|
|
}
|
|
|
|
snapshot.swapVolume = snapshot.swapVolume.plus(volume)
|
|
snapshot.swapFees = snapshot.swapFees.plus(fees)
|
|
snapshot.save()
|
|
}
|
|
|
|
export function updatePoolSnapshotToken(
|
|
poolAddress: string,
|
|
timestamp: i32,
|
|
poolTokenId: string,
|
|
amount: BigDecimal,
|
|
balance: BigDecimal,
|
|
feeValue: BigDecimal
|
|
): void {
|
|
log.warning('Start create Pool Snapshot Token: {} {}', [
|
|
poolAddress,
|
|
timestamp.toString()
|
|
])
|
|
const dayTimestamp = timestamp - (timestamp % DAY) // Todays timestamp
|
|
|
|
const snapshotId = poolAddress + '-' + dayTimestamp.toString()
|
|
log.warning('Pool Snapshot Token: {} {} {} {}', [
|
|
amount.toString(),
|
|
balance.toString(),
|
|
feeValue.toString(),
|
|
snapshotId + '-' + poolTokenId
|
|
])
|
|
const token = new PoolSnapshotTokenValue(snapshotId + '-' + poolTokenId)
|
|
|
|
token.poolSnapshot = snapshotId
|
|
token.value = amount
|
|
token.tokenReserve = balance
|
|
token.tokenAddress = poolTokenId
|
|
token.feeValue = feeValue
|
|
if (amount.lt(ZERO_BD)) {
|
|
token.type = 'out'
|
|
} else {
|
|
token.type = 'in'
|
|
}
|
|
log.warning('Snapshot Token ID: {}', [token.id])
|
|
token.save()
|
|
}
|