@sentio/sdk 2.5.4-rc.1 → 2.5.5-rc.1

package/src/aptos/module-client.ts

@@ -0,0 +1,30 @@
+import { defaultMoveCoder } from './index.js'
+import { AptosClient, Types } from 'aptos-sdk'
+
+export class ModuleClient {
+  client: AptosClient
+  constructor(client: AptosClient | string) {
+    if (typeof client === 'string') {
+      this.client = new AptosClient(client)
+    } else {
+      this.client = client
+    }
+  }
+  public async viewDecoded(
+    func: string,
+    typeArguments: string[],
+    args: any[],
+    ledger_version?: bigint
+  ): Promise<any[]> {
+    const coder = defaultMoveCoder()
+    const encodedArgs = coder.encodeCallArgs(args, func)
+
+    const request: Types.ViewRequest = {
+      function: func,
+      type_arguments: typeArguments,
+      arguments: encodedArgs,
+    }
+    const res = await this.client.view(request, ledger_version?.toString())
+    return coder.decodeCallResult(res, func)
+  }
+}

package/src/aptos/move-coder.ts

@@ -6,9 +6,10 @@ import {
   TransactionPayload_EntryFunctionPayload,
 } from './move-types.js'
 
-import { TypedEventInstance, TypedMoveResource, TypedEntryFunctionPayload } from './models.js'
+import { TypedEventInstance, TypedMoveResource, TypedFunctionPayload } from './models.js'
 import { getMeaningfulFunctionParams } from './utils.js'
 import { AbstractMoveCoder } from '../move/abstract-move-coder.js'
+import { TypeDescriptor } from '../move/index.js'
 
 export class MoveCoder extends AbstractMoveCoder<Event | MoveResource> {
   load(module: MoveModuleBytecode) {
@@ -34,26 +35,19 @@ export class MoveCoder extends AbstractMoveCoder<Event | MoveResource> {
     return this.filterAndDecodeInternal(typeQname, resources)
   }
 
-  decodeFunctionPayload(payload: TransactionPayload_EntryFunctionPayload): TransactionPayload_EntryFunctionPayload {
-    const argumentsTyped: any[] = []
+  getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
+    return getMeaningfulFunctionParams(params)
+  }
 
-    try {
-      const func = this.getMoveFunction(payload.function)
-      const params = getMeaningfulFunctionParams(func.params)
-      for (const [idx, arg] of payload.arguments.entries()) {
-        // TODO consider apply payload.type_arguments, but this might be hard since we don't code gen for them
-        const argType = params[idx]
-        argumentsTyped.push(this.decode(arg, argType))
-      }
-    } catch (e) {
-      console.error('Decoding error for ', JSON.stringify(payload), e)
-      return payload
-    }
+  decodeFunctionPayload(payload: TransactionPayload_EntryFunctionPayload): TransactionPayload_EntryFunctionPayload {
+    const func = this.getMoveFunction(payload.function)
+    const params = getMeaningfulFunctionParams(func.params)
+    const argumentsDecoded = this.decodeArray(payload.arguments, params)
 
     return {
       ...payload,
-      arguments_decoded: argumentsTyped,
-    } as TypedEntryFunctionPayload<any>
+      arguments_decoded: argumentsDecoded,
+    } as TypedFunctionPayload<any>
   }
 }
 

package/src/aptos/network.ts

@@ -1,4 +1,5 @@
 import { CHAIN_IDS, getChainName } from '../core/chain.js'
