@sentio/sdk 2.0.0-rc.9 → 2.0.1-rc.1

package/src/{builtin → eth/builtin}/internal/weth9_processor.ts

@@ -20,7 +20,7 @@ import {
   DummyProvider,
   TypedCallTrace,
   toBlockTag,
-} from "@sentio/sdk";
+} from "@sentio/sdk/eth";
 import { EthFetchConfig } from "@sentio/protos";
 
 import { WETH9, WETH9__factory } from "./index.js";
@@ -182,68 +182,48 @@ export class WETH9BoundContractView extends BoundContractView<
   WETH9ContractView
 > {
   async name(overrides?: Overrides): Promise<string> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.name(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.name(overrides || {});
   }
 
   async totalSupply(overrides?: Overrides): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.totalSupply(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.totalSupply(overrides || {});
   }
 
   async decimals(overrides?: Overrides): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.decimals(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.decimals(overrides || {});
   }
 
   async balanceOf(arg0: string, overrides?: Overrides): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.balanceOf(arg0, overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.balanceOf(arg0, overrides || {});
   }
 
   async symbol(overrides?: Overrides): Promise<string> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.symbol(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.symbol(overrides || {});
   }
 
   async allowance(
@@ -251,16 +231,12 @@ export class WETH9BoundContractView extends BoundContractView<
     arg1: string,
     overrides?: Overrides
   ): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.allowance(arg0, arg1, overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.allowance(arg0, arg1, overrides || {});
   }
 }
 
