@sentio/sdk 2.15.0-rc.2 → 2.15.0-rc.4

package/src/move/ext/move-dex.ts

@@ -0,0 +1,255 @@
+import { DecodedStruct, TypeDescriptor } from '../types.js'
+import { BigDecimal } from '@sentio/bigdecimal'
+import { Gauge } from '../../core/index.js'
+import { MoveAccountContext, MoveContext } from '../move-context.js'
+import { MoveCoinList } from './coin-list.js'
+
+export interface SimpleCoinInfo {
+  token_type: { type: string; account_address: string }
+  symbol: string
+  decimals: number
+  bridge: string
+}
+
+export interface MovePoolAdaptor<StructType, T> {
+  getXReserve(pool: T): bigint
+
+  getYReserve(pool: T): bigint
+
+  getExtraPoolTags(pool: DecodedStruct<StructType, T>): any
+
+  poolType: TypeDescriptor<T>
+}
+
+export class MoveDex<
+  Network,
+  ModuleType,
+  StructType,
+  EventType,
+  ContextType extends MoveContext<Network, ModuleType, StructType | EventType>,
+  AccountContextType extends MoveAccountContext<Network, ModuleType, StructType | EventType>,
+  T
+> {
+  coinList: MoveCoinList
+  poolAdaptor: MovePoolAdaptor<StructType, T>
+  volume: Gauge
+  volumeByCoin: Gauge
+  tvlAll: Gauge
+  tvlByPool: Gauge
+  tvlByCoin: Gauge
+
+  constructor(
+    volume: Gauge,
+    volumeByCoin: Gauge,
+    tvlAll: Gauge,
+    tvlByCoin: Gauge,
+    tvlByPool: Gauge,
+    poolAdaptor: MovePoolAdaptor<StructType, T>
+  ) {
+    this.volume = volume
+    this.volumeByCoin = volumeByCoin
+    this.tvlAll = tvlAll
+    this.tvlByPool = tvlByPool
+    this.tvlByCoin = tvlByCoin
+    this.poolAdaptor = poolAdaptor
+  }
+
+  async recordTradingVolume(
+    ctx: ContextType,
+    coinx: string,
+    coiny: string,
+    coinXAmount: bigint,
+    coinYAmount: bigint,
+    extraLabels?: any
+  ): Promise<BigDecimal> {
+    let result = BigDecimal(0)
+
+    const whitelistx = this.coinList.whiteListed(coinx)
+    const whitelisty = this.coinList.whiteListed(coiny)
+    if (!whitelistx && !whitelisty) {
+      return result
+    }
+    const coinXInfo = await this.coinList.getCoinInfo(coinx)
+    const coinYInfo = await this.coinList.getCoinInfo(coiny)
+    const timestamp = ctx.getTimestamp()
+    let resultX = BigDecimal(0)
+    let resultY = BigDecimal(0)
+    const pair = await this.getPair(coinx, coiny)
+    const baseLabels: Record<string, string> = extraLabels ? { ...extraLabels, pair } : { pair }
+    if (whitelistx) {
+      resultX = await this.coinList.calculateValueInUsd(coinXAmount, coinXInfo, timestamp)
+    }
+    if (whitelisty) {
+      resultY = await this.coinList.calculateValueInUsd(coinYAmount, coinYInfo, timestamp)
+    }
+    if (resultX.eq(0)) {
+      resultX = BigDecimal(resultY)
+    }
+    if (resultY.eq(0)) {
+      resultY = BigDecimal(resultX)
+    }
+    const total = resultX.plus(resultY)
+    if (total.gt(0)) {
+      this.volume.record(ctx, total, {
+        ...baseLabels,
+        bridge: coinXInfo.bridge,
+      })
+    }
+    if (resultX.gt(0)) {
+      this.volumeByCoin.record(ctx, resultX, {
+        coin: coinXInfo.symbol,
+        bridge: coinXInfo.bridge,
+        type: coinXInfo.token_type.type,
+      })
+    }
+    if (resultY.gt(0)) {
+      this.volumeByCoin.record(ctx, resultY, {
+        coin: coinYInfo.symbol,
+        bridge: coinYInfo.bridge,
+        type: coinYInfo.token_type.type,
+      })
+    }
+    result = resultX.plus(resultY).div(2)
+    return result
+  }
+
+  async syncPools(
+    resources: StructType[],
+    ctx: AccountContextType,
+    poolsHandler?: (pools: DecodedStruct<StructType, T>[]) => Promise<void> | void
+  ) {
+    const pools = await ctx.coder.filterAndDecodeStruct(this.poolAdaptor.poolType, resources)
+
+    const volumeByCoin = new Map<string, BigDecimal>()
+    const timestamp = ctx.getTimestamp()
+
+    console.log('num of pools: ', pools.length, timestamp)
+
+    let tvlAllValue = BigDecimal(0)
+    for (const pool of pools) {
+      // savePool(ctx.version, pool.type_arguments)
+      const coinx = pool.type_arguments[0]
+      const coiny = pool.type_arguments[1]
+      const whitelistx = this.coinList.whiteListed(coinx)
+      const whitelisty = this.coinList.whiteListed(coiny)
+      if (!whitelistx && !whitelisty) {
+        continue
+      }
+
+      const pair = await this.getPair(coinx, coiny)
+      const extraLabels = this.poolAdaptor.getExtraPoolTags(pool)
+      const baseLabels: Record<string, string> = { ...extraLabels, pair }
+
+      const coinXInfo = await this.coinList.getCoinInfo(coinx)
+      const coinYInfo = await this.coinList.getCoinInfo(coiny)
+
+      const coinx_amount = this.poolAdaptor.getXReserve(pool.data_decoded)
+      const coiny_amount = this.poolAdaptor.getYReserve(pool.data_decoded)
+
+      let resultX = BigDecimal(0)
+      let resultY = BigDecimal(0)
+
+      if (whitelistx) {
+        resultX = await this.coinList.calculateValueInUsd(coinx_amount, coinXInfo, timestamp)
+        let coinXTotal = volumeByCoin.get(coinXInfo.token_type.type)
+        if (!coinXTotal) {
+          coinXTotal = resultX
+        } else {
+          coinXTotal = coinXTotal.plus(resultX)
+        }
+        volumeByCoin.set(coinXInfo.token_type.type, coinXTotal)
+      }
+      if (whitelisty) {
+        resultY = await this.coinList.calculateValueInUsd(coiny_amount, coinYInfo, timestamp)
+        let coinYTotal = volumeByCoin.get(coinYInfo.token_type.type)
+        if (!coinYTotal) {
+          coinYTotal = resultY
+        } else {
+          coinYTotal = coinYTotal.plus(resultY)
+        }
+        volumeByCoin.set(coinYInfo.token_type.type, coinYTotal)
+      }
+
+      if (resultX.eq(0)) {
+        resultX = BigDecimal(resultY)
+      }
+      if (resultY.eq(0)) {
+        resultY = BigDecimal(resultX)
+      }
+
+      const poolValue = resultX.plus(resultY)
+
+      if (poolValue.isGreaterThan(0)) {
+        this.tvlByPool.record(ctx, poolValue, baseLabels)
+      }
+      tvlAllValue = tvlAllValue.plus(poolValue)
+    }
+    this.tvlAll.record(ctx, tvlAllValue)
+
+    if (poolsHandler) {
+      poolsHandler(pools)
+    }
+
+    for (const [k, v] of volumeByCoin) {
+      const coinInfo = this.coinList.whitelistCoins().get(k)
+      if (!coinInfo) {
+        throw Error('unexpected coin ' + k)
+      }
+      // const price = await getPrice(coinInfo, timestamp)
+      // priceGauge.record(ctx, price, { coin: coinInfo.symbol })
+      if (v.isGreaterThan(0)) {
+        this.tvlByCoin.record(ctx, v, {
+          coin: coinInfo.symbol,
+          bridge: coinInfo.bridge,
+          type: coinInfo.token_type.type,
+        })
+      }
+    }
+  }
+
+  async getPair(coinx: string, coiny: string): Promise<string> {
+    const coinXInfo = await this.coinList.getCoinInfo(coinx)
+    const coinYInfo = await this.coinList.getCoinInfo(coiny)
+    if (coinXInfo.symbol.localeCompare(coinYInfo.symbol) > 0) {
+      return `${coinYInfo.symbol}-${coinXInfo.symbol}`
+    }
+    return `${coinXInfo.symbol}-${coinYInfo.symbol}`
+  }
+
+  async getPairValue(
+    ctx: ContextType,
+    coinx: string,
+    coiny: string,
+    coinXAmount: bigint,
+    coinYAmount: bigint
+  ): Promise<BigDecimal> {
+    const whitelistx = this.coinList.whiteListed(coinx)
+    const whitelisty = this.coinList.whiteListed(coiny)
+    const coinXInfo = await this.coinList.getCoinInfo(coinx)
+    const coinYInfo = await this.coinList.getCoinInfo(coiny)
+    const timestamp = ctx.getTimestamp()
+    let result = BigDecimal(0.0)
+
+    if (!whitelistx || !whitelisty) {
+      return result
+    }
+
+    if (whitelistx) {
+      const value = await this.coinList.calculateValueInUsd(coinXAmount, coinXInfo, timestamp)
+      result = value
+
+      if (!whitelisty) {
+        result = result.plus(value)
+      }
+    }
+    if (whitelisty) {
+      const value = await this.coinList.calculateValueInUsd(coinYAmount, coinYInfo, timestamp)
+
+      if (!whitelistx) {
+        result = result.plus(value)
+      }
+    }
+
+    return result
+  }
+}

