@sentio/sdk 1.8.2 → 1.9.0

package/src/builtin/internal/weth9_processor.ts

@@ -1,7 +1,7 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-import { CallOverrides } from "ethers";
+import { BigNumberish, CallOverrides } from "ethers";
 import { Networkish } from "@ethersproject/providers";
 import {
   addContractByABI,
@@ -18,6 +18,7 @@ import {
   ContractView,
   DummyProvider,
   getContractName,
+  TypedTrace,
 } from "@sentio/sdk";
 import { PromiseOrValue } from "./common";
 import { WETH9, WETH9__factory } from "./index";
@@ -304,6 +305,54 @@ export class WETH9ProcessorTemplate extends BaseProcessorTemplate<
   }
 }
 
+export interface NameCallTrace extends TypedTrace {
+  args: [];
+}
+
+export interface ApproveCallTrace extends TypedTrace {
+  args: [guy: PromiseOrValue<string>, wad: PromiseOrValue<BigNumberish>];
+}
+
+export interface TotalSupplyCallTrace extends TypedTrace {
+  args: [];
+}
+
+export interface TransferFromCallTrace extends TypedTrace {
+  args: [
+    src: PromiseOrValue<string>,
+    dst: PromiseOrValue<string>,
+    wad: PromiseOrValue<BigNumberish>
+  ];
+}
+
+export interface WithdrawCallTrace extends TypedTrace {
+  args: [wad: PromiseOrValue<BigNumberish>];
+}
+
+export interface DecimalsCallTrace extends TypedTrace {
+  args: [];
+}
+
+export interface BalanceOfCallTrace extends TypedTrace {
+  args: [arg0: PromiseOrValue<string>];
+}
+
+export interface SymbolCallTrace extends TypedTrace {
+  args: [];
+}
+
+export interface TransferCallTrace extends TypedTrace {
+  args: [dst: PromiseOrValue<string>, wad: PromiseOrValue<BigNumberish>];
+}
+
+export interface DepositCallTrace extends TypedTrace {
+  args: [];
+}
+
+export interface AllowanceCallTrace extends TypedTrace {
+  args: [arg0: PromiseOrValue<string>, arg1: PromiseOrValue<string>];
+}
+
 export class WETH9Processor extends BaseProcessor<
   WETH9,
   WETH9BoundContractView
@@ -359,6 +408,64 @@ export class WETH9Processor extends BaseProcessor<
     return super.onEvent(handler, filter);
   }
 
