@sentio/sdk 2.40.0-rc.2 → 2.40.0-rc.20

package/src/eth/codegen/event-handler.ts

@@ -12,7 +12,7 @@ export function generateEventHandler(event: EventDeclaration, contractName: stri
     handler: (event: ${eventNamePrefix}Event, ctx: ${contractName}Context) => void,
     filter?: ${eventNamePrefix}EventFilter | ${eventNamePrefix}EventFilter[],
     fetchConfig?: Partial<EthFetchConfig>,
-    preprocessHandler?: (event: ${eventNamePrefix}Event, ctx: ${contractName}Context) => Promise<PreprocessResult>
+    preprocessHandler?: (event: ${eventNamePrefix}Event, ctx: ${contractName}Context, preprocessStore: {[k: string]: any}) => Promise<PreprocessResult>
   ): this {
     if (!filter) {
       filter = templateContract.filters['${filterName}'](${event.inputs.map(() => 'null').join(',')})

package/src/eth/codegen/file.ts

@@ -9,7 +9,12 @@ import {
 import { reservedKeywords } from '@sentio/ethers-v6/dist/codegen/reserved-keywords.js'
 import { codegenCallTraceTypes, generateCallHandlers } from './functions-handler.js'
 import { generateEventFilters, generateEventHandlers } from './event-handler.js'
-import { generateBoundViewFunctions, generateViewFunctions } from './function-calls.js'
+import {
+  generateBoundFunctionCallEncoders,
+  generateBoundViewFunctions,
+  generateFunctionCallEncoders,
+  generateViewFunctions
+} from './function-calls.js'
 
 export function codeGenIndex(contract: Contract): string {
   return ` 
@@ -44,6 +49,13 @@ export function codeGenSentioFile(contract: Contract): string {
         .flatMap((fs) => generateViewFunctions(false, fs))
         .join(',\n')}
     }
+    
+    encodeCall = {
+      ${Object.values(contract.functions)
+        .filter((f) => !reservedKeywords.has(f[0].name))
+        .flatMap((fs) => generateFunctionCallEncoders(fs))
+        .join(',\n')}
+    }
   }
   
   export class ${contract.name}BoundContractView extends BoundContractView<${contract.name}, 
@@ -61,6 +73,15 @@ export function codeGenSentioFile(contract: Contract): string {
         .flatMap((fs) => generateBoundViewFunctions(false, fs))
         .join(',\n')}
     }
+    
+    encodeCall = {
+      view: this.view,
+      context: this.context,
+      ${Object.values(contract.functions)
+        .filter((f) => !reservedKeywords.has(f[0].name))
+        .flatMap((fs) => generateBoundFunctionCallEncoders(fs))
+        .join(',\n')}
+    }
   }
 
   export type ${contract.name}Context = ContractContext<${contract.name}, ${contract.name}BoundContractView>
@@ -173,7 +194,7 @@ export class ${contract.name}ProcessorTemplate extends BaseProcessorTemplate<${c
 
   const imports = createImportsForUsedIdentifiers(
     {
-      ethers: ['BigNumberish', 'Overrides', 'BytesLike'],
+      ethers: ['BigNumberish', 'Overrides', 'BytesLike', 'Interface'],
       // 'ethers/providers': ['Networkish'],
       '@sentio/sdk/eth': [
         'addContractByABI',
@@ -195,10 +216,12 @@ export class ${contract.name}ProcessorTemplate extends BaseProcessorTemplate<${c
         'TypedCallTrace',
         'EthContext',
         'EthFetchConfig',
-        'PreprocessResult'
+        'PreprocessResult',
+        'makeEthCallKey'
       ],
       // '@sentio/sdk/eth': ['BaseContext'],
       // '@sentio/protos': ['EthFetchConfig'],
+      '@sentio/protos': ['EthCallParam', 'EthCallContext', 'PreparedData'],
       './common.js': ['PromiseOrValue'],
       './index.js': [`${contract.name}__factory`],
       [`./${contract.name}.js`]: [`${contract.name}`, ...eventsImports, ...uniqueStructImports]

package/src/eth/codegen/function-calls.ts

@@ -1,7 +1,11 @@
 // https://github.com/dethcrypto/TypeChain/blob/015abb28bd22826611051f27e0ec96a00f9a0b61/packages/target-ethers-v5/src/codegen/functions.ts#L54
-import { FunctionDeclaration } from 'typechain'
+import { FunctionDeclaration, getSignatureForFn } from 'typechain'
 import { generateInputTypes, generateOutputTypes } from '@sentio/ethers-v6/dist/codegen/types.js'
-import { getFullSignatureAsSymbolForFunction, getFullSignatureForFunction } from './types.js'
+import {
+  getFullSignatureAsSymbolForFunction,
+  getFullSignatureForFunction,
+  getFullSignatureWithOutputForFn
+} from './types.js'
 
 function generateReturnTypes(fn: FunctionDeclaration) {
   // sounds like returnResultObject should be true but we need to set false to make it work
@@ -34,11 +38,33 @@ export function generateViewFunction(view: boolean, fn: FunctionDeclaration, inc
     `
   async ${declName}(${generateInputTypes(fn.inputs, {
     useStructs: true
-  })}overrides?: Overrides): ${generateReturnTypes(fn)} {
-    try {    
-       return await ${func}${call}(${
-         fn.inputs.length > 0 ? fn.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
-       } overrides || {})
+  })}overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): ${generateReturnTypes(fn)} {
+    try {
+      if (preparedData?.ethCallResults && ethCallContext) {
+        const iface = new Interface(["function ${getFullSignatureWithOutputForFn(fn)}"])
+        const calldata = iface.encodeFunctionData(
+          "${fn.name}",[${
+            fn.inputs.length > 0 ? fn.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
+          }] 
+        )
+        const key = makeEthCallKey({
+          context: ethCallContext,
+          calldata
+        })
+        console.debug("looking up eth call key:", key)
+        const ret = preparedData.ethCallResults[key]
+        if (ret) {
+          console.debug("prepared eth call found:", key)
+          const result = iface.decodeFunctionResult("${fn.name}", ret).toArray()
+          return result.length == 1? result[0]: result
+        }
+        console.debug("missing eth call key:", "${fn.name}", ${
+          fn.inputs.length > 0 ? fn.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
+        }key)
+      }
+      return await ${func}${call}(${
+        fn.inputs.length > 0 ? fn.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
+      } overrides || {})
     } catch (e) {
       const stack = new Error().stack
       throw transformEtherError(e, undefined, stack)
@@ -67,12 +93,79 @@ export function generateBoundViewFunction(view: boolean, fn: FunctionDeclaration
   async ${declName ?? fn.name}(${generateInputTypes(fn.inputs, {
     useStructs: true
   })}overrides?: Overrides): ${generateReturnTypes(fn)} {
+    const ethCallContext = {
+      chainId: this.context.chainId,
+      blockTag: "0x" + this.context.blockNumber.toString(16),
+      address: this.context.address,
+    }
     return await this.${qualifier}.${declName}(${
       fn.inputs.length > 0 ? fn.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
     } {
       blockTag: this.context.blockNumber,
       ...overrides
-    })
+    }, this.context.preparedData, ethCallContext)
+  }
+  `
+  ]
+}
+
+// TODO add tests for these
+export function generateFunctionCallEncoders(functions: FunctionDeclaration[]): string[] {
+  const includeArgTypes = functions.length !== 1
+  return functions.flatMap((fn) => generateFunctionCallEncoder(fn, includeArgTypes))
+}
+
+export function generateFunctionCallEncoder(fn: FunctionDeclaration, includeArgTypes: boolean): string[] {
+  const declName = includeArgTypes ? getFullSignatureAsSymbolForFunction(fn) : fn.name
+  return [
+    `
+  ${declName}(${generateInputTypes(fn.inputs, {
+    useStructs: true
+  })}ethCallContext: EthCallContext): EthCallParam {
+    try {
+      const iface = new Interface(["function ${getSignatureForFn(fn)}"])
+      const calldata = iface.encodeFunctionData(
+        "${fn.name}",[${
+          fn.inputs.length > 0 ? fn.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
+        }] 
+      )
+      return {
+        context: ethCallContext,
+        calldata
+      }
+    } catch (e) {
+      const stack = new Error().stack
+      throw transformEtherError(e, undefined, stack)
+    }
+  }
+  `
+  ]
+}
+
+export function generateBoundFunctionCallEncoders(functions: FunctionDeclaration[]): string[] {
+  const includeArgTypes = functions.length !== 1
+  return functions.flatMap((fn) => generateBoundFunctionCallEncoder(fn, includeArgTypes))
+}
+
+export function generateBoundFunctionCallEncoder(fn: FunctionDeclaration, includeArgTypes: boolean): string[] {
+  const declName = includeArgTypes ? getFullSignatureAsSymbolForFunction(fn) : fn.name
+
+  // TODO need override address?
+  return [
+    `
+  ${declName ?? fn.name}(${generateInputTypes(fn.inputs, {
+    useStructs: true
+  })}overrides?: Overrides): EthCallParam {
+    const chainId = overrides?.chainId?.toString() ?? this.context.chainId.toString()
+    const address = this.context.address
+    let blockTag = "0x" + this.context.blockNumber.toString(16)
+    if (overrides?.blockTag) {
+      blockTag = typeof(overrides.blockTag) == 'string'? overrides.blockTag: "0x" + overrides.blockTag.toString(16)
+    }
+    
+    return this.view.encodeCall.${declName}(${
+      fn.inputs.length > 0 ? fn.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
+    }{chainId, address, blockTag})
   }
   `
   ]

package/src/eth/codegen/types.ts

@@ -1,4 +1,11 @@
-import { EventDeclaration, FunctionDeclaration } from 'typechain'
+import {
+  AbiOutputParameter,
+  AbiParameter,
+  EventDeclaration,
+  FunctionDeclaration,
+  getArgumentForSignature,
+  getSignatureForFn
+} from 'typechain'
 import { EvmType } from 'typechain/dist/parser/parseEvmType.js'
 
 export function getFullSignatureAsSymbolForFunction(fn: FunctionDeclaration): string {
@@ -40,3 +47,17 @@ export function getFullSignatureForFunction(fn: FunctionDeclaration): string {
     })
     .join(',')})`
 }
+
+function getOutputArgumentForSignature(argument: AbiOutputParameter) {
+  if (argument.type.type == 'void') {
+    return ''
+  }
+  return getArgumentForSignature(argument as AbiParameter)
+}
+
+export function getFullSignatureWithOutputForFn(fn: FunctionDeclaration) {
+  return `${getSignatureForFn(fn)} ${fn.stateMutability} returns (${fn.outputs
+    .map((i) => getOutputArgumentForSignature(i))
+    .filter((s) => s != '')
+    .join(',')})`
+}

package/src/eth/context.ts

@@ -188,6 +188,9 @@ export class ContractContext<
     if (view.callStatic) {
       view.callStatic.context = this
     }
+    if (view.encodeCall) {
+      view.encodeCall.context = this
+    }
     this.contractName = contractName
     this.contract = view
   }
@@ -226,6 +229,10 @@ export class BoundContractView<TContract extends BaseContract, TContractView ext
     context: EthContext
     view: TContractView
   }
