@sentio/sdk 2.13.0-rc.1 → 2.13.0-rc.10

package/src/aptos/codegen/codegen.ts

@@ -1,76 +1,32 @@
 import * as fs from 'fs'
-import { MoveModuleBytecode, toInternalModule } from '../move-types.js'
-import { moduleQname, SPLITTER, TypeDescriptor } from '../../move/index.js'
+import { Event, MoveModuleBytecode, MoveResource } from '../move-types.js'
 import chalk from 'chalk'
 import { AptosNetwork } from '../network.js'
-import { AptosClient } from 'aptos-sdk'
-import { getMeaningfulFunctionParams } from '../utils.js'
-import { InternalMoveModule, InternalMoveStruct } from '../../move/internal-models.js'
+import { join } from 'path'
+import { AptosChainAdapter } from '../aptos-chain-adapter.js'
 import { AbstractCodegen } from '../../move/abstract-codegen.js'
-import {join} from "path";
 
-export async function codegen(abisDir: string, outDir = join('src', 'types', 'aptos'), genExample = false) {
+export async function codegen(
+  abisDir: string,
+  outDir = join('src', 'types', 'aptos'),
+  genExample = false,
+  builtin = false
+) {
   if (!fs.existsSync(abisDir)) {
     return
   }
   const gen = new AptosCodegen()
-  const numFiles = await gen.generate(abisDir, outDir)
+  const numFiles = await gen.generate(abisDir, outDir, builtin)
   console.log(chalk.green(`Generated ${numFiles} for Aptos`))
 }
 
-function getRpcEndpoint(network: AptosNetwork): string {
-  switch (network) {
-    case AptosNetwork.TEST_NET:
-      return 'https://testnet.aptoslabs.com/'
-  }
-  return 'https://mainnet.aptoslabs.com/'
-}
-
-function getRpcClient(network: AptosNetwork): AptosClient {
-  return new AptosClient(getRpcEndpoint(network))
-}
-
-class AptosCodegen extends AbstractCodegen<MoveModuleBytecode[], AptosNetwork> {
+class AptosCodegen extends AbstractCodegen<AptosNetwork, MoveModuleBytecode, Event | MoveResource> {
   ADDRESS_TYPE = 'Address'
   MAIN_NET = AptosNetwork.MAIN_NET
   TEST_NET = AptosNetwork.TEST_NET
   PREFIX = 'Aptos'
 
-  async fetchModules(account: string, network: AptosNetwork): Promise<MoveModuleBytecode[]> {
-    const client = getRpcClient(network)
-    return await client.getAccountModules(account)
-  }
-
-  toInternalModules(modules: MoveModuleBytecode[]): InternalMoveModule[] {
-    return modules.flatMap((m) => (m.abi ? [toInternalModule(m)] : []))
-  }
-
-  getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
-    return getMeaningfulFunctionParams(params)
-  }
-
-  getEventStructs(module: InternalMoveModule) {
-    const qname = moduleQname(module)
-    const structMap = new Map<string, InternalMoveStruct>()
-    const eventMap = new Map<string, InternalMoveStruct>()
-
-    for (const struct of module.structs) {
-      structMap.set(qname + SPLITTER + struct.name, struct)
-    }
-
-    for (const struct of module.structs) {
-      for (const field of struct.fields) {
-        const t = field.type
-        if (t.qname === '0x1::event::EventHandle') {
-          const event = t.typeArgs[0].qname
-          const eventStruct = structMap.get(event)
-          if (eventStruct) {
-            eventMap.set(event, eventStruct)
-          }
-        }
-      }
-    }
-
-    return eventMap
+  constructor() {
+    super(AptosChainAdapter.INSTANCE)
   }
 }

package/src/aptos/codegen/run.ts

@@ -6,7 +6,7 @@ if (process.argv.length > 3) {
   const abisDir = process.argv[2]
   const targetDir = process.argv[3]
 
-  await codegen(abisDir, targetDir)
+  await codegen(abisDir, targetDir, false, true)
 } else {
   console.error('Not enough argument')
   process.exit(1)

package/src/aptos/context.ts

@@ -2,6 +2,7 @@ import { RecordMetaData } from '@sentio/protos'
 import { type Labels, BaseContext, normalizeLabels } from '@sentio/sdk'
 import { Transaction_UserTransaction } from './move-types.js'
 import { AptosNetwork, getChainId } from './network.js'
+import { defaultMoveCoder, MoveCoder } from './move-coder.js'
 
 export class AptosContext extends BaseContext {
   address: string
@@ -10,6 +11,7 @@ export class AptosContext extends BaseContext {
   version: bigint
   transaction: Transaction_UserTransaction
   eventIndex: number
+  coder: MoveCoder
 
   constructor(
     moduleName: string,
@@ -25,6 +27,7 @@ export class AptosContext extends BaseContext {
     this.moduleName = moduleName
     this.version = version
     this.eventIndex = eventIndex
+    this.coder = defaultMoveCoder(network)
     if (transaction) {
       this.transaction = transaction
     }
@@ -54,6 +57,7 @@ export class AptosResourcesContext extends BaseContext {
   network: AptosNetwork
   version: bigint
   timestampInMicros: number
+  coder: MoveCoder
 
   constructor(network: AptosNetwork, address: string, version: bigint, timestampInMicros: number) {
     super()
@@ -61,6 +65,7 @@ export class AptosResourcesContext extends BaseContext {
     this.network = network
     this.version = version
     this.timestampInMicros = timestampInMicros
+    this.coder = defaultMoveCoder(network)
   }
 
   getChainId(): string {

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

@@ -1,19 +1,14 @@
 import { Gauge } from '@sentio/sdk'
 import { BigDecimal } from '@sentio/bigdecimal'
 import { calculateValueInUsd, getCoinInfo, whitelistCoins, whiteListed } from './coin.js'
-import {
-  AptosResourcesContext,
-  TypedMoveResource,
-  MoveResource,
-  defaultMoveCoder,
-  AptosContext,
-} from '@sentio/sdk/aptos'
+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
-  poolTypeName: string
+  poolType: TypeDescriptor<T>
 }
 
 export class AptosDex<T> {
@@ -104,10 +99,7 @@ export class AptosDex<T> {
     ctx: AptosResourcesContext,
     poolsHandler?: (pools: TypedMoveResource<T>[]) => Promise<void> | void
   ) {
-    const pools: TypedMoveResource<T>[] = defaultMoveCoder().filterAndDecodeResources(
-      this.poolAdaptor.poolTypeName,
-      resources
-    )
+    const pools = await ctx.coder.filterAndDecodeResources(this.poolAdaptor.poolType, resources)
 
     const volumeByCoin = new Map<string, BigDecimal>()
     const timestamp = ctx.timestampInMicros

package/src/aptos/index.ts

@@ -8,3 +8,5 @@ export * from './api.js'
 export { ModuleClient } from './module-client.js'
 
 export { AptosPlugin } from './aptos-plugin.js'
+
+export { BUILTIN_TYPES } from '../move/types.js'

package/src/aptos/models.ts

@@ -1,17 +1,12 @@
 import { Event, MoveResource, TransactionPayload_EntryFunctionPayload } from './move-types.js'
+import { DecodedStruct } from '../move/types.js'
 
 export type EventInstance = Event & {
   version: string
 }
 
-export type TypedEventInstance<T> = EventInstance & {
-  /**
-   * decoded data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
-   */
-  data_decoded: T
-
-  type_arguments: string[]
-}
+export type TypedEventInstance<T> = DecodedStruct<EventInstance, T>
+export type TypedMoveResource<T> = DecodedStruct<MoveResource, T>
 
 // Don't use intermediate type to make IDE happier
 export type TypedFunctionPayload<T extends Array<any>> = TransactionPayload_EntryFunctionPayload & {
@@ -20,8 +15,3 @@ export type TypedFunctionPayload<T extends Array<any>> = TransactionPayload_Entr
    */
   arguments_decoded: T
 }
-
-export type TypedMoveResource<T> = MoveResource & {
-  data_decoded: T
-  type_arguments: string[]
-}

package/src/aptos/module-client.ts

@@ -17,7 +17,7 @@ export class ModuleClient {
     ledger_version?: bigint
   ): Promise<any[]> {
     const coder = defaultMoveCoder()
-    const encodedArgs = coder.encodeCallArgs(args, func)
+    const encodedArgs = await coder.encodeCallArgs(args, func)
 
     const request: Types.ViewRequest = {
       function: func,

package/src/aptos/move-coder.ts

@@ -6,43 +6,62 @@ import {
   TransactionPayload_EntryFunctionPayload,
 } from './move-types.js'
 
-import { TypedEventInstance, TypedMoveResource, TypedFunctionPayload } from './models.js'
-import { getMeaningfulFunctionParams } from './utils.js'
+import { TypedEventInstance, TypedFunctionPayload, TypedMoveResource } from './models.js'
 import { AbstractMoveCoder } from '../move/abstract-move-coder.js'
-import { TypeDescriptor } from '../move/index.js'
+import { AptosNetwork } from './network.js'
+import { AptosChainAdapter } from './aptos-chain-adapter.js'
+import { parseMoveType, TypeDescriptor } from '../move/index.js'
+
+export class MoveCoder extends AbstractMoveCoder<AptosNetwork, MoveModuleBytecode, Event | MoveResource> {
+  constructor(network: AptosNetwork) {
+    super(network)
+    this.adapter = new AptosChainAdapter()
+  }
 
-export class MoveCoder extends AbstractMoveCoder<Event | MoveResource> {
   load(module: MoveModuleBytecode) {
     if (!module.abi) {
       throw Error('Module without abi')
     }
-    if (this.contains(module.abi.address, module.abi.name)) {
-      return
+    let m = this.moduleMapping.get(module.abi.address + '::' + module.abi.name)
+    // if (this.contains(module.abi.address, module.abi.name)) {
+    //   return
+    // }
+    if (m) {
+      return m
     }
-    this.loadInternal(toInternalModule(module))
+    m = toInternalModule(module)
+    this.loadInternal(m)
+    return m
   }
 
-  decodeEvent<T>(event: Event): TypedEventInstance<T> | undefined {
-    return this.decodedStruct<T>(event) as TypedEventInstance<T>
+  decodeEvent<T>(event: Event): Promise<TypedEventInstance<T> | undefined> {
+    return this.decodedStruct<T>(event) as any
   }
-  filterAndDecodeEvents<T>(typeQname: string, resources: Event[]): TypedEventInstance<T>[] {
-    return this.filterAndDecodeStruct(typeQname, resources) as TypedEventInstance<T>[]
+  filterAndDecodeEvents<T>(type: string | TypeDescriptor<T>, resources: Event[]): Promise<TypedEventInstance<T>[]> {
+    if (typeof type === 'string') {
+      type = parseMoveType(type)
+    }
+    return this.filterAndDecodeStruct(type, resources) as any
   }
-  decodeResource<T>(res: MoveResource): TypedMoveResource<T> | undefined {
+  decodeResource<T>(res: MoveResource): Promise<TypedMoveResource<T> | undefined> {
     return this.decodedStruct<T>(res)
   }
-  filterAndDecodeResources<T>(typeQname: string, resources: MoveResource[]): TypedMoveResource<T>[] {
-    return this.filterAndDecodeStruct(typeQname, resources) as any
-  }
-
-  getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
-    return getMeaningfulFunctionParams(params)
+  filterAndDecodeResources<T>(
+    type: string | TypeDescriptor<T>,
+    resources: MoveResource[]
+  ): Promise<TypedMoveResource<T>[]> {
+    if (typeof type === 'string') {
+      type = parseMoveType(type)
+    }
+    return this.filterAndDecodeStruct(type, resources)
   }
 
-  decodeFunctionPayload(payload: TransactionPayload_EntryFunctionPayload): TransactionPayload_EntryFunctionPayload {
-    const func = this.getMoveFunction(payload.function)
-    const params = getMeaningfulFunctionParams(func.params)
-    const argumentsDecoded = this.decodeArray(payload.arguments, params)
+  async decodeFunctionPayload(
+    payload: TransactionPayload_EntryFunctionPayload
+  ): Promise<TransactionPayload_EntryFunctionPayload> {
+    const func = await this.getMoveFunction(payload.function)
+    const params = this.adapter.getMeaningfulFunctionParams(func.params)
+    const argumentsDecoded = await this.decodeArray(payload.arguments, params)
 
     return {
       ...payload,
@@ -51,8 +70,12 @@ export class MoveCoder extends AbstractMoveCoder<Event | MoveResource> {
   }
 }
 
-export const MOVE_CODER = new MoveCoder()
+const MOVE_CODER = new MoveCoder(AptosNetwork.MAIN_NET)
+const TESTNET_MOVE_CODER = new MoveCoder(AptosNetwork.TEST_NET)
 
-export function defaultMoveCoder(): MoveCoder {
-  return MOVE_CODER
+export function defaultMoveCoder(network: AptosNetwork = AptosNetwork.MAIN_NET): MoveCoder {
+  if (network == AptosNetwork.MAIN_NET) {
+    return MOVE_CODER
+  }
+  return TESTNET_MOVE_CODER
 }

package/src/eth/base-processor-template.ts

@@ -30,6 +30,7 @@ export abstract class BaseProcessorTemplate<
     handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
     blockInterval?: HandleInterval
     timeIntervalInMinutes?: HandleInterval
+    fetchConfig?: EthFetchConfig
   }[] = []
   traceHandlers: {
     signature: string
@@ -64,7 +65,7 @@ export abstract class BaseProcessorTemplate<
       processor.onTrace(th.signature, th.handler, th.fetchConfig)
     }
     for (const bh of this.blockHandlers) {
-      processor.onInterval(bh.handler, bh.timeIntervalInMinutes, bh.blockInterval)
+      processor.onInterval(bh.handler, bh.timeIntervalInMinutes, bh.blockInterval, bh.fetchConfig)
     }
 
     const instance: TemplateInstance = {
@@ -103,32 +104,41 @@ export abstract class BaseProcessorTemplate<
   public onBlockInterval(
     handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     blockInterval = 1000,
-    backfillBlockInterval = 4000
+    backfillBlockInterval = 4000,
+    fetchConfig?: EthFetchConfig
   ) {
-    return this.onInterval(handler, undefined, {
-      recentInterval: blockInterval,
-      backfillInterval: backfillBlockInterval,
-    })
+    return this.onInterval(
+      handler,
+      undefined,
+      {
+        recentInterval: blockInterval,
+        backfillInterval: backfillBlockInterval,
+      },
+      fetchConfig
+    )
   }
 
   public onTimeInterval(
     handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
-    backfillBlockInterval = 240
+    backfillBlockInterval = 240,
+    fetchConfig?: EthFetchConfig
   ) {
     return this.onInterval(
       handler,
       { recentInterval: timeIntervalInMinutes, backfillInterval: backfillBlockInterval },
-      undefined
+      undefined,
+      fetchConfig
     )
   }
 
   public onInterval(
     handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
-    blockInterval: HandleInterval | undefined
+    blockInterval: HandleInterval | undefined,
+    fetchConfig: EthFetchConfig | undefined
   ) {
-    this.blockHandlers.push({ handler, timeIntervalInMinutes: timeInterval, blockInterval: blockInterval })
+    this.blockHandlers.push({ handler, timeIntervalInMinutes: timeInterval, blockInterval, fetchConfig })
     return this
   }
 

package/src/eth/base-processor.ts

@@ -1,5 +1,5 @@
 import { BaseContract, DeferredTopicFilter, TransactionResponseParams } from 'ethers'
-import { BlockParams, Network } from 'ethers/providers'
+import { Network } from 'ethers/providers'
 
 import { BoundContractView, ContractContext, ContractView, GlobalContext } from './context.js'
 import {
@@ -15,8 +15,7 @@ import {
 import { BindOptions } from './bind-options.js'
 import { PromiseOrVoid } from '../core/promises.js'
 import { ServerError, Status } from 'nice-grpc'
-import { fixEmptyKey, TypedEvent, TypedCallTrace, formatEthData } from './eth.js'
-import * as console from 'console'
+import { fixEmptyKey, TypedEvent, TypedCallTrace, formatEthData, RichBlock } from './eth.js'
 import { getNetworkFromCtxOrNetworkish } from './provider.js'
 import sha3 from 'js-sha3'
 import { ListStateStorage } from '@sentio/runtime'
@@ -42,6 +41,7 @@ export class BlockHandler {
   blockInterval?: HandleInterval
   timeIntervalInMinutes?: HandleInterval
   handler: (block: Data_EthBlock) => Promise<ProcessResult>
+  fetchConfig: EthFetchConfig
 }
 
 export class TransactionHandler {
@@ -88,25 +88,33 @@ export class GlobalProcessor {
   }
 
   public onBlockInterval(
-    handler: (block: BlockParams, ctx: GlobalContext) => PromiseOrVoid,
+    handler: (block: RichBlock, ctx: GlobalContext) => PromiseOrVoid,
     blockInterval = 250,
-    backfillBlockInterval = 1000
+    backfillBlockInterval = 1000,
+    fetchConfig?: Partial<EthFetchConfig>
   ): this {
-    return this.onInterval(handler, undefined, {
-      recentInterval: blockInterval,
-      backfillInterval: backfillBlockInterval,
-    })
+    return this.onInterval(
+      handler,
+      undefined,
+      {
+        recentInterval: blockInterval,
+        backfillInterval: backfillBlockInterval,
+      },
+      fetchConfig
+    )
   }
 
   public onTimeInterval(
-    handler: (block: BlockParams, ctx: GlobalContext) => PromiseOrVoid,
+    handler: (block: RichBlock, ctx: GlobalContext) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
-    backfillTimeIntervalInMinutes = 240
+    backfillTimeIntervalInMinutes = 240,
+    fetchConfig?: Partial<EthFetchConfig>
   ): this {
     return this.onInterval(
       handler,
       { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
-      undefined
+      undefined,
+      fetchConfig
     )
   }
 
@@ -115,9 +123,10 @@ export class GlobalProcessor {
   }
 
   public onInterval(
-    handler: (block: BlockParams, ctx: GlobalContext) => PromiseOrVoid,
+    handler: (block: RichBlock, ctx: GlobalContext) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
-    blockInterval: HandleInterval | undefined
+    blockInterval: HandleInterval | undefined,
+    fetchConfig: Partial<EthFetchConfig> | undefined
   ): this {
     const chainId = this.getChainId()
 
@@ -135,6 +144,7 @@ export class GlobalProcessor {
       },
       timeIntervalInMinutes: timeInterval,
       blockInterval: blockInterval,
+      fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {}),
     })
     return this
   }
@@ -245,32 +255,41 @@ export abstract class BaseProcessor<
   }
 
   public onBlockInterval(
-    handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    handler: (block: RichBlock, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     blockInterval = 250,
-    backfillBlockInterval = 1000
+    backfillBlockInterval = 1000,
+    fetchConfig?: Partial<EthFetchConfig>
   ): this {
-    return this.onInterval(handler, undefined, {
-      recentInterval: blockInterval,
-      backfillInterval: backfillBlockInterval,
-    })
+    return this.onInterval(
+      handler,
+      undefined,
+      {
+        recentInterval: blockInterval,
+        backfillInterval: backfillBlockInterval,
+      },
+      fetchConfig
+    )
   }
 
   public onTimeInterval(
-    handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    handler: (block: RichBlock, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
-    backfillTimeIntervalInMinutes = 240
+    backfillTimeIntervalInMinutes = 240,
+    fetchConfig?: Partial<EthFetchConfig>
   ): this {
     return this.onInterval(
       handler,
       { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
-      undefined
+      undefined,
+      fetchConfig
     )
   }
 
   public onInterval(
-    handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    handler: (block: RichBlock, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
-    blockInterval: HandleInterval | undefined
+    blockInterval: HandleInterval | undefined,
+    fetchConfig: Partial<EthFetchConfig> | undefined
   ): this {
     const chainId = this.getChainId()
     const processor = this
@@ -300,6 +319,7 @@ export abstract class BaseProcessor<
       },
       timeIntervalInMinutes: timeInterval,
       blockInterval: blockInterval,
+      fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {}),
     })
     return this
   }

package/src/eth/eth-plugin.ts

@@ -62,6 +62,7 @@ export class EthPlugin extends Plugin {
           minutes: 0,
           minutesInterval: blockHandler.timeIntervalInMinutes,
           handlerId: handlerId,
+          fetchConfig: blockHandler.fetchConfig,
         })
       }
 
@@ -140,6 +141,7 @@ export class EthPlugin extends Plugin {
           minutes: 0,
           minutesInterval: blockHandler.timeIntervalInMinutes,
           handlerId: handlerId,
+          fetchConfig: blockHandler.fetchConfig,
         })
       }
 

package/src/eth/eth.ts

@@ -11,7 +11,7 @@ import {
   object,
   formatData,
 } from 'ethers/providers'
-import { CallExceptionError, LogDescription, Result, DeferredTopicFilter } from 'ethers'
+import { CallExceptionError, LogDescription, Result, DeferredTopicFilter, BlockParams } from 'ethers'
 import { ContractContext } from './context.js'
 import { getAddress } from 'ethers/address'
 import { getBigInt, getNumber, hexlify } from 'ethers/utils'
@@ -34,6 +34,11 @@ export interface TypedEvent<TArgsArray extends Array<any> = any, TArgsObject = a
 
 export type TypedEventFilter<_TEvent extends TypedEvent> = DeferredTopicFilter
 
+export interface RichBlock extends BlockParams {
+  traces?: Trace[]
+  transactionReceipts?: TransactionReceiptParams[]
+}
+
 export class SimpleEthersError extends Error {
   e: Error
 
@@ -132,7 +137,7 @@ export function formatEthData(data: {
   if (data.block && !data.block.transactions) {
     data.block.transactions = []
   }
-  const block = data.block ? formatBlock(data.block) : undefined
+  const block = data.block ? formatRichBlock(data.block) : undefined
   const trace = data.trace ? (data.trace as Trace) : undefined
   const transaction = data.transaction ? formatTransactionResponse(data.transaction) : undefined
   const transactionReceipt = data.transactionReceipt ? formatTransactionReceipt(data.transactionReceipt) : undefined
@@ -145,6 +150,14 @@ export function formatEthData(data: {
   }
 }
 
+export function formatRichBlock(block: RichBlock): RichBlock {
+  formatBlock(block)
+  if (block.transactionReceipts) {
+    block.transactionReceipts = block.transactionReceipts.map((t) => formatTransactionReceipt(t))
+  }
+  return block
+}
+
 export interface TypedCallTrace<TArgsArray extends Array<any> = any, TArgsObject = any> extends Trace {
   args: TArgsObject & IResult
   name: string