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

package/src/queries/coreQuery.ts

@@ -1,5 +1,4 @@
 import { normalizeStructTag } from '@mysten/sui.js/utils';
-import BigNumber from 'bignumber.js';
 import {
   SUPPORT_POOLS,
   PROTOCOL_OBJECT_ID,
@@ -32,10 +31,10 @@ import {
   BalanceSheet,
   RiskModel,
   CollateralStat,
-  CoinAmounts,
-  MarketCoinAmounts,
   SupportMarketCoins,
+  OptionalKeys,
 } from '../types';
+import BigNumber from 'bignumber.js';
 
 /**
  * Query market data.
@@ -782,61 +781,16 @@ export const getCoinAmounts = async (
 ) => {
   assetCoinNames = assetCoinNames || [...SUPPORT_POOLS];
   const owner = ownerAddress || query.suiKit.currentAddress();
-  const coinObjectsResponse: SuiObjectResponse[] = [];
-  let hasNextPage = false;
-  let nextCursor: string | null | undefined = null;
-  do {
-    const paginatedCoinObjectsResponse = await query.cache.queryGetOwnedObjects(
-      {
-        owner,
-        filter: {
-          MatchAny: assetCoinNames.map((assetCoinName) => {
-            const coinType = query.utils.parseCoinType(assetCoinName);
-            return { StructType: `0x2::coin::Coin<${coinType}>` };
-          }),
-        },
-        options: {
-          showType: true,
-          showContent: true,
-        },
-        cursor: nextCursor,
-      }
-    );
-
-    coinObjectsResponse.push(...paginatedCoinObjectsResponse.data);
-    if (
-      paginatedCoinObjectsResponse.hasNextPage &&
-      paginatedCoinObjectsResponse.nextCursor
-    ) {
-      hasNextPage = true;
-      nextCursor = paginatedCoinObjectsResponse.nextCursor;
-    } else {
-      hasNextPage = false;
-    }
-  } while (hasNextPage);
+  const assetCoins = {} as OptionalKeys<Record<SupportAssetCoins, number>>;
 
-  const coinAmounts: CoinAmounts = {};
-  const coinObjects = coinObjectsResponse
-    .map((response) => {
-      return response.data;
+  await Promise.allSettled(
+    assetCoinNames.map(async (assetCoinName) => {
+      const marketCoin = await getCoinAmount(query, assetCoinName, owner);
+      assetCoins[assetCoinName] = marketCoin;
     })
-    .filter(
-      (object: any) => object !== undefined && object !== null
-    ) as SuiObjectData[];
-  for (const coinObject of coinObjects) {
-    const type = coinObject.type as string;
-    if (coinObject.content && 'fields' in coinObject.content) {
-      const fields = coinObject.content.fields as any;
-      const poolCoinName =
-        query.utils.parseCoinNameFromType<SupportPoolCoins>(type);
-      if (poolCoinName) {
-        coinAmounts[poolCoinName] = BigNumber(coinAmounts[poolCoinName] ?? 0)
-          .plus(fields.balance)
-          .toNumber();
-      }
-    }
-  }
-  return coinAmounts;
+  );
+
+  return assetCoins;
 };
 
 /**
@@ -854,48 +808,11 @@ export const getCoinAmount = async (
 ) => {
   const owner = ownerAddress || query.suiKit.currentAddress();
   const coinType = query.utils.parseCoinType(assetCoinName);
-  const coinObjectsResponse: SuiObjectResponse[] = [];
-  let hasNextPage = false;
-  let nextCursor: string | null | undefined = null;
-  do {
-    const paginatedCoinObjectsResponse = await query.cache.queryGetOwnedObjects(
-      {
-        owner,
-        filter: { StructType: `0x2::coin::Coin<${coinType}>` },
-        options: {
-          showContent: true,
-        },
-        cursor: nextCursor,
-      }
-    );
-
-    coinObjectsResponse.push(...paginatedCoinObjectsResponse.data);
-    if (
-      paginatedCoinObjectsResponse.hasNextPage &&
-      paginatedCoinObjectsResponse.nextCursor
-    ) {
-      hasNextPage = true;
-      nextCursor = paginatedCoinObjectsResponse.nextCursor;
-    } else {
-      hasNextPage = false;
-    }
-  } while (hasNextPage);
-
-  let coinAmount: number = 0;
-  const coinObjects = coinObjectsResponse
-    .map((response) => {
-      return response.data;
-    })
-    .filter(
-      (object: any) => object !== undefined && object !== null
-    ) as SuiObjectData[];
-  for (const coinObject of coinObjects) {
-    if (coinObject.content && 'fields' in coinObject.content) {
-      const fields = coinObject.content.fields as any;
-      coinAmount = BigNumber(coinAmount).plus(fields.balance).toNumber();
-    }
-  }
-  return coinAmount;
+  const amount = await query.cache.queryGetCoinBalance({
+    owner,
+    coinType: coinType,
+  });
+  return BigNumber(amount).toNumber();
 };
 
 /**
@@ -917,63 +834,20 @@ export const getMarketCoinAmounts = async (
       query.utils.parseMarketCoinName(poolCoinName)
     );
   const owner = ownerAddress || query.suiKit.currentAddress();
-  const marketCoinObjectsResponse: SuiObjectResponse[] = [];
-  let hasNextPage = false;
-  let nextCursor: string | null | undefined = null;
-  do {
-    const paginatedMarketCoinObjectsResponse =
-      await query.cache.queryGetOwnedObjects({
-        owner,
-        filter: {
-          MatchAny: marketCoinNames.map((marketCoinName) => {
-            const marketCoinType =
-              query.utils.parseMarketCoinType(marketCoinName);
-            return { StructType: `0x2::coin::Coin<${marketCoinType}>` };
-          }),
-        },
-        options: {
-          showType: true,
-          showContent: true,
-        },
-        cursor: nextCursor,
-      });
-
-    marketCoinObjectsResponse.push(...paginatedMarketCoinObjectsResponse.data);
-    if (
-      paginatedMarketCoinObjectsResponse.hasNextPage &&
-      paginatedMarketCoinObjectsResponse.nextCursor
-    ) {
-      hasNextPage = true;
-      nextCursor = paginatedMarketCoinObjectsResponse.nextCursor;
-    } else {
-      hasNextPage = false;
-    }
-  } while (hasNextPage);
-
-  const marketCoinAmounts: MarketCoinAmounts = {};
-  const marketCoinObjects = marketCoinObjectsResponse
-    .map((response) => {
-      return response.data;
+  const marketCoins = {} as OptionalKeys<Record<SupportMarketCoins, number>>;
+
+  Promise.allSettled(
+    marketCoinNames.map(async (marketCoinName) => {
+      const marketCoin = await getMarketCoinAmount(
+        query,
+        marketCoinName,
+        owner
+      );
+      marketCoins[marketCoinName] = marketCoin;
     })
-    .filter(
-      (object: any) => object !== undefined && object !== null
-    ) as SuiObjectData[];
-  for (const marketCoinObject of marketCoinObjects) {
-    const marketCoinType = marketCoinObject.type as string;
-    if (marketCoinObject.content && 'fields' in marketCoinObject.content) {
-      const fields = marketCoinObject.content.fields as any;
-      const marketCoinName =
-        query.utils.parseCoinNameFromType<SupportMarketCoins>(marketCoinType);
-      if (marketCoinName) {
-        marketCoinAmounts[marketCoinName] = BigNumber(
-          marketCoinAmounts[marketCoinName] ?? 0
-        )
-          .plus(fields.balance)
-          .toNumber();
-      }
-    }
-  }
-  return marketCoinAmounts;
+  );
+
+  return marketCoins;
 };
 
 /**
@@ -991,47 +865,9 @@ export const getMarketCoinAmount = async (
 ) => {
   const owner = ownerAddress || query.suiKit.currentAddress();
   const marketCoinType = query.utils.parseMarketCoinType(marketCoinName);
-  const marketCoinObjectsResponse: SuiObjectResponse[] = [];
-  let hasNextPage = false;
-  let nextCursor: string | null | undefined = null;
-  do {
-    const paginatedMarketCoinObjectsResponse =
-      await query.cache.queryGetOwnedObjects({
-        owner,
-        filter: { StructType: `0x2::coin::Coin<${marketCoinType}>` },
-        options: {
-          showContent: true,
-        },
-        cursor: nextCursor,
-      });
-
-    marketCoinObjectsResponse.push(...paginatedMarketCoinObjectsResponse.data);
-    if (
-      paginatedMarketCoinObjectsResponse.hasNextPage &&
-      paginatedMarketCoinObjectsResponse.nextCursor
-    ) {
-      hasNextPage = true;
-      nextCursor = paginatedMarketCoinObjectsResponse.nextCursor;
-    } else {
-      hasNextPage = false;
-    }
-  } while (hasNextPage);
-
-  let marketCoinAmount: number = 0;
-  const marketCoinObjects = marketCoinObjectsResponse
-    .map((response) => {
-      return response.data;
-    })
-    .filter(
-      (object: any) => object !== undefined && object !== null
-    ) as SuiObjectData[];
-  for (const marketCoinObject of marketCoinObjects) {
-    if (marketCoinObject.content && 'fields' in marketCoinObject.content) {
-      const fields = marketCoinObject.content.fields as any;
-      marketCoinAmount = BigNumber(marketCoinAmount)
-        .plus(fields.balance)
-        .toNumber();
-    }
-  }
-  return marketCoinAmount;
+  const amount = await query.cache.queryGetCoinBalance({
+    owner,
+    coinType: marketCoinType,
+  });
+  return BigNumber(amount).toNumber();
 };

package/src/queries/index.ts

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

package/src/queries/priceQuery.ts

@@ -1,3 +1,4 @@
+import { SuiObjectData } from '@mysten/sui.js/src/client';
 import type { ScallopQuery } from '../models';
 import type { SupportAssetCoins } from '../types';
 
@@ -10,18 +11,19 @@ import type { SupportAssetCoins } from '../types';
  */
 export const getPythPrice = async (
   query: ScallopQuery,
-  assetCoinName: SupportAssetCoins
+  assetCoinName: SupportAssetCoins,
+  priceFeedObject?: SuiObjectData | null
 ) => {
   const pythFeedObjectId = query.address.get(
     `core.coins.${assetCoinName}.oracle.pyth.feedObject`
   );
-  const priceFeedObjectResponse = await query.cache.queryGetObject(
-    pythFeedObjectId,
-    { showContent: true }
-  );
+  priceFeedObject =
+    priceFeedObject ||
+    (await query.cache.queryGetObject(pythFeedObjectId, { showContent: true }))
+      .data;
 
-  if (priceFeedObjectResponse.data) {
-    const priceFeedPoolObject = priceFeedObjectResponse.data;
+  if (priceFeedObject) {
+    const priceFeedPoolObject = priceFeedObject;
     if (
       priceFeedPoolObject.content &&
       'fields' in priceFeedPoolObject.content
@@ -54,3 +56,42 @@ export const getPythPrice = async (
 
   return 0;
 };
+
+export const getPythPrices = async (
+  query: ScallopQuery,
+  assetCoinNames: SupportAssetCoins[]
+) => {
+  const seen: Record<string, boolean> = {};
+  const pythFeedObjectIds = assetCoinNames
+    .map((assetCoinName) => {
+      const pythFeedObjectId = query.address.get(
+        `core.coins.${assetCoinName}.oracle.pyth.feedObject`
+      );
+      if (seen[pythFeedObjectId]) return null;
+
+      seen[pythFeedObjectId] = true;
+      return pythFeedObjectId;
+    })
+    .filter((item) => !!item) as string[];
+  const priceFeedObjects = await query.cache.queryGetObjects(
+    pythFeedObjectIds,
+    {
+      showContent: true,
+    }
+  );
+
+  return (
+    await Promise.all(
+      priceFeedObjects.map(async (priceFeedObject, idx) => ({
+        coinName: assetCoinNames[idx],
+        price: await getPythPrice(query, assetCoinNames[idx], priceFeedObject),
+      }))
+    )
+  ).reduce(
+    (prev, curr) => {
+      prev[curr.coinName] = curr.price;
+      return prev;
+    },
+    {} as Record<SupportAssetCoins, number>
+  );
+};

package/src/queries/referralQuery.ts

@@ -0,0 +1,27 @@
+import { ScallopQuery } from 'src/models';
+
+/**
+ * Query the veScaKeyId from the referral bindings table using the borrower address
+ * @param query
+ * @returns
+ */
+export const queryVeScaKeyIdFromReferralBindings = async (
+  query: ScallopQuery,
+  refereeAddress: string
+): Promise<string | null> => {
+  const referralBindingTableId = query.address.get('referral.bindingTableId');
+
+  const referralBindResponse = await query.cache.queryGetDynamicFieldObject({
+    parentId: referralBindingTableId,
+    name: {
+      type: 'address',
+      value: refereeAddress,
+    },
+  });
+
+  if (referralBindResponse.data?.content?.dataType !== 'moveObject')
+    return null;
+
+  const fields = referralBindResponse.data.content.fields as any;
+  return fields.value;
+};

package/src/queries/spoolQuery.ts

@@ -133,25 +133,21 @@ export const getSpool = async (
     return spoolIndexer;
   }
 
-  const spoolObjectResponse = await query.suiKit.client().multiGetObjects({
-    ids: [poolId, rewardPoolId],
-    options: {
+  const spoolObjectResponse = await query.cache.queryGetObjects(
+    [poolId, rewardPoolId],
+    {
       showContent: true,
-    },
-  });
+    }
+  );
 
-  if (
-    marketPool &&
-    spoolObjectResponse[0].data &&
-    spoolObjectResponse[1].data
-  ) {
+  if (marketPool && spoolObjectResponse[0] && spoolObjectResponse[1]) {
     const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
     coinPrices =
       coinPrices ||
       (await query.utils.getCoinPrices([coinName, rewardCoinName]));
 
-    const spoolObject = spoolObjectResponse[0].data;
-    const rewardPoolObject = spoolObjectResponse[1].data;
+    const spoolObject = spoolObjectResponse[0];
+    const rewardPoolObject = spoolObjectResponse[1];
     if (spoolObject.content && 'fields' in spoolObject.content) {
       const spoolFields = spoolObject.content.fields as any;
       const parsedSpoolData = parseOriginSpoolData({

package/src/queries/vescaQuery.ts

@@ -1,8 +1,14 @@
 import BigNumber from 'bignumber.js';
 import { Vesca } from '../types';
-import type { SuiObjectResponse, SuiObjectData } from '@mysten/sui.js/client';
+import {
+  type SuiObjectResponse,
+  type SuiObjectData,
+  DevInspectResults,
+} from '@mysten/sui.js/client';
 import type { ScallopQuery } from '../models';
-import { IS_VE_SCA_TEST, MAX_LOCK_DURATION } from 'src/constants';
+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';
 /**
  * Query all owned veSca key.
  *
@@ -15,10 +21,8 @@ export const getVescaKeys = async (
   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 veScaObjId = query.address.get('vesca.object');
+  const veScaKeyType = `${veScaObjId}::ve_sca::VeScaKey`;
   const keyObjectsResponse: SuiObjectResponse[] = [];
   let hasNextPage = false;
   let nextCursor: string | null | undefined = null;
@@ -61,13 +65,18 @@ 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 veScas: (Vesca | undefined)[] = Array(keyObjectId.length).fill(null);
+  const tasks = keyObjectId.map(async (keyId, idx) => {
     const veSca = await getVeSca(query, keyId);
-    if (veSca) veScas.push(veSca);
-  }
+    if (veSca) {
+      veScas[idx] = veSca;
+    }
+  });
+  await Promise.allSettled(tasks);
 
-  return veScas;
+  return veScas
+    .filter(Boolean)
+    .sort((a, b) => a!.currentVeScaBalance - b!.currentVeScaBalance);
 };
 
 /**
@@ -83,9 +92,7 @@ export const getVeSca = async (
   veScaKeyId?: string,
   ownerAddress?: string
 ) => {
-  const tableId = IS_VE_SCA_TEST
-    ? '0xc607241e4a679fe376d1170b2fbe07b64917bfe69100d4825241cda20039d4bd'
-    : query.address.get(`vesca.tableId`);
+  const tableId = query.address.get(`vesca.tableId`);
   veScaKeyId =
     veScaKeyId || (await getVescaKeys(query, ownerAddress))[0].objectId;
 
@@ -128,9 +135,81 @@ export const getVeSca = async (
       lockedScaAmount,
       lockedScaCoin,
       currentVeScaBalance,
-      unlockAt: BigNumber(dynamicFields.unlock_at).toNumber(),
+      unlockAt: BigNumber(dynamicFields.unlock_at * 1000).toNumber(),
     } as Vesca;
   }
 
   return vesca;
 };
+
+/**
+ * Get current total veSca treasury amount.
+ */
+export const getTotalVeScaTreasuryAmount = async (
+  query: ScallopQuery
+): Promise<string> => {
+  const veScaPkgId = query.address.get('vesca.id');
+  const veScaConfig = query.address.get('vesca.config');
+  const veScaTreasury = query.address.get('vesca.treasury');
+
+  // refresh query
+  const refreshQueryTarget = `${veScaPkgId}::treasury::refresh`;
+  const refreshArgs = [veScaConfig, veScaTreasury, SUI_CLOCK_OBJECT_ID];
+
+  // query total veSca amount
+  const veScaAmountQueryTarget = `${veScaPkgId}::treasury::total_ve_sca_amount`;
+  const veScaAmountArgs = [veScaTreasury, SUI_CLOCK_OBJECT_ID];
+
+  // resolve each args
+  const resolvedRefreshArgs = await Promise.all(
+    refreshArgs.map(async (arg) => {
+      if (typeof arg === 'string') {
+        return (await query.cache.queryGetObject(arg, { showContent: true }))
+          .data;
+      }
+      return arg;
+    })
+  );
+
+  const resolvedVeScaAmountArgs = await Promise.all(
+    veScaAmountArgs.map(async (arg) => {
+      if (typeof arg === 'string') {
+        return (await query.cache.queryGetObject(arg, { showContent: true }))
+          .data;
+      }
+      return arg;
+    })
+  );
+
+  const txb = new SuiTxBlock();
+  // refresh first
+  txb.moveCall(refreshQueryTarget, resolvedRefreshArgs);
+  txb.moveCall(veScaAmountQueryTarget, resolvedVeScaAmountArgs);
+
+  const txBytes = await txb.txBlock.build({
+    client: query.suiKit.client(),
+    onlyTransactionKind: true,
+    protocolConfig: await query.cache.getProtocolConfig(),
+  });
+
+  // return result
+  const res = await query.cache.queryClient.fetchQuery<DevInspectResults>({
+    queryKey: [
+      'getTotalVeScaTreasuryAmount',
+      JSON.stringify([...refreshArgs, ...veScaAmountArgs]),
+    ],
+    queryFn: async () => {
+      return await query.suiKit.inspectTxn(txBytes);
+    },
+    staleTime: 8000,
+  });
+
+  const results = res.results;
+  if (results && results[1].returnValues) {
+    const value = Uint8Array.from(results[1].returnValues[0][0]);
+    const type = results[1].returnValues[0][1];
+    return bcs.de(type, value);
+  }
+
+  return '0';
+};

package/src/types/address.ts

@@ -73,6 +73,7 @@ export interface AddressesInterface {
     id: string;
     adminCap: string;
     object: string;
+    config: string;
     pools: Partial<
       Record<
         SupportStakeMarketCoins,
@@ -94,12 +95,26 @@ export interface AddressesInterface {
   };
   vesca: {
     id: string;
+    object: string;
     adminCap: string;
     tableId: string;
     table: string;
     treasury: string;
     config: string;
   };
+  referral: {
+    id: string;
+    version: string;
+    object: string;
+    adminCap: string;
+    referralBindings: string;
+    bindingTableId: string;
+    referralRevenuePool: string;
+    revenueTableId: string;
+    referralTiers: string;
+    tiersTableId: string;
+    authorizedWitnessList: string;
+  };
 }
 
 type AddressPathsProps<T> = T extends string

package/src/types/builder/core.ts

@@ -57,6 +57,13 @@ export type CoreNormalMethods = {
     amount: SuiTxArg,
     poolCoinName: SupportPoolCoins
   ) => TransactionResult;
+  borrowWithReferral: (
+    obligation: SuiAddressArg,
+    obligationKey: SuiAddressArg,
+    borrowReferral: SuiObjectArg,
+    amount: SuiTxArg,
+    poolCoinName: SupportPoolCoins
+  ) => TransactionResult;
   borrowEntry: (
     obligation: SuiAddressArg,
     obligationKey: SuiAddressArg,
@@ -97,6 +104,13 @@ export type CoreQuickMethods = {
     obligationId?: SuiAddressArg,
     obligationKey?: SuiAddressArg
   ) => Promise<TransactionResult>;
+  borrowWithReferralQuick: (
+    amount: number,
+    poolCoinName: SupportPoolCoins,
+    borrowReferral: SuiObjectArg,
+    obligationId?: SuiAddressArg,
+    obligationKey?: SuiAddressArg
+  ) => Promise<TransactionResult>;
   depositQuick: (
     amount: number,
     poolCoinName: SupportPoolCoins

package/src/types/builder/index.ts

@@ -2,6 +2,7 @@ import type { CoreTxBlock } from './core';
 import type { SpoolTxBlock } from './spool';
 import type { BorrowIncentiveTxBlock } from './borrowIncentive';
 import type { VeScaTxBlock } from './vesca';
+import type { ReferralTxBlock } from './referral';
 
 export type * from './core';
 export type * from './spool';
@@ -10,5 +11,6 @@ export type * from './vesca';
 
 export type ScallopTxBlock = CoreTxBlock &
   SpoolTxBlock &
+  ReferralTxBlock &
   BorrowIncentiveTxBlock &
   VeScaTxBlock;

package/src/types/builder/referral.ts

@@ -0,0 +1,51 @@
+import {
+  SuiObjectArg,
+  TransactionResult,
+  SuiTxBlock as SuiKitTxBlock,
+} from '@scallop-io/sui-kit';
+import { ScallopBuilder } from 'src/models';
+import { SupportPoolCoins } from '../constant';
+
+export type ReferralIds = {
+  referralPgkId: string;
+  referralBindings: string;
+  referralRevenuePool: string;
+  referralTiers: string;
+  authorizedWitnessList: string;
+  version: string;
+};
+
+export type ReferralNormalMethods = {
+  bindToReferral: (veScaKeyId: string) => void;
+  claimReferralTicket: (poolCoinName: SupportPoolCoins) => TransactionResult;
+  burnReferralTicket: (
+    ticket: SuiObjectArg,
+    poolCoinName: SupportPoolCoins
+  ) => void;
+  claimReferralRevenue: (
+    veScaKey: SuiObjectArg,
+    poolCoinName: SupportPoolCoins
+  ) => TransactionResult;
+};
+
+export type ReferralQuickMethods = {
+  claimReferralRevenueQuick: (
+    veScaKey: SuiObjectArg,
+    coinNames: SupportPoolCoins[]
+  ) => Promise<void>;
+};
+
+export type SuiTxBlockWithReferralNormalMethods = SuiKitTxBlock &
+  ReferralNormalMethods;
+export type ReferralTxBlock = SuiTxBlockWithReferralNormalMethods &
+  ReferralQuickMethods;
+
+export type GenerateReferralNormalMethod = (params: {
+  builder: ScallopBuilder;
+  txBlock: SuiKitTxBlock;
+}) => ReferralNormalMethods;
+
+export type GenerateReferralQuickMethod = (params: {
+  builder: ScallopBuilder;
+  txBlock: SuiTxBlockWithReferralNormalMethods;
+}) => ReferralQuickMethods;