+  encodeCall: {
+    context: EthContext
+    view: TContractView
+  }
 
   constructor(address: string, view: TContractView) {
     this.address = address

package/src/eth/eth-plugin.ts

@@ -35,10 +35,13 @@ interface Handlers {
 }
 
 interface PreprocessHandlers {
-  eventHandlers: ((event: Data_EthLog) => Promise<PreprocessResult>)[]
-  traceHandlers: ((trace: Data_EthTrace) => Promise<PreprocessResult>)[]
-  blockHandlers: ((block: Data_EthBlock) => Promise<PreprocessResult>)[]
-  transactionHandlers: ((txn: Data_EthTransaction) => Promise<PreprocessResult>)[]
+  eventHandlers: ((event: Data_EthLog, preprocessStore: { [k: string]: any }) => Promise<PreprocessResult>)[]
+  traceHandlers: ((trace: Data_EthTrace, preprocessStore: { [k: string]: any }) => Promise<PreprocessResult>)[]
+  blockHandlers: ((block: Data_EthBlock, preprocessStore: { [k: string]: any }) => Promise<PreprocessResult>)[]
+  transactionHandlers: ((
+    txn: Data_EthTransaction,
+    preprocessStore: { [k: string]: any }
+  ) => Promise<PreprocessResult>)[]
 }
 
 export class EthPlugin extends Plugin {
@@ -278,16 +281,16 @@ export class EthPlugin extends Plugin {
     }
   }
 
-  preprocessBinding(request: DataBinding): Promise<PreprocessResult> {
+  preprocessBinding(request: DataBinding, preprocessStore: { [k: string]: any }): Promise<PreprocessResult> {
     switch (request.handlerType) {
       case HandlerType.ETH_LOG:
-        return this.preprocessLog(request)
+        return this.preprocessLog(request, preprocessStore)
       case HandlerType.ETH_TRACE:
-        return this.preprocessTrace(request)
+        return this.preprocessTrace(request, preprocessStore)
       case HandlerType.ETH_BLOCK:
-        return this.preprocessBlock(request)
+        return this.preprocessBlock(request, preprocessStore)
       case HandlerType.ETH_TRANSACTION:
-        return this.preprocessTransaction(request)
+        return this.preprocessTransaction(request, preprocessStore)
       default:
         throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
     }
@@ -326,7 +329,7 @@ export class EthPlugin extends Plugin {
     return TemplateInstanceState.INSTANCE.getValues().length !== config.templateInstances.length
   }
 
-  async preprocessLog(request: DataBinding): Promise<PreprocessResult> {
+  async preprocessLog(request: DataBinding, preprocessStore: { [k: string]: any }): Promise<PreprocessResult> {
     if (!request.data?.ethLog?.log) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Log can't be null")
     }
@@ -335,7 +338,7 @@ export class EthPlugin extends Plugin {
     const promises: Promise<PreprocessResult>[] = []
     for (const handlerId of request.handlerIds) {
       const handler = this.preprocessHandlers.eventHandlers[handlerId]
-      const promise = handler(ethLog).catch((e) => {
+      const promise = handler(ethLog, preprocessStore).catch((e) => {
         throw new ServerError(
           Status.INTERNAL,
           'error processing log: ' + JSON.stringify(ethLog.log) + '\n' + errorString(e)
@@ -346,7 +349,7 @@ export class EthPlugin extends Plugin {
     return mergePreprocessResults(await Promise.all(promises))
   }
 
-  async preprocessTrace(binding: DataBinding): Promise<PreprocessResult> {
+  async preprocessTrace(binding: DataBinding, preprocessStore: { [k: string]: any }): Promise<PreprocessResult> {
     if (!binding.data?.ethTrace?.trace) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Trace can't be null")
     }
@@ -355,7 +358,7 @@ export class EthPlugin extends Plugin {
     const promises: Promise<PreprocessResult>[] = []
 
     for (const handlerId of binding.handlerIds) {
-      const promise = this.preprocessHandlers.traceHandlers[handlerId](ethTrace).catch((e) => {
+      const promise = this.preprocessHandlers.traceHandlers[handlerId](ethTrace, preprocessStore).catch((e) => {
         throw new ServerError(
           Status.INTERNAL,
           'error processing trace: ' + JSON.stringify(ethTrace.trace) + '\n' + errorString(e)
@@ -366,7 +369,7 @@ export class EthPlugin extends Plugin {
     return mergePreprocessResults(await Promise.all(promises))
   }
 
-  async preprocessBlock(binding: DataBinding): Promise<PreprocessResult> {
+  async preprocessBlock(binding: DataBinding, preprocessStore: { [k: string]: any }): Promise<PreprocessResult> {
     if (!binding.data?.ethBlock?.block) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Block can't be empty")
     }
@@ -374,7 +377,7 @@ export class EthPlugin extends Plugin {
 
     const promises: Promise<PreprocessResult>[] = []
     for (const handlerId of binding.handlerIds) {
-      const promise = this.preprocessHandlers.blockHandlers[handlerId](ethBlock).catch((e) => {
+      const promise = this.preprocessHandlers.blockHandlers[handlerId](ethBlock, preprocessStore).catch((e) => {
         throw new ServerError(
           Status.INTERNAL,
           'error processing block: ' + ethBlock.block?.number + '\n' + errorString(e)
@@ -385,7 +388,7 @@ export class EthPlugin extends Plugin {
     return mergePreprocessResults(await Promise.all(promises))
   }
 
-  async preprocessTransaction(binding: DataBinding): Promise<PreprocessResult> {
+  async preprocessTransaction(binding: DataBinding, preprocessStore: { [k: string]: any }): Promise<PreprocessResult> {
     if (!binding.data?.ethTransaction?.transaction) {
       throw new ServerError(Status.INVALID_ARGUMENT, "transaction can't be null")
     }
@@ -394,12 +397,14 @@ export class EthPlugin extends Plugin {
     const promises: Promise<PreprocessResult>[] = []
 
     for (const handlerId of binding.handlerIds) {
-      const promise = this.preprocessHandlers.transactionHandlers[handlerId](ethTransaction).catch((e) => {
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing transaction: ' + JSON.stringify(ethTransaction.transaction) + '\n' + errorString(e)
-        )
-      })
+      const promise = this.preprocessHandlers.transactionHandlers[handlerId](ethTransaction, preprocessStore).catch(
+        (e) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing transaction: ' + JSON.stringify(ethTransaction.transaction) + '\n' + errorString(e)
+          )
+        }
+      )
       promises.push(promise)
     }
     return mergePreprocessResults(await Promise.all(promises))
@@ -414,7 +419,7 @@ export class EthPlugin extends Plugin {
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of request.handlerIds) {
       const handler = this.handlers.eventHandlers[handlerId]
-      const promise = handler(ethLog).catch((e) => {
+      const promise = handler(ethLog, preparedData).catch((e) => {
         throw new ServerError(
           Status.INTERNAL,
           'error processing log: ' + JSON.stringify(ethLog.log) + '\n' + errorString(e)
@@ -437,7 +442,7 @@ export class EthPlugin extends Plugin {
     const promises: Promise<ProcessResult>[] = []
 
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.traceHandlers[handlerId](ethTrace).catch((e) => {
+      const promise = this.handlers.traceHandlers[handlerId](ethTrace, preparedData).catch((e) => {
         throw new ServerError(
           Status.INTERNAL,
           'error processing trace: ' + JSON.stringify(ethTrace.trace) + '\n' + errorString(e)
@@ -459,7 +464,7 @@ export class EthPlugin extends Plugin {
 
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.blockHandlers[handlerId](ethBlock).catch((e) => {
+      const promise = this.handlers.blockHandlers[handlerId](ethBlock, preparedData).catch((e) => {
         throw new ServerError(
           Status.INTERNAL,
           'error processing block: ' + ethBlock.block?.number + '\n' + errorString(e)
@@ -482,7 +487,7 @@ export class EthPlugin extends Plugin {
     const promises: Promise<ProcessResult>[] = []
 
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.transactionHandlers[handlerId](ethTransaction).catch((e) => {
+      const promise = this.handlers.transactionHandlers[handlerId](ethTransaction, preparedData).catch((e) => {
         throw new ServerError(
           Status.INTERNAL,
           'error processing transaction: ' + JSON.stringify(ethTransaction.transaction) + '\n' + errorString(e)

package/src/eth/index.ts

@@ -14,3 +14,5 @@ export { EthPlugin } from './eth-plugin.js'
 export { EthFetchConfig, PreprocessResult } from '@sentio/protos'
 
 export { EthChainId } from '@sentio/chain'
+
+export { makeEthCallKey } from '@sentio/runtime'

package/src/solana/builtin/spl-token-processor.ts

@@ -1,4 +1,4 @@
-import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions } from '@sentio/sdk/solana'
+import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions } from "../index.js"
 import { Instruction } from '@project-serum/anchor'
 import { AmountToUiAmount, Approve, ApproveChecked, Burn, BurnChecked, CloseAccount, CreateNativeMint, DefaultAccountStateExtension, FreezeAccount, GetAccountDataSize, InitializeAccount, InitializeAccount2, InitializeAccount3, InitializeImmutableOwner, InitializeMint, InitializeMintCloseAuthority, InitializeMultisig, MemoTransferExtension, MintTo, MintToChecked, Reallocate, Revoke, SyncNative, ThawAccount, Transfer, TransferChecked, TransferFeeExtension, UiAmountToAmount } from './types.js';
 

package/src/solana/solana-context.ts

@@ -1,4 +1,4 @@
-import { normalizeLabels, Labels, BaseContext, RecordMetaData } from '@sentio/sdk'
+import { normalizeLabels, Labels, BaseContext, RecordMetaData } from '../index.js'
 import { SolanaChainId } from '@sentio/chain'
 
 export class SolanaContext extends BaseContext {
@@ -35,7 +35,7 @@ export class SolanaContext extends BaseContext {
       logIndex: 0,
       chainId: this.getChainId(),
       name: name,
-      labels: normalizeLabels(labels),
+      labels: normalizeLabels(labels)
     }
   }
 }

package/src/store/cache.ts

@@ -0,0 +1,46 @@
+import { ID } from './types.js'
+import type { Entity as EntityStruct } from '@sentio/protos'
+
+export interface Entity {
+  id: ID
+}
+
+export class LocalCache {
+  private cache: Map<string, EntityStruct> = new Map()
+
+  getKey(entity: string, id: ID) {
+    return `${entity}-${id}`
+  }
+
+  has(entity: string, id: ID): boolean {
+    return this.cache.has(this.getKey(entity, id))
+  }
+
+  get(entity: string, id: ID): EntityStruct | undefined {
+    return this.cache.get(this.getKey(entity, id))
+  }
+
+  set(entity: EntityStruct) {
+    const id = entity.data?.fields['id'].stringValue
+    if (id) {
+      const key = this.getKey(entity.entity, id)
+      let fields = entity.data?.fields || {}
+      if (this.cache.has(key)) {
+        const existFields = this.cache.get(key)?.data?.fields || {}
+        fields = Object.assign(existFields, fields)
+      }
+      this.cache.set(key, {
+        ...entity,
+        data: {
+          fields
+        }
+      })
+    }
+  }
+
+  delete(entityName: string, id: string | undefined) {
+    if (id) {
+      this.cache.delete(this.getKey(entityName, id))
+    }
+  }
+}