+import { AptosClient } from 'aptos-sdk'
 
 export enum AptosNetwork {
   MAIN_NET = 1,
@@ -25,5 +26,6 @@ export function getAptosChainName(network: AptosNetwork): string {
 export class AptosBindOptions {
   address: string
   network?: AptosNetwork = AptosNetwork.MAIN_NET
+  client?: AptosClient
   startVersion?: bigint | number
 }

package/src/move/abstract-codegen.ts

@@ -1,4 +1,9 @@
-import { InternalMoveFunction, InternalMoveModule, InternalMoveStruct } from './internal-models.js'
+import {
+  InternalMoveFunction,
+  InternalMoveFunctionVisibility,
+  InternalMoveModule,
+  InternalMoveStruct,
+} from './internal-models.js'
 import path from 'path'
 import fs from 'fs'
 import { AccountModulesImportInfo, AccountRegister } from './account.js'
@@ -26,6 +31,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
   ADDRESS_TYPE: string
   PREFIX: string
   STRUCT_FIELD_NAME: string = 'data'
+  GENERATED_CLIENT = false
 
   abstract fetchModules(account: string, network: NetworkType): Promise<ModuleTypes>
   abstract toInternalModules(modules: ModuleTypes): InternalMoveModule[]
@@ -48,9 +54,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     if (!fs.existsSync(srcDir)) {
       return
     }
-    if (network === this.TEST_NET) {
-      console.log('Found testnet directory, generate code for testnet modules')
-    }
+
     const files = fs.readdirSync(srcDir)
     outputDir = path.resolve(outputDir)
     const outputs: OutputFile[] = []
@@ -118,6 +122,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     }
 
     for (const output of outputs) {
+      // const content = output.fileContent
       const content = format(output.fileContent, { parser: 'typescript' })
       fs.writeFileSync(path.join(outputDir, output.fileName), content)
     }
@@ -132,7 +137,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     )
     for (const output of outputs) {
       const parsed = path.parse(output.fileName)
-      const content = `export * as _${parsed.name} from './${parsed.name}.js'\n`
+      const content = `export * as _${parsed.name.replaceAll('-', '_')} from './${parsed.name}.js'\n`
       fs.appendFileSync(rootFile, content)
     }
   }
@@ -149,7 +154,9 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     const functions = module.exposedFunctions
       .map((f) => this.generateOnEntryFunctions(module, f))
       .filter((s) => s !== '')
-
+    const clientFunctions = module.exposedFunctions
+      .map((f) => this.generateClientFunctions(module, f))
+      .filter((s) => s !== '')
     const eventStructs = this.getEventStructs(module)
     const eventTypes = new Set(eventStructs.keys())
     const events = Array.from(eventStructs.values())
@@ -160,6 +167,16 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
 
     const moduleName = normalizeToJSName(module.name)
     let processor = ''
