@scallop-io/sui-scallop-sdk 2.0.13-merge-split-ve-sca-alpha.4 → 2.1.0-alpha.1

package/src/queries/loyaltyProgramQuery.ts

@@ -36,7 +36,7 @@ export const getLoyaltyProgramInformations = async (
   const rewardPool = query.address.get('loyaltyProgram.rewardPool');
 
   // get fields from rewardPool object
-  const rewardPoolObject = await query.cache.queryGetObject(rewardPool);
+  const rewardPoolObject = await query.scallopSuiKit.queryGetObject(rewardPool);
 
   if (rewardPoolObject?.data?.content?.dataType !== 'moveObject') return null;
   const rewardPoolFields = rewardPoolObject.data.content.fields;
@@ -58,13 +58,15 @@ export const getLoyaltyProgramInformations = async (
     'loyaltyProgram.userRewardTableId'
   );
 
-  const userRewardObject = await query.cache.queryGetDynamicFieldObject({
-    parentId: userRewardTableId,
-    name: {
-      type: '0x2::object::ID',
-      value: typeof veScaKey === 'string' ? veScaKey : veScaKey.objectId,
-    },
-  });
+  const userRewardObject = await query.scallopSuiKit.queryGetDynamicFieldObject(
+    {
+      parentId: userRewardTableId,
+      name: {
+        type: '0x2::object::ID',
+        value: typeof veScaKey === 'string' ? veScaKey : veScaKey.objectId,
+      },
+    }
+  );
 
   if (userRewardObject?.data?.content?.dataType !== 'moveObject') return result;
   const userRewardFields = userRewardObject.data.content.fields;

package/src/queries/ownerQuery.ts

@@ -0,0 +1,32 @@
+// import { ObjectOwner, SuiObjectData } from '@mysten/sui/client';
+
+// const parseOwnerAddress = (owner: ObjectOwner | null | undefined): string => {
+//   const notSupportedOwner =
+//     !owner ||
+//     typeof owner === 'string' ||
+//     (typeof owner === 'object' &&
+//       ('Shared' in owner || 'ConsensusV2' in owner));
+//   if (notSupportedOwner)
+//     throw new Error('Owner not supported (ConsensusV2 or Shared or Immutable)');
+
+//   if ('AddressOwner' in owner) {
+//     return owner.AddressOwner;
+//   } else {
+//     return owner.ObjectOwner;
+//   }
+// };
+
+// export const getObjectOwner = async (
+//   cache: ScallopCache,
+//   object: string | SuiObjectData
+// ) => {
+//   if (typeof object === 'object') {
+//     return parseOwnerAddress(object.owner);
+//   }
+
+//   const objResponse = await cache.queryGetObject(object, {
+//     showOwner: true,
+//   });
+
+//   return parseOwnerAddress(objResponse.data?.owner);
+// };

package/src/queries/portfolioQuery.ts

@@ -1,6 +1,6 @@
 import BigNumber from 'bignumber.js';
 import { minBigNumber, estimatedFactor } from 'src/utils';
-import type { ScallopQuery } from 'src/models';
+import type { ScallopQuery } from '../models';
 import type {
   Market,
   MarketPool,
@@ -16,9 +16,8 @@ import type {
   ObligationBorrowIncentiveReward,
   MarketPools,
   MarketCollaterals,
-} from 'src/types';
+} from '../types';
 import { SuiObjectRef } from '@mysten/sui/client';
-import { queryMultipleObjects } from './objectsQuery';
 import { normalizeStructTag, SUI_TYPE_ARG } from '@scallop-io/sui-kit';
 
 /**
@@ -67,6 +66,7 @@ export const getLendings = async (
   ]);
 
   const lendings: Lendings = {};
+
   await Promise.allSettled(
     poolCoinNames.map(async (poolCoinName) => {
       const stakeMarketCoinName = stakeMarketCoinNames.find(
@@ -317,8 +317,7 @@ export const getObligationAccounts = async (
     query.getObligations(ownerAddress),
   ]);
 
-  const obligationObjects = await queryMultipleObjects(
-    query.cache,
+  const obligationObjects = await query.scallopSuiKit.queryGetObjects(
     obligations.map((obligation) => obligation.id)
   );
   const obligationAccounts: ObligationAccounts = {};

package/src/queries/priceQuery.ts

@@ -1,8 +1,7 @@
 import { SuiObjectData } from '@mysten/sui/client';
-import type { ScallopAddress, ScallopQuery } from '../models';
+import type { ScallopAddress, ScallopQuery, ScallopSuiKit } from 'src/models';
 import type { CoinPrices, MarketPools, OptionalKeys } from '../types';
 import BigNumber from 'bignumber.js';
-import { ScallopConstants } from 'src/models/scallopConstants';
 
 /**
  * Get price from pyth fee object.
@@ -14,8 +13,10 @@ import { ScallopConstants } from 'src/models/scallopConstants';
 export const getPythPrice = async (
   {
     address,
+    scallopSuiKit,
   }: {
     address: ScallopAddress;
+    scallopSuiKit: ScallopSuiKit;
   },
   assetCoinName: string,
   priceFeedObject?: SuiObjectData | null
@@ -25,7 +26,7 @@ export const getPythPrice = async (
   );
   priceFeedObject =
     priceFeedObject ||
-    (await address.cache.queryGetObject(pythFeedObjectId))?.data;
+    (await scallopSuiKit.queryGetObject(pythFeedObjectId))?.data;
 
   if (priceFeedObject) {
     const priceFeedPoolObject = priceFeedObject;
@@ -64,15 +65,17 @@ export const getPythPrice = async (
 
 export const getPythPrices = async (
   {
-    constants,
+    address,
+    scallopSuiKit,
   }: {
-    constants: ScallopConstants;
+    address: ScallopAddress;
+    scallopSuiKit: ScallopSuiKit;
   },
   assetCoinNames: string[]
 ) => {
   const pythPriceFeedIds = assetCoinNames.reduce(
     (prev, assetCoinName) => {
-      const pythPriceFeed = constants.address.get(
+      const pythPriceFeed = address.get(
         `core.coins.${assetCoinName}.oracle.pyth.feedObject`
       );
       if (pythPriceFeed) {
@@ -88,7 +91,7 @@ export const getPythPrices = async (
   );
 
   // Fetch multiple objects at once to save rpc calls
-  const priceFeedObjects = await constants.address.cache.queryGetObjects(
+  const priceFeedObjects = await scallopSuiKit.queryGetObjects(
     Object.keys(pythPriceFeedIds)
   );
 
@@ -108,7 +111,10 @@ export const getPythPrices = async (
         async ([assetCoinName, priceFeedObject]) => ({
           coinName: assetCoinName,
           price: await getPythPrice(
-            constants,
+            {
+              address,
+              scallopSuiKit,
+            },
             assetCoinName as string,
             priceFeedObject
           ),

package/src/queries/referralQuery.ts

@@ -1,4 +1,4 @@
-import { ScallopAddress } from 'src/models';
+import type { ScallopAddress, ScallopSuiKit } from 'src/models';
 
 /**
  * Query the veScaKeyId from the referral bindings table using the borrower address
@@ -6,11 +6,17 @@ import { ScallopAddress } from 'src/models';
  * @returns
  */
 export const queryVeScaKeyIdFromReferralBindings = async (
-  address: ScallopAddress,
+  {
+    address,
+    scallopSuiKit,
+  }: {
+    address: ScallopAddress;
+    scallopSuiKit: ScallopSuiKit;
+  },
   refereeAddress: string
 ): Promise<string | null> => {
   const referralBindingTableId = address.get('referral.bindingTableId');
-  const referralBindResponse = await address.cache.queryGetDynamicFieldObject({
+  const referralBindResponse = await scallopSuiKit.queryGetDynamicFieldObject({
     parentId: referralBindingTableId,
     name: {
       type: 'address',

package/src/queries/sCoinQuery.ts

@@ -26,7 +26,7 @@ export const getSCoinTotalSupply = async (
     utils.parseUnderlyingSCoinType(sCoinName),
   ];
   const queryTarget = `${sCoinPkgId}::s_coin_converter::total_supply`;
-  const queryResults = await utils.cache.queryInspectTxn({
+  const queryResults = await utils.scallopSuiKit.queryInspectTxn({
     queryTarget,
     args,
     typeArgs,
@@ -62,7 +62,7 @@ export const getSCoinAmounts = async (
   sCoinNames: string[] = [...utils.constants.whitelist.scoin],
   ownerAddress?: string
 ) => {
-  const owner = ownerAddress || utils.suiKit.currentAddress();
+  const owner = ownerAddress || utils.suiKit.currentAddress;
   const sCoins = {} as OptionalKeys<Record<string, number>>;
 
   await Promise.allSettled(
@@ -92,9 +92,9 @@ export const getSCoinAmount = async (
   sCoinName: string,
   ownerAddress?: string
 ) => {
-  const owner = ownerAddress || utils.suiKit.currentAddress();
+  const owner = ownerAddress || utils.suiKit.currentAddress;
   const sCoinType = utils.parseSCoinType(sCoinName);
-  const coinBalance = await utils.cache.queryGetCoinBalance({
+  const coinBalance = await utils.scallopSuiKit.queryGetCoinBalance({
     owner,
     coinType: sCoinType,
   });

package/src/queries/spoolQuery.ts

@@ -5,9 +5,9 @@ import {
   parseOriginSpoolRewardPoolData,
   calculateSpoolRewardPoolData,
   parseObjectAs,
-} from 'src/utils';
+} from '../utils';
 import type { SuiObjectData, SuiObjectResponse } from '@mysten/sui/client';
-import type { ScallopQuery, ScallopUtils } from 'src/models';
+import type { ScallopQuery, ScallopUtils } from '../models';
 import type {
   Spools,
   Spool,
@@ -19,8 +19,7 @@ import type {
   OriginSpoolRewardPoolData,
   SpoolData,
   OriginSpoolData,
-} from 'src/types';
-import { queryMultipleObjects } from './objectsQuery';
+} from '../types';
 
 const queryRequiredSpoolObjects = async (
   query: ScallopQuery,
@@ -63,9 +62,9 @@ const queryRequiredSpoolObjects = async (
   // Phase 2: Parallel queries with pre-collected keys
   const [spoolObjects, spoolRewardObjects, sCoinTreasuryObjects] =
     await Promise.all([
-      queryMultipleObjects(query.cache, keyCollections.spool),
-      queryMultipleObjects(query.cache, keyCollections.spoolReward),
-      queryMultipleObjects(query.cache, keyCollections.sCoinTreasury),
+      query.scallopSuiKit.queryGetObjects(keyCollections.spool),
+      query.scallopSuiKit.queryGetObjects(keyCollections.spoolReward),
+      query.scallopSuiKit.queryGetObjects(keyCollections.sCoinTreasury),
     ]);
 
   // Phase 3: Create lookup maps
@@ -315,7 +314,7 @@ export const getStakeAccounts = async (
   },
   ownerAddress?: string
 ) => {
-  const owner = ownerAddress || utils.suiKit.currentAddress();
+  const owner = ownerAddress || utils.suiKit.currentAddress;
   const spoolObjectId = utils.address.get('spool.object');
   const stakeAccountType = `${spoolObjectId}::spool_account::SpoolAccount`;
   const stakeObjectsResponse: SuiObjectResponse[] = [];
@@ -323,7 +322,7 @@ export const getStakeAccounts = async (
   let nextCursor: string | null | undefined = null;
   do {
     const paginatedStakeObjectsResponse =
-      await utils.cache.queryGetOwnedObjects({
+      await utils.scallopSuiKit.queryGetOwnedObjects({
         owner,
         filter: { StructType: stakeAccountType },
         options: {
@@ -445,7 +444,8 @@ export const getStakePool = async (
 ) => {
   const poolId = utils.address.get(`spool.pools.${marketCoinName}.id`);
   let stakePool: StakePool | undefined = undefined;
-  const stakePoolObjectResponse = await utils.cache.queryGetObject(poolId);
+  const stakePoolObjectResponse =
+    await utils.scallopSuiKit.queryGetObject(poolId);
   if (stakePoolObjectResponse?.data) {
     const stakePoolObject = stakePoolObjectResponse.data;
     const id = stakePoolObject.objectId;
@@ -505,7 +505,7 @@ export const getStakeRewardPool = async (
   );
   let stakeRewardPool: StakeRewardPool | undefined = undefined;
   const stakeRewardPoolObjectResponse =
-    await utils.cache.queryGetObject(poolId);
+    await utils.scallopSuiKit.queryGetObject(poolId);
 
   if (stakeRewardPoolObjectResponse?.data) {
     const stakeRewardPoolObject = stakeRewardPoolObjectResponse.data;

package/src/queries/supplyLimitQuery.ts

@@ -30,7 +30,7 @@ export const getSupplyLimit = async (utils: ScallopUtils, poolName: string) => {
     const marketObject = utils.address.get('core.market');
     if (!marketObject) return null;
 
-    const object = await utils.cache.queryGetDynamicFieldObject({
+    const object = await utils.scallopSuiKit.queryGetDynamicFieldObject({
       parentId: marketObject,
       name: {
         type: supplyLimitKeyType,

package/src/queries/switchboardQuery.ts

@@ -47,7 +47,7 @@ export const getOnDemandAggObjectIds = async (
         },
       };
 
-      const resp = await query.cache.queryGetDynamicFieldObject({
+      const resp = await query.scallopSuiKit.queryGetDynamicFieldObject({
         parentId: switchboardRegistryTableId,
         name: dfName,
       });

package/src/queries/vescaQuery.ts

@@ -1,11 +1,11 @@
 import BigNumber from 'bignumber.js';
-import { VeScaTreasuryFields, VeScaTreasuryInfo, Vesca } from 'src/types';
+import { VeScaTreasuryFields, VeScaTreasuryInfo, Vesca } from '../types';
 import {
   type SuiObjectResponse,
   type SuiObjectData,
   DevInspectResults,
 } from '@mysten/sui/client';
-import type { ScallopUtils } from 'src/models';
+import type { ScallopUtils } from '../models';
 import { MAX_LOCK_DURATION } from 'src/constants';
 import { SUI_CLOCK_OBJECT_ID, SuiTxBlock } from '@scallop-io/sui-kit';
 import { bcs } from '@mysten/sui/bcs';
@@ -23,21 +23,22 @@ export const getVescaKeys = async (
   utils: ScallopUtils,
   ownerAddress?: string
 ) => {
-  const owner = ownerAddress || utils.suiKit.currentAddress();
+  const owner = ownerAddress || utils.suiKit.currentAddress;
   const veScaObjId = utils.address.get('vesca.object');
   const veScaKeyType = `${veScaObjId}::ve_sca::VeScaKey`;
   const keyObjectsResponse: SuiObjectResponse[] = [];
   let hasNextPage = false;
   let nextCursor: string | null | undefined = null;
   do {
-    const paginatedKeyObjectsResponse = await utils.cache.queryGetOwnedObjects({
-      owner,
-      filter: {
-        StructType: veScaKeyType,
-      },
-      cursor: nextCursor,
-      limit: 10,
-    });
+    const paginatedKeyObjectsResponse =
+      await utils.scallopSuiKit.queryGetOwnedObjects({
+        owner,
+        filter: {
+          StructType: veScaKeyType,
+        },
+        cursor: nextCursor,
+        limit: 10,
+      });
     if (!paginatedKeyObjectsResponse) continue;
 
     keyObjectsResponse.push(...paginatedKeyObjectsResponse.data);
@@ -125,7 +126,7 @@ export const getVeSca = async (
   let vesca: Vesca | undefined = undefined;
 
   const veScaDynamicFieldObjectResponse =
-    await utils.cache.queryGetDynamicFieldObject({
+    await utils.scallopSuiKit.queryGetDynamicFieldObject({
       parentId: tableId,
       name: {
         type: '0x2::object::ID',
@@ -196,22 +197,22 @@ const getTotalVeScaTreasuryAmount = async (
 
   // query total veSca amount
   const veScaAmountQueryTarget = `${veScaPkgId}::treasury::total_ve_sca_amount`;
-  const veScaAmountArgs = [veScaTreasury, clockObjectRef];
+  const vescaAmountArgs = [veScaTreasury, clockObjectRef];
 
   // resolve each args
   const resolvedRefreshArgs = await Promise.all(
     refreshArgs.map(async (arg) => {
       if (typeof arg === 'string') {
-        return (await utils.cache.queryGetObject(arg))?.data;
+        return (await utils.scallopSuiKit.queryGetObject(arg))?.data;
       }
       return arg;
     })
   );
 
   const resolvedVeScaAmountArgs = await Promise.all(
-    veScaAmountArgs.map(async (arg) => {
+    vescaAmountArgs.map(async (arg) => {
       if (typeof arg === 'string') {
-        return (await utils.cache.queryGetObject(arg))?.data;
+        return (await utils.scallopSuiKit.queryGetObject(arg))?.data;
       }
       return arg;
     })
@@ -222,20 +223,22 @@ const getTotalVeScaTreasuryAmount = async (
   txb.moveCall(veScaAmountQueryTarget, resolvedVeScaAmountArgs);
 
   const txBytes = await txb.txBlock.build({
-    client: utils.suiKit.client(),
+    client: utils.suiKit.client,
     onlyTransactionKind: true,
   });
 
   // return result
-  const res = await utils.cache.queryClient.fetchQuery<DevInspectResults>({
-    queryKey: queryKeys.rpc.getTotalVeScaTreasuryAmount(
-      refreshArgs,
-      veScaAmountArgs
-    ),
-    queryFn: async () => {
-      return await utils.suiKit.inspectTxn(txBytes);
-    },
-  });
+  const res =
+    await utils.scallopSuiKit.queryClient.fetchQuery<DevInspectResults>({
+      queryKey: queryKeys.rpc.getTotalVeScaTreasuryAmount({
+        refreshArgs,
+        vescaAmountArgs,
+        node: utils.scallopSuiKit.currentFullNode,
+      }),
+      queryFn: async () => {
+        return await utils.suiKit.inspectTxn(txBytes);
+      },
+    });
 
   const results = res.results;
   if (results && results[1]?.returnValues) {
@@ -257,7 +260,8 @@ export const getVeScaTreasuryInfo = async (
   utils: ScallopUtils
 ): Promise<VeScaTreasuryInfo | null> => {
   const veScaTreasuryId = utils.address.get('vesca.treasury');
-  const veScaTreasury = await utils.cache.queryGetObject(veScaTreasuryId);
+  const veScaTreasury =
+    await utils.scallopSuiKit.queryGetObject(veScaTreasuryId);
 
   if (!veScaTreasury || veScaTreasury.data?.content?.dataType !== 'moveObject')
     return null;

package/src/queries/xOracleQuery.ts

@@ -1,5 +1,5 @@
 import { SuiObjectResponse } from '@mysten/sui/client';
-import { ScallopAddress, ScallopUtils } from 'src/models';
+import { ScallopAddress, ScallopSuiKit, ScallopUtils } from 'src/models';
 import { SupportOracleType, xOracleRuleType } from 'src/types';
 
 /**
@@ -7,23 +7,27 @@ import { SupportOracleType, xOracleRuleType } from 'src/types';
  * @param query
  * @returns Primary and Secondary price update policy table object
  */
-export const getPriceUpdatePolicies = async (
-  address: ScallopAddress
-): Promise<{
+export const getPriceUpdatePolicies = async ({
+  address,
+  scallopSuiKit,
+}: {
+  address: ScallopAddress;
+  scallopSuiKit: ScallopSuiKit;
+}): Promise<{
   primary: SuiObjectResponse | null;
   secondary: SuiObjectResponse | null;
 }> => {
   const priceUpdatePolicyRulesKeyType = `${address.get('core.packages.xOracle.object')}::price_update_policy::PriceUpdatePolicyRulesKey`;
   const [primaryPriceUpdatePolicyTable, secondaryPriceUpdatePolicyTable] =
     await Promise.all([
-      address.cache.queryGetDynamicFieldObject({
+      scallopSuiKit.queryGetDynamicFieldObject({
         parentId: address.get('core.oracles.primaryPriceUpdatePolicyObject'),
         name: {
           type: priceUpdatePolicyRulesKeyType,
           value: { dummy_field: false },
         },
       }),
-      address.cache.queryGetDynamicFieldObject({
+      scallopSuiKit.queryGetDynamicFieldObject({
         parentId: address.get('core.oracles.secondaryPriceUpdatePolicyObject'),
         name: {
           type: priceUpdatePolicyRulesKeyType,
@@ -67,7 +71,7 @@ export const getAssetOracles = async (
   const assetOracles = {} as Record<string, SupportOracleType[]>;
   let cursor = null;
   do {
-    const response = await utils.cache.queryGetDynamicFields({
+    const response = await utils.scallopSuiKit.queryGetDynamicFields({
       parentId:
         ruleType === 'primary'
           ? utils.address.get('core.oracles.primaryPriceUpdatePolicyVecsetId')
@@ -85,7 +89,8 @@ export const getAssetOracles = async (
     const objectIds = data.map((dynamicField) => dynamicField.objectId);
 
     // batch fetch object responses
-    const objectResponses = await utils.cache.queryGetObjects(objectIds);
+    const objectResponses =
+      await utils.scallopSuiKit.queryGetObjects(objectIds);
     objectResponses.forEach((object) => {
       if (!object.content || object.content.dataType !== 'moveObject') return;
       const fields = object.content.fields as any;

package/src/types/address.ts

@@ -108,9 +108,6 @@ export interface AddressesInterface {
     table: string;
     treasury: string;
     config: string;
-    subsTable: string;
-    subsTableId: string;
-    subsWhitelist: string;
   };
   referral: {
     id: string;

package/src/types/builder/core.ts

@@ -4,8 +4,8 @@ import type {
   SuiTxArg,
 } from '@scallop-io/sui-kit';
 import type { Argument, TransactionResult } from '@mysten/sui/transactions';
-import type { ScallopBuilder } from '../../models';
 import { SuiTxBlockWithSpool } from '.';
+import { ScallopBuilder } from 'src/models';
 
 export type CoreIds = {
   protocolPkg: string;

package/src/types/builder/vesca.ts

@@ -2,6 +2,13 @@ import { SuiTxBlock as SuiKitTxBlock, SuiObjectArg } from '@scallop-io/sui-kit';
 import type { TransactionResult } from '@mysten/sui/transactions';
 import { ScallopBuilder } from 'src/models';
 
+export type VescaIds = {
+  pkgId: string;
+  table: string;
+  treasury: string;
+  config: string;
+};
+
 export type VeScaNormalMethods = {
   lockSca: (
     scaCoin: SuiObjectArg,
@@ -19,17 +26,9 @@ export type VeScaNormalMethods = {
   ) => void;
   redeemSca: (veScaKey: SuiObjectArg) => TransactionResult;
   mintEmptyVeSca: () => TransactionResult;
-  splitVeSca: (
-    veScaKey: SuiObjectArg,
-    splitAmount: string
-  ) => TransactionResult;
-  mergeVeSca: (
-    targetVeScaKey: SuiObjectArg,
-    sourceVeScaKey: SuiObjectArg
-  ) => void;
 };
 
-export type QuickMethodReturnType<T extends boolean> = T extends true
+export type RedeemScaQuickReturnType<T extends boolean> = T extends true
   ? void
   : TransactionResult | undefined;
 
@@ -72,18 +71,9 @@ export type VeScaQuickMethods = {
     autoCheck?: boolean
   ) => Promise<void>;
   redeemScaQuick: <T extends boolean>(
-    veScaKey?: SuiObjectArg,
+    veSCaKey?: SuiObjectArg,
     transferSca?: T
-  ) => Promise<QuickMethodReturnType<T>>;
-  splitVeScaQuick: <T extends boolean>(
-    splitAmount: string,
-    veScaKey: string,
-    transferVeScaKey?: T
-  ) => Promise<QuickMethodReturnType<T>>;
-  mergeVeScaQuick: (
-    targetVeScaKey: string,
-    sourceVeScaKey: string
-  ) => Promise<void>;
+  ) => Promise<RedeemScaQuickReturnType<T>>;
 };
 
 export type SuiTxBlockWithVeScaNormalMethods = SuiKitTxBlock &

package/src/types/constant/queryKeys.ts

@@ -0,0 +1,48 @@
+import type {
+  GetDynamicFieldObjectParams,
+  GetDynamicFieldsParams,
+  GetOwnedObjectsParams,
+  SuiObjectData,
+  SuiObjectDataOptions,
+} from '@mysten/sui/dist/cjs/client';
+import type { SuiObjectArg, SuiTxArg } from '@scallop-io/sui-kit';
+
+export namespace QueryKeys {
+  export namespace API {
+    export type GetAddresses = {
+      addressId?: string;
+    };
+  }
+  export namespace RPC {
+    type BaseType = {
+      node?: string;
+    };
+
+    export type GetInspectTxn = BaseType & {
+      queryTarget?: string;
+      args?: SuiObjectArg[];
+      typeArgs?: any[];
+    };
+    export type GetObject = BaseType & {
+      objectId?: string;
+      options?: SuiObjectDataOptions;
+    };
+    export type GetObjects = BaseType & {
+      objectIds?: string[];
+    };
+    export type GetOwnedObjects = BaseType & Partial<GetOwnedObjectsParams>;
+    export type GetDynamicFields = BaseType & Partial<GetDynamicFieldsParams>;
+    export type GetDynamicFieldObject = BaseType &
+      Partial<GetDynamicFieldObjectParams>;
+    export type getTotalVeScaTreasuryAmount = BaseType & {
+      refreshArgs?: any[];
+      vescaAmountArgs?: (string | SuiObjectData | SuiTxArg)[];
+    };
+    export type GetAllCoinBalances = BaseType & {
+      activeAddress?: string;
+    };
+    export type GetNormalizedMoveFunction = BaseType & {
+      target?: string;
+    };
+  }
+}

package/src/types/index.ts

@@ -2,5 +2,4 @@ export type * from './builder';
 export type * from './constant';
 export type * from './query';
 export type * from './address';
-export type * from './model';
 export type * from './utils';

package/src/utils/builder.ts

@@ -5,7 +5,7 @@ import {
   MAX_LOCK_ROUNDS,
   MIN_INITIAL_LOCK_AMOUNT,
   MIN_TOP_UP_AMOUNT,
-} from 'src/constants';
+} from '../constants';
 import type { SuiObjectArg } from '@scallop-io/sui-kit';
 
 /**