@typemove/iota 1.10.0-rc.1

package/src/builtin/index.ts

@@ -0,0 +1,6 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export * as _0x1 from './0x1.js'
+export * as _0x2 from './0x2.js'
+export * as _0x3 from './0x3.js'

package/src/codegen/codegen.ts

@@ -0,0 +1,290 @@
+import { IotaMoveNormalizedModule, IotaEvent, IotaMoveObject, IotaClient } from '@iota/iota-sdk/client'
+
+import * as fs from 'fs'
+import chalk from 'chalk'
+import {
+  InternalMoveModule,
+  InternalMoveStruct,
+  structQname,
+  InternalMoveFunction,
+  InternalMoveFunctionVisibility,
+  normalizeToJSName,
+  camel
+} from '@typemove/move'
+import { AbstractCodegen } from '@typemove/move/codegen'
+import { join } from 'path'
+import { IotaChainAdapter } from '../sui-chain-adapter.js'
+
+export async function codegen(
+  abisDir: string,
+  outDir = join('src', 'types', 'sui'),
+  endpoint: string,
+  genExample = false,
+  builtin = false
+) {
+  if (!fs.existsSync(abisDir)) {
+    console.error(chalk.red(`ABIs directory ${abisDir} does not exist`))
+    return 0
+  }
+  try {
+    const gen = new IotaCodegen(endpoint)
+    const numFiles = await gen.generate(abisDir, outDir, builtin)
+    if (numFiles > 0) {
+      console.log(chalk.green(`Generated for ${numFiles} accounts for Iota to ${outDir}`))
+    } else {
+      console.error(chalk.red(`No account found`))
+    }
+    return numFiles
+  } catch (e) {
+    console.error(chalk.red(`Failed to generate for ${abisDir}, please check if ABI json files are valid`))
+    console.log(e)
+    return 0
+  }
+}
+
+export class IotaCodegen extends AbstractCodegen<
+  // IotaNetwork,
+  IotaMoveNormalizedModule,
+  IotaEvent | IotaMoveObject
+> {
+  ADDRESS_TYPE = 'string'
+  SYSTEM_PACKAGE = '@typemove/iota'
+  // ADDRESS_TYPE = 'string'
+  // MAIN_NET = IotaNetwork.MAIN_NET
+  // TEST_NET = IotaNetwork.TEST_NET
+  PREFIX = 'Iota'
+  // STRUCT_FIELD_NAME = 'fields'
+  // GENERATE_ON_ENTRY = true
+  PAYLOAD_OPTIONAL = true
+
+  constructor(endpoint: string) {
+    super(new IotaChainAdapter(new IotaClient({ url: endpoint })))
+  }
+
+  readModulesFile(fullPath: string) {
+    const res = super.readModulesFile(fullPath)
+    if (res.result) {
+      return res.result
+    }
+    return res
+  }
+
+  generateStructs(module: InternalMoveModule, struct: InternalMoveStruct, events: Set<string>): string {
+    let content = ''
+    switch (structQname(module, struct)) {
+      // TODO they should still have module code generated
+      case '0x1::ascii::Char':
+      case '0x1::ascii::String':
+      case '0x2::object::ID':
+        content += `export type ${struct.name} = string`
+        break
+      case '0x2::coin::Coin':
+        content += `export type ${struct.name}<T> = string`
+        break
+      case '0x2::balance::Balance':
+        content += `export type ${struct.name}<T> = bigint`
+        break
+      case '0x1::option::Option':
+        content += `export type Option<T> = T | undefined`
+        break
+    }
+    return content + super.generateStructs(module, struct, events, content !== '')
+  }
+
+  generateForEvents(module: InternalMoveModule, struct: InternalMoveStruct): string {
+    switch (structQname(module, struct)) {
+      case '0x1::ascii::Char':
+      case '0x1::ascii::String':
+      case '0x2::object::ID':
+      case '0x2::coin::Coin':
+      case '0x1::option::Option':
+      case '0x2::balance::Balance':
+        return ''
+    }
+    return super.generateForEvents(module, struct)
+  }
+
+  protected generateExtra(address: string | undefined, module: InternalMoveModule): string {
+    const funcs = module.exposedFunctions.map((f) =>
+      this.generateBuilderForFunction(address || module.address, module, f)
+    )
+
+    const viewFuncs = module.exposedFunctions.map((f) => this.generateViewFunction(module, f))
+
+    return `
+    export namespace builder {
+      ${funcs.join('\n')}
+    }
+    export namespace view {
+      ${viewFuncs.join('\n')}
+    }
+    `
+  }
+
+  private generateArgs(module: InternalMoveModule, func: InternalMoveFunction, isView: boolean) {
+    const args = []
+    const argsLen = func.params.length
+    for (const [idx, arg] of func.params.entries()) {
+      if (idx === argsLen - 1 && arg.qname === '0x2::tx_context::TxContext') {
+        // no op
+      } else if (arg.reference) {
+        args.push({
+          paramType: isView
+            ? this.ADDRESS_TYPE
+            : `${this.ADDRESS_TYPE} | TransactionObjectArgument | TransactionArgument`,
+          callValue: `_args.push(transactionArgumentOrObject(args[${idx}], tx))`
+        })
+      } else if (arg.isVector()) {
+        // TODO fix pure vector
+        args.push({
+          paramType: isView
+            ? `${this.ADDRESS_TYPE}[]`
+            : `(${this.ADDRESS_TYPE} | TransactionObjectArgument)[] | TransactionArgument`,
+          callValue: `_args.push(transactionArgumentOrVec(args[${idx}], tx))`
+        })
+      } else {
+        // Handle pure type
+        let pureFunction = ''
+        const paramType = isView
+          ? this.generateTypeForDescriptor(arg, module.address)
+          : `${this.generateTypeForDescriptor(arg, module.address)} | TransactionArgument`
+
+        switch (arg.qname.toLowerCase()) {
+          case 'u8':
+            pureFunction = `transactionArgumentOrPureU8`
+            break
+          case 'u16':
+            pureFunction = `transactionArgumentOrPureU16`
+            break
+          case 'u32':
+            pureFunction = `transactionArgumentOrPureU32`
+            break
+          case 'u64':
+            pureFunction = `transactionArgumentOrPureU64`
+            break
+          case 'u128':
+            pureFunction = `transactionArgumentOrPureU128`
+            break
+          case 'u256':
+            pureFunction = `transactionArgumentOrPureU256`
+            break
+          case 'bool':
+            pureFunction = `transactionArgumentOrPureBool`
+            break
+          case 'string':
+            pureFunction = `transactionArgumentOrPureString`
+            break
+          case 'address':
+            pureFunction = `transactionArgumentOrPureAddress`
+            break
+          // case 'vector':
+          // case 'option':
+          default:
+            pureFunction = `transactionArgumentOrPure`
+          //   paramType = 'TransactionArgument'
+        }
+        const callValue = pureFunction ? `_args.push(${pureFunction}(args[${idx}], tx))` : `_args.push(args[${idx}])`
+
+        args.push({
+          paramType,
+          callValue
+        })
+      }
+    }
+    return args
+  }
+
+  protected generateViewFunction(module: InternalMoveModule, func: InternalMoveFunction): string {
+    if (func.visibility === InternalMoveFunctionVisibility.PRIVATE) {
+      return ''
+    }
+    const genericString = this.generateFunctionTypeParameters(func)
+
+    const typeParamArg = func.typeParams
+      .map((v, idx) => {
+        return `TypeDescriptor<T${idx}> | string`
+      })
+      .join(',')
+
+    const args = this.generateArgs(module, func, true)
+    const returnType = `${this.generateFunctionReturnTypeParameters(func, module.address)}`
+
+    return `export async function ${camel(normalizeToJSName(func.name))}${genericString}(
+      client: IotaClient,
+      args: [${args.map((a) => a.paramType).join(',')}],
+      ${
+        typeParamArg.length > 0 ? `typeArguments: [${typeParamArg}]` : ``
+      } ): Promise<TypedDevInspectResults<${returnType}>> {
+      const tx = new Transaction()
+      builder.${camel(normalizeToJSName(func.name))}(tx, args ${typeParamArg.length > 0 ? `, typeArguments` : ''})
+      const inspectRes = await client.devInspectTransactionBlock({
+        transactionBlock: tx,
+        sender: ZERO_ADDRESS
+      })
+
+      return (await getMoveCoder(client)).decodeDevInspectResult<${returnType}>(inspectRes)
+    }`
+  }
+
+  protected generateBuilderForFunction(
+    address: string,
+    module: InternalMoveModule,
+    func: InternalMoveFunction
+  ): string {
+    if (func.visibility === InternalMoveFunctionVisibility.PRIVATE && func.isEntry !== true) {
+      return ''
+    }
+
+    const args = this.generateArgs(module, func, false)
+
+    const genericString = this.generateFunctionTypeParameters(func)
+
+    const typeParamArg = func.typeParams
+      .map((v, idx) => {
+        return `TypeDescriptor<T${idx}> | string`
+      })
+      .join(',')
+    const typeParamToString = func.typeParams
+      .map((v, idx) => {
+        return `typeof typeArguments[${idx}] === 'string' ? typeArguments[${idx}] : typeArguments[${idx}].getSignature()`
+      })
+      .join(',')
+
+    return `export function ${camel(normalizeToJSName(func.name))}${genericString}(tx: Transaction,
+      args: [${args.map((a) => a.paramType).join(',')}],
+      ${typeParamArg.length > 0 ? `typeArguments: [${typeParamArg}]` : ``} ):
+       TransactionArgument & [ ${'TransactionArgument,'.repeat(args.length)} ] {
+      const _args: any[] = []
+      ${args.map((a) => a.callValue).join('\n')}
+
+      // @ts-ignore
+      return tx.moveCall({
+        target: "${address}::${module.name}::${func.name}",
+        arguments: _args,
+        ${typeParamArg.length > 0 ? `typeArguments: [${typeParamToString}]` : ``}
+      })
+    }`
+  }
+
+  generateImports(): string {
+    return `
+      ${super.generateImports()}
+      import { ZERO_ADDRESS, TypedDevInspectResults, getMoveCoder } from '@typemove/iota'
+      import { Transaction, TransactionArgument, TransactionObjectArgument } from '@iota/iota-sdk/transactions'
+      import { IotaClient } from '@iota/iota-sdk/client'
+      import {  transactionArgumentOrObject, 
+                transactionArgumentOrVec,
+                transactionArgumentOrPure,
+                transactionArgumentOrPureU8,
+                transactionArgumentOrPureU16,
+                transactionArgumentOrPureU32,
+                transactionArgumentOrPureU64,
+                transactionArgumentOrPureU128,
+                transactionArgumentOrPureU256,
+                transactionArgumentOrPureBool,
+                transactionArgumentOrPureString,
+                transactionArgumentOrPureAddress,
+      } from '@typemove/iota'
+    `
+  }
+}

