@suilend/sdk 2.0.4 → 2.0.6

package/client.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { SUI_CLOCK_OBJECT_ID, SUI_SYSTEM_STATE_OBJECT_ID, fromBase64, normalizeStructTag, toHex, } from "@mysten/sui/utils";
 import { SuiPriceServiceConnection, SuiPythClient, } from "@pythnetwork/pyth-sui-js";
-import { extractCTokenCoinType, getAllCoins, mergeAllCoins, } from "@suilend/sui-fe";
+import { extractCTokenCoinType, getAllCoins, getSpendableCoin, } from "@suilend/sui-fe";
 import { PriceInfoObject } from "./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-info/structs";
 import { phantom } from "./_generated/_framework/reified";
 import { PKG_V10, setPublishedAt } from "./_generated/suilend";
@@ -221,16 +221,7 @@ export class SuilendClient {
     }
     addReward(ownerId_1, lendingMarketOwnerCapId_1, reserveArrayIndex_1, isDepositReward_1, rewardCoinType_1, rewardValue_1, startTimeMs_1, endTimeMs_1, transaction_1) {
         return __awaiter(this, arguments, void 0, function* (ownerId, lendingMarketOwnerCapId, reserveArrayIndex, isDepositReward, rewardCoinType, rewardValue, startTimeMs, endTimeMs, transaction, mergeCoins = true) {
-            const coins = (yield this.client.getCoins({
-                owner: ownerId,
-                coinType: rewardCoinType,
-            })).data;
-            if (coins.length > 1 && !isSui(rewardCoinType) && mergeCoins) {
-                transaction.mergeCoins(transaction.object(coins[0].coinObjectId), coins.map((c) => transaction.object(c.coinObjectId)).slice(1));
-            }
-            const [rewardCoin] = transaction.splitCoins(isSui(rewardCoinType)
-                ? transaction.gas
-                : transaction.object(coins[0].coinObjectId), [rewardValue]);
+            const rewardCoin = yield getSpendableCoin(this.client, ownerId, rewardCoinType, rewardValue, transaction);
             return addPoolReward(transaction, [this.lendingMarket.$typeArgs[0], rewardCoinType], {
                 lendingMarketOwnerCap: transaction.object(lendingMarketOwnerCapId),
                 lendingMarket: transaction.object(this.lendingMarket.id),
@@ -454,21 +445,13 @@ export class SuilendClient {
     }
     depositIntoObligation(ownerId, coinType, value, transaction, obligationOwnerCap) {
         return __awaiter(this, void 0, void 0, function* () {
-            const coins = yield getAllCoins(this.client, ownerId, coinType);
-            const mergeCoin = mergeAllCoins(coinType, transaction, coins);
-            const [sendCoin] = transaction.splitCoins(isSui(coinType)
-                ? transaction.gas
-                : transaction.object(mergeCoin.coinObjectId), [value]);
+            const sendCoin = yield getSpendableCoin(this.client, ownerId, coinType, value, transaction);
             this.deposit(sendCoin, coinType, obligationOwnerCap, transaction);
         });
     }
     depositLiquidityAndGetCTokens(ownerId, coinType, value, transaction) {
         return __awaiter(this, void 0, void 0, function* () {
-            const coins = yield getAllCoins(this.client, ownerId, coinType);
-            const mergeCoin = mergeAllCoins(coinType, transaction, coins);
-            const [sendCoin] = transaction.splitCoins(isSui(coinType)
-                ? transaction.gas
-                : transaction.object(mergeCoin.coinObjectId), [value]);
+            const sendCoin = yield getSpendableCoin(this.client, ownerId, coinType, value, transaction);
             const [ctokens] = depositLiquidityAndMintCtokens(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
                 lendingMarket: transaction.object(this.lendingMarket.id),
                 reserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
@@ -578,11 +561,7 @@ export class SuilendClient {
     }
     repayIntoObligation(ownerId, obligationId, coinType, value, transaction) {
         return __awaiter(this, void 0, void 0, function* () {
-            const coins = yield getAllCoins(this.client, ownerId, coinType);
-            const mergeCoin = mergeAllCoins(coinType, transaction, coins);
-            const [sendCoin] = transaction.splitCoins(isSui(coinType)
-                ? transaction.gas
-                : transaction.object(mergeCoin.coinObjectId), [value]);
+            const sendCoin = yield getSpendableCoin(this.client, ownerId, coinType, value, transaction);
             const result = this.repay(obligationId, coinType, sendCoin, transaction);
             transaction.transferObjects([sendCoin], transaction.pure.address(ownerId));
             return result;
@@ -637,13 +616,12 @@ export class SuilendClient {
     }
     redeemCtokensAndWithdrawLiquidity(ownerId, ctokenCoinTypes, transaction) {
         return __awaiter(this, void 0, void 0, function* () {
-            const mergeCoinMap = {};
             for (const ctokenCoinType of ctokenCoinTypes) {
                 const coins = yield getAllCoins(this.client, ownerId, ctokenCoinType);
-                const mergeCoin = mergeAllCoins(ctokenCoinType, transaction, coins);
-                mergeCoinMap[ctokenCoinType] = mergeCoin;
-            }
-            for (const [ctokenCoinType, mergeCoin] of Object.entries(mergeCoinMap)) {
+                const totalBalance = coins.reduce((sum, c) => sum + BigInt(c.balance), BigInt(0));
+                if (totalBalance === BigInt(0))
+                    throw new Error(`No ${ctokenCoinType} coins found for redeem`);
+                const ctokenCoin = yield getSpendableCoin(this.client, ownerId, ctokenCoinType, totalBalance.toString(), transaction);
                 const coinType = extractCTokenCoinType(ctokenCoinType);
                 const [exemption] = transaction.moveCall({
                     target: `0x1::option::none`,
@@ -652,7 +630,7 @@ export class SuilendClient {
                     ],
                     arguments: [],
                 });
-                const [redeemCoin] = this.redeem(transaction.object(mergeCoin.coinObjectId), coinType, exemption, transaction);
+                const [redeemCoin] = this.redeem(ctokenCoin, coinType, exemption, transaction);
                 transaction.transferObjects([redeemCoin], transaction.pure.address(ownerId));
             }
         });

package/lib/initialize.js

@@ -16,7 +16,7 @@ import { parseLendingMarket, parseObligation } from "../parsers";
 import * as simulate from "../utils/simulate";
 import { WAD } from "./constants";
 import { getWorkingPythEndpoint } from "./pyth";
-import { STRATEGY_WRAPPER_PACKAGE_ID_V1, } from "./strategyOwnerCap";
+import { STRATEGY_TYPE_INFO_MAP, STRATEGY_WRAPPER_PACKAGE_ID_V1, } from "./strategyOwnerCap";
 export const RESERVES_CUSTOM_ORDER = {
     [LENDING_MARKET_ID]: [
         // MAIN ASSETS
@@ -232,8 +232,9 @@ export const initializeObligations = (suiClient, suilendClient, refreshedRawRese
         };
     const [strategyOwnerCaps, obligationOwnerCaps] = yield Promise.all([
         (() => __awaiter(void 0, void 0, void 0, function* () {
-            if (suilendClient.lendingMarket.id !== LENDING_MARKET_ID)
-                return []; // Only main lending market has strategy owner caps
+            const hasStrategies = Object.values(STRATEGY_TYPE_INFO_MAP).some((info) => info.lendingMarketId === suilendClient.lendingMarket.id);
+            if (!hasStrategies)
+                return [];
             const objects = yield getAllOwnedObjects(suiClient, address, {
                 StructType: `${STRATEGY_WRAPPER_PACKAGE_ID_V1}::strategy_wrapper::StrategyOwnerCap<${suilendClient.lendingMarket.$typeArgs[0]}>`,
             });

package/lib/strategyOwnerCap.d.ts

@@ -1,22 +1,27 @@
 import { AggregatorClient as CetusSdk } from "@cetusprotocol/aggregator-sdk";
-import { Transaction, TransactionObjectInput, TransactionResult } from "@mysten/sui/transactions";
+import { Transaction, TransactionObjectArgument, TransactionObjectInput, TransactionResult } from "@mysten/sui/transactions";
 import BigNumber from "bignumber.js";
 import { ParsedObligation, ParsedReserve } from "../parsers";
 import { RewardsMap, StrategyOwnerCap } from "./types";
 export declare const STRATEGY_WRAPPER_PACKAGE_ID_V1 = "0xba97dc73a07638d03d77ad2161484eb21db577edc9cadcd7035fef4b4f2f6fa1";
 export declare enum StrategyType {
     sSUI_SUI_LOOPING = "1",
-    stratSUI_SUI_LOOPING = "2",
     USDC_sSUI_SUI_LOOPING = "3",
+    USDsui_USDC_LOOPING = "10",
+    eEARN_USDC_LOOPING = "11",
     AUSD_sSUI_SUI_LOOPING = "4",
     xBTC_sSUI_SUI_LOOPING = "100",// Used to be for Slush Strategies #0
     xBTC_suiWBTC_LOOPING = "101",// Used to be for Slush Strategies #1
     suiUSDT_sSUI_SUI_LOOPING = "5",
     AUSD_USDC_LOOPING = "6",
     AUSD_suiUSDT_LOOPING = "7",
-    USDC_suiUSDT_LOOPING = "8"
+    USDC_suiUSDT_LOOPING = "8",
+    USDsui_sSUI_SUI_LOOPING = "9",
+    stratSUI_SUI_LOOPING = "2"
 }
 export declare const STRATEGY_TYPE_INFO_MAP: Record<StrategyType, {
+    lendingMarketId: string;
+    lendingMarketType: string;
     queryParam: string;
     header: {
         coinTypes: string[];
@@ -30,10 +35,10 @@ export declare const STRATEGY_TYPE_INFO_MAP: Record<StrategyType, {
     currencyCoinTypes: string[];
     defaultCurrencyCoinType: string;
 }>;
-export declare const strategyDeposit: (coin: TransactionObjectInput, coinType: string, strategyOwnerCap: TransactionObjectInput, reserveArrayIndex: bigint, transaction: Transaction) => TransactionResult;
-export declare const strategyBorrow: (coinType: string, strategyOwnerCap: TransactionObjectInput, reserveArrayIndex: bigint, value: bigint, transaction: Transaction) => TransactionResult;
-export declare const strategyWithdraw: (coinType: string, strategyOwnerCap: TransactionObjectInput, reserveArrayIndex: bigint, value: bigint, transaction: Transaction) => TransactionResult;
-export declare const strategyClaimRewardsAndSwapForCoinType: (address: string, cetusSdk: CetusSdk, cetusPartnerId: string, rewardsMap: RewardsMap, rewardPriceMap: Record<string, BigNumber | undefined>, depositReserve: ParsedReserve, strategyOwnerCap: TransactionObjectInput, isDepositing: boolean, transaction: Transaction) => Promise<void>;
+export declare const strategyDeposit: (strategyType: StrategyType, coin: TransactionObjectInput, coinType: string, strategyOwnerCap: TransactionObjectInput, reserveArrayIndex: bigint, transaction: Transaction) => TransactionResult;
+export declare const strategyBorrow: (strategyType: StrategyType, coinType: string, strategyOwnerCap: TransactionObjectInput, reserveArrayIndex: bigint, value: bigint, transaction: Transaction) => TransactionResult;
+export declare const strategyWithdraw: (strategyType: StrategyType, coinType: string, strategyOwnerCap: TransactionObjectInput, reserveArrayIndex: bigint, value: bigint, transaction: Transaction) => TransactionResult;
+export declare const strategyClaimRewardsAndMergeCoins: (strategyType: StrategyType, rewardsMap: RewardsMap, strategyOwnerCap: TransactionObjectInput, transaction: Transaction) => Record<string, TransactionObjectArgument>;
 export declare const strategySwapSomeDepositsForCoinType: (strategyType: StrategyType, cetusSdk: CetusSdk, cetusPartnerId: string, obligation: ParsedObligation, noSwapCoinTypes: string[], // coinTypes to not swap for depositReserve.coinType
 swapPercent: BigNumber, // percent of deposit to swap for depositReserve.coinType (0-100)
 depositReserve: ParsedReserve, strategyOwnerCap: TransactionObjectInput, transaction: Transaction) => Promise<void>;

package/lib/strategyOwnerCap.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { SUI_CLOCK_OBJECT_ID, SUI_SYSTEM_STATE_OBJECT_ID, } from "@mysten/sui/utils";
 import BigNumber from "bignumber.js";
 import BN from "bn.js";
-import { MAX_U64, NORMALIZED_AUSD_COINTYPE, NORMALIZED_SUI_COINTYPE, NORMALIZED_USDC_COINTYPE, NORMALIZED_sSUI_COINTYPE, NORMALIZED_stratSUI_COINTYPE, NORMALIZED_suiUSDT_COINTYPE, NORMALIZED_suiWBTC_COINTYPE, NORMALIZED_xBTC_COINTYPE, isSui, } from "@suilend/sui-fe";
+import { MAX_U64, NORMALIZED_AUSD_COINTYPE, NORMALIZED_SUI_COINTYPE, NORMALIZED_USDC_COINTYPE, NORMALIZED_USDsui_COINTYPE, NORMALIZED_eEARN_COINTYPE, NORMALIZED_sSUI_COINTYPE, NORMALIZED_stratSUI_COINTYPE, NORMALIZED_suiUSDT_COINTYPE, NORMALIZED_suiWBTC_COINTYPE, NORMALIZED_xBTC_COINTYPE, isSui, } from "@suilend/sui-fe";
 import { LENDING_MARKET_ID, LENDING_MARKET_TYPE, } from "../client";
 import { Side } from "./types";
 export const STRATEGY_WRAPPER_PACKAGE_ID_V1 = "0xba97dc73a07638d03d77ad2161484eb21db577edc9cadcd7035fef4b4f2f6fa1";
@@ -18,8 +18,9 @@ const STRATEGY_WRAPPER_PACKAGE_ID_V7 = "0x864b66441e95323c320ee7584592769930a2d2
 export var StrategyType;
 (function (StrategyType) {
     StrategyType["sSUI_SUI_LOOPING"] = "1";
-    StrategyType["stratSUI_SUI_LOOPING"] = "2";
     StrategyType["USDC_sSUI_SUI_LOOPING"] = "3";
+    StrategyType["USDsui_USDC_LOOPING"] = "10";
+    StrategyType["eEARN_USDC_LOOPING"] = "11";
     StrategyType["AUSD_sSUI_SUI_LOOPING"] = "4";
     StrategyType["xBTC_sSUI_SUI_LOOPING"] = "100";
     StrategyType["xBTC_suiWBTC_LOOPING"] = "101";
@@ -27,9 +28,13 @@ export var StrategyType;
     StrategyType["AUSD_USDC_LOOPING"] = "6";
     StrategyType["AUSD_suiUSDT_LOOPING"] = "7";
     StrategyType["USDC_suiUSDT_LOOPING"] = "8";
+    StrategyType["USDsui_sSUI_SUI_LOOPING"] = "9";
+    StrategyType["stratSUI_SUI_LOOPING"] = "2";
 })(StrategyType || (StrategyType = {}));
 export const STRATEGY_TYPE_INFO_MAP = {
     [StrategyType.sSUI_SUI_LOOPING]: {
+        lendingMarketId: LENDING_MARKET_ID,
+        lendingMarketType: LENDING_MARKET_TYPE,
         queryParam: "sSUI-SUI-looping",
         header: {
             coinTypes: [NORMALIZED_sSUI_COINTYPE, NORMALIZED_SUI_COINTYPE],
@@ -43,21 +48,9 @@ export const STRATEGY_TYPE_INFO_MAP = {
         currencyCoinTypes: [NORMALIZED_SUI_COINTYPE, NORMALIZED_sSUI_COINTYPE],
         defaultCurrencyCoinType: NORMALIZED_SUI_COINTYPE,
     },
-    [StrategyType.stratSUI_SUI_LOOPING]: {
-        queryParam: "stratSUI-SUI-looping",
-        header: {
-            coinTypes: [NORMALIZED_stratSUI_COINTYPE, NORMALIZED_SUI_COINTYPE],
-            title: "stratSUI/SUI",
-            tooltip: "Sets up a stratSUI/SUI Looping strategy by depositing stratSUI and borrowing SUI to the desired leverage",
-            type: "Looping",
-        },
-        depositBaseCoinType: undefined,
-        depositLstCoinType: NORMALIZED_stratSUI_COINTYPE,
-        borrowCoinType: NORMALIZED_SUI_COINTYPE,
-        currencyCoinTypes: [NORMALIZED_SUI_COINTYPE, NORMALIZED_stratSUI_COINTYPE],
-        defaultCurrencyCoinType: NORMALIZED_SUI_COINTYPE,
-    },
     [StrategyType.USDC_sSUI_SUI_LOOPING]: {
+        lendingMarketId: LENDING_MARKET_ID,
+        lendingMarketType: LENDING_MARKET_TYPE,
         queryParam: "USDC-sSUI-SUI-looping",
         header: {
             coinTypes: [NORMALIZED_USDC_COINTYPE],
@@ -71,7 +64,41 @@ export const STRATEGY_TYPE_INFO_MAP = {
         currencyCoinTypes: [NORMALIZED_USDC_COINTYPE],
         defaultCurrencyCoinType: NORMALIZED_USDC_COINTYPE,
     },
+    [StrategyType.USDsui_USDC_LOOPING]: {
+        lendingMarketId: LENDING_MARKET_ID,
+        lendingMarketType: LENDING_MARKET_TYPE,
+        queryParam: "USDsui-USDC-looping",
+        header: {
+            coinTypes: [NORMALIZED_USDsui_COINTYPE, NORMALIZED_USDC_COINTYPE],
+            title: "USDsui/USDC",
+            tooltip: "Sets up an USDsui/USDC Looping strategy by depositing USDsui and borrowing USDC to the desired leverage",
+            type: "Looping",
+        },
+        depositBaseCoinType: NORMALIZED_USDsui_COINTYPE,
+        depositLstCoinType: undefined,
+        borrowCoinType: NORMALIZED_USDC_COINTYPE,
+        currencyCoinTypes: [NORMALIZED_USDsui_COINTYPE, NORMALIZED_USDC_COINTYPE],
+        defaultCurrencyCoinType: NORMALIZED_USDsui_COINTYPE,
+    },
+    [StrategyType.eEARN_USDC_LOOPING]: {
+        lendingMarketId: "0x74d92cb095b618f344486f77bcce87fbffc0fe0b46584bb1828bb291a222dda8",
+        lendingMarketType: "0x423f05ea163ae1bc5c03d75ef70d3e5d887455084118e46c4f76878530a03619::ember_market::EMBER_MARKET",
+        queryParam: "eEARN-USDC-looping",
+        header: {
+            coinTypes: [NORMALIZED_eEARN_COINTYPE, NORMALIZED_USDC_COINTYPE],
+            title: "eEARN/USDC",
+            tooltip: "Sets up an eEARN/USDC Looping strategy by depositing eEARN and borrowing USDC to the desired leverage",
+            type: "Looping",
+        },
+        depositBaseCoinType: NORMALIZED_eEARN_COINTYPE,
+        depositLstCoinType: undefined,
+        borrowCoinType: NORMALIZED_USDC_COINTYPE,
+        currencyCoinTypes: [NORMALIZED_eEARN_COINTYPE, NORMALIZED_USDC_COINTYPE],
+        defaultCurrencyCoinType: NORMALIZED_eEARN_COINTYPE,
+    },
     [StrategyType.AUSD_sSUI_SUI_LOOPING]: {
+        lendingMarketId: LENDING_MARKET_ID,
+        lendingMarketType: LENDING_MARKET_TYPE,
         queryParam: "AUSD-sSUI-SUI-looping",
         header: {
             coinTypes: [NORMALIZED_AUSD_COINTYPE],
@@ -86,6 +113,8 @@ export const STRATEGY_TYPE_INFO_MAP = {
         defaultCurrencyCoinType: NORMALIZED_AUSD_COINTYPE,
     },
     [StrategyType.xBTC_sSUI_SUI_LOOPING]: {
+        lendingMarketId: LENDING_MARKET_ID,
+        lendingMarketType: LENDING_MARKET_TYPE,
         queryParam: "xBTC-sSUI-SUI-looping",
         header: {
             coinTypes: [NORMALIZED_xBTC_COINTYPE],
@@ -100,6 +129,8 @@ export const STRATEGY_TYPE_INFO_MAP = {
         defaultCurrencyCoinType: NORMALIZED_xBTC_COINTYPE,
     },
     [StrategyType.xBTC_suiWBTC_LOOPING]: {
+        lendingMarketId: LENDING_MARKET_ID,
+        lendingMarketType: LENDING_MARKET_TYPE,
         queryParam: "xBTC-suiWBTC-looping",
         header: {
             coinTypes: [NORMALIZED_xBTC_COINTYPE, NORMALIZED_suiWBTC_COINTYPE],
@@ -114,6 +145,8 @@ export const STRATEGY_TYPE_INFO_MAP = {
         defaultCurrencyCoinType: NORMALIZED_xBTC_COINTYPE,
     },
     [StrategyType.suiUSDT_sSUI_SUI_LOOPING]: {
+        lendingMarketId: LENDING_MARKET_ID,
+        lendingMarketType: LENDING_MARKET_TYPE,
         queryParam: "suiUSDT-sSUI-SUI-looping",
         header: {
             coinTypes: [NORMALIZED_suiUSDT_COINTYPE],
@@ -128,6 +161,8 @@ export const STRATEGY_TYPE_INFO_MAP = {
         defaultCurrencyCoinType: NORMALIZED_suiUSDT_COINTYPE,
     },
     [StrategyType.AUSD_USDC_LOOPING]: {
+        lendingMarketId: LENDING_MARKET_ID,
+        lendingMarketType: LENDING_MARKET_TYPE,
         queryParam: "AUSD-USDC-looping",
         header: {
             coinTypes: [NORMALIZED_AUSD_COINTYPE, NORMALIZED_USDC_COINTYPE],
@@ -142,6 +177,8 @@ export const STRATEGY_TYPE_INFO_MAP = {
         defaultCurrencyCoinType: NORMALIZED_AUSD_COINTYPE,
     },
     [StrategyType.AUSD_suiUSDT_LOOPING]: {
+        lendingMarketId: LENDING_MARKET_ID,
+        lendingMarketType: LENDING_MARKET_TYPE,
         queryParam: "AUSD-suiUSDT-looping",
         header: {
             coinTypes: [NORMALIZED_AUSD_COINTYPE, NORMALIZED_suiUSDT_COINTYPE],
@@ -156,6 +193,8 @@ export const STRATEGY_TYPE_INFO_MAP = {
         defaultCurrencyCoinType: NORMALIZED_AUSD_COINTYPE,
     },
     [StrategyType.USDC_suiUSDT_LOOPING]: {
+        lendingMarketId: LENDING_MARKET_ID,
+        lendingMarketType: LENDING_MARKET_TYPE,
         queryParam: "USDC-suiUSDT-looping",
         header: {
             coinTypes: [NORMALIZED_USDC_COINTYPE, NORMALIZED_suiUSDT_COINTYPE],
@@ -169,66 +208,117 @@ export const STRATEGY_TYPE_INFO_MAP = {
         currencyCoinTypes: [NORMALIZED_USDC_COINTYPE, NORMALIZED_suiUSDT_COINTYPE],
         defaultCurrencyCoinType: NORMALIZED_USDC_COINTYPE,
     },
+    [StrategyType.USDsui_sSUI_SUI_LOOPING]: {
+        lendingMarketId: LENDING_MARKET_ID,
+        lendingMarketType: LENDING_MARKET_TYPE,
+        queryParam: "USDsui-sSUI-SUI-looping",
+        header: {
+            coinTypes: [NORMALIZED_USDsui_COINTYPE],
+            title: "USDsui sSUI/SUI",
+            tooltip: "Sets up a USDsui sSUI/SUI Looping strategy by depositing USDsui and looping sSUI/SUI to the desired leverage",
+            type: "Looping",
+        },
+        depositBaseCoinType: NORMALIZED_USDsui_COINTYPE,
+        depositLstCoinType: NORMALIZED_sSUI_COINTYPE,
+        borrowCoinType: NORMALIZED_SUI_COINTYPE,
+        currencyCoinTypes: [NORMALIZED_USDsui_COINTYPE],
+        defaultCurrencyCoinType: NORMALIZED_USDsui_COINTYPE,
+    },
+    [StrategyType.stratSUI_SUI_LOOPING]: {
+        lendingMarketId: LENDING_MARKET_ID,
+        lendingMarketType: LENDING_MARKET_TYPE,
+        queryParam: "stratSUI-SUI-looping",
+        header: {
+            coinTypes: [NORMALIZED_stratSUI_COINTYPE, NORMALIZED_SUI_COINTYPE],
+            title: "stratSUI/SUI",
+            tooltip: "Sets up a stratSUI/SUI Looping strategy by depositing stratSUI and borrowing SUI to the desired leverage",
+            type: "Looping",
+        },
+        depositBaseCoinType: undefined,
+        depositLstCoinType: NORMALIZED_stratSUI_COINTYPE,
+        borrowCoinType: NORMALIZED_SUI_COINTYPE,
+        currencyCoinTypes: [NORMALIZED_SUI_COINTYPE, NORMALIZED_stratSUI_COINTYPE],
+        defaultCurrencyCoinType: NORMALIZED_SUI_COINTYPE,
+    },
 };
-export const strategyDeposit = (coin, coinType, strategyOwnerCap, reserveArrayIndex, transaction) => transaction.moveCall({
-    target: `${STRATEGY_WRAPPER_PACKAGE_ID_V7}::strategy_wrapper::deposit_liquidity_and_deposit_into_obligation`,
-    typeArguments: [LENDING_MARKET_TYPE, coinType],
-    arguments: [
-        transaction.object(strategyOwnerCap),
-        transaction.object(LENDING_MARKET_ID),
-        transaction.pure.u64(reserveArrayIndex),
-        transaction.object(SUI_CLOCK_OBJECT_ID),
-        transaction.object(coin),
-    ],
-});
-export const strategyBorrow = (coinType, strategyOwnerCap, reserveArrayIndex, value, transaction) => isSui(coinType)
-    ? transaction.moveCall({
-        target: `${STRATEGY_WRAPPER_PACKAGE_ID_V7}::strategy_wrapper::borrow_sui_from_obligation`,
-        typeArguments: [LENDING_MARKET_TYPE],
+const getStrategyLendingMarket = (strategyType) => {
+    const info = STRATEGY_TYPE_INFO_MAP[strategyType];
+    return {
+        lendingMarketId: info.lendingMarketId,
+        lendingMarketType: info.lendingMarketType,
+    };
+};
+export const strategyDeposit = (strategyType, coin, coinType, strategyOwnerCap, reserveArrayIndex, transaction) => {
+    const { lendingMarketId, lendingMarketType } = getStrategyLendingMarket(strategyType);
+    return transaction.moveCall({
+        target: `${STRATEGY_WRAPPER_PACKAGE_ID_V7}::strategy_wrapper::deposit_liquidity_and_deposit_into_obligation`,
+        typeArguments: [lendingMarketType, coinType],
         arguments: [
             transaction.object(strategyOwnerCap),
-            transaction.object(LENDING_MARKET_ID),
+            transaction.object(lendingMarketId),
             transaction.pure.u64(reserveArrayIndex),
             transaction.object(SUI_CLOCK_OBJECT_ID),
-            transaction.pure.u64(value),
-            transaction.object(SUI_SYSTEM_STATE_OBJECT_ID),
+            transaction.object(coin),
         ],
-    })
-    : transaction.moveCall({
-        target: `${STRATEGY_WRAPPER_PACKAGE_ID_V7}::strategy_wrapper::borrow_from_obligation`,
-        typeArguments: [LENDING_MARKET_TYPE, coinType],
+    });
+};
+export const strategyBorrow = (strategyType, coinType, strategyOwnerCap, reserveArrayIndex, value, transaction) => {
+    const { lendingMarketId, lendingMarketType } = getStrategyLendingMarket(strategyType);
+    return isSui(coinType)
+        ? transaction.moveCall({
+            target: `${STRATEGY_WRAPPER_PACKAGE_ID_V7}::strategy_wrapper::borrow_sui_from_obligation`,
+            typeArguments: [lendingMarketType],
+            arguments: [
+                transaction.object(strategyOwnerCap),
+                transaction.object(lendingMarketId),
+                transaction.pure.u64(reserveArrayIndex),
+                transaction.object(SUI_CLOCK_OBJECT_ID),
+                transaction.pure.u64(value),
+                transaction.object(SUI_SYSTEM_STATE_OBJECT_ID),
+            ],
+        })
+        : transaction.moveCall({
+            target: `${STRATEGY_WRAPPER_PACKAGE_ID_V7}::strategy_wrapper::borrow_from_obligation`,
+            typeArguments: [lendingMarketType, coinType],
+            arguments: [
+                transaction.object(strategyOwnerCap),
+                transaction.object(lendingMarketId),
+                transaction.pure.u64(reserveArrayIndex),
+                transaction.object(SUI_CLOCK_OBJECT_ID),
+                transaction.pure.u64(value),
+            ],
+        });
+};
+export const strategyWithdraw = (strategyType, coinType, strategyOwnerCap, reserveArrayIndex, value, transaction) => {
+    const { lendingMarketId, lendingMarketType } = getStrategyLendingMarket(strategyType);
+    return transaction.moveCall({
+        target: `${STRATEGY_WRAPPER_PACKAGE_ID_V7}::strategy_wrapper::withdraw_from_obligation_and_redeem`,
+        typeArguments: [lendingMarketType, coinType],
         arguments: [
             transaction.object(strategyOwnerCap),
-            transaction.object(LENDING_MARKET_ID),
+            transaction.object(lendingMarketId),
             transaction.pure.u64(reserveArrayIndex),
             transaction.object(SUI_CLOCK_OBJECT_ID),
             transaction.pure.u64(value),
         ],
     });
-export const strategyWithdraw = (coinType, strategyOwnerCap, reserveArrayIndex, value, transaction) => transaction.moveCall({
-    target: `${STRATEGY_WRAPPER_PACKAGE_ID_V7}::strategy_wrapper::withdraw_from_obligation_and_redeem`,
-    typeArguments: [LENDING_MARKET_TYPE, coinType],
-    arguments: [
-        transaction.object(strategyOwnerCap),
-        transaction.object(LENDING_MARKET_ID),
-        transaction.pure.u64(reserveArrayIndex),
-        transaction.object(SUI_CLOCK_OBJECT_ID),
-        transaction.pure.u64(value),
-    ],
-});
-const strategyClaimRewards = (coinType, strategyOwnerCap, reserveArrayIndex, rewardIndex, side, transaction) => transaction.moveCall({
-    target: `${STRATEGY_WRAPPER_PACKAGE_ID_V7}::strategy_wrapper::claim_rewards`,
-    typeArguments: [LENDING_MARKET_TYPE, coinType],
-    arguments: [
-        transaction.object(strategyOwnerCap),
-        transaction.object(LENDING_MARKET_ID),
-        transaction.object(SUI_CLOCK_OBJECT_ID),
-        transaction.pure.u64(reserveArrayIndex),
-        transaction.pure.u64(rewardIndex),
-        transaction.pure.bool(side === Side.DEPOSIT),
-    ],
-});
-const strategyClaimRewardsAndMergeCoins = (rewardsMap, strategyOwnerCap, transaction) => {
+};
+const strategyClaimRewards = (strategyType, coinType, strategyOwnerCap, reserveArrayIndex, rewardIndex, side, transaction) => {
+    const { lendingMarketId, lendingMarketType } = getStrategyLendingMarket(strategyType);
+    return transaction.moveCall({
+        target: `${STRATEGY_WRAPPER_PACKAGE_ID_V7}::strategy_wrapper::claim_rewards`,
+        typeArguments: [lendingMarketType, coinType],
+        arguments: [
+            transaction.object(strategyOwnerCap),
+            transaction.object(lendingMarketId),
+            transaction.object(SUI_CLOCK_OBJECT_ID),
+            transaction.pure.u64(reserveArrayIndex),
+            transaction.pure.u64(rewardIndex),
+            transaction.pure.bool(side === Side.DEPOSIT),
+        ],
+    });
+};
+export const strategyClaimRewardsAndMergeCoins = (strategyType, rewardsMap, strategyOwnerCap, transaction) => {
     // 1) Get rewards
     const rewards = Object.values(rewardsMap)
         .flatMap((r) => r.rewards)
@@ -241,7 +331,7 @@ const strategyClaimRewardsAndMergeCoins = (rewardsMap, strategyOwnerCap, transac
     // 2) Claim rewards and merge coins
     const mergeCoinsMap = {};
     for (const reward of rewards) {
-        const [claimedCoin] = strategyClaimRewards(reward.rewardCoinType, strategyOwnerCap, reward.reserveArrayIndex, reward.rewardIndex, reward.side, transaction);
+        const [claimedCoin] = strategyClaimRewards(strategyType, reward.rewardCoinType, strategyOwnerCap, reward.reserveArrayIndex, reward.rewardIndex, reward.side, transaction);
         if (mergeCoinsMap[reward.rewardCoinType] === undefined)
             mergeCoinsMap[reward.rewardCoinType] = [];
         mergeCoinsMap[reward.rewardCoinType].push(claimedCoin);
@@ -255,94 +345,6 @@ const strategyClaimRewardsAndMergeCoins = (rewardsMap, strategyOwnerCap, transac
     }
     return mergedCoinsMap;
 };
-export const strategyClaimRewardsAndSwapForCoinType = (address, cetusSdk, cetusPartnerId, rewardsMap, rewardPriceMap, depositReserve, strategyOwnerCap, isDepositing, transaction) => __awaiter(void 0, void 0, void 0, function* () {
-    const filteredRewardsMap = Object.fromEntries(Object.entries(rewardsMap).filter(([coinType]) => {
-        var _a;
-        return ((_a = rewardPriceMap[coinType]) !== null && _a !== void 0 ? _a : new BigNumber(0))
-            .times(rewardsMap[coinType].amount)
-            .gte(0.01);
-    }));
-    // 1) Claim rewards and merge coins
-    const mergedCoinsMap = strategyClaimRewardsAndMergeCoins(filteredRewardsMap, strategyOwnerCap, transaction);
-    // 2) Prepare
-    const nonSwappedCoinTypes = Object.keys(mergedCoinsMap).filter((coinType) => coinType === depositReserve.coinType);
-    const swappedCoinTypes = Object.keys(mergedCoinsMap).filter((coinType) => coinType !== depositReserve.coinType);
-    let resultCoin = undefined;
-    // 3.1) Non-swapped coins
-    for (const [coinType, coin] of Object.entries(mergedCoinsMap).filter(([coinType]) => nonSwappedCoinTypes.includes(coinType))) {
-        if (resultCoin)
-            transaction.mergeCoins(resultCoin, [coin]);
-        else
-            resultCoin = coin;
-    }
-    // 3.2) Swapped coins
-    // 3.2.1) Get routers
-    const amountsAndSortedQuotesMap = Object.fromEntries(yield Promise.all(Object.entries(mergedCoinsMap)
-        .filter(([coinType]) => swappedCoinTypes.includes(coinType))
-        .map(([coinType, coin]) => (() => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            // Get amount
-            const { rawAmount: amount } = filteredRewardsMap[coinType]; // Use underestimate (rewards keep accruing)
-            // Get routes
-            const routers = yield cetusSdk.findRouters({
-                from: coinType,
-                target: depositReserve.coinType,
-                amount: new BN(amount.toString()), // Underestimate (rewards keep accruing)
-                byAmountIn: true,
-            });
-            if (!routers)
-                throw new Error(`No swap quote found for ${coinType}`);
-            console.log("[strategyClaimRewardsAndSwapForCoinType] routers", {
-                coinType,
-                routers,
-            });
-            return [coinType, { coin, routers }];
-        }
-        catch (err) {
-            console.error(err);
-            return [coinType, { coin, routers: undefined }];
-        }
-    }))())));
-    console.log("[strategyClaimRewardsAndSwapForCoinType] amountsAndSortedQuotesMap", { amountsAndSortedQuotesMap });
-    // 3.2.2) Swap
-    for (const [coinType, { coin: coinIn, routers }] of Object.entries(amountsAndSortedQuotesMap)) {
-        if (routers === undefined)
-            continue; // Skip coin if no swap quote found
-        console.log("[strategyClaimRewardsAndSwapForCoinType] swapping coinType", coinType);
-        try {
-            let coinOut;
-            try {
-                coinOut = (yield cetusSdk.fixableRouterSwapV3({
-                    router: routers,
-                    inputCoin: coinIn,
-                    slippage: 3 / 100,
-                    txb: transaction,
-                    partner: cetusPartnerId,
-                }));
-                if (resultCoin)
-                    transaction.mergeCoins(resultCoin, [coinOut]);
-                else
-                    resultCoin = coinOut;
-            }
-            catch (err) {
-                throw new Error(`No swap quote found for ${coinType}`);
-            }
-        }
-        catch (err) {
-            console.error(err);
-            continue; // Skip coin if swap fails
-        }
-    }
-    // 4) Deposit
-    if (!resultCoin)
-        throw new Error("No coin to deposit or transfer");
-    if (isDepositing) {
-        strategyDeposit(resultCoin, depositReserve.coinType, strategyOwnerCap, depositReserve.arrayIndex, transaction);
-    }
-    else {
-        transaction.transferObjects([resultCoin], transaction.pure.address(address));
-    }
-});
 export const strategySwapSomeDepositsForCoinType = (strategyType, cetusSdk, cetusPartnerId, obligation, noSwapCoinTypes, // coinTypes to not swap for depositReserve.coinType
 swapPercent, // percent of deposit to swap for depositReserve.coinType (0-100)
 depositReserve, strategyOwnerCap, transaction) => __awaiter(void 0, void 0, void 0, function* () {
@@ -352,7 +354,7 @@ depositReserve, strategyOwnerCap, transaction) => __awaiter(void 0, void 0, void
         return;
     const withdrawnCoinsMap = {};
     for (const deposit of swapCoinTypeDeposits) {
-        const [withdrawnCoin] = strategyWithdraw(deposit.coinType, strategyOwnerCap, deposit.reserve.arrayIndex, swapPercent.eq(100)
+        const [withdrawnCoin] = strategyWithdraw(strategyType, deposit.coinType, strategyOwnerCap, deposit.reserve.arrayIndex, swapPercent.eq(100)
             ? BigInt(MAX_U64.toString())
             : BigInt(new BigNumber(new BigNumber(deposit.depositedAmount.times(swapPercent.div(100)))
                 .times(10 ** deposit.reserve.token.decimals)
@@ -429,9 +431,10 @@ depositReserve, strategyOwnerCap, transaction) => __awaiter(void 0, void 0, void
     if (!resultCoin)
         throw new Error("No coin to deposit or transfer");
     console.log("[strategySwapSomeDepositsForCoinType] depositing resultCoin");
-    strategyDeposit(resultCoin, depositReserve.coinType, strategyOwnerCap, depositReserve.arrayIndex, transaction);
+    strategyDeposit(strategyType, resultCoin, depositReserve.coinType, strategyOwnerCap, depositReserve.arrayIndex, transaction);
 });
 export const createStrategyOwnerCapIfNoneExists = (strategyType, strategyOwnerCap, transaction) => {
+    const { lendingMarketId, lendingMarketType } = getStrategyLendingMarket(strategyType);
     let strategyOwnerCapId;
     let didCreate = false;
     if (strategyOwnerCap)
@@ -439,9 +442,9 @@ export const createStrategyOwnerCapIfNoneExists = (strategyType, strategyOwnerCa
     else {
         strategyOwnerCapId = transaction.moveCall({
             target: `${STRATEGY_WRAPPER_PACKAGE_ID_V7}::strategy_wrapper::create_strategy_owner_cap`,
-            typeArguments: [LENDING_MARKET_TYPE],
+            typeArguments: [lendingMarketType],
             arguments: [
-                transaction.object(LENDING_MARKET_ID),
+                transaction.object(lendingMarketId),
                 transaction.pure.u8(+strategyType),
             ],
         });