@sentio/sdk 2.60.0-rc.4 → 2.60.0-rc.5

package/src/iota/iota-plugin-part.ts

@@ -0,0 +1,211 @@
+import { USER_PROCESSOR } from '@sentio/runtime'
+import {
+  AccountConfig,
+  ContractConfig,
+  HandlerType,
+  InitResponse,
+  MoveCallHandlerConfig,
+  MoveEventHandlerConfig,
+  MoveResourceChangeConfig,
+  ProcessConfigResponse,
+  StartRequest
+} from '@sentio/protos'
+
+import { PartitionHandlerManager } from '../core/index.js'
+import { HandlerRegister } from '../core/handler-register.js'
+
+import { IotaProcessorState } from './iota-processor.js'
+import { IotaAccountProcessorState, IotaAddressProcessor } from './iota-object-processor.js'
+import { initCoinList } from './ext/coin.js'
+import { SuiChainId } from '@sentio/chain'
+import {
+  IotaAccountProcessorTemplateState,
+  IotaObjectOrAddressProcessorTemplate
+} from './iota-object-processor-template.js'
+import { IotaNetwork } from './network.js'
+import { IotaContext } from './context.js'
+
+export class IotaPluginPart {
+  constructor(
+    private handlerRegister: HandlerRegister,
+    private partitionManager: PartitionHandlerManager
+  ) {}
+
+  async start(request: StartRequest): Promise<void> {
+    await initCoinList()
+
+    console.log('total instances:', request.templateInstances.length)
+    const allowedChainIds = new Set<string>([SuiChainId.IOTA_MAINNET, SuiChainId.IOTA_TESTNET])
+    for (const instance of request.templateInstances) {
+      if (!allowedChainIds.has(instance.contract?.chainId || '')) {
+        continue
+      }
+
+      console.log('start template instance', instance.templateId)
+      const template: IotaObjectOrAddressProcessorTemplate<any, any, any> =
+        IotaAccountProcessorTemplateState.INSTANCE.getValues()[instance.templateId]
+
+      template.bind(
+        {
+          address: instance.contract?.address || '',
+          objectId: instance.contract?.address || '',
+          network: <IotaNetwork>instance.contract?.chainId || IotaNetwork.MAIN_NET,
+          startCheckpoint: instance.startBlock || 0n,
+          endCheckpoint: instance.endBlock || 0n,
+          baseLabels: instance.baseLabels
+        },
+        NoopContext
+      )
+    }
+  }
+
+  async init(config: InitResponse) {
+    for (const state of [IotaProcessorState.INSTANCE, IotaAccountProcessorState.INSTANCE]) {
+      for (const suiProcessor of state.getValues()) {
+        config.chainIds.push(suiProcessor.config.network)
+      }
+    }
+  }
+
+  async configure(config: ProcessConfigResponse, forChainId?: string) {
+    // this.handlerRegister.clear(forChainId as any)
+
+    for (const suiProcessor of IotaProcessorState.INSTANCE.getValues()) {
+      const chainId = suiProcessor.config.network
+      if (forChainId !== undefined && forChainId !== chainId.toString()) {
+        continue
+      }
+      const contractConfig = ContractConfig.fromPartial({
+        transactionConfig: [],
+        processorType: USER_PROCESSOR,
+        contract: {
+          name: suiProcessor.moduleName,
+          chainId: suiProcessor.config.network,
+          address: suiProcessor.config.address,
+          abi: ''
+        },
+        startBlock: suiProcessor.config.startCheckpoint,
+        endBlock: suiProcessor.config.endCheckpoint
+      })
+      for (const handler of suiProcessor.eventHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId)
+        this.partitionManager.registerPartitionHandler(HandlerType.SUI_EVENT, handlerId, handler.partitionHandler)
+        const eventHandlerConfig: MoveEventHandlerConfig = {
+          filters: handler.filters.map((f) => {
+            return {
+              type: f.type,
+              account: f.account || '',
+              eventAccount: f.eventAccount || ''
+            }
+          }),
+          fetchConfig: handler.fetchConfig,
+          handlerId,
+          handlerName: handler.handlerName
+        }
+        contractConfig.moveEventConfigs.push(eventHandlerConfig)
+      }
+      for (const handler of suiProcessor.callHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId)
+        this.partitionManager.registerPartitionHandler(HandlerType.SUI_CALL, handlerId, handler.partitionHandler)
+        const functionHandlerConfig: MoveCallHandlerConfig = {
+          filters: handler.filters.map((filter) => {
+            return {
+              function: filter.function,
+              typeArguments: filter.typeArguments || [],
+              withTypeArguments: !!filter.typeArguments,
+              includeFailed: filter.includeFailed || false,
+              publicKeyPrefix: filter.publicKeyPrefix || '',
+              fromAndToAddress: filter.fromAndToAddress
+            }
+          }),
+          fetchConfig: handler.fetchConfig,
+          handlerId,
+          handlerName: handler.handlerName
+        }
+        contractConfig.moveCallConfigs.push(functionHandlerConfig)
+      }
+      // deprecated, use objectType processor instead
+      for (const handler of suiProcessor.objectChangeHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId)
+        const objectChangeHandler: MoveResourceChangeConfig = {
+          type: handler.type,
+          handlerId,
+          handlerName: handler.handlerName,
+          includeDeleted: false
+        }
+        contractConfig.moveResourceChangeConfigs.push(objectChangeHandler)
+      }
+      config.contractConfigs.push(contractConfig)
+    }
+
+    for (const processor of IotaAccountProcessorState.INSTANCE.getValues()) {
+      const chainId = processor.getChainId()
+      if (forChainId !== undefined && forChainId !== chainId.toString()) {
+        continue
+      }
+      const accountConfig = AccountConfig.fromPartial({
+        address: processor.config.address,
+        chainId: processor.getChainId(),
+        startBlock: processor.config.startCheckpoint, // TODO maybe use another field
+        endBlock: processor.config.endCheckpoint
+      })
+
+      for (const handler of processor.objectChangeHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId)
+        const objectChangeHandler: MoveResourceChangeConfig = {
+          type: handler.type,
+          handlerId,
+          handlerName: handler.handlerName,
+          includeDeleted: false
+        }
+        accountConfig.moveResourceChangeConfigs.push(objectChangeHandler)
+      }
+
+      for (const handler of processor.objectHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId)
+
+        accountConfig.moveIntervalConfigs.push({
+          intervalConfig: {
+            handlerId: handlerId,
+            handlerName: handler.handlerName,
+            minutes: 0,
+            minutesInterval: handler.timeIntervalInMinutes,
+            slot: 0,
+            slotInterval: handler.checkPointInterval,
+            fetchConfig: undefined
+          },
+          type: handler.type || '',
+          ownerType: processor.ownerType,
+          resourceFetchConfig: handler.fetchConfig,
+          fetchConfig: undefined
+        })
+      }
+
+      if (processor instanceof IotaAddressProcessor) {
+        for (const handler of processor.callHandlers) {
+          const handlerId = this.handlerRegister.register(handler.handler, chainId)
+          const functionHandlerConfig: MoveCallHandlerConfig = {
+            filters: handler.filters.map((filter) => {
+              return {
+                function: filter.function,
+                typeArguments: filter.typeArguments || [],
+                withTypeArguments: !!filter.typeArguments,
+                includeFailed: filter.includeFailed || false,
+                publicKeyPrefix: filter.publicKeyPrefix || '',
+                fromAndToAddress: filter.fromAndToAddress
+              }
+            }),
+            fetchConfig: handler.fetchConfig,
+            handlerId,
+            handlerName: handler.handlerName
+          }
+          accountConfig.moveCallConfigs.push(functionHandlerConfig)
+        }
+      }
+
+      config.accountConfigs.push(accountConfig)
+    }
+  }
+}
+
+const NoopContext = new IotaContext('', SuiChainId.IOTA_MAINNET, '', new Date(), 0n, {} as any, 0, {})

