@alphafi/alphafi-sdk 0.0.107 → 1.0.0

package/dist/cjs/strategies/looping.js

@@ -0,0 +1,977 @@
+"use strict";
+/**
+ * Looping Strategy
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopingStrategy = void 0;
+const decimal_js_1 = require("decimal.js");
+const strategy_js_1 = require("./strategy.js");
+const constants_js_1 = require("../utils/constants.js");
+const alphalend_sdk_1 = require("@alphafi/alphalend-sdk");
+const stsui_sdk_1 = require("@alphafi/stsui-sdk");
+const pyth_sui_js_1 = require("@pythnetwork/pyth-sui-js");
+/**
+ * Looping Strategy for leveraged positions with automated compounding
+ */
+class LoopingStrategy extends strategy_js_1.BaseStrategy {
+    poolLabel;
+    poolObject;
+    investorObject;
+    receiptObjects = [];
+    context;
+    constructor(poolLabel, poolObject, investorObject, context) {
+        super();
+        this.poolLabel = poolLabel;
+        this.poolObject = this.parsePoolObject(poolObject);
+        this.investorObject = this.parseInvestorObject(investorObject);
+        this.context = context;
+    }
+    getPoolLabel() {
+        return this.poolLabel;
+    }
+    getOtherAmount(_amount, _isAmountA) {
+        throw new Error('getOtherAmount is not supported for single-asset Looping strategy');
+    }
+    updateReceipts(receipts) {
+        this.receiptObjects = this.parseReceiptObjects(receipts);
+    }
+    /**
+     * Get alpha mining data including pool and receipt information
+     */
+    getAlphaMiningData() {
+        const receipt = this.receiptObjects.length > 0 ? this.receiptObjects[0] : null;
+        return {
+            poolId: this.poolLabel.poolId,
+            accRewardsPerXtoken: this.poolObject.accRewardsPerXtoken,
+            xTokenSupply: this.poolObject.xTokenSupply,
+            receipt: receipt
+                ? {
+                    lastAccRewardPerXtoken: receipt.lastAccRewardPerXtoken,
+                    pendingRewards: receipt.pendingRewards,
+                    xTokenBalance: receipt.xTokenBalance,
+                }
+                : null,
+        };
+    }
+    /**
+     * Get the exchange rate for xtoken to underlying token ratio
+     * Adjusted for current debt-to-supply ratio in leveraged positions
+     */
+    exchangeRate() {
+        const currentDebtToSupplyRatio = new decimal_js_1.Decimal(this.investorObject.currentDebtToSupplyRatio);
+        const tokensInvested = new decimal_js_1.Decimal(this.investorObject.tokensDeposited).mul(new decimal_js_1.Decimal(1).minus(currentDebtToSupplyRatio.div(new decimal_js_1.Decimal(10).pow(20))));
+        const xtokenSupply = new decimal_js_1.Decimal(this.poolObject.xTokenSupply);
+        if (xtokenSupply.isZero()) {
+            return new decimal_js_1.Decimal(1); // Default exchange rate when no tokens are supplied
+        }
+        return tokensInvested.div(xtokenSupply);
+    }
+    /**
+     * Get comprehensive pool data including TVL and APR information
+     */
+    async getData() {
+        const [alphafi, parent, apr] = await Promise.all([
+            this.getTvl(),
+            this.getParentTvl(),
+            this.context.getAprData(this.poolLabel.poolId),
+        ]);
+        return {
+            poolId: this.poolLabel.poolId,
+            poolName: this.poolLabel.poolName,
+            apr,
+            tvl: {
+                alphafi,
+                parent,
+            },
+        };
+    }
+    /**
+     * Calculate total value locked adjusted for leveraged position
+     * Accounts for debt-to-supply ratio and protocol-specific scaling
+     */
+    async getTvl() {
+        const supplyType = this.poolLabel.supplyAsset.type;
+        const userDepositType = this.poolLabel.userDepositAsset.type;
+        const cdsr = new decimal_js_1.Decimal(this.investorObject.currentDebtToSupplyRatio);
+        let tokensInvested = new decimal_js_1.Decimal(this.poolObject.tokensInvested).mul(new decimal_js_1.Decimal(1).minus(cdsr.div(new decimal_js_1.Decimal(10).pow(20))));
+        if (this.poolLabel.parentProtocol === 'Navi') {
+            tokensInvested = tokensInvested.div(new decimal_js_1.Decimal(10).pow(9));
+        }
+        else {
+            const supplyDecimals = (await this.context.coinInfoProvider.getCoinByType(supplyType))?.decimals ?? 9;
+            tokensInvested = tokensInvested.div(new decimal_js_1.Decimal(10).pow(supplyDecimals));
+        }
+        const supplyPrice = await this.context.getCoinPrice(supplyType);
+        const userDepositPrice = await this.context.getCoinPrice(userDepositType);
+        const tokenAmount = tokensInvested.mul(supplyPrice).div(userDepositPrice);
+        const usdValue = tokensInvested.mul(userDepositPrice);
+        return { tokenAmount, usdValue };
+    }
+    /**
+     * Calculate parent protocol TVL based on protocol type (Navi/Alphalend)
+     */
+    async getParentTvl() {
+        const protocol = this.poolLabel.parentProtocol;
+        const coinType = this.poolLabel.supplyAsset.type;
+        const price = await this.context.getCoinPrice(coinType);
+        if (protocol === 'Navi') {
+            const tokenAmountUsd = await this.context.getNaviTvlByPoolId(this.poolLabel.poolId);
+            return { tokenAmount: tokenAmountUsd.div(price), usdValue: tokenAmountUsd };
+        }
+        else if (protocol === 'Alphalend') {
+            const tokenAmount = await this.context.getAlphaLendTvl(coinType);
+            return { tokenAmount, usdValue: tokenAmount.mul(price) };
+        }
+        throw new Error(`Unsupported parent protocol: ${protocol}`);
+    }
+    /**
+     * Calculate user's current pool balance from xToken balance
+     * Includes leverage adjustment and protocol-specific scaling
+     */
+    async getBalance(_userAddress) {
+        if (this.receiptObjects.length === 0 || this.receiptObjects[0].xTokenBalance === '0') {
+            return { tokenAmount: new decimal_js_1.Decimal(0), usdValue: new decimal_js_1.Decimal(0) };
+        }
+        const xTokens = new decimal_js_1.Decimal(this.receiptObjects[0].xTokenBalance);
+        const exchangeRate = this.exchangeRate();
+        let tokens = xTokens.mul(exchangeRate);
+        if (this.poolLabel.parentProtocol === 'Navi') {
+            tokens = tokens.div(new decimal_js_1.Decimal(10).pow(9));
+        }
+        else {
+            const supplyDecimals = await this.context.getCoinDecimals(this.poolLabel.supplyAsset.type);
+            tokens = tokens.div(new decimal_js_1.Decimal(10).pow(supplyDecimals));
+        }
+        const [supplyPrice, userDepositPrice] = await Promise.all([
+            this.context.getCoinPrice(this.poolLabel.supplyAsset.type),
+            this.context.getCoinPrice(this.poolLabel.userDepositAsset.type),
+        ]);
+        const amount = tokens.mul(supplyPrice).div(userDepositPrice);
+        return { tokenAmount: amount, usdValue: amount.mul(userDepositPrice) };
+    }
+    /**
+     * Parse pool object from blockchain response
+     */
+    parsePoolObject(response) {
+        return this.safeParseObject(() => {
+            const fields = this.extractFields(response);
+            return {
+                accRewardsPerXtoken: this.parseVecMap(fields.acc_rewards_per_xtoken || {}),
+                depositFee: this.getStringField(fields, 'deposit_fee'),
+                depositFeeMaxCap: this.getStringField(fields, 'deposit_fee_max_cap'),
+                id: this.getStringField(fields, 'id'),
+                imageUrl: this.getStringField(fields, 'image_url'),
+                name: this.getStringField(fields, 'name'),
+                paused: this.getBooleanField(fields, 'paused', false),
+                rewards: (() => {
+                    const idVal = this.getNestedField(fields, 'rewards.id');
+                    const sizeVal = this.getNestedField(fields, 'rewards.size');
+                    return { id: String(idVal), size: String(sizeVal) };
+                })(),
+                tokensInvested: this.getStringField(fields, 'tokensInvested'),
+                withdrawFeeMaxCap: this.getStringField(fields, 'withdraw_fee_max_cap'),
+                withdrawalFee: this.getStringField(fields, 'withdrawal_fee'),
+                xTokenSupply: this.getStringField(fields, 'xTokenSupply'),
+            };
+        }, 'Failed to parse Looping pool object');
+    }
+    /**
+     * Parse investor object from blockchain response
+     */
+    parseInvestorObject(response) {
+        return this.safeParseObject(() => {
+            const fields = this.extractFields(response);
+            return {
+                currentDebtToSupplyRatio: this.getStringField(fields, 'current_debt_to_supply_ratio'),
+                freeRewards: (() => {
+                    const idVal = this.getNestedField(fields, 'free_rewards.id');
+                    const sizeVal = this.getNestedField(fields, 'free_rewards.size');
+                    return { id: String(idVal), size: String(sizeVal) };
+                })(),
+                id: this.getStringField(fields, 'id'),
+                loops: this.getStringField(fields, 'loops'),
+                maxCapPerformanceFee: this.getStringField(fields, 'max_cap_performance_fee'),
+                minimumSwapAmount: this.getStringField(fields, 'minimum_swap_amount'),
+                naviAccCap: {
+                    id: this.getNestedField(fields, 'navi_acc_cap.id'),
+                    owner: this.getNestedField(fields, 'navi_acc_cap.owner'),
+                },
+                performanceFee: this.getStringField(fields, 'performance_fee'),
+                safeBorrowPercentage: this.getStringField(fields, 'safe_borrow_percentage'),
+                tokensDeposited: this.getStringField(fields, 'tokens_deposited') ||
+                    this.getStringField(fields, 'tokensDeposited'),
+            };
+        }, 'Failed to parse Looping investor object');
+    }
+    /**
+     * Parse parent pool object (not applicable for Looping)
+     */
+    parseParentPoolObject(_response) {
+        throw new Error('Looping strategy does not have parent pool objects');
+    }
+    /**
+     * Parse receipt objects from blockchain responses
+     */
+    parseReceiptObjects(responses) {
+        return responses
+            .map((response, index) => {
+            return this.safeParseObject(() => {
+                const fields = this.extractFields(response);
+                return {
+                    id: this.getStringField(fields, 'id'),
+                    imageUrl: this.getStringField(fields, 'image_url'),
+                    lastAccRewardPerXtoken: this.parseVecMap(fields.last_acc_reward_per_xtoken || {}),
+                    name: this.getStringField(fields, 'name'),
+                    owner: this.getStringField(fields, 'owner'),
+                    pendingRewards: this.parseVecMap(fields.pending_rewards || {}),
+                    poolId: this.getStringField(fields, 'pool_id'),
+                    xTokenBalance: this.getStringField(fields, 'xTokenBalance'),
+                };
+            }, `Failed to parse Looping receipt object at index ${index}`);
+        })
+            .filter((receipt) => receipt.poolId === this.poolLabel.poolId);
+    }
+    async getAvailableRewards(address) {
+        try {
+            // Call the integration API
+            const apiUrl = 'https://api.alphafi.xyz';
+            const response = await fetch(`${apiUrl}/navi-params/rewards?address=${encodeURIComponent(address)}`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                throw new Error(errorData.error ||
+                    errorData.message ||
+                    `Failed to fetch rewards: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            // The API returns { address, rewards, timestamp }
+            // We just need the rewards object
+            return data.rewards || {};
+        }
+        catch (error) {
+            console.error('Error fetching Navi rewards from API:', error);
+            throw new Error(`Failed to fetch Navi rewards: ${error.message}`);
+        }
+    }
+    async collectAndSwapRewardsTxb(tx, rewardCoinSet, claimableRewards) {
+        if (!claimableRewards) {
+            return;
+        }
+        const [navxCoin, vsuiCoin, stsuiCoin] = await this.context.getCoinsBySymbols([
+            'NAVX',
+            'vSUI',
+            'stSUI',
+        ]);
+        for (const reward of claimableRewards) {
+            if (rewardCoinSet.has(reward.rewardCoinType) === false) {
+                if (this.poolLabel.supplyAsset.name === 'vSUI') {
+                    if (reward.rewardCoinType === navxCoin.coinType) {
+                        tx.moveCall({
+                            target: `${this.poolLabel.packageId}::alphafi_navi_sui_vsui_investor::collect_reward_with_two_swaps_v2`,
+                            typeArguments: [navxCoin.coinType],
+                            arguments: [
+                                tx.object(this.poolLabel.investorId),
+                                tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[2]),
+                                tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.REWARDS_POOL.NAVX),
+                                tx.object(constants_js_1.NAVI_CONFIG.VOLO.STAKE_POOL),
+                                tx.object(constants_js_1.NAVI_CONFIG.VOLO.METADATA),
+                                tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                                tx.object(await this.context.getPoolIdBySymbolsAndProtocol('NAVX', 'vSUI', 'cetus')),
+                                tx.object(await this.context.getPoolIdBySymbolsAndProtocol('vSUI', 'SUI', 'cetus')),
+                                tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                            ],
+                        });
+                    }
+                    else if (reward.rewardCoinType === vsuiCoin.coinType) {
+                        tx.moveCall({
+                            target: `${this.poolLabel.packageId}::alphafi_navi_sui_vsui_investor::collect_reward_with_no_swap`,
+                            arguments: [
+                                tx.object(this.poolLabel.investorId),
+                                tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[2]),
+                                tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.REWARDS_POOL.vSUI),
+                            ],
+                        });
+                    }
+                }
+                else if (this.poolLabel.supplyAsset.name === 'HASUI') {
+                    if (reward.rewardCoinType === navxCoin.coinType) {
+                        tx.moveCall({
+                            target: `${this.poolLabel.packageId}::alphafi_navi_hasui_sui_investor::collect_reward_with_two_swaps`,
+                            typeArguments: [navxCoin.coinType],
+                            arguments: [
+                                tx.object(this.poolLabel.investorId),
+                                tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[2]),
+                                tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.REWARDS_POOL.NAVX),
+                                tx.object(constants_js_1.NAVI_CONFIG.HAEDEL_STAKING),
+                                tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                                tx.object(await this.context.getPoolIdBySymbolsAndProtocol('NAVX', 'SUI', 'cetus')),
+                                tx.object(await this.context.getPoolIdBySymbolsAndProtocol('HASUI', 'SUI', 'cetus')),
+                                tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                            ],
+                        });
+                    }
+                    else if (reward.rewardCoinType === vsuiCoin.coinType) {
+                        tx.moveCall({
+                            target: `${this.poolLabel.packageId}::alphafi_navi_hasui_sui_investor::collect_reward_with_two_swaps`,
+                            typeArguments: [vsuiCoin.coinType],
+                            arguments: [
+                                tx.object(this.poolLabel.investorId),
+                                tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[2]),
+                                tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.REWARDS_POOL.vSUI),
+                                tx.object(constants_js_1.NAVI_CONFIG.HAEDEL_STAKING),
+                                tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                                tx.object(await this.context.getPoolIdBySymbolsAndProtocol('vSUI', 'SUI', 'cetus')),
+                                tx.object(await this.context.getPoolIdBySymbolsAndProtocol('HASUI', 'SUI', 'cetus')),
+                                tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                            ],
+                        });
+                    }
+                }
+                else if (this.poolLabel.supplyAsset.name === 'stSUI') {
+                    if (reward.rewardCoinType === navxCoin.coinType) {
+                        tx.moveCall({
+                            target: `${this.poolLabel.packageId}::alphafi_navi_sui_stsui_pool::collect_v3_rewards_with_two_swaps_bluefin`,
+                            typeArguments: [navxCoin.coinType],
+                            arguments: [
+                                tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                                tx.object(this.poolLabel.investorId),
+                                tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.REWARDS_POOL.NAVX),
+                                tx.object(constants_js_1.STSUI.LST_INFO),
+                                tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                                tx.object(await this.context.getPoolIdBySymbolsAndProtocol('NAVX', 'SUI', 'bluefin')),
+                                tx.object(constants_js_1.GLOBAL_CONFIGS.BLUEFIN),
+                                tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                            ],
+                        });
+                    }
+                    else if (reward.rewardCoinType === vsuiCoin.coinType) {
+                        tx.moveCall({
+                            target: `${this.poolLabel.packageId}::alphafi_navi_sui_stsui_pool::collect_v3_rewards_with_two_swaps`,
+                            typeArguments: [vsuiCoin.coinType],
+                            arguments: [
+                                tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                                tx.object(this.poolLabel.investorId),
+                                tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.REWARDS_POOL.vSUI),
+                                tx.object(constants_js_1.STSUI.LST_INFO),
+                                tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                                tx.object(await this.context.getPoolIdBySymbolsAndProtocol('vSUI', 'SUI', 'cetus')),
+                                tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                                tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                            ],
+                        });
+                    }
+                    else if (reward.rewardCoinType === stsuiCoin.coinType) {
+                        tx.moveCall({
+                            target: `${this.poolLabel.packageId}::alphafi_navi_sui_stsui_pool::collect_v3_rewards_with_no_swap`,
+                            arguments: [
+                                tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                                tx.object(this.poolLabel.investorId),
+                                tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.REWARDS_POOL.stSUI),
+                                tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                            ],
+                        });
+                    }
+                }
+                else if (this.poolLabel.supplyAsset.name === 'USDC') {
+                    if (reward.rewardCoinType === navxCoin.coinType) {
+                        tx.moveCall({
+                            target: `${this.poolLabel.packageId}::alphafi_navi_native_usdc_usdt_investor::collect_reward_with_two_swaps`,
+                            typeArguments: [navxCoin.coinType],
+                            arguments: [
+                                tx.object(this.poolLabel.investorId),
+                                tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[2]),
+                                tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.REWARDS_POOL.NAVX),
+                                tx.object(await this.context.getPoolIdBySymbolsAndProtocol('NAVX', 'SUI', 'cetus')),
+                                tx.object(await this.context.getPoolIdBySymbolsAndProtocol('USDC', 'SUI', 'cetus')),
+                                tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                            ],
+                        });
+                    }
+                    else if (reward.rewardCoinType === vsuiCoin.coinType) {
+                        tx.moveCall({
+                            target: `${this.poolLabel.packageId}::alphafi_navi_native_usdc_usdt_investor::collect_reward_with_two_swaps`,
+                            typeArguments: [vsuiCoin.coinType],
+                            arguments: [
+                                tx.object(this.poolLabel.investorId),
+                                tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[2]),
+                                tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                                tx.object(constants_js_1.NAVI_CONFIG.REWARDS_POOL.vSUI),
+                                tx.object(await this.context.getPoolIdBySymbolsAndProtocol('vSUI', 'SUI', 'cetus')),
+                                tx.object(await this.context.getPoolIdBySymbolsAndProtocol('USDC', 'SUI', 'cetus')),
+                                tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                            ],
+                        });
+                    }
+                }
+                rewardCoinSet.add(reward.reward_coin_type);
+            }
+        }
+    }
+    async collectAndSwapRewards(tx) {
+        const rewardCoinSet = new Set();
+        if (this.poolLabel.supplyAsset.name === 'vSUI') {
+            const claimableRewards = await this.getAvailableRewards(constants_js_1.NAVI_CONFIG.ACCOUNT_ADDRESSES.SUI_VSUI_LOOP);
+            await this.collectAndSwapRewardsTxb(tx, rewardCoinSet, claimableRewards[this.poolLabel.supplyAsset.type]);
+            await this.collectAndSwapRewardsTxb(tx, rewardCoinSet, claimableRewards['0000000000000000000000000000000000000000000000000000000000000002::sui::SUI']);
+        }
+        else if (this.poolLabel.supplyAsset.name === 'HASUI') {
+            const claimableRewards = await this.getAvailableRewards(constants_js_1.NAVI_CONFIG.ACCOUNT_ADDRESSES.HASUI_SUI_LOOP);
+            await this.collectAndSwapRewardsTxb(tx, rewardCoinSet, claimableRewards[this.poolLabel.supplyAsset.type]);
+            await this.collectAndSwapRewardsTxb(tx, rewardCoinSet, claimableRewards['0000000000000000000000000000000000000000000000000000000000000002::sui::SUI']);
+        }
+        else if (this.poolLabel.supplyAsset.name === 'stSUI') {
+            const claimableRewards = await this.getAvailableRewards('');
+            await this.collectAndSwapRewardsTxb(tx, rewardCoinSet, claimableRewards[this.poolLabel.supplyAsset.type]);
+            await this.collectAndSwapRewardsTxb(tx, rewardCoinSet, claimableRewards['0000000000000000000000000000000000000000000000000000000000000002::sui::SUI']);
+        }
+        else if (this.poolLabel.supplyAsset.name === 'USDC') {
+            const claimableRewards = await this.getAvailableRewards(constants_js_1.NAVI_CONFIG.ACCOUNT_ADDRESSES.USDC_USDT_LOOP);
+            await this.collectAndSwapRewardsTxb(tx, rewardCoinSet, claimableRewards[this.poolLabel.supplyAsset.type]);
+            await this.collectAndSwapRewardsTxb(tx, rewardCoinSet, claimableRewards[this.poolLabel.borrowAsset.type]);
+        }
+    }
+    async updateSingleTokenPrice(tx, pythPriceInfo, feedId) {
+        const pythClient = new pyth_sui_js_1.SuiPythClient(this.context.blockchain.suiClient, constants_js_1.PYTH_STATE_ID, constants_js_1.WORMHOLE_STATE_ID);
+        const pythConnection = new pyth_sui_js_1.SuiPriceServiceConnection('https://hermes.pyth.network');
+        const priceFeedUpdateData = await pythConnection.getPriceFeedsUpdateData([pythPriceInfo]);
+        const priceInfoObjectIds = await pythClient.updatePriceFeeds(tx, priceFeedUpdateData, [
+            pythPriceInfo,
+        ]);
+        tx.moveCall({
+            target: '0xc2d49bf5e75d2258ee5563efa527feb6155de7ac6f6bf025a23ee88cd12d5a83::oracle_pro::update_single_price',
+            arguments: [
+                tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                tx.object(constants_js_1.NAVI_CONFIG.ORACLE_CONFIG),
+                tx.object(constants_js_1.NAVI_CONFIG.PRICE_ORACLE_ID),
+                tx.object(constants_js_1.NAVI_CONFIG.SUPRA_ORACLE_HOLDER),
+                tx.object(priceInfoObjectIds[0]),
+                tx.pure.address(feedId),
+            ],
+        });
+    }
+    async deposit(tx, options) {
+        // get Coin Object
+        const depositCoin = await this.context.blockchain.getCoinObject(tx, this.poolLabel.userDepositAsset.type, options.address, options.amount);
+        const receiptOption = this.context.blockchain.getOptionReceipt(tx, this.poolLabel.poolId, options.address);
+        if (this.poolLabel.parentProtocol === 'Alphalend') {
+            const [alphaCoin, blueCoin] = await this.context.getCoinsBySymbols(['ALPHA', 'BLUE']);
+            tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_sui_stsui_pool::collect_v3_rewards_with_one_swap`,
+                typeArguments: [alphaCoin.coinType],
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.ALPHALEND_LENDING_PROTOCOL_ID),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('ALPHA', 'STSUI', 'bluefin')),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.BLUEFIN),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+            tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_sui_stsui_pool::collect_v3_rewards_with_no_swap_v2`,
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.ALPHALEND_LENDING_PROTOCOL_ID),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+            tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_sui_stsui_pool::collect_v3_rewards_with_two_swaps_v2`,
+                typeArguments: [blueCoin.coinType],
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.ALPHALEND_LENDING_PROTOCOL_ID),
+                    tx.object(constants_js_1.STSUI.LST_INFO),
+                    tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('BLUE', 'SUI', 'cetus')),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.BLUEFIN),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+            tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_sui_stsui_pool::user_deposit_v3`,
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[1]),
+                    receiptOption,
+                    tx.object(this.poolLabel.poolId),
+                    depositCoin,
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.DISTRIBUTOR_OBJECT_ID),
+                    tx.object(constants_js_1.ALPHALEND_LENDING_PROTOCOL_ID),
+                    tx.object(constants_js_1.STSUI.LST_INFO),
+                    tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+            return;
+        }
+        await this.updateSingleTokenPrice(tx, constants_js_1.NAVI_CONFIG.PRICE_FEED[this.poolLabel.supplyAsset.name]
+            .pythPriceInfo, constants_js_1.NAVI_CONFIG.PRICE_FEED[this.poolLabel.supplyAsset.name]
+            .feedId);
+        await this.updateSingleTokenPrice(tx, constants_js_1.NAVI_CONFIG.PRICE_FEED[this.poolLabel.borrowAsset.name]
+            .pythPriceInfo, constants_js_1.NAVI_CONFIG.PRICE_FEED[this.poolLabel.borrowAsset.name]
+            .feedId);
+        await this.collectAndSwapRewards(tx);
+        if (this.poolLabel.supplyAsset.name === 'vSUI') {
+            tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_sui_vsui_pool::user_deposit_v3`,
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[2]),
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[1]),
+                    receiptOption,
+                    tx.object(this.poolLabel.poolId),
+                    depositCoin,
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.DISTRIBUTOR_OBJECT_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.PRICE_ORACLE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.vSUI),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.SUI),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V2_ID),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('vSUI', 'SUI', 'cetus')),
+                    tx.object(constants_js_1.NAVI_CONFIG.VOLO.STAKE_POOL),
+                    tx.object(constants_js_1.NAVI_CONFIG.VOLO.METADATA),
+                    tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                    tx.object(constants_js_1.NAVI_CONFIG.KRIYA.VSUI_SUI_POOL),
+                    tx.object(constants_js_1.NAVI_CONFIG.KRIYA.VERSION),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+        }
+        else if (this.poolLabel.supplyAsset.name === 'HASUI') {
+            tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_hasui_sui_pool::user_deposit_v2`, // change package id for testing
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[2]), // change version object id for testing
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[1]),
+                    receiptOption,
+                    tx.object(this.poolLabel.poolId),
+                    depositCoin,
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.DISTRIBUTOR_OBJECT_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.PRICE_ORACLE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.HASUI),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.SUI),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V2_ID),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('HASUI', 'SUI', 'cetus')),
+                    tx.object(constants_js_1.NAVI_CONFIG.HAEDEL_STAKING),
+                    tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+        }
+        else if (this.poolLabel.supplyAsset.name === 'USDC') {
+            tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_native_usdc_usdt_pool::user_deposit_v3`,
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[2]),
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[1]),
+                    receiptOption,
+                    tx.object(this.poolLabel.poolId),
+                    depositCoin,
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.DISTRIBUTOR_OBJECT_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.PRICE_ORACLE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.USDC),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.USDT),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V1_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V2_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.FUNDS_POOLS.vSUI),
+                    tx.object(constants_js_1.NAVI_CONFIG.FUNDS_POOLS.NAVX),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('vSUI', 'SUI', 'cetus')),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('NAVX', 'SUI', 'cetus')),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('USDC', 'SUI', 'cetus')),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('USDC', 'USDT', 'cetus')),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.BLUEFIN),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('USDT', 'USDC', 'bluefin')),
+                    tx.pure.bool(true),
+                    tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+        }
+        else if (this.poolLabel.supplyAsset.name === 'USDT') {
+            const [navxCoin] = await this.context.getCoinsBySymbols(['NAVX']);
+            tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_usdt_usdc_pool::user_deposit_v3`,
+                typeArguments: [navxCoin.coinType],
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[1]),
+                    receiptOption,
+                    tx.object(this.poolLabel.poolId),
+                    depositCoin,
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.DISTRIBUTOR_OBJECT_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.PRICE_ORACLE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.USDT),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.USDC),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V1_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V2_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.FUNDS_POOLS.vSUI),
+                    tx.object(constants_js_1.NAVI_CONFIG.FUNDS_POOLS.NAVX),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('vSUI', 'SUI', 'cetus')),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('USDC', 'USDT', 'cetus')),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('USDC', 'SUI', 'cetus')),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('NAVX', 'SUI', 'cetus')),
+                    tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+        }
+    }
+    async fetchVoloExchangeRate() {
+        const apiUrl = 'https://open-api.naviprotocol.io/api/volo/stats';
+        const default_volo_data = {
+            data: {
+                operatorBalance: '',
+                collectableFee: '',
+                pendingStakes: '',
+                poolTotalRewards: '0',
+                unstakeTicketSupply: '',
+                totalStaked: '',
+                activeStake: '',
+                calcTotalRewards: '',
+                currentEpoch: '',
+                validators: {},
+                exchangeRate: (1 / 0.973).toString(),
+                totalSupply: '',
+                apy: '',
+                sortedValidators: [''],
+                maxInstantUnstake: '',
+                maxNoFeeUnstake: '',
+            },
+            code: 0,
+        };
+        try {
+            const response = await fetch(apiUrl);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            return data;
+        }
+        catch (error) {
+            console.error('error in api', error);
+            return default_volo_data;
+        }
+    }
+    async coinAmountToXToken(amount) {
+        const exchangeRate = this.exchangeRate();
+        if (this.poolLabel.poolName === 'NAVI-LOOP-SUI-VSUI') {
+            const voloExchRate = await this.fetchVoloExchangeRate();
+            amount = amount.div(parseFloat(voloExchRate.data.exchangeRate));
+        }
+        else if (this.poolLabel.poolName === 'ALPHALEND-LOOP-SUI-STSUI') {
+            const suiTostSuiExchangeRate = await (0, stsui_sdk_1.stSuiExchangeRate)((0, stsui_sdk_1.getConf)().LST_INFO, true);
+            amount = amount.div(suiTostSuiExchangeRate);
+        }
+        return new decimal_js_1.Decimal(amount).div(exchangeRate).floor().toString();
+    }
+    async withdraw(tx, options) {
+        if (this.receiptObjects.length === 0) {
+            throw new Error('No receipt found');
+        }
+        let xtokenAmount = await this.coinAmountToXToken(new decimal_js_1.Decimal(options.amount));
+        if (options.withdrawMax) {
+            xtokenAmount = this.receiptObjects[0].xTokenBalance;
+        }
+        const noneAlphaReceipt = tx.moveCall({
+            target: `0x1::option::none`,
+            typeArguments: [
+                '0x9bbd650b8442abb082c20f3bc95a9434a8d47b4bef98b0832dab57c1a8ba7123::alphapool::Receipt',
+            ],
+            arguments: [],
+        });
+        if (this.poolLabel.parentProtocol === 'Alphalend') {
+            await this.collectAndSwapRewards(tx);
+            const [stsuiCoin, suiCoin, alphaCoin, blueCoin] = await this.context.getCoinsBySymbols([
+                'stSUI',
+                'SUI',
+                'ALPHA',
+                'BLUE',
+            ]);
+            const alphalendClient = new alphalend_sdk_1.AlphalendClient('mainnet', this.context.blockchain.suiClient);
+            await alphalendClient.updatePrices(tx, [stsuiCoin.coinType, suiCoin.coinType]);
+            tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_sui_stsui_pool::collect_v3_rewards_with_one_swap`,
+                typeArguments: [alphaCoin.coinType],
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.ALPHALEND_LENDING_PROTOCOL_ID),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('ALPHA', 'STSUI', 'bluefin')),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.BLUEFIN),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+            tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_sui_stsui_pool::collect_v3_rewards_with_no_swap_v2`,
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.ALPHALEND_LENDING_PROTOCOL_ID),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+            tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_sui_stsui_pool::collect_v3_rewards_with_two_swaps_v2`,
+                typeArguments: [blueCoin.coinType],
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.ALPHALEND_LENDING_PROTOCOL_ID),
+                    tx.object(constants_js_1.STSUI.LST_INFO),
+                    tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('BLUE', 'SUI', 'cetus')),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+            const [stsui_coin] = tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_sui_stsui_pool::user_withdraw_v3`,
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[1]),
+                    tx.object(this.receiptObjects[0].id),
+                    noneAlphaReceipt,
+                    tx.object(constants_js_1.POOLS.ALPHA_LEGACY),
+                    tx.object(this.poolLabel.poolId),
+                    tx.pure.u64(xtokenAmount),
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.DISTRIBUTOR_OBJECT_ID),
+                    tx.object(constants_js_1.ALPHALEND_LENDING_PROTOCOL_ID),
+                    tx.object(constants_js_1.STSUI.LST_INFO),
+                    tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+            tx.moveCall({
+                target: `0x2::transfer::public_transfer`,
+                typeArguments: [`0x2::coin::Coin<${suiCoin.coinType}>`],
+                arguments: [stsui_coin, tx.pure.address(options.address)],
+            });
+            return;
+        }
+        await this.updateSingleTokenPrice(tx, constants_js_1.NAVI_CONFIG.PRICE_FEED[this.poolLabel.supplyAsset.name]
+            .pythPriceInfo, constants_js_1.NAVI_CONFIG.PRICE_FEED[this.poolLabel.supplyAsset.name]
+            .feedId);
+        await this.updateSingleTokenPrice(tx, constants_js_1.NAVI_CONFIG.PRICE_FEED[this.poolLabel.borrowAsset.name]
+            .pythPriceInfo, constants_js_1.NAVI_CONFIG.PRICE_FEED[this.poolLabel.borrowAsset.name]
+            .feedId);
+        await this.collectAndSwapRewards(tx);
+        if (this.poolLabel.supplyAsset.name === 'vSUI') {
+            const [vsui_coin] = tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_sui_vsui_pool::user_withdraw_v3`,
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[2]),
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[1]),
+                    tx.object(this.receiptObjects[0].id),
+                    noneAlphaReceipt,
+                    tx.object(constants_js_1.POOLS.ALPHA_LEGACY),
+                    tx.object(this.poolLabel.poolId),
+                    tx.pure.u64(xtokenAmount),
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.DISTRIBUTOR_OBJECT_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.PRICE_ORACLE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.vSUI),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.SUI),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V2_ID),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('vSUI', 'SUI', 'cetus')),
+                    tx.object(constants_js_1.NAVI_CONFIG.VOLO.STAKE_POOL),
+                    tx.object(constants_js_1.NAVI_CONFIG.VOLO.METADATA),
+                    tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                    tx.object(constants_js_1.NAVI_CONFIG.KRIYA.VSUI_SUI_POOL),
+                    tx.object(constants_js_1.NAVI_CONFIG.KRIYA.VERSION),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+            tx.moveCall({
+                target: `0x2::transfer::public_transfer`,
+                typeArguments: [`0x2::coin::Coin<${this.poolLabel.borrowAsset.type}>`],
+                arguments: [vsui_coin, tx.pure.address(options.address)],
+            });
+        }
+        else if (this.poolLabel.supplyAsset.name === 'HASUI') {
+            const [hasuiCoin] = tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_hasui_sui_pool::user_withdraw_v2`, // change package id for testing
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[2]), // change  version object id for testing
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[1]),
+                    tx.object(this.receiptObjects[0].id),
+                    noneAlphaReceipt,
+                    tx.object(constants_js_1.POOLS.ALPHA_LEGACY),
+                    tx.object(this.poolLabel.poolId),
+                    tx.pure.u64(xtokenAmount),
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.DISTRIBUTOR_OBJECT_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.PRICE_ORACLE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.HASUI),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.SUI),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V2_ID),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('HASUI', 'SUI', 'cetus')),
+                    tx.object(constants_js_1.NAVI_CONFIG.HAEDEL_STAKING),
+                    tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+            tx.moveCall({
+                target: `0x2::transfer::public_transfer`,
+                typeArguments: [`0x2::coin::Coin<${this.poolLabel.supplyAsset.type}>`],
+                arguments: [hasuiCoin, tx.pure.address(options.address)],
+            });
+        }
+        else if (this.poolLabel.supplyAsset.name === 'USDC') {
+            const [usdcCoin] = tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_native_usdc_usdt_pool::user_withdraw_v4`,
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[2]),
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[1]),
+                    tx.object(this.receiptObjects[0].id),
+                    noneAlphaReceipt,
+                    tx.object(constants_js_1.POOLS.ALPHA_LEGACY),
+                    tx.object(this.poolLabel.poolId),
+                    tx.pure.u256(xtokenAmount),
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.DISTRIBUTOR_OBJECT_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.PRICE_ORACLE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.USDC),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.USDT),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V2_ID),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('USDC', 'USDT', 'cetus')),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.BLUEFIN),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('USDT', 'USDC', 'bluefin')),
+                    tx.pure.bool(true),
+                    tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+            tx.moveCall({
+                target: `0x2::transfer::public_transfer`,
+                typeArguments: [`0x2::coin::Coin<${this.poolLabel.supplyAsset.type}>`],
+                arguments: [usdcCoin, tx.pure.address(options.address)],
+            });
+        }
+        else if (this.poolLabel.supplyAsset.name === 'USDT') {
+            const [usdtCoin] = tx.moveCall({
+                target: `${this.poolLabel.packageId}::alphafi_navi_usdt_usdc_pool::user_withdraw_v3`,
+                arguments: [
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[5]),
+                    tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[1]),
+                    tx.object(this.receiptObjects[0].id),
+                    noneAlphaReceipt,
+                    tx.object(constants_js_1.POOLS.ALPHA_LEGACY),
+                    tx.object(this.poolLabel.poolId),
+                    tx.pure.u256(xtokenAmount),
+                    tx.object(this.poolLabel.investorId),
+                    tx.object(constants_js_1.DISTRIBUTOR_OBJECT_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.PRICE_ORACLE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_STORAGE_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.USDT),
+                    tx.object(constants_js_1.NAVI_CONFIG.NAVI_POOLS.USDC),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V3_ID),
+                    tx.object(constants_js_1.NAVI_CONFIG.INCENTIVE_V2_ID),
+                    tx.object(constants_js_1.GLOBAL_CONFIGS.CETUS),
+                    tx.object(await this.context.getPoolIdBySymbolsAndProtocol('USDC', 'USDT', 'cetus')),
+                    tx.object(constants_js_1.SUI_SYSTEM_STATE),
+                    tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                ],
+            });
+            tx.moveCall({
+                target: `0x2::transfer::public_transfer`,
+                typeArguments: [`0x2::coin::Coin<${this.poolLabel.supplyAsset.type}>`],
+                arguments: [usdtCoin, tx.pure.address(options.address)],
+            });
+        }
+    }
+    async claimRewards(tx, alphaReceipt) {
+        let target, version;
+        if (this.poolLabel.poolName == 'NAVI-LOOP-USDT-USDC') {
+            target = `${this.poolLabel.packageId}::alphafi_navi_usdt_usdc_pool::get_user_rewards_all`;
+            version = constants_js_1.VERSIONS.ALPHA_VERSIONS[5];
+        }
+        else if (this.poolLabel.poolName == 'ALPHALEND-LOOP-SUI-STSUI') {
+            target = `${this.poolLabel.packageId}::alphafi_navi_sui_stsui_pool::get_user_rewards_all`;
+            version = constants_js_1.VERSIONS.ALPHA_VERSIONS[5];
+        }
+        else if (this.poolLabel.poolName == 'NAVI-LOOP-SUI-VSUI') {
+            target = `${this.poolLabel.packageId}::alphafi_navi_sui_vsui_pool::get_user_rewards_all`;
+            version = constants_js_1.VERSIONS.ALPHA_VERSIONS[2];
+        }
+        else if (this.poolLabel.poolName == 'NAVI-LOOP-USDC-USDT') {
+            target = `${this.poolLabel.packageId}::alphafi_navi_native_usdc_usdt_pool::get_user_rewards_all`;
+            version = constants_js_1.VERSIONS.ALPHA_VERSIONS[2];
+        }
+        else if (this.poolLabel.poolName == 'NAVI-LOOP-HASUI-SUI') {
+            target = `${this.poolLabel.packageId}::alphafi_navi_hasui_sui_pool::get_user_rewards_all`;
+            version = constants_js_1.VERSIONS.ALPHA_VERSIONS[2];
+        }
+        if (version && target) {
+            this.receiptObjects.forEach((receipt) => {
+                alphaReceipt = tx.moveCall({
+                    target,
+                    arguments: [
+                        tx.object(version),
+                        tx.object(constants_js_1.VERSIONS.ALPHA_VERSIONS[1]),
+                        tx.object(receipt.id),
+                        alphaReceipt,
+                        tx.object(this.poolLabel.poolId),
+                        tx.object(constants_js_1.POOLS.ALPHA_LEGACY),
+                        tx.object(constants_js_1.DISTRIBUTOR_OBJECT_ID),
+                        tx.object(constants_js_1.CLOCK_PACKAGE_ID),
+                    ],
+                });
+            });
+        }
+    }
+}
+exports.LoopingStrategy = LoopingStrategy;
+//# sourceMappingURL=looping.js.map