@sentio/sdk 2.3.6-rc.1 → 2.4.0

package/src/testing/sui-facet.ts

@@ -0,0 +1,119 @@
+import { DataBinding, HandlerType } from '@sentio/protos'
+import { getChainId } from '../sui/network.js'
+import { TestProcessorServer } from './test-processor-server.js'
+import { parseMoveType } from '../aptos/types.js'
+import { SuiNetwork } from '../sui/index.js'
+import { MoveEvent, SuiTransactionResponse, MoveCall } from '@mysten/sui.js'
+import { getMoveCalls } from '../sui/utils.js'
+
+export class SuiFacet {
+  server: TestProcessorServer
+  constructor(server: TestProcessorServer) {
+    this.server = server
+  }
+
+  testEntryFunctionCall(transaction: SuiTransactionResponse, network: SuiNetwork = SuiNetwork.MAIN_NET) {
+    return this.testEntryFunctionCalls([transaction], network)
+  }
+
+  testEntryFunctionCalls(transactions: SuiTransactionResponse[], network: SuiNetwork = SuiNetwork.MAIN_NET) {
+    const bindings = []
+    for (const trans of transactions) {
+      const binding = this.buildEntryFunctionCallBinding(trans, network)
+      if (!binding) {
+        throw Error('Invalid test transaction: ' + JSON.stringify(trans))
+      }
+      bindings.push(binding)
+    }
+    return this.server.processBindings({
+      bindings: bindings,
+    })
+  }
+
+  private buildEntryFunctionCallBinding(
+    transaction: SuiTransactionResponse,
+    network: SuiNetwork = SuiNetwork.MAIN_NET
+  ): DataBinding | undefined {
+    const calls: MoveCall[] = getMoveCalls(transaction)
+    if (calls.length !== 1) {
+      throw Error('Transaction has more than one calls')
+    }
+    const functionType = calls[0].package.objectId + calls[0].module + calls[0].function
+
+    for (const config of this.server.contractConfigs) {
+      if (config.contract?.chainId !== getChainId(network)) {
+        continue
+      }
+      for (const callConfig of config.moveCallConfigs) {
+        for (const callFilter of callConfig.filters) {
+          if (config.contract.address + '::' + callFilter.function === functionType) {
+            return {
+              data: {
+                suiCall: {
+                  transaction,
+                  timestamp: new Date(),
+                  slot: 10000n,
+                },
+              },
+              handlerIds: [callConfig.handlerId],
+              handlerType: HandlerType.SUI_CALL,
+            }
+          }
+        }
+      }
+    }
+    return undefined
+  }
+
+  testEvent(transaction: SuiTransactionResponse, event: number | MoveEvent, network: SuiNetwork = SuiNetwork.MAIN_NET) {
+    if (typeof event !== 'number') {
+      const transaction2: SuiTransactionResponse = {} as any
+      Object.assign(transaction2, transaction)
+      transaction = transaction2
+      transaction.effects.events = [event]
+      event = 0
+    }
+    const binding = this.buildEventBinding(transaction, event, network)
+    if (!binding) {
+      throw Error('Invalid test event: ' + JSON.stringify(transaction))
+    }
+    return this.server.processBinding(binding)
+  }
+
+  private buildEventBinding(
+    transaction: SuiTransactionResponse,
+    eventIdx: number,
+    network: SuiNetwork = SuiNetwork.MAIN_NET
+  ): DataBinding | undefined {
+    // const allEvents = new Set(transaction.events.map(e => e.type))
+    const event = transaction.effects.events?.[eventIdx]
+    if (!event || !event.moveEvent) {
+      throw Error('Invaild test transaction, no event located')
+    }
+
+    for (const config of this.server.contractConfigs) {
+      if (config.contract?.chainId !== getChainId(network)) {
+        continue
+      }
+      for (const eventConfig of config.moveEventConfigs) {
+        for (const eventFilter of eventConfig.filters) {
+          if (config.contract.address + '::' + eventFilter.type === parseMoveType(event.moveEvent.type).qname) {
+            transaction.effects.events = [event]
+            return {
+              data: {
+                suiEvent: {
+                  transaction,
+                  timestamp: new Date(transaction.timestamp_ms || 0),
+                  slot: 10000n,
+                },
+              },
+              handlerIds: [eventConfig.handlerId],
+              handlerType: HandlerType.SUI_EVENT,
+            }
+          }
+        }
+      }
+    }
+    return undefined
+  }
+}

package/src/testing/test-processor-server.ts

@@ -2,30 +2,27 @@ import {
   AccountConfig,
   ContractConfig,
   DataBinding,
-  HandlerType,
-  Data_SolInstruction,
+  Empty,
   ProcessBindingResponse,
   ProcessBindingsRequest,
   ProcessConfigRequest,
   ProcessConfigResponse,
   ProcessorServiceImplementation,
   StartRequest,
-  Empty,
 } from '@sentio/protos'
 import { CallContext } from 'nice-grpc-common'
-import { ProcessorServiceImpl, Endpoints, State } from '@sentio/runtime'
+import { Endpoints, ProcessorServiceImpl, State } from '@sentio/runtime'
 import { CHAIN_MAP } from '../core/chain.js'
 
