@sentio/sdk 1.9.0 → 1.10.1

package/src/target-ethers-sentio/codegen.ts

@@ -20,6 +20,8 @@ export function codeGenIndex(contract: Contract): string {
 
 export function codeGenSentioFile(contract: Contract): string {
   const source = `
+  ${Object.values(contract.functions).map(codegenCallTraceTypes).join('\n')}
+
   const templateContract = ${contract.name}__factory.connect("", DummyProvider)
 
   export class ${contract.name}ContractView extends ContractView<${contract.name}> {
@@ -71,10 +73,12 @@ export function codeGenSentioFile(contract: Contract): string {
         }
       })
       .join('\n')}
+    
+    ${Object.values(contract.functions)
+      .map((f) => codegenFunctions(f, contract.name))
+      .join('\n')}
     }
 
-    ${Object.values(contract.functions).map(codegenCallTraceTypes).join('\n')}
-
     export class ${contract.name}Processor extends BaseProcessor<${contract.name}, ${contract.name}BoundContractView> {
       ${Object.values(contract.events)
         .map((events) => {
@@ -121,6 +125,31 @@ export function codeGenSentioFile(contract: Contract): string {
     return contract
   }
   `
+  const eventsImports = Object.values(contract.events).flatMap((events) => {
+    if (events.length === 1) {
+      return [`${events[0].name}Event`, `${events[0].name}EventFilter`]
+    } else {
+      return events.flatMap((e) => [
+        `${getFullSignatureAsSymbolForEvent(e)}_Event`,
+        `${getFullSignatureAsSymbolForEvent(e)}_EventFilter`,
+      ])
+    }
+  })
+
+  const structImports = Object.values(contract.structs).flatMap((structs) => {
+    return structs.flatMap((s) => {
+      if (!s.structName) {
+        return []
+      }
+      if (s.structName.namespace) {
+        return [s.structName.namespace]
+      } else {
+        return [s.structName.identifier]
+      }
+    })
+  })
+  // dedup namespace
+  const uniqueStructImports = [...new Set(structImports)]
 
   const imports = createImportsForUsedIdentifiers(
     {
@@ -141,22 +170,11 @@ export function codeGenSentioFile(contract: Contract): string {
         'ContractView',
         'DummyProvider',
         'getContractName',
-        'TypedTrace',
+        'TypedCallTrace',
       ],
       './common': ['PromiseOrValue'],
       './index': [`${contract.name}`, `${contract.name}__factory`],
-      [`./${contract.name}`]: (<string[]>[]).concat(
-        ...Object.values(contract.events).map((events) => {
-          if (events.length === 1) {
-            return [`${events[0].name}Event`, `${events[0].name}EventFilter`]
-          } else {
-            return events.flatMap((e) => [
-              `${getFullSignatureAsSymbolForEvent(e)}_Event`,
-              `${getFullSignatureAsSymbolForEvent(e)}_EventFilter`,
-            ])
-          }
-        })
-      ),
+      [`./${contract.name}`]: eventsImports.concat(uniqueStructImports),
     },
     source
   )
@@ -216,7 +234,7 @@ function generateOnEventFunction(event: EventDeclaration, contractName: string,
   const filterName = getFullSignatureForEvent(event)
 
   return `
-  on${eventName}(
+  onEvent${eventName}(
     handler: (event: ${eventName}Event, ctx: ${contractName}Context) => void,
     filter?: ${eventName}EventFilter | ${eventName}EventFilter[]
   ) {

package/src/target-ethers-sentio/functions.ts

@@ -1,5 +1,9 @@
-import { generateInputTypes } from '@typechain/ethers-v5/dist/codegen/types'
+import {
+  generateOutputComplexTypeAsArray,
+  generateOutputComplexTypesAsObject,
+} from '@typechain/ethers-v5/dist/codegen/types'
 import { FunctionDeclaration, getSignatureForFn } from 'typechain'
+import { utils } from 'ethers'
 
 export function codegenFunctions(fns: FunctionDeclaration[], contractName: string): string {
   if (fns.length === 1) {
@@ -18,19 +22,28 @@ export function codegenCallTraceTypes(fns: FunctionDeclaration[]): string {
 }
 
 function codegenCallTraceType(fn: FunctionDeclaration, overloadedName?: string): string {
+  const identifier = capitalizeFirstChar(overloadedName ?? fn.name)
+
+  const components = fn.inputs.map((input, i) => ({ name: input.name ?? `arg${i.toString()}`, type: input.type }))
+  const arrayOutput = generateOutputComplexTypeAsArray(components, { useStructs: true })
+  const objectOutput = generateOutputComplexTypesAsObject(components, { useStructs: true }) || '{}'
+
   return `
-  export interface ${capitalizeFirstChar(overloadedName ?? fn.name)}CallTrace extends TypedTrace {
-    args: [${generateInputTypes(fn.inputs, { useStructs: true })}]
-  }
+  export interface ${identifier}CallObject ${objectOutput}
+    
+  export type ${identifier}CallTrace = TypedCallTrace<${arrayOutput}, ${identifier}CallObject>
   `
 }
 
 function generateFunction(fn: FunctionDeclaration, contractName: string, overloadedName?: string): string {
+  const signature = getSignatureForFn(fn)
+  const sighash = utils.keccak256(utils.toUtf8Bytes(signature)).substring(0, 10)
+
   return `
-  on${capitalizeFirstChar(overloadedName ?? fn.name)}Call(
-    handler: (trace: ${capitalizeFirstChar(overloadedName ?? fn.name)}CallTrace, ctx: ${contractName}Context) => void
+  onCall${capitalizeFirstChar(overloadedName ?? fn.name)}(
+    handler: (call: ${capitalizeFirstChar(overloadedName ?? fn.name)}CallTrace, ctx: ${contractName}Context) => void
   ) {
-    return super.onTrace("${getSignatureForFn(fn)}", handler);
+    return super.onTrace("${sighash}", handler);
   }
 `
 }