@sentio/sdk 2.5.0 → 2.5.1-rc.2

package/src/move/abstract-codegen.ts

@@ -1,4 +1,4 @@
-import { NeutralMoveFunction, NeutralMoveModule, NeutralMoveStruct } from './neutral-models.js'
+import { InternalMoveFunction, InternalMoveModule, InternalMoveStruct } from './internal-models.js'
 import path from 'path'
 import fs from 'fs'
 import { AccountModulesImportInfo, AccountRegister } from './account.js'
@@ -6,7 +6,7 @@ import chalk from 'chalk'
 import { format } from 'prettier'
 import { isFrameworkAccount, moduleQname, normalizeToJSName, SPLITTER } from './utils.js'
 import { generateTypeForDescriptor } from './ts-type.js'
-import { camelCase } from 'lodash-es'
+import { camelCase, upperFirst } from 'lodash-es'
 import { TypeDescriptor } from './types.js'
 
 interface OutputFile {
@@ -28,9 +28,11 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
   STRUCT_FIELD_NAME: string = 'data'
 
   abstract fetchModules(account: string, network: NetworkType): Promise<ModuleTypes>
-  abstract toNeutral(modules: ModuleTypes): NeutralMoveModule[]
-  abstract getEventStructs(module: NeutralMoveModule): Map<string, NeutralMoveStruct>
-
+  abstract toInternalModules(modules: ModuleTypes): InternalMoveModule[]
+  // Get the structs that represent Events
+  abstract getEventStructs(module: InternalMoveModule): Map<string, InternalMoveStruct>
+  // Get the parameters that actually have arguments in runtime
+  // Aptos first signer and Sui's last TxContext are no use
   abstract getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[]
 
   readModulesFile(fullPath: string) {
@@ -69,7 +71,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
       }
       const fullPath = path.resolve(srcDir, file)
       const abi = this.readModulesFile(fullPath)
-      const modules = this.toNeutral(abi)
+      const modules = this.toInternalModules(abi)
 
       for (const module of modules) {
         loader.register(module, path.basename(file, '.json'))
@@ -89,7 +91,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
 
         try {
           const rawModules = await this.fetchModules(account, network)
-          const modules = this.toNeutral(rawModules)
+          const modules = this.toInternalModules(rawModules)
 
           fs.writeFileSync(path.resolve(srcDir, account + '.json'), JSON.stringify(rawModules, null, '\t'))
 
@@ -143,8 +145,8 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     return 'MAIN_NET'
   }
 
-  generateModule(module: NeutralMoveModule, network: NetworkType) {
-    const functions = module.exposed_functions
+  generateModule(module: InternalMoveModule, network: NetworkType) {
+    const functions = module.exposedFunctions
       .map((f) => this.generateOnEntryFunctions(module, f))
       .filter((s) => s !== '')
 
@@ -154,7 +156,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
       .map((e) => this.generateOnEvents(module, e))
       .filter((s) => s !== '')
     const structs = module.structs.map((s) => this.generateStructs(module, s, eventTypes))
-    const callArgs = module.exposed_functions.map((f) => this.generateCallArgsStructs(module, f))
+    const callArgs = module.exposedFunctions.map((f) => this.generateCallArgsStructs(module, f))
 
     const moduleName = normalizeToJSName(module.name)
     let processor = ''
@@ -166,15 +168,15 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     }
     static DEFAULT_OPTIONS: ${this.PREFIX}BindOptions = {
       address: "${module.address}",
-      network: ${this.PREFIX}Network.${this.generateNetworkOption(network)}       
+      network: ${this.PREFIX}Network.${this.generateNetworkOption(network)}
     }
 
     static bind(options: Partial<${this.PREFIX}BindOptions> = {}): ${moduleName} {
       return new ${moduleName}({ ...${moduleName}.DEFAULT_OPTIONS, ...options })
     }
-    
+
     ${functions.join('\n')}
-    
+
     ${events.join('\n')}
   }
   `
@@ -185,13 +187,13 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
 
   export namespace ${moduleName} {
     ${structs.join('\n')}
-    
+
     ${callArgs.join('\n')}
  }
   `
   }
 
-  generateStructs(module: NeutralMoveModule, struct: NeutralMoveStruct, events: Set<string>) {
+  generateStructs(module: InternalMoveModule, struct: InternalMoveStruct, events: Set<string>) {
     const genericString = this.generateStructTypeParameters(struct)
     const genericStringAny = this.generateStructTypeParameters(struct, true)
 
@@ -205,10 +207,10 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     let eventPayload = ''
     if (events.has(moduleQname(module) + SPLITTER + struct.name)) {
       eventPayload = `
-    export interface ${structName}Instance extends 
+    export interface ${structName}Instance extends
         TypedEventInstance<${structName}${genericStringAny}> {
       ${this.STRUCT_FIELD_NAME}_decoded: ${structName}${genericStringAny}
-      type_arguments: [${struct.generic_type_params.map((_) => 'string').join(', ')}]
+      type_arguments: [${struct.typeParams.map((_) => 'string').join(', ')}]
     }
     `
     }
@@ -216,17 +218,17 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     return `
   export class ${structName}${genericString} {
     static TYPE_QNAME = '${module.address}::${module.name}::${struct.name}'
-    ${fields.join('\n')} 
+    ${fields.join('\n')}
   }
-  
+
   ${eventPayload}
   `
   }
 
-  generateFunctionTypeParameters(func: NeutralMoveFunction) {
+  generateFunctionTypeParameters(func: InternalMoveFunction) {
     let genericString = ''
-    if (func.generic_type_params && func.generic_type_params.length > 0) {
-      const params = func.generic_type_params
+    if (func.typeParams && func.typeParams.length > 0) {
+      const params = func.typeParams
         .map((v, idx) => {
           return `T${idx}=any`
         })
@@ -236,11 +238,11 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     return genericString
   }
 
-  generateStructTypeParameters(struct: NeutralMoveStruct, useAny = false) {
+  generateStructTypeParameters(struct: InternalMoveStruct, useAny = false) {
     let genericString = ''
 
-    if (struct.generic_type_params && struct.generic_type_params.length > 0) {
-      const params = struct.generic_type_params
+    if (struct.typeParams && struct.typeParams.length > 0) {
+      const params = struct.typeParams
         .map((v, idx) => {
           return useAny ? 'any' : 'T' + idx
         })
@@ -250,8 +252,8 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     return genericString
   }
 
-  generateCallArgsStructs(module: NeutralMoveModule, func: NeutralMoveFunction) {
-    if (!func.is_entry) {
+  generateCallArgsStructs(module: InternalMoveModule, func: InternalMoveFunction) {
+    if (!func.isEntry) {
       return
     }
 
@@ -259,27 +261,27 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
       return generateTypeForDescriptor(param, module.address, this.ADDRESS_TYPE)
     })
 
-    const camelFuncName = capitalizeFirstChar(camelCase(func.name))
+    const camelFuncName = upperFirst(camelCase(func.name))
 
     const genericString = this.generateFunctionTypeParameters(func)
     return `
   export interface ${camelFuncName}Payload${genericString}
       extends TypedEntryFunctionPayload<[${fields.join(',')}]> {
     arguments_decoded: [${fields.join(',')}],
-    type_arguments: [${func.generic_type_params.map((_) => 'string').join(', ')}]
+    type_arguments: [${func.typeParams.map((_) => 'string').join(', ')}]
   }
   `
   }
 
-  generateOnEntryFunctions(module: NeutralMoveModule, func: NeutralMoveFunction) {
-    if (!func.is_entry) {
+  generateOnEntryFunctions(module: InternalMoveModule, func: InternalMoveFunction) {
+    if (!func.isEntry) {
       return ''
     }
 
     // const genericString = generateFunctionTypeParameters(func)
     const moduleName = normalizeToJSName(module.name)
 
-    const camelFuncName = capitalizeFirstChar(camelCase(func.name))
+    const camelFuncName = upperFirst(camelCase(func.name))
     const source = `
   onEntry${camelFuncName}(func: (call: ${moduleName}.${camelFuncName}Payload, ctx: ${this.PREFIX}Context) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): ${moduleName} {
     this.onEntryFunctionCall(func, {
@@ -293,7 +295,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     return source
   }
 
-  generateOnEvents(module: NeutralMoveModule, struct: NeutralMoveStruct): string {
+  generateOnEvents(module: InternalMoveModule, struct: InternalMoveStruct): string {
     // for struct that has drop + store
     // if (!isEvent(struct, module)) {
     //   return ''
@@ -318,7 +320,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
 }
 
 export class AccountCodegen<ModuleType, NetworkType> {
-  modules: NeutralMoveModule[]
+  modules: InternalMoveModule[]
   config: Config<NetworkType>
   abi: ModuleType
   loader: AccountRegister
@@ -328,7 +330,7 @@ export class AccountCodegen<ModuleType, NetworkType> {
     moduleGen: AbstractCodegen<ModuleType, NetworkType>,
     loader: AccountRegister,
     abi: ModuleType,
-    modules: NeutralMoveModule[],
+    modules: InternalMoveModule[],
     config: Config<NetworkType>
   ) {
     // const json = fs.readFileSync(config.srcFile, 'utf-8')
@@ -355,8 +357,8 @@ export class AccountCodegen<ModuleType, NetworkType> {
 
     const imports = `
     import { CallFilter } from "@sentio/sdk/move"
-    import { 
-      MoveCoder, defaultMoveCoder, ${this.moduleGen.PREFIX}BindOptions, ${this.moduleGen.PREFIX}BaseProcessor, 
+    import {
+      MoveCoder, defaultMoveCoder, ${this.moduleGen.PREFIX}BindOptions, ${this.moduleGen.PREFIX}BaseProcessor,
       TypedEventInstance, ${this.moduleGen.PREFIX}Network, TypedEntryFunctionPayload,
       ${this.moduleGen.PREFIX}Context } from "@sentio/sdk/${this.moduleGen.PREFIX.toLowerCase()}"
     import { MoveFetchConfig } from "@sentio/protos"
@@ -388,15 +390,15 @@ export class AccountCodegen<ModuleType, NetworkType> {
     /* Autogenerated file. Do not edit manually. */
     /* tslint:disable */
     /* eslint-disable */
-  
+
     /* Generated modules for account ${address} */
-  
+
     ${imports}
-    
+
     ${moduleImports.join('\n')}
-    
+
     ${this.modules.map((m) => this.moduleGen.generateModule(m, this.config.network)).join('\n')}
-    
+
     const MODULES = JSON.parse('${JSON.stringify(this.abi)}')
 
     export function loadAllTypes(coder: MoveCoder) {
@@ -405,7 +407,7 @@ export class AccountCodegen<ModuleType, NetworkType> {
         coder.load(m as any)
       }
     }
-    
+
     loadAllTypes(defaultMoveCoder())
     ` // source
 
@@ -417,10 +419,3 @@ export class AccountCodegen<ModuleType, NetworkType> {
     ]
   }
 }
-
-function capitalizeFirstChar(input: string): string {
-  if (!input) {
-    return input
-  }
-  return input[0].toUpperCase() + (input.length > 1 ? input.substring(1) : '')
-}

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

@@ -1,6 +1,6 @@
 import { moduleQname, SPLITTER, VECTOR_STR } from './utils.js'
 import { parseMoveType, TypeDescriptor } from './types.js'
-import { NeutralMoveFunction, NeutralMoveModule, NeutralMoveStruct } from './neutral-models.js'
+import { InternalMoveFunction, InternalMoveModule, InternalMoveStruct } from './internal-models.js'
 import { bytesToBigInt } from '../utils/index.js'
 
 type StructWithTag<Base> = Base & {
@@ -14,15 +14,15 @@ type DecodedStructWithTag<B, T> = StructWithTag<B> & {
 }
 
 export abstract class AbstractMoveCoder<StructType> {
-  private moduleMapping = new Map<string, NeutralMoveModule>()
-  private typeMapping = new Map<string, NeutralMoveStruct>()
-  private funcMapping = new Map<string, NeutralMoveFunction>()
+  private moduleMapping = new Map<string, InternalMoveModule>()
+  private typeMapping = new Map<string, InternalMoveStruct>()
+  private funcMapping = new Map<string, InternalMoveFunction>()
 
   contains(account: string, name: string) {
     return this.moduleMapping.has(account + '::' + name)
   }
 
-  loadNeutral(module: NeutralMoveModule) {
+  loadInternal(module: InternalMoveModule) {
     if (this.contains(module.address, module.name)) {
       return
     }
@@ -34,8 +34,8 @@ export abstract class AbstractMoveCoder<StructType> {
       this.typeMapping.set(key, struct)
     }
 
-    for (const func of module.exposed_functions) {
-      if (!func.is_entry) {
+    for (const func of module.exposedFunctions) {
+      if (!func.isEntry) {
         continue
       }
       const key = [module.address, module.name, func.name].join(SPLITTER)
@@ -53,7 +53,7 @@ export abstract class AbstractMoveCoder<StructType> {
     }
   }
 
-  protected getMoveStruct(type: string): NeutralMoveStruct {
+  protected 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,7 +61,7 @@ export abstract class AbstractMoveCoder<StructType> {
     return struct
   }
 
-  protected getMoveFunction(type: string): NeutralMoveFunction {
+  protected 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')

package/src/move/account.ts

@@ -1,6 +1,5 @@
-import { parseMoveType, TypeDescriptor } from './types.js'
 import { moduleQname, moduleQnameForType } from './utils.js'
-import { NeutralMoveModule } from './neutral-models.js'
+import { InternalMoveModule } from './internal-models.js'
 
 export class AccountModulesImportInfo {
   // account to module
@@ -31,21 +30,7 @@ export class AccountRegister {
   accountImports = new Map<string, AccountModulesImportInfo>()
   pendingAccounts = new Set<string>()
 
-  // loadedAccount = new Set<string>()
-  typeDescriptors = new Map<string, TypeDescriptor>()
-
-  protected loadTypeDescriptor(type: string) {
-    let descriptor = this.typeDescriptors.get(type)
-
-    // const descriptparseMoveType(type)
-    if (!descriptor) {
-      descriptor = parseMoveType(type)
-      this.typeDescriptors.set(type, descriptor)
-    }
-    return descriptor
-  }
-
-  register(module: NeutralMoveModule, tsModuleName: string): AccountModulesImportInfo {
+  register(module: InternalMoveModule, tsModuleName: string): AccountModulesImportInfo {
     const currentModuleFqn = moduleQname(module)
 
     let accountModuleImports = this.accountImports.get(module.address)
@@ -63,9 +48,9 @@ export class AccountRegister {
     return accountModuleImports
   }
 
-  registerFunctions(module: NeutralMoveModule, accountModuleImports: AccountModulesImportInfo): void {
-    for (const func of module.exposed_functions) {
-      if (!func.is_entry) {
+  private registerFunctions(module: InternalMoveModule, accountModuleImports: AccountModulesImportInfo): void {
+    for (const func of module.exposedFunctions) {
+      if (!func.isEntry) {
         continue
       }
       for (const param of func.params) {
@@ -80,7 +65,7 @@ export class AccountRegister {
     }
   }
 
-  registerStruct(module: NeutralMoveModule, accountModuleImports: AccountModulesImportInfo): void {
+  private registerStruct(module: InternalMoveModule, accountModuleImports: AccountModulesImportInfo): void {
     for (const struct of module.structs) {
       for (const field of struct.fields) {
         for (const type of field.type.dependedTypes()) {

package/src/move/internal-models.ts

@@ -0,0 +1,40 @@
+import { TypeDescriptor } from './types.js'
+
+export interface InternalMoveModule {
+  address: string
+  name: string
+  exposedFunctions: InternalMoveFunction[]
+  structs: InternalMoveStruct[]
+}
+
+export interface InternalMoveFunction {
+  name: string
+  visibility: InternalMoveFunctionVisibility
+  isEntry: boolean
+  typeParams: InternalMoveTypeParam[]
+  params: TypeDescriptor[]
+  return: TypeDescriptor[]
+}
+
+export interface InternalMoveStruct {
+  name: string
+  isNative: boolean
+  abilities: string[]
+  typeParams: InternalMoveTypeParam[]
+  fields: InternalMoveStructField[]
+}
+
+export interface InternalMoveStructField {
+  name: string
+  type: TypeDescriptor
+}
+
+export enum InternalMoveFunctionVisibility {
+  PRIVATE = 'private',
+  PUBLIC = 'public',
+  FRIEND = 'friend',
+}
+
+export type InternalMoveTypeParam = {
+  constraints: string[]
+}

package/src/move/ts-type.ts

@@ -2,10 +2,8 @@ import { TypeDescriptor } from './types.js'
 import { normalizeToJSName, SPLITTER, VECTOR_STR } from './utils.js'
 
 export function generateTypeForDescriptor(type: TypeDescriptor, currentAddress: string, addressType: string): string {
-  // TODO &signer is defintely an address, but what if &OTHER_TYPE?
   if (type.qname.startsWith('&')) {
-    console.error('Unexpected &')
-    return addressType
+    throw Error('Unexpected &')
   }
   if (type.reference) {
     return addressType

package/src/move/types.ts

@@ -1,20 +1,15 @@
 import { SPLITTER, VECTOR_STR } from './utils.js'
 
 export class TypeDescriptor {
-  // type: string
-
-  // TODO add reference flag
-
-  // qualified name without type parameters
   qname: string
   reference: boolean
-  // account?: string
-  // module?: string
-
+  mutable: boolean
   typeArgs: TypeDescriptor[]
 
   constructor(symbol: string, typeParams?: TypeDescriptor[]) {
     this.qname = symbol
+    this.reference = false
+    this.mutable = false
     this.typeArgs = typeParams || []
   }
 
@@ -97,20 +92,15 @@ export class TypeDescriptor {
 }
 
 export function parseMoveType(type: string): TypeDescriptor {
-  // type = type.replace('&', '')
-
-  type = type.replaceAll('&mut ', '&')
-  type = type.replaceAll('mut ', '')
-
-  // TODO replace ' ' is not exactly safe, need to double check this
-  type = type.replaceAll(' ', '')
-
   const stack: TypeDescriptor[] = [new TypeDescriptor('')]
   let buffer = []
 
   // xxx:asdf<g1<a,<c,d>>, b, g2<a,b>, e>
   for (let i = 0; i < type.length; i++) {
     const ch = type[i]
+    if (ch === ' ') {
+      continue
+    }
     if (ch === '<') {
       // const symbol = type.slice(symbolStart, i)
       // symbolStart =
@@ -121,7 +111,7 @@ export function parseMoveType(type: string): TypeDescriptor {
       stack.push(new TypeDescriptor(''))
       continue
     }
-    if (ch === '>') {
+    if (ch === '>' || ch === ',') {
       const typeParam = stack.pop()
       if (!typeParam) {
         throw Error('Unexpected stack size')
@@ -132,25 +122,11 @@ export function parseMoveType(type: string): TypeDescriptor {
       }
       adjustType(typeParam)
       stack[stack.length - 1].typeArgs.push(typeParam)
-      continue
-    }
-    if (ch === ',') {
-      const typeParam = stack.pop()
-      if (!typeParam) {
-        throw Error('Unexpected stack size')
-      }
-      if (buffer.length > 0) {
-        typeParam.qname = buffer.join('')
-        buffer = []
+      if (ch === ',') {
+        stack.push(new TypeDescriptor(''))
       }
-      adjustType(typeParam)
-
-      stack[stack.length - 1].typeArgs.push(typeParam)
-      // continue parse next param
-      stack.push(new TypeDescriptor(''))
       continue
     }
-
     buffer.push(ch)
   }
 
@@ -171,4 +147,8 @@ function adjustType(type: TypeDescriptor) {
     type.reference = true
     type.qname = type.qname.slice(1)
   }
+  if (type.qname.startsWith('mut')) {
+    type.mutable = true
+    type.qname = type.qname.slice(3)
+  }
 }

package/src/sui/codegen/codegen.ts

@@ -1,10 +1,10 @@
 import { SuiNetwork } from '../network.js'
 import * as fs from 'fs'
 import chalk from 'chalk'
-import { NeutralMoveModule, NeutralMoveStruct } from '../../move/neutral-models.js'
+import { InternalMoveModule, InternalMoveStruct } from '../../move/internal-models.js'
 import { AbstractCodegen } from '../../move/abstract-codegen.js'
 import { JsonRpcProvider, SuiMoveNormalizedModules } from '@mysten/sui.js'
-import { toNeutralModule } from '../move-types.js'
+import { toInternalModule } from '../move-types.js'
 import { moduleQname, SPLITTER, TypeDescriptor } from '../../move/index.js'
 
 export async function codegen(abisDir: string, outDir = 'src/types/sui') {
@@ -12,7 +12,7 @@ export async function codegen(abisDir: string, outDir = 'src/types/sui') {
     return
   }
   console.log(chalk.green('Generated Types for Sui'))
-  const gen = new SuiCodeGen()
+  const gen = new SuiCodegen()
   await gen.generate(abisDir, outDir)
 }
 
@@ -28,7 +28,7 @@ function getRpcClient(network: SuiNetwork): JsonRpcProvider {
   return new JsonRpcProvider(getRpcEndpoint(network))
 }
 
-class SuiCodeGen extends AbstractCodegen<SuiMoveNormalizedModules, SuiNetwork> {
+class SuiCodegen extends AbstractCodegen<SuiMoveNormalizedModules, SuiNetwork> {
   ADDRESS_TYPE = 'SuiAddress'
   MAIN_NET = SuiNetwork.MAIN_NET
   TEST_NET = SuiNetwork.TEST_NET
@@ -44,13 +44,13 @@ class SuiCodeGen extends AbstractCodegen<SuiMoveNormalizedModules, SuiNetwork> {
     return params.slice(0, params.length - 1)
   }
 
-  toNeutral(modules: SuiMoveNormalizedModules): NeutralMoveModule[] {
-    return Object.values(modules).map(toNeutralModule)
+  toInternalModules(modules: SuiMoveNormalizedModules): InternalMoveModule[] {
+    return Object.values(modules).map(toInternalModule)
   }
 
-  getEventStructs(module: NeutralMoveModule) {
+  getEventStructs(module: InternalMoveModule) {
     const qname = moduleQname(module)
-    const eventMap = new Map<string, NeutralMoveStruct>()
+    const eventMap = new Map<string, InternalMoveStruct>()
 
     for (const struct of module.structs) {
       const abilities = new Set(struct.abilities)

package/src/sui/move-coder.ts

@@ -1,7 +1,7 @@
 import { TypedEventInstance, TypedEntryFunctionPayload } from './models.js'
 import { AbstractMoveCoder } from '../move/abstract-move-coder.js'
 import { MoveCall, MoveEvent, SuiMoveNormalizedModule } from '@mysten/sui.js'
-import { toNeutralModule } from './move-types.js'
+import { toInternalModule } from './move-types.js'
 import { SPLITTER } from '../move/index.js'
 
 export class MoveCoder extends AbstractMoveCoder<MoveEvent> {
@@ -9,7 +9,7 @@ export class MoveCoder extends AbstractMoveCoder<MoveEvent> {
     if (this.contains(module.address, module.name)) {
       return
     }
-    this.loadNeutral(toNeutralModule(module))
+    this.loadInternal(toInternalModule(module))
   }
 
   decodeEvent<T>(event: MoveEvent): TypedEventInstance<T> | undefined {