@sentio/sdk 2.13.0-rc.7 → 2.13.0-rc.8

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

@@ -4,7 +4,7 @@
 
 /* Generated modules for account 0x3 */
 
-import { CallFilter } from "@sentio/sdk/move";
+import { CallFilter, TypeDescriptor, ANY_TYPE } from "@sentio/sdk/move";
 import {
   MoveCoder,
   defaultMoveCoder,
@@ -70,8 +70,7 @@ export class genesis extends SuiBaseProcessor {
 }
 
 export namespace genesis {
-  export class GenesisChainParameters {
-    static TYPE_QNAME = "0x3::genesis::GenesisChainParameters";
+  export interface GenesisChainParameters {
     protocol_version: bigint;
     chain_start_timestamp_ms: bigint;
     epoch_duration_ms: bigint;
@@ -86,14 +85,25 @@ export namespace genesis {
     validator_low_stake_grace_period: bigint;
   }
 
+  export namespace GenesisChainParameters {
+    export const TYPE_QNAME = "0x3::genesis::GenesisChainParameters";
+
+    const TYPE = new TypeDescriptor<GenesisChainParameters>(
+      GenesisChainParameters.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<GenesisChainParameters> {
+      return TYPE.apply();
+    }
+  }
+
   export interface GenesisChainParametersInstance
     extends TypedEventInstance<GenesisChainParameters> {
     data_decoded: GenesisChainParameters;
     type_arguments: [];
   }
 
-  export class GenesisValidatorMetadata {
-    static TYPE_QNAME = "0x3::genesis::GenesisValidatorMetadata";
+  export interface GenesisValidatorMetadata {
     name: number[];
     description: number[];
     image_url: number[];
@@ -111,29 +121,62 @@ export namespace genesis {
     worker_address: number[];
   }
 
+  export namespace GenesisValidatorMetadata {
+    export const TYPE_QNAME = "0x3::genesis::GenesisValidatorMetadata";
+
+    const TYPE = new TypeDescriptor<GenesisValidatorMetadata>(
+      GenesisValidatorMetadata.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<GenesisValidatorMetadata> {
+      return TYPE.apply();
+    }
+  }
+
   export interface GenesisValidatorMetadataInstance
     extends TypedEventInstance<GenesisValidatorMetadata> {
     data_decoded: GenesisValidatorMetadata;
     type_arguments: [];
   }
 
-  export class TokenAllocation {
-    static TYPE_QNAME = "0x3::genesis::TokenAllocation";
+  export interface TokenAllocation {
     recipient_address: SuiAddress;
     amount_mist: bigint;
     staked_with_validator: _0x1.option.Option<SuiAddress>;
   }
 
-  export class TokenDistributionSchedule {
-    static TYPE_QNAME = "0x3::genesis::TokenDistributionSchedule";
+  export namespace TokenAllocation {
+    export const TYPE_QNAME = "0x3::genesis::TokenAllocation";
+
+    const TYPE = new TypeDescriptor<TokenAllocation>(
+      TokenAllocation.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<TokenAllocation> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface TokenDistributionSchedule {
     stake_subsidy_fund_mist: bigint;
     allocations: genesis.TokenAllocation[];
   }
+
+  export namespace TokenDistributionSchedule {
+    export const TYPE_QNAME = "0x3::genesis::TokenDistributionSchedule";
+
+    const TYPE = new TypeDescriptor<TokenDistributionSchedule>(
+      TokenDistributionSchedule.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<TokenDistributionSchedule> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace stake_subsidy {
-  export class StakeSubsidy {
-    static TYPE_QNAME = "0x3::stake_subsidy::StakeSubsidy";
+  export interface StakeSubsidy {
     balance: _0x2.balance.Balance<_0x2.sui.SUI>;
     distribution_counter: bigint;
     current_distribution_amount: bigint;
@@ -141,6 +184,16 @@ export namespace stake_subsidy {
     stake_subsidy_decrease_rate: number;
     extra_fields: _0x2.bag.Bag;
   }
+
+  export namespace StakeSubsidy {
+    export const TYPE_QNAME = "0x3::stake_subsidy::StakeSubsidy";
+
+    const TYPE = new TypeDescriptor<StakeSubsidy>(StakeSubsidy.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<StakeSubsidy> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class staking_pool extends SuiBaseProcessor {
@@ -207,28 +260,47 @@ export class staking_pool extends SuiBaseProcessor {
 }
 
 export namespace staking_pool {
-  export class PoolTokenExchangeRate {
-    static TYPE_QNAME = "0x3::staking_pool::PoolTokenExchangeRate";
+  export interface PoolTokenExchangeRate {
     sui_amount: bigint;
     pool_token_amount: bigint;
   }
 
+  export namespace PoolTokenExchangeRate {
+    export const TYPE_QNAME = "0x3::staking_pool::PoolTokenExchangeRate";
+
+    const TYPE = new TypeDescriptor<PoolTokenExchangeRate>(
+      PoolTokenExchangeRate.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<PoolTokenExchangeRate> {
+      return TYPE.apply();
+    }
+  }
+
   export interface PoolTokenExchangeRateInstance
     extends TypedEventInstance<PoolTokenExchangeRate> {
     data_decoded: PoolTokenExchangeRate;
     type_arguments: [];
   }
 
-  export class StakedSui {
-    static TYPE_QNAME = "0x3::staking_pool::StakedSui";
+  export interface StakedSui {
     id: _0x2.object_.UID;
     pool_id: _0x2.object_.ID;
     stake_activation_epoch: bigint;
     principal: _0x2.balance.Balance<_0x2.sui.SUI>;
   }
 
-  export class StakingPool {
-    static TYPE_QNAME = "0x3::staking_pool::StakingPool";
+  export namespace StakedSui {
+    export const TYPE_QNAME = "0x3::staking_pool::StakedSui";
+
+    const TYPE = new TypeDescriptor<StakedSui>(StakedSui.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<StakedSui> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface StakingPool {
     id: _0x2.object_.UID;
     activation_epoch: _0x1.option.Option<bigint>;
     deactivation_epoch: _0x1.option.Option<bigint>;
@@ -245,6 +317,16 @@ export namespace staking_pool {
     extra_fields: _0x2.bag.Bag;
   }
 
+  export namespace StakingPool {
+    export const TYPE_QNAME = "0x3::staking_pool::StakingPool";
+
+    const TYPE = new TypeDescriptor<StakingPool>(StakingPool.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<StakingPool> {
+      return TYPE.apply();
+    }
+  }
+
   export interface JoinStakedSuiPayload
     extends TypedFunctionPayload<[SuiAddress | undefined]> {
     arguments_decoded: [SuiAddress | undefined];
@@ -259,11 +341,20 @@ export namespace staking_pool {
 }
 
 export namespace storage_fund {
-  export class StorageFund {
-    static TYPE_QNAME = "0x3::storage_fund::StorageFund";
+  export interface StorageFund {
     total_object_storage_rebates: _0x2.balance.Balance<_0x2.sui.SUI>;
     non_refundable_balance: _0x2.balance.Balance<_0x2.sui.SUI>;
   }
+
+  export namespace StorageFund {
+    export const TYPE_QNAME = "0x3::storage_fund::StorageFund";
+
+    const TYPE = new TypeDescriptor<StorageFund>(StorageFund.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<StorageFund> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class sui_system extends SuiBaseProcessor {
@@ -877,12 +968,21 @@ export class sui_system extends SuiBaseProcessor {
 }
 
 export namespace sui_system {
-  export class SuiSystemState {
-    static TYPE_QNAME = "0x3::sui_system::SuiSystemState";
+  export interface SuiSystemState {
     id: _0x2.object_.UID;
     version: bigint;
   }
 
+  export namespace SuiSystemState {
+    export const TYPE_QNAME = "0x3::sui_system::SuiSystemState";
+
+    const TYPE = new TypeDescriptor<SuiSystemState>(SuiSystemState.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<SuiSystemState> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ReportValidatorPayload
     extends TypedFunctionPayload<
       [SuiAddress | undefined, SuiAddress | undefined]
@@ -1224,8 +1324,7 @@ export class sui_system_state_inner extends SuiBaseProcessor {
 }
 
 export namespace sui_system_state_inner {
-  export class SuiSystemStateInner {
-    static TYPE_QNAME = "0x3::sui_system_state_inner::SuiSystemStateInner";
+  export interface SuiSystemStateInner {
     epoch: bigint;
     protocol_version: bigint;
     system_state_version: bigint;
@@ -1247,8 +1346,20 @@ export namespace sui_system_state_inner {
     extra_fields: _0x2.bag.Bag;
   }
 
-  export class SystemEpochInfoEvent {
-    static TYPE_QNAME = "0x3::sui_system_state_inner::SystemEpochInfoEvent";
+  export namespace SuiSystemStateInner {
+    export const TYPE_QNAME =
+      "0x3::sui_system_state_inner::SuiSystemStateInner";
+
+    const TYPE = new TypeDescriptor<SuiSystemStateInner>(
+      SuiSystemStateInner.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<SuiSystemStateInner> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface SystemEpochInfoEvent {
     epoch: bigint;
     protocol_version: bigint;
     reference_gas_price: bigint;
@@ -1263,14 +1374,26 @@ export namespace sui_system_state_inner {
     leftover_storage_fund_inflow: bigint;
   }
 
+  export namespace SystemEpochInfoEvent {
+    export const TYPE_QNAME =
+      "0x3::sui_system_state_inner::SystemEpochInfoEvent";
+
+    const TYPE = new TypeDescriptor<SystemEpochInfoEvent>(
+      SystemEpochInfoEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<SystemEpochInfoEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface SystemEpochInfoEventInstance
     extends TypedEventInstance<SystemEpochInfoEvent> {
     data_decoded: SystemEpochInfoEvent;
     type_arguments: [];
   }
 
-  export class SystemParameters {
-    static TYPE_QNAME = "0x3::sui_system_state_inner::SystemParameters";
+  export interface SystemParameters {
     epoch_duration_ms: bigint;
     stake_subsidy_start_epoch: bigint;
     max_validator_count: bigint;
@@ -1280,6 +1403,18 @@ export namespace sui_system_state_inner {
     validator_low_stake_grace_period: bigint;
     extra_fields: _0x2.bag.Bag;
   }
+
+  export namespace SystemParameters {
+    export const TYPE_QNAME = "0x3::sui_system_state_inner::SystemParameters";
+
+    const TYPE = new TypeDescriptor<SystemParameters>(
+      SystemParameters.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<SystemParameters> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class validator extends SuiBaseProcessor {
@@ -1331,8 +1466,7 @@ export class validator extends SuiBaseProcessor {
 }
 
 export namespace validator {
-  export class StakingRequestEvent {
-    static TYPE_QNAME = "0x3::validator::StakingRequestEvent";
+  export interface StakingRequestEvent {
     pool_id: _0x2.object_.ID;
     validator_address: SuiAddress;
     staker_address: SuiAddress;
@@ -1340,14 +1474,25 @@ export namespace validator {
     amount: bigint;
   }
 
+  export namespace StakingRequestEvent {
+    export const TYPE_QNAME = "0x3::validator::StakingRequestEvent";
+
+    const TYPE = new TypeDescriptor<StakingRequestEvent>(
+      StakingRequestEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<StakingRequestEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface StakingRequestEventInstance
     extends TypedEventInstance<StakingRequestEvent> {
     data_decoded: StakingRequestEvent;
     type_arguments: [];
   }
 
-  export class UnstakingRequestEvent {
-    static TYPE_QNAME = "0x3::validator::UnstakingRequestEvent";
+  export interface UnstakingRequestEvent {
     pool_id: _0x2.object_.ID;
     validator_address: SuiAddress;
     staker_address: SuiAddress;
@@ -1357,14 +1502,25 @@ export namespace validator {
     reward_amount: bigint;
   }
 
+  export namespace UnstakingRequestEvent {
+    export const TYPE_QNAME = "0x3::validator::UnstakingRequestEvent";
+
+    const TYPE = new TypeDescriptor<UnstakingRequestEvent>(
+      UnstakingRequestEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UnstakingRequestEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UnstakingRequestEventInstance
     extends TypedEventInstance<UnstakingRequestEvent> {
     data_decoded: UnstakingRequestEvent;
     type_arguments: [];
   }
 
-  export class Validator {
-    static TYPE_QNAME = "0x3::validator::Validator";
+  export interface Validator {
     metadata: validator.ValidatorMetadata;
     voting_power: bigint;
     operation_cap_id: _0x2.object_.ID;
@@ -1377,8 +1533,17 @@ export namespace validator {
     extra_fields: _0x2.bag.Bag;
   }
 
-  export class ValidatorMetadata {
-    static TYPE_QNAME = "0x3::validator::ValidatorMetadata";
+  export namespace Validator {
+    export const TYPE_QNAME = "0x3::validator::Validator";
+
+    const TYPE = new TypeDescriptor<Validator>(Validator.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Validator> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ValidatorMetadata {
     sui_address: SuiAddress;
     protocol_pubkey_bytes: number[];
     network_pubkey_bytes: number[];
@@ -1402,19 +1567,54 @@ export namespace validator {
     next_epoch_worker_address: _0x1.option.Option<string>;
     extra_fields: _0x2.bag.Bag;
   }
+
+  export namespace ValidatorMetadata {
+    export const TYPE_QNAME = "0x3::validator::ValidatorMetadata";
+
+    const TYPE = new TypeDescriptor<ValidatorMetadata>(
+      ValidatorMetadata.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ValidatorMetadata> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace validator_cap {
-  export class UnverifiedValidatorOperationCap {
-    static TYPE_QNAME = "0x3::validator_cap::UnverifiedValidatorOperationCap";
+  export interface UnverifiedValidatorOperationCap {
     id: _0x2.object_.UID;
     authorizer_validator_address: SuiAddress;
   }
 
-  export class ValidatorOperationCap {
-    static TYPE_QNAME = "0x3::validator_cap::ValidatorOperationCap";
+  export namespace UnverifiedValidatorOperationCap {
+    export const TYPE_QNAME =
+      "0x3::validator_cap::UnverifiedValidatorOperationCap";
+
+    const TYPE = new TypeDescriptor<UnverifiedValidatorOperationCap>(
+      UnverifiedValidatorOperationCap.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UnverifiedValidatorOperationCap> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ValidatorOperationCap {
     authorizer_validator_address: SuiAddress;
   }
+
+  export namespace ValidatorOperationCap {
+    export const TYPE_QNAME = "0x3::validator_cap::ValidatorOperationCap";
+
+    const TYPE = new TypeDescriptor<ValidatorOperationCap>(
+      ValidatorOperationCap.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ValidatorOperationCap> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class validator_set extends SuiBaseProcessor {
@@ -1483,8 +1683,7 @@ export class validator_set extends SuiBaseProcessor {
 }
 
 export namespace validator_set {
-  export class ValidatorEpochInfoEvent {
-    static TYPE_QNAME = "0x3::validator_set::ValidatorEpochInfoEvent";
+  export interface ValidatorEpochInfoEvent {
     epoch: bigint;
     validator_address: SuiAddress;
     reference_gas_survey_quote: bigint;
@@ -1497,41 +1696,74 @@ export namespace validator_set {
     tallying_rule_global_score: bigint;
   }
 
+  export namespace ValidatorEpochInfoEvent {
+    export const TYPE_QNAME = "0x3::validator_set::ValidatorEpochInfoEvent";
+
+    const TYPE = new TypeDescriptor<ValidatorEpochInfoEvent>(
+      ValidatorEpochInfoEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ValidatorEpochInfoEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ValidatorEpochInfoEventInstance
     extends TypedEventInstance<ValidatorEpochInfoEvent> {
     data_decoded: ValidatorEpochInfoEvent;
     type_arguments: [];
   }
 
-  export class ValidatorJoinEvent {
-    static TYPE_QNAME = "0x3::validator_set::ValidatorJoinEvent";
+  export interface ValidatorJoinEvent {
     epoch: bigint;
     validator_address: SuiAddress;
     staking_pool_id: _0x2.object_.ID;
   }
 
+  export namespace ValidatorJoinEvent {
+    export const TYPE_QNAME = "0x3::validator_set::ValidatorJoinEvent";
+
+    const TYPE = new TypeDescriptor<ValidatorJoinEvent>(
+      ValidatorJoinEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ValidatorJoinEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ValidatorJoinEventInstance
     extends TypedEventInstance<ValidatorJoinEvent> {
     data_decoded: ValidatorJoinEvent;
     type_arguments: [];
   }
 
-  export class ValidatorLeaveEvent {
-    static TYPE_QNAME = "0x3::validator_set::ValidatorLeaveEvent";
+  export interface ValidatorLeaveEvent {
     epoch: bigint;
     validator_address: SuiAddress;
     staking_pool_id: _0x2.object_.ID;
     is_voluntary: Boolean;
   }
 
+  export namespace ValidatorLeaveEvent {
+    export const TYPE_QNAME = "0x3::validator_set::ValidatorLeaveEvent";
+
+    const TYPE = new TypeDescriptor<ValidatorLeaveEvent>(
+      ValidatorLeaveEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ValidatorLeaveEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ValidatorLeaveEventInstance
     extends TypedEventInstance<ValidatorLeaveEvent> {
     data_decoded: ValidatorLeaveEvent;
     type_arguments: [];
   }
 
-  export class ValidatorSet {
-    static TYPE_QNAME = "0x3::validator_set::ValidatorSet";
+  export interface ValidatorSet {
     total_stake: bigint;
     active_validators: validator.Validator[];
     pending_active_validators: _0x2.table_vec.TableVec<validator.Validator>;
@@ -1548,21 +1780,53 @@ export namespace validator_set {
     at_risk_validators: _0x2.vec_map.VecMap<SuiAddress, bigint>;
     extra_fields: _0x2.bag.Bag;
   }
+
+  export namespace ValidatorSet {
+    export const TYPE_QNAME = "0x3::validator_set::ValidatorSet";
+
+    const TYPE = new TypeDescriptor<ValidatorSet>(ValidatorSet.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ValidatorSet> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace validator_wrapper {
-  export class ValidatorWrapper {
-    static TYPE_QNAME = "0x3::validator_wrapper::ValidatorWrapper";
+  export interface ValidatorWrapper {
     inner: _0x2.versioned.Versioned;
   }
+
+  export namespace ValidatorWrapper {
+    export const TYPE_QNAME = "0x3::validator_wrapper::ValidatorWrapper";
+
+    const TYPE = new TypeDescriptor<ValidatorWrapper>(
+      ValidatorWrapper.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ValidatorWrapper> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace voting_power {
-  export class VotingPowerInfo {
-    static TYPE_QNAME = "0x3::voting_power::VotingPowerInfo";
+  export interface VotingPowerInfo {
     validator_index: bigint;
     voting_power: bigint;
   }
+
+  export namespace VotingPowerInfo {
+    export const TYPE_QNAME = "0x3::voting_power::VotingPowerInfo";
+
+    const TYPE = new TypeDescriptor<VotingPowerInfo>(
+      VotingPowerInfo.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<VotingPowerInfo> {
+      return TYPE.apply();
+    }
+  }
 }
 
 const MODULES = JSON.parse(

package/src/sui/codegen/codegen.ts

@@ -9,17 +9,23 @@ import { structQname } from '../../move/index.js'
 import { join } from 'path'
 import { SuiChainAdapter } from '../sui-chain-adapter.js'
 
-export async function codegen(abisDir: string, outDir = join('src', 'types', 'sui'), genExample = false) {
+export async function codegen(
+  abisDir: string,
+  outDir = join('src', 'types', 'sui'),
+  genExample = false,
+  builtin = false
+) {
   if (!fs.existsSync(abisDir)) {
     return
   }
   const gen = new SuiCodegen()
-  const numFiles = await gen.generate(abisDir, outDir)
+  const numFiles = await gen.generate(abisDir, outDir, builtin)
   console.log(chalk.green(`Generated ${numFiles} for Sui`))
 }
 
 class SuiCodegen extends AbstractCodegen<SuiNetwork, SuiMoveNormalizedModule, SuiEvent | SuiMoveObject> {
   ADDRESS_TYPE = 'SuiAddress'
+  // ADDRESS_TYPE = 'string'
   MAIN_NET = SuiNetwork.MAIN_NET
   TEST_NET = SuiNetwork.TEST_NET
   PREFIX = 'Sui'

package/src/sui/codegen/run.ts

@@ -6,7 +6,7 @@ if (process.argv.length > 3) {
   const abisDir = process.argv[2]
   const targetDir = process.argv[3]
 
-  await codegen(abisDir, targetDir)
+  await codegen(abisDir, targetDir, false, true)
 } else {
   console.error('Not enough argument')
   process.exit(1)

package/src/sui/index.ts

@@ -11,6 +11,7 @@ export * from './context.js'
 export * from './models.js'
 
 export type { SuiAddress } from './move-types.js'
+export { BUILTIN_TYPES } from '../move/types.js'
 
 export * from './move-coder.js'
 

package/src/sui/models.ts

@@ -1,13 +1,8 @@
 import type { SuiEvent, MoveCallSuiTransaction, SuiMoveObject } from '@mysten/sui.js'
+import { DecodedStruct } from '../move/types.js'
 
-export type TypedEventInstance<T> = SuiEvent & {
-  /**
-   * decoded data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
-   */
-  data_decoded: T
-
-  type_arguments: string[]
-}
+export type TypedEventInstance<T> = DecodedStruct<SuiEvent, T>
+export type TypedSuiMoveObject<T> = DecodedStruct<SuiMoveObject, T>
 
 export type TypedFunctionPayload<T extends Array<any>> = MoveCallSuiTransaction & {
   /**
@@ -15,8 +10,3 @@ export type TypedFunctionPayload<T extends Array<any>> = MoveCallSuiTransaction
    */
   arguments_decoded: T
 }
-
-export type TypedSuiMoveObject<T> = SuiMoveObject & {
-  data_decoded: T
-  type_arguments: string[]
-}