@scallop-io/sui-scallop-sdk 0.44.18 → 0.44.19

package/src/builders/borrowIncentiveBuilder.ts

@@ -13,14 +13,20 @@ import type {
   SuiTxBlockWithBorrowIncentiveNormalMethods,
   BorrowIncentiveTxBlock,
   ScallopTxBlock,
+  VescaIds,
 } from '../types';
+import { requireVeSca } from './vescaBuilder';
+import {
+  IS_VE_SCA_TEST,
+  OLD_BORROW_INCENTIVE_PROTOCOL_ID,
+} from 'src/constants';
 
 /**
  * Check and get Obligation information from transaction block.
  *
  * @description
- * If the obligation id is provided, direactly return it.
- * If both obligation id and key is provided, direactly return them.
+ * If the obligation id is provided, directly return it.
+ * If both obligation id and key is provided, directly return them.
  * Otherwise, automatically get obligation id and key from the sender.
  *
  * @param builder - Scallop builder instance.
@@ -62,6 +68,59 @@ const requireObligationInfo = async (
   };
 };
 
+/**
+ * Check veSca bind status
+ * @param query
+ * @param veScaKey
+ * @returns
+ */
+export const getBindedObligationId = async (
+  builder: ScallopBuilder,
+  veScaKey: string
+) => {
+  const borrowIncentivePkgId = builder.address.get('borrowIncentive.id');
+  const incentivePoolsId = builder.address.get(
+    'borrowIncentive.incentivePools'
+  );
+  const veScaPkgId = IS_VE_SCA_TEST
+    ? '0xb220d034bdf335d77ae5bfbf6daf059c2cc7a1f719b12bfed75d1736fac038c8'
+    : builder.address.get('vesca.id');
+
+  const client = builder.suiKit.client();
+
+  // get incentive pools
+  const incentivePoolsResponse = await client.getObject({
+    id: incentivePoolsId,
+    options: {
+      showContent: true,
+    },
+  });
+
+  if (incentivePoolsResponse.data?.content?.dataType !== 'moveObject')
+    return false;
+  const incentivePoolFields = incentivePoolsResponse.data.content.fields as any;
+  const veScaBindTableId = incentivePoolFields.ve_sca_bind.fields.id
+    .id as string;
+
+  // check if veSca is inside the bind table
+  const keyType = `${borrowIncentivePkgId}::typed_id::TypedID<${veScaPkgId}::ve_sca::VeScaKey>`;
+  const veScaBindTableResponse = await client.getDynamicFieldObject({
+    parentId: veScaBindTableId,
+    name: {
+      type: keyType,
+      value: veScaKey,
+    },
+  });
+
+  if (veScaBindTableResponse.data?.content?.dataType !== 'moveObject')
+    return false;
+  const veScaBindTableFields = veScaBindTableResponse.data.content
+    .fields as any;
+  // get obligationId pair
+  const obligationId = veScaBindTableFields.value.fields.id as string;
+
+  return obligationId;
+};
 /**
  * Generate borrow incentive normal methods.
  *
@@ -72,59 +131,89 @@ const requireObligationInfo = async (
 const generateBorrowIncentiveNormalMethod: GenerateBorrowIncentiveNormalMethod =
   ({ builder, txBlock }) => {
     const borrowIncentiveIds: BorrowIncentiveIds = {
-      borrowIncentivePkg: builder.address.get('borrowIncentive.id'),
+      borrowIncentivePkg: IS_VE_SCA_TEST
+        ? '0x4d5a7cefa4147b4ace0ca845b20437d6ac0d32e5f2f855171f745472c2576246'
+        : builder.address.get('borrowIncentive.id'),
       query: builder.address.get('borrowIncentive.query'),
+      config: builder.address.get('borrowIncentive.config'),
       incentivePools: builder.address.get('borrowIncentive.incentivePools'),
       incentiveAccounts: builder.address.get(
         'borrowIncentive.incentiveAccounts'
       ),
       obligationAccessStore: builder.address.get('core.obligationAccessStore'),
     };
+
+    const veScaIds: Omit<VescaIds, 'pkgId'> = {
+      table: builder.address.get('vesca.table'),
+      treasury: builder.address.get('vesca.treasury'),
+      config: builder.address.get('vesca.config'),
+    };
+
     return {
-      stakeObligation: (obligationId, obligaionKey) => {
-        // NOTE: Pools without incentives also need to stake after change obligation,
-        // the default here use sui as reward coin.
-        const rewardCoinName = 'sui';
-        const rewardType = builder.utils.parseCoinType(rewardCoinName);
+      stakeObligation: (obligationId, obligationKey) => {
         txBlock.moveCall(
           `${borrowIncentiveIds.borrowIncentivePkg}::user::stake`,
           [
+            borrowIncentiveIds.config,
+            borrowIncentiveIds.incentivePools,
+            borrowIncentiveIds.incentiveAccounts,
+            obligationKey,
+            obligationId,
+            borrowIncentiveIds.obligationAccessStore,
+            SUI_CLOCK_OBJECT_ID,
+          ]
+        );
+      },
+      stakeObligationWithVesca: (obligationId, obligationKey, veScaKey) => {
+        txBlock.moveCall(
+          `${borrowIncentiveIds.borrowIncentivePkg}::user::stake_with_ve_sca`,
+          [
+            borrowIncentiveIds.config,
             borrowIncentiveIds.incentivePools,
             borrowIncentiveIds.incentiveAccounts,
-            obligaionKey,
+            obligationKey,
             obligationId,
             borrowIncentiveIds.obligationAccessStore,
+            veScaIds.config,
+            veScaIds.treasury,
+            veScaIds.table,
+            veScaKey,
             SUI_CLOCK_OBJECT_ID,
           ],
-          [rewardType]
+          []
         );
       },
-      unstakeObligation: (obligationId, obligaionKey) => {
-        // NOTE: Pools without incentives also need to unstake to change obligation,
-        // the default here use sui as reward coin.
-        const rewardCoinName = 'sui';
-        const rewardType = builder.utils.parseCoinType(rewardCoinName);
+      unstakeObligation: (obligationId, obligationKey) => {
         txBlock.moveCall(
           `${borrowIncentiveIds.borrowIncentivePkg}::user::unstake`,
           [
+            borrowIncentiveIds.config,
             borrowIncentiveIds.incentivePools,
             borrowIncentiveIds.incentiveAccounts,
-            obligaionKey,
+            obligationKey,
             obligationId,
             SUI_CLOCK_OBJECT_ID,
-          ],
-          [rewardType]
+          ]
         );
       },
-      claimBorrowIncentive: (obligationId, obligaionKey, coinName) => {
-        const rewardCoinName = borrowIncentiveRewardCoins[coinName];
+      claimBorrowIncentive: (
+        obligationId,
+        obligationKey,
+        coinName,
+        rewardCoinName
+      ) => {
+        const rewardCoinNames = borrowIncentiveRewardCoins[coinName];
+        if (rewardCoinNames.includes(rewardCoinName) === false) {
+          throw new Error(`Invalid reward coin name ${rewardCoinName}`);
+        }
         const rewardType = builder.utils.parseCoinType(rewardCoinName);
         return txBlock.moveCall(
           `${borrowIncentiveIds.borrowIncentivePkg}::user::redeem_rewards`,
           [
+            borrowIncentiveIds.config,
             borrowIncentiveIds.incentivePools,
             borrowIncentiveIds.incentiveAccounts,
-            obligaionKey,
+            obligationKey,
             obligationId,
             SUI_CLOCK_OBJECT_ID,
           ],
@@ -144,7 +233,7 @@ const generateBorrowIncentiveNormalMethod: GenerateBorrowIncentiveNormalMethod =
  *
  * @param builder - Scallop builder instance.
  * @param txBlock - TxBlock created by SuiKit .
- * @return Spool quick methods.
+ * @return Borrow Incentive quick methods.
  */
 const generateBorrowIncentiveQuickMethod: GenerateBorrowIncentiveQuickMethod =
   ({ builder, txBlock }) => {
@@ -165,14 +254,72 @@ const generateBorrowIncentiveQuickMethod: GenerateBorrowIncentiveQuickMethod =
           !!txBlock.txBlock.blockData.transactions.find(
             (txn) =>
               txn.kind === 'MoveCall' &&
-              txn.target ===
-                `${builder.address.get('borrowIncentive.id')}::user::unstake`
+              (txn.target ===
+                `${OLD_BORROW_INCENTIVE_PROTOCOL_ID}::user::unstake` ||
+                txn.target ===
+                  (IS_VE_SCA_TEST
+                    ? `${'0x4d5a7cefa4147b4ace0ca845b20437d6ac0d32e5f2f855171f745472c2576246'}::user::unstake`
+                    : `${builder.address.get(
+                        'borrowIncentive.id'
+                      )}::user::unstake`))
           );
 
         if (!obligationLocked || unstakeObligationBeforeStake) {
           txBlock.stakeObligation(obligationArg, obligationtKeyArg);
         }
       },