+    let client = ''
+
+    if (this.GENERATED_CLIENT && clientFunctions.length > 0) {
+      client = `
+      export class ${moduleName}_client extends ModuleClient {
+        ${clientFunctions.join('\n')}
+      }
+      `
+    }
+
     if (functions.length > 0 || events.length > 0) {
       processor = `export class ${moduleName} extends ${this.PREFIX}BaseProcessor {
 
@@ -183,6 +200,8 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     }
 
     return `
+  ${client}
+
   ${processor}
 
   export namespace ${moduleName} {
@@ -266,13 +285,40 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     const genericString = this.generateFunctionTypeParameters(func)
     return `
   export interface ${camelFuncName}Payload${genericString}
-      extends TypedEntryFunctionPayload<[${fields.join(',')}]> {
+      extends TypedFunctionPayload<[${fields.join(',')}]> {
     arguments_decoded: [${fields.join(',')}],
     type_arguments: [${func.typeParams.map((_) => 'string').join(', ')}]
   }
   `
   }
 
+  generateClientFunctions(module: InternalMoveModule, func: InternalMoveFunction) {
+    if (func.visibility === InternalMoveFunctionVisibility.PRIVATE) {
+      return ''
+    }
+    if (func.isEntry) {
+      return ''
+    }
+    // const moduleName = normalizeToJSName(module.name)
+    const funcName = camelCase(func.name)
+    const fields = this.getMeaningfulFunctionParams(func.params).map((param) => {
+      return generateTypeForDescriptor(param, module.address, this.ADDRESS_TYPE)
+    })
+    const genericString = this.generateFunctionTypeParameters(func)
+
+    const returns = func.return.map((param) => {
+      return generateTypeForDescriptor(param, module.address, this.ADDRESS_TYPE)
+    })
+
+    const source = `
+  ${funcName}${genericString}(type_arguments: [${func.typeParams
+      .map((_) => 'string')
+      .join(', ')}], args: [${fields.join(',')}], version?: bigint): Promise<[${returns.join(',')}]> {
+    return this.viewDecoded('${module.address}::${module.name}::${func.name}', type_arguments, args, version) as any
+  }`
+    return source
+  }
+
   generateOnEntryFunctions(module: InternalMoveModule, func: InternalMoveFunction) {
     if (!func.isEntry) {
       return ''
@@ -359,10 +405,10 @@ export class AccountCodegen<ModuleType, NetworkType> {
     import { CallFilter } from "@sentio/sdk/move"
     import {
       MoveCoder, defaultMoveCoder, ${this.moduleGen.PREFIX}BindOptions, ${this.moduleGen.PREFIX}BaseProcessor,
-      TypedEventInstance, ${this.moduleGen.PREFIX}Network, TypedEntryFunctionPayload,
+      TypedEventInstance, ${this.moduleGen.PREFIX}Network, TypedFunctionPayload,
       ${this.moduleGen.PREFIX}Context } from "@sentio/sdk/${this.moduleGen.PREFIX.toLowerCase()}"
     import { MoveFetchConfig } from "@sentio/protos"
-    import { ${this.moduleGen.ADDRESS_TYPE} } from "@sentio/sdk/${this.moduleGen.PREFIX.toLowerCase()}"
+    import { ${this.moduleGen.ADDRESS_TYPE}, ModuleClient } from "@sentio/sdk/${this.moduleGen.PREFIX.toLowerCase()}"
     `
 
     const dependedAccounts: string[] = []

package/src/move/abstract-move-coder.ts

@@ -22,7 +22,9 @@ export abstract class AbstractMoveCoder<StructType> {
     return this.moduleMapping.has(account + '::' + name)
   }
 
-  loadInternal(module: InternalMoveModule) {
+  protected abstract getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[]
+
+  protected loadInternal(module: InternalMoveModule) {
     if (this.contains(module.address, module.name)) {
       return
     }
@@ -35,15 +37,15 @@ export abstract class AbstractMoveCoder<StructType> {
     }
 
     for (const func of module.exposedFunctions) {
-      if (!func.isEntry) {
-        continue
-      }
+      // if (!func.isEntry) {
+      //   continue
+      // }
       const key = [module.address, module.name, func.name].join(SPLITTER)
       this.funcMapping.set(key, func)
     }
   }
 
-  protected dataToBigInt(data: any): bigint {
+  protected decodeBigInt(data: any): bigint {
     if (Array.isArray(data)) {
       // Only sui function need this, strange
       const bytes = data as number[]
@@ -53,7 +55,11 @@ export abstract class AbstractMoveCoder<StructType> {
     }
   }
 
-  protected getMoveStruct(type: string): InternalMoveStruct {
+  protected encodeBigInt(data: bigint): any {
+    return '0x' + data.toString(16)
+  }
+
+  getMoveStruct(type: string): InternalMoveStruct {
     const struct = this.typeMapping.get(type)
     if (!struct) {
       throw new Error('Failed to load type' + type + ' type are not imported anywhere')
@@ -61,15 +67,15 @@ export abstract class AbstractMoveCoder<StructType> {
     return struct
   }
 
-  protected getMoveFunction(type: string): InternalMoveFunction {
+  getMoveFunction(type: string): InternalMoveFunction {
     const func = this.funcMapping.get(type)
     if (!func) {
-      throw new Error('Failed to load function' + type + ' type are not imported anywhere')
+      throw new Error('Failed to load function ' + type + ' type are not imported anywhere')
     }
     return func
   }
 
-  protected decode(data: any, type: TypeDescriptor): any {
+  decode(data: any, type: TypeDescriptor): any {
     // process simple type
     if (type.reference) {
       return data
@@ -94,7 +100,7 @@ export abstract class AbstractMoveCoder<StructType> {
       case 'U64':
       case 'u128':
       case 'U128':
-        return this.dataToBigInt(data)
+        return this.decodeBigInt(data)
     }
 
     // process vector
@@ -130,6 +136,106 @@ export abstract class AbstractMoveCoder<StructType> {
     return typedData
   }
 
+  encode(data: any, type: TypeDescriptor): any {
+    // process simple type
+    if (type.reference) {
+      return data
+    }
+    switch (type.qname) {
+      case 'signer': // TODO check this, aptos only
+      case 'address':
+      case 'Address':
+      case '0x2::object::ID':
+      case '0x2::coin::Coin':
+      case '0x1::string::String':
+      case 'bool':
+      case 'Bool':
+      case 'u8':
+      case 'U8':
+      case 'u16':
+      case 'U16':
+      case 'u32':
+      case 'U32':
+        return data
+      case 'u64':
+      case 'U64':
+      case 'u128':
+      case 'U128':
+        return this.encodeBigInt(data)
+    }
+
+    // process vector
+    if (type.qname === VECTOR_STR) {
+      // vector<u8> as hex string
+      if (type.typeArgs[0].qname === 'u8' || type.typeArgs[0].qname === 'U8') {
+        return data
+      }
+
+      const res = []
+      for (const entry of data) {
+        res.push(this.encode(entry, type.typeArgs[0]))
+      }
+      return res
+    }
+
+    // Process complex type
+    const struct = this.getMoveStruct(type.qname)
+
+    const typeCtx = new Map<string, TypeDescriptor>()
+    for (const [idx, typeArg] of type.typeArgs.entries()) {
+      typeCtx.set('T' + idx, typeArg)
+    }
+
+    const typedData: any = {}
+
+    for (const field of struct.fields) {
+      let filedType = field.type
+      filedType = filedType.applyTypeArgs(typeCtx)
+      const value = this.encode(data[field.name], filedType)
+      typedData[field.name] = value
+    }
+    return typedData
+  }
+
+  decodeArray(entries: any[], types: TypeDescriptor[]): any[] {
+    const entriesDecoded: any[] = []
+    for (const [idx, arg] of entries.entries()) {
+      // TODO consider apply payload.type_arguments, but this might be hard since we don't code gen for them
+      const argType = types[idx]
+      try {
+        entriesDecoded.push(this.decode(arg, argType))
+      } catch (e) {
+        console.error(e, 'Decoding error for ', JSON.stringify(arg), 'using type', argType)
+        return entries
+      }
+    }
+    return entriesDecoded
+  }
+
+  encodeArray(entriesDecoded: any[], types: TypeDescriptor[]): any[] {
+    const entries: any[] = []
+    for (const [idx, arg] of entriesDecoded.entries()) {
+      // TODO consider apply payload.type_arguments, but this might be hard since we don't code gen for them
+      const argType = types[idx]
+      try {
+        entries.push(this.encode(arg, argType))
+      } catch (e) {
+        throw Error('Decoding error for ' + JSON.stringify(arg) + 'using type' + argType + e.toString())
+      }
+    }
+    return entries
+  }
+
+  encodeCallArgs(args: any[], func: string): any[] {
+    const f = this.getMoveFunction(func)
+    return this.encodeArray(args, this.getMeaningfulFunctionParams(f.params))
+  }
+
+  decodeCallResult(res: any[], func: string): any[] {
+    const f = this.getMoveFunction(func)
+    return this.decodeArray(res, f.return)
+  }
+
   protected filterAndDecodeInternal<T>(
     typeQname: string,
     structs: StructWithTag<StructType>[]

package/src/move/ts-type.ts

@@ -52,7 +52,7 @@ export function generateTypeForDescriptor(type: TypeDescriptor, currentAddress:
   if (simpleName.length === 0) {
     console.error('unexpected error')
   }
-  if (simpleName.toLowerCase().includes(VECTOR_STR)) {
+  if (simpleName.toLowerCase() === VECTOR_STR || simpleName.toLowerCase().startsWith(VECTOR_STR + SPLITTER)) {
     console.error('unexpected vector type error')
   }
   if (type.typeArgs.length > 0) {

package/src/move/utils.ts

@@ -6,7 +6,7 @@ export function isFrameworkAccount(account: string) {
   return account === '0x1' || account === '0x2' || account === '0x3'
 }
 
-const KEYWORDS = new Set(['package', 'namespace', 'volatile', 'object', 'string', 'number', 'bigint'])
+const KEYWORDS = new Set(['package', 'namespace', 'volatile', 'object', 'string', 'number', 'bigint', 'any'])
 
 export function normalizeToJSName(name: string) {
   if (KEYWORDS.has(name)) {

package/src/sui/builtin/0x1.ts

@@ -12,11 +12,11 @@ import {
   SuiBaseProcessor,
   TypedEventInstance,
   SuiNetwork,
-  TypedEntryFunctionPayload,
+  TypedFunctionPayload,
   SuiContext,
 } from "@sentio/sdk/sui";
 import { MoveFetchConfig } from "@sentio/protos";
-import { SuiAddress } from "@sentio/sdk/sui";
+import { SuiAddress, ModuleClient } from "@sentio/sdk/sui";
 
 export namespace address {}