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

package/src/queries/portfolioQuery.ts

@@ -1,10 +1,13 @@
 import BigNumber from 'bignumber.js';
-import { SUPPORT_POOLS, SUPPORT_SPOOLS } from '../constants';
+import {
+  SUPPORT_BORROW_INCENTIVE_REWARDS,
+  SUPPORT_POOLS,
+  SUPPORT_SPOOLS,
+} from '../constants';
 import { minBigNumber, estimatedFactor } from 'src/utils';
 import type { ScallopQuery } from '../models';
 import type {
   Market,
-  SupportAssetCoins,
   SupportPoolCoins,
   MarketPool,
   Spool,
@@ -20,6 +23,7 @@ import type {
   SupportMarketCoins,
   TotalValueLocked,
   SupportBorrowIncentiveCoins,
+  ObligationBorrowIcentiveReward,
 } from '../types';
 
 /**
@@ -309,9 +313,8 @@ export const getObligationAccount = async (
   coinAmounts?: CoinAmounts
 ) => {
   market = market || (await query.queryMarket(indexer));
-  const assetCoinNames: SupportAssetCoins[] = [
+  const collateralAssetCoinNames: SupportCollateralCoins[] = [
     ...new Set([
-      ...Object.values(market.pools).map((pool) => pool.coinName),
       ...Object.values(market.collaterals).map(
         (collateral) => collateral.coinName
       ),
@@ -324,9 +327,11 @@ export const getObligationAccount = async (
   );
   const borrowIncentiveAccounts =
     await query.getBorrowIncentiveAccounts(obligationId);
-  coinPrices = coinPrices || (await query.utils.getCoinPrices(assetCoinNames));
+  coinPrices =
+    coinPrices || (await query.utils.getCoinPrices(collateralAssetCoinNames));
   coinAmounts =
-    coinAmounts || (await query.getCoinAmounts(assetCoinNames, ownerAddress));
+    coinAmounts ||
+    (await query.getCoinAmounts(collateralAssetCoinNames, ownerAddress));
 
   const collaterals: ObligationAccount['collaterals'] = {};
   const debts: ObligationAccount['debts'] = {};
@@ -339,7 +344,7 @@ export const getObligationAccount = async (
   let totalBorrowedValue = BigNumber(0);
   let totalBorrowedValueWithWeight = BigNumber(0);
 
-  for (const assetCoinName of assetCoinNames) {
+  for (const assetCoinName of collateralAssetCoinNames) {
     const collateral = obligationQuery.collaterals.find((collateral) => {
       const collateralCoinName =
         query.utils.parseCoinNameFromType<SupportCollateralCoins>(
@@ -405,7 +410,11 @@ export const getObligationAccount = async (
     }
   }
 
-  for (const assetCoinName of assetCoinNames) {
+  const borrowAssetCoinNames: SupportPoolCoins[] = [
+    ...new Set([...Object.values(market.pools).map((pool) => pool.coinName)]),
+  ];
+
+  for (const assetCoinName of borrowAssetCoinNames) {
     const debt = obligationQuery.debts.find((debt) => {
       const poolCoinName = query.utils.parseCoinNameFromType<SupportPoolCoins>(
         debt.type.name
@@ -476,41 +485,70 @@ export const getObligationAccount = async (
     const coinName = poolCoinName as SupportBorrowIncentiveCoins;
     const borrowIncentivePool = borrowIncentivePools[coinName];
 
-    let availableClaimAmount = BigNumber(0);
-    let availableClaimCoin = BigNumber(0);
     if (borrowIncentivePool) {
-      const accountBorrowedAmount = BigNumber(borrowIncentiveAccount.amount);
-      const baseIndexRate = 1_000_000_000;
-      const increasedPointRate = borrowIncentivePool.currentPointIndex
-        ? BigNumber(
-            borrowIncentivePool.currentPointIndex - borrowIncentiveAccount.index
-          ).dividedBy(baseIndexRate)
-        : 1;
-      availableClaimAmount = availableClaimAmount.plus(
-        accountBorrowedAmount
-          .multipliedBy(increasedPointRate)
-          .plus(borrowIncentiveAccount.points)
-          .multipliedBy(borrowIncentivePool.exchangeRateNumerator)
-          .dividedBy(borrowIncentivePool.exchangeRateDenominator)
-      );
-      availableClaimCoin = availableClaimAmount.shiftedBy(
-        -1 * borrowIncentivePool.rewardCoinDecimal
-      );
-
-      if (availableClaimAmount.isGreaterThan(0)) {
-        borrowIncentives[coinName] = {
-          coinName: borrowIncentivePool.coinName,
-          coinType: borrowIncentivePool.coinType,
-          rewardCoinType: borrowIncentivePool.rewardCoinType,
-          symbol: borrowIncentivePool.symbol,
-          coinDecimal: borrowIncentivePool.coinDecimal,
-          rewardCoinDecimal: borrowIncentivePool.rewardCoinDecimal,
-          coinPrice: borrowIncentivePool.coinPrice,
-          rewardCoinPrice: borrowIncentivePool.rewardCoinPrice,
-          availableClaimAmount: availableClaimAmount.toNumber(),
-          availableClaimCoin: availableClaimCoin.toNumber(),
-        };
+      const rewards: ObligationBorrowIcentiveReward[] = [];
+      for (const rewardCoinName of SUPPORT_BORROW_INCENTIVE_REWARDS) {
+        const accountPoint = borrowIncentiveAccount.pointList[rewardCoinName];
+        const poolPoint = borrowIncentivePool.points[rewardCoinName];
+
+        if (accountPoint && poolPoint) {
+          let availableClaimAmount = BigNumber(0);
+          let availableClaimCoin = BigNumber(0);
+          const accountBorrowedAmount = BigNumber(accountPoint.weightedAmount);
+          const baseIndexRate = 1_000_000_000;
+          const increasedPointRate = poolPoint.currentPointIndex
+            ? BigNumber(
+                poolPoint.currentPointIndex - accountPoint.index
+              ).dividedBy(baseIndexRate)
+            : 1;
+          availableClaimAmount = availableClaimAmount.plus(
+            accountBorrowedAmount
+              .multipliedBy(increasedPointRate)
+              .plus(accountPoint.points)
+          );
+          availableClaimCoin = availableClaimAmount.shiftedBy(
+            -1 * poolPoint.coinDecimal
+          );
+
+          // for veSCA
+          // console.log('poolPoint.weightedAmount', poolPoint.weightedAmount);
+          // console.log(
+          //   'borrowIncentiveAccount.amount',
+          //   borrowIncentiveAccount.debtAmount
+          // );
+          const weightScale = BigNumber('1000000000000');
+
+          const boostValue = BigNumber(accountPoint.weightedAmount)
+            .div(
+              BigNumber(borrowIncentiveAccount.debtAmount)
+                .multipliedBy(poolPoint.baseWeight)
+                .dividedBy(weightScale)
+            )
+            .toNumber();
+
+          if (availableClaimAmount.isGreaterThan(0)) {
+            rewards.push({
+              coinName: poolPoint.coinName,
+              coinType: poolPoint.coinType,
+              symbol: poolPoint.symbol,
+              coinDecimal: poolPoint.coinDecimal,
+              coinPrice: poolPoint.coinPrice,
+              availableClaimAmount: availableClaimAmount.toNumber(),
+              availableClaimCoin: availableClaimCoin.toNumber(),
+              boostValue,
+            });
+          }
+        }
       }
+
+      borrowIncentives[coinName] = {
+        coinName: borrowIncentivePool.coinName,
+        coinType: borrowIncentivePool.coinType,
+        symbol: borrowIncentivePool.symbol,
+        coinDecimal: borrowIncentivePool.coinDecimal,
+        coinPrice: borrowIncentivePool.coinPrice,
+        rewards,
+      };
     }
   }
 

package/src/queries/spoolQuery.ts

@@ -243,7 +243,7 @@ export const getStakeAccounts = async (
   const stakeAccountType = `${spoolObjectId}::spool_account::SpoolAccount`;
   const stakeObjectsResponse: SuiObjectResponse[] = [];
   let hasNextPage = false;
-  let nextCursor: string | null = null;
+  let nextCursor: string | null | undefined = null;
   do {
     const paginatedStakeObjectsResponse = await query.suiKit
       .client()

package/src/queries/vescaQuery.ts

@@ -0,0 +1,124 @@
+import BigNumber from 'bignumber.js';
+import { Vesca } from '../types';
+import type { SuiObjectResponse, SuiObjectData } from '@mysten/sui.js/client';
+import type { ScallopQuery } from '../models';
+import { IS_VE_SCA_TEST } from 'src/constants';
+/**
+ * Query all owned veSca key.
+ *
+ * @param query - The Scallop query instance.
+ * @param ownerAddress - The owner address.
+ * @return Owned veSca key.
+ */
+export const getVescaKeys = async (
+  query: ScallopQuery,
+  ownerAddress?: string
+) => {
+  const owner = ownerAddress || query.suiKit.currentAddress();
+  const veScaPkgId = IS_VE_SCA_TEST
+    ? '0xb220d034bdf335d77ae5bfbf6daf059c2cc7a1f719b12bfed75d1736fac038c8'
+    : query.address.get('vesca.id');
+  const veScaKeyType = `${veScaPkgId}::ve_sca::VeScaKey`;
+  const keyObjectsResponse: SuiObjectResponse[] = [];
+  let hasNextPage = false;
+  let nextCursor: string | null | undefined = null;
+  do {
+    const paginatedKeyObjectsResponse = await query.suiKit
+      .client()
+      .getOwnedObjects({
+        owner,
+        filter: {
+          StructType: veScaKeyType,
+        },
+        cursor: nextCursor,
+      });
+    keyObjectsResponse.push(...paginatedKeyObjectsResponse.data);
+    if (
+      paginatedKeyObjectsResponse.hasNextPage &&
+      paginatedKeyObjectsResponse.nextCursor
+    ) {
+      hasNextPage = true;
+      nextCursor = paginatedKeyObjectsResponse.nextCursor;
+    } else {
+      hasNextPage = false;
+    }
+  } while (hasNextPage);
+
+  const keyObjectDatas = keyObjectsResponse
+    .map((objResponse) => objResponse.data)
+    .filter((data) => !!data) as SuiObjectData[];
+  return keyObjectDatas;
+};
+
+/**
+ * Query all owned veSca.
+ *
+ * @param query - The Scallop query instance.
+ * @param ownerAddress - The owner address.
+ * @return Owned veScas.
+ */
+export const getVeScas = async (query: ScallopQuery, ownerAddress?: string) => {
+  const keyObjectDatas = await getVescaKeys(query, ownerAddress);
+  const keyObjectId: string[] = keyObjectDatas.map((data) => data.objectId);
+
+  const veScas: Vesca[] = [];
+  for (const keyId of keyObjectId) {
+    const veSca = await getVeSca(query, keyId);
+    if (veSca) veScas.push(veSca);
+  }
+
+  return veScas;
+};
+
+/**
+ * Get veSca data.
+ *
+ * @param query - The Scallop query instance.
+ * @param veScaKeyId - The vesca key id.
+ * @param ownerAddress - The owner address.
+ * @returns Vesca data.
+ */
+export const getVeSca = async (
+  query: ScallopQuery,
+  veScaKeyId?: string,
+  ownerAddress?: string
+) => {
+  const tableId = IS_VE_SCA_TEST
+    ? '0xc607241e4a679fe376d1170b2fbe07b64917bfe69100d4825241cda20039d4bd'
+    : query.address.get(`vesca.tableId`);
+  veScaKeyId =
+    veScaKeyId || (await getVescaKeys(query, ownerAddress))[0].objectId;
+
+  let vesca: Vesca | undefined = undefined;
+
+  const veScaDynamicFieldObjectResponse = await query.suiKit
+    .client()
+    .getDynamicFieldObject({
+      parentId: tableId,
+      name: {
+        type: '0x2::object::ID',
+        value: veScaKeyId,
+      },
+    });
+  const veScaDynamicFieldObject = veScaDynamicFieldObjectResponse.data;
+  if (
+    veScaDynamicFieldObject &&
+    veScaDynamicFieldObject.content &&
+    veScaDynamicFieldObject.content.dataType === 'moveObject' &&
+    'fields' in veScaDynamicFieldObject.content
+  ) {
+    const dynamicFields = (veScaDynamicFieldObject.content.fields as any).value
+      .fields;
+    vesca = {
+      id: veScaDynamicFieldObject.objectId,
+      keyId: veScaKeyId,
+      lockedScaAmount: BigNumber(dynamicFields.locked_sca_amount).toNumber(),
+      lockedScaCoin: BigNumber(dynamicFields.locked_sca_amount)
+        .shiftedBy(-9)
+        .toNumber(),
+      unlockAt: BigNumber(dynamicFields.unlock_at).toNumber(),
+    } as Vesca;
+  }
+
+  return vesca;
+};

package/src/types/address.ts

@@ -88,9 +88,18 @@ export interface AddressesInterface {
     adminCap: string;
     object: string;
     query: string;
+    config: string;
     incentivePools: string;
     incentiveAccounts: string;
   };
+  vesca: {
+    id: string;
+    adminCap: string;
+    tableId: string;
+    table: string;
+    treasury: string;
+    config: string;
+  };
 }
 
 type AddressPathsProps<T> = T extends string