+      stakeObligationWithVeScaQuick: async (
+        obligation,
+        obligationKey,
+        veScaKey
+      ) => {
+        const {
+          obligationId: obligationArg,
+          obligationKey: obligationtKeyArg,
+          obligationLocked: obligationLocked,
+        } = await requireObligationInfo(
+          builder,
+          txBlock,
+          obligation,
+          obligationKey
+        );
+
+        const unstakeObligationBeforeStake =
+          !!txBlock.txBlock.blockData.transactions.find(
+            (txn) =>
+              txn.kind === 'MoveCall' &&
+              (txn.target ===
+                `${OLD_BORROW_INCENTIVE_PROTOCOL_ID}::user::unstake` ||
+                txn.target ===
+                  (IS_VE_SCA_TEST
+                    ? `${'0x4d5a7cefa4147b4ace0ca845b20437d6ac0d32e5f2f855171f745472c2576246'}::user::unstake`
+                    : `${builder.address.get(
+                        'borrowIncentive.id'
+                      )}::user::unstake`))
+          );
+
+        if (!obligationLocked || unstakeObligationBeforeStake) {
+          const veSca = await requireVeSca(builder, txBlock, veScaKey);
+          if (veSca) {
+            const bindedObligationId = await getBindedObligationId(
+              builder,
+              veSca.keyId
+            );
+            // if bindedObligationId is equal to obligationId, then use it again
+            if (!bindedObligationId || bindedObligationId === obligationArg) {
+              txBlock.stakeObligationWithVesca(
+                obligationArg,
+                obligationtKeyArg,
+                veSca.keyId
+              );
+            } else {
+              txBlock.stakeObligation(obligationArg, obligationtKeyArg);
+            }
+          } else {
+            txBlock.stakeObligation(obligationArg, obligationtKeyArg);
+          }
+        }
+      },
       unstakeObligationQuick: async (obligation, obligationKey) => {
         const {
           obligationId: obligationArg,
@@ -191,6 +338,7 @@ const generateBorrowIncentiveQuickMethod: GenerateBorrowIncentiveQuickMethod =
       },
       claimBorrowIncentiveQuick: async (
         coinName,
+        rewardCoinName,
         obligation,
         obligationKey
       ) => {
@@ -207,7 +355,8 @@ const generateBorrowIncentiveQuickMethod: GenerateBorrowIncentiveQuickMethod =
         return txBlock.claimBorrowIncentive(
           obligationArg,
           obligationtKeyArg,
-          coinName
+          coinName,
+          rewardCoinName
         );
       },
     };