package/src/iota/iota-plugin.ts

@@ -0,0 +1,2 @@
+// real plugin is in src/sui/sui-plugin.ts
+export class IotaPlugin {}

package/src/iota/iota-processor.ts

@@ -0,0 +1,339 @@
+import { Data_SuiCall, Data_SuiEvent, Data_SuiObjectChange, MoveFetchConfig } from '@sentio/protos'
+import { ListStateStorage } from '@sentio/runtime'
+import { IotaNetwork } from './network.js'
+import { ServerError, Status } from 'nice-grpc'
+import { IotaContext, IotaObjectChangeContext } from './context.js'
+import {
+  MoveCallIotaTransaction,
+  IotaEvent,
+  IotaTransactionBlockResponse,
+  IotaObjectChange
+} from '@iota/iota-sdk/client'
+import {
+  accountAddressString,
+  CallHandler,
+  EventFilter,
+  EventHandler,
+  FunctionNameAndCallFilter,
+  ObjectChangeHandler,
+  SPLITTER,
+  TransactionFilter
+} from '../move/index.js'
+import { getMoveCalls } from './utils.js'
+import { defaultMoveCoder, MoveCoder } from './index.js'
+import { ALL_ADDRESS, Labels, PromiseOrVoid } from '../core/index.js'
+import { Required } from 'utility-types'
+import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
+import { HandlerOptions } from './models.js'
+
+export const DEFAULT_FETCH_CONFIG: MoveFetchConfig = {
+  resourceChanges: false,
+  allEvents: true,
+  inputs: true
+}
+
+export type IndexConfigure = Required<IotaBindOptions, 'startCheckpoint' | 'network'>
+
+export function configure(options: IotaBindOptions): IndexConfigure {
+  return {
+    startCheckpoint: options.startCheckpoint || 0n,
+    endCheckpoint: options.endCheckpoint,
+    address: options.address === ALL_ADDRESS ? ALL_ADDRESS : accountAddressString(options.address),
+    network: options.network || IotaNetwork.MAIN_NET,
+    baseLabels: options.baseLabels
+  }
+}
+
+export interface IotaBindOptions {
+  address: string
+  network?: IotaNetwork
+  startCheckpoint?: bigint
+  endCheckpoint?: bigint
+  baseLabels?: Labels
+}
+
+export class IotaProcessorState extends ListStateStorage<IotaBaseProcessor> {
+  static INSTANCE = new IotaProcessorState()
+}
+
+export class IotaBaseProcessor {
+  readonly moduleName: string
+  config: IndexConfigure
+
+  eventHandlers: EventHandler<Data_SuiEvent>[] = []
+  callHandlers: CallHandler<Data_SuiCall>[] = []
+  objectChangeHandlers: ObjectChangeHandler<Data_SuiObjectChange>[] = []
+
+  coder: MoveCoder
+
+  constructor(name: string, options: IotaBindOptions) {
+    this.moduleName = name
+    this.config = configure(options)
+    IotaProcessorState.INSTANCE.addValue(this)
+    this.coder = defaultMoveCoder(this.config.network)
+
+    return proxyProcessor(this)
+  }
+
+  getChainId(): string {
+    return this.config.network
+  }
+
+  protected onMoveEvent(
+    handler: (event: IotaEvent, ctx: IotaContext) => PromiseOrVoid,
+    filter: EventFilter | EventFilter[],
+    handlerOptions?: HandlerOptions<MoveFetchConfig, IotaEvent>
+  ): IotaBaseProcessor {
+    let _filters: EventFilter[] = []
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...handlerOptions })
+
+    if (Array.isArray(filter)) {
+      _filters = filter
+    } else {
+      _filters.push(filter)
+    }
+
+    // const address = this.config.address
+    // const moduleName = this.moduleName
+
+    const processor = this
+
+    this.eventHandlers.push({
+      handlerName: getHandlerName(),
+      handler: async function (data) {
+        if (!data.rawTransaction) {
+          throw new ServerError(Status.INVALID_ARGUMENT, 'event is null')
+        }
+        const txn = JSON.parse(data.rawTransaction) as IotaTransactionBlockResponse
+        if (txn.events == null) {
+          txn.events = []
+        }
+
+        const evt = JSON.parse(data.rawEvent) as IotaEvent
+        const idx = Number(evt.id.eventSeq) || 0
+
+        const ctx = new IotaContext(
+          processor.moduleName,
+          processor.config.network,
+          processor.config.address,
+          data.timestamp || new Date(0),
+          data.slot,
+          txn,
+          idx,
+          processor.config.baseLabels
+        )
+
+        const decoded = await processor.coder.decodeEvent<any>(evt)
+        await handler(decoded || evt, ctx)
+
+        return ctx.stopAndGetResult()
+      },
+      filters: _filters,
+      fetchConfig: _fetchConfig,
+      partitionHandler: async (data: Data_SuiEvent): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const evt = JSON.parse(data.rawEvent) as IotaEvent
+          const decoded = await processor.coder.decodeEvent<any>(evt)
+          return p(decoded || evt)
+        }
+        return p
+      }
+    })
+    return this
+  }
+
+  protected onEntryFunctionCall(
+    handler: (call: MoveCallIotaTransaction, ctx: IotaContext) => PromiseOrVoid,
+    filter: FunctionNameAndCallFilter | FunctionNameAndCallFilter[],
+    handlerOptions?: HandlerOptions<MoveFetchConfig, MoveCallIotaTransaction>
+  ): IotaBaseProcessor {
+    let _filters: FunctionNameAndCallFilter[] = []
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...handlerOptions })
+
+    if (Array.isArray(filter)) {
+      _filters = filter
+    } else {
+      _filters.push(filter)
+    }
+
+    const processor = this
+    const allFunctionType = new Set(_filters.map((f) => f.function))
+
+    this.callHandlers.push({
+      handlerName: getHandlerName(),
+      handler: async function (data) {
+        if (!data.rawTransaction) {
+          throw new ServerError(Status.INVALID_ARGUMENT, 'call is null')
+        }
+        const tx = JSON.parse(data.rawTransaction) as IotaTransactionBlockResponse
+
+        const ctx = new IotaContext(
+          processor.moduleName,
+          processor.config.network,
+          processor.config.address,
+          data.timestamp || new Date(0),
+          data.slot,
+          tx,
+          0,
+          processor.config.baseLabels
+        )
+        if (tx) {
+          const calls: MoveCallIotaTransaction[] = getMoveCalls(tx)
+          const txKind = tx.transaction?.data?.transaction
+          if (!txKind) {
+            throw new ServerError(Status.INVALID_ARGUMENT, 'Unexpected getTransactionKind get empty')
+          }
+
+          // getProgrammableTransaction(txKind)
+          const programmableTx = txKind.kind === 'ProgrammableTransaction' ? txKind : undefined
+
+          // TODO potential pass index
+          for (const call of calls) {
+            const functionType = [call.module, call.function].join(SPLITTER)
+            if (!allFunctionType.has(functionType)) {
+              continue
+            }
+
+            // TODO maybe do in parallel
+            const decoded = await processor.coder.decodeFunctionPayload(call, programmableTx?.inputs || [])
+            await handler(decoded, ctx)
+          }
+        }
+        return ctx.stopAndGetResult()
+      },
+      filters: _filters,
+      fetchConfig: _fetchConfig,
+      partitionHandler: async (data: Data_SuiCall): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const tx = JSON.parse(data.rawTransaction) as IotaTransactionBlockResponse
+          const calls: MoveCallIotaTransaction[] = getMoveCalls(tx)
+          // For simplicity, use the first call for partitioning
+          if (calls.length > 0) {
+            return p(calls[0])
+          }
+          return undefined
+        }
+        return p
+      }
+    })
+    return this
+  }
+
+  onEvent(
+    handler: (event: IotaEvent, ctx: IotaContext) => void,
+    handlerOptions?: HandlerOptions<MoveFetchConfig, IotaEvent>
+  ): this {
+    this.onMoveEvent(handler, { type: '' }, handlerOptions)
+    return this
+  }
+
+  onTransactionBlock(
+    handler: (transaction: IotaTransactionBlockResponse, ctx: IotaContext) => PromiseOrVoid,
+    filter?: TransactionFilter,
+    handlerOptions?: HandlerOptions<MoveFetchConfig, IotaTransactionBlockResponse>
+  ): this {
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...handlerOptions })
+
+    const processor = this
+
+    this.callHandlers.push({
+      handlerName: getHandlerName(),
+      handler: async function (data) {
+        if (!data.rawTransaction) {
+          throw new ServerError(Status.INVALID_ARGUMENT, 'transaction is null')
+        }
+        const tx = JSON.parse(data.rawTransaction) as IotaTransactionBlockResponse
+
+        const ctx = new IotaContext(
+          processor.moduleName,
+          processor.config.network,
+          processor.config.address,
+          data.timestamp || new Date(0),
+          data.slot,
+          tx,
+          0,
+          processor.config.baseLabels
+        )
+        if (tx) {
+          await handler(tx, ctx)
+        }
+        return ctx.stopAndGetResult()
+      },
+      filters: [{ ...filter, function: '' }],
+      fetchConfig: _fetchConfig,
+      partitionHandler: async (data: Data_SuiCall): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const tx = JSON.parse(data.rawTransaction) as IotaTransactionBlockResponse
+          return p(tx)
+        }
+        return p
+      }
+    })
+    return this
+  }
+
+  protected onObjectChange(
+    handler: (changes: IotaObjectChange[], ctx: IotaObjectChangeContext) => PromiseOrVoid,
+    type: string
+  ): this {
+    if (this.config.network === IotaNetwork.TEST_NET) {
+      throw new ServerError(Status.INVALID_ARGUMENT, 'object change not supported in testnet')
+    }
+    const processor = this
+    this.objectChangeHandlers.push({
+      handlerName: getHandlerName(),
+      handler: async function (data: Data_SuiObjectChange) {
+        const ctx = new IotaObjectChangeContext(
+          processor.config.network,
+          processor.config.address,
+          data.timestamp || new Date(0),
+          data.slot,
+          data.txDigest,
+          processor.config.baseLabels
+        )
+        await handler(data.rawChanges.map((r) => JSON.parse(r)) as IotaObjectChange[], ctx)
+        return ctx.stopAndGetResult()
+      },
+      type
+    })
+
+    return this
+  }
+}
+
+export class IotaModulesProcessor extends IotaBaseProcessor {
+  static bind(options: IotaBindOptions): IotaModulesProcessor {
+    return new IotaModulesProcessor(ALL_ADDRESS, options)
+  }
+}
+
+export class IotaGlobalProcessor extends IotaBaseProcessor {
+  static bind(options: Omit<IotaBindOptions, 'address'>): IotaGlobalProcessor {
+    return new IotaGlobalProcessor(ALL_ADDRESS, { ...options, address: ALL_ADDRESS })
+  }
+  onTransactionBlock(
+    handler: (transaction: IotaTransactionBlockResponse, ctx: IotaContext) => void,
+    filter: TransactionFilter,
+    fetchConfig?: Partial<MoveFetchConfig>
+  ): this {
+    // TODO enable more strict check
+    // if (!filter.publicKeyPrefix || filter.publicKeyPrefix.length < 2) {
+    //   throw new ServerError(Status.INVALID_ARGUMENT, 'restriction too low for global processor')
+    // }
+    return super.onTransactionBlock(handler, filter, fetchConfig)
+  }
+
+  // deprecated,, use object type processor
+  public onObjectChange(
+    handler: (changes: IotaObjectChange[], ctx: IotaObjectChangeContext) => void,
+    type: string
+  ): this {
+    return super.onObjectChange(handler, type)
+  }
+}

