@scallop-io/sui-scallop-sdk 0.45.0 → 0.46.1

package/src/builders/referralBuilder.ts

@@ -0,0 +1,178 @@
+import { ScallopBuilder } from 'src/models';
+import { ScallopTxBlock, SupportCoins, SupportPoolCoins } from 'src/types';
+import {
+  SUI_CLOCK_OBJECT_ID,
+  SuiTxBlock as SuiKitTxBlock,
+  SuiObjectArg,
+  TransactionBlock,
+} from '@scallop-io/sui-kit';
+import {
+  GenerateReferralNormalMethod,
+  GenerateReferralQuickMethod,
+  ReferralIds,
+  ReferralTxBlock,
+  SuiTxBlockWithReferralNormalMethods,
+} from 'src/types/builder/referral';
+import { SUPPORT_POOLS } from 'src/constants';
+import { requireSender } from 'src/utils';
+
+const generateReferralNormalMethod: GenerateReferralNormalMethod = ({
+  builder,
+  txBlock,
+}) => {
+  const referralIds: ReferralIds = {
+    referralPgkId: builder.address.get('referral.id'),
+    referralBindings: builder.address.get('referral.referralBindings'),
+    referralRevenuePool: builder.address.get('referral.referralRevenuePool'),
+    authorizedWitnessList: builder.address.get(
+      'referral.authorizedWitnessList'
+    ),
+    referralTiers: builder.address.get('referral.referralTiers'),
+    version: builder.address.get('referral.version'),
+  };
+
+  const veScaTable = builder.address.get('vesca.table');
+
+  return {
+    bindToReferral: (veScaKeyId: string) => {
+      return txBlock.moveCall(
+        `${referralIds.referralPgkId}::referral_bindings::bind_ve_sca_referrer`,
+        [
+          referralIds.referralBindings,
+          txBlock.pure(veScaKeyId),
+          veScaTable,
+          SUI_CLOCK_OBJECT_ID,
+        ],
+        []
+      );
+    },
+    claimReferralTicket: (poolCoinName: SupportCoins) => {
+      const coinType = builder.utils.parseCoinType(poolCoinName);
+      return txBlock.moveCall(
+        `${referralIds.referralPgkId}::scallop_referral_program::claim_ve_sca_referral_ticket`,
+        [
+          referralIds.version,
+          veScaTable,
+          referralIds.referralBindings,
+          referralIds.authorizedWitnessList,
+          referralIds.referralTiers,
+          SUI_CLOCK_OBJECT_ID,
+        ],
+        [coinType]
+      );
+    },
+    burnReferralTicket: (ticket: SuiObjectArg, poolCoinName: SupportCoins) => {
+      const coinType = builder.utils.parseCoinType(poolCoinName);
+      return txBlock.moveCall(
+        `${referralIds.referralPgkId}::scallop_referral_program::burn_ve_sca_referral_ticket`,
+        [
+          referralIds.version,
+          ticket,
+          referralIds.referralRevenuePool,
+          SUI_CLOCK_OBJECT_ID,
+        ],
+        [coinType]
+      );
+    },
+    claimReferralRevenue: (
+      veScaKey: SuiObjectArg,
+      poolCoinName: SupportCoins
+    ) => {
+      const coinType = builder.utils.parseCoinType(poolCoinName);
+      return txBlock.moveCall(
+        `${referralIds.referralPgkId}::referral_revenue_pool::claim_revenue_with_ve_sca_key`,
+        [
+          referralIds.version,
+          referralIds.referralRevenuePool,
+          veScaKey,
+          SUI_CLOCK_OBJECT_ID,
+        ],
+        [coinType]
+      );
+    },
+  };
+};
+
+const generateReferralQuickMethod: GenerateReferralQuickMethod = ({
+  builder,
+  txBlock,
+}) => {
+  return {
+    claimReferralRevenueQuick: async (
+      veScaKey: SuiObjectArg,
+      coinNames: SupportPoolCoins[] = [...SUPPORT_POOLS]
+    ) => {
+      const sender = requireSender(txBlock);
+      const objToTransfer: SuiObjectArg[] = [];
+      for (const coinName of coinNames) {
+        if (coinName === 'sui') {
+          const rewardCoin = txBlock.claimReferralRevenue(veScaKey, coinName);
+          objToTransfer.push(rewardCoin);
+        } else {
+          // get the matching user coin if exists
+          const coins = await builder.suiKit.suiInteractor.selectCoins(
+            sender,
+            Infinity,
+            builder.utils.parseCoinType(coinName)
+          );
+
+          const rewardCoin = txBlock.claimReferralRevenue(veScaKey, coinName);
+          if (coins.length > 0) {
+            txBlock.mergeCoins(rewardCoin, coins);
+          }
+          objToTransfer.push(rewardCoin);
+        }
+      }
+      if (objToTransfer.length > 0) {
+        txBlock.transferObjects(objToTransfer, sender);
+      }
+    },
+  };
+};
+
+/**
+ * Create an enhanced transaction block instance for interaction with borrow incentive 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 newReferralTxBlock = (
+  builder: ScallopBuilder,
+  initTxBlock?: ScallopTxBlock | SuiKitTxBlock | TransactionBlock
+) => {
+  const txBlock =
+    initTxBlock instanceof TransactionBlock
+      ? new SuiKitTxBlock(initTxBlock)
+      : initTxBlock
+      ? initTxBlock
+      : new SuiKitTxBlock();
+
+  const normalMethod = generateReferralNormalMethod({
+    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 SuiTxBlockWithReferralNormalMethods;
+
+  const quickMethod = generateReferralQuickMethod({
+    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 ReferralTxBlock;
+};

package/src/builders/vescaBuilder.ts

@@ -65,11 +65,7 @@ export const requireVeSca = async (
     return undefined;
   }
 
-  return veScas.reduce(
-    (prev, acc) =>
-      acc.currentVeScaBalance > prev.currentVeScaBalance ? acc : prev,
-    veScas[0]
-  ); // return veSCA with highest veSCA balance
+  return veScas[0]; // return veSCA with highest veSCA balance
 };
 
 /**
@@ -161,6 +157,13 @@ const generateNormalVeScaMethod: GenerateVeScaNormalMethod = ({
         []
       );
     },
+    mintEmptyVeSca: () => {
+      return txBlock.moveCall(
+        `${veScaIds.pkgId}::ve_sca::mint_ve_sca_placeholder_key`,
+        [veScaIds.config, veScaIds.table],
+        []
+      );
+    },
   };
 };
 
@@ -378,7 +381,6 @@ export const newVeScaTxBlock = (
     },
   }) as SuiTxBlockWithVeScaNormalMethods;
 
-  // TODO: Add quickMethod for veSCA
   const quickMethod = generateQuickVeScaMethod({
     builder,
     txBlock: normalTxBlock,

package/src/constants/common.ts

@@ -3,18 +3,25 @@ export const SDK_API_BASE_URL = 'https://sdk.api.scallop.io';
 
 export const IS_VE_SCA_TEST = false;
 
+// export const ADDRESSES_ID = '';
 export const ADDRESSES_ID = IS_VE_SCA_TEST
-  ? ('65fb07c39c845425d71d7b18' as const)
-  : ('6601955b8b0024600a917079' as const);
+  ? // ? ('65fb07c39c845425d71d7b18' as const)
+    ('65fb07c39c845425d71d7b18' as const)
+  : ('664dfe22898c36c159e28bc8' as const);
+// : ('6601955b8b0024600a917079' as const);
 // : ('6462a088a7ace142bb6d7e9b' as const);
 
 export const PROTOCOL_OBJECT_ID = IS_VE_SCA_TEST
   ? ('0xc9f859f98ca352a11b97a038c4b4162bee437b8df8caa047990fe9cb03d4f778' as const)
   : ('0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf' as const);
+// export const PROTOCOL_OBJECT_ID =
+//   '0x87ddec2984645dbbe2403a509cc6edf393a43acdba9b77d45da2bcbefcf733c1' as const;
 
 export const BORROW_FEE_PROTOCOL_ID = IS_VE_SCA_TEST
   ? ('0xc9f859f98ca352a11b97a038c4b4162bee437b8df8caa047990fe9cb03d4f778' as const)
   : ('0xc38f849e81cfe46d4e4320f508ea7dda42934a329d5a6571bb4c3cb6ea63f5da' as const); // test environment
+// export const BORROW_FEE_PROTOCOL_ID =
+//   '0x87ddec2984645dbbe2403a509cc6edf393a43acdba9b77d45da2bcbefcf733c1' as const;
 
 export const SCA_COIN_TYPE = IS_VE_SCA_TEST
   ? (`0x6cd813061a3adf3602b76545f076205f0c8e7ec1d3b1eab9a1da7992c18c0524::sca::SCA` as const)

package/src/constants/vesca.ts

@@ -1,7 +1,5 @@
-import { IS_VE_SCA_TEST } from './common';
-
 export const UNLOCK_ROUND_DURATION = 60 * 60 * 24; // 1 days in seconds
-export const MAX_LOCK_ROUNDS: number = IS_VE_SCA_TEST ? 9 : 1460; // 4 years in days (or 9 days for testing)
+export const MAX_LOCK_ROUNDS: number = 1460; // 4 years in days (or 9 days for testing)
 export const MAX_LOCK_DURATION: number =
   MAX_LOCK_ROUNDS * UNLOCK_ROUND_DURATION; // 4 years in seconds
 

package/src/models/scallopAddress.ts

@@ -19,6 +19,45 @@ const EMPTY_ADDRESSES: AddressesInterface = {
     coinDecimalsRegistry: '',
     obligationAccessStore: '',
     coins: {
+      cetus: {
+        id: '',
+        metaData: '',
+        treasury: '',
+        oracle: {
+          supra: '',
+          switchboard: '',
+          pyth: {
+            feed: '',
+            feedObject: '',
+          },
+        },
+      },
+      apt: {
+        id: '',
+        metaData: '',
+        treasury: '',
+        oracle: {
+          supra: '',
+          switchboard: '',
+          pyth: {
+            feed: '',
+            feedObject: '',
+          },
+        },
+      },
+      sol: {
+        id: '',
+        metaData: '',
+        treasury: '',
+        oracle: {
+          supra: '',
+          switchboard: '',
+          pyth: {
+            feed: '',
+            feedObject: '',
+          },
+        },
+      },
       btc: {
         id: '',
         metaData: '',
@@ -140,15 +179,8 @@ const EMPTY_ADDRESSES: AddressesInterface = {
     oracles: {
       xOracle: '',
       xOracleCap: '',
-      supra: {
-        registry: '',
-        registryCap: '',
-        holder: '',
-      },
-      switchboard: {
-        registry: '',
-        registryCap: '',
-      },
+      supra: { registry: '', registryCap: '', holder: '' },
+      switchboard: { registry: '', registryCap: '' },
       pyth: {
         registry: '',
         registryCap: '',
@@ -178,27 +210,25 @@ const EMPTY_ADDRESSES: AddressesInterface = {
         id: '',
         upgradeCap: '',
       },
-      query: {
+      protocolWhitelist: {
         id: '',
         upgradeCap: '',
       },
-      pyth: {
+      query: {
         id: '',
         upgradeCap: '',
       },
-      switchboard: {
+      supra: { id: '', upgradeCap: '' },
+      pyth: {
         id: '',
         upgradeCap: '',
       },
+      switchboard: { id: '', upgradeCap: '' },
       xOracle: {
         id: '',
         upgradeCap: '',
       },
-      // Deploy for faucet on testnet.
-      testCoin: {
-        id: '',
-        upgradeCap: '',
-      },
+      testCoin: { id: '', upgradeCap: '' },
     },
   },
   spool: {
@@ -239,26 +269,40 @@ const EMPTY_ADDRESSES: AddressesInterface = {
         rewardPoolId: '',
       },
     },
+    config: '',
   },
   borrowIncentive: {
     id: '',
     adminCap: '',
     object: '',
     query: '',
-    config: '',
     incentivePools: '',
     incentiveAccounts: '',
+    config: '',
   },
   vesca: {
     id: '',
+    object: '',
     adminCap: '',
     tableId: '',
     table: '',
     treasury: '',
     config: '',
   },
+  referral: {
+    id: '',
+    version: '',
+    object: '',
+    adminCap: '',
+    referralBindings: '',
+    bindingTableId: '',
+    referralRevenuePool: '',
+    revenueTableId: '',
+    referralTiers: '',
+    tiersTableId: '',
+    authorizedWitnessList: '',
+  },
 };
-
 /**
  * @description
  * It provides methods for managing addresses.

package/src/models/scallopCache.ts

@@ -1,5 +1,5 @@
 import { QueryClient, QueryClientConfig } from '@tanstack/query-core';
-import { SuiTxArg, SuiTxBlock } from '@scallop-io/sui-kit';
+import { SuiTxArg, SuiTxBlock, normalizeStructTag } from '@scallop-io/sui-kit';
 import { SuiKit } from '@scallop-io/sui-kit';
 import type {
   SuiObjectResponse,
@@ -11,6 +11,7 @@ import type {
   GetDynamicFieldsParams,
   DynamicFieldPage,
   GetDynamicFieldObjectParams,
+  GetBalanceParams,
 } from '@mysten/sui.js/client';
 import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
 
@@ -70,7 +71,7 @@ export class ScallopCache {
    * @description Cache protocol config call for 60 seconds.
    * @returns Promise<ProtocolConfig>
    */