package/src/move/index.ts

@@ -3,5 +3,6 @@ export * from './types.js'
 export * from './utils.js'
 export * from './account.js'
 export * from './chain-adapter.js'
+export * from './move-context.js'
 
 export { MoveFetchConfig } from '@sentio/protos'

package/src/move/move-context.ts

@@ -0,0 +1,18 @@
+import { BaseContext } from '../core/index.js'
+import { AbstractMoveCoder } from './abstract-move-coder.js'
+
+export abstract class MoveContext<Network, ModuleType, StructType> extends BaseContext {
+  address: string
+  coder: AbstractMoveCoder<Network, ModuleType, StructType>
+  network: Network
+
+  abstract getTimestamp(): number
+}
+
+export abstract class MoveAccountContext<Network, ModuleType, StructType> extends BaseContext {
+  address: string
+  coder: AbstractMoveCoder<Network, ModuleType, StructType>
+  network: Network
+
+  abstract getTimestamp(): number
+}

package/src/sui/context.ts

@@ -1,14 +1,20 @@
 import { RecordMetaData } from '@sentio/protos'
-import { type Labels, BaseContext, normalizeLabels } from '../index.js'
+import { type Labels, normalizeLabels } from '../index.js'
 import { SuiNetwork } from './network.js'
-import { SuiTransactionBlockResponse, JsonRpcProvider, Connection } from '@mysten/sui.js'
+import {
+  SuiTransactionBlockResponse,
+  JsonRpcProvider,
+  Connection,
+  SuiEvent,
+  SuiMoveNormalizedModule,
+  SuiMoveObject,
+} from '@mysten/sui.js'
 import { MoveCoder, defaultMoveCoder } from './move-coder.js'
 import { Endpoints } from '@sentio/runtime'
 import { ServerError, Status } from 'nice-grpc'
