@scallop-io/sui-scallop-sdk 0.46.39 → 0.46.41

package/src/queries/portfolioQuery.ts

@@ -24,6 +24,7 @@ import type {
   TotalValueLocked,
   SupportBorrowIncentiveCoins,
   ObligationBorrowIcentiveReward,
+  SupportBorrowIncentiveRewardCoins,
 } from '../types';
 
 /**
@@ -118,6 +119,7 @@ export const getLending = async (
   stakeAccounts?: StakeAccount[],
   coinAmount?: number,
   marketCoinAmount?: number,
+  sCoinAmount?: number,
   coinPrice?: number
 ) => {
   const marketCoinName = query.utils.parseMarketCoinName(poolCoinName);
@@ -140,6 +142,8 @@ export const getLending = async (
   marketCoinAmount =
     marketCoinAmount ||
     (await query.getMarketCoinAmount(marketCoinName, ownerAddress));
+  sCoinAmount =
+    sCoinAmount || (await query.getSCoinAmount(marketCoinName, ownerAddress));
   coinPrice =
     coinPrice ||
     (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
@@ -206,9 +210,9 @@ export const getLending = async (
   }
 
   // Handle supplied coin
-  const suppliedAmount = BigNumber(marketCoinAmount).multipliedBy(
-    marketPool?.conversionRate ?? 1
-  );
+  const suppliedAmount = BigNumber(marketCoinAmount)
+    .plus(BigNumber(sCoinAmount))
+    .multipliedBy(marketPool?.conversionRate ?? 1);
   const suppliedCoin = suppliedAmount.shiftedBy(-1 * coinDecimal);
   const suppliedValue = suppliedCoin.multipliedBy(coinPrice ?? 0);
 
@@ -351,6 +355,7 @@ export const getObligationAccount = async (
   let totalBorrowCapacityValue = BigNumber(0);
   let totalRequiredCollateralValue = BigNumber(0);
   let totalBorrowedPools = 0;
+  let totalRewardedPools = 0;
   let totalBorrowedValue = BigNumber(0);
   let totalBorrowedValueWithWeight = BigNumber(0);
 
@@ -555,6 +560,22 @@ export const getObligationAccount = async (
         }
       }
 
+      if (
+        Object.keys(borrowIncentivePool.points).some((coinName: any) => {
+          const rewardApr =
+            borrowIncentivePool.points[
+              coinName as SupportBorrowIncentiveRewardCoins
+            ]?.rewardApr;
+          return (
+            rewardApr !== Infinity &&
+            typeof rewardApr == 'number' &&
+            rewardApr > 0
+          );
+        }) &&
+        borrowIncentiveAccount.debtAmount > 0
+      ) {
+        totalRewardedPools++;
+      }
       borrowIncentives[coinName] = {
         coinName: borrowIncentivePool.coinName,
         coinType: borrowIncentivePool.coinType,
@@ -612,6 +633,7 @@ export const getObligationAccount = async (
     totalRiskLevel: riskLevel.toNumber(),
     totalDepositedPools,
     totalBorrowedPools,
+    totalRewardedPools,
     collaterals,
     debts,
     borrowIncentives,

package/src/queries/sCoinQuery.ts

@@ -0,0 +1,94 @@
+import { bcs } from '@mysten/sui.js/bcs';
+import assert from 'assert';
+import BigNumber from 'bignumber.js';
+import { SUPPORT_SCOIN } from 'src/constants';
+import { ScallopQuery } from 'src/models';
+import { OptionalKeys, SupportSCoin, sCoinBalance } from 'src/types';
+
+/**
+ * Get total supply of sCoin
+ * @param query
+ * @param sCoinName
+ * @returns `number`
+ */
+export const getSCoinTotalSupply = async (
+  query: ScallopQuery,
+  sCoinName: SupportSCoin
+): Promise<sCoinBalance> => {
+  const sCoinPkgId = query.address.get('scoin.id');
+  // get treasury
+  const args = [query.utils.getSCoinTreasury(sCoinName)];
+  const typeArgs = [
+    query.utils.parseSCoinType(sCoinName),
+    query.utils.parseUnderlyingSCoinType(sCoinName),
+  ];
+  const queryTarget = `${sCoinPkgId}::s_coin_converter::total_supply`;
+  const queryResults = await query.cache.queryInspectTxn({
+    queryTarget,
+    args,
+    typeArgs,
+  });
+  const results = queryResults.results;
+  if (results && results[0].returnValues) {
+    const value = Uint8Array.from(results[0].returnValues[0][0]);
+    const type = results[0].returnValues[0][1]; // should be u64
+    assert(type === 'u64', 'Result type is not u64');
+
+    return BigNumber(bcs.de(type, value))
+      .shiftedBy(
+        query.utils.getCoinDecimal(query.utils.parseCoinName(sCoinName))
+      )
+      .toNumber();
+  }
+
+  return 0;
+};
+
+/**
+ * Query all owned sCoin amount.
+ *
+ * @param query - The Scallop query instance.
+ * @param sCoinNames - Specific an array of support sCoin name.
+ * @param ownerAddress - The owner address.
+ * @return All owned sCoins amount.
+ */
+export const getSCoinAmounts = async (
+  query: ScallopQuery,
+  sCoinNames?: SupportSCoin[],
+  ownerAddress?: string
+) => {
+  sCoinNames = sCoinNames || [...SUPPORT_SCOIN];
+  const owner = ownerAddress || query.suiKit.currentAddress();
+  const sCoins = {} as OptionalKeys<Record<SupportSCoin, number>>;
+
+  await Promise.allSettled(
+    sCoinNames.map(async (sCoinName) => {
+      const sCoin = await getSCoinAmount(query, sCoinName, owner);
+      sCoins[sCoinName] = sCoin;
+    })
+  );
+
+  return sCoins;
+};
+
+/**
+ * Query owned sCoin amount.
+ *
+ * @param query - The Scallop query instance.
+ * @param sCoinNames - Specific support sCoin name.
+ * @param ownerAddress - The owner address.
+ * @return Owned sCoin amount.
+ */
+export const getSCoinAmount = async (
+  query: ScallopQuery,
+  sCoinName: SupportSCoin,
+  ownerAddress?: string
+) => {
+  const owner = ownerAddress || query.suiKit.currentAddress();
+  const sCoinType = query.utils.parseSCoinType(sCoinName);
+  const amount = await query.cache.queryGetCoinBalance({
+    owner,
+    coinType: sCoinType,
+  });
+  return BigNumber(amount).toNumber();
+};