package/src/iota/models.ts

@@ -0,0 +1,14 @@
+import type { IotaEvent, MoveCallIotaTransaction, IotaMoveObject } from '@iota/iota-sdk/client'
+import { DecodedStruct } from '@typemove/move'
+
+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 { PartitionHandler, HandlerOptions } from '../core/index.js'

package/src/iota/move-coder.ts

@@ -0,0 +1,15 @@
+import { MoveCoder } from '@typemove/iota'
+
+import { getClient, IotaNetwork } from './network.js'
+
+const CODERS = new Map<IotaNetwork, MoveCoder>()
+
+export function defaultMoveCoder(network: IotaNetwork = IotaNetwork.MAIN_NET): MoveCoder {
+  let coder = CODERS.get(network)
+  if (!coder) {
+    coder = new MoveCoder(getClient(network))
+    CODERS.set(network, coder)
+  }
+
+  return coder
+}

package/src/iota/network.ts

@@ -0,0 +1,27 @@
+import { SuiChainId } from '@sentio/chain'
+import { Endpoints } from '@sentio/runtime'
+// import { ServerError, Status } from 'nice-grpc'
+import { IotaClient } from '@iota/iota-sdk/client'
+
+export type IotaNetwork = SuiChainId
+export const IotaNetwork = <const>{
+  MAIN_NET: SuiChainId.IOTA_MAINNET,
+  TEST_NET: SuiChainId.IOTA_TESTNET
+}
+
+export function getClient(network: IotaNetwork): IotaClient {
+  let chainServer = Endpoints.INSTANCE.chainServer.get(network)
+  if (!chainServer) {
+    chainServer = getRpcEndpoint(network)
+    // throw new ServerError(Status.INTERNAL, 'RPC endpoint not provided')
+  }
+  return new IotaClient({ url: chainServer })
+}
+
+export function getRpcEndpoint(network: IotaNetwork): string {
+  switch (network) {
+    case IotaNetwork.TEST_NET:
+      return 'https://api.testnet.iota.cafe/'
+  }
+  return 'https://api.mainnet.iota.cafe/'
+}