+import { MoveAccountContext, MoveContext } from '../move/index.js'
 
-export class SuiContext extends BaseContext {
-  address: string
-  network: SuiNetwork
+export class SuiContext extends MoveContext<SuiNetwork, SuiMoveNormalizedModule, SuiEvent | SuiMoveObject> {
   moduleName: string
   timestamp: Date
   slot: bigint
@@ -40,7 +46,11 @@ export class SuiContext extends BaseContext {
   }
 
   getChainId() {
-    return this.network as any
+    return this.network
+  }
+
+  getTimestamp(): number {
+    return this.timestamp.getDate()
   }
 
   getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
@@ -66,7 +76,11 @@ export class SuiContext extends BaseContext {
   }
 }
 
-export class SuiObjectsContext extends BaseContext {
+export class SuiObjectsContext extends MoveAccountContext<
+  SuiNetwork,
+  SuiMoveNormalizedModule,
+  SuiEvent | SuiMoveObject
+> {
   address: string
   network: SuiNetwork
   slot: bigint
@@ -83,7 +97,7 @@ export class SuiObjectsContext extends BaseContext {
   }
 
   getChainId() {
-    return this.network as any
+    return this.network
   }
 
   getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
@@ -107,4 +121,8 @@ export class SuiObjectsContext extends BaseContext {
     }
     return new JsonRpcProvider(new Connection({ fullnode: chainServer }))
   }
+
+  getTimestamp(): number {
+    return this.timestamp.getDate()
+  }
 }