@scallop-io/sui-scallop-sdk 0.46.36 → 0.46.38

package/src/queries/coreQuery.ts

@@ -50,18 +50,6 @@ export const queryMarket = async (
   query: ScallopQuery,
   indexer: boolean = false
 ) => {
-  const packageId = query.address.get('core.packages.query.id');
-  const marketId = query.address.get('core.market');
-  const queryTarget = `${packageId}::market_query::market_data`;
-  const args = [marketId];
-
-  // const txBlock = new SuiKitTxBlock();
-  // txBlock.moveCall(queryTarget, args);
-  const queryResult = await query.cache.queryInspectTxn(
-    { queryTarget, args }
-    // txBlock
-  );
-  const marketData = queryResult.events[0].parsedJson as MarketQueryInterface;
   const coinPrices = await query.utils.getCoinPrices();
 
   const pools: MarketPools = {};
@@ -86,6 +74,14 @@ export const queryMarket = async (
     };
   }
 
+  const packageId = query.address.get('core.packages.query.id');
+  const marketId = query.address.get('core.market');
+  const queryTarget = `${packageId}::market_query::market_data`;
+  const args = [marketId];
+
+  const queryResult = await query.cache.queryInspectTxn({ queryTarget, args });
+  const marketData = queryResult.events[0].parsedJson as MarketQueryInterface;
+
   for (const pool of marketData.pools) {
     const coinType = normalizeStructTag(pool.type.name);
     const poolCoinName =
@@ -236,19 +232,21 @@ export const getMarketPools = async (
     return marketPools;
   }
 
-  for (const poolCoinName of poolCoinNames) {
-    const marketPool = await getMarketPool(
-      query,
-      poolCoinName,
-      indexer,
-      marketObjectResponse.data,
-      coinPrices?.[poolCoinName]
-    );
+  Promise.allSettled(
+    poolCoinNames.map(async (poolCoinName) => {
+      const marketPool = await getMarketPool(
+        query,
+        poolCoinName,
+        indexer,
+        marketObjectResponse.data,
+        coinPrices?.[poolCoinName]
+      );
 
-    if (marketPool) {
-      marketPools[poolCoinName] = marketPool;
-    }
-  }
+      if (marketPool) {
+        marketPools[poolCoinName] = marketPool;
+      }
+    })
+  );
 
   return marketPools;
 };
