@sentio/sdk 2.40.0-rc.5 → 2.40.0-rc.6

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,28 @@ 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
+        })
+        const ret = preparedData.ethCallResults[key]
+        if (ret) {
+          const result = iface.decodeFunctionResult("${fn.name}", ret).toArray()
+          return result.length == 1? result[0]: result
+        }
+      }
+      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 +88,76 @@ 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: 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 blockTag = overrides?.blockTag?.toString() ?? this.context.blockNumber.toString(16)
+    const address = this.context.address
+    
+    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/eth-plugin.ts

@@ -414,7 +414,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 +437,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 +459,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 +482,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'