+  onNameCall(handler: (trace: NameCallTrace, ctx: WETH9Context) => void) {
+    return super.onTrace("name()", handler);
+  }
+
+  onApproveCall(handler: (trace: ApproveCallTrace, ctx: WETH9Context) => void) {
+    return super.onTrace("approve(address,uint256)", handler);
+  }
+
+  onTotalSupplyCall(
+    handler: (trace: TotalSupplyCallTrace, ctx: WETH9Context) => void
+  ) {
+    return super.onTrace("totalSupply()", handler);
+  }
+
+  onTransferFromCall(
+    handler: (trace: TransferFromCallTrace, ctx: WETH9Context) => void
+  ) {
+    return super.onTrace("transferFrom(address,address,uint256)", handler);
+  }
+
+  onWithdrawCall(
+    handler: (trace: WithdrawCallTrace, ctx: WETH9Context) => void
+  ) {
+    return super.onTrace("withdraw(uint256)", handler);
+  }
+
+  onDecimalsCall(
+    handler: (trace: DecimalsCallTrace, ctx: WETH9Context) => void
+  ) {
+    return super.onTrace("decimals()", handler);
+  }
+
+  onBalanceOfCall(
+    handler: (trace: BalanceOfCallTrace, ctx: WETH9Context) => void
+  ) {
+    return super.onTrace("balanceOf(address)", handler);
+  }
+
+  onSymbolCall(handler: (trace: SymbolCallTrace, ctx: WETH9Context) => void) {
+    return super.onTrace("symbol()", handler);
+  }
+
+  onTransferCall(
+    handler: (trace: TransferCallTrace, ctx: WETH9Context) => void
+  ) {
+    return super.onTrace("transfer(address,uint256)", handler);
+  }
+
+  onDepositCall(handler: (trace: DepositCallTrace, ctx: WETH9Context) => void) {
+    return super.onTrace("deposit()", handler);
+  }
+
+  onAllowanceCall(
+    handler: (trace: AllowanceCallTrace, ctx: WETH9Context) => void
+  ) {
+    return super.onTrace("allowance(address,address)", handler);
+  }
+
   public static filters = templateContract.filters;
 
   protected CreateBoundContractView(): WETH9BoundContractView {

package/src/index.ts

@@ -12,6 +12,7 @@ export { transformEtherError } from './error'
 export { ProcessorState } from './processor-state'
 export { BigNumber as BigDecimal } from 'bignumber.js'
 export { EthersError } from './error'
+export type { TypedTrace } from './trace'
 
 export { getProcessor, addProcessor, getContractByABI, addContractByABI, getContractName } from './binds'
 

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

@@ -9,6 +9,7 @@ import {
 import { reservedKeywords } from '@typechain/ethers-v5/dist/codegen/reserved-keywords'
 import { generateInputTypes } from '@typechain/ethers-v5/dist/codegen/types'
 import { getFullSignatureForEvent } from 'typechain/dist/utils/signatures'
+import { codegenCallTraceTypes, codegenFunctions } from './functions'
 
 export function codeGenIndex(contract: Contract): string {
   return ` 
@@ -72,6 +73,8 @@ export function codeGenSentioFile(contract: Contract): string {
       .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) => {
@@ -83,6 +86,10 @@ export function codeGenSentioFile(contract: Contract): string {
         })
         .join('\n')}
 
+      ${Object.values(contract.functions)
+        .map((f) => codegenFunctions(f, contract.name))
+        .join('\n')}
+
     public static filters = templateContract.filters
     
     protected CreateBoundContractView(): ${contract.name}BoundContractView {
@@ -134,6 +141,7 @@ export function codeGenSentioFile(contract: Contract): string {
         'ContractView',
         'DummyProvider',
         'getContractName',
+        'TypedTrace',
       ],
       './common': ['PromiseOrValue'],
       './index': [`${contract.name}`, `${contract.name}__factory`],

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

@@ -0,0 +1,55 @@
+import { generateInputTypes } from '@typechain/ethers-v5/dist/codegen/types'
+import { FunctionDeclaration, getSignatureForFn } from 'typechain'
+
+export function codegenFunctions(fns: FunctionDeclaration[], contractName: string): string {
+  if (fns.length === 1) {
+    return generateFunction(fns[0], contractName)
+  }
+
+  return fns.map((fn) => generateFunction(fn, contractName, getFullSignatureAsSymbolForFunction(fn))).join('\n')
+}
+
+export function codegenCallTraceTypes(fns: FunctionDeclaration[]): string {
+  if (fns.length === 1) {
+    return codegenCallTraceType(fns[0])
+  }
+
+  return fns.map((fn) => codegenCallTraceType(fn, getFullSignatureAsSymbolForFunction(fn))).join('\n')
+}
+
+function codegenCallTraceType(fn: FunctionDeclaration, overloadedName?: string): string {
+  return `
+  export interface ${capitalizeFirstChar(overloadedName ?? fn.name)}CallTrace extends TypedTrace {
+    args: [${generateInputTypes(fn.inputs, { useStructs: true })}]
+  }
+  `
+}
+
+function generateFunction(fn: FunctionDeclaration, contractName: string, overloadedName?: string): string {
+  return `
+  on${capitalizeFirstChar(overloadedName ?? fn.name)}Call(
+    handler: (trace: ${capitalizeFirstChar(overloadedName ?? fn.name)}CallTrace, ctx: ${contractName}Context) => void
+  ) {
+    return super.onTrace("${getSignatureForFn(fn)}", handler);
+  }
+`
+}
+
+function getFullSignatureAsSymbolForFunction(fn: FunctionDeclaration): string {
+  return `${fn.name}_${fn.inputs
+    .map((e) => {
+      if (e.type.type === 'array') {
+        return e.type.itemType.originalType + '_array'
+      } else {
+        return e.type.originalType
+      }
+    })
+    .join('_')}`
+}
+
+function capitalizeFirstChar(input: string): string {
+  if (!input) {
+    return input
+  }
+  return input[0].toUpperCase() + (input.length > 1 ? input.substring(1) : '')
+}