@sentio/sdk 2.23.0-rc.1 → 2.24.0-rc.1

package/src/aptos/index.ts

@@ -1,15 +1,26 @@
-export * from './move-types.js'
 export type { TypedEventInstance, TypedFunctionPayload, TypedMoveResource } from './models.js'
-export { defaultMoveCoder, MoveCoder } from './move-coder.js'
 export { AptosBaseProcessor, AptosResourcesProcessor, AptosModulesProcessor } from './aptos-processor.js'
 export { AptosResourceProcessorTemplate } from './aptos-resource-processor-template.js'
 export { AptosContext, AptosResourcesContext } from './context.js'
 export { AptosBindOptions, AptosNetwork } from './network.js'
 export * from './api.js'
-export { ModuleClient } from './module-client.js'
 
 export { AptosPlugin } from './aptos-plugin.js'
 
-export { BUILTIN_TYPES } from '../move/types.js'
+export { defaultMoveCoder } from './move-coder.js'
+
+export type {
+  Event,
+  Transaction_UserTransaction,
+  Address,
+  MoveResource,
+  MoveFunction,
+  MoveStruct,
+  MoveModuleBytecode,
+  TransactionPayload_EntryFunctionPayload
+} from '@typemove/aptos'
+export { MoveCoder } from '@typemove/aptos'
+
+export { BUILTIN_TYPES } from '@typemove/move'
 
 // export * from './utils.js'

package/src/aptos/models.ts

@@ -1,5 +1,5 @@
-import { Event, MoveResource, TransactionPayload_EntryFunctionPayload } from './move-types.js'
-import { DecodedStruct } from '../move/types.js'
+import { Event, MoveResource, TransactionPayload_EntryFunctionPayload } from '@typemove/aptos'
+import { DecodedStruct } from '@typemove/move'
 
 export type TypedEventInstance<T> = DecodedStruct<Event, T>
 export type TypedMoveResource<T> = DecodedStruct<MoveResource, T>

package/src/aptos/move-coder.ts

@@ -1,77 +1,8 @@
-import {
-  Event,
-  MoveModuleBytecode,
-  MoveResource,
-  toInternalModule,
-  TransactionPayload_EntryFunctionPayload,
-} from './move-types.js'
+import { AptosNetwork, getRpcEndpoint } from './network.js'
+import { MoveCoder } from '@typemove/aptos'
 