-  private async getProtocolConfig() {
+  public async getProtocolConfig() {
     return await this.queryClient.fetchQuery({
       queryKey: ['getProtocolConfig'],
       queryFn: async () => {
@@ -242,4 +243,43 @@ export class ScallopCache {
       },
     });
   }
+
+  public async queryGetAllCoinBalances(
+    owner: string
+  ): Promise<{ [k: string]: string }> {
+    const queryKey = ['getAllCoinBalances', owner];
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        const allBalances = await this.suiKit
+          .client()
+          .getAllBalances({ owner });
+        return allBalances.reduce(
+          (acc, coinBalance) => {
+            if (coinBalance.totalBalance !== '0') {
+              acc[normalizeStructTag(coinBalance.coinType)] =
+                coinBalance.totalBalance;
+            }
+            return acc;
+          },
+          {} as { [k: string]: string }
+        );
+      },
+    });
+  }
+
+  public async queryGetCoinBalance(input: GetBalanceParams): Promise<string> {
+    const queryKey = ['getCoinBalance', input.owner, input.coinType];
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        if (!input.coinType) return '0';
+        return (
+          (await this.queryGetAllCoinBalances(input.owner))[
+            normalizeStructTag(input.coinType)
+          ] ?? '0'
+        );
+      },
+    });
+  }
 }

