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

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;
+};

package/src/utils/builder.ts

@@ -22,16 +22,61 @@ export const requireSender = (txBlock: SuiKitTxBlock) => {
   return sender;
 };
 
+export const checkVesca = (prevUnlockAtInMillisTimestamp?: number) => {
+  if (prevUnlockAtInMillisTimestamp === undefined) {
+    throw new Error('veSca not found');
+  }
+};
+
+export const checkVescaExpired = (prevUnlockAtInMillisTimestamp: number) => {
+  if (prevUnlockAtInMillisTimestamp <= new Date().getTime()) {
+    throw new Error('veSca is expired, use renewExpiredVeScaQuick instead');
+  }
+};
+
+export const checkExtendLockPeriod = (
+  lockPeriodInDays: number,
+  newUnlockAtInSecondTimestamp: number,
+  prevUnlockAtInMillisTimestamp?: number
+) => {
+  checkVesca(prevUnlockAtInMillisTimestamp);
+  checkVescaExpired(prevUnlockAtInMillisTimestamp!);
+  const prevUnlockAtInSecondTimestamp = Math.floor(
+    prevUnlockAtInMillisTimestamp! / 1000
+  );
+  if (lockPeriodInDays < 1) {
+    throw new Error('Minimum lock period is 1 day');
+  }
+
+  const availableLockPeriodInDays = Math.floor(
+    (newUnlockAtInSecondTimestamp - prevUnlockAtInSecondTimestamp) /
+      UNLOCK_ROUND_DURATION
+  );
+  console.log('availableLockPeriodInDays', availableLockPeriodInDays);
+  if (lockPeriodInDays > availableLockPeriodInDays) {
+    throw new Error(
+      `Cannot extend lock period by ${lockPeriodInDays} days, maximum lock period is ~4 years (${MAX_LOCK_ROUNDS} days), remaining lock period is ${
+        MAX_LOCK_ROUNDS - availableLockPeriodInDays
+      }`
+    );
+  }
+};
+
 export const checkLockSca = (
-  scaAmountOrCoin?: number | SuiObjectArg | undefined,
+  scaAmountOrCoin: number | SuiObjectArg | undefined,
   lockPeriodInDays?: number,
   newUnlockAtInSecondTimestamp?: number,
-  prevUnlockAtInSecondTimestamp?: number
+  prevUnlockAtInMillisTimestamp?: number
 ) => {
+  const prevUnlockAtInSecondTimestamp = prevUnlockAtInMillisTimestamp
+    ? Math.floor(prevUnlockAtInMillisTimestamp / 1000)
+    : undefined;
   const isInitialLock = !prevUnlockAtInSecondTimestamp;
   const isLockExpired =
     !isInitialLock &&
     prevUnlockAtInSecondTimestamp * 1000 <= new Date().getTime();
+
+  // handle for initial lock / renewing expired veSca
   if (isInitialLock || isLockExpired) {
     if (scaAmountOrCoin !== undefined && lockPeriodInDays !== undefined) {
       if (lockPeriodInDays <= 0) {
@@ -61,7 +106,9 @@ export const checkLockSca = (
       );
     }
   } else {
-    checkVesca(prevUnlockAtInSecondTimestamp);
+    // handle for extending lock period / top up / both
+    checkVesca(prevUnlockAtInMillisTimestamp);
+    checkVescaExpired(prevUnlockAtInMillisTimestamp!);
     if (
       typeof scaAmountOrCoin === 'number' &&
       scaAmountOrCoin < MIN_TOP_UP_AMOUNT
@@ -69,43 +116,12 @@ export const checkLockSca = (
       throw new Error('Minimum top up amount is 1 SCA');
     }
 
-    if (!!newUnlockAtInSecondTimestamp && !!prevUnlockAtInSecondTimestamp) {
-      const totalLockDuration =
-        newUnlockAtInSecondTimestamp - prevUnlockAtInSecondTimestamp;
-      if (totalLockDuration > MAX_LOCK_DURATION - UNLOCK_ROUND_DURATION) {
-        throw new Error(
-          `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS - 1} days)`
-        );
-      }
-    }
-  }
-};
-
-export const checkExtendLockPeriod = (
-  lockPeriodInDays: number,
-  newUnlockAtInSecondTimestamp: number,
-  prevUnlockAtInSecondTimestamp?: number
-) => {
-  checkVesca(prevUnlockAtInSecondTimestamp);
-
-  if (lockPeriodInDays <= 0) {
-    throw new Error('Lock period must be greater than 0');
-  }
-
-  const isInitialLock = !prevUnlockAtInSecondTimestamp;
-  const isLockExpired =
-    !isInitialLock &&
-    prevUnlockAtInSecondTimestamp * 1000 <= new Date().getTime();
-  if (isLockExpired) {
-    throw new Error('veSca is expired, use renewExpiredVeScaQuick instead');
-  }
-
-  if (prevUnlockAtInSecondTimestamp) {
-    const totalLockDuration =
-      newUnlockAtInSecondTimestamp - prevUnlockAtInSecondTimestamp!;
-    if (totalLockDuration > MAX_LOCK_DURATION - UNLOCK_ROUND_DURATION) {
-      throw new Error(
-        `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS - 1} days)`
+    // for topup and extend lock period
+    if (newUnlockAtInSecondTimestamp && lockPeriodInDays) {
+      checkExtendLockPeriod(
+        lockPeriodInDays,
+        newUnlockAtInSecondTimestamp,
+        prevUnlockAtInMillisTimestamp
       );
     }
   }
@@ -113,18 +129,19 @@ export const checkExtendLockPeriod = (
 
 export const checkExtendLockAmount = (
   scaAmount: number,
-  prevUnlockAtInSecondTimestamp?: number
+  prevUnlockAtInMillisTimestamp?: number
 ) => {
-  checkVesca(prevUnlockAtInSecondTimestamp);
+  checkVesca(prevUnlockAtInMillisTimestamp);
+  checkVescaExpired(prevUnlockAtInMillisTimestamp!);
 
   if (scaAmount < MIN_TOP_UP_AMOUNT) {
     throw new Error('Minimum top up amount is 1 SCA');
   }
 
-  const isInitialLock = !prevUnlockAtInSecondTimestamp;
+  const isInitialLock = !prevUnlockAtInMillisTimestamp;
   const isLockExpired =
-    !isInitialLock &&
-    prevUnlockAtInSecondTimestamp * 1000 <= new Date().getTime();
+    !isInitialLock && prevUnlockAtInMillisTimestamp <= new Date().getTime();
+
   if (isLockExpired) {
     throw new Error('veSca is expired, use renewExpiredVeScaQuick instead');
   }
@@ -133,9 +150,14 @@ export const checkExtendLockAmount = (
 export const checkRenewExpiredVeSca = (
   scaAmount: number,
   lockPeriodInDays: number,
-  prevUnlockAtInSecondTimestamp?: number
+  prevUnlockAtInMillisTimestamp?: number
 ) => {
-  checkVesca(prevUnlockAtInSecondTimestamp);
+  if (
+    !prevUnlockAtInMillisTimestamp ||
+    prevUnlockAtInMillisTimestamp > new Date().getTime()
+  ) {
+    throw new Error('Renew method can only be used for expired veSca');
+  }
 
   if (scaAmount < MIN_INITIAL_LOCK_AMOUNT) {
     throw new Error('Minimum lock amount for renewing expired vesca 10 SCA');
@@ -148,9 +170,3 @@ export const checkRenewExpiredVeSca = (
     );
   }
 };
-
-export const checkVesca = (prevUnlockAtInSecondTimestamp?: number) => {
-  if (prevUnlockAtInSecondTimestamp === undefined) {
-    throw new Error('veSca not found');
-  }
-};