package/src/queries/vescaQuery.ts

@@ -244,7 +244,6 @@ export const getVeScaTreasuryInfo = async (
   const treasuryFields = veScaTreasury.data.content
     .fields as VeScaTreasuryFields;
 
-  console.log(treasuryFields);
   const totalLockedSca = BigNumber(
     treasuryFields.unlock_schedule.fields.locked_sca_amount
   )

package/src/test.ts

@@ -0,0 +1,19 @@
+import { Scallop } from './models';
+import * as dotenv from 'dotenv';
+dotenv.config();
+const scallop = new Scallop({
+  secretKey: process.env.SECRET_KEY as string,
+});
+
+const main = async () => {
+  const query = await scallop.createScallopQuery();
+
+  const res = await query.getVeScas(
+    '0xd1a70cfe7332e994a950b9c570e93def4b6d2ec53b34ff5c0cc9946226a7cf3d'
+  );
+  console.dir(res, { depth: null });
+};
+main()
+  .then()
+  .catch(console.error)
+  .finally(() => process.exit(0));

package/src/types/address.ts

@@ -3,6 +3,7 @@ import type {
   SupportAssetCoins,
   SupportOracleType,
   SupportPackageType,
+  SupportSCoin,
   SupportStakeMarketCoins,
 } from './constant';
 
@@ -121,6 +122,18 @@ export interface AddressesInterface {
     rewardPool: string;
     userRewardTableId: string;
   };
+  scoin: {
+    id: string;
+    coins: Partial<
+      Record<
+        SupportSCoin,
+        {
+          coinType: string;
+          treasury: string;
+        }
+      >
+    >;
+  };
 }
 
 type AddressPathsProps<T> = T extends string