package/src/types/builder/borrowIncentive.ts

@@ -1,14 +1,19 @@
 import type {
   SuiTxBlock as SuiKitTxBlock,
   SuiAddressArg,
+  SuiTxArg,
 } from '@scallop-io/sui-kit';
 import type { TransactionResult } from '@mysten/sui.js/transactions';
 import type { ScallopBuilder } from '../../models';
-import type { SupportBorrowIncentiveCoins } from '../constant';
+import type {
+  SupportBorrowIncentiveCoins,
+  SupportBorrowIncentiveRewardCoins,
+} from '../constant';
 
 export type BorrowIncentiveIds = {
   borrowIncentivePkg: string;
   query: string;
+  config: string;
   incentivePools: string;
   incentiveAccounts: string;
   obligationAccessStore: string;
@@ -17,16 +22,22 @@ export type BorrowIncentiveIds = {
 export type BorrowIncentiveNormalMethods = {
   stakeObligation: (
     obligation: SuiAddressArg,
-    obligaionKey: SuiAddressArg
+    obligationKey: SuiAddressArg
+  ) => void;
+  stakeObligationWithVesca: (
+    obligation: SuiAddressArg,
+    obligationKey: SuiAddressArg,
+    veScaKey: SuiTxArg
   ) => void;
   unstakeObligation: (
     obligation: SuiAddressArg,
-    obligaionKey: SuiAddressArg
+    obligationKey: SuiAddressArg
   ) => void;
   claimBorrowIncentive: (
     obligation: SuiAddressArg,
-    obligaionKey: SuiAddressArg,
-    coinName: SupportBorrowIncentiveCoins
+    obligationKey: SuiAddressArg,
+    coinName: SupportBorrowIncentiveCoins,
+    rewardType: SupportBorrowIncentiveRewardCoins
   ) => TransactionResult;
 };
 
@@ -35,12 +46,18 @@ export type BorrowIncentiveQuickMethods = {
     obligation?: SuiAddressArg,
     obligationKey?: SuiAddressArg
   ): Promise<void>;
+  stakeObligationWithVeScaQuick(
+    obligation?: SuiAddressArg,
+    obligationKey?: SuiAddressArg,
+    veScaKey?: SuiAddressArg
+  ): Promise<void>;
   unstakeObligationQuick(
     obligation?: SuiAddressArg,
     obligationKey?: SuiAddressArg
   ): Promise<void>;
   claimBorrowIncentiveQuick(
     coinName: SupportBorrowIncentiveCoins,
+    rewardType: SupportBorrowIncentiveRewardCoins,
     obligation?: SuiAddressArg,
     obligationKey?: SuiAddressArg
   ): Promise<TransactionResult>;

package/src/types/builder/index.ts

@@ -1,11 +1,14 @@
 import type { CoreTxBlock } from './core';
 import type { SpoolTxBlock } from './spool';
 import type { BorrowIncentiveTxBlock } from './borrowIncentive';
+import type { VeScaTxBlock } from './vesca';
 
 export type * from './core';
 export type * from './spool';
 export type * from './borrowIncentive';
+export type * from './vesca';
 
 export type ScallopTxBlock = CoreTxBlock &
   SpoolTxBlock &
-  BorrowIncentiveTxBlock;
+  BorrowIncentiveTxBlock &
+  VeScaTxBlock;

package/src/types/builder/vesca.ts

@@ -0,0 +1,73 @@
+import {
+  SuiTxBlock as SuiKitTxBlock,
+  SuiAddressArg,
+  SuiObjectArg,
+  SuiTxArg,
+} from '@scallop-io/sui-kit';
+import type { TransactionResult } from '@mysten/sui.js/transactions';
+import { ScallopBuilder } from 'src/models';
+
+export type VescaIds = {
+  pkgId: string;
+  table: string;
+  treasury: string;
+  config: string;
+};
+
+export type VeScaNormalMethods = {
+  lockSca: (
+    scaCoin: SuiObjectArg,
+    unlockAtInSecondTimestamp: SuiTxArg
+  ) => TransactionResult;
+  extendLockPeriod: (
+    veScaKey: SuiAddressArg,
+    newUnlockAtInSecondTimestamp: SuiTxArg
+  ) => void;
+  extendLockAmount: (veScaKey: SuiAddressArg, scaCoin: SuiObjectArg) => void;
+  renewExpiredVeSca: (
+    veScaKey: SuiAddressArg,
+    scaCoin: SuiObjectArg,
+    newUnlockAtInSecondTimestamp: SuiTxArg
+  ) => void;
+  redeemSca: (veScaKey: SuiAddressArg) => TransactionResult;
+};
+
+export type VeScaQuickMethods = {
+  lockScaQuick(
+    amountOrCoin?: SuiObjectArg | number,
+    lockPeriodInDays?: number,
+    autoCheck?: boolean
+  ): Promise<void>;
+  extendLockPeriodQuick: (
+    lockPeriodInDays: number,
+    veScaKey?: SuiAddressArg,
+    autoCheck?: boolean
+  ) => Promise<void>;
+  extendLockAmountQuick: (
+    scaAmount: number,
+    veScaKey?: SuiAddressArg,
+    autoCheck?: boolean
+  ) => Promise<void>;
+  renewExpiredVeScaQuick: (
+    scaAmount: number,
+    lockPeriodInDays: number,
+    veScaKey?: SuiAddressArg,
+    autoCheck?: boolean
+  ) => Promise<void>;
+  redeemScaQuick: (veScaKey?: SuiAddressArg) => Promise<void>;
+};
+
+export type SuiTxBlockWithVeScaNormalMethods = SuiKitTxBlock &
+  VeScaNormalMethods;
+
+export type VeScaTxBlock = SuiTxBlockWithVeScaNormalMethods & VeScaQuickMethods;
+
+export type GenerateVeScaNormalMethod = (params: {
+  builder: ScallopBuilder;
+  txBlock: SuiKitTxBlock;
+}) => VeScaNormalMethods;
+
+export type GenerateVeScaQuickMethod = (params: {
+  builder: ScallopBuilder;
+  txBlock: SuiTxBlockWithVeScaNormalMethods;
+}) => VeScaQuickMethods;

package/src/types/constant/enum.ts

@@ -29,7 +29,7 @@ export type StakeRewardCoins = {
 };
 
 export type BorrowIncentiveRewardCoins = {
-  [key in SupportBorrowIncentiveCoins]: SupportBorrowIncentiveRewardCoins;
+  [key in SupportBorrowIncentiveCoins]: SupportBorrowIncentiveRewardCoins[];
 };
 
 export type AssetCoinIds = {