package/src/iota/utils.ts

@@ -0,0 +1,52 @@
+import {
+  IotaTransactionBlockResponse,
+  MoveCallIotaTransaction,
+  ProgrammableTransaction,
+  IotaTransaction
+} from '@iota/iota-sdk/client'
+import { accountTypeString } from '@typemove/move'
+
+export function getMoveCalls(txBlock: IotaTransactionBlockResponse) {
+  const txKind = txBlock.transaction?.data.transaction
+  if (!txKind) {
+    return []
+  }
+  const programmableTx: ProgrammableTransaction | undefined =
+    txKind.kind === 'ProgrammableTransaction' ? txKind : undefined
+  if (!programmableTx) {
+    return []
+  }
+
+  return programmableTx.transactions.flatMap((tx: IotaTransaction) => {
+    if ('MoveCall' in tx) {
+      const call = tx.MoveCall as MoveCallIotaTransaction
+      call.package = accountTypeString(call.package)
+
+      return [call]
+    }
+    return []
+  })
+}
+
+// function isHex(value: string): boolean {
+//   return /^(0x|0X)?[a-fA-F0-9]+$/.test(value)
+// }
+//
+// function getHexByteLength(value: string): number {
+//   return /^(0x|0X)/.test(value) ? (value.length - 2) / 2 : value.length / 2
+// }
+//
+// export function isValidIotaAddress(value: string): value is IotaAddress {
+//   return isHex(value) && getHexByteLength(value) <= SUI_ADDRESS_LENGTH
+// }
+
+// export function validateAndNormalizeAddress(address: string): string {
+//   // if (isFrameworkAccount(address)) {
+//   //   const n = parseInt(address, 16)
+//   //   return `0x${n.toString(16)}`
+//   // }
+//   if (!isValidIotaAddress(address)) {
+//     throw Error('Not valid Address')
+//   }
+//   return normalizeIotaAddress(address)
+// }

package/src/sui/network.ts

@@ -7,9 +7,6 @@ export type SuiNetwork = SuiChainId
 export const SuiNetwork = <const>{
   MAIN_NET: SuiChainId.SUI_MAINNET,
   TEST_NET: SuiChainId.SUI_TESTNET
-  // DEV_NET: SuiChainId.SUI_DEVNET,
-  // MOVEMENT_MAIN_NET: SuiChainId.SUI_MOVEMENT_MAINNET,
-  // MOVEMENT_TEST_NET: SuiChainId.SUI_MOVEMENT_TESTNET
 }
 
 export function getClient(network: SuiNetwork): SuiClient {