@scallop-io/sui-scallop-sdk 1.4.2-rc.5 → 1.4.3-rc.1

package/dist/types/builder/borrowIncentive.d.ts

@@ -11,11 +11,11 @@ export type BorrowIncentiveIds = {
     obligationAccessStore: string;
 };
 export type BorrowIncentiveNormalMethods = {
-    stakeObligation: (obligation: SuiObjectArg, obligationKey: SuiObjectArg) => Promise<void>;
-    stakeObligationWithVesca: (obligation: SuiObjectArg, obligationKey: SuiObjectArg, veScaKey: SuiObjectArg) => Promise<void>;
-    unstakeObligation: (obligation: SuiObjectArg, obligationKey: SuiObjectArg) => Promise<void>;
-    claimBorrowIncentive: (obligation: SuiObjectArg, obligationKey: SuiObjectArg, rewardType: SupportBorrowIncentiveRewardCoins) => Promise<TransactionResult>;
-    deactivateBoost: (obligation: SuiObjectArg, veScaKey: SuiObjectArg) => Promise<void>;
+    stakeObligation: (obligation: SuiObjectArg, obligationKey: SuiObjectArg) => void;
+    stakeObligationWithVesca: (obligation: SuiObjectArg, obligationKey: SuiObjectArg, veScaKey: SuiObjectArg) => void;
+    unstakeObligation: (obligation: SuiObjectArg, obligationKey: SuiObjectArg) => void;
+    claimBorrowIncentive: (obligation: SuiObjectArg, obligationKey: SuiObjectArg, rewardType: SupportBorrowIncentiveRewardCoins) => TransactionResult;
+    deactivateBoost: (obligation: SuiObjectArg, veScaKey: SuiObjectArg) => void;
 };
 export type BorrowIncentiveQuickMethods = {
     stakeObligationQuick(obligation?: string, obligationKey?: string): Promise<void>;

package/dist/types/builder/core.d.ts

@@ -17,25 +17,21 @@ type Obligation = NestedResult;
 type ObligationKey = NestedResult;
 type ObligationHotPotato = NestedResult;
 export type CoreNormalMethods = {
-    openObligation: () => Promise<[
-        Obligation,
-        ObligationKey,
-        ObligationHotPotato
-    ]>;
-    returnObligation: (obligation: SuiObjectArg, obligationHotPotato: SuiObjectArg) => Promise<void>;
-    openObligationEntry: () => Promise<void>;
-    addCollateral: (obligation: SuiObjectArg, coin: SuiObjectArg, collateralCoinName: SupportCollateralCoins) => Promise<void>;
-    takeCollateral: (obligation: SuiObjectArg, obligationKey: SuiObjectArg, amount: number, collateralCoinName: SupportCollateralCoins) => Promise<TransactionResult>;
-    deposit: (coin: SuiObjectArg, poolCoinName: SupportPoolCoins) => Promise<TransactionResult>;
-    depositEntry: (coin: SuiObjectArg, poolCoinName: SupportPoolCoins) => Promise<TransactionResult>;
-    withdraw: (marketCoin: SuiObjectArg, poolCoinName: SupportPoolCoins) => Promise<TransactionResult>;
-    withdrawEntry: (marketCoin: SuiObjectArg, poolCoinName: SupportPoolCoins) => Promise<TransactionResult>;
-    borrow: (obligation: SuiObjectArg, obligationKey: SuiObjectArg, amount: number, poolCoinName: SupportPoolCoins) => Promise<TransactionResult>;
-    borrowWithReferral: (obligation: SuiObjectArg, obligationKey: SuiObjectArg, borrowReferral: SuiObjectArg, amount: number | SuiTxArg, poolCoinName: SupportPoolCoins) => Promise<TransactionResult>;
-    borrowEntry: (obligation: SuiObjectArg, obligationKey: SuiObjectArg, amount: number, poolCoinName: SupportPoolCoins) => Promise<TransactionResult>;
-    repay: (obligation: SuiObjectArg, coin: SuiObjectArg, poolCoinName: SupportPoolCoins) => Promise<void>;
-    borrowFlashLoan: (amount: number | SuiTxArg, poolCoinName: SupportPoolCoins) => Promise<TransactionResult>;
-    repayFlashLoan: (coin: SuiObjectArg, loan: SuiObjectArg, poolCoinName: SupportPoolCoins) => Promise<void>;
+    openObligation: () => [Obligation, ObligationKey, ObligationHotPotato];
+    returnObligation: (obligation: SuiObjectArg, obligationHotPotato: SuiObjectArg) => void;
+    openObligationEntry: () => void;
+    addCollateral: (obligation: SuiObjectArg, coin: SuiObjectArg, collateralCoinName: SupportCollateralCoins) => void;
+    takeCollateral: (obligation: SuiObjectArg, obligationKey: SuiObjectArg, amount: number, collateralCoinName: SupportCollateralCoins) => TransactionResult;
+    deposit: (coin: SuiObjectArg, poolCoinName: SupportPoolCoins) => TransactionResult;
+    depositEntry: (coin: SuiObjectArg, poolCoinName: SupportPoolCoins) => TransactionResult;
+    withdraw: (marketCoin: SuiObjectArg, poolCoinName: SupportPoolCoins) => TransactionResult;
+    withdrawEntry: (marketCoin: SuiObjectArg, poolCoinName: SupportPoolCoins) => TransactionResult;
+    borrow: (obligation: SuiObjectArg, obligationKey: SuiObjectArg, amount: number, poolCoinName: SupportPoolCoins) => TransactionResult;
+    borrowWithReferral: (obligation: SuiObjectArg, obligationKey: SuiObjectArg, borrowReferral: SuiObjectArg, amount: number | SuiTxArg, poolCoinName: SupportPoolCoins) => TransactionResult;
+    borrowEntry: (obligation: SuiObjectArg, obligationKey: SuiObjectArg, amount: number, poolCoinName: SupportPoolCoins) => TransactionResult;
+    repay: (obligation: SuiObjectArg, coin: SuiObjectArg, poolCoinName: SupportPoolCoins) => void;
+    borrowFlashLoan: (amount: number | SuiTxArg, poolCoinName: SupportPoolCoins) => TransactionResult;
+    repayFlashLoan: (coin: SuiObjectArg, loan: SuiObjectArg, poolCoinName: SupportPoolCoins) => void;
 };
 export type CoreQuickMethods = {
     addCollateralQuick: (amount: number, collateralCoinName: SupportCollateralCoins, obligationId?: SuiObjectArg) => Promise<void>;

package/dist/types/builder/loyaltyProgram.d.ts

@@ -6,7 +6,7 @@ export type LoyaltyProgramIds = {
     userRewardTableId: string;
 };
 export type LoyaltyProgramNormalMethods = {
-    claimLoyaltyRevenue: (veScaKey: SuiObjectArg) => Promise<TransactionResult>;
+    claimLoyaltyRevenue: (veScaKey: SuiObjectArg) => TransactionResult;
 };
 export type LoyaltyProgramQuickMethods = {
     claimLoyaltyRevenueQuick: (veScaKey?: SuiObjectArg) => Promise<void>;

package/dist/types/builder/referral.d.ts

@@ -10,10 +10,10 @@ export type ReferralIds = {
     version: string;
 };
 export type ReferralNormalMethods = {
-    bindToReferral: (veScaKeyId: string) => Promise<void>;
-    claimReferralTicket: (poolCoinName: SupportPoolCoins) => Promise<TransactionResult>;
-    burnReferralTicket: (ticket: SuiObjectArg, poolCoinName: SupportPoolCoins) => Promise<void>;
-    claimReferralRevenue: (veScaKey: SuiObjectArg, poolCoinName: SupportPoolCoins) => Promise<TransactionResult>;
+    bindToReferral: (veScaKeyId: string) => void;
+    claimReferralTicket: (poolCoinName: SupportPoolCoins) => TransactionResult;
+    burnReferralTicket: (ticket: SuiObjectArg, poolCoinName: SupportPoolCoins) => void;
+    claimReferralRevenue: (veScaKey: SuiObjectArg, poolCoinName: SupportPoolCoins) => TransactionResult;
 };
 export type ReferralQuickMethods = {
     claimReferralRevenueQuick: (veScaKey: SuiObjectArg, coinNames: SupportPoolCoins[]) => Promise<void>;

package/dist/types/builder/sCoin.d.ts

@@ -12,14 +12,14 @@ export type sCoinNormalMethods = {
      * @param marketCoin
      * @returns
      */
-    mintSCoin: (marketCoinName: SupportSCoin, marketCoin: SuiObjectArg) => Promise<TransactionResult>;
+    mintSCoin: (marketCoinName: SupportSCoin, marketCoin: SuiObjectArg) => TransactionResult;
     /**
      * Burn sCoin and return marketCoin
      * @param sCoinName
      * @param sCoin
      * @returns
      */
-    burnSCoin: (sCoinName: SupportSCoin, sCoin: SuiObjectArg) => Promise<TransactionResult>;
+    burnSCoin: (sCoinName: SupportSCoin, sCoin: SuiObjectArg) => TransactionResult;
 };
 export type sCoinQuickMethods = {
     mintSCoinQuick: (marketCoinName: SupportSCoin, amount: number) => Promise<TransactionResult>;

package/dist/types/builder/spool.d.ts

@@ -7,10 +7,10 @@ export type SpoolIds = {
     spoolPkg: string;
 };
 export type SpoolNormalMethods = {
-    createStakeAccount: (stakeMarketCoinName: SupportStakeMarketCoins) => Promise<TransactionResult>;
-    stake: (stakeAccount: SuiAddressArg, coin: SuiObjectArg, stakeMarketCoinName: SupportStakeMarketCoins) => Promise<void>;
-    unstake: (stakeAccount: SuiAddressArg, amount: number, stakeMarketCoinName: SupportStakeMarketCoins) => Promise<TransactionResult>;
-    claim: (stakeAccount: SuiAddressArg, stakeMarketCoinName: SupportStakeMarketCoins) => Promise<TransactionResult>;
+    createStakeAccount: (stakeMarketCoinName: SupportStakeMarketCoins) => TransactionResult;
+    stake: (stakeAccount: SuiAddressArg, coin: SuiObjectArg, stakeMarketCoinName: SupportStakeMarketCoins) => void;
+    unstake: (stakeAccount: SuiAddressArg, amount: number, stakeMarketCoinName: SupportStakeMarketCoins) => TransactionResult;
+    claim: (stakeAccount: SuiAddressArg, stakeMarketCoinName: SupportStakeMarketCoins) => TransactionResult;
 };
 export type SpoolQuickMethods = {
     stakeQuick(amountOrMarketCoin: SuiObjectArg | number, stakeMarketCoinName: SupportStakeMarketCoins, stakeAccountId?: SuiAddressArg): Promise<void>;

package/dist/types/builder/vesca.d.ts

@@ -8,12 +8,12 @@ export type VescaIds = {
     config: string;
 };
 export type VeScaNormalMethods = {
-    lockSca: (scaCoin: SuiObjectArg, unlockAtInSecondTimestamp: number) => Promise<TransactionResult>;
-    extendLockPeriod: (veScaKey: SuiObjectArg, newUnlockAtInSecondTimestamp: number) => Promise<void>;
-    extendLockAmount: (veScaKey: SuiObjectArg, scaCoin: SuiObjectArg) => Promise<void>;
-    renewExpiredVeSca: (veScaKey: SuiObjectArg, scaCoin: SuiObjectArg, newUnlockAtInSecondTimestamp: number) => Promise<void>;
-    redeemSca: (veScaKey: SuiObjectArg) => Promise<TransactionResult>;
-    mintEmptyVeSca: () => Promise<TransactionResult>;
+    lockSca: (scaCoin: SuiObjectArg, unlockAtInSecondTimestamp: number) => TransactionResult;
+    extendLockPeriod: (veScaKey: SuiObjectArg, newUnlockAtInSecondTimestamp: number) => void;
+    extendLockAmount: (veScaKey: SuiObjectArg, scaCoin: SuiObjectArg) => void;
+    renewExpiredVeSca: (veScaKey: SuiObjectArg, scaCoin: SuiObjectArg, newUnlockAtInSecondTimestamp: number) => void;
+    redeemSca: (veScaKey: SuiObjectArg) => TransactionResult;
+    mintEmptyVeSca: () => TransactionResult;
 };
 export type RedeemScaQuickReturnType<T extends boolean> = T extends true ? void : TransactionResult | undefined;
 export type VeScaQuickMethods = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "1.4.2-rc.5",
+  "version": "1.4.3-rc.1",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",

package/src/builders/borrowIncentiveBuilder.ts

@@ -97,8 +97,8 @@ const generateBorrowIncentiveNormalMethod: GenerateBorrowIncentiveNormalMethod =
     };
 
     return {
-      stakeObligation: async (obligationId, obligationKey) => {
-        await builder.moveCall(
+      stakeObligation: (obligationId, obligationKey) => {
+        builder.moveCall(
           txBlock,
           `${borrowIncentiveIds.borrowIncentivePkg}::user::stake`,
           [
@@ -112,12 +112,8 @@ const generateBorrowIncentiveNormalMethod: GenerateBorrowIncentiveNormalMethod =
           ]
         );
       },
-      stakeObligationWithVesca: async (
-        obligationId,
-        obligationKey,
-        veScaKey
-      ) => {
-        await builder.moveCall(
+      stakeObligationWithVesca: (obligationId, obligationKey, veScaKey) => {
+        builder.moveCall(
           txBlock,
           `${borrowIncentiveIds.borrowIncentivePkg}::user::stake_with_ve_sca`,
           [
@@ -136,8 +132,8 @@ const generateBorrowIncentiveNormalMethod: GenerateBorrowIncentiveNormalMethod =
           []
         );
       },
-      unstakeObligation: async (obligationId, obligationKey) => {
-        await builder.moveCall(
+      unstakeObligation: (obligationId, obligationKey) => {
+        builder.moveCall(
           txBlock,
           `${borrowIncentiveIds.borrowIncentivePkg}::user::unstake`,
           [
@@ -150,13 +146,9 @@ const generateBorrowIncentiveNormalMethod: GenerateBorrowIncentiveNormalMethod =
           ]
         );
       },
-      claimBorrowIncentive: async (
-        obligationId,
-        obligationKey,
-        rewardCoinName
-      ) => {
+      claimBorrowIncentive: (obligationId, obligationKey, rewardCoinName) => {
         const rewardType = builder.utils.parseCoinType(rewardCoinName);
-        return await builder.moveCall(
+        return builder.moveCall(
           txBlock,
           `${borrowIncentiveIds.borrowIncentivePkg}::user::redeem_rewards`,
           [
@@ -170,8 +162,8 @@ const generateBorrowIncentiveNormalMethod: GenerateBorrowIncentiveNormalMethod =
           [rewardType]
         );
       },
-      deactivateBoost: async (obligation, veScaKey) => {
-        await builder.moveCall(
+      deactivateBoost: (obligation, veScaKey) => {
+        builder.moveCall(
           txBlock,
           `${borrowIncentiveIds.borrowIncentivePkg}::user::deactivate_boost`,
           [
@@ -225,7 +217,7 @@ const generateBorrowIncentiveQuickMethod: GenerateBorrowIncentiveQuickMethod =
           );
 
         if (!obligationLocked || unstakeObligationBeforeStake) {
-          await txBlock.stakeObligation(obligationArg, obligationKeyArg);
+          txBlock.stakeObligation(obligationArg, obligationKeyArg);
         }
       },
       stakeObligationWithVeScaQuick: async (
@@ -260,9 +252,9 @@ const generateBorrowIncentiveQuickMethod: GenerateBorrowIncentiveQuickMethod =
 
           const _veScaKey = bindedVeScaKey ?? veScaKey;
           if (!_veScaKey) {
-            await txBlock.stakeObligation(obligationArg, obligationKeyArg);
+            txBlock.stakeObligation(obligationArg, obligationKeyArg);
           } else {
-            await txBlock.stakeObligationWithVesca(
+            txBlock.stakeObligationWithVesca(
               obligationArg,
               obligationKeyArg,
               _veScaKey
@@ -283,7 +275,7 @@ const generateBorrowIncentiveQuickMethod: GenerateBorrowIncentiveQuickMethod =
         );
 
         if (obligationLocked) {
-          await txBlock.unstakeObligation(obligationArg, obligationKeyArg);
+          txBlock.unstakeObligation(obligationArg, obligationKeyArg);
         }
       },
       claimBorrowIncentiveQuick: async (
@@ -300,7 +292,8 @@ const generateBorrowIncentiveQuickMethod: GenerateBorrowIncentiveQuickMethod =
             obligationKey
           );
 
-        return await txBlock.claimBorrowIncentive(
+        // return await txBlock.claimBorrowIncentive(
+        return txBlock.claimBorrowIncentive(
           obligationArg,
           obligationKeyArg,
           rewardCoinName

package/src/builders/coreBuilder.ts

@@ -77,50 +77,45 @@ const generateCoreNormalMethod: GenerateCoreNormalMethod = ({
   const referralWitnessType = `${referralPkgId}::scallop_referral_program::REFERRAL_WITNESS`;
 
   return {
-    openObligation: async () => {
-      const [obligation, obligationKey, obligationHotPotato] =
-        await builder.moveCall(
-          txBlock,
-          `${coreIds.protocolPkg}::open_obligation::open_obligation`,
-          [coreIds.version]
-        );
+    openObligation: () => {
+      const [obligation, obligationKey, obligationHotPotato] = builder.moveCall(
+        txBlock,
+        `${coreIds.protocolPkg}::open_obligation::open_obligation`,
+        [coreIds.version]
+      );
       return [obligation, obligationKey, obligationHotPotato] as [
         NestedResult,
         NestedResult,
         NestedResult,
       ];
     },
-    returnObligation: async (obligation, obligationHotPotato) => {
-      await builder.moveCall(
+    returnObligation: (obligation, obligationHotPotato) => {
+      builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::open_obligation::return_obligation`,
         [coreIds.version, obligation, obligationHotPotato]
       );
     },
-    openObligationEntry: async () => {
-      await builder.moveCall(
+    openObligationEntry: () => {
+      builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::open_obligation::open_obligation_entry`,
         [coreIds.version]
       );
     },
-    addCollateral: async (obligation, coin, collateralCoinName) => {
+    addCollateral: (obligation, coin, collateralCoinName) => {
       const coinType = builder.utils.parseCoinType(collateralCoinName);
-      await builder.moveCall(
+      builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::deposit_collateral::deposit_collateral`,
         [coreIds.version, obligation, coreIds.market, coin],
         [coinType]
       );
     },
-    takeCollateral: async (
-      obligation,
-      obligationKey,
-      amount,
-      collateralCoinName
-    ) => {
+    takeCollateral: (obligation, obligationKey, amount, collateralCoinName) => {
       const coinType = builder.utils.parseCoinType(collateralCoinName);
-      return await builder.moveCall(
+      // return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::withdraw_collateral::withdraw_collateral`,
         [
@@ -136,45 +131,50 @@ const generateCoreNormalMethod: GenerateCoreNormalMethod = ({
         [coinType]
       );
     },
-    deposit: async (coin, poolCoinName) => {
+    deposit: (coin, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return await builder.moveCall(
+      // return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::mint::mint`,
         [coreIds.version, coreIds.market, coin, SUI_CLOCK_OBJECT_ID],
         [coinType]
       );
     },
-    depositEntry: async (coin, poolCoinName) => {
+    depositEntry: (coin, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return await builder.moveCall(
+      // return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::mint::mint_entry`,
         [coreIds.version, coreIds.market, coin, SUI_CLOCK_OBJECT_ID],
         [coinType]
       );
     },
-    withdraw: async (marketCoin, poolCoinName) => {
+    withdraw: (marketCoin, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return await builder.moveCall(
+      // return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::redeem::redeem`,
         [coreIds.version, coreIds.market, marketCoin, SUI_CLOCK_OBJECT_ID],
         [coinType]
       );
     },
-    withdrawEntry: async (marketCoin, poolCoinName) => {
+    withdrawEntry: (marketCoin, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return await builder.moveCall(
+      // return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::redeem::redeem_entry`,
         [coreIds.version, coreIds.market, marketCoin, SUI_CLOCK_OBJECT_ID],
         [coinType]
       );
     },
-    borrow: async (obligation, obligationKey, amount, poolCoinName) => {
+    borrow: (obligation, obligationKey, amount, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return await builder.moveCall(
+      // return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::borrow::borrow`,
         [
@@ -190,7 +190,7 @@ const generateCoreNormalMethod: GenerateCoreNormalMethod = ({
         [coinType]
       );
     },
-    borrowWithReferral: async (
+    borrowWithReferral: (
       obligation,
       obligationKey,
       borrowReferral,
@@ -198,7 +198,8 @@ const generateCoreNormalMethod: GenerateCoreNormalMethod = ({
       poolCoinName
     ) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return await builder.moveCall(
+      // return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::borrow::borrow_with_referral`,
         [
@@ -215,9 +216,10 @@ const generateCoreNormalMethod: GenerateCoreNormalMethod = ({
         [coinType, referralWitnessType]
       );
     },
-    borrowEntry: async (obligation, obligationKey, amount, poolCoinName) => {
+    borrowEntry: (obligation, obligationKey, amount, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return await builder.moveCall(
+      // return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::borrow::borrow_entry`,
         [
@@ -233,9 +235,9 @@ const generateCoreNormalMethod: GenerateCoreNormalMethod = ({
         [coinType]
       );
     },
-    repay: async (obligation, coin, poolCoinName) => {
+    repay: (obligation, coin, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      await builder.moveCall(
+      builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::repay::repay`,
         [
@@ -248,18 +250,18 @@ const generateCoreNormalMethod: GenerateCoreNormalMethod = ({
         [coinType]
       );
     },
-    borrowFlashLoan: async (amount, poolCoinName) => {
+    borrowFlashLoan: (amount, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::flash_loan::borrow_flash_loan`,
         [coreIds.version, coreIds.market, amount],
         [coinType]
       );
     },
-    repayFlashLoan: async (coin, loan, poolCoinName) => {
+    repayFlashLoan: (coin, loan, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      await builder.moveCall(
+      builder.moveCall(
         txBlock,
         `${coreIds.protocolPkg}::flash_loan::repay_flash_loan`,
         [coreIds.version, coreIds.market, coin, loan],

package/src/builders/loyaltyProgramBuilder.ts

@@ -23,8 +23,8 @@ const generateLoyaltyProgramNormalMethod: GenerateLoyaltyProgramNormalMethod =
     };
 
     return {
-      claimLoyaltyRevenue: async (veScaKey) => {
-        return await builder.moveCall(
+      claimLoyaltyRevenue: (veScaKey) => {
+        return builder.moveCall(
           txBlock,
           `${loyaltyProgramIds.loyaltyProgramPkgId}::reward_pool::redeem_reward`,
           [loyaltyProgramIds.rewardPool, veScaKey]

package/src/builders/referralBuilder.ts

@@ -34,8 +34,8 @@ const generateReferralNormalMethod: GenerateReferralNormalMethod = ({
   const veScaTable = builder.address.get('vesca.table');
 
   return {
-    bindToReferral: async (veScaKeyId: string) => {
-      await builder.moveCall(
+    bindToReferral: (veScaKeyId: string) => {
+      builder.moveCall(
         txBlock,
         `${referralIds.referralPgkId}::referral_bindings::bind_ve_sca_referrer`,
         [
@@ -47,9 +47,9 @@ const generateReferralNormalMethod: GenerateReferralNormalMethod = ({
         []
       );
     },
-    claimReferralTicket: async (poolCoinName: SupportCoins) => {
+    claimReferralTicket: (poolCoinName: SupportCoins) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${referralIds.referralPgkId}::scallop_referral_program::claim_ve_sca_referral_ticket`,
         [
@@ -63,12 +63,9 @@ const generateReferralNormalMethod: GenerateReferralNormalMethod = ({
         [coinType]
       );
     },
-    burnReferralTicket: async (
-      ticket: SuiObjectArg,
-      poolCoinName: SupportCoins
-    ) => {
+    burnReferralTicket: (ticket: SuiObjectArg, poolCoinName: SupportCoins) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      await builder.moveCall(
+      builder.moveCall(
         txBlock,
         `${referralIds.referralPgkId}::scallop_referral_program::burn_ve_sca_referral_ticket`,
         [
@@ -80,12 +77,12 @@ const generateReferralNormalMethod: GenerateReferralNormalMethod = ({
         [coinType]
       );
     },
-    claimReferralRevenue: async (
+    claimReferralRevenue: (
       veScaKey: SuiObjectArg,
       poolCoinName: SupportCoins
     ) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${referralIds.referralPgkId}::referral_revenue_pool::claim_revenue_with_ve_sca_key`,
         [

package/src/builders/sCoinBuilder.ts

@@ -20,8 +20,8 @@ const generateSCoinNormalMethod: GenerateSCoinNormalMethod = ({
   };
 
   return {
-    mintSCoin: async (marketCoinName, marketCoin) => {
-      return await builder.moveCall(
+    mintSCoin: (marketCoinName, marketCoin) => {
+      return builder.moveCall(
         txBlock,
         `${sCoinPkgIds.pkgId}::s_coin_converter::mint_s_coin`,
         [builder.utils.getSCoinTreasury(marketCoinName), marketCoin],
@@ -31,8 +31,8 @@ const generateSCoinNormalMethod: GenerateSCoinNormalMethod = ({
         ]
       );
     },
-    burnSCoin: async (sCoinName, sCoin) => {
-      return await builder.moveCall(
+    burnSCoin: (sCoinName, sCoin) => {
+      return builder.moveCall(
         txBlock,
         `${sCoinPkgIds.pkgId}::s_coin_converter::burn_s_coin`,
         [builder.utils.getSCoinTreasury(sCoinName), sCoin],

package/src/builders/spoolBuilder.ts

@@ -100,10 +100,10 @@ const stakeHelper = async (
       ? await builder.selectSCoin(txBlock, coinName, amount, sender)
       : await builder.selectMarketCoin(txBlock, coinName, amount, sender);
     if (isSCoin) {
-      const marketCoin = await txBlock.burnSCoin(coinName, takeCoin);
-      await txBlock.stake(stakeAccount, marketCoin, coinName);
+      const marketCoin = txBlock.burnSCoin(coinName, takeCoin);
+      txBlock.stake(stakeAccount, marketCoin, coinName);
     } else {
-      await txBlock.stake(stakeAccount, takeCoin, coinName);
+      txBlock.stake(stakeAccount, takeCoin, coinName);
     }
     txBlock.transferObjects([leftCoin], sender);
     return totalAmount;
@@ -127,46 +127,46 @@ const generateSpoolNormalMethod: GenerateSpoolNormalMethod = ({
     spoolPkg: builder.address.get('spool.id'),
   };
   return {
-    createStakeAccount: async (stakeMarketCoinName) => {
+    createStakeAccount: (stakeMarketCoinName) => {
       const marketCoinType =
         builder.utils.parseMarketCoinType(stakeMarketCoinName);
       const stakePoolId = builder.address.get(
         `spool.pools.${stakeMarketCoinName}.id`
       );
-      return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${spoolIds.spoolPkg}::user::new_spool_account`,
         [stakePoolId, SUI_CLOCK_OBJECT_ID],
         [marketCoinType]
       );
     },
-    stake: async (stakeAccount, coin, stakeMarketCoinName) => {
+    stake: (stakeAccount, coin, stakeMarketCoinName) => {
       const marketCoinType =
         builder.utils.parseMarketCoinType(stakeMarketCoinName);
       const stakePoolId = builder.address.get(
         `spool.pools.${stakeMarketCoinName}.id`
       );
-      await builder.moveCall(
+      builder.moveCall(
         txBlock,
         `${spoolIds.spoolPkg}::user::stake`,
         [stakePoolId, stakeAccount, coin, SUI_CLOCK_OBJECT_ID],
         [marketCoinType]
       );
     },
-    unstake: async (stakeAccount, amount, stakeMarketCoinName) => {
+    unstake: (stakeAccount, amount, stakeMarketCoinName) => {
       const marketCoinType =
         builder.utils.parseMarketCoinType(stakeMarketCoinName);
       const stakePoolId = builder.address.get(
         `spool.pools.${stakeMarketCoinName}.id`
       );
-      return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${spoolIds.spoolPkg}::user::unstake`,
         [stakePoolId, stakeAccount, amount, SUI_CLOCK_OBJECT_ID],
         [marketCoinType]
       );
     },
-    claim: async (stakeAccount, stakeMarketCoinName) => {
+    claim: (stakeAccount, stakeMarketCoinName) => {
       const stakePoolId = builder.address.get(
         `spool.pools.${stakeMarketCoinName}.id`
       ) as string;
@@ -177,7 +177,7 @@ const generateSpoolNormalMethod: GenerateSpoolNormalMethod = ({
         builder.utils.parseMarketCoinType(stakeMarketCoinName);
       const rewardCoinName = spoolRewardCoins[stakeMarketCoinName];
       const rewardCoinType = builder.utils.parseCoinType(rewardCoinName);
-      return await builder.moveCall(
+      return builder.moveCall(
         txBlock,
         `${spoolIds.spoolPkg}::user::redeem_rewards`,
         [stakePoolId, rewardPoolId, stakeAccount, SUI_CLOCK_OBJECT_ID],