package/src/builders/index.ts

@@ -3,6 +3,7 @@ import { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
 import { newCoreTxBlock } from './coreBuilder';
 import { newSpoolTxBlock } from './spoolBuilder';
 import { newBorrowIncentiveTxBlock } from './borrowIncentiveBuilder';
+import { newVeScaTxBlock } from './vescaBuilder';
 import type { ScallopBuilder } from '../models';
 import type { ScallopTxBlock } from '../types';
 
@@ -17,16 +18,19 @@ export const newScallopTxBlock = (
   builder: ScallopBuilder,
   initTxBlock?: ScallopTxBlock | SuiKitTxBlock | TransactionBlock
 ): ScallopTxBlock => {
+  const vescaTxBlock = newVeScaTxBlock(builder, initTxBlock);
   const borrowIncentiveTxBlock = newBorrowIncentiveTxBlock(
     builder,
-    initTxBlock
+    vescaTxBlock
   );
   const spoolTxBlock = newSpoolTxBlock(builder, borrowIncentiveTxBlock);
   const coreTxBlock = newCoreTxBlock(builder, spoolTxBlock);
 
   return new Proxy(coreTxBlock, {
     get: (target, prop) => {
-      if (prop in borrowIncentiveTxBlock) {
+      if (prop in vescaTxBlock) {
+        return Reflect.get(vescaTxBlock, prop);
+      } else if (prop in borrowIncentiveTxBlock) {
         return Reflect.get(borrowIncentiveTxBlock, prop);
       } else if (prop in spoolTxBlock) {
         return Reflect.get(spoolTxBlock, prop);

package/src/builders/vescaBuilder.ts

@@ -0,0 +1,392 @@
+import {
+  SUI_CLOCK_OBJECT_ID,
+  SuiAddressArg,
+  SuiTxBlock,
+  TransactionBlock,
+  SuiTxBlock as SuiKitTxBlock,
+} from '@scallop-io/sui-kit';
+import { SCA_COIN_TYPE } from 'src/constants';
+import { ScallopBuilder } from '../models';
+import { getVeSca, getVeScas } from '../queries';
+import {
+  requireSender,
+  checkLockSca,
+  checkExtendLockPeriod,
+  checkExtendLockAmount,
+  checkRenewExpiredVeSca,
+  checkVesca,
+} from '../utils';
+import type {
+  TransactionObjectArgument,
+  SuiObjectArg,
+} from '@scallop-io/sui-kit';
+import type {
+  GenerateVeScaNormalMethod,
+  GenerateVeScaQuickMethod,
+  ScallopTxBlock,
+  SuiTxBlockWithVeScaNormalMethods,
+  VeScaTxBlock,
+  VescaIds,
+} from 'src/types';
+
+/**
+ * Check and get veSCA data from transaction block.
+ *
+ * @description
+ * If the veScaKey id is provided, directly return it.
+ * Otherwise, automatically get veScaKey from the sender.
+ *
+ * @param builder - Scallop builder instance.
+ * @param txBlock - TxBlock created by SuiKit.
+ * @param veScaKey - veSCA key.
+ * @return veSCA key, ID, locked amount and unlock at timestamp.
+ */
+
+export const requireVeSca = async (
+  ...params: [
+    builder: ScallopBuilder,
+    SuiTxBlock: SuiTxBlock,
+    veScaKey?: SuiAddressArg,
+  ]
+) => {
+  const [builder, txBlock, veScaKey] = params;
+  if (params.length === 3 && veScaKey && typeof veScaKey === 'string') {
+    const veSca = await getVeSca(builder.query, veScaKey);
+
+    if (!veSca) {
+      return undefined;
+    }
+
+    return veSca;
+  }
+
+  const sender = requireSender(txBlock);
+  const veScas = await getVeScas(builder.query, sender);
+  if (veScas.length === 0) {
+    return undefined;
+  }
+
+  return veScas[0];
+};
+
+/**
+ * Generate veSCA normal methods.
+ *
+ * @param builder - Scallop builder instance.
+ * @param txBlock - TxBlock created by SuiKit .
+ * @return veSCA normal methods.
+ */
+const generateNormalVeScaMethod: GenerateVeScaNormalMethod = ({
+  builder,
+  txBlock,
+}) => {
+  const veScaIds: VescaIds = {
+    pkgId: builder.address.get('vesca.id'),
+    table: builder.address.get('vesca.table'),
+    treasury: builder.address.get('vesca.treasury'),
+    config: builder.address.get('vesca.config'),
+  };
+
+  return {
+    lockSca: (scaCoin, unlockAtInSecondTimestamp) => {
+      return txBlock.moveCall(
+        `${veScaIds.pkgId}::ve_sca::mint_ve_sca_key`,
+        [
+          veScaIds.config,
+          veScaIds.table,
+          veScaIds.treasury,
+          scaCoin,
+          unlockAtInSecondTimestamp,
+          SUI_CLOCK_OBJECT_ID,
+        ],
+        []
+      );
+    },
+    extendLockPeriod: (veScaKey, newUnlockAtInSecondTimestamp) => {
+      txBlock.moveCall(
+        `${veScaIds.pkgId}::ve_sca::extend_lock_period`,
+        [
+          veScaIds.config,
+          veScaKey,
+          veScaIds.table,
+          veScaIds.treasury,
+          newUnlockAtInSecondTimestamp,
+          SUI_CLOCK_OBJECT_ID,
+        ],
+        []
+      );
+    },
+    extendLockAmount: (veScaKey, scaCoin) => {
+      txBlock.moveCall(
+        `${veScaIds.pkgId}::ve_sca::lock_more_sca`,
+        [
+          veScaIds.config,
+          veScaKey,
+          veScaIds.table,
+          veScaIds.treasury,
+          scaCoin,
+          SUI_CLOCK_OBJECT_ID,
+        ],
+        []
+      );
+    },
+    renewExpiredVeSca: (veScaKey, scaCoin, newUnlockAtInSecondTimestamp) => {
+      txBlock.moveCall(
+        `${veScaIds.pkgId}::ve_sca::renew_expired_ve_sca`,
+        [
+          veScaIds.config,
+          veScaKey,
+          veScaIds.table,
+          veScaIds.treasury,
+          scaCoin,
+          newUnlockAtInSecondTimestamp,
+          SUI_CLOCK_OBJECT_ID,
+        ],
+        []
+      );
+    },
+    redeemSca: (veScaKey) => {
+      return txBlock.moveCall(
+        `${veScaIds.pkgId}::ve_sca::redeem`,
+        [
+          veScaIds.config,
+          veScaKey,
+          veScaIds.table,
+          veScaIds.treasury,
+          SUI_CLOCK_OBJECT_ID,
+        ],
+        []
+      );
+    },
+  };
+};
+
+/**
+ * Generate veSCA quick methods.
+ *
+ * @description
+ * The quick methods are the same as the normal methods, but they will automatically
+ * help users organize transaction blocks, include get veSca info, and transfer
+ * coins to the sender. So, they are all asynchronous methods.
+ *
+ * @param builder - Scallop builder instance.
+ * @param txBlock - TxBlock created by SuiKit .
+ * @return veSCA quick methods.
+ */
+const generateQuickVeScaMethod: GenerateVeScaQuickMethod = ({
+  builder,
+  txBlock,
+}) => {
+  return {
+    lockScaQuick: async (amountOrCoin, lockPeriodInDays, autoCheck = true) => {
+      const sender = requireSender(txBlock);
+      const veSca = await requireVeSca(builder, txBlock);
+
+      let scaCoin: TransactionObjectArgument | SuiObjectArg | undefined =
+        undefined;
+      const transferObjects = [];
+      if (amountOrCoin !== undefined && typeof amountOrCoin === 'number') {
+        const coins = await builder.utils.selectCoinIds(
+          amountOrCoin,
+          SCA_COIN_TYPE,
+          sender
+        );
+        const [takeCoin, leftCoin] = txBlock.takeAmountFromCoins(
+          coins,
+          amountOrCoin
+        );
+        scaCoin = takeCoin;
+        transferObjects.push(leftCoin);
+      } else {
+        // With amountOrCoin is SuiObjectArg, we cannot validate the minimum sca amount for locking and topup
+        scaCoin = amountOrCoin;
+      }
+
+      const newUnlockAt = builder.utils.getUnlockAt(
+        lockPeriodInDays,
+        veSca?.unlockAt
+      );
+      if (autoCheck)
+        checkLockSca(
+          amountOrCoin,
+          lockPeriodInDays,
+          newUnlockAt,
+          veSca?.unlockAt
+        );
+      console.log(
+        new Date(newUnlockAt * 1000).toLocaleString('en-CA', {
+          hour12: true,
+        })
+      );
+
+      const isInitialLock = !veSca?.unlockAt;
+      const isLockExpired =
+        !isInitialLock && veSca.unlockAt * 1000 <= new Date().getTime();
+      if (isInitialLock || isLockExpired) {
+        if (scaCoin) {
+          if (isInitialLock) {
+            const veScaKey = txBlock.lockSca(scaCoin, newUnlockAt);
+            transferObjects.push(veScaKey);
+          } else {
+            // user must withdraw current unlocked SCA first if any
+            if (veSca.lockedScaAmount !== 0) {
+              const unlockedSca = txBlock.redeemSca(veSca.keyId);
+              transferObjects.push(unlockedSca);
+            }
+            // enforce renew on expired
+            txBlock.renewExpiredVeSca(veSca.keyId, scaCoin, newUnlockAt);
+          }
+        }
+      } else {
+        if (!!scaCoin && !!lockPeriodInDays) {
+          txBlock.extendLockPeriod(veSca.keyId, newUnlockAt);
+          txBlock.extendLockAmount(veSca.keyId, scaCoin);
+        } else if (lockPeriodInDays) {
+          txBlock.extendLockPeriod(veSca.keyId, newUnlockAt);
+        } else if (scaCoin) {
+          txBlock.extendLockAmount(veSca.keyId, scaCoin);
+        }
+      }
+
+      if (transferObjects.length > 0) {
+        txBlock.transferObjects(transferObjects, sender);
+      }
+    },
+    extendLockPeriodQuick: async (
+      lockPeriodInDays: number,
+      veScaKey?: SuiAddressArg,
+      autoCheck = true
+    ) => {
+      const veSca = await requireVeSca(builder, txBlock, veScaKey);
+
+      const newUnlockAt = builder.utils.getUnlockAt(lockPeriodInDays);
+      if (autoCheck)
+        checkExtendLockPeriod(lockPeriodInDays, newUnlockAt, veSca?.unlockAt);
+
+      if (veSca) {
+        txBlock.extendLockPeriod(veSca.keyId, newUnlockAt);
+      }
+    },
+    extendLockAmountQuick: async (
+      scaAmount: number,
+      veScaKey?: SuiAddressArg,
+      autoCheck = true
+    ) => {
+      const sender = requireSender(txBlock);
+      const veSca = await requireVeSca(builder, txBlock, veScaKey);
+
+      if (autoCheck) checkExtendLockAmount(scaAmount, veSca?.unlockAt);
+
+      if (veSca) {
+        const scaCoins = await builder.utils.selectCoinIds(
+          scaAmount,
+          SCA_COIN_TYPE,
+          sender
+        );
+        const [takeCoin, leftCoin] = txBlock.takeAmountFromCoins(
+          scaCoins,
+          scaAmount
+        );
+
+        txBlock.extendLockAmount(veSca.keyId, takeCoin);
+        txBlock.transferObjects([leftCoin], sender);
+      }
+    },
+    renewExpiredVeScaQuick: async (
+      scaAmount: number,
+      lockPeriodInDays: number,
+      veScaKey?: SuiAddressArg,
+      autoCheck = true
+    ) => {
+      const sender = requireSender(txBlock);
+      const veSca = await requireVeSca(builder, txBlock, veScaKey);
+
+      const newUnlockAt = builder.utils.getUnlockAt(
+        lockPeriodInDays,
+        veSca?.unlockAt
+      );
+      if (autoCheck)
+        checkRenewExpiredVeSca(scaAmount, lockPeriodInDays, veSca?.unlockAt);
+
+      if (veSca) {
+        const transferObjects = [];
+        if (veSca.lockedScaAmount !== 0) {
+          const unlockedSca = txBlock.redeemSca(veSca.keyId);
+          transferObjects.push(unlockedSca);
+        }
+        const scaCoins = await builder.utils.selectCoinIds(
+          scaAmount,
+          SCA_COIN_TYPE,
+          sender
+        );
+        const [takeCoin, leftCoin] = txBlock.takeAmountFromCoins(
+          scaCoins,
+          scaAmount
+        );
+        transferObjects.push(leftCoin);
+
+        txBlock.renewExpiredVeSca(veSca.keyId, takeCoin, newUnlockAt);
+        txBlock.transferObjects(transferObjects, sender);
+      }
+    },
+    redeemScaQuick: async (veScaKey?: SuiAddressArg) => {
+      const sender = requireSender(txBlock);
+      const veSca = await requireVeSca(builder, txBlock, veScaKey);
+
+      checkVesca(veSca?.unlockAt);
+
+      if (veSca) {
+        const sca = txBlock.redeemSca(veSca.keyId);
+        txBlock.transferObjects([sca], sender);
+      }
+    },
+  };
+};
+
+/**
+ * Create an enhanced transaction block instance for interaction with veSCA modules of the Scallop contract.
+ *
+ * @param builder - Scallop builder instance.
+ * @param initTxBlock - Scallop txBlock, txBlock created by SuiKit, or original transaction block.
+ * @return Scallop borrow incentive txBlock.
+ */
+export const newVeScaTxBlock = (
+  builder: ScallopBuilder,
+  initTxBlock?: ScallopTxBlock | SuiKitTxBlock | TransactionBlock
+) => {
+  const txBlock =
+    initTxBlock instanceof TransactionBlock
+      ? new SuiKitTxBlock(initTxBlock)
+      : initTxBlock
+      ? initTxBlock
+      : new SuiKitTxBlock();
+
+  const normalMethod = generateNormalVeScaMethod({
+    builder,
+    txBlock,
+  });
+
+  const normalTxBlock = new Proxy(txBlock, {
+    get: (target, prop) => {
+      if (prop in normalMethod) {
+        return Reflect.get(normalMethod, prop);
+      }
+      return Reflect.get(target, prop);
+    },
+  }) as SuiTxBlockWithVeScaNormalMethods;
+
+  // TODO: Add quickMethod for veSCA
+  const quickMethod = generateQuickVeScaMethod({
+    builder,
+    txBlock: normalTxBlock,
+  });
+
+  return new Proxy(normalTxBlock, {
+    get: (target, prop) => {
+      if (prop in quickMethod) {
+        return Reflect.get(quickMethod, prop);
+      }
+      return Reflect.get(target, prop);
+    },
+  }) as VeScaTxBlock;
+};