package/src/types/builder/core.ts

@@ -4,13 +4,17 @@ import type {
   SuiObjectArg,
   SuiTxArg,
 } from '@scallop-io/sui-kit';
-import type { TransactionResult } from '@mysten/sui.js/transactions';
+import type {
+  TransactionArgument,
+  TransactionResult,
+} from '@mysten/sui.js/transactions';
 import type { ScallopBuilder } from '../../models';
 import type {
   SupportCollateralCoins,
   SupportPoolCoins,
   SupportAssetCoins,
 } from '../constant';
+import { ScallopTxBlockWithoutCoreTxBlock } from '.';
 
 export type CoreIds = {
   protocolPkg: string;
@@ -20,8 +24,16 @@ export type CoreIds = {
   xOracle: string;
 };
 
+export type NestedResult = Extract<
+  TransactionArgument,
+  { kind: 'NestedResult' }
+>;
+type Obligation = NestedResult;
+type ObligationKey = NestedResult;
+type ObligationHotPotato = NestedResult;
+
 export type CoreNormalMethods = {
-  openObligation: () => TransactionResult;
+  openObligation: () => [Obligation, ObligationKey, ObligationHotPotato];
   returnObligation: (
     obligation: SuiAddressArg,
     obligationHotPotato: SuiObjectArg
@@ -113,7 +125,8 @@ export type CoreQuickMethods = {
   ) => Promise<TransactionResult>;
   depositQuick: (
     amount: number,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: SupportPoolCoins,
+    returnSCoin?: boolean
   ) => Promise<TransactionResult>;
   withdrawQuick: (
     amount: number,
@@ -129,7 +142,9 @@ export type CoreQuickMethods = {
   ) => Promise<void>;
 };
 
-export type SuiTxBlockWithCoreNormalMethods = SuiKitTxBlock & CoreNormalMethods;
+export type SuiTxBlockWithCoreNormalMethods = SuiKitTxBlock &
+  ScallopTxBlockWithoutCoreTxBlock &
+  CoreNormalMethods;
 
 export type CoreTxBlock = SuiTxBlockWithCoreNormalMethods & CoreQuickMethods;
 

package/src/types/builder/index.ts

@@ -4,16 +4,24 @@ import type { BorrowIncentiveTxBlock } from './borrowIncentive';
 import type { VeScaTxBlock } from './vesca';
 import type { ReferralTxBlock } from './referral';
 import { LoyaltyProgramTxBlock } from './loyaltyProgram';
+import { SCoinTxBlock } from './sCoin';
 
 export type * from './core';
 export type * from './spool';
 export type * from './borrowIncentive';
 export type * from './vesca';
 export type * from './loyaltyProgram';
+export type * from './sCoin';
 
-export type ScallopTxBlock = CoreTxBlock &
-  SpoolTxBlock &
-  ReferralTxBlock &
+export type BaseScallopTxBlock = ReferralTxBlock &
   LoyaltyProgramTxBlock &
   BorrowIncentiveTxBlock &
   VeScaTxBlock;
+
+export type ScallopTxBlockWithoutSCoinTxBlock = SpoolTxBlock &
+  BaseScallopTxBlock;
+
+export type ScallopTxBlockWithoutCoreTxBlock = SCoinTxBlock &
+  ScallopTxBlockWithoutSCoinTxBlock;
+
+export type ScallopTxBlock = CoreTxBlock & ScallopTxBlockWithoutCoreTxBlock;

package/src/types/builder/sCoin.ts

@@ -0,0 +1,61 @@
+import {
+  SuiObjectArg,
+  SuiTxBlock as SuiKitTxBlock,
+  TransactionResult,
+} from '@scallop-io/sui-kit';
+import { SupportSCoin } from '../constant';
+import { ScallopBuilder } from 'src/models';
+import { ScallopTxBlockWithoutSCoinTxBlock } from '.';
+
+export type sCoinPkgIds = {
+  pkgId: string;
+};
+
+export type sCoinNormalMethods = {
+  /**
+   * Lock marketCoin and return sCoin
+   * @param marketCoinName
+   * @param marketCoin
+   * @returns
+   */
+  mintSCoin: (
+    marketCoinName: SupportSCoin,
+    marketCoin: SuiObjectArg
+  ) => TransactionResult;
+  /**
+   * Burn sCoin and return marketCoin
+   * @param sCoinName
+   * @param sCoin
+   * @returns
+   */
+  burnSCoin: (
+    sCoinName: SupportSCoin,
+    sCoin: SuiObjectArg
+  ) => TransactionResult; // returns marketCoin
+};
+
+export type sCoinQuickMethods = {
+  mintSCoinQuick: (
+    marketCoinName: SupportSCoin,
+    amount: number
+  ) => Promise<TransactionResult>;
+  burnSCoinQuick: (
+    sCoinName: SupportSCoin,
+    amount: number
+  ) => Promise<TransactionResult>;
+};
+
+export type SuiTxBlockWithSCoinNormalMethods = SuiKitTxBlock &
+  ScallopTxBlockWithoutSCoinTxBlock &
+  sCoinNormalMethods;
+export type SCoinTxBlock = SuiTxBlockWithSCoinNormalMethods & sCoinQuickMethods;
+
+export type GenerateSCoinNormalMethod = (params: {
+  builder: ScallopBuilder;
+  txBlock: SuiKitTxBlock;
+}) => sCoinNormalMethods;
+
+export type GenerateSCoinQuickMethod = (params: {
+  builder: ScallopBuilder;
+  txBlock: SuiTxBlockWithSCoinNormalMethods;
+}) => sCoinQuickMethods;

package/src/types/builder/spool.ts

@@ -7,6 +7,7 @@ import type {
 import type { TransactionResult } from '@mysten/sui.js/transactions';
 import type { ScallopBuilder } from '../../models';
 import type { SupportStakeMarketCoins } from '../constant';
+import { BaseScallopTxBlock } from '.';
 
 export type SpoolIds = {
   spoolPkg: string;
@@ -50,6 +51,7 @@ export type SpoolQuickMethods = {
 };
 
 export type SuiTxBlockWithSpoolNormalMethods = SuiKitTxBlock &
+  BaseScallopTxBlock &
   SpoolNormalMethods;
 
 export type SpoolTxBlock = SuiTxBlockWithSpoolNormalMethods & SpoolQuickMethods;

package/src/types/constant/common.ts

@@ -7,6 +7,7 @@ import {
   SUPPORT_SPOOLS_REWARDS,
   SUPPORT_BORROW_INCENTIVE_POOLS,
   SUPPORT_BORROW_INCENTIVE_REWARDS,
+  SUPPORT_SCOIN,
 } from '../../constants';
 
 type ParseMarketCoins<T extends string> = `s${T}`;
@@ -15,7 +16,8 @@ type ParseCoins<T extends string> = T extends `s${infer R}` ? R : never;
 export type SupportCoins =
   | SupportAssetCoins
   | SupportMarketCoins
-  | SupportStakeMarketCoins;
+  | SupportStakeMarketCoins
+  | SupportSCoin;
 export type SupportAssetCoins =
   | SupportPoolCoins
   | SupportCollateralCoins
@@ -36,6 +38,7 @@ export type SupportBorrowIncentiveCoins =
   (typeof SUPPORT_BORROW_INCENTIVE_POOLS)[number];
 export type SupportBorrowIncentiveRewardCoins =
   (typeof SUPPORT_BORROW_INCENTIVE_REWARDS)[number];
+export type SupportSCoin = (typeof SUPPORT_SCOIN)[number];
 
 export type SupportOracleType = (typeof SUPPORT_ORACLES)[number];
 

package/src/types/constant/enum.ts

@@ -6,6 +6,7 @@ import {
   SupportStakeRewardCoins,
   SupportBorrowIncentiveCoins,
   SupportBorrowIncentiveRewardCoins,
+  SupportSCoin,
 } from './common';
 
 export type Coins = {
@@ -20,6 +21,10 @@ export type MarketCoins = {
   [K in SupportMarketCoins]: K;
 };
 
+export type SCoins = {
+  [K in SupportSCoin]: K;
+};
+
 export type StakeMarketCoins = {
   [K in SupportStakeMarketCoins]: K;
 };
@@ -36,6 +41,18 @@ export type AssetCoinIds = {
   [key in SupportAssetCoins]: string;
 };
 
+export type SCoinIds = {
+  [key in SupportSCoin]: string;
+};
+
+export type SCoinTreasuryCaps = {
+  [key in SupportSCoin]: string;
+};
+
+export type SCoinConverterTreasury = {
+  [key in SupportSCoin]: string;
+};
+
 type PickFromUnion<T, K extends string> = K extends T ? K : never;
 
 export type WormholeCoinIds = {

package/src/types/query/core.ts

@@ -3,6 +3,7 @@ import type {
   SupportCollateralCoins,
   SupportMarketCoins,
   CoinWrappedType,
+  SupportSCoin,
 } from '../constant';
 
 type OptionalKeys<T> = {
@@ -18,6 +19,8 @@ export type MarketCoinAmounts = OptionalKeys<
   Record<SupportMarketCoins, number>
 >;
 
+export type SCoinAmounts = OptionalKeys<Record<SupportSCoin, number>>;
+
 export type BalanceSheet = {
   cash: string;
   debt: string;

package/src/types/query/index.ts

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

package/src/types/query/portfolio.ts

@@ -69,6 +69,7 @@ export type ObligationAccount = {
   totalRiskLevel: number;
   totalDepositedPools: number;
   totalBorrowedPools: number;
+  totalRewardedPools: number;
   collaterals: OptionalKeys<
     Record<SupportCollateralCoins, ObligationCollateral>
   >;

package/src/types/query/sCoin.ts

@@ -0,0 +1 @@
+export type sCoinBalance = number;

package/src/utils/builder.ts

@@ -52,7 +52,7 @@ export const checkExtendLockPeriod = (
     (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 ${

package/src/utils/util.ts

@@ -5,6 +5,7 @@ import {
   SUPPORT_SPOOLS_REWARDS,
   MAX_LOCK_DURATION,
   SUPPORT_BORROW_INCENTIVE_REWARDS,
+  SUPPORT_SCOIN,
 } from '../constants';
 import type { ScallopAddress } from '../models';
 import type {
@@ -13,20 +14,22 @@ import type {
   SupportMarketCoins,
 } from '../types';
 
+const COIN_SET = Array.from(
+  new Set([
+    ...SUPPORT_POOLS,
+    ...SUPPORT_COLLATERALS,
+    ...SUPPORT_SPOOLS_REWARDS,
+    ...SUPPORT_BORROW_INCENTIVE_REWARDS,
+    ...SUPPORT_SCOIN,
+  ])
+);
+
 export const isMarketCoin = (
   coinName: SupportCoins
 ): coinName is SupportMarketCoins => {
   const assetCoinName = coinName.slice(1).toLowerCase() as SupportAssetCoins;
   return (
-    coinName.charAt(0).toLowerCase() === 's' &&
-    [
-      ...new Set([
-        ...SUPPORT_POOLS,
-        ...SUPPORT_COLLATERALS,
-        ...SUPPORT_SPOOLS_REWARDS,
-        ...SUPPORT_BORROW_INCENTIVE_REWARDS,
-      ]),
-    ].includes(assetCoinName)
+    coinName.charAt(0).toLowerCase() === 's' && COIN_SET.includes(assetCoinName)
   );
 };
 
@@ -54,14 +57,7 @@ export const parseDataFromPythPriceFeed = (
   feed: PriceFeed,
   address: ScallopAddress
 ) => {
-  const assetCoinNames = [
-    ...new Set([
-      ...SUPPORT_POOLS,
-      ...SUPPORT_COLLATERALS,
-      ...SUPPORT_SPOOLS_REWARDS,
-      ...SUPPORT_BORROW_INCENTIVE_REWARDS,
-    ]),
-  ] as SupportAssetCoins[];
+  const assetCoinNames = COIN_SET as SupportAssetCoins[];
   const assetCoinName = assetCoinNames.find((assetCoinName) => {
     return (
       address.get(`core.coins.${assetCoinName}.oracle.pyth.feed`) === feed.id