-import { TypedEventInstance, TypedFunctionPayload, TypedMoveResource } from './models.js'
-import { AbstractMoveCoder } from '../move/abstract-move-coder.js'
-import { AptosNetwork } from './network.js'
-import { AptosChainAdapter } from './aptos-chain-adapter.js'
-import { parseMoveType, TypeDescriptor } from '../move/index.js'
-
-export class MoveCoder extends AbstractMoveCoder<AptosNetwork, MoveModuleBytecode, Event | MoveResource> {
-  constructor(network: AptosNetwork) {
-    super(network)
-    this.adapter = new AptosChainAdapter()
-  }
-
-  load(module: MoveModuleBytecode) {
-    if (!module.abi) {
-      throw Error('Module without abi')
-    }
-    let m = this.moduleMapping.get(module.abi.address + '::' + module.abi.name)
-    // if (this.contains(module.abi.address, module.abi.name)) {
-    //   return
-    // }
-    if (m) {
-      return m
-    }
-    m = toInternalModule(module)
-    this.loadInternal(m)
-    return m
-  }
-
-  decodeEvent<T>(event: Event): Promise<TypedEventInstance<T> | undefined> {
-    return this.decodedStruct(event)
-  }
-  filterAndDecodeEvents<T>(type: string | TypeDescriptor<T>, resources: Event[]): Promise<TypedEventInstance<T>[]> {
-    if (typeof type === 'string') {
-      type = parseMoveType(type)
-    }
-    return this.filterAndDecodeStruct(type, resources)
-  }
-  decodeResource<T>(res: MoveResource): Promise<TypedMoveResource<T> | undefined> {
-    return this.decodedStruct(res)
-  }
-  filterAndDecodeResources<T>(
-    type: string | TypeDescriptor<T>,
-    resources: MoveResource[]
-  ): Promise<TypedMoveResource<T>[]> {
-    if (typeof type === 'string') {
-      type = parseMoveType(type)
-    }
-    return this.filterAndDecodeStruct(type, resources)
-  }
-
-  async decodeFunctionPayload(
-    payload: TransactionPayload_EntryFunctionPayload
-  ): Promise<TransactionPayload_EntryFunctionPayload> {
-    const func = await this.getMoveFunction(payload.function)
-    const params = this.adapter.getMeaningfulFunctionParams(func.params)
-    const argumentsDecoded = await this.decodeArray(payload.arguments, params)
-
-    return {
-      ...payload,
-      arguments_decoded: argumentsDecoded,
-    } as TypedFunctionPayload<any>
-  }
-}
-
-const MOVE_CODER = new MoveCoder(AptosNetwork.MAIN_NET)
-const TESTNET_MOVE_CODER = new MoveCoder(AptosNetwork.TEST_NET)
+const MOVE_CODER = new MoveCoder(getRpcEndpoint(AptosNetwork.MAIN_NET))
+const TESTNET_MOVE_CODER = new MoveCoder(getRpcEndpoint(AptosNetwork.TEST_NET))
 
 export function defaultMoveCoder(network: AptosNetwork = AptosNetwork.MAIN_NET): MoveCoder {
   if (network == AptosNetwork.MAIN_NET) {

package/src/aptos/network.ts

@@ -6,7 +6,7 @@ export type AptosNetwork = AptosChainId
 export const AptosNetwork = <const>{
   MAIN_NET: AptosChainId.APTOS_MAINNET,
   TEST_NET: AptosChainId.APTOS_TESTNET,
-  DEV_NET: AptosChainId.APTOS_DEVNET,
+  DEV_NET: AptosChainId.APTOS_DEVNET
 }
 
 export class AptosBindOptions {
@@ -16,3 +16,11 @@ export class AptosBindOptions {
   startVersion?: bigint | number
   baseLabels?: Labels
 }
+
+export function getRpcEndpoint(network: AptosNetwork): string {
+  switch (network) {
+    case AptosNetwork.TEST_NET:
+      return 'https://testnet.aptoslabs.com/'
+  }
+  return 'https://mainnet.aptoslabs.com/'
+}

package/src/eth/codegen/codegen.ts

@@ -2,7 +2,8 @@ import { loadFileDescriptions, processOutput, skipEmptyAbis } from 'typechain/di
 import * as fs from 'fs'
 import { DEFAULT_FLAGS, Services } from 'typechain'
 import EthersSentio, { SentioEthersConfig } from './ethers-sentio.js'
-import * as prettier from 'prettier'
+// @ts-ignore - no types
+import * as prettier from 'prettier2'
 import path from 'path'
 import mkdirp from 'mkdirp'
 import { YamlContractConfig } from '../../core/yaml-contract-config.js'
@@ -20,7 +21,7 @@ export async function codegen(abisDir: string, outDir: string, contractsToGenExa
 async function codegenInternal(
   abisDir: string,
   outDir: string,
-  contractsToGenExample: YamlContractConfig[],
+  contractsToGenExample: YamlContractConfig[]
 ): Promise<number> {
   const allFiles = fs.readdirSync(abisDir)
   if (allFiles.length === 0) {
@@ -51,14 +52,14 @@ async function codegenInternal(
     outDir: outInternal,
     allFiles: allABIFiles,
     filesToProcess: allABIFiles,
-    contractsToGenExample: contractsToGenExample,
+    contractsToGenExample: contractsToGenExample
   }
   const services: Services = {
     fs,
     // @ts-ignore for test
     // prettier: { format: (s) => s },
     prettier: prettier,
-    mkdirp: mkdirp.sync,
+    mkdirp: mkdirp.sync
   }
   let filesGenerated = 0
 

package/src/move/ext/move-dex.ts

@@ -1,4 +1,4 @@
-import { DecodedStruct, TypeDescriptor } from '../types.js'
+import { DecodedStruct, TypeDescriptor } from '@typemove/move'
 import { BigDecimal } from '@sentio/bigdecimal'
 import { Gauge } from '../../core/index.js'
 import { MoveAccountContext, MoveContext } from '../move-context.js'
@@ -92,21 +92,21 @@ export class MoveDex<
     if (total.gt(0)) {
       this.volume.record(ctx, total, {
         ...baseLabels,
-        bridge: coinXInfo.bridge,
+        bridge: coinXInfo.bridge
       })
     }
     if (resultX.gt(0)) {
       this.volumeByCoin.record(ctx, resultX, {
         coin: coinXInfo.symbol,
         bridge: coinXInfo.bridge,
-        type: coinXInfo.token_type.type,
+        type: coinXInfo.token_type.type
       })
     }
     if (resultY.gt(0)) {
       this.volumeByCoin.record(ctx, resultY, {
         coin: coinYInfo.symbol,
         bridge: coinYInfo.bridge,
-        type: coinYInfo.token_type.type,
+        type: coinYInfo.token_type.type
       })
     }
     result = resultX.plus(resultY).div(2)
@@ -201,7 +201,7 @@ export class MoveDex<
         this.tvlByCoin.record(ctx, v, {
           coin: coinInfo.symbol,
           bridge: coinInfo.bridge,
-          type: coinInfo.token_type.type,
+          type: coinInfo.token_type.type
         })
       }
     }

package/src/move/index.ts

@@ -1,8 +1,6 @@
 export * from './filter.js'
-export * from './types.js'
-export * from './utils.js'
-export * from './account.js'
-export * from './chain-adapter.js'
 export * from './move-context.js'
 
+export * from '@typemove/move'
+
 export { MoveFetchConfig } from '@sentio/protos'

package/src/move/move-context.ts

@@ -1,9 +1,9 @@
 import { BaseContext } from '../core/index.js'
-import { AbstractMoveCoder } from './abstract-move-coder.js'
+import { AbstractMoveCoder } from '@typemove/move'
 
 export abstract class MoveContext<Network, ModuleType, StructType> extends BaseContext {
   address: string
-  coder: AbstractMoveCoder<Network, ModuleType, StructType>
+  coder: AbstractMoveCoder<ModuleType, StructType>
   network: Network
 
   abstract getTimestamp(): number
@@ -11,7 +11,7 @@ export abstract class MoveContext<Network, ModuleType, StructType> extends BaseC
 
 export abstract class MoveAccountContext<Network, ModuleType, StructType> extends BaseContext {
   address: string
-  coder: AbstractMoveCoder<Network, ModuleType, StructType>
+  coder: AbstractMoveCoder<ModuleType, StructType>
   network: Network
 
   abstract getTimestamp(): number

package/src/move/shared-network-codegen.ts

@@ -0,0 +1,160 @@
+import {
+  AbstractCodegen,
+  ChainAdapter,
+  InternalMoveFunction,
+  InternalMoveModule,
+  InternalMoveStruct,
+  moduleQname,
+  SPLITTER,
+  normalizeToJSName,
+  upperFirst
+} from '@typemove/move'
+import { camel } from 'radash'
+
+export abstract class SharedNetworkCodegen<NetworkType, ModuleTypes, StructType> extends AbstractCodegen<
+  ModuleTypes,
+  StructType
+> {
+  network: NetworkType
+  constructor(network: NetworkType, chainAdapter: ChainAdapter<ModuleTypes, StructType>) {
+    super(chainAdapter)
+    this.network = network
+  }
+  generateModule(module: InternalMoveModule, allEventStructs: Map<string, InternalMoveStruct>) {
+    const functions = module.exposedFunctions
+      .map((f) => this.generateForEntryFunctions(module, f))
+      .filter((s) => s !== '')
+
+    const qname = moduleQname(module)
+    const eventStructs = new Map<string, InternalMoveStruct>()
+    for (const [type, struct] of allEventStructs.entries()) {
+      if (type.startsWith(qname + SPLITTER)) {
+        eventStructs.set(type, struct)
+      }
+    }
+
+    const events = Array.from(eventStructs.values())
+      .map((e) => this.generateForOnEvents(module, e))
+      .filter((s) => s !== '')
+
+    const moduleName = normalizeToJSName(module.name)
+
+    let processor = ''
+    if (functions.length > 0 || events.length > 0) {
+      processor = `export class ${moduleName} extends ${this.PREFIX}BaseProcessor {
+
+    constructor(options: ${this.PREFIX}BindOptions) {
+      super("${module.name}", options)
+    }
+    static DEFAULT_OPTIONS: ${this.PREFIX}BindOptions = {
+      address: "${module.address}",
+      network: ${this.PREFIX}Network.${this.generateNetworkOption(this.network)}
+    }
+
+    static bind(options: Partial<${this.PREFIX}BindOptions> = {}): ${moduleName} {
+      return new ${moduleName}({ ...${moduleName}.DEFAULT_OPTIONS, ...options })
+    }
+
+    ${functions.join('\n')}
+    
+    ${events.join('\n')}
+ }
+  `
+    }
+
+    return processor + super.generateModule(module, allEventStructs)
+  }
+
+  // protected generateExtra(module: InternalMoveModule): string {
+  //   const callArgs = module.exposedFunctions.map((f: InternalMoveFunction) => this.generateCallArgsStructs(module, f))
+  //
+  //   return `
+  //     ${callArgs.join('\n')}
+  //   `
+  // }
+
+  abstract generateNetworkOption(network: NetworkType): string
+
+  generateForEntryFunctions(module: InternalMoveModule, func: InternalMoveFunction) {
+    if (!func.isEntry) {
+      return ''
+    }
+
+    // const genericString = generateFunctionTypeParameters(func)
+    const moduleName = normalizeToJSName(module.name)
+
+    const camelFuncName = upperFirst(camel(func.name))
+    const source = `
+  onEntry${camelFuncName}(func: (call: ${moduleName}.${camelFuncName}Payload, ctx: ${this.PREFIX}Context) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): ${moduleName} {
+    this.onEntryFunctionCall(func, {
+      ...filter,
+      function: '${module.name}::${func.name}'
+    },
+    fetchConfig)
+    return this
+  }`
+
+    return source
+  }
+
+  generateForOnEvents(module: InternalMoveModule, struct: InternalMoveStruct): string {
+    const moduleName = normalizeToJSName(module.name)
+    const source = `
+onEvent${struct.name}(func: (event: ${moduleName}.${normalizeToJSName(struct.name)}Instance, ctx: ${
+      this.PREFIX
+    }Context) => void, fetchConfig?: Partial<MoveFetchConfig>): ${moduleName} {
+  this.onMoveEvent(func, { type: '${module.name}::${struct.name}' }, fetchConfig)
+  return this
+}`
+    return source
+  }
+
+  generateImports() {
+    return (
+      super.generateImports() +
+      `
+    import { CallFilter, MoveFetchConfig } from "@sentio/sdk/move"
+    import {
+      ${this.PREFIX}BindOptions, ${this.PREFIX}BaseProcessor,
+      ${this.PREFIX}Network, TypedFunctionPayload,
+      ${this.PREFIX}Context } from "@sentio/sdk/${this.PREFIX.toLowerCase()}"
+`
+    )
+  }
+
+  protected defaultCoderPackage(): string {
+    return `@sentio/sdk/${this.PREFIX.toLowerCase()}`
+  }
+
+  generateLoadAll(isSystem: boolean): string {
+    let source = `loadAllTypes(defaultMoveCoder(${this.PREFIX}Network.${this.generateNetworkOption(this.network)}))`
+    if (isSystem) {
+      source = `
+      loadAllTypes(defaultMoveCoder(${this.PREFIX}Network.MAIN_NET))
+      loadAllTypes(defaultMoveCoder(${this.PREFIX}Network.TEST_NET))
+      `
+    }
+    return source
+  }
+
+  generateCallArgsStructs(module: InternalMoveModule, func: InternalMoveFunction) {
+    if (!func.isEntry) {
+      return ''
+    }
+
+    const fields = this.chainAdapter.getMeaningfulFunctionParams(func.params).map((param) => {
+      return this.generateTypeForDescriptor(param, module.address) + (this.PAYLOAD_OPTIONAL ? ' | undefined' : '')
+    })
+
+    const camelFuncName = upperFirst(camel(func.name))
+
+    const genericString = this.generateFunctionTypeParameters(func)
+    return `
+  export interface ${camelFuncName}Payload${genericString}
+      extends TypedFunctionPayload<[${fields.join(',')}]> {
+    arguments_decoded: [${fields.join(',')}],
+    type_arguments: [${func.typeParams.map((_) => 'string').join(', ')}]
+  }
+  `
+  }
+}