package/src/models/scallopQuery.ts

@@ -25,8 +25,12 @@ import {
   getObligationAccounts,
   getObligationAccount,
   getTotalValueLocked,
+  queryVeScaKeyIdFromReferralBindings,
   getBindedObligationId,
   getBindedVeScaKey,
+  getVeScas,
+  getPythPrices,
+  getTotalVeScaTreasuryAmount,
 } from '../queries';
 import {
   ScallopQueryParams,
@@ -272,6 +276,16 @@ export class ScallopQuery {
     return await getPythPrice(this, assetCoinName);
   }
 
+  /**
+   * Get prices from pyth fee object.
+   *
+   * @param assetCoinNames - Array of supported asset coin names.
+   * @return Array of asset coin prices.
+   */
+  public async getPricesFromPyth(assetCoinNames: SupportAssetCoins[]) {
+    return await getPythPrices(this, assetCoinNames);
+  }
+
   /* ==================== Spool Query Methods ==================== */
 
   /**
@@ -524,6 +538,32 @@ export class ScallopQuery {
     return await getTotalValueLocked(this, indexer);
   }
 
+  /**
+   * Get all veSca from walletAdddress
+   * @param walletAddress
+   * @returns array of veSca
+   */
+  public async getVeScas(walletAddress: string) {
+    return await getVeScas(this, walletAddress);
+  }
+
+  /**
+   * Get total vesca treasury with movecall
+   * @returns Promise<string | undefined>
+   */
+  public async getTotalVeScaTreasuryAmount() {
+    return await getTotalVeScaTreasuryAmount(this);
+  }
+
+  /**
+   * Return binded veScaKeyId of walletAddress if exist
+   * @param walletAddress
+   * @returns veScaKeyId
+   */
+  public async getVeScaKeyIdFromReferralBindings(walletAddress: string) {
+    return await queryVeScaKeyIdFromReferralBindings(this, walletAddress);
+  }
+
   /**
    * Get binded obligationId from a veScaKey if it exists.
    * @param veScaKey

package/src/models/scallopUtils.ts

@@ -419,9 +419,6 @@ export class ScallopUtils {
       );
 
       for (const endpoint of endpoints) {
-        let hasFailRequest = false;
-        const pythConnection = new SuiPriceServiceConnection(endpoint);
-
         const priceIds = Array.from(failedRequests.values()).reduce(
           (acc, coinName) => {
             const priceId = this._address.get(
@@ -433,43 +430,46 @@ export class ScallopUtils {
           {} as Record<SupportAssetCoins, string>
         );
 
-        for (const [coinName, priceId] of Object.entries(priceIds)) {
-          try {
-            const feed = await this._cache.queryClient.fetchQuery({
-              queryKey: [priceId],
-              queryFn: async () => {
-                return await pythConnection.getLatestPriceFeeds([priceId]);
-              },
-              // staleTime: 15000,
-            });
-            if (feed) {
-              const data = parseDataFromPythPriceFeed(feed[0], this._address);
-              this._priceMap.set(coinName as SupportAssetCoins, {
-                price: data.price,
-                publishTime: data.publishTime,
+        await Promise.allSettled(
+          Object.entries(priceIds).map(async ([coinName, priceId]) => {
+            const pythConnection = new SuiPriceServiceConnection(endpoint);
+            try {
+              const feed = await this._cache.queryClient.fetchQuery({
+                queryKey: [priceId],
+                queryFn: async () => {
+                  return await pythConnection.getLatestPriceFeeds([priceId]);
+                },
               });
-              coinPrices[coinName as SupportAssetCoins] = data.price;
+              if (feed) {
+                const data = parseDataFromPythPriceFeed(feed[0], this._address);
+                this._priceMap.set(coinName as SupportAssetCoins, {
+                  price: data.price,
+                  publishTime: data.publishTime,
+                });
+                coinPrices[coinName as SupportAssetCoins] = data.price;
+              }
+              failedRequests.delete(coinName as SupportAssetCoins); // remove success price feed to prevent duplicate request on the next endpoint
+            } catch (e) {
+              console.warn(
+                `Failed to get price ${coinName} feeds with endpoint ${endpoint}: ${e}`
+              );
             }
-            failedRequests.delete(coinName as SupportAssetCoins); // remove success price feed to prevent duplicate request on the next endpoint
-          } catch (e) {
-            console.warn(
-              `Failed to get price ${coinName} feeds with endpoint ${endpoint}: ${e}`
-            );
-            hasFailRequest = true;
-          }
-        }
-        if (!hasFailRequest) break;
+          })
+        );
+        if (failedRequests.size === 0) break;
       }
 
       if (failedRequests.size > 0) {
-        for (const coinName of failedRequests.values()) {
-          const price = await this._query.getPriceFromPyth(coinName);
-          this._priceMap.set(coinName, {
-            price: price,
-            publishTime: Date.now(),
-          });
-          coinPrices[coinName] = price;
-        }
+        await Promise.allSettled(
+          Array.from(failedRequests.values()).map(async (coinName) => {
+            const price = await this._query.getPriceFromPyth(coinName);
+            this._priceMap.set(coinName, {
+              price: price,
+              publishTime: Date.now(),
+            });
+            coinPrices[coinName] = price;
+          })
+        );
       }
     }
 

package/src/queries/borrowIncentiveQuery.ts

@@ -1,6 +1,5 @@
 import { normalizeStructTag } from '@mysten/sui.js/utils';
 import {
-  IS_VE_SCA_TEST,
   SUPPORT_BORROW_INCENTIVE_POOLS,
   SUPPORT_BORROW_INCENTIVE_REWARDS,
 } from '../constants';
@@ -208,9 +207,7 @@ export const getBindedObligationId = async (
 ): Promise<string | null> => {
   const borrowIncentiveObjectId = query.address.get('borrowIncentive.object');
   const incentivePoolsId = query.address.get('borrowIncentive.incentivePools');
-  const veScaPkgId = IS_VE_SCA_TEST
-    ? '0xb220d034bdf335d77ae5bfbf6daf059c2cc7a1f719b12bfed75d1736fac038c8'
-    : query.address.get('vesca.id');
+  const veScaObjId = query.address.get('vesca.object');
 
   const client = query.suiKit.client();
 
@@ -229,7 +226,7 @@ export const getBindedObligationId = async (
     .id as string;
 
   // check if veSca is inside the bind table
-  const keyType = `${borrowIncentiveObjectId}::typed_id::TypedID<${veScaPkgId}::ve_sca::VeScaKey>`;
+  const keyType = `${borrowIncentiveObjectId}::typed_id::TypedID<${veScaObjId}::ve_sca::VeScaKey>`;
   const veScaBindTableResponse = await client.getDynamicFieldObject({
     parentId: veScaBindTableId,
     name: {