@sentio/sdk 2.21.2 → 2.21.3-rc.2

package/src/aptos/aptos-processor.ts

@@ -18,7 +18,15 @@ import {
   Data_AptCall,
 } from '@sentio/protos'
 import { ServerError, Status } from 'nice-grpc'
-import { CallHandler, EventFilter, EventHandler, FunctionNameAndCallFilter, parseMoveType } from '../move/index.js'
+import {
+  accountAddressString,
+  accountTypeString,
+  CallHandler,
+  EventFilter,
+  EventHandler,
+  FunctionNameAndCallFilter,
+  parseMoveType,
+} from '../move/index.js'
 import { Labels, PromiseOrVoid } from '../core/index.js'
 
 const DEFAULT_FETCH_CONFIG: MoveFetchConfig = {
@@ -77,7 +85,7 @@ export class AptosBaseProcessor {
     // const moduleName = this.moduleName
 
     const processor = this
-    const allEventType = new Set(_filters.map((f) => processor.config.address + '::' + f.type))
+    const allEventType = new Set(_filters.map((f) => accountTypeString(processor.config.address) + '::' + f.type))
 
     this.eventHandlers.push({
       handler: async function (data) {
@@ -315,7 +323,7 @@ function configure(options: AptosBindOptions): IndexConfigure {
 
   return {
     startVersion: startVersion,
-    address: options.address,
+    address: options.address === '*' ? '*' : accountAddressString(options.address),
     network: options.network || AptosNetwork.MAIN_NET,
     baseLabels: options.baseLabels,
   }

package/src/aptos/ext/coin.ts

@@ -1,7 +1,7 @@
 import { getPriceByType } from '@sentio/sdk/utils'
 import fetch from 'node-fetch'
-import { validateAndNormalizeAddress } from '../utils.js'
-import { SPLITTER } from '../../move/index.js'
+// import { validateAndNormalizeAddress } from '../utils.js'
+import { accountTypeString, SPLITTER } from '../../move/index.js'
 import { AptosChainId } from '@sentio/chain'
 import { SimpleCoinInfo } from '../../move/ext/move-dex.js'
 
@@ -43,7 +43,7 @@ export function whitelistCoins() {
 
 export function whiteListed(coin: string): boolean {
   const [addr, module, type] = coin.split(SPLITTER)
-  const normalized = [validateAndNormalizeAddress(addr), module, type].join(SPLITTER)
+  const normalized = [accountTypeString(addr), module, type].join(SPLITTER)
   return WHITELISTED_COINS.has(normalized)
 }
 

package/src/aptos/utils.ts

@@ -1,15 +1,15 @@
-import { HexString, TxnBuilderTypes } from 'aptos-sdk'
+// import { HexString, TxnBuilderTypes } from 'aptos-sdk'
 // import { isFrameworkAccount } from '../move/index.js'
 
-export function isValidAptosAddress(value: string): boolean {
-  return TxnBuilderTypes.AccountAddress.isValid(value)
-}
-
-export function validateAndNormalizeAddress(address: string): string {
-  const hex = TxnBuilderTypes.AccountAddress.fromHex(address).toHexString()
-  // if (isFrameworkAccount(address)) {
-  //   return HexString.ensure(hex).toShortString()
-  // }
-  // return hex.toString()
-  return HexString.ensure(hex).toShortString()
-}
+// export function isValidAptosAddress(value: string): boolean {
+//   return TxnBuilderTypes.AccountAddress.isValid(value)
+// }
+//
+// export function validateAndNormalizeAddress(address: string): string {
+//   const hex = TxnBuilderTypes.AccountAddress.fromHex(address).toHexString()
+//   // if (isFrameworkAccount(address)) {
+//   //   return HexString.ensure(hex).toShortString()
+//   // }
+//   // return hex.toString()
+//   return HexString.ensure(hex).toShortString()
+// }

package/src/eth/codegen/functions-handler.ts

@@ -5,7 +5,7 @@ import {
 import sha3 from 'js-sha3'
 import { FunctionDeclaration, getSignatureForFn } from 'typechain'
 import { getFullSignatureAsSymbolForFunction } from './types.js'
-import { upperFirst } from 'lodash-es'
+import { upperFirst } from '../../move/index.js'
 
 export function generateCallHandlers(fns: FunctionDeclaration[], contractName: string): string {
   if (fns.length === 1) {

package/src/eth/provider.ts

@@ -104,6 +104,13 @@ class QueuedStaticJsonRpcProvider extends JsonRpcProvider {
             }
           }, 1000)
         }
+        if (e.code === 'CALL_EXCEPTION' && !e.data) {
+          setTimeout(() => {
+            if (this.#performCache.get(tag) === perform) {
+              this.#performCache.delete(tag)
+            }
+          }, 1000)
+        }
       })
       this.#performCache.set(tag, perform)
       // For non latest block call, we cache permanently, otherwise we cache for one minute

package/src/move/abstract-codegen.ts

@@ -1,6 +1,6 @@
 import {
   InternalMoveFunction,
-  InternalMoveFunctionVisibility,
+  // InternalMoveFunctionVisibility,
   InternalMoveModule,
   InternalMoveStruct,
 } from './internal-models.js'
@@ -9,8 +9,8 @@ import fs from 'fs'
 import { AccountModulesImportInfo, AccountRegister } from './account.js'
 import chalk from 'chalk'
 import { format } from 'prettier'
-import { isFrameworkAccount, moduleQname, normalizeToJSName, SPLITTER, VECTOR_STR } from './utils.js'
-import { camelCase, upperFirst } from 'lodash-es'
+import { isFrameworkAccount, moduleQname, normalizeToJSName, SPLITTER, upperFirst, VECTOR_STR } from './utils.js'
+import { camel } from 'radash'
 import { TypeDescriptor } from './types.js'
 import { ChainAdapter } from './chain-adapter.js'
 
@@ -161,11 +161,11 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
   generateModule(module: InternalMoveModule, allEventStructs: Map<string, InternalMoveStruct>, network: NetworkType) {
     const qname = moduleQname(module)
     const functions = this.GENERATE_ON_ENTRY
-      ? module.exposedFunctions.map((f) => this.generateOnEntryFunctions(module, f)).filter((s) => s !== '')
-      : []
-    const clientFunctions = this.GENERATE_CLIENT
-      ? module.exposedFunctions.map((f) => this.generateClientFunctions(module, f)).filter((s) => s !== '')
+      ? module.exposedFunctions.map((f) => this.generateForEntryFunctions(module, f)).filter((s) => s !== '')
       : []
+    // const clientFunctions = this.GENERATE_CLIENT
+    //   ? module.exposedFunctions.map((f) => this.generateClientFunctions(module, f)).filter((s) => s !== '')
+    //   : []
     const eventStructs = new Map<string, InternalMoveStruct>()
     for (const [type, struct] of allEventStructs.entries()) {
       if (type.startsWith(qname + SPLITTER)) {
@@ -175,22 +175,21 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
 
     const eventTypes = new Set(eventStructs.keys())
     const events = Array.from(eventStructs.values())
-      .map((e) => this.generateOnEvents(module, e))
+      .map((e) => this.generateForEvents(module, e))
       .filter((s) => s !== '')
     const structs = module.structs.map((s) => this.generateStructs(module, s, eventTypes))
     const callArgs = module.exposedFunctions.map((f) => this.generateCallArgsStructs(module, f))
 
     const moduleName = normalizeToJSName(module.name)
     let processor = ''
-    let client = ''
-
-    if (clientFunctions.length > 0) {
-      client = `
-      export class ${moduleName}_client extends ModuleClient {
-        ${clientFunctions.join('\n')}
-      }
-      `
-    }
+    // let client = ''
+    // if (clientFunctions.length > 0) {
+    //   client = `
+    //   export class ${moduleName}_client extends ModuleClient {
+    //     ${clientFunctions.join('\n')}
+    //   }
+    //   `
+    // }
 
     if (functions.length > 0 || events.length > 0) {
       processor = `export class ${moduleName} extends ${this.PREFIX}BaseProcessor {
@@ -215,7 +214,6 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
     }
 
     return `
-  ${client}
 
   ${processor}
 
@@ -323,7 +321,7 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
       return this.generateTypeForDescriptor(param, module.address) + (this.PAYLOAD_OPTIONAL ? ' | undefined' : '')
     })
 
-    const camelFuncName = upperFirst(camelCase(func.name))
+    const camelFuncName = upperFirst(camel(func.name))
 
     const genericString = this.generateFunctionTypeParameters(func)
     return `
@@ -335,34 +333,34 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
   `
   }
 
-  generateClientFunctions(module: InternalMoveModule, func: InternalMoveFunction) {
-    if (func.visibility === InternalMoveFunctionVisibility.PRIVATE) {
-      return ''
-    }
-    if (func.isEntry) {
-      return ''
-    }
-    // const moduleName = normalizeToJSName(module.name)
-    const funcName = camelCase(func.name)
-    const fields = this.chainAdapter.getMeaningfulFunctionParams(func.params).map((param) => {
-      return this.generateTypeForDescriptor(param, module.address)
-    })
-    const genericString = this.generateFunctionTypeParameters(func)
-
-    const returns = func.return.map((param) => {
-      return this.generateTypeForDescriptor(param, module.address)
-    })
-
-    const source = `
-  ${funcName}${genericString}(type_arguments: [${func.typeParams
-      .map((_) => 'string')
-      .join(', ')}], args: [${fields.join(',')}], version?: bigint): Promise<[${returns.join(',')}]> {
-    return this.viewDecoded('${module.address}::${module.name}::${func.name}', type_arguments, args, version) as any
-  }`
-    return source
-  }
-
-  generateOnEntryFunctions(module: InternalMoveModule, func: InternalMoveFunction) {
+  // generateClientFunctions(module: InternalMoveModule, func: InternalMoveFunction) {
+  //   if (func.visibility === InternalMoveFunctionVisibility.PRIVATE) {
+  //     return ''
+  //   }
+  //   if (func.isEntry) {
+  //     return ''
+  //   }
+  //   // const moduleName = normalizeToJSName(module.name)
+  //   const funcName = camel(func.name)
+  //   const fields = this.chainAdapter.getMeaningfulFunctionParams(func.params).map((param) => {
+  //     return this.generateTypeForDescriptor(param, module.address)
+  //   })
+  //   const genericString = this.generateFunctionTypeParameters(func)
+  //
+  //   const returns = func.return.map((param) => {
+  //     return this.generateTypeForDescriptor(param, module.address)
+  //   })
+  //
+  //   const source = `
+  // ${funcName}${genericString}(type_arguments: [${func.typeParams
+  //     .map((_) => 'string')
+  //     .join(', ')}], args: [${fields.join(',')}], version?: bigint): Promise<[${returns.join(',')}]> {
+  //   return this.viewDecoded('${module.address}::${module.name}::${func.name}', type_arguments, args, version) as any
+  // }`
+  //   return source
+  // }
+
+  generateForEntryFunctions(module: InternalMoveModule, func: InternalMoveFunction) {
     if (!func.isEntry) {
       return ''
     }
@@ -370,7 +368,7 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
     // const genericString = generateFunctionTypeParameters(func)
     const moduleName = normalizeToJSName(module.name)
 
-    const camelFuncName = upperFirst(camelCase(func.name))
+    const camelFuncName = upperFirst(camel(func.name))
     const source = `
   onEntry${camelFuncName}(func: (call: ${moduleName}.${camelFuncName}Payload, ctx: ${this.PREFIX}Context) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): ${moduleName} {
     this.onEntryFunctionCall(func, {
@@ -384,7 +382,7 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
     return source
   }
 
-  generateOnEvents(module: InternalMoveModule, struct: InternalMoveStruct): string {
+  generateForEvents(module: InternalMoveModule, struct: InternalMoveStruct): string {
     // for struct that has drop + store
     // if (!isEvent(struct, module)) {
     //   return ''

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

@@ -16,7 +16,7 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
   }
 
   contains(account: string, name: string) {
-    return this.moduleMapping.has(account + '::' + name)
+    return this.moduleMapping.has(moduleQname({ address: account, name }))
   }
 
   abstract load(module: ModuleType): InternalMoveModule

package/src/move/chain-adapter.ts

@@ -1,5 +1,6 @@
 import { InternalMoveModule, InternalMoveStruct } from './internal-models.js'
 import { TypeDescriptor } from './types.js'
+import { accountAddressString } from './utils.js'
 
 export abstract class ChainAdapter<NetworkType, ModuleType, StructType> {
   abstract fetchModule(account: string, module: string, network: NetworkType): Promise<ModuleType>
@@ -16,5 +17,8 @@ export abstract class ChainAdapter<NetworkType, ModuleType, StructType> {
 
   abstract getType(base: StructType): string
   abstract getData<T>(base: StructType): any
-  abstract validateAndNormalizeAddress(address: string): string
+
+  validateAndNormalizeAddress(address: string): string {
+    return accountAddressString(address)
+  }
 }

package/src/move/types.ts

@@ -1,4 +1,4 @@
-import { SPLITTER, VECTOR_STR } from './utils.js'
+import { accountTypeString, SPLITTER, VECTOR_STR } from './utils.js'
 
 export type DecodedStruct<B, T> = B & {
   /**
@@ -174,6 +174,11 @@ function adjustType(type: TypeDescriptor) {
     type.mutable = true
     type.qname = type.qname.slice(3)
   }
+  const parts = type.qname.split(SPLITTER)
+  if (parts.length > 1) {
+    const [account, module, name] = parts
+    type.qname = [accountTypeString(account), module, name].join(SPLITTER)
+  }
 }
 
 export const ANY_TYPE = new TypeDescriptor<any>('any')

package/src/move/utils.ts

@@ -12,6 +12,36 @@ export function isFrameworkAccount(account: string) {
   return n >= 0 && n < 16
 }
 
+// strip any lead 0
+export function accountTypeString(account: string): string {
+  const withoutPrefix = account.toLowerCase().replace(/^(0x)/, '')
+  return '0x' + withoutPrefix.replace(/^0*/, '')
+}
+
+const MOVE_ADDRESS_LENGTH = 32
+
+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 isValidMoveAddress(value: string): boolean {
+  return isHex(value) && getHexByteLength(value) <= MOVE_ADDRESS_LENGTH
+}
+
+// Get full address with 32 bytes
+export function accountAddressString(account: string): string {
+  if (!isValidMoveAddress(account)) {
+    throw Error('Not valid move address')
+  }
+
+  const address = account.toLowerCase().replace(/^(0x)/, '')
+  return `0x${address.padStart(MOVE_ADDRESS_LENGTH * 2, '0')}`
+}
+
 const KEYWORDS = new Set(['package', 'namespace', 'volatile', 'object', 'string', 'number', 'bigint', 'any'])
 
 export function normalizeToJSName(name: string) {
@@ -27,9 +57,13 @@ export function moduleQnameForType(type: string): [string, string] {
 }
 
 export function moduleQname(module: { address: string; name: string }): string {
-  return module.address.toLowerCase() + SPLITTER + module.name
+  return accountTypeString(module.address) + SPLITTER + module.name
 }
 
 export function structQname(module: InternalMoveModule, struct: InternalMoveStruct): string {
-  return [module.address, module.name, struct.name].join(SPLITTER)
+  return [accountTypeString(module.address), module.name, struct.name].join(SPLITTER)
+}
+
+export function upperFirst(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1)
 }

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

@@ -677,9 +677,9 @@ export class sui_system extends SuiBaseProcessor {
     return this;
   }
 
-  onEntryUpdateCandidateValidatorP2PAddress(
+  onEntryUpdateCandidateValidatorP2pAddress(
     func: (
-      call: sui_system.UpdateCandidateValidatorP2PAddressPayload,
+      call: sui_system.UpdateCandidateValidatorP2pAddressPayload,
       ctx: SuiContext
     ) => void,
     filter?: CallFilter,
@@ -867,9 +867,9 @@ export class sui_system extends SuiBaseProcessor {
     return this;
   }
 
-  onEntryUpdateValidatorNextEpochP2PAddress(
+  onEntryUpdateValidatorNextEpochP2pAddress(
     func: (
-      call: sui_system.UpdateValidatorNextEpochP2PAddressPayload,
+      call: sui_system.UpdateValidatorNextEpochP2pAddressPayload,
       ctx: SuiContext
     ) => void,
     filter?: CallFilter,
@@ -1222,7 +1222,7 @@ export namespace sui_system {
     type_arguments: [];
   }
 
-  export interface UpdateCandidateValidatorP2PAddressPayload
+  export interface UpdateCandidateValidatorP2pAddressPayload
     extends TypedFunctionPayload<
       [SuiAddress | undefined, number[] | undefined, SuiAddress | undefined]
     > {
@@ -1348,7 +1348,7 @@ export namespace sui_system {
     type_arguments: [];
   }
 
-  export interface UpdateValidatorNextEpochP2PAddressPayload
+  export interface UpdateValidatorNextEpochP2pAddressPayload
     extends TypedFunctionPayload<
       [SuiAddress | undefined, number[] | undefined, SuiAddress | undefined]
     > {

package/src/sui/codegen/codegen.ts

@@ -67,7 +67,7 @@ class SuiCodegen extends AbstractCodegen<SuiNetwork, SuiMoveNormalizedModule, Su
     return content + super.generateStructs(module, struct, events, content !== '')
   }
 
-  generateOnEvents(module: InternalMoveModule, struct: InternalMoveStruct): string {
+  generateForEvents(module: InternalMoveModule, struct: InternalMoveStruct): string {
     switch (structQname(module, struct)) {
       case '0x1::ascii::Char':
       case '0x1::ascii::String':
@@ -77,6 +77,6 @@ class SuiCodegen extends AbstractCodegen<SuiNetwork, SuiMoveNormalizedModule, Su
       case '0x2::balance::Balance':
         return ''
     }
-    return super.generateOnEvents(module, struct)
+    return super.generateForEvents(module, struct)
   }
 }

package/src/sui/ext/coin.ts

@@ -1,9 +1,9 @@
 import { SimpleCoinInfo } from '../../move/ext/index.js'
 import fetch from 'node-fetch'
-import { SPLITTER } from '../../move/index.js'
+import { accountTypeString, SPLITTER } from '../../move/index.js'
 import { getPriceByType } from '../../utils/index.js'
 import { SuiChainId } from '@sentio/chain'
-import { validateAndNormalizeAddress } from '../utils.js'
+// import { validateAndNormalizeAddress } from '../utils.js'
 import { getClient, SuiNetwork } from '../network.js'
 import { CoinMetadata } from '@mysten/sui.js'
 
@@ -65,7 +65,7 @@ export function whitelistCoins() {
 
 export function whiteListed(coin: string): boolean {
   const [addr, module, type] = coin.split(SPLITTER)
-  const normalized = [validateAndNormalizeAddress(addr), module, type].join(SPLITTER)
+  const normalized = [accountTypeString(addr), module, type].join(SPLITTER)
   return WHITELISTED_COINS.has(normalized)
 }
 

package/src/sui/index.ts

@@ -25,4 +25,4 @@ export { SuiPlugin } from './sui-plugin.js'
 
 export { ModuleClient } from './module-client.js'
 
-export { validateAndNormalizeAddress, isValidSuiAddress } from './utils.js'
+// export { validateAndNormalizeAddress, isValidSuiAddress } from './utils.js'

package/src/sui/sui-chain-adapter.ts

@@ -10,7 +10,6 @@ import {
   SuiMoveObject,
   SuiParsedData,
 } from '@mysten/sui.js'
-import { validateAndNormalizeAddress } from './utils.js'
 
 export class SuiChainAdapter extends ChainAdapter<SuiNetwork, SuiMoveNormalizedModule, SuiEvent | SuiMoveObject> {
   static INSTANCE = new SuiChainAdapter()
@@ -76,9 +75,9 @@ export class SuiChainAdapter extends ChainAdapter<SuiNetwork, SuiMoveNormalizedM
     }
     return val as any
   }
-  validateAndNormalizeAddress(address: string) {
-    return validateAndNormalizeAddress(address)
-  }
+  // validateAndNormalizeAddress(address: string) {
+  //   return validateAndNormalizeAddress(address)
+  // }
 }
 
 function getRpcEndpoint(network: SuiNetwork): string {

package/src/sui/sui-plugin.ts

@@ -18,7 +18,6 @@ import { ServerError, Status } from 'nice-grpc'
 
 import { SuiProcessorState } from './sui-processor.js'
 import { SuiAccountProcessorState } from './sui-object-processor.js'
-import { validateAndNormalizeAddress } from './utils.js'
 import { initCoinList } from './ext/coin.js'
 import { SuiChainId } from '@sentio/chain'
 import {
@@ -77,7 +76,7 @@ export class SuiPlugin extends Plugin {
         contract: {
           name: suiProcessor.moduleName,
           chainId: suiProcessor.config.network,
-          address: suiProcessor.config.address === '*' ? '*' : validateAndNormalizeAddress(suiProcessor.config.address),
+          address: suiProcessor.config.address,
           abi: '',
         },
         startBlock: suiProcessor.config.startCheckpoint,
@@ -118,7 +117,7 @@ export class SuiPlugin extends Plugin {
 
     for (const processor of SuiAccountProcessorState.INSTANCE.getValues()) {
       const accountConfig = AccountConfig.fromPartial({
-        address: validateAndNormalizeAddress(processor.config.address),
+        address: processor.config.address,
         chainId: processor.getChainId(),
         startBlock: processor.config.startCheckpoint, // TODO maybe use another field
       })

package/src/sui/sui-processor.ts

@@ -11,6 +11,8 @@ import {
   SuiTransactionBlockResponse,
 } from '@mysten/sui.js'
 import {
+  accountAddressString,
+  accountTypeString,
   CallHandler,
   EventFilter,
   EventHandler,
@@ -32,21 +34,9 @@ const DEFAULT_FETCH_CONFIG: MoveFetchConfig = {
 export type IndexConfigure = Required<SuiBindOptions, 'startCheckpoint' | 'network'>
 
 export function configure(options: SuiBindOptions): IndexConfigure {
-  let addressNoPrefix = options.address
-
-  if (addressNoPrefix.startsWith('0x')) {
-    addressNoPrefix = addressNoPrefix.slice(2)
-  }
-  for (let i = 0; i < addressNoPrefix.length; i++) {
-    if (addressNoPrefix[i] !== '0') {
-      addressNoPrefix = addressNoPrefix.slice(i)
-      break
-    }
-  }
-
   return {
     startCheckpoint: options.startCheckpoint || 0n,
-    address: addressNoPrefix === '*' ? '*' : '0x' + addressNoPrefix,
+    address: options.address === '*' ? '*' : accountAddressString(options.address),
     network: options.network || SuiNetwork.MAIN_NET,
     baseLabels: options.baseLabels,
   }
@@ -100,7 +90,7 @@ export class SuiBaseProcessor {
     // const moduleName = this.moduleName
 
     const processor = this
-    const allEventType = new Set(_filters.map((f) => processor.config.address + '::' + f.type))
+    const allEventType = new Set(_filters.map((f) => accountTypeString(processor.config.address) + '::' + f.type))
 
     this.eventHandlers.push({
       handler: async function (data) {
@@ -158,7 +148,9 @@ export class SuiBaseProcessor {
     }
 
     const processor = this
-    const allFunctionType = new Set(_filters.map((f) => processor.config.address + '::' + f.function))
+    const allFunctionType = new Set(
+      _filters.map((f) => accountTypeString(processor.config.address) + '::' + f.function)
+    )
 
     this.callHandlers.push({
       handler: async function (data) {

package/src/sui/utils.ts

@@ -5,11 +5,8 @@ import {
   getProgrammableTransaction,
   ProgrammableTransaction,
   SuiTransaction,
-  normalizeSuiAddress,
-  SUI_ADDRESS_LENGTH,
-  SuiAddress,
 } from '@mysten/sui.js'
-import { isFrameworkAccount } from '../move/index.js'
+import { accountTypeString } from '../move/index.js'
 
 export function getMoveCalls(txBlock: SuiTransactionBlockResponse) {
   const txKind = getTransactionKind(txBlock)
@@ -24,12 +21,7 @@ export function getMoveCalls(txBlock: SuiTransactionBlockResponse) {
   return programmableTx.transactions.flatMap((tx: SuiTransaction) => {
     if ('MoveCall' in tx) {
       const call = tx.MoveCall as MoveCallSuiTransaction
-
-      let pkg: string = call.package
-      if (call.package.startsWith('0x000000000000000000000000000000000000000000000000000000000000000')) {
-        pkg = '0x' + pkg[pkg.length - 1]
-      }
-      call.package = pkg
+      call.package = accountTypeString(call.package)
 
       return [call]
     }
@@ -37,25 +29,25 @@ export function getMoveCalls(txBlock: SuiTransactionBlockResponse) {
   })
 }
 
-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 isValidSuiAddress(value: string): value is SuiAddress {
-  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 (!isValidSuiAddress(address)) {
-    throw Error('Not valid Address')
-  }
-  return normalizeSuiAddress(address)
-}
+// 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 isValidSuiAddress(value: string): value is SuiAddress {
+//   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 (!isValidSuiAddress(address)) {
+//     throw Error('Not valid Address')
+//   }
+//   return normalizeSuiAddress(address)
+// }