-import { Trace } from '../eth/trace.js'
-import { LogParams, Networkish, BlockParams, Network } from 'ethers/providers'
-
-import { Block, Log } from 'ethers'
+import { AptosFacet } from './aptos-facet.js'
+import { SolanaFacet } from './solana-facet.js'
+import { EthFacet } from './eth-facet.js'
+import { SuiFacet } from './sui-facet.js'
 
 export const TEST_CONTEXT: CallContext = <CallContext>{}
 
 export function cleanTest() {
   State.reset()
-  // Endpoints.reset()
 }
 
 export class TestProcessorServer implements ProcessorServiceImplementation {
@@ -33,10 +30,19 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
   contractConfigs: ContractConfig[]
   accountConfigs: AccountConfig[]
 
+  aptos: AptosFacet
+  eth: EthFacet
+  solana: SolanaFacet
+  sui: SuiFacet
+
   constructor(loader: () => Promise<any>, httpEndpoints: Record<string, string> = {}) {
     cleanTest()
 
     this.service = new ProcessorServiceImpl(loader)
+    this.aptos = new AptosFacet(this)
+    this.solana = new SolanaFacet(this)
+    this.eth = new EthFacet(this)
+    this.sui = new SuiFacet(this)
 
     for (const k in CHAIN_MAP) {
       const http = httpEndpoints[k] || ''
@@ -60,249 +66,6 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     return this.service.getConfig(request, context)
   }
 
-  // processLogs(request: ProcessBindingsRequest, context = TEST_CONTEXT): Promise<ProcessBindingResponse> {
-  //   return this.service.processLogs(request, context)
-  // }
-  //
-  // processTraces(request: ProcessBindingsRequest, context: CallContext = TEST_CONTEXT): Promise<ProcessBindingResponse> {
-  //   return this.service.processTraces(request, context)
-  // }
-
-  testTrace(trace: Trace, network: Networkish = 1): Promise<ProcessBindingResponse> {
-    return this.testTraces([trace], network)
-  }
-
-  testTraces(traces: Trace[], network: Networkish = 1): Promise<ProcessBindingResponse> {
-    const bindings = []
-    for (const trace of traces) {
-      const binding = this.buildTraceBinding(trace, network)
-      if (!binding) {
-        throw Error('Invalid test trace: ' + JSON.stringify(trace))
-      }
-      bindings.push(binding)
-    }
-    return this.processBindings({
-      bindings: bindings,
-    })
-  }
-
-  buildTraceBinding(trace: Trace, network: Networkish = 1): DataBinding | undefined {
-    if (trace.type !== 'call' || !trace.action.input) {
-      throw Error('Invalid test trace: ' + JSON.stringify(trace))
-    }
-    const signature = trace.action.input.slice(0, 10)
-
-    for (const contract of this.contractConfigs) {
-      if (contract.contract?.chainId !== Network.from(network).chainId.toString()) {
-        continue
-      }
-      if (trace.action.to?.toLowerCase() !== contract.contract?.address.toLowerCase()) {
-        continue
-      }
-      for (const config of contract.traceConfigs) {
-        if (config.signature == signature) {
-          return {
-            data: {
-              ethTrace: {
-                trace,
-                timestamp: new Date(),
-              },
-            },
-            handlerIds: [config.handlerId],
-            handlerType: HandlerType.ETH_TRACE,
-          }
-        }
-      }
-    }
-    return undefined
-  }
-
-  testLog(log: LogParams, network: Networkish = 1): Promise<ProcessBindingResponse> {
-    return this.testLogs([log], network)
-  }
-
-  testLogs(logs: LogParams[], network: Networkish = 1): Promise<ProcessBindingResponse> {
-    const bindings = []
-    for (const log of logs) {
-      const binding = this.buildLogBinding(log, network)
-      if (!binding) {
-        throw Error('Invalid test log: ' + JSON.stringify(log))
-      }
-      bindings.push(binding)
-    }
-    return this.processBindings({
-      bindings: bindings,
-    })
-  }
-
-  buildLogBinding(log: LogParams, network: Networkish = 1): DataBinding | undefined {
-    for (const contract of this.contractConfigs) {
-      if (contract.contract?.chainId !== Network.from(network).chainId.toString()) {
-        continue
-      }
-      if (log.address.toLowerCase() !== contract.contract?.address.toLowerCase()) {
-        continue
-      }
-      for (const config of contract.logConfigs) {
-        for (const filter of config.filters) {
-          // if (filter.topics.length != log.topics.length) {
-          //   continue
-          // }
-
-          let match = true
-          for (const topicIdx in filter.topics) {
-            const logTopic = log.topics[topicIdx]
-            const possibleTopic = filter.topics[topicIdx].hashes
-            if (possibleTopic.length === 0) {
-              // match all
-              continue
-            }
-            if (possibleTopic.find((e) => e.toLowerCase() === logTopic.toLowerCase())) {
-              // find one
-              continue
-            }
-            match = false
-            break
-          }
-          if (match) {
-            return {
-              data: {
-                ethLog: { log, timestamp: new Date() },
-              },
-              handlerIds: [config.handlerId],
-              handlerType: HandlerType.ETH_LOG,
-            }
-          }
-        }
-      }
-    }
-    return undefined
-  }
-  testAccountLog(address: string, log: LogParams, network: Networkish = 1): Promise<ProcessBindingResponse> {
-    return this.testAccountLogs(address, [log], network)
-  }
-
-  testAccountLogs(address: string, logs: LogParams[], network: Networkish = 1): Promise<ProcessBindingResponse> {
-    const bindings = []
-    for (const log of logs) {
-      const binding = this.buildAccountLogBinding(address, log, network)
-      if (!binding) {
-        throw Error('Invalid test log: ' + JSON.stringify(log))
-      }
-      bindings.push(binding)
-    }
-    return this.processBindings({
-      bindings: bindings,
-    })
-  }
-
-  buildAccountLogBinding(address: string, log: LogParams, network: Networkish = 1): DataBinding | undefined {
-    for (const account of this.accountConfigs) {
-      if (account.chainId !== Network.from(network).chainId.toString()) {
-        continue
-      }
-      if (address.toLowerCase() !== account.address.toLowerCase()) {
-        continue
-      }
-      for (const config of account.logConfigs) {
-        for (const filter of config.filters) {
-          // if (filter.topics.length != log.topics.length) {
-          //   continue
-          // }
-
-          let match = true
-          for (const topicIdx in filter.topics) {
-            const logTopic = log.topics[topicIdx]
-            const possibleTopic = filter.topics[topicIdx].hashes
-            if (possibleTopic.length === 0) {
-              // match all
-              continue
-            }
-            if (possibleTopic.find((e) => e.toLowerCase() === logTopic.toLowerCase())) {
-              // find one
-              continue
-            }
-            match = false
-            break
-          }
-          if (match) {
-            return {
-              data: {
-                ethLog: { log, timestamp: new Date() },
-              },
-              handlerIds: [config.handlerId],
-              handlerType: HandlerType.ETH_LOG,
-            }
-          }
-        }
-      }
-    }
-    return undefined
-  }
-
-  testBlock(
-    block: Partial<BlockParams> & { number: number },
-    network: Networkish = 1
-  ): Promise<ProcessBindingResponse> {
-    return this.testBlocks([block], network)
-  }
-
-  testBlocks(blocks: Partial<BlockParams> & { number: number }[], network: Networkish = 1) {
-    const bindings = []
-    for (const block of blocks) {
-      const binding = this.buildBlockBinding(block, network)
-      if (!binding) {
-        throw Error('Invalid test block: ' + JSON.stringify(block))
-      }
-      bindings.push(binding)
-    }
-    return this.processBindings({
-      bindings: bindings,
-    })
-  }
-
-  buildBlockBinding(block: Partial<Block> & { number: number }, network: Networkish = 1): DataBinding {
-    const binding: DataBinding = {
-      data: {
-        ethBlock: { block },
-      },
-      handlerType: HandlerType.ETH_BLOCK,
-      handlerIds: [],
-    }
-    for (const contract of this.contractConfigs) {
-      if (contract.contract?.chainId !== Network.from(network).chainId.toString()) {
-        continue
-      }
-      const longBlockNumber = block.number
-      if (longBlockNumber < contract.startBlock) {
-        continue
-      }
-      if (contract.endBlock !== 0n && longBlockNumber >= contract.endBlock) {
-        continue
-      }
-
-      for (const config of contract.intervalConfigs) {
-        binding.handlerIds.push(config.handlerId)
-      }
-    }
-    return binding
-  }
-
-  testInstructions(instructions: Data_SolInstruction[]): Promise<ProcessBindingResponse> {
-    return this.processBindings({
-      bindings: instructions.map((instruction) => {
-        return {
-          data: {
-            raw: new Uint8Array(),
-            solInstruction: instruction,
-          },
-          handlerIds: [],
-          handlerType: HandlerType.SOL_INSTRUCTION,
-        }
-      }),
-    })
-  }
-
   processBindings(
     request: ProcessBindingsRequest,
     context: CallContext = TEST_CONTEXT

package/src/utils/dex-price.ts

@@ -1,4 +1,4 @@
-import { getEACAggregatorProxyContract } from '../eth/builtin/internal/eacaggregatorproxy_processor.js'
+import { getEACAggregatorProxyContract } from '../eth/builtin/eacaggregatorproxy.js'
 import fs from 'fs'
 import { parse } from 'csv-parse/sync'
 import { BlockTag } from 'ethers/providers'

package/src/utils/token.ts

@@ -1,8 +1,6 @@
 import { getERC20Contract } from '../eth/builtin/erc20.js'
-import { getERC20BytesContract } from '../eth/builtin/internal/erc20bytes_processor.js'
+import { getERC20BytesContract } from '../eth/builtin/erc20bytes.js'
 import { BigDecimal, scaleDown } from '../core/big-decimal.js'
-// import { toBigDecimal } from './conversion'
-// import { utils } from 'ethers'
 import { PromiseOrValue } from '../eth/builtin/internal/common.js'
 import { decodeBytes32String } from 'ethers'