@@ -427,7 +403,7 @@ export class WETH9Processor extends BaseProcessor<
 
   protected CreateBoundContractView(): WETH9BoundContractView {
     const view = getWETH9Contract(this.config.address, this.config.network);
-    return new WETH9BoundContractView(view);
+    return new WETH9BoundContractView(this.config.address, view);
   }
 
   public static bind(options: BindOptions): WETH9Processor {

package/src/eth/codegen/codegen.ts

@@ -0,0 +1,62 @@
+import { loadFileDescriptions, processOutput, skipEmptyAbis } from 'typechain/dist/typechain/io.js'
+import * as fs from 'fs'
+import { Config, DEFAULT_FLAGS, Services } from 'typechain'
+import EthersSentio from './ethers-sentio.js'
+import * as prettier from 'prettier'
+import path from 'path'
+import mkdirp from 'mkdirp'
+
+export async function codegen(abisDir: string, outDir: string) {
+  if (!fs.existsSync(abisDir)) {
+    return
+  }
+  console.log('Generated', await codegenInternal(abisDir, outDir), 'files')
+}
+
+async function codegenInternal(abisDir: string, outDir: string): Promise<number> {
+  let allFiles = fs.readdirSync(abisDir)
+  if (allFiles.length === 0) {
+    return 0
+  }
+  allFiles = allFiles.map((f) => path.resolve(abisDir, f))
+
+  allFiles = skipEmptyAbis(allFiles)
+  if (allFiles.length === 0) {
+    return 0
+  }
+  const outInternal = path.resolve(outDir, 'internal')
+  if (!fs.existsSync(outInternal)) {
+    fs.mkdirSync(outInternal, { recursive: true })
+  }
+
+  // skip empty paths
+  const config: Config = {
+    cwd: process.cwd(),
+    flags: DEFAULT_FLAGS,
+    inputDir: abisDir,
+    target: '',
+    outDir: outInternal,
+    allFiles: allFiles,
+    filesToProcess: allFiles,
+  }
+  const services: Services = {
+    fs,
+    prettier,
+    mkdirp: mkdirp.sync,
+  }
+  let filesGenerated = 0
+
+  const target = new EthersSentio(config)
+
+  const fileDescriptions = loadFileDescriptions(services, config.filesToProcess)
+
+  filesGenerated += processOutput(services, config, await target.beforeRun())
+
+  for (const fd of fileDescriptions) {
+    filesGenerated += processOutput(services, config, await target.transformFile(fd))
+  }
+
+  filesGenerated += processOutput(services, config, target.afterRun())
+
+  return filesGenerated
+}

package/src/{target-ethers-sentio/index.cts → eth/codegen/ethers-sentio.ts}

@@ -1,9 +1,9 @@
 import Ethers from '@sentio/ethers-v6'
 import { Config, extractAbi, extractDocumentation, FileDescription, parse, shortenFullJsonFilePath } from 'typechain'
 import { dirname, join, relative } from 'path'
-import { codeGenIndex, codeGenSentioFile, codeGenTestUtilsFile } from './file.cjs'
+import { codeGenIndex, codeGenSentioFile, codeGenTestUtilsFile } from './file.js'
 
-export default class EthersSentio extends Ethers {
+export default class EthersSentio extends Ethers.default {
   constructor(config: Config) {
     if (!config.outDir) {
       throw new Error('Out put path not specificed')

package/src/{target-ethers-sentio/event-handler.cts → eth/codegen/event-handler.ts}

@@ -1,6 +1,6 @@
 import { EventDeclaration, Contract, getFullSignatureAsSymbolForEvent } from 'typechain'
-import { getFullSignatureForEventPatched } from './types.cjs'
-import { generateEventInputs } from '@sentio/ethers-v6/dist/codegen/events'
+import { getFullSignatureForEventPatched } from './types.js'
+import { generateEventInputs } from '@sentio/ethers-v6/dist/codegen/events.js'
 
 export function generateEventHandler(event: EventDeclaration, contractName: string, includeArgTypes: boolean): string {
   const eventName = includeArgTypes ? getFullSignatureAsSymbolForEvent(event) : event.name

package/src/{target-ethers-sentio/file.cts → eth/codegen/file.ts}

@@ -3,13 +3,13 @@ import {
   createImportsForUsedIdentifiers,
   EventDeclaration,
   getFullSignatureAsSymbolForEvent,
+  getFullSignatureForEvent,
 } from 'typechain'
 
-import { reservedKeywords } from '@sentio/ethers-v6/dist/codegen/reserved-keywords'
-import { getFullSignatureForEvent } from 'typechain/dist/utils/signatures'
-import { codegenCallTraceTypes, generateCallHandlers } from './functions-handler.cjs'
-import { generateEventFilters, generateEventHandlers } from './event-handler.cjs'
-import { generateBoundViewFunctions, generateViewFunctions } from './view-function.cjs'
+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 './view-function.js'
 
 export function codeGenIndex(contract: Contract): string {
   return ` 
@@ -63,7 +63,7 @@ export function codeGenSentioFile(contract: Contract): string {
   
   protected CreateBoundContractView(): ${contract.name}BoundContractView {
     const view = get${contract.name}Contract(this.config.address, this.config.network)
-    return new ${contract.name}BoundContractView(view)
+    return new ${contract.name}BoundContractView(this.config.address, view)
   }
 
   public static bind(options: BindOptions): ${contract.name}Processor {
@@ -146,7 +146,7 @@ export class ${contract.name}ProcessorTemplate extends BaseProcessorTemplate<${c
     {
       ethers: ['BigNumberish', 'Overrides', 'BytesLike'],
       'ethers/providers': ['Networkish'],
-      '@sentio/sdk': [
+      '@sentio/sdk/eth': [
         'addContractByABI',
         'getContractByABI',
         'addProcessor',

package/src/{target-ethers-sentio/functions-handler.cts → eth/codegen/functions-handler.ts}

@@ -1,10 +1,10 @@
 import {
   generateOutputComplexTypeAsArray,
   generateOutputComplexTypesAsObject,
-} from '@sentio/ethers-v6/dist/codegen/types'
-import { keccak_256 } from 'js-sha3'
+} from '@sentio/ethers-v6/dist/codegen/types.js'
+import sha3 from 'js-sha3'
 import { FunctionDeclaration, getSignatureForFn } from 'typechain'
-import { getFullSignatureAsSymbolForFunction } from './types.cjs'
+import { getFullSignatureAsSymbolForFunction } from './types.js'
 
 export function generateCallHandlers(fns: FunctionDeclaration[], contractName: string): string {
   if (fns.length === 1) {
@@ -41,7 +41,7 @@ function generateCallHandler(fn: FunctionDeclaration, contractName: string, over
   // utils.toUtf8Bytes(signature))
 
   const test = new TextEncoder().encode(signature)
-  const sighash = "0x" + keccak_256(test).substring(0, 8)
+  const sighash = '0x' + sha3.keccak_256(test).substring(0, 8)
 
   return `
   onCall${capitalizeFirstChar(overloadedName ?? fn.name)}(

package/src/eth/codegen/index.ts

@@ -0,0 +1 @@
+export * from './codegen.js'

package/src/eth/codegen/run.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import { codegen } from './index.js'
+
+if (process.argv.length > 3) {
+  const abisDir = process.argv[2]
+  const targetDir = process.argv[3]
+  await codegen(abisDir, targetDir)
+} else {
+  console.error('Not enough argument')
+  process.exit(1)
+}

package/src/eth/codegen/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "rootDir": "..",
+    "outDir": "../../../lib"
+  },
+  "extends": "../../../tsconfig.json",
+  "include": ["./"]
+}

package/src/{target-ethers-sentio/types.cts → eth/codegen/types.ts}

@@ -1,5 +1,5 @@
 import { EventDeclaration, FunctionDeclaration } from 'typechain'
-import { EvmType } from 'typechain/dist/parser/parseEvmType'
+import { EvmType } from 'typechain/dist/parser/parseEvmType.js'
 
 export function getFullSignatureAsSymbolForFunction(fn: FunctionDeclaration): string {
   return `${fn.name}_${fn.inputs

package/src/{target-ethers-sentio/view-function.cts → eth/codegen/view-function.ts}

@@ -1,7 +1,7 @@
 // https://github.com/dethcrypto/TypeChain/blob/015abb28bd22826611051f27e0ec96a00f9a0b61/packages/target-ethers-v5/src/codegen/functions.ts#L54
 import { FunctionDeclaration } from 'typechain'
-import { generateInputTypes, generateOutputTypes } from '@sentio/ethers-v6/dist/codegen/types'
-import { getFullSignatureAsSymbolForFunction, getFullSignatureForFunction } from './types.cjs'
+import { generateInputTypes, generateOutputTypes } from '@sentio/ethers-v6/dist/codegen/types.js'
+import { getFullSignatureAsSymbolForFunction, getFullSignatureForFunction } from './types.js'
 
 function generateReturnTypes(fn: FunctionDeclaration) {
   // sounds like returnResultObject should be true but we need to set false to make it work
@@ -60,19 +60,14 @@ export function generateBoundViewFunction(fn: FunctionDeclaration, includeArgTyp
   async ${declName ?? fn.name}(${generateInputTypes(fn.inputs, {
     useStructs: true,
   })}overrides?: Overrides): ${generateReturnTypes(fn)} {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        }
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
       }
-      return await this.view.${declName}(${
+    }
+    return await this.view.${declName}(${
     fn.inputs.length > 0 ? fn.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
   } overrides || {})
-
-    } catch (e) {
-      throw transformEtherError(e, this.context)
-    }
   }
   `
 }

package/src/{core → eth}/context.ts

@@ -2,10 +2,10 @@ import { BaseContract, Transaction, TransactionReceipt, Block } from 'ethers'
 import { LogParams } from 'ethers/providers'
 
 import { RecordMetaData } from '@sentio/protos'
-import { Trace } from '../eth/trace.js'
-import { Labels, normalizeLabels } from './metadata.js'
-import { CHAIN_IDS } from '../utils/chain.js'
-import { BaseContext } from './base-context.js'
+import { Trace } from './trace.js'
+import { Labels, normalizeLabels } from '../core/metadata.js'
+import { CHAIN_IDS } from '../core/chain.js'
+import { BaseContext } from '../core/base-context.js'
 
 export abstract class EthContext extends BaseContext {
   chainId: number
@@ -122,10 +122,7 @@ export class ContractContext<
     transaction?: Transaction,
     transactionReceipt?: TransactionReceipt
   ) {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    const address = view.rawContract.getAddress() as string
-    super(chainId, address, timestamp, block, log, trace, transaction, transactionReceipt)
+    super(chainId, view.address, timestamp, block, log, trace, transaction, transactionReceipt)
     view.context = this
     this.contractName = contractName
     this.contract = view
@@ -154,10 +151,12 @@ export class ContractView<TContract extends BaseContract> {
 
 export class BoundContractView<TContract extends BaseContract, TContractView extends ContractView<TContract>> {
   protected view: TContractView
+  readonly address: string
   // context will be set right after context creation (in context's constructor)
   context: ContractContext<TContract, BoundContractView<TContract, TContractView>>
 
-  constructor(view: TContractView) {
+  constructor(address: string, view: TContractView) {
+    this.address = address
     this.view = view
   }
 

package/src/eth/error.ts

@@ -0,0 +1,4 @@
+// Transform error in more readable format
+import { ContractContext } from './context.js'
+import { CallExceptionError } from 'ethers'
+// import { errors } from 'ethers/providers'

package/src/eth/eth.ts

@@ -0,0 +1,56 @@
+import { BlockTag, LogParams } from 'ethers/providers'
+import { CallExceptionError, Result } from 'ethers'
+import { ContractContext } from './context.js'
+
+export interface EthLog<TArgsArray extends Array<any> = any, TArgsObject = any> extends LogParams {
+  args: TArgsArray & TArgsObject & Result
+}
+
+export function toBlockTag(a: number | bigint): BlockTag {
+  if (typeof a === 'number') {
+    return a
+  }
+  if (a > Number.MAX_SAFE_INTEGER) {
+    return '0x' + a.toString(16)
+  }
+  return Number(a)
+}
+
+export class SimpleEthersError extends Error {
+  e: Error
+
+  constructor(message: string, e: Error) {
+    super(message)
+    this.stack = e.stack
+  }
+
+  toString() {
+    return this.message + '\n' + this.stack?.toString()
+  }
+}
+
+export function transformEtherError(e: Error, ctx: ContractContext<any, any> | undefined): Error {
+  if (e instanceof SimpleEthersError) {
+    return e
+  }
+
+  let msg = ''
+  const err = e as CallExceptionError
+  if (err.code === 'CALL_EXCEPTION') {
+    if (err.data === '0x') {
+      if (ctx) {
+        msg =
+          "jsonrpc eth_call return '0x' (likely contract not existed) at chain " +
+          ctx.chainId +
+          ': ' +
+          JSON.stringify(e)
+      } else {
+        msg = "jsonrpc eth_call return '0x' (likely contract not existed): " + JSON.stringify(err)
+      }
+      return new SimpleEthersError(msg, err)
+    }
+  }
+
+  msg = 'ethers call error\n' + JSON.stringify(e) + '\n' + e.stack?.toString()
+  return new Error(msg)
+}

package/src/eth/generic-processor.ts

@@ -1,6 +1,6 @@
 import { BaseContract } from 'ethers'
-import { BoundContractView, ContractView } from '../core/context.js'
-import { BindOptions } from '../core/bind-options.js'
+import { BoundContractView, ContractView } from './context.js'
+import { BindOptions } from './bind-options.js'
 import { BaseProcessor } from './base-processor.js'
 import { getProvider } from './provider.js'
 import { addProcessor } from './binds.js'
@@ -17,7 +17,7 @@ export class GenericProcessor extends BaseProcessor<
 
   protected CreateBoundContractView(): BoundContractView<BaseContract, ContractView<BaseContract>> {
     const contract = new BaseContract(this.config.address, this.eventABI, getProvider(this.config.network))
-    return new BoundContractView(new ContractView<BaseContract>(contract))
+    return new BoundContractView(this.config.address, new ContractView<BaseContract>(contract))
   }
 
   public static bind(eventABI: string[] | string, options: BindOptions): GenericProcessor {

package/src/eth/index.ts

@@ -3,6 +3,10 @@ export { GenericProcessor } from './generic-processor.js'
 export { BaseProcessorTemplate } from './base-processor-template.js'
 export { getProvider, DummyProvider } from './provider.js'
 export type { TypedCallTrace, Trace } from './trace.js'
-export { EthPlugin } from './eth-plugin.js'
-
+export * from './eth.js'
+export * from './error.js'
+export { BindOptions, AccountBindOptions } from './bind-options.js'
 export { getProcessor, addProcessor, getContractByABI, addContractByABI } from './binds.js'
+export { ContractContext, ContractView, BoundContractView } from './context.js'
+
+export { EthPlugin } from './eth-plugin.js'

package/src/eth/provider.ts

@@ -31,7 +31,7 @@ export function getProvider(networkish?: Networkish): Provider {
         [...Endpoints.INSTANCE.chainServer.keys()].join(' ')
     )
   }
-  provider = new QueuedStaticJsonRpcProvider(address, network, Endpoints.INSTANCE.concurrency)
+  provider = new QueuedStaticJsonRpcProvider(address, Network.from(network), Endpoints.INSTANCE.concurrency)
   providers.set(network.chainId.toString(), provider)
   return provider
 }
@@ -71,8 +71,9 @@ export function getProvider(networkish?: Networkish): Provider {
 class QueuedStaticJsonRpcProvider extends JsonRpcProvider {
   executor: PQueue
 
-  constructor(url: string, network: Networkish, concurrency: number) {
-    super(url, Network.from(network))
+  constructor(url: string, network: Network, concurrency: number) {
+    // TODO re-enable match when possible
+    super(url, network, { staticNetwork: network, batchMaxCount: 1 })
     this.executor = new PQueue({ concurrency: concurrency })
   }
 

package/src/index.ts

@@ -1,10 +1,5 @@
-export { transformEtherError, EthersError } from './error.js'
-
-// TODO maybe remove this
 export * from '@sentio/protos'
 
 export * from './core/index.js'
-export * from './eth/index.js'
 
-export * from './utils/chain.js'
-// export * from  './api'
+export * from './core/chain.js'

package/src/jest.config.ts

@@ -0,0 +1,8 @@
+/** @type {import('ts-jest/dist/types').JestConfigWithTsJest} */
+export default {
+  preset: 'ts-jest/presets/default-esm',
+  modulePathIgnorePatterns: ['<rootDir>/dist/'],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+}

package/src/solana/builtin/index.ts

@@ -0,0 +1 @@
+export * from './spl-token-processor.js'