@@ -475,11 +473,12 @@ export const getMarketCollaterals = async (
 ) => {
   collateralCoinNames = collateralCoinNames || [...SUPPORT_COLLATERALS];
   const marketId = query.address.get('core.market');
-  const marketObjectResponse = await query.cache.queryGetObject(marketId, {
-    showContent: true,
-  });
-  const coinPrices = await query.utils.getCoinPrices(collateralCoinNames ?? []);
-
+  const [marketObjectResponse, coinPrices] = await Promise.all([
+    query.cache.queryGetObject(marketId, {
+      showContent: true,
+    }),
+    query.utils.getCoinPrices(collateralCoinNames ?? []),
+  ]);
   const marketCollaterals: MarketCollaterals = {};
 
   if (indexer) {
@@ -496,19 +495,21 @@ export const getMarketCollaterals = async (
     return marketCollaterals;
   }
 
-  for (const collateralCoinName of collateralCoinNames) {
-    const marketCollateral = await getMarketCollateral(
-      query,
-      collateralCoinName,
-      indexer,
-      marketObjectResponse.data,
-      coinPrices?.[collateralCoinName]
-    );
+  await Promise.allSettled(
+    collateralCoinNames.map(async (collateralCoinName) => {
+      const marketCollateral = await getMarketCollateral(
+        query,
+        collateralCoinName,
+        indexer,
+        marketObjectResponse.data,
+        coinPrices?.[collateralCoinName]
+      );
 
-    if (marketCollateral) {
-      marketCollaterals[collateralCoinName] = marketCollateral;
-    }
-  }
+      if (marketCollateral) {
+        marketCollaterals[collateralCoinName] = marketCollateral;
+      }
+    })
+  );
 
   return marketCollaterals;
 };
@@ -530,6 +531,22 @@ export const getMarketCollateral = async (
   marketObject?: SuiObjectData | null,
   coinPrice?: number
 ) => {
+  if (indexer) {
+    const marketCollateralIndexer =
+      await query.indexer.getMarketCollateral(collateralCoinName);
+    marketCollateralIndexer.coinPrice =
+      coinPrice || marketCollateralIndexer.coinPrice;
+    marketCollateralIndexer.coinWrappedType = query.utils.getCoinWrappedType(
+      marketCollateralIndexer.coinName
+    );
+
+    return marketCollateralIndexer;
+  }
+
+  let marketCollateral: MarketCollateral | undefined;
+  let riskModel: RiskModel | undefined;
+  let collateralStat: CollateralStat | undefined;
+
   const marketId = query.address.get('core.market');
   marketObject =
     marketObject ||
@@ -545,22 +562,6 @@ export const getMarketCollateral = async (
       collateralCoinName
     ];
 
-  let marketCollateral: MarketCollateral | undefined;
-  let riskModel: RiskModel | undefined;
-  let collateralStat: CollateralStat | undefined;
-
-  if (indexer) {
-    const marketCollateralIndexer =
-      await query.indexer.getMarketCollateral(collateralCoinName);
-    marketCollateralIndexer.coinPrice =
-      coinPrice || marketCollateralIndexer.coinPrice;
-    marketCollateralIndexer.coinWrappedType = query.utils.getCoinWrappedType(
-      marketCollateralIndexer.coinName
-    );
-
-    return marketCollateralIndexer;
-  }
-
   if (marketObject) {
     if (marketObject.content && 'fields' in marketObject.content) {
       const fields = marketObject.content.fields as any;
@@ -698,15 +699,18 @@ export const getObligations = async (
   const keyObjects = await query.cache.queryGetObjects(keyObjectIds);
 
   const obligations: Obligation[] = [];
-  for (const keyObject of keyObjects) {
-    const keyId = keyObject.objectId;
-    if (keyObject.content && 'fields' in keyObject.content) {
-      const fields = keyObject.content.fields as any;
-      const obligationId = String(fields.ownership.fields.of);
-      const locked = await getObligationLocked(query, obligationId);
-      obligations.push({ id: obligationId, keyId, locked });
-    }
-  }
+  await Promise.allSettled(
+    keyObjects.map(async (keyObject) => {
+      const keyId = keyObject.objectId;
+      if (keyObject.content && 'fields' in keyObject.content) {
+        const fields = keyObject.content.fields as any;
+        const obligationId = String(fields.ownership.fields.of);
+        const locked = await getObligationLocked(query, obligationId);
+        obligations.push({ id: obligationId, keyId, locked });
+      }
+    })
+  );
+
   return obligations;
 };
 

package/src/queries/index.ts

@@ -5,3 +5,4 @@ export * from './priceQuery';
 export * from './portfolioQuery';
 export * from './vescaQuery';
 export * from './referralQuery';
+export * from './loyaltyProgramQuery';

package/src/queries/loyaltyProgramQuery.ts

@@ -0,0 +1,77 @@
+import { SuiObjectData } from '@mysten/sui.js/src/client';
+import BigNumber from 'bignumber.js';
+import { ScallopQuery } from 'src/models';
+import { LoyaltyProgramInfo } from 'src/types';
+import { z as zod } from 'zod';
+
+const rewardPoolFieldsZod = zod
+  .object({
+    balance: zod.string(),
+    enable_claim: zod.boolean(),
+  })
+  .transform((value) => ({
+    totalPoolReward: BigNumber(value.balance).shiftedBy(-9).toNumber(),
+    isClaimEnabled: value.enable_claim,
+  }));
+
+const userRewardFieldsZod = zod
+  .object({
+    value: zod.string(),
+  })
+  .transform((value) => BigNumber(value.value).shiftedBy(-9).toNumber());
+
+type RewardPoolFields = zod.infer<typeof rewardPoolFieldsZod>;
+type UserRewardFields = zod.infer<typeof userRewardFieldsZod>;
+
+/**
+ * Get user's loyalty program information and pending rewards if exists
+ * @param query
+ * @param veScaKey
+ * @returns
+ */
+export const getLoyaltyProgramInformations = async (
+  query: ScallopQuery,
+  veScaKey?: string | SuiObjectData
+): Promise<LoyaltyProgramInfo | null> => {
+  const rewardPool = query.address.get('loyaltyProgram.rewardPool');
+
+  // get fields from rewardPool object
+  const rewardPoolObject = await query.cache.queryGetObject(rewardPool, {
+    showContent: true,
+  });
+
+  if (rewardPoolObject.data?.content?.dataType !== 'moveObject') return null;
+  const rewardPoolFields = rewardPoolObject.data.content.fields;
+  const { isClaimEnabled, totalPoolReward } = rewardPoolFieldsZod.parse(
+    rewardPoolFields
+  ) as RewardPoolFields;
+
+  const result: LoyaltyProgramInfo = {
+    pendingReward: 0,
+    totalPoolReward,
+    isClaimEnabled,
+  };
+
+  // query the user pending reward if exist
+  veScaKey = veScaKey || (await query.getVeScas())[0]?.keyObject;
+  if (!veScaKey) return result;
+
+  const userRewardTableId = query.address.get(
+    'loyaltyProgram.userRewardTableId'
+  );
+
+  const userRewardObject = await query.cache.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;
+  result.pendingReward = userRewardFieldsZod.parse(
+    userRewardFields
+  ) as UserRewardFields;
+  return result;
+};

package/src/queries/portfolioQuery.ts

@@ -49,36 +49,44 @@ export const getLendings = async (
     (SUPPORT_SPOOLS as readonly SupportMarketCoins[]).includes(marketCoinName)
   ) as SupportStakeMarketCoins[];
 
-  const marketPools = await query.getMarketPools(poolCoinNames, indexer);
-  const spools = await query.getSpools(stakeMarketCoinNames, indexer);
-  const coinAmounts = await query.getCoinAmounts(poolCoinNames, ownerAddress);
-  const marketCoinAmounts = await query.getMarketCoinAmounts(
-    marketCoinNames,
-    ownerAddress
-  );
-  const allStakeAccounts = await query.getAllStakeAccounts(ownerAddress);
-  const coinPrices = await query.utils.getCoinPrices(poolCoinNames);
+  const [
+    marketPools,
+    spools,
+    coinAmounts,
+    marketCoinAmounts,
+    allStakeAccounts,
+    coinPrices,
+  ] = await Promise.all([
+    query.getMarketPools(poolCoinNames, indexer),
+    query.getSpools(stakeMarketCoinNames, indexer),
+    query.getCoinAmounts(poolCoinNames, ownerAddress),
+    query.getMarketCoinAmounts(marketCoinNames, ownerAddress),
+    query.getAllStakeAccounts(ownerAddress),
+    query.utils.getCoinPrices(poolCoinNames),
+  ]);
 
   const lendings: Lendings = {};
-  for (const poolCoinName of poolCoinNames) {
-    const stakeMarketCoinName = stakeMarketCoinNames.find(
-      (marketCoinName) =>
-        marketCoinName === query.utils.parseMarketCoinName(poolCoinName)
-    );
-    const marketCoinName = query.utils.parseMarketCoinName(poolCoinName);
-    lendings[poolCoinName] = await getLending(
-      query,
-      poolCoinName,
-      ownerAddress,
-      indexer,
-      marketPools?.[poolCoinName],
-      stakeMarketCoinName ? spools[stakeMarketCoinName] : undefined,
-      stakeMarketCoinName ? allStakeAccounts[stakeMarketCoinName] : undefined,
-      coinAmounts?.[poolCoinName],
-      marketCoinAmounts?.[marketCoinName],
-      coinPrices?.[poolCoinName] ?? 0
-    );
-  }
+  await Promise.allSettled(
+    poolCoinNames.map(async (poolCoinName) => {
+      const stakeMarketCoinName = stakeMarketCoinNames.find(
+        (marketCoinName) =>
+          marketCoinName === query.utils.parseMarketCoinName(poolCoinName)
+      );
+      const marketCoinName = query.utils.parseMarketCoinName(poolCoinName);
+      lendings[poolCoinName] = await getLending(
+        query,
+        poolCoinName,
+        ownerAddress,
+        indexer,
+        marketPools?.[poolCoinName],
+        stakeMarketCoinName ? spools[stakeMarketCoinName] : undefined,
+        stakeMarketCoinName ? allStakeAccounts[stakeMarketCoinName] : undefined,
+        coinAmounts?.[poolCoinName],
+        marketCoinAmounts?.[marketCoinName],
+        coinPrices?.[poolCoinName] ?? 0
+      );
+    })
+  );
 
   return lendings;
 };

package/src/queries/vescaQuery.ts

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { Vesca } from '../types';
+import { VeScaTreasuryFields, VeScaTreasuryInfo, Vesca } from '../types';
 import {
   type SuiObjectResponse,
   type SuiObjectData,
@@ -9,6 +9,7 @@ import type { ScallopQuery } 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.js/bcs';
+import { z as zod } from 'zod';
 /**
  * Query all owned veSca key.
  *
@@ -63,11 +64,10 @@ export const getVescaKeys = async (
  */
 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 | undefined)[] = Array(keyObjectId.length).fill(null);
-  const tasks = keyObjectId.map(async (keyId, idx) => {
-    const veSca = await getVeSca(query, keyId);
+  const veScas: Vesca[] = Array(keyObjectDatas.length).fill(null);
+  const tasks = keyObjectDatas.map(async (veScaKey, idx) => {
+    const veSca = await getVeSca(query, veScaKey);
     if (veSca) {
       veScas[idx] = veSca;
     }
@@ -79,22 +79,33 @@ export const getVeScas = async (query: ScallopQuery, ownerAddress?: string) => {
     .sort((a, b) => b!.currentVeScaBalance - a!.currentVeScaBalance);
 };
 
+const SuiObjectRefZod = zod.object({
+  objectId: zod.string(),
+  digest: zod.string(),
+  version: zod.string(),
+});
+
+type SuiObjectRefType = zod.infer<typeof SuiObjectRefZod>;
 /**
  * Get veSca data.
  *
  * @param query - The Scallop query instance.
- * @param veScaKeyId - The vesca key id.
+ * @param veScaKey - The vesca key id.
  * @param ownerAddress - The owner address.
  * @returns Vesca data.
  */
 export const getVeSca = async (
   query: ScallopQuery,
-  veScaKeyId?: string,
+  veScaKey?: string | SuiObjectData,
   ownerAddress?: string
 ) => {
   const tableId = query.address.get(`vesca.tableId`);
-  veScaKeyId =
-    veScaKeyId || (await getVescaKeys(query, ownerAddress))[0].objectId;
+  veScaKey = veScaKey || (await getVescaKeys(query, ownerAddress))[0];
+
+  if (!veScaKey) return undefined;
+  if (typeof veScaKey === 'object') {
+    veScaKey = SuiObjectRefZod.parse(veScaKey) as SuiObjectRefType;
+  }
 
   let vesca: Vesca | undefined = undefined;
 
@@ -103,7 +114,7 @@ export const getVeSca = async (
       parentId: tableId,
       name: {
         type: '0x2::object::ID',
-        value: veScaKeyId,
+        value: typeof veScaKey === 'string' ? veScaKey : veScaKey.objectId,
       },
     });
   const veScaDynamicFieldObject = veScaDynamicFieldObjectResponse.data;
@@ -131,7 +142,9 @@ export const getVeSca = async (
 
     vesca = {
       id: veScaDynamicFieldObject.objectId,
-      keyId: veScaKeyId,
+      keyId: typeof veScaKey === 'string' ? veScaKey : veScaKey.objectId,
+      keyObject: typeof veScaKey === 'string' ? undefined : veScaKey,
+      object: SuiObjectRefZod.parse(veScaDynamicFieldObjectResponse.data),
       lockedScaAmount,
       lockedScaCoin,
       currentVeScaBalance,
@@ -145,12 +158,13 @@ export const getVeSca = async (
 /**
  * Get current total veSca treasury amount.
  */
-export const getTotalVeScaTreasuryAmount = async (
-  query: ScallopQuery
+const getTotalVeScaTreasuryAmount = async (
+  query: ScallopQuery,
+  veScaTreasury: SuiObjectData
 ): Promise<string> => {
   const veScaPkgId = query.address.get('vesca.id');
   const veScaConfig = query.address.get('vesca.config');
-  const veScaTreasury = query.address.get('vesca.treasury');
+  veScaTreasury = veScaTreasury ?? query.address.get('vesca.treasury');
 
   // refresh query
   const refreshQueryTarget = `${veScaPkgId}::treasury::refresh`;
@@ -201,7 +215,6 @@ export const getTotalVeScaTreasuryAmount = async (
     queryFn: async () => {
       return await query.suiKit.inspectTxn(txBytes);
     },
-    staleTime: 8000,
   });
 
   const results = res.results;
@@ -213,3 +226,45 @@ export const getTotalVeScaTreasuryAmount = async (
 
   return '0';
 };
+
+/**
+ * Get veSCA treasury informations
+ * @param query
+ * @returns VeScaTreasuryInfo
+ */
+export const getVeScaTreasuryInfo = async (
+  query: ScallopQuery
+): Promise<VeScaTreasuryInfo | null> => {
+  const veScaTreasuryId = query.address.get('vesca.treasury');
+  const veScaTreasury = await query.cache.queryGetObject(veScaTreasuryId, {
+    showContent: true,
+  });
+
+  if (!veScaTreasury || veScaTreasury.data?.content?.dataType !== 'moveObject')
+    return null;
+
+  const treasuryFields = veScaTreasury.data.content
+    .fields as VeScaTreasuryFields;
+
+  console.log(treasuryFields);
+  const totalLockedSca = BigNumber(
+    treasuryFields.unlock_schedule.fields.locked_sca_amount
+  )
+    .shiftedBy(-9)
+    .toNumber();
+  const totalVeSca = BigNumber(
+    (await getTotalVeScaTreasuryAmount(query, veScaTreasury.data)) ?? 0
+  )
+    .shiftedBy(-9)
+    .toNumber();
+  const averageLockingPeriod =
+    totalLockedSca > 0 ? (totalVeSca / totalLockedSca) * 4 : 0; // in years
+
+  const averageLockingPeriodUnit = 'year';
+  return {
+    totalLockedSca,
+    totalVeSca,
+    averageLockingPeriod,
+    averageLockingPeriodUnit,
+  };
+};

package/src/types/address.ts

@@ -115,6 +115,12 @@ export interface AddressesInterface {
     tiersTableId: string;
     authorizedWitnessList: string;
   };
+  loyaltyProgram: {
+    id: string;
+    object: string;
+    rewardPool: string;
+    userRewardTableId: string;
+  };
 }
 
 type AddressPathsProps<T> = T extends string

package/src/types/builder/index.ts

@@ -3,14 +3,17 @@ import type { SpoolTxBlock } from './spool';
 import type { BorrowIncentiveTxBlock } from './borrowIncentive';
 import type { VeScaTxBlock } from './vesca';
 import type { ReferralTxBlock } from './referral';
+import { LoyaltyProgramTxBlock } from './loyaltyProgram';
 
 export type * from './core';
 export type * from './spool';
 export type * from './borrowIncentive';
 export type * from './vesca';
+export type * from './loyaltyProgram';
 
 export type ScallopTxBlock = CoreTxBlock &
   SpoolTxBlock &
   ReferralTxBlock &
+  LoyaltyProgramTxBlock &
   BorrowIncentiveTxBlock &
   VeScaTxBlock;

package/src/types/builder/loyaltyProgram.ts

@@ -0,0 +1,35 @@
+import {
+  SuiObjectArg,
+  SuiTxBlock as SuiKitTxBlock,
+  TransactionResult,
+} from '@scallop-io/sui-kit';
+import { type ScallopBuilder } from 'src/models';
+
+export type LoyaltyProgramIds = {
+  loyaltyProgramPkgId: string;
+  rewardPool: string;
+  userRewardTableId: string;
+};
+
+export type LoyaltyProgramNormalMethods = {
+  claimLoyaltyRevenue: (veScaKey: SuiObjectArg) => TransactionResult;
+};
+
+export type LoyaltyProgramQuickMethods = {
+  claimLoyaltyRevenueQuick: (veScaKey?: SuiObjectArg) => Promise<void>;
+};
+
+export type SuiTxBlockWithLoyaltyProgramNormalMethods = SuiKitTxBlock &
+  LoyaltyProgramNormalMethods;
+export type LoyaltyProgramTxBlock = SuiTxBlockWithLoyaltyProgramNormalMethods &
+  LoyaltyProgramQuickMethods;
+
+export type GenerateLoyaltyProgramNormalMethod = (params: {
+  builder: ScallopBuilder;
+  txBlock: SuiKitTxBlock;
+}) => LoyaltyProgramNormalMethods;
+
+export type GenerateLoyaltyProgramQuickMethod = (params: {
+  builder: ScallopBuilder;
+  txBlock: SuiTxBlockWithLoyaltyProgramNormalMethods;
+}) => LoyaltyProgramQuickMethods;

package/src/types/builder/vesca.ts

@@ -33,6 +33,22 @@ export type VeScaNormalMethods = {
 };
 
 export type VeScaQuickMethods = {
+  /**
+   * Quick methods to automate
+   * lock initial SCA, extend lock period, lock more SCA, renew expired VeSCA, and redeem SCA
+   *
+   * **Flow:**
+   * - If only `amountOrCoin` is provided, it will lock the amount of existing not expired veSCA
+   * - If only `lockPeriodInDays` is provided, it will extend the lock period of existing not expired veSCA
+   *
+   * **Note:**
+   * - If one or both flow above is used on a expired veSCA, it will claim the unlocked SCA
+   *   and renew the veSCA first, and then flow continues
+   * - If users has no veSCA yet, they need to provide both `amountOrCoin` and `lockPeriodInDays` for initial lock
+   * @param amountOrCoin
+   * @param lockPeriodInDays
+   * @param autoCheck
+   */
   lockScaQuick(
     amountOrCoin?: SuiObjectArg | number,
     lockPeriodInDays?: number,

package/src/types/query/index.ts

@@ -3,3 +3,4 @@ export type * from './spool';
 export type * from './borrowIncentive';
 export type * from './portfolio';
 export type * from './vesca';
+export type * from './loyaltyProgram';

package/src/types/query/loyaltyProgram.ts

@@ -0,0 +1,5 @@
+export type LoyaltyProgramInfo = {
+  pendingReward: number;
+  totalPoolReward: number;
+  isClaimEnabled: boolean;
+};

package/src/types/query/vesca.ts

@@ -1,8 +1,29 @@
+import type { SuiObjectRef } from '@mysten/sui.js/client';
+
 export type Vesca = {
   id: string;
   keyId: string;
+  keyObject?: SuiObjectRef;
+  object?: SuiObjectRef;
   lockedScaAmount: string;
   lockedScaCoin: number;
   currentVeScaBalance: number;
   unlockAt: number;
 };
+
+export type VeScaTreasuryFields = {
+  total_ve_sca_amount: string;
+  sca_balance: string;
+  unlock_schedule: {
+    fields: {
+      locked_sca_amount: string;
+    };
+  };
+};
+
+export type VeScaTreasuryInfo = {
+  totalLockedSca: number;
+  totalVeSca: number;
+  averageLockingPeriod: number;
+  averageLockingPeriodUnit: string;
+};