package/src/codegen/index.ts

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

package/src/codegen/run.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+import { codegen } from './codegen.js'
+import { Command } from 'commander'
+import { createRequire } from 'module'
+import fs from 'fs'
+import path from 'path'
+import { IotaClient } from '@iota/iota-sdk/client'
+const require = createRequire(import.meta.url)
+let pkg = undefined
+try {
+  pkg = require('../../package.json')
+} catch (e) {
+  pkg = require('../../../package.json')
+}
+
+const program = new Command()
+program
+  .name('typemove-sui')
+  .description('CLI to generate typescript types from SUI ABIs')
+  .showHelpAfterError()
+  .version(pkg.version)
+  .argument('<location>', 'Directory of ABI json files or address of account to generate types for')
+  .option('-a, --abi-dir <dir>', 'Directory to store downloaded ABI. Only useful if <location> is address', './abis')
+  .option('-t, --target-dir <dir>', 'Directory to output generated files', './types')
+  .option(
+    '-n, --network <mainnet|testnet|$url>',
+    'Network to use, could be either "mainnet", "testnet" or any node URL',
+    'mainnet'
+  )
+  .action(async (location, options) => {
+    let endpoint = options.network
+    if (endpoint == 'mainnet') {
+      endpoint = 'https://api.mainnet.iota.cafe/'
+    }
+    if (endpoint == 'testnet') {
+      endpoint = 'https://api.testnet.iota.cafe/'
+    }
+
+    const suiClient = new IotaClient({ url: endpoint })
+
+    let abisDir = location
+    if (location.startsWith('0x')) {
+      const abiAddress = abisDir
+      const abi = await suiClient.getNormalizedMoveModulesByPackage({ package: abiAddress })
+      abisDir = options.abiDir
+      if (!fs.existsSync(abisDir)) {
+        fs.mkdirSync(abisDir, { recursive: true })
+      }
+      fs.writeFileSync(path.join(abisDir, abiAddress + '.json'), JSON.stringify(abi, null, 2))
+    }
+
+    const num = await codegen(abisDir, options.targetDir, endpoint, true)
+    process.exit(num == 0 ? 1 : 0)
+  })
+
+program.parse()

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './models.js'
+export * from './transaction.js'
+
+export { MoveCoder, defaultMoveCoder, getMoveCoder } from './move-coder.js'

