@symmetry-hq/sdk 1.0.1

package/dist/src/states/intents/rebalanceIntent.js

@@ -0,0 +1,680 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeRebalanceIntentBountyAmount = computeRebalanceIntentBountyAmount;
+exports.formatRebalanceIntent = formatRebalanceIntent;
+exports.fetchRebalanceIntent = fetchRebalanceIntent;
+exports.fetchRebalanceIntentsMultiple = fetchRebalanceIntentsMultiple;
+exports.fetchRebalanceIntents = fetchRebalanceIntents;
+exports.getSwapPairs = getSwapPairs;
+const web3_js_1 = require("@solana/web3.js");
+const rebalanceIntent_1 = require("../../layouts/intents/rebalanceIntent");
+const constants_1 = require("../../constants");
+const fraction_1 = require("../../layouts/fraction");
+const txUtils_1 = require("../../txUtils");
+const bn_js_1 = __importDefault(require("bn.js"));
+const basket_1 = require("../basket");
+function computeRebalanceIntentBountyAmount(rebalance_type, num_tokens, bounty_bond, bounty_per_task, bounty_per_price_update_task_max) {
+    let num_tasks = 0;
+    num_tasks += 1; // FinishPriceUpdates;
+    num_tasks += 1; // CancelRebalance;
+    if (rebalance_type == rebalanceIntent_1.RebalanceType.Deposit) {
+        num_tasks += 1; // MintBasket;
+    }
+    if (rebalance_type == rebalanceIntent_1.RebalanceType.Deposit || rebalance_type == rebalanceIntent_1.RebalanceType.Withdraw) {
+        num_tasks += num_tokens; // TokenSettlement;
+    }
+    else {
+        num_tasks += 1; // AuctionCreation;
+    }
+    let claim_bounty_tasks = (num_tasks + constants_1.MAX_TRANSFER_TOKENS - 1) / constants_1.MAX_TRANSFER_TOKENS;
+    let price_update_tasks = num_tokens;
+    let tasks = num_tasks + claim_bounty_tasks;
+    let bounty_total = bounty_per_price_update_task_max * price_update_tasks +
+        bounty_per_task * tasks +
+        bounty_bond;
+    return bounty_total;
+}
+function formatRebalanceIntent(rebalanceIntent, basket) {
+    var _a, _b, _c, _d;
+    let numTokens = constants_1.MAX_SUPPORTED_TOKENS_PER_BASKET;
+    while (numTokens > 0 && rebalanceIntent.tokens[numTokens - 1].mint.equals(web3_js_1.PublicKey.default))
+        numTokens--;
+    rebalanceIntent.tokens = rebalanceIntent.tokens.slice(0, numTokens);
+    rebalanceIntent.priceUpdateTasks = rebalanceIntent.priceUpdateTasks.slice(0, numTokens);
+    rebalanceIntent.tokenSettlementTasks = rebalanceIntent.tokenSettlementTasks.slice(0, numTokens);
+    let priceUpdateTasks = [];
+    for (let i = 0; i < numTokens; i++) {
+        priceUpdateTasks.push({
+            completed_by: rebalanceIntent.priceUpdateTasks[i].completedBy.toBase58(),
+            completed_bounty: parseInt(rebalanceIntent.priceUpdateTasks[i].completedBounty.toString()),
+            completed_time: parseInt(rebalanceIntent.priceUpdateTasks[i].completedTime.toString()),
+        });
+    }
+    let tokenSettlementTasks = [];
+    for (let i = 0; i < numTokens; i++) {
+        tokenSettlementTasks.push({
+            completed_by: rebalanceIntent.tokenSettlementTasks[i].completedBy.toBase58(),
+            completed_bounty: parseInt(rebalanceIntent.tokenSettlementTasks[i].completedBounty.toString()),
+            completed_time: parseInt(rebalanceIntent.tokenSettlementTasks[i].completedTime.toString()),
+        });
+    }
+    let placeholderTask = {
+        completed_by: rebalanceIntent.placeholderTask.completedBy.toBase58(),
+        completed_bounty: parseInt(rebalanceIntent.placeholderTask.completedBounty.toString()),
+        completed_time: parseInt(rebalanceIntent.placeholderTask.completedTime.toString()),
+    };
+    let finishPriceUpdateTask = {
+        completed_by: rebalanceIntent.finishPriceUpdateTask.completedBy.toBase58(),
+        completed_bounty: parseInt(rebalanceIntent.finishPriceUpdateTask.completedBounty.toString()),
+        completed_time: parseInt(rebalanceIntent.finishPriceUpdateTask.completedTime.toString()),
+    };
+    let auctionCreationTask = {
+        completed_by: rebalanceIntent.auctionCreationTask.completedBy.toBase58(),
+        completed_bounty: parseInt(rebalanceIntent.auctionCreationTask.completedBounty.toString()),
+        completed_time: parseInt(rebalanceIntent.auctionCreationTask.completedTime.toString()),
+    };
+    let mintBasketTask = {
+        completed_by: rebalanceIntent.mintBasketTask.completedBy.toBase58(),
+        completed_bounty: parseInt(rebalanceIntent.mintBasketTask.completedBounty.toString()),
+        completed_time: parseInt(rebalanceIntent.mintBasketTask.completedTime.toString()),
+    };
+    let cancelRebalanceTask = {
+        completed_by: rebalanceIntent.cancelRebalanceTask.completedBy.toBase58(),
+        completed_bounty: parseInt(rebalanceIntent.cancelRebalanceTask.completedBounty.toString()),
+        completed_time: parseInt(rebalanceIntent.cancelRebalanceTask.completedTime.toString()),
+    };
+    let tasks = [
+        placeholderTask,
+        finishPriceUpdateTask,
+        auctionCreationTask,
+        mintBasketTask,
+        cancelRebalanceTask,
+        ...tokenSettlementTasks,
+        ...priceUpdateTasks,
+    ];
+    let depositData = {
+        tokens: rebalanceIntent.tokens.map(token => ({
+            mint: token.mint.toBase58(),
+            amount: parseInt(token.amount.toString()),
+        })),
+    };
+    let priceUpdatesData = {
+        tokens: rebalanceIntent.priceUpdateTasks.map((task, index) => ({
+            mint: rebalanceIntent.tokens[index].mint.toBase58(),
+            updated: parseInt(task.completedTime.toString()) > 0 ? true : false,
+            price: (0, fraction_1.fractionToDecimal)(rebalanceIntent.tokens[index].price.price).toNumber(),
+            conf: (0, fraction_1.fractionToDecimal)(rebalanceIntent.tokens[index].price.conf).toNumber(),
+            expiration: parseInt(task.completedTime.toString()) + 60,
+            update_time: parseInt(task.completedTime.toString()),
+        })),
+    };
+    let auctionData = {
+        auction_stages: rebalanceIntent.auctions.map(auction => ({
+            start_time: parseInt(auction.startTime.toString()),
+            end_time: parseInt(auction.endTime.toString()),
+        })),
+        tokens: rebalanceIntent.tokens.map(token => ({
+            mint: token.mint.toBase58(),
+            amount: parseInt(token.amount.toString()),
+            target_amount: parseInt(token.targetAmount.toString()),
+            price: (0, fraction_1.fractionToDecimal)(token.price.price).toNumber(),
+            conf: (0, fraction_1.fractionToDecimal)(token.price.conf).toNumber(),
+        })),
+    };
+    let mintData = {
+        mintAmount: 0,
+        mintValue: 0,
+        fees: {
+            host: 0,
+            creator: 0,
+            managers: 0,
+            symmetry: 0,
+            basket: 0,
+        },
+        tokens: auctionData.tokens.map(token => ({
+            mint: token.mint,
+            contribution_amount: 0,
+            remaining_amount: 0,
+        })),
+    };
+    if (basket) {
+        let minRatio = 1;
+        for (let i = 0; i < basket.composition.length; i++) {
+            if (basket.composition[i].amount == 0)
+                continue;
+            let ratio = auctionData.tokens[i].amount / basket.composition[i].amount;
+            minRatio = Math.min(minRatio, ratio);
+        }
+        let mintValue = 0;
+        let remainingValue = 0;
+        let mintAmount = Math.floor(basket.supply_outstanding * minRatio);
+        for (let i = 0; i < basket.composition.length; i++) {
+            let contributionAmount = Math.floor(basket.composition[i].amount * minRatio);
+            contributionAmount = Math.min(contributionAmount, auctionData.tokens[i].amount);
+            mintData.tokens[i].contribution_amount = contributionAmount;
+            mintData.tokens[i].remaining_amount = auctionData.tokens[i].amount - contributionAmount;
+            mintValue += contributionAmount * auctionData.tokens[i].price;
+            remainingValue += (auctionData.tokens[i].amount - contributionAmount) * auctionData.tokens[i].price;
+        }
+        mintData.mintValue = mintValue;
+        mintData.mintAmount = mintAmount;
+        mintData.fees.host = Math.floor(mintValue * rebalanceIntent.basketFeeSettings.hostDepositFeeBps / constants_1.HUNDRED_PERCENT_BPS);
+        mintData.fees.creator = Math.floor(mintValue * rebalanceIntent.basketFeeSettings.creatorDepositFeeBps / constants_1.HUNDRED_PERCENT_BPS);
+        mintData.fees.managers = Math.floor(mintValue * rebalanceIntent.basketFeeSettings.managersDepositFeeBps / constants_1.HUNDRED_PERCENT_BPS);
+        mintData.fees.basket = Math.floor(mintValue * rebalanceIntent.basketFeeSettings.basketDepositFeeBps / constants_1.HUNDRED_PERCENT_BPS);
+        mintData.fees.symmetry = Math.floor(mintValue * 10 / constants_1.HUNDRED_PERCENT_BPS);
+        mintData.mintAmount -= mintData.fees.host + mintData.fees.creator + mintData.fees.managers + mintData.fees.symmetry + mintData.fees.basket;
+    }
+    let redeemData = {
+        tokens: rebalanceIntent.tokens.map(token => ({
+            mint: token.mint.toBase58(),
+            amount: parseInt(token.amount.toString()),
+        })).filter(token => token.amount > 0),
+    };
+    let bountyData = {
+        bounty_mint: rebalanceIntent.bounty.bountyMint.toBase58(),
+        keepers: [],
+        unused_bounty: {
+            pubkey: rebalanceIntent.bounty.bountyDepositor.toBase58(),
+            bounty_amount: parseInt(rebalanceIntent.bounty.bountyLeft.toString()),
+        },
+        rent: {
+            pubkey: rebalanceIntent.rentPayer.toBase58(),
+            sol_amount: (_a = rebalanceIntent.solBalance) !== null && _a !== void 0 ? _a : 0,
+        },
+    };
+    for (let i = 0; i < tasks.length; i++) {
+        if (tasks[i].completed_bounty > 0) {
+            let indexOf = bountyData.keepers.findIndex(keeper => keeper.pubkey == tasks[i].completed_by);
+            if (indexOf == -1) {
+                bountyData.keepers.push({
+                    pubkey: tasks[i].completed_by,
+                    bounty_amount: tasks[i].completed_bounty,
+                });
+                bountyData.unused_bounty.bounty_amount -= tasks[i].completed_bounty;
+            }
+            else {
+                bountyData.keepers[indexOf].bounty_amount += tasks[i].completed_bounty;
+            }
+        }
+    }
+    let formatted = {
+        pubkey: rebalanceIntent.ownAddress.toBase58(),
+        sol_balance: (_b = rebalanceIntent.solBalance) !== null && _b !== void 0 ? _b : 0,
+        basket: rebalanceIntent.basket.toBase58(),
+        owner: rebalanceIntent.owner.toBase58(),
+        rent_payer: rebalanceIntent.rentPayer.toBase58(),
+        rebalance_type: (_c = rebalanceIntent_1.REBALANCE_TYPE_STRINGS.get(rebalanceIntent.rebalanceType)) !== null && _c !== void 0 ? _c : "basket_custom",
+        current_action: (_d = rebalanceIntent_1.REBALANCE_ACTION_STRINGS.get(rebalanceIntent.currentAction)) !== null && _d !== void 0 ? _d : "not_active",
+        withdraw_params_burn_amount: parseInt(rebalanceIntent.withdrawParamsBurnAmount.toString()),
+        withdraw_params_amount_wo_fees: parseInt(rebalanceIntent.withdrawParamsAmountWoFees.toString()),
+        withdraw_params_keep_tokens_bitmask: rebalanceIntent.withdrawParamsKeepTokensBitmask,
+        withdraw_params_keep_all_tokens: rebalanceIntent.withdrawParamsKeepAllTokens == 1 ? true : false,
+        basket_fee_settings: {
+            host_deposit_fee_bps: rebalanceIntent.basketFeeSettings.hostDepositFeeBps,
+            host_withdraw_fee_bps: rebalanceIntent.basketFeeSettings.hostWithdrawFeeBps,
+            host_management_fee_bps: rebalanceIntent.basketFeeSettings.hostManagementFeeBps,
+            host_performance_fee_bps: rebalanceIntent.basketFeeSettings.hostPerformanceFeeBps,
+            creator_deposit_fee_bps: rebalanceIntent.basketFeeSettings.creatorDepositFeeBps,
+            creator_withdraw_fee_bps: rebalanceIntent.basketFeeSettings.creatorWithdrawFeeBps,
+            creator_management_fee_bps: rebalanceIntent.basketFeeSettings.creatorManagementFeeBps,
+            creator_performance_fee_bps: rebalanceIntent.basketFeeSettings.creatorPerformanceFeeBps,
+            managers_deposit_fee_bps: rebalanceIntent.basketFeeSettings.managersDepositFeeBps,
+            managers_withdraw_fee_bps: rebalanceIntent.basketFeeSettings.managersWithdrawFeeBps,
+            managers_management_fee_bps: rebalanceIntent.basketFeeSettings.managersManagementFeeBps,
+            managers_performance_fee_bps: rebalanceIntent.basketFeeSettings.managersPerformanceFeeBps,
+            basket_deposit_fee_bps: rebalanceIntent.basketFeeSettings.basketDepositFeeBps,
+            basket_withdraw_fee_bps: rebalanceIntent.basketFeeSettings.basketWithdrawFeeBps,
+            modification_delay: parseInt(rebalanceIntent.basketFeeSettings.modificationDelay.toString()),
+            updated_at: 0,
+        },
+        execution_start_time: parseInt(rebalanceIntent.executionStartTime.toString()),
+        rebalance_threshold_slippage_bps: rebalanceIntent.rebalanceThresholdSlippageBps,
+        per_trade_rebalance_threshold_slippage_bps: rebalanceIntent.perTradeRebalanceThresholdSlippageBps,
+        initial_tvl: (0, fraction_1.fractionToDecimal)(rebalanceIntent.initialTvl).toNumber(),
+        auction_update_timestamp: parseInt(rebalanceIntent.auctionUpdateTimestamp.toString()),
+        auctions: rebalanceIntent.auctions.map(auction => ({
+            start_time: parseInt(auction.startTime.toString()),
+            end_time: parseInt(auction.endTime.toString()),
+        })),
+        tokens: rebalanceIntent.tokens.map(token => ({
+            mint: token.mint.toBase58(),
+            amount: parseInt(token.amount.toString()),
+            target_amount: parseInt(token.targetAmount.toString()),
+            price: {
+                price: (0, fraction_1.fractionToDecimal)(token.price.price).toNumber(),
+                conf: (0, fraction_1.fractionToDecimal)(token.price.conf).toNumber(),
+                update_time: parseInt(token.price.updateTime.toString()),
+            },
+            keep_token: token.keepToken == 1 ? true : false,
+        })),
+        last_action_timestamp: parseInt(rebalanceIntent.lastActionTimestamp.toString()),
+        bounty: {
+            bounty_depositor: rebalanceIntent.bounty.bountyDepositor.toBase58(),
+            bounty_mint: rebalanceIntent.bounty.bountyMint.toBase58(),
+            bounty_per_price_update_task: {
+                min_bounty: parseInt(rebalanceIntent.bounty.bountyPerPriceUpdateTask.minBounty.toString()),
+                max_bounty: parseInt(rebalanceIntent.bounty.bountyPerPriceUpdateTask.maxBounty.toString()),
+                min_bounty_until: parseInt(rebalanceIntent.bounty.bountyPerPriceUpdateTask.minBountyUntil.toString()),
+                max_bounty_after: parseInt(rebalanceIntent.bounty.bountyPerPriceUpdateTask.maxBountyAfter.toString()),
+            },
+            bounty_per_task: {
+                min_bounty: parseInt(rebalanceIntent.bounty.bountyPerTask.minBounty.toString()),
+                max_bounty: parseInt(rebalanceIntent.bounty.bountyPerTask.maxBounty.toString()),
+                min_bounty_until: parseInt(rebalanceIntent.bounty.bountyPerTask.minBountyUntil.toString()),
+                max_bounty_after: parseInt(rebalanceIntent.bounty.bountyPerTask.maxBountyAfter.toString()),
+            },
+            bounty_total: parseInt(rebalanceIntent.bounty.bountyTotal.toString()),
+            bounty_left: parseInt(rebalanceIntent.bounty.bountyLeft.toString()),
+        },
+        bounty_adjustment_amount: parseInt(rebalanceIntent.bountyAdjustmentAmount.toString()),
+        placeholder_task: placeholderTask,
+        price_update_tasks: priceUpdateTasks,
+        finish_price_update_task: finishPriceUpdateTask,
+        auction_creation_task: auctionCreationTask,
+        mint_basket_task: mintBasketTask,
+        cancel_rebalance_task: cancelRebalanceTask,
+        token_settlement_tasks: tokenSettlementTasks,
+    };
+    let uiRebalanceIntent = {
+        rebalance_type: formatted.mint_basket_task.completed_time > 0 ? "deposit" : formatted.rebalance_type,
+        formatted_data: formatted,
+        chain_data: rebalanceIntent,
+        deposit_data: null,
+        price_updates_data: null,
+        auction_data: null,
+        mint_data: null,
+        redeem_data: null,
+        claim_bounty_data: null,
+    };
+    if (formatted.current_action == "deposit_tokens") {
+        uiRebalanceIntent.deposit_data = depositData;
+    }
+    if (formatted.current_action == "update_prices") {
+        uiRebalanceIntent.price_updates_data = priceUpdatesData;
+    }
+    if (formatted.current_action == "auction") {
+        let now = Math.floor(Date.now() / 1000);
+        if (now <= auctionData.auction_stages[2].end_time) {
+            uiRebalanceIntent.auction_data = auctionData;
+        }
+        else {
+            if (formatted.rebalance_type == "deposit") {
+                uiRebalanceIntent.mint_data = mintData;
+            }
+            else if (formatted.rebalance_type == "withdraw" && redeemData.tokens.length > 0) {
+                uiRebalanceIntent.redeem_data = redeemData;
+            }
+            else {
+                uiRebalanceIntent.claim_bounty_data = bountyData;
+            }
+        }
+    }
+    return uiRebalanceIntent;
+}
+function fetchRebalanceIntent(connection, rebalanceIntentAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const rebalanceIntentAi = yield connection.getAccountInfo(rebalanceIntentAddress);
+        if (!rebalanceIntentAi)
+            throw new Error("Rebalance intent not found");
+        let rebalanceIntent = rebalanceIntent_1.RebalanceIntentLayout.decode(rebalanceIntentAi.data.slice(8));
+        rebalanceIntent.ownAddress = rebalanceIntentAddress;
+        rebalanceIntent.solBalance = (_a = rebalanceIntentAi.lamports) !== null && _a !== void 0 ? _a : 0;
+        let basket = (yield (0, basket_1.fetchBasket)(connection, rebalanceIntent.basket)).formatted;
+        return formatRebalanceIntent(rebalanceIntent, basket);
+    });
+}
+function fetchRebalanceIntentsMultiple(connection, rebalanceIntentAddresses) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let multipleAccountsInfo = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(connection, rebalanceIntentAddresses);
+        let rebalanceIntents = rebalanceIntentAddresses.map(address => {
+            var _a;
+            let ai = multipleAccountsInfo.get(address.toBase58());
+            if (!ai)
+                return null;
+            return Object.assign(Object.assign({}, rebalanceIntent_1.RebalanceIntentLayout.decode(ai.data.slice(8))), { ownAddress: address, solBalance: (_a = ai.lamports) !== null && _a !== void 0 ? _a : 0 });
+        }).filter(rebalanceIntent => rebalanceIntent !== null);
+        let formattedRebalanceIntents = rebalanceIntents.map(rebalanceIntent => formatRebalanceIntent(rebalanceIntent));
+        let rebalanceIntentsMap = new Map();
+        for (let rebalanceIntent of formattedRebalanceIntents)
+            rebalanceIntentsMap.set(rebalanceIntent.formatted_data.pubkey, rebalanceIntent);
+        return rebalanceIntentsMap;
+    });
+}
+function fetchRebalanceIntents(connection, filter) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let accountFilters = [
+            { dataSize: 8 + rebalanceIntent_1.RebalanceIntentLayout.getSpan() },
+        ];
+        if ((filter === null || filter === void 0 ? void 0 : filter.type) === "basket") {
+            accountFilters.push({ memcmp: {
+                    offset: 8,
+                    bytes: filter.pubkey
+                } });
+        }
+        else if ((filter === null || filter === void 0 ? void 0 : filter.type) === "owner") {
+            accountFilters.push({ memcmp: {
+                    offset: 8 + 32,
+                    bytes: filter.pubkey
+                } });
+        }
+        const accounts = yield connection
+            .getProgramAccounts(constants_1.BASKETS_V3_PROGRAM_ID, {
+            commitment: "confirmed",
+            filters: accountFilters,
+            encoding: 'base64'
+        });
+        let basket;
+        if (filter && filter.type === "basket") {
+            basket = (yield (0, basket_1.fetchBasket)(connection, new web3_js_1.PublicKey(filter.pubkey))).formatted;
+        }
+        let rebalanceIntents = accounts.map(account => {
+            var _a;
+            let rebalanceIntent = rebalanceIntent_1.RebalanceIntentLayout.decode(account.account.data.slice(8));
+            rebalanceIntent.ownAddress = account.pubkey;
+            rebalanceIntent.solBalance = (_a = account.account.lamports) !== null && _a !== void 0 ? _a : 0;
+            return formatRebalanceIntent(rebalanceIntent, basket);
+        });
+        return rebalanceIntents;
+    });
+}
+class RebalanceIntentRustClass {
+    constructor(rebalanceIntent) {
+        this.self = rebalanceIntent;
+    }
+    findTokenIndex(mint) {
+        for (let i = 0; i < this.self.priceUpdateTasks.length; i++)
+            if (this.self.tokens[i].mint.equals(mint))
+                return i;
+        return undefined;
+    }
+    getSelfTvl() {
+        let selfTvl = { high: new bn_js_1.default(0), low: new bn_js_1.default(0) };
+        for (let i = 0; i < this.self.priceUpdateTasks.length; i++) {
+            if (this.self.priceUpdateTasks[i].completedTime.isZero()) {
+                continue;
+            }
+            const tokenAuction = this.self.tokens[i];
+            const tokenPrice = tokenAuction.price; // contains .price (mid)
+            if (!tokenPrice || !tokenAuction.amount)
+                continue;
+            // price * amount
+            const tokenValue = (0, fraction_1.fractionMul)(tokenPrice.price, { high: new bn_js_1.default(tokenAuction.amount), low: new bn_js_1.default(0) });
+            selfTvl = (0, fraction_1.fractionAdd)(selfTvl, tokenValue);
+        }
+        return selfTvl;
+    }
+    getBasketTvlAndWeightSum(basket) {
+        let basketTvl = { high: new bn_js_1.default(0), low: new bn_js_1.default(0) };
+        let weightSum = 0;
+        for (let i = 0; i < basket.numTokens; i++) {
+            const basketToken = basket.composition[i];
+            weightSum += basketToken.weight;
+            if (basketToken.amount.isZero()) {
+                continue;
+            }
+            const tokenIndex = this.findTokenIndex(basketToken.mint);
+            if (tokenIndex === undefined)
+                throw new Error("TokenNotFound");
+            if (this.self.priceUpdateTasks[tokenIndex].completedTime.isZero())
+                throw new Error("PriceUpdateNotCompleted");
+            const tokenPrice = this.self.tokens[tokenIndex].price;
+            // price * amount
+            const tokenValue = (0, fraction_1.fractionMul)(tokenPrice.price, { high: new bn_js_1.default(basketToken.amount), low: new bn_js_1.default(0) });
+            basketTvl = (0, fraction_1.fractionAdd)(basketTvl, tokenValue);
+        }
+        return { basketTvl, weightSum };
+    }
+    getPriceChange(price, timeSinceAuctionStart, auctionDuration) {
+        // price_change = conf * 2 * time_since_auction_start / auction_duration
+        if (auctionDuration.isZero()) {
+            throw new Error("AuctionNotLive");
+        }
+        // conf * 2
+        const confTimes2 = (0, fraction_1.fractionMul)(price.conf, { high: new bn_js_1.default(2), low: new bn_js_1.default(0) });
+        // conf * 2 * time_since_auction_start
+        const confTimes2TimesTime = (0, fraction_1.fractionMul)(confTimes2, { high: new bn_js_1.default(timeSinceAuctionStart), low: new bn_js_1.default(0) });
+        // (conf * 2 * time_since_auction_start) / auction_duration
+        const auctionDurationFraction = { high: new bn_js_1.default(auctionDuration), low: new bn_js_1.default(0) };
+        return (0, fraction_1.fractionDiv)(confTimes2TimesTime, auctionDurationFraction);
+    }
+    getSellPrice(price, timeSinceAuctionStart, auctionDuration) {
+        // sell_price = high() - get_price_change()
+        // high() = price + conf
+        const high = (0, fraction_1.fractionAdd)(price.price, price.conf);
+        const priceChange = this.getPriceChange(price, timeSinceAuctionStart, auctionDuration);
+        return (0, fraction_1.fractionSub)(high, priceChange);
+    }
+    getBuyPrice(price, timeSinceAuctionStart, auctionDuration) {
+        // buy_price = low() + get_price_change()
+        // low() = price - conf
+        const low = (0, fraction_1.fractionSub)(price.price, price.conf);
+        const priceChange = this.getPriceChange(price, timeSinceAuctionStart, auctionDuration);
+        return (0, fraction_1.fractionAdd)(low, priceChange);
+    }
+    getExchangeRate(outToken, inToken, timeSinceAuctionStart, auctionDuration) {
+        const outAmount = outToken.amount;
+        const outTargetAmount = outToken.targetAmount;
+        const inAmount = inToken.amount;
+        const inTargetAmount = inToken.targetAmount;
+        if (outAmount.lte(outTargetAmount))
+            throw new Error("InvalidSwap");
+        if (inAmount.gte(inTargetAmount))
+            throw new Error("InvalidSwap");
+        const maxAmountToSell = outAmount.sub(outTargetAmount);
+        const maxAmountToBuy = inTargetAmount.sub(inAmount);
+        const sellRate = this.getSellPrice(outToken.price, timeSinceAuctionStart, auctionDuration);
+        const buyRate = this.getBuyPrice(inToken.price, timeSinceAuctionStart, auctionDuration);
+        // sellValue = sellRate * maxAmountToSell
+        const sellValue = (0, fraction_1.fractionMul)(sellRate, { high: new bn_js_1.default(maxAmountToSell), low: new bn_js_1.default(0) });
+        // buyValue = buyRate * maxAmountToBuy
+        const buyValue = (0, fraction_1.fractionMul)(buyRate, { high: new bn_js_1.default(maxAmountToBuy), low: new bn_js_1.default(0) });
+        let sellSideLimits;
+        if ((0, fraction_1.fractionLte)(sellValue, buyValue)) {
+            sellSideLimits = true;
+        }
+        else if (!outTargetAmount.isZero()) {
+            sellSideLimits = false;
+        }
+        else {
+            // adjustedSellValue = sellValue * (HUNDRED_PERCENT_BPS - 100) / HUNDRED_PERCENT_BPS
+            const adjustmentFactor = (0, fraction_1.fractionDiv)({ high: new bn_js_1.default(constants_1.HUNDRED_PERCENT_BPS - 100), low: new bn_js_1.default(0) }, { high: new bn_js_1.default(constants_1.HUNDRED_PERCENT_BPS), low: new bn_js_1.default(0) });
+            const adjustedSellValue = (0, fraction_1.fractionMul)(sellValue, adjustmentFactor);
+            sellSideLimits = (0, fraction_1.fractionLte)(adjustedSellValue, buyValue);
+        }
+        if (sellSideLimits) {
+            // amountToBuy = sellValue / buyRate (rounded up)
+            const amountToBuy = (0, fraction_1.fractionRoundUp)((0, fraction_1.fractionDiv)(sellValue, buyRate));
+            return {
+                amountToSell: maxAmountToSell,
+                amountToBuy: amountToBuy,
+                exchangeValue: sellValue,
+            };
+        }
+        else {
+            // amountToSell = buyValue / sellRate (rounded down)
+            const amountToSell = (0, fraction_1.fractionRoundDown)((0, fraction_1.fractionDiv)(buyValue, sellRate));
+            return {
+                amountToSell: amountToSell,
+                amountToBuy: maxAmountToBuy,
+                exchangeValue: buyValue,
+            };
+        }
+    }
+    getSwapAmounts(inTokenIndex, outTokenIndex, timeSinceAuctionStart, auctionDuration) {
+        if (inTokenIndex === outTokenIndex)
+            throw new Error("InvalidSwap");
+        if (this.self.priceUpdateTasks[inTokenIndex].completedTime.isZero())
+            throw new Error("PriceUpdateNotCompleted");
+        if (this.self.priceUpdateTasks[outTokenIndex].completedTime.isZero())
+            throw new Error("PriceUpdateNotCompleted");
+        const inToken = this.self.tokens[inTokenIndex];
+        const outToken = this.self.tokens[outTokenIndex];
+        const exchangeRate = this.getExchangeRate(outToken, inToken, timeSinceAuctionStart, auctionDuration);
+        let basketBuys = exchangeRate.amountToBuy;
+        let basketSells = exchangeRate.amountToSell;
+        // inValue = inTokenPrice * basketBuys
+        const inValue = (0, fraction_1.fractionMul)(inToken.price.price, { high: new bn_js_1.default(basketBuys), low: new bn_js_1.default(0) });
+        // outValue = outTokenPrice * basketSells
+        const outValue = (0, fraction_1.fractionMul)(outToken.price.price, { high: new bn_js_1.default(basketSells), low: new bn_js_1.default(0) });
+        // slippageFactor = (HUNDRED_PERCENT_BPS - bps) / HUNDRED_PERCENT_BPS
+        const slippageFactor = (0, fraction_1.fractionDiv)({ high: new bn_js_1.default(constants_1.HUNDRED_PERCENT_BPS - this.self.perTradeRebalanceThresholdSlippageBps), low: new bn_js_1.default(0) }, { high: new bn_js_1.default(constants_1.HUNDRED_PERCENT_BPS), low: new bn_js_1.default(0) });
+        // Check: inValue < outValue * slippageFactor
+        const outValueWithSlippage = (0, fraction_1.fractionMul)(outValue, slippageFactor);
+        if ((0, fraction_1.fractionLt)(inValue, outValueWithSlippage)) {
+            throw new Error("RebalanceSlippageExceeded");
+        }
+        const selfTvl = this.getSelfTvl();
+        // minSelfTvl = initialTvl * (HUNDRED_PERCENT_BPS - rebalanceThresholdSlippageBps) / HUNDRED_PERCENT_BPS
+        const tvlSlippageFactor = (0, fraction_1.fractionDiv)({ high: new bn_js_1.default(constants_1.HUNDRED_PERCENT_BPS - this.self.rebalanceThresholdSlippageBps), low: new bn_js_1.default(0) }, { high: new bn_js_1.default(constants_1.HUNDRED_PERCENT_BPS), low: new bn_js_1.default(0) });
+        const minSelfTvl = (0, fraction_1.fractionMul)(this.self.initialTvl, tvlSlippageFactor);
+        if ((0, fraction_1.fractionLt)(selfTvl, minSelfTvl)) {
+            throw new Error("RebalanceSlippageExceeded");
+        }
+        return exchangeRate;
+    }
+    updateTargetAmounts(basket) {
+        this.self.auctionUpdateTimestamp = new bn_js_1.default(Math.floor(Date.now() / 1000));
+        const selfTvl = this.getSelfTvl();
+        const { basketTvl, weightSum } = this.getBasketTvlAndWeightSum(basket);
+        for (let tokenIndex = 0; tokenIndex < this.self.priceUpdateTasks.length; tokenIndex++) {
+            if (this.self.tokens[tokenIndex].mint.equals(web3_js_1.PublicKey.default)) {
+                continue;
+            }
+            if (this.self.priceUpdateTasks[tokenIndex].completedTime.isZero()) {
+                continue;
+            }
+            const auctionToken = this.self.tokens[tokenIndex];
+            const auctionTokenPrice = auctionToken.price;
+            const tokenPrice = auctionTokenPrice.price;
+            if (this.self.rebalanceType === rebalanceIntent_1.RebalanceType.Withdraw) {
+                this.self.tokens[tokenIndex].targetAmount = new bn_js_1.default(0);
+                if (auctionToken.keepToken === 1) {
+                    // targetAmount = selfTvl / tokenPrice (rounded down) * 2
+                    const targetAmount = (0, fraction_1.fractionRoundDown)((0, fraction_1.fractionDiv)(selfTvl, tokenPrice));
+                    this.self.tokens[tokenIndex].targetAmount = targetAmount.mul(new bn_js_1.default(2));
+                }
+                continue;
+            }
+            // Find token index in basket composition
+            let tokenIndexInBasket = undefined;
+            for (let i = 0; i < basket.numTokens; i++) {
+                if (basket.composition[i].mint.equals(this.self.tokens[tokenIndex].mint)) {
+                    tokenIndexInBasket = i;
+                    break;
+                }
+            }
+            if (tokenIndexInBasket === undefined) {
+                this.self.tokens[tokenIndex].targetAmount = new bn_js_1.default(0);
+                continue;
+            }
+            const basketToken = basket.composition[tokenIndexInBasket];
+            if (this.self.rebalanceType === rebalanceIntent_1.RebalanceType.Deposit && basket.supplyOutstanding.gt(new bn_js_1.default(0))) {
+                // targetAmount = (basketToken.amount * selfTvl) / basketTvl (rounded down)
+                const basketTokenAmountFraction = { high: new bn_js_1.default(basketToken.amount), low: new bn_js_1.default(0) };
+                const numerator = (0, fraction_1.fractionMul)(basketTokenAmountFraction, selfTvl);
+                const targetAmount = (0, fraction_1.fractionRoundDown)((0, fraction_1.fractionDiv)(numerator, basketTvl));
+                this.self.tokens[tokenIndex].targetAmount = targetAmount;
+            }
+            if (this.self.rebalanceType === rebalanceIntent_1.RebalanceType.Deposit && basket.supplyOutstanding.isZero()) {
+                // targetValue = selfTvl * weight / weightSum
+                // targetAmount = targetValue / tokenPrice (rounded down)
+                const targetValue = (0, fraction_1.fractionDiv)((0, fraction_1.fractionMul)(selfTvl, { high: new bn_js_1.default(basketToken.weight), low: new bn_js_1.default(0) }), { high: new bn_js_1.default(weightSum), low: new bn_js_1.default(0) });
+                const targetAmount = (0, fraction_1.fractionRoundDown)((0, fraction_1.fractionDiv)(targetValue, tokenPrice));
+                this.self.tokens[tokenIndex].targetAmount = targetAmount;
+            }
+            if (this.self.rebalanceType === rebalanceIntent_1.RebalanceType.Basket || this.self.rebalanceType === rebalanceIntent_1.RebalanceType.BasketCustom) {
+                // targetValue = basketTvl * weight / weightSum
+                // targetAmount = targetValue / tokenPrice (rounded down)
+                const targetValue = (0, fraction_1.fractionDiv)((0, fraction_1.fractionMul)(basketTvl, { high: new bn_js_1.default(basketToken.weight), low: new bn_js_1.default(0) }), { high: new bn_js_1.default(weightSum), low: new bn_js_1.default(0) });
+                let targetAmount = (0, fraction_1.fractionRoundDown)((0, fraction_1.fractionDiv)(targetValue, tokenPrice));
+                if (this.self.bounty.bountyMint.equals(auctionToken.mint)) {
+                    targetAmount = targetAmount.add(this.self.bountyAdjustmentAmount);
+                }
+                this.self.tokens[tokenIndex].targetAmount = targetAmount;
+            }
+        }
+    }
+}
+/**
+ * Returns all valid swap pairs available during the rebalance auction phase.
+ *
+ * **Swap direction (basket perspective):**
+ * - `inMint` / `inAmount`: what the basket is supposed to **receive**.
+ * - `outMint` / `outAmount`: what the basket wants to **swap** (give away).
+ * So each pair describes an **outMint → inMint** swap. When generating swap
+ * transactions, use this direction: swap `outMint` → `inMint` (sell outAmount of
+ * outMint, receive inAmount of inMint).
+ *
+ * Only runs when the rebalance is in Auction action and the current time falls
+ * within one of the three auction windows. For the active auction, target amounts
+ * are refreshed if they haven't been updated since the auction started.
+ *
+ * Iterates over completed price-update tokens to compute exchange rates via
+ * getSwapAmounts (using time-since-start and auction duration). Pairs with
+ * positive in/out amounts are collected and sorted by value descending
+ * (highest value first).
+ *
+ * @param rebalanceIntent - The rebalance intent state
+ * @param basket - The basket (used to update target amounts when needed)
+ * @returns Array of swap pairs, or empty array when not in auction or outside auction windows
+ */
+function getSwapPairs(rebalanceIntent, basket) {
+    let rebalanceIntentRustClass = new RebalanceIntentRustClass(rebalanceIntent);
+    if (rebalanceIntentRustClass.self.currentAction !== rebalanceIntent_1.RebalanceAction.Auction)
+        return [];
+    const timestamp = new bn_js_1.default(Math.floor(Date.now() / 1000));
+    let currentAuction;
+    if (rebalanceIntentRustClass.self.auctions[0].startTime.lte(timestamp) && timestamp.lt(rebalanceIntentRustClass.self.auctions[0].endTime))
+        currentAuction = rebalanceIntentRustClass.self.auctions[0];
+    else if (rebalanceIntentRustClass.self.auctions[1].startTime.lte(timestamp) && timestamp.lt(rebalanceIntentRustClass.self.auctions[1].endTime))
+        currentAuction = rebalanceIntentRustClass.self.auctions[1];
+    else if (rebalanceIntentRustClass.self.auctions[2].startTime.lte(timestamp) && timestamp.lt(rebalanceIntentRustClass.self.auctions[2].endTime))
+        currentAuction = rebalanceIntentRustClass.self.auctions[2];
+    else
+        return [];
+    let start_time = currentAuction.startTime;
+    if (rebalanceIntentRustClass.self.auctionUpdateTimestamp.lt(start_time))
+        rebalanceIntentRustClass.updateTargetAmounts(basket);
+    let timeSinceAuctionStart = timestamp.sub(currentAuction.startTime);
+    let auctionDuration = currentAuction.endTime.sub(currentAuction.startTime);
+    let allPairs = [];
+    for (let inTokenIndex = 0; inTokenIndex < rebalanceIntentRustClass.self.priceUpdateTasks.length; inTokenIndex++) {
+        if (rebalanceIntentRustClass.self.priceUpdateTasks[inTokenIndex].completedTime.isZero())
+            continue;
+        for (let outTokenIndex = 0; outTokenIndex < rebalanceIntentRustClass.self.priceUpdateTasks.length; outTokenIndex++) {
+            if (inTokenIndex === outTokenIndex)
+                continue;
+            if (rebalanceIntentRustClass.self.priceUpdateTasks[outTokenIndex].completedTime.isZero())
+                continue;
+            try {
+                let exchangeRate = rebalanceIntentRustClass.getSwapAmounts(inTokenIndex, outTokenIndex, timeSinceAuctionStart, auctionDuration);
+                if (parseInt(exchangeRate.amountToBuy.toString()) > 0 && parseInt(exchangeRate.amountToSell.toString()) > 0) {
+                    allPairs.push({
+                        inMint: rebalanceIntentRustClass.self.tokens[inTokenIndex].mint.toBase58(),
+                        outMint: rebalanceIntentRustClass.self.tokens[outTokenIndex].mint.toBase58(),
+                        inAmount: parseInt(exchangeRate.amountToBuy.toString()),
+                        outAmount: parseInt(exchangeRate.amountToSell.toString()),
+                        value: (0, fraction_1.fractionToDecimal)(exchangeRate.exchangeValue).toNumber(),
+                    });
+                }
+            }
+            catch (_a) { }
+        }
+    }
+    allPairs.sort((a, b) => b.value - a.value);
+    return allPairs;
+}