@typemove/iota 1.14.0-rc.1 → 2.0.0

package/src/builtin/index.ts

@@ -1,6 +0,0 @@
-/* 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

@@ -1,288 +0,0 @@
-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`,
-          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

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

package/src/codegen/run.ts

@@ -1,57 +0,0 @@
-#!/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-iota')
-  .description('CLI to generate typescript types from Iota 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

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

package/src/models.ts

@@ -1,21 +0,0 @@
-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

@@ -1,316 +0,0 @@
-import { TypedDevInspectResults, TypedEventInstance, TypedFunctionPayload } from './models.js'
-import {
-  AbstractMoveCoder,
-  ANY_TYPE,
-  DecodedStruct,
-  accountTypeString,
-  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))
-  }
-
-  load(module: IotaMoveNormalizedModule, address: string): InternalMoveModule {
-    address = accountTypeString(address)
-    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.buffer, 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
-}