@sentio/sdk 2.15.0-rc.1 → 2.15.0-rc.3

package/src/aptos/context.ts

@@ -1,15 +1,14 @@
 import { RecordMetaData } from '@sentio/protos'
-import { type Labels, BaseContext, normalizeLabels } from '@sentio/sdk'
-import { Transaction_UserTransaction } from './move-types.js'
+import { type Labels, normalizeLabels } from '@sentio/sdk'
+import { Event, MoveModuleBytecode, MoveResource, Transaction_UserTransaction } from './move-types.js'
 import { AptosNetwork } from './network.js'
 import { defaultMoveCoder, MoveCoder } from './move-coder.js'
 import { Endpoints } from '@sentio/runtime'
 import { ServerError, Status } from 'nice-grpc'
 import { AptosClient } from 'aptos-sdk'
+import { MoveAccountContext, MoveContext } from '../move/index.js'
 
-export class AptosContext extends BaseContext {
-  address: string
-  network: AptosNetwork
+export class AptosContext extends MoveContext<AptosNetwork, MoveModuleBytecode, Event | MoveResource> {
   moduleName: string
   version: bigint
   transaction: Transaction_UserTransaction
@@ -41,6 +40,10 @@ export class AptosContext extends BaseContext {
     return this.network
   }
 
+  getTimestamp(): number {
+    return parseInt(this.transaction.timestamp)
+  }
+
   getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
     return {
       address: this.address,
@@ -56,9 +59,7 @@ export class AptosContext extends BaseContext {
   }
 }
 
-export class AptosResourcesContext extends BaseContext {
-  address: string
-  network: AptosNetwork
+export class AptosResourcesContext extends MoveAccountContext<AptosNetwork, MoveModuleBytecode, Event | MoveResource> {
   version: bigint
   timestampInMicros: number
   coder: MoveCoder
@@ -76,6 +77,10 @@ export class AptosResourcesContext extends BaseContext {
     return this.network
   }
 
+  getTimestamp(): number {
+    return this.timestampInMicros
+  }
+
   getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
     return {
       address: this.address,

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

@@ -1,236 +1,46 @@
-import { Gauge } from '@sentio/sdk'
 import { BigDecimal } from '@sentio/bigdecimal'
 import { calculateValueInUsd, getCoinInfo, whitelistCoins, whiteListed } from './coin.js'
-import { AptosResourcesContext, TypedMoveResource, MoveResource, AptosContext } from '@sentio/sdk/aptos'
-import { TypeDescriptor } from '../../move/index.js'
-
-export interface PoolAdaptor<T> {
-  getXReserve(pool: T): bigint
-  getYReserve(pool: T): bigint
-  getExtraPoolTags(pool: TypedMoveResource<T>): any
-  poolType: TypeDescriptor<T>
-}
-
-export class AptosDex<T> {
-  poolAdaptor: PoolAdaptor<T>
-  volume: Gauge
-  volumeByCoin: Gauge
-  tvlAll: Gauge
-  tvlByPool: Gauge
-  tvlByCoin: Gauge
-
-  constructor(
-    volume: Gauge,
-    volumeByCoin: Gauge,
-    tvlAll: Gauge,
-    tvlByCoin: Gauge,
-    tvlByPool: Gauge,
-    poolAdaptor: PoolAdaptor<T>
-  ) {
-    this.volume = volume
-    this.volumeByCoin = volumeByCoin
-    this.tvlAll = tvlAll
-    this.tvlByPool = tvlByPool
-    this.tvlByCoin = tvlByCoin
-    this.poolAdaptor = poolAdaptor
+import {
+  AptosResourcesContext,
+  MoveResource,
+  AptosContext,
+  AptosNetwork,
+  MoveModuleBytecode,
+  Event,
+} from '@sentio/sdk/aptos'
+import { MoveCoinList, MoveDex, MovePoolAdaptor, SimpleCoinInfo } from '../../move/ext/index.js'
+
+export type PoolAdaptor<T> = MovePoolAdaptor<MoveResource, T>
+
+export class CoinList implements MoveCoinList {
+  calculateValueInUsd(amount: bigint, coinInfo: SimpleCoinInfo, timestamp: number): Promise<BigDecimal> {
+    return calculateValueInUsd(amount, coinInfo, timestamp)
   }
 
-  async recordTradingVolume(
-    ctx: AptosContext,
-    coinx: string,
-    coiny: string,
-    coinXAmount: bigint,
-    coinYAmount: bigint,
-    extraLabels?: any
-  ): Promise<BigDecimal> {
-    let result = BigDecimal(0)
-
-    const whitelistx = whiteListed(coinx)
-    const whitelisty = whiteListed(coiny)
-    if (!whitelistx && !whitelisty) {
-      return result
-    }
-    const coinXInfo = await getCoinInfo(coinx)
-    const coinYInfo = await getCoinInfo(coiny)
-    const timestamp = ctx.transaction.timestamp
-    let resultX = BigDecimal(0)
-    let resultY = BigDecimal(0)
-    const pair = await getPair(coinx, coiny)
-    const baseLabels: Record<string, string> = extraLabels ? { ...extraLabels, pair } : { pair }
-    if (whitelistx) {
-      resultX = await calculateValueInUsd(coinXAmount, coinXInfo, timestamp)
-    }
-    if (whitelisty) {
-      resultY = await 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
+  getCoinInfo(type: string): SimpleCoinInfo {
+    return getCoinInfo(type)
   }
 
-  async syncPools(
-    resources: MoveResource[],
-    ctx: AptosResourcesContext,
-    poolsHandler?: (pools: TypedMoveResource<T>[]) => Promise<void> | void
-  ) {
-    const pools = await ctx.coder.filterAndDecodeResources(this.poolAdaptor.poolType, resources)
-
-    const volumeByCoin = new Map<string, BigDecimal>()
-    const timestamp = ctx.timestampInMicros
-
-    console.log('num of pools: ', pools.length, ctx.version.toString())
-
-    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 = whiteListed(coinx)
-      const whitelisty = whiteListed(coiny)
-      if (!whitelistx && !whitelisty) {
-        continue
-      }
-
-      const pair = await getPair(coinx, coiny)
-      const extraLabels = this.poolAdaptor.getExtraPoolTags(pool)
-      const baseLabels: Record<string, string> = { ...extraLabels, pair }
-
-      const coinXInfo = await getCoinInfo(coinx)
-      const coinYInfo = await 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 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 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 = 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,
-        })
-      }
-    }
+  whiteListed(type: string): boolean {
+    return whiteListed(type)
   }
-}
 
-export async function getPair(coinx: string, coiny: string): Promise<string> {
-  const coinXInfo = await getCoinInfo(coinx)
-  const coinYInfo = await getCoinInfo(coiny)
-  if (coinXInfo.symbol.localeCompare(coinYInfo.symbol) > 0) {
-    return `${coinYInfo.symbol}-${coinXInfo.symbol}`
+  whitelistCoins(): Map<string, SimpleCoinInfo> {
+    return whitelistCoins()
   }
-  return `${coinXInfo.symbol}-${coinYInfo.symbol}`
 }
 
-export async function getPairValue(
-  ctx: AptosContext,
-  coinx: string,
-  coiny: string,
-  coinXAmount: bigint,
-  coinYAmount: bigint
-): Promise<BigDecimal> {
-  const whitelistx = whiteListed(coinx)
-  const whitelisty = whiteListed(coiny)
-  const coinXInfo = await getCoinInfo(coinx)
-  const coinYInfo = await getCoinInfo(coiny)
-  const timestamp = ctx.transaction.timestamp
-  let result = BigDecimal(0.0)
-
-  if (!whitelistx || !whitelisty) {
-    return result
-  }
-
-  if (whitelistx) {
-    const value = await calculateValueInUsd(coinXAmount, coinXInfo, timestamp)
-    result = value
-
-    if (!whitelisty) {
-      result = result.plus(value)
-    }
-  }
-  if (whitelisty) {
-    const value = await calculateValueInUsd(coinYAmount, coinYInfo, timestamp)
-
-    if (!whitelistx) {
-      result = result.plus(value)
-    }
-  }
-
-  return result
+export const AptosCoinList = new CoinList()
+
+export class AptosDex<T> extends MoveDex<
+  AptosNetwork,
+  MoveModuleBytecode,
+  MoveResource,
+  Event,
+  AptosContext,
+  AptosResourcesContext,
+  T
+> {
+  coinList = new CoinList()
+  declare poolAdaptor: PoolAdaptor<T>
 }

package/src/aptos/ext/coin.ts

@@ -3,16 +3,10 @@ import fetch from 'node-fetch'
 import { validateAndNormalizeAddress } from '../utils.js'
 import { SPLITTER } from '../../move/index.js'
 import { AptosChainId } from '../../core/chain.js'
+import { SimpleCoinInfo } from '../../move/ext/move-dex.js'
 
 const WHITELISTED_COINS = new Map<string, SimpleCoinInfo>()
 
-export interface SimpleCoinInfo {
-  token_type: { type: string; account_address: string }
-  symbol: string
-  decimals: number
-  bridge: string
-}
-
 export async function initCoinList() {
   let list = DEFAULT_LIST
   try {
@@ -81,10 +75,7 @@ export async function getPrice(coinType: string, timestamp: number): Promise<num
   }
 }
 
-export async function calculateValueInUsd(n: bigint, coinInfo: SimpleCoinInfo, timestamp: number | string) {
-  if (typeof timestamp === 'string') {
-    timestamp = parseInt(timestamp)
-  }
+export async function calculateValueInUsd(n: bigint, coinInfo: SimpleCoinInfo, timestamp: number) {
   const price = await getPrice(coinInfo.token_type.type, timestamp)
   const amount = n.scaleDown(coinInfo.decimals)
   return amount.multipliedBy(price)

package/src/core/chain.ts

@@ -44,6 +44,7 @@ export enum EthChainId {
   KUCOIN = '321',
   ZKSYNC_ERA = '324',
   SHIDEN = '336',
+  CRONOS_TESTNET = '338',
   THETA = '361',
   SX = '416',
   CANDLE = '534',

package/src/move/abstract-move-coder.ts

@@ -270,7 +270,7 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
     return this.decodeArray(res, f.return)
   }
 
-  protected async filterAndDecodeStruct<T, ST extends StructType>(
+  async filterAndDecodeStruct<T, ST extends StructType>(
     typeMatcher: TypeDescriptor<T>,
     structsWithTags: ST[]
   ): Promise<DecodedStruct<ST, T>[]> {

package/src/move/ext/coin-list.ts

@@ -0,0 +1,9 @@
+import { BigDecimal } from '@sentio/bigdecimal'
+import { SimpleCoinInfo } from './move-dex.js'
+
+export interface MoveCoinList {
+  whiteListed(type: string): boolean
+  whitelistCoins(): Map<string, SimpleCoinInfo>
+  getCoinInfo(type: string): SimpleCoinInfo
+  calculateValueInUsd(amount: bigint, coinInfo: SimpleCoinInfo, timestamp: number): Promise<BigDecimal>
+}

package/src/move/ext/index.ts

@@ -0,0 +1,2 @@
+export * from './coin-list.js'
+export * from './move-dex.js'

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
+}