@sentio/sdk 1.0.0-development → 1.0.0-rc.3

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

@@ -0,0 +1,334 @@
+import {
+  AccountConfig,
+  ContractConfig,
+  DataBinding,
+  HandlerType,
+  Data_SolInstruction,
+  ProcessBindingResponse,
+  ProcessBindingsRequest,
+  ProcessConfigRequest,
+  ProcessConfigResponse,
+  ProcessorServiceImplementation,
+  StartRequest,
+} from '../gen'
+import { CallContext } from 'nice-grpc-common'
+import { Empty } from '../gen/google/protobuf/empty'
+import { ChainConfig } from '../chain-config'
+import { CHAIN_MAP } from '../utils/chain'
+import { Block, Log } from '@ethersproject/abstract-provider'
+import Long from 'long'
+import { getNetwork, Networkish } from '@ethersproject/providers'
+import { Endpoints } from '../endpoints'
+import { ProcessorState } from '../state/processor-state'
+import { ProcessorServiceImpl } from '../service'
+import { Trace } from '../core/trace'
+import { setProvider } from '../provider'
+
+export const TEST_CONTEXT: CallContext = <CallContext>{}
+
+export function cleanTest() {
+  global.PROCESSOR_STATE = new ProcessorState()
+  if (!global.ENDPOINTS) {
+    global.ENDPOINTS = new Endpoints()
+  }
+}
+
+export class TestProcessorServer implements ProcessorServiceImplementation {
+  service: ProcessorServiceImpl
+  contractConfigs: ContractConfig[]
+  accountConfigs: AccountConfig[]
+
+  constructor(loader: () => void, httpEndpoints: Record<string, string> = {}) {
+    cleanTest()
+
+    this.service = new ProcessorServiceImpl(loader)
+    const dummyConfig: Record<string, ChainConfig> = {}
+
+    for (const k in CHAIN_MAP) {
+      const http = httpEndpoints[k] || ''
+      dummyConfig[k] = {
+        ChainID: k,
+        Https: [http],
+      }
+    }
+
+    setProvider(dummyConfig)
+  }
+
+  async start(request: StartRequest = { templateInstances: [] }, context = TEST_CONTEXT): Promise<Empty> {
+    const res = await this.service.start(request, context)
+    const config = await this.getConfig({})
+    this.contractConfigs = config.contractConfigs
+    this.accountConfigs = config.accountConfigs
+    return res
+  }
+
+  stop(request: Empty, context = TEST_CONTEXT): Promise<Empty> {
+    return this.service.stop(request, context)
+  }
+
+  getConfig(request: ProcessConfigRequest, context = TEST_CONTEXT): Promise<ProcessConfigResponse> {
+    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 !== getNetwork(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: {
+              raw: new Uint8Array(),
+              ethTrace: { trace },
+            },
+            handlerIds: [config.handlerId],
+            handlerType: HandlerType.ETH_TRACE,
+          }
+        }
+      }
+    }
+    return undefined
+  }
+
+  testLog(log: Log, network: Networkish = 1): Promise<ProcessBindingResponse> {
+    return this.testLogs([log], network)
+  }
+
+  testLogs(logs: Log[], 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: Log, network: Networkish = 1): DataBinding | undefined {
+    for (const contract of this.contractConfigs) {
+      if (contract.contract?.chainId !== getNetwork(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: {
+                raw: new Uint8Array(),
+                ethLog: { log },
+              },
+              handlerIds: [config.handlerId],
+              handlerType: HandlerType.ETH_LOG,
+            }
+          }
+        }
+      }
+    }
+    return undefined
+  }
+  testAccountLog(address: string, log: Log, network: Networkish = 1): Promise<ProcessBindingResponse> {
+    return this.testAccountLogs(address, [log], network)
+  }
+
+  testAccountLogs(address: string, logs: Log[], 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: Log, network: Networkish = 1): DataBinding | undefined {
+    for (const account of this.accountConfigs) {
+      if (account.chainId !== getNetwork(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: {
+                raw: new Uint8Array(),
+                ethLog: { log },
+              },
+              handlerIds: [config.handlerId],
+              handlerType: HandlerType.ETH_LOG,
+            }
+          }
+        }
+      }
+    }
+    return undefined
+  }
+
+  testBlock(block: Partial<Block> & { number: number }, network: Networkish = 1): Promise<ProcessBindingResponse> {
+    return this.testBlocks([block], network)
+  }
+
+  testBlocks(blocks: Partial<Block> & { 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: {
+        raw: new Uint8Array(),
+        ethBlock: { block },
+      },
+      handlerType: HandlerType.ETH_BLOCK,
+      handlerIds: [],
+    }
+    for (const contract of this.contractConfigs) {
+      if (contract.contract?.chainId !== getNetwork(network).chainId.toString()) {
+        continue
+      }
+      const longBlockNumber = Long.fromNumber(block.number)
+      if (longBlockNumber < contract.startBlock) {
+        continue
+      }
+      if (contract.endBlock !== Long.ZERO && 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
+  ): Promise<ProcessBindingResponse> {
+    return this.service.processBindings(request, context)
+  }
+
+  processBindingsStream(request: AsyncIterable<DataBinding>, context: CallContext) {
+    return this.service.processBindingsStream(request, context)
+  }
+}
+
+function toBytes(obj: any): Uint8Array {
+  const logJsonStr = JSON.stringify(obj)
+  const raw = new Uint8Array(logJsonStr.length)
+  for (let i = 0; i < logJsonStr.length; i++) {
+    raw[i] = logJsonStr.charCodeAt(i)
+  }
+  return raw
+}

package/src/testing/test-provider.ts

@@ -0,0 +1,33 @@
+import { ChainConfig } from '../chain-config'
+import { CHAIN_MAP } from '../utils/chain'
+import { setProvider } from '../provider'
+
+export function loadTestProvidersFromEnv(requiredChainIds: string[] | string): boolean {
+  const dummyConfig: Record<string, ChainConfig> = {}
+  const found: string[] = []
+
+  if (!Array.isArray(requiredChainIds)) {
+    requiredChainIds = [requiredChainIds]
+  }
+
+  for (const k of Object.keys(CHAIN_MAP)) {
+    const envKey = 'TEST_ENDPOINT_' + k
+    const http = process.env[envKey]
+    if (!http) {
+      continue
+    }
+    found.push(k)
+    dummyConfig[k] = {
+      ChainID: k,
+      Https: [http],
+    }
+  }
+
+  setProvider(dummyConfig)
+  for (const id of requiredChainIds) {
+    if (!found.includes(id)) {
+      return false
+    }
+  }
+  return true
+}

package/src/types/global.d.ts

@@ -0,0 +1,15 @@
+import { ProcessorState } from '../state/processor-state'
+import { Endpoints } from "../endpoints";
+
+declare global {
+  var PROCESSOR_STATE: ProcessorState
+  var ENDPOINTS: Endpoints
+}
+
+
+// declare module "long" {
+//   export interface Long {
+//     toBigInt(): bigint;
+//   }
+// }
+//

package/src/utils/chain.ts

@@ -0,0 +1,127 @@
+// copy from https://github.com/DefiLlama/chainlist/blob/main/constants/chainIds.js
+// and https://besu.hyperledger.org/en/stable/Concepts/NetworkID-And-ChainID/
+
+export const CHAIN_IDS = {
+  KARDIA: '0',
+  ETHEREUM: '1',
+  EXPANSE: '2',
+  ROPSTEN: '3',
+  RINKEBY: '4',
+  GOERLI: '5',
+  KOTTI: '6',
+  UBIQ: '8',
+  OPTIMISM: '10',
+  SONGBIRD: '19',
+  ELASTOS: '20',
+  CRONOS: '25',
+  RSK: '30',
+  TELOS: '40',
+  XDC: '50',
+  CSC: '52',
+  ZYX: '55',
+  BINANCE: '56',
+  SYSCOIN: '57',
+  GOCHAIN: '60',
+  ETHCLASSIC: '61',
+  MORDOR: '63',
+  OKEXCHAIN: '66',
+  HOO: '70',
+  METER: '82',
+  TOMOCHAIN: '88',
+  XDAI: '100',
+  VELAS: '106',
+  THUNDERCORE: '108',
+  FUSE: '122',
+  HECO: '128',
+  POLYGON: '137',
+  XDAIARB: '200',
+  ASTOR: '212',
+  ENERGYWEB: '246',
+  FANTOM: '250',
+  HPB: '269',
+  BOBA: '288',
+  KUCOIN: '321',
+  SHIDEN: '336',
+  THETA: '361',
+  SX: '416',
+  CANDLE: '534',
+  ASTAR: '592',
+  CALLISTO: '820',
+  WANCHAIN: '888',
+  METIS: '1088',
+  OMCHAIN: '1246',
+  MOONBEAM: '1284',
+  MOONRIVER: '1285',
+  DEV: '2018',
+  RONIN: '2020',
+  KAVA: '2222',
+  EZCHAIN: '2612',
+  PHI: '4181',
+  IOTEX: '4689',
+  XLC: '5050',
+  NAHMII: '5551',
+  NMACTEST: '7777',
+  KLAYTN: '8217',
+  EVMOS: '9001',
+  SMARTBCH: '10000',
+  CRYSTALEUM: '103090',
+  FUSION: '32659',
+  ARBITRUM: '42161',
+  CELO: '42220',
+  OASIS: '42262',
+  AVALANCHE: '43114',
+  GODWOKEN: '71402',
+  AKROMA: '200625',
+  POLIS: '333999',
+  ARBITRUM_TEST: '421613',
+  SEPOLIA: '11155111',
+  AURORA: '1313161554',
+  HARMONY: '1666600000',
+  PALM: '11297108109',
+  CURIO: '836542336838601',
+  SOLANA_MAINNET: 'sol_mainnet',
+  SOLANA_DEVNET: 'sol_devnet',
+  SOLANA_TESTNET: 'sol_testnet',
+  SOLANA_PYTH: 'sol_pyth',
+  SUI_DEVNET: 'sui_devnet',
+  APTOS_MAINNET: 'aptos_mainnet',
+  APTOS_TESTNET: 'aptos_testnet',
+}
+
+export const CHAIN_MAP: Record<string, string> = {}
+
+for (const [key, value] of Object.entries(CHAIN_IDS)) {
+  const parts = key.split('_')
+  CHAIN_MAP[value] = parts
+    .map((part, index) => {
+      return part[0] + part.slice(1).toLowerCase()
+    })
+    .join(' ')
+}
+
+export function getChainName(chainId: string | number | null | undefined): string {
+  if (typeof chainId === 'number') {
+    chainId = chainId.toString()
+  }
+  if (chainId) {
+    const name = CHAIN_MAP[chainId]
+    if (name) {
+      return name
+    }
+  }
+  return chainId || ''
+}
+
+export function getChainType(chainId?: string | number): string {
+  const id = String(chainId).toLowerCase()
+  if (id.startsWith('sol')) {
+    return 'solana'
+  }
+  if (id.startsWith('sui')) {
+    return 'sui'
+  }
+  if (id.startsWith('apt')) {
+    return 'aptos'
+  }
+  return 'EVM'
+}

package/src/utils/chainlink-oracles-goerli.csv

@@ -0,0 +1,8 @@
+BTC / ETH,,,0x779877A7B0D9E8603169DdbD7836e478b4624789
+BTC / USD,,,0xA39434A63A52E749F02807ae27335515BA4b07F7
+DAI / USD,,,0x0d79df66BE487753B02D015Fb622DED7f0E9798d
+ETH / USD,,,0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e
+FORTH / USD,,,0x7A65Cf6C2ACE993f09231EC1Ea7363fb29C13f2F
+LINK / ETH,,,0xb4c4a493AB6356497713A78FFA6c60FB53517c63
+LINK / USD,,,0x48731cF7e84dc94C5f84577882c14Be11a5B7456
+USDC / USD,,,0xAb5c49580294Aff77670F839ea425f5b78ab3Ae7