package/src/models.ts

@@ -0,0 +1,21 @@
+import type { IotaEvent, MoveCallIotaTransaction, IotaMoveObject, DevInspectResults } from '@iota/iota-sdk/client'
+import { DecodedStruct } from '@typemove/move'
+
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000000000000000000000000000'
+
+export type TypedEventInstance<T> = DecodedStruct<IotaEvent, T>
+export type TypedIotaMoveObject<T> = DecodedStruct<IotaMoveObject, T>
+
+export type TypedFunctionPayload<T extends Array<any>> = MoveCallIotaTransaction & {
+  /**
+   * decoded argument data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
+   */
+  arguments_decoded: T
+}
+
+export type TypedDevInspectResults<T extends Array<any>> = DevInspectResults & {
+  /**
+   * Decoded return values using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
+   */
+  results_decoded?: T
+}

package/src/move-coder.ts

@@ -0,0 +1,318 @@
+import { TypedDevInspectResults, TypedEventInstance, TypedFunctionPayload } from './models.js'
+import {
+  AbstractMoveCoder,
+  ANY_TYPE,
+  DecodedStruct,
+  parseMoveType,
+  SPLITTER,
+  TypeDescriptor,
+  InternalMoveModule
+} from '@typemove/move'
+import {
+  MoveCallIotaTransaction,
+  IotaCallArg,
+  IotaEvent,
+  IotaMoveNormalizedModule,
+  IotaMoveObject,
+  DevInspectResults,
+  IotaClient
+} from '@iota/iota-sdk/client'
+import { toInternalModule } from './to-internal.js'
+import { IotaChainAdapter } from './sui-chain-adapter.js'
+import { dynamic_field } from './builtin/0x2.js'
+import { BcsType, bcs } from '@iota/iota-sdk/bcs'
+
+// import { Encoding } from '@mysten/bcs/types', this doesn't get exported correctly
+export type Encoding = 'base58' | 'base64' | 'hex'
+
+import { normalizeIotaObjectId, normalizeIotaAddress } from '@iota/iota-sdk/utils'
+
+export class MoveCoder extends AbstractMoveCoder<
+  // IotaNetwork,
+  IotaMoveNormalizedModule,
+  IotaEvent | IotaMoveObject
+> {
+  constructor(client: IotaClient) {
+    super(new IotaChainAdapter(client))
+  }
+
+  async maybeGetMoveEnum(type: string) {
+    return undefined
+  }
+
+  load(module: IotaMoveNormalizedModule, address: string): InternalMoveModule {
+    let m = this.moduleMapping.get(module.address + '::' + module.name)
+    const mDeclared = this.moduleMapping.get(address + '::' + module.name)
+    if (m && mDeclared) {
+      return m
+    }
+    this.accounts.add(module.address)
+    m = toInternalModule(module)
+    this.loadInternal(m, address)
+    return m
+  }
+
+  protected async decode(data: any, type: TypeDescriptor): Promise<any> {
+    switch (type.qname) {
+      case '0x1::ascii::Char':
+        if (data !== undefined && typeof data !== 'string') {
+          // bcs
+          const byte = (await super.decode(data, type)).byte as number
+          return String.fromCharCode(byte)
+        }
+      case '0x1::ascii::String':
+        if (data !== undefined && typeof data !== 'string') {
+          // bcs verified
+          const bytes = (await super.decode(data, type)).bytes as number[]
+          return new TextDecoder().decode(new Uint8Array(bytes))
+        }
+      case '0x2::object::ID':
+        if (data !== undefined && typeof data !== 'string') {
+          // bcs verified
+          const bytes = (await super.decode(data, type)).bytes as string
+          return normalizeIotaObjectId(bytes)
+        }
+      case '0x2::url::Url':
+        if (data !== undefined && typeof data !== 'string') {
+          // bcs
+          return (await super.decode(data, type)).url
+        }
+      case '0x2::coin::Coin':
+        if (data !== undefined && typeof data !== 'string') {
+          // bcs
+          const bytes = (await super.decode(data, type)).id.id.bytes as number[]
+          return new TextDecoder().decode(new Uint8Array(bytes))
+        }
+        return data
+      case '0x2::balance::Balance':
+        if (data.value) {
+          // bcs verfied
+          const balance = await super.decode(data, type)
+          return balance.value
+        }
+        return BigInt(data)
+      case '0x1::option::Option':
+        if (data === null) {
+          return data
+        }
+        if (data.vec) {
+          // bcs verifed
+          let vec = await super.decode(data, type)
+          vec = vec.vec
+          if (vec.length === 0) {
+            return null
+          }
+          return vec[0]
+        }
+        return this.decode(data, type.typeArgs[0])
+      case 'Address':
+        const str = data as string
+        return normalizeIotaAddress(str)
+      case '0x1::string::String':
+        if (typeof data !== 'string') {
+          // bcs
+          return new TextDecoder().decode(new Uint8Array(data.bytes))
+        }
+      default:
+        return super.decode(data, type)
+    }
+  }
+
+  decodeEvent<T>(event: IotaEvent): Promise<TypedEventInstance<T> | undefined> {
+    return this.decodedStruct(event)
+  }
+  filterAndDecodeEvents<T>(type: TypeDescriptor<T> | string, resources: IotaEvent[]): Promise<TypedEventInstance<T>[]> {
+    if (typeof type === 'string') {
+      type = parseMoveType(type)
+    }
+    return this.filterAndDecodeStruct(type, resources)
+  }
+
+  async getDynamicFields<T1, T2>(
+    objects: IotaMoveObject[],
+    keyType: TypeDescriptor<T1> = ANY_TYPE,
+    valueType: TypeDescriptor<T2> = ANY_TYPE
+  ): Promise<dynamic_field.Field<T1, T2>[]> {
+    // const type = dynamic_field.Field.TYPE
+    // Not using the code above to avoid cycle initialize failed
+    const type = new TypeDescriptor<dynamic_field.Field<T1, T2>>('0x2::dynamic_field::Field')
+    type.typeArgs = [keyType, valueType]
+    const res = await this.filterAndDecodeObjects(type, objects)
+    return res.map((o) => o.data_decoded)
+  }
+
+  filterAndDecodeObjects<T>(
+    type: TypeDescriptor<T>,
+    objects: IotaMoveObject[]
+  ): Promise<DecodedStruct<IotaMoveObject, T>[]> {
+    return this.filterAndDecodeStruct(type, objects)
+  }
+
+  async decodeFunctionPayload(
+    payload: MoveCallIotaTransaction,
+    inputs: IotaCallArg[]
+  ): Promise<MoveCallIotaTransaction> {
+    const functionType = [payload.package, payload.module, payload.function].join(SPLITTER)
+    const func = await this.getMoveFunction(functionType)
+    const params = this.adapter.getMeaningfulFunctionParams(func.params)
+    const args = []
+    for (const value of payload.arguments || []) {
+      const argValue = value as any
+      if ('Input' in (argValue as any)) {
+        const idx = argValue.Input
+        const arg = inputs[idx]
+        if (arg.type === 'pure') {
+          args.push(arg.value)
+        } else if (arg.type === 'object') {
+          // object is not there
+          args.push(undefined)
+        } else {
+          console.error('unexpected function arg value')
+          args.push(undefined)
+        }
+        // args.push(arg) // TODO check why ts not work using arg.push(arg)
+      } else {
+        args.push(undefined)
+      }
+    }
+
+    const argumentsTyped = await this.decodeArray(args, params, false)
+    return {
+      ...payload,
+      arguments_decoded: argumentsTyped
+    } as TypedFunctionPayload<any>
+  }
+
+  private bcsRegistered = new Set<string>()
+  private bcsRegistry = new Map<string, BcsType<any>>()
+
+  private async getBCSTypeWithArgs(type: TypeDescriptor, args: BcsType<any>[] = []): Promise<BcsType<any>> {
+    const qname = type.qname
+    const sig = type.getNormalizedSignature()
+    const cached = this.bcsRegistry.get(sig)
+    if (cached) {
+      return cached
+    }
+    const lowerQname = qname.toLowerCase()
+    switch (lowerQname) {
+      case 'u8':
+      case 'u16':
+      case 'u32':
+      case 'u64':
+      case 'u128':
+      case 'u256':
+      case 'bool':
+        return bcs[lowerQname]()
+      case 'address':
+        return bcs.Address
+      case 'vector':
+        return bcs.vector(args[0])
+      default:
+        if (!qname.includes('::')) {
+          throw `Unimplemented builtin type ${qname}`
+        }
+    }
+    let moveStruct
+    try {
+      moveStruct = await this.getMoveStruct(qname)
+    } catch (e) {
+      console.error('Invalid move address', qname)
+      throw e
+    }
+    const structDef: Record<string, any> = {}
+    for (const field of moveStruct.fields) {
+      if (field.type.qname.startsWith('T') && args.length) {
+        const index = +field.type.qname.slice(1)
+        structDef[field.name] = args[index]
+      } else if (field.type.typeArgs.length && args.length) {
+        structDef[field.name] = await this.getBCSTypeWithArgs(field.type, args)
+      } else {
+        structDef[field.name] = await this.getBCSType(field.type)
+      }
+    }
+    return bcs.struct(qname, structDef)
+  }
+
+  async getBCSType(type: TypeDescriptor): Promise<BcsType<any>> {
+    const args = await Promise.all(type.typeArgs.map((x) => this.getBCSType(x)))
+    const bcsType = await this.getBCSTypeWithArgs(type, args)
+    this.bcsRegistry.set(type.getNormalizedSignature(), bcsType)
+    return bcsType
+  }
+
+  async registerBCSTypes(type: TypeDescriptor): Promise<void> {
+    const sig = type.getNormalizedSignature()
+    if (this.bcsRegistered.has(sig)) {
+      return
+    }
+    this.bcsRegistered.add(sig)
+
+    const bcsType = await this.getBCSType(type)
+    this.bcsRegistry.set(type.getNormalizedSignature(), bcsType)
+  }
+
+  async decodeBCS(type: TypeDescriptor, data: Uint8Array | string, encoding?: Encoding): Promise<any> {
+    await this.registerBCSTypes(type)
+    if (typeof data == 'string') {
+      const buf = Buffer.from(data, encoding as any)
+      data = new Uint8Array(buf, buf.byteOffset, buf.byteLength)
+    }
+    const bcsType = this.bcsRegistry.get(type.getNormalizedSignature())
+    return bcsType?.parse(data)
+  }
+
+  async decodeDevInspectResult<T extends any[]>(inspectRes: DevInspectResults): Promise<TypedDevInspectResults<T>> {
+    const returnValues = []
+    if (inspectRes.results != null) {
+      for (const r of inspectRes.results) {
+        if (r.returnValues) {
+          for (const returnValue of r.returnValues) {
+            const type = parseMoveType(returnValue[1])
+            const bcsDecoded = await this.decodeBCS(type, new Uint8Array(returnValue[0]))
+            const decoded = await this.decodeType(bcsDecoded, type)
+            returnValues.push(decoded)
+          }
+        } else {
+          returnValues.push(null)
+        }
+      }
+    }
+    return { ...inspectRes, results_decoded: returnValues as any }
+  }
+}
+
+const DEFAULT_ENDPOINT = 'https://api.mainnet.iota.cafe/'
+const CODER_MAP = new Map<string, MoveCoder>()
+const CHAIN_ID_CODER_MAP = new Map<string, MoveCoder>()
+
+export function defaultMoveCoder(endpoint: string = DEFAULT_ENDPOINT): MoveCoder {
+  let coder = CODER_MAP.get(endpoint)
+  if (!coder) {
+    coder = new MoveCoder(new IotaClient({ url: endpoint }))
+    CODER_MAP.set(endpoint, coder)
+  }
+  return coder
+}
+
+const PROVIDER_CODER_MAP = new Map<IotaClient, MoveCoder>()
+
+let DEFAULT_CHAIN_ID: string | undefined
+
+export async function getMoveCoder(client: IotaClient): Promise<MoveCoder> {
+  let coder = PROVIDER_CODER_MAP.get(client)
+  if (!coder) {
+    coder = new MoveCoder(client)
+    // TODO how to dedup
+    const id = await client.getChainIdentifier()
+    const defaultCoder = defaultMoveCoder()
+    if (!DEFAULT_CHAIN_ID) {
+      DEFAULT_CHAIN_ID = await defaultCoder.adapter.getChainId()
+    }
+    if (id === DEFAULT_CHAIN_ID) {
+      coder = defaultCoder
+    }
+
+    PROVIDER_CODER_MAP.set(client, coder)
+  }
+  return coder
+}