@symmetry-hq/sdk 1.0.1

package/dist/src/index.js

@@ -0,0 +1,2097 @@
+"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.RebalanceHandler = exports.KeeperMonitor = exports.getJupTokenLedgerAndSwapInstructions = exports.TaskType = exports.SymmetryCore = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const bn_js_1 = __importDefault(require("bn.js"));
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+const claimBounty_1 = require("./instructions/automation/claimBounty");
+const flashSwap_1 = require("./instructions/automation/flashSwap");
+const priceUpdate_1 = require("./instructions/automation/priceUpdate");
+const rebalanceIntent_1 = require("./instructions/automation/rebalanceIntent");
+const addBounty_1 = require("./instructions/management/addBounty");
+const admin_1 = require("./instructions/management/admin");
+const claimFees_1 = require("./instructions/management/claimFees");
+const createBasket_1 = require("./instructions/management/createBasket");
+const edit_1 = require("./instructions/management/edit");
+const luts_1 = require("./instructions/management/luts");
+const pda_1 = require("./instructions/pda");
+const deposit_1 = require("./instructions/user/deposit");
+const withdraw_1 = require("./instructions/user/withdraw");
+const jup_1 = require("./jup");
+Object.defineProperty(exports, "getJupTokenLedgerAndSwapInstructions", { enumerable: true, get: function () { return jup_1.getJupTokenLedgerAndSwapInstructions; } });
+const fraction_1 = require("./layouts/fraction");
+const intent_1 = require("./layouts/intents/intent");
+Object.defineProperty(exports, "TaskType", { enumerable: true, get: function () { return intent_1.TaskType; } });
+const rebalanceIntent_2 = require("./layouts/intents/rebalanceIntent");
+const oracle_1 = require("./layouts/oracle");
+const basket_1 = require("./states/basket");
+const config_1 = require("./states/config");
+const intent_2 = require("./states/intents/intent");
+const rebalanceIntent_3 = require("./states/intents/rebalanceIntent");
+const withdrawBasketFees_1 = require("./states/withdrawBasketFees");
+const pythOracle_1 = require("./states/oracles/pythOracle");
+const txUtils_1 = require("./txUtils");
+class SymmetryCore {
+    /**
+     * Initializes the SymmetryCore SDK.
+     * @param params {connection: Connection, network: "devnet" | "mainnet", priorityFee?: number} - The parameters for the SDK.
+     * @param params.connection - The connection to the Solana network.
+     * @param params.network - The network to use (devnet or mainnet).
+     * @param params.priorityFee - Optional. Compute unit price in micro-lamports. Defaults to PRIORITY_FEE (25_000).
+    */
+    constructor(params) {
+        var _a;
+        this.sdkParams = {
+            connection: params.connection,
+            network: params.network,
+            priorityFee: (_a = params.priorityFee) !== null && _a !== void 0 ? _a : constants_1.PRIORITY_FEE,
+        };
+    }
+    /**
+     * Sets the priority fee for the SDK.
+     * @param {number} priorityFee - The priority fee in micro-lamports.
+    */
+    setPriorityFee(priorityFee) {
+        this.sdkParams.priorityFee = priorityFee;
+    }
+    /**
+     * Fetches the global config account.
+     * @returns {Promise<GlobalConfig>} The global config.
+    */
+    fetchGlobalConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, config_1.fetchGlobalConfig)(this.sdkParams.connection);
+        });
+    }
+    /**
+     * Fetches a basket by its public key.
+     * @param {string} basketPubkey - The public key of the basket.
+     * @returns {Promise<Basket>} The basket.
+    */
+    fetchBasket(basketPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, basket_1.fetchBasket)(this.sdkParams.connection, new web3_js_1.PublicKey(basketPubkey));
+        });
+    }
+    /**
+     * Fetches multiple baskets by their public keys.
+     * @param {string[]} basketPubkeys - The public keys of the baskets.
+     * @returns {Promise<Map<string, Basket>>} A map of basket public keys to baskets.
+    */
+    fetchMultipleBaskets(basketPubkeys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, basket_1.fetchBasketsMultiple)(this.sdkParams.connection, basketPubkeys.map(key => new web3_js_1.PublicKey(key)));
+        });
+    }
+    /**
+     * Fetches all baskets.
+     * @param {BasketFilter} basketFilter - Optional. The filter to apply to the baskets.
+     * @param {"creator" | "host" | "manager"} basketFilter.type - The type of the basket filter ("creator", "host", "manager").
+     * @param {string} basketFilter.pubkey - The public key of the basket filter.
+     * @returns {Promise<Basket[]>} The baskets.
+    */
+    fetchAllBaskets(basketFilter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, basket_1.fetchBaskets)(this.sdkParams.connection, basketFilter);
+        });
+    }
+    /**
+     * Fetches all baskets created by a given public key.
+     * @param {string} creatorPubkey - The public key of the creator.
+     * @returns {Promise<Basket[]>} The baskets.
+    */
+    fetchCreatedBaskets(creatorPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, basket_1.fetchBaskets)(this.sdkParams.connection, { type: "creator", pubkey: creatorPubkey });
+        });
+    }
+    /**
+     * Fetches all baskets hosted by a given public key.
+     * @param {string} hostPubkey - The public key of the host.
+     * @returns {Promise<Basket[]>} The baskets.
+    */
+    fetchHostedBaskets(hostPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, basket_1.fetchBaskets)(this.sdkParams.connection, { type: "host", pubkey: hostPubkey });
+        });
+    }
+    /**
+     * Fetches all baskets managed by a given public key.
+     * @param {string} managerPubkey - The public key of the manager.
+     * @returns {Promise<Basket[]>} The baskets.
+    */
+    fetchManagedBaskets(managerPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, basket_1.fetchBaskets)(this.sdkParams.connection, { type: "manager", pubkey: managerPubkey });
+        });
+    }
+    /**
+     * Derives baskets by their mints.
+     * @param {string[]} mints - The mint public keys of the baskets.
+     * @returns {Promise<Map<string, string>>} A map of basket mint public keys to basket public keys.
+    */
+    deriveBasketsByMints(mints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = new Map();
+            for (let basketId = 0; basketId < 50000; basketId++) {
+                let mint = (0, pda_1.getBasketTokenMintPda)(basketId).toBase58();
+                if (mints.includes(mint)) {
+                    result.set(mint, (0, pda_1.getBasketState)(new web3_js_1.PublicKey(mint)).toBase58());
+                }
+            }
+            return result;
+        });
+    }
+    /**
+     * Fetches baskets by their mint public keys.
+     * @param {string[]} mints - The mint public keys of the baskets.
+     * @returns {Promise<Map<string, Basket>>} A map of basket mint public keys to baskets.
+    */
+    fetchBasketsFromMints(mints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let basketPubkeys = mints.map(mint => {
+                let res = null;
+                try {
+                    res = (0, pda_1.getBasketState)(new web3_js_1.PublicKey(mint));
+                }
+                catch (e) {
+                    return null;
+                }
+                return res;
+            }).filter(mint => mint !== null);
+            const basketsMap = yield (0, basket_1.fetchBasketsMultiple)(this.sdkParams.connection, basketPubkeys);
+            let mintsMap = new Map();
+            for (let basket of basketsMap.values()) {
+                mintsMap.set(basket.mint.toBase58(), basket);
+            }
+            return mintsMap;
+        });
+    }
+    /**
+     * Loads the price of a basket.
+     * @param {Basket} basket - The basket.
+     * @returns {Promise<Basket>} The basket with the price.
+    */
+    loadBasketPrice(basket) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, basket_1.loadBasketPrice)(basket, this.sdkParams.connection);
+        });
+    }
+    /**
+     * Fetches an intent by its public key.
+     * @param {string} intentPubkey - The public key of the intent.
+     * @returns {Promise<Intent>} The intent.
+    */
+    fetchIntent(intentPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, intent_2.fetchIntent)(this.sdkParams.connection, new web3_js_1.PublicKey(intentPubkey));
+        });
+    }
+    /**
+     * Fetches multiple intents by their public keys.
+     * @param {string[]} intentPubkeys - The public keys of the intents.
+     * @returns {Promise<Map<string, Intent>>} A map of intent public keys to intents.
+    */
+    fetchMultipleIntents(intentPubkeys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, intent_2.fetchIntentsMultiple)(this.sdkParams.connection, intentPubkeys.map(key => new web3_js_1.PublicKey(key)));
+        });
+    }
+    /**
+     * Fetches all intents.
+     * @param {IntentFilter} filter - Optional. The filter to apply to the intents.
+     * @param {"creator" | "host" | "manager" | "basket" | "owner"} filter.type - The type of the intent filter ("creator", "host", "manager", "basket", "owner").
+     * @param {string} filter.pubkey - The public key of the intent filter.
+     * @returns {Promise<Intent[]>} The intents.
+    */
+    fetchAllIntents(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, intent_2.fetchIntents)(this.sdkParams.connection, filter);
+        });
+    }
+    /**
+     * Fetches all intents created by a given public key.
+     * @param {string} creatorPubkey - The public key of the creator.
+     * @returns {Promise<Intent[]>} The intents.
+    */
+    fetchCreatedIntents(creatorPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, intent_2.fetchIntents)(this.sdkParams.connection, { type: "manager", pubkey: creatorPubkey });
+        });
+    }
+    /**
+     * Fetches all intents for a given basket.
+     * @param {string} basketPubkey - The public key of the basket.
+     * @returns {Promise<Intent[]>} The intents.
+    */
+    fetchBasketIntents(basketPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, intent_2.fetchIntents)(this.sdkParams.connection, { type: "basket", pubkey: basketPubkey });
+        });
+    }
+    /**
+     * Fetches a rebalance intent by its public key.
+     * @param {string} rebalanceIntentPubkey - The public key of the rebalance intent.
+     * @returns {Promise<UIRebalanceIntent>} The rebalance intent.
+    */
+    fetchRebalanceIntent(rebalanceIntentPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, rebalanceIntent_3.fetchRebalanceIntent)(this.sdkParams.connection, new web3_js_1.PublicKey(rebalanceIntentPubkey));
+        });
+    }
+    /**
+     * Fetches multiple rebalance intents by their public keys.
+     * @param {string[]} rebalanceIntentPubkeys - The public keys of the rebalance intents.
+     * @returns {Promise<Map<string, UIRebalanceIntent>>} A map of rebalance intent public keys to rebalance intents.
+    */
+    fetchMultipleRebalanceIntents(rebalanceIntentPubkeys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, rebalanceIntent_3.fetchRebalanceIntentsMultiple)(this.sdkParams.connection, rebalanceIntentPubkeys.map(key => new web3_js_1.PublicKey(key)));
+        });
+    }
+    /**
+     * Fetches all rebalance intents.
+     * @param {RebalanceIntentFilter} filter - Optional. The filter to apply to the rebalance intents.
+     * @param {"owner" | "basket"} filter.type - The type of the rebalance intent filter ("owner", "basket").
+     * @param {string} filter.pubkey - The public key of the rebalance intent filter.
+     * @returns {Promise<UIRebalanceIntent[]>} The rebalance intents.
+    */
+    fetchAllRebalanceIntents(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, rebalanceIntent_3.fetchRebalanceIntents)(this.sdkParams.connection, filter);
+        });
+    }
+    /**
+     * Fetches all rebalance intents for a given owner.
+     * @param {string} ownerPubkey - The public key of the owner.
+     * @returns {Promise<UIRebalanceIntent[]>} The rebalance intents.
+    */
+    fetchOwnerRebalanceIntents(ownerPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, rebalanceIntent_3.fetchRebalanceIntents)(this.sdkParams.connection, { type: "owner", pubkey: ownerPubkey });
+        });
+    }
+    /**
+     * Fetches all rebalance intents for a given basket.
+     * @param {string} basketPubkey - The public key of the basket.
+     * @returns {Promise<UIRebalanceIntent[]>} The rebalance intents.
+    */
+    fetchBasketRebalanceIntents(basketPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, rebalanceIntent_3.fetchRebalanceIntents)(this.sdkParams.connection, { type: "basket", pubkey: basketPubkey });
+        });
+    }
+    /**
+     * Fetches a WithdrawBasketFees account by its public key.
+     * @param {string} withdrawBasketFeesPubkey - The public key of the WithdrawBasketFees account.
+     * @returns {Promise<WithdrawBasketFees>} The WithdrawBasketFees account.
+    */
+    fetchWithdrawBasketFees(withdrawBasketFeesPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, withdrawBasketFees_1.fetchWithdrawBasketFees)(this.sdkParams.connection, new web3_js_1.PublicKey(withdrawBasketFeesPubkey));
+        });
+    }
+    /**
+     * Fetches multiple WithdrawBasketFees accounts by their public keys.
+     * @param {string[]} withdrawBasketFeesPubkeys - The public keys of the WithdrawBasketFees accounts.
+     * @returns {Promise<Map<string, WithdrawBasketFees>>} A map of WithdrawBasketFees public keys to WithdrawBasketFees accounts.
+    */
+    fetchMultipleWithdrawBasketFees(withdrawBasketFeesPubkeys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, withdrawBasketFees_1.fetchWithdrawBasketFeesMultiple)(this.sdkParams.connection, withdrawBasketFeesPubkeys.map(key => new web3_js_1.PublicKey(key)));
+        });
+    }
+    /**
+     * Fetches all WithdrawBasketFees accounts with optional filter.
+     * @param {WithdrawBasketFeesFilter} filter - Optional. The filter to apply to the WithdrawBasketFees accounts.
+     * @param {"basket" | "manager" | "creator" | "host" | "symmetry"} filter.type - The type of the filter.
+     * @param {string} filter.pubkey - The public key to filter by.
+     * @returns {Promise<WithdrawBasketFees[]>} The WithdrawBasketFees accounts.
+    */
+    fetchAllWithdrawBasketFees(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, withdrawBasketFees_1.fetchWithdrawBasketFeesList)(this.sdkParams.connection, filter);
+        });
+    }
+    /**
+     * Fetches all WithdrawBasketFees accounts for a given basket.
+     * @param {string} basketPubkey - The public key of the basket.
+     * @returns {Promise<WithdrawBasketFees[]>} The WithdrawBasketFees accounts.
+    */
+    fetchBasketWithdrawBasketFees(basketPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, withdrawBasketFees_1.fetchWithdrawBasketFeesList)(this.sdkParams.connection, { type: "basket", pubkey: basketPubkey });
+        });
+    }
+    /**
+     * Fetches all WithdrawBasketFees accounts for a given manager.
+     * @param {string} managerPubkey - The public key of the manager.
+     * @returns {Promise<WithdrawBasketFees[]>} The WithdrawBasketFees accounts.
+    */
+    fetchManagerWithdrawBasketFees(managerPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, withdrawBasketFees_1.fetchWithdrawBasketFeesList)(this.sdkParams.connection, { type: "manager", pubkey: managerPubkey });
+        });
+    }
+    /**
+     * Fetches all WithdrawBasketFees accounts for a given creator.
+     * @param {string} creatorPubkey - The public key of the creator.
+     * @returns {Promise<WithdrawBasketFees[]>} The WithdrawBasketFees accounts.
+    */
+    fetchCreatorWithdrawBasketFees(creatorPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, withdrawBasketFees_1.fetchWithdrawBasketFeesList)(this.sdkParams.connection, { type: "creator", pubkey: creatorPubkey });
+        });
+    }
+    /**
+     * Fetches all WithdrawBasketFees accounts for a given host.
+     * @param {string} hostPubkey - The public key of the host.
+     * @returns {Promise<WithdrawBasketFees[]>} The WithdrawBasketFees accounts.
+    */
+    fetchHostWithdrawBasketFees(hostPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, withdrawBasketFees_1.fetchWithdrawBasketFeesList)(this.sdkParams.connection, { type: "host", pubkey: hostPubkey });
+        });
+    }
+    /**
+     * Fetches all WithdrawBasketFees accounts for a given symmetry fee collector.
+     * @param {string} symmetryPubkey - The public key of the symmetry fee collector.
+     * @returns {Promise<WithdrawBasketFees[]>} The WithdrawBasketFees accounts.
+    */
+    fetchSymmetryWithdrawBasketFees(symmetryPubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, withdrawBasketFees_1.fetchWithdrawBasketFeesList)(this.sdkParams.connection, { type: "symmetry", pubkey: symmetryPubkey });
+        });
+    }
+    createGlobalConfigTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let ix = (0, admin_1.createGlobalConfigIx)({ admin: params.signer });
+            let txBatchData = { batches: [[{
+                            payer: params.signer,
+                            instructions: [
+                                ix,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    editGlobalConfigTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let ix = (0, admin_1.editGlobalConfigIx)(params);
+            let txBatchData = { batches: [[{
+                            payer: params.signer,
+                            instructions: [
+                                ix,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Creates a basket.
+     * @param {Object} params - The parameters for the basket creation.
+     * @param {string} params.creator - The public key of the creator.
+     * @param {string} params.start_price - The start price of the basket.
+     * @param {string} params.name - The name of the basket.
+     * @param {string} params.symbol - The symbol of the basket.
+     * @param {string} params.metadata_uri - The metadata URI of the basket.
+     * @param {Object} params.host_platform_params - Optional. The host platform parameters.
+     * @param {string} params.host_platform_params.host_pubkey - The public key of the host.
+     * @param {number} params.host_platform_params.host_deposit_fee_bps - The host deposit fee in basis points.
+     * @param {number} params.host_platform_params.host_withdraw_fee_bps - The host withdrawal fee in basis points.
+     * @param {number} params.host_platform_params.host_management_fee_bps - The host management fee in basis points.
+     * @param {number} params.host_platform_params.host_performance_fee_bps - The host performance fee in basis points.
+     * @returns {Promise<BasketCreationTx>} The basket creation transaction.
+    */
+    createBasketTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            const creator = new web3_js_1.PublicKey(params.creator);
+            const host = new web3_js_1.PublicKey((_b = (_a = params.host_platform_params) === null || _a === void 0 ? void 0 : _a.host_pubkey) !== null && _b !== void 0 ? _b : params.creator);
+            const hostFees = {
+                hostDepositFeeBps: (_d = (_c = params.host_platform_params) === null || _c === void 0 ? void 0 : _c.host_deposit_fee_bps) !== null && _d !== void 0 ? _d : 0,
+                hostWithdrawalFeeBps: (_f = (_e = params.host_platform_params) === null || _e === void 0 ? void 0 : _e.host_withdraw_fee_bps) !== null && _f !== void 0 ? _f : 0,
+                hostManagementFeeBps: (_h = (_g = params.host_platform_params) === null || _g === void 0 ? void 0 : _g.host_management_fee_bps) !== null && _h !== void 0 ? _h : 0,
+                hostPerformanceFeeBps: (_k = (_j = params.host_platform_params) === null || _j === void 0 ? void 0 : _j.host_performance_fee_bps) !== null && _k !== void 0 ? _k : 0,
+            };
+            const metadataParams = {
+                name: params.name,
+                symbol: params.symbol,
+                uri: params.metadata_uri,
+            };
+            const startPrice = (0, fraction_1.decimalToFraction)(new decimal_js_1.default(parseFloat(params.start_price) / 10 ** 6));
+            let globalConfig = yield this.fetchGlobalConfig();
+            let bountyWsolAmount = 0;
+            if (globalConfig.bountyMint.equals(constants_1.MINTS["mainnet"].WSOL)) {
+                let boundBounty = parseInt(globalConfig.bountyBondAmount.toString());
+                let minBasketAutomationBounty = parseInt(globalConfig.minBountyForBasketAutomation.toString());
+                bountyWsolAmount = boundBounty + minBasketAutomationBounty;
+            }
+            let wsolIxs = yield (0, txUtils_1.wrapWsolIxs)(this.sdkParams.connection, creator, bountyWsolAmount);
+            let basketId = parseInt(globalConfig.totalNumberOfBaskets.toString());
+            let mint = (0, pda_1.getBasketTokenMintPda)(basketId);
+            let basket = (0, pda_1.getBasketState)(mint);
+            const slot = yield this.sdkParams.connection.getSlot();
+            let ix = (0, createBasket_1.createBasketIx)({
+                basket,
+                mint,
+                slot,
+                creator,
+                host,
+                startPrice: startPrice,
+                hostFees,
+                metadataParams,
+                network: this.sdkParams.network,
+            });
+            let preIx = (0, createBasket_1.createBasketStateAccountIx)({
+                creator,
+                basket
+            });
+            let preIx2 = (0, createBasket_1.resizeBasketStateIx)({
+                basket
+            });
+            let createBasketFeesAccountIx = (0, spl_token_1.createAssociatedTokenAccountInstruction)(creator, (0, pda_1.getAta)((0, pda_1.getBasketFeesPda)(basket), mint), (0, pda_1.getBasketFeesPda)(basket), mint);
+            let txBatchData = { batches: [[{
+                            payer: creator,
+                            instructions: [
+                                ...wsolIxs,
+                                preIx, preIx2, preIx2, ix, createBasketFeesAccountIx,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return {
+                mint: mint.toBase58(),
+                basket: basket.toBase58(),
+                batches: txPayloadBatchSequence.batches,
+            };
+        });
+    }
+    /**
+     * Changes the creator of a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditCreatorSettings} settings - The settings for the creator edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editCreatorTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditCreator, context, settings });
+        });
+    }
+    /**
+     * Creates an edit manager settings intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditManagerSettings} settings - The settings for the manager edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editManagersTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditManagerSettings, context, settings });
+        });
+    }
+    /**
+     * Creates an edit schedule settings intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditScheduleSettings} settings - The settings for the schedule edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editScheduleTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditScheduleSettings, context, settings });
+        });
+    }
+    /**
+     * Creates an edit fees settings intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditFeeSettings} settings - The settings for the fee edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editFeesTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditFeeSettings, context, settings });
+        });
+    }
+    /**
+     * Creates an edit automation settings intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditAutomationSettings} settings - The settings for the automation edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editAutomationTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditAutomationSettings, context, settings });
+        });
+    }
+    /**
+     * Creates an edit LP settings intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditLpSettings} settings - The settings for the LP edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editLpTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditLpSettings, context, settings });
+        });
+    }
+    /**
+     * Creates an edit metadata settings intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditMetadataSettings} settings - The settings for the metadata edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editMetadataTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditMetadataSettings, context, settings });
+        });
+    }
+    /**
+     * Creates an edit deposits settings intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditDepositsSettings} settings - The settings for the deposits edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editDepositsTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditDepositsSettings, context, settings });
+        });
+    }
+    /**
+     * Creates an edit force rebalance settings intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditForceRebalanceSettings} settings - The settings for the force rebalance edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editForceRebalanceTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditForceRebalanceSettings, context, settings });
+        });
+    }
+    /**
+     * Creates an edit custom rebalance settings intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditCustomRebalanceSettings} settings - The settings for the custom rebalance edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editCustomRebalanceTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditCustomRebalanceSettings, context, settings });
+        });
+    }
+    /**
+     * Creates an edit add token delay intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditAddTokenSettings} settings - The settings for the add token delay edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editAddTokenDelayTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditAddTokenDelay, context, settings });
+        });
+    }
+    /**
+     * Creates an edit update weights delay intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditUpdateWeightsSettings} settings - The settings for the update weights delay edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editUpdateWeightsDelayTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditUpdateWeightsDelay, context, settings });
+        });
+    }
+    /**
+     * Creates an edit swap delay intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {EditMakeDirectSwapSettings} settings - The settings for the make direct swap delay edit.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    editSwapDelayTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.EditMakeDirectSwapDelay, context, settings });
+        });
+    }
+    /**
+     * Creates an add or edit token intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {AddOrEditTokenInput} settings - The settings for the add or edit token.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    addOrEditTokenTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.AddToken, context, settings });
+        });
+    }
+    /**
+     * Creates a update weights intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {UpdateWeightsInput} settings - The settings for the update weights.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    updateWeightsTx(context, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.UpdateWeights, context, settings });
+        });
+    }
+    /**
+     * Creates a direct swap intent for a basket.
+     * @param {TaskContext} context - The context of the task.
+     * @param {MakeDirectSwapInput} settings - The settings for the make direct swap.
+     * @param {TransactionInstruction} jup_swap_ix - Optional. The JUP swap instruction.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    makeDirectSwapTx(context, settings, jup_swap_ix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.openBasketIntentTx({ type: intent_1.TaskType.MakeDirectSwap, context, settings, jup_swap_ix: jup_swap_ix });
+        });
+    }
+    /**
+     * Creates basket intent account.
+     * @param {Object} params - The parameters for the basket intent.
+     * @param {TaskContext} params.context - The context of the task.
+     * @param {TaskType} params.type - The type of the task.
+     * @param {Settings} params.settings - The settings for the task.
+     * @param {number} params.min_bounty_per_task - Optional. The minimum bounty per task.
+     * @param {number} params.max_bounty_per_task - Optional. The maximum bounty per task.
+     * @param {TransactionInstruction} params.jup_swap_ix - Optional. The JUP swap instruction (for MakeDirectSwap task).
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    openBasketIntentTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            let basket = yield this.fetchBasket(params.context.basket);
+            let manager = new web3_js_1.PublicKey(params.context.manager);
+            let activationTimestamp = new bn_js_1.default((_a = params.context.activation_timestamp) !== null && _a !== void 0 ? _a : 0);
+            let expirationTimestamp = new bn_js_1.default((_b = params.context.expiration_timestamp) !== null && _b !== void 0 ? _b : 0);
+            let editType = params.type;
+            let editData = params.settings;
+            let modificationDelay = (() => {
+                switch (editType) {
+                    case intent_1.TaskType.EditCreator: return new bn_js_1.default(0);
+                    case intent_1.TaskType.EditManagerSettings: return basket.settings.managers.modificationDelay;
+                    case intent_1.TaskType.EditFeeSettings: return basket.settings.fees.modificationDelay;
+                    case intent_1.TaskType.EditScheduleSettings: return basket.settings.schedule.modificationDelay;
+                    case intent_1.TaskType.EditAutomationSettings: return basket.settings.automation.modificationDelay;
+                    case intent_1.TaskType.EditLpSettings: return basket.settings.lp.modificationDelay;
+                    case intent_1.TaskType.EditMetadataSettings: return basket.settings.metadata.modificationDelay;
+                    case intent_1.TaskType.EditDepositsSettings: return new bn_js_1.default(0);
+                    case intent_1.TaskType.EditForceRebalanceSettings: return basket.settings.forceRebalanceModificationDelay;
+                    case intent_1.TaskType.EditCustomRebalanceSettings: return basket.settings.customRebalanceModificationDelay;
+                    case intent_1.TaskType.EditAddTokenDelay: return basket.settings.addTokenDelay;
+                    case intent_1.TaskType.EditUpdateWeightsDelay: return basket.settings.updateWeightsDelay;
+                    case intent_1.TaskType.EditMakeDirectSwapDelay: return basket.settings.makeDirectSwapDelay;
+                    case intent_1.TaskType.AddToken: return basket.settings.addTokenDelay;
+                    case intent_1.TaskType.UpdateWeights: return basket.settings.updateWeightsDelay;
+                    case intent_1.TaskType.MakeDirectSwap: return basket.settings.makeDirectSwapDelay;
+                    default: return new bn_js_1.default(0);
+                }
+            })();
+            let globalConfig = yield this.fetchGlobalConfig();
+            let minBounty = params.context.min_bounty !== undefined
+                ? new bn_js_1.default(params.context.min_bounty)
+                : globalConfig.bountyPerTask.minBounty;
+            let maxBounty = params.context.max_bounty !== undefined
+                ? new bn_js_1.default(params.context.max_bounty)
+                : globalConfig.bountyPerTask.maxBounty;
+            if (parseInt(minBounty.toString()) > parseInt(maxBounty.toString()))
+                minBounty = maxBounty.div(new bn_js_1.default(2));
+            let bountyWsolAmount = 0;
+            if (globalConfig.bountyMint.equals(constants_1.MINTS["mainnet"].WSOL)) {
+                let boundBounty = parseInt(globalConfig.bountyBondAmount.toString());
+                let maxBountyPerTask = parseInt(maxBounty.toString());
+                bountyWsolAmount = maxBountyPerTask + boundBounty;
+            }
+            let wsolIxs = yield (0, txUtils_1.wrapWsolIxs)(this.sdkParams.connection, manager, bountyWsolAmount);
+            let intentSeedArray = web3_js_1.Keypair.generate().publicKey.toBytes();
+            let tokenProgram = undefined;
+            if (editType === intent_1.TaskType.AddToken) {
+                let tokenMint = new web3_js_1.PublicKey(editData.token_mint);
+                intentSeedArray = tokenMint.toBytes();
+                let tokenInfo = yield this.sdkParams.connection.getAccountInfo(tokenMint);
+                if (tokenInfo.owner.equals(spl_token_1.TOKEN_PROGRAM_ID) || tokenInfo.owner.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)) {
+                    tokenProgram = tokenInfo.owner;
+                }
+            }
+            let intent = (0, pda_1.getIntentPda)(basket.ownAddress, intentSeedArray, editType);
+            let openBasketIntentIx = (0, edit_1.createEditBasketIntentIx)({
+                manager: manager,
+                basket: basket,
+                intent: intent,
+                intentSeedArray: intentSeedArray,
+                editType: editType,
+                editData: editData,
+                activationTimestamp: activationTimestamp,
+                expirationTimestamp: expirationTimestamp,
+                minBounty: minBounty,
+                maxBounty: maxBounty,
+                tokenProgram: tokenProgram,
+            });
+            let txBatchData = { batches: [[{
+                            payer: manager,
+                            instructions: [
+                                ...wsolIxs,
+                                openBasketIntentIx,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]] };
+            // Only execute in the same transaction when there is no delay and no scheduled activation.
+            if (modificationDelay.eq(new bn_js_1.default(0)) && activationTimestamp.eq(new bn_js_1.default(0))) {
+                let executeBasketIntentIx = (0, edit_1.executeEditBasketIntentIx)({
+                    basket: basket.ownAddress,
+                    intent: intent,
+                    editType: editType,
+                    manager: manager,
+                    bountyMint: basket.settings.bountyMint,
+                    keeper: manager,
+                    basketMint: basket.mint,
+                });
+                if (editType == intent_1.TaskType.MakeDirectSwap && params.jup_swap_ix) {
+                    let flashParams = {
+                        keeper: manager,
+                        basket: basket.ownAddress,
+                        rebalanceIntent: undefined,
+                        intent: intent,
+                        mintIn: new web3_js_1.PublicKey(editData.from_token_mint),
+                        mintOut: new web3_js_1.PublicKey(editData.to_token_mint),
+                        amountIn: new bn_js_1.default(editData.amount_from),
+                        amountOut: new bn_js_1.default(editData.amount_to),
+                        mode: undefined,
+                    };
+                    let ixWithdraw = (0, flashSwap_1.flashWithdrawIx)(flashParams);
+                    let ixDeposit = (0, flashSwap_1.flashDepositIx)(flashParams);
+                    txBatchData.batches.push([{
+                            payer: manager,
+                            instructions: [
+                                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(manager, (0, pda_1.getAta)(manager, flashParams.mintIn), manager, flashParams.mintIn),
+                                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(manager, (0, pda_1.getAta)(manager, flashParams.mintOut), manager, flashParams.mintOut),
+                                ixWithdraw,
+                                params.jup_swap_ix,
+                                ixDeposit,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]);
+                    txBatchData.batches.push([{
+                            payer: manager,
+                            instructions: [
+                                executeBasketIntentIx,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]);
+                }
+                else {
+                    txBatchData.batches[0][0].instructions = [
+                        ...wsolIxs,
+                        openBasketIntentIx,
+                        executeBasketIntentIx,
+                        web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                        web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                    ];
+                }
+            }
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Executes a basket intent. Basket intent will be executed immediately.
+     * @param {Object} params - The parameters for the basket intent.
+     * @param {string} params.keeper - The public key of the keeper.
+     * @param {string} params.intent - The public key of the intent.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    executeBasketIntentTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let keeper = new web3_js_1.PublicKey(params.keeper);
+            let intent = yield this.fetchIntent(params.intent);
+            let basketMint;
+            if (intent.taskType === intent_1.TaskType.EditMetadataSettings) {
+                let basket = yield this.fetchBasket(intent.basket.toBase58());
+                basketMint = basket.mint;
+            }
+            let ix = (0, edit_1.executeEditBasketIntentIx)({
+                basket: intent.basket,
+                intent: intent.ownAddress,
+                editType: intent.taskType,
+                manager: intent.manager,
+                bountyMint: intent.bounty.bountyMint,
+                keeper: keeper,
+                basketMint: intent.taskType === intent_1.TaskType.EditMetadataSettings ? basketMint : undefined,
+            });
+            let txBatchData = { batches: [[{
+                            payer: keeper,
+                            instructions: [
+                                ix,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Cancels a basket intent. Basket intent account will get closed.
+     * @param {Object} params - The parameters for the basket intent.
+     * @param {string} params.keeper - The public key of the keeper.
+     * @param {string} params.intent - The public key of the intent.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    cancelBasketIntentTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let keeper = new web3_js_1.PublicKey(params.keeper);
+            let intent = yield this.fetchIntent(params.intent);
+            let ix = (0, edit_1.cancelIntentIx)({
+                keeper: keeper,
+                basket: intent.basket,
+                intent: intent.ownAddress,
+                editType: intent.taskType,
+                manager: intent.manager,
+                bountyMint: intent.bounty.bountyMint,
+            });
+            let txBatchData = { batches: [[{
+                            payer: keeper,
+                            instructions: [
+                                ix,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Cancels a rebalance intent. Rebalance intent status will be set to AuctionFinished.
+     * @param {Object} params - The parameters for the rebalance intent.
+     * @param {string} params.keeper - The public key of the keeper.
+     * @param {string} params.rebalance_intent - The public key of the rebalance intent.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    cancelRebalanceIntentTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let keeper = new web3_js_1.PublicKey(params.keeper);
+            let intent = (yield this.fetchRebalanceIntent(params.rebalance_intent)).chain_data;
+            let ix = (0, rebalanceIntent_1.cancelRebalanceIx)({
+                keeper: keeper,
+                basket: intent.basket,
+                rebalanceIntent: intent.ownAddress,
+            });
+            let txBatchData = { batches: [[{
+                            payer: keeper,
+                            instructions: [
+                                ix,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Creates a rebalance intent for a user to deposit tokens into a basket.
+     *
+     * Batch layout:
+     *
+     *  batch 0:
+     * * tx0: [create, resize, init rebalance intent],
+     *
+     * batch 1:
+     * * tx0: [deposit tokens ix],
+     * * tx1: [deposit tokens ix],
+     * * ...
+     *
+     * batch 2:
+     * * tx0: [lock deposits ix, start price updates ix],
+     *
+     * @param {Object} params - The parameters for the basket purchase.
+     * @param {string} params.buyer - The public key of the buyer.
+     * @param {string} params.basket_mint - The mint public key of the basket.
+     * @param {{mint: string, amount: number}[]} params.contributions - The contributions to the basket.
+     * @param {string} params.contributions[].mint - The mint public key of the contribution.
+     * @param {number} params.contributions[].amount - The amount of the contribution.
+     * @param {number} params.rebalance_slippage_bps - Optional. The rebalance slippage in basis points.
+     * @param {number} params.per_trade_rebalance_slippage_bps - Optional. The per trade rebalance slippage in basis points.
+     * @param {number} params.execution_start_time - Optional. The execution start time.
+     * @param {number} params.min_bounty_amount - Optional. The minimum bounty amount.
+     * @param {number} params.max_bounty_amount - Optional. The maximum bounty amount.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    buyBasketTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            let buyer = new web3_js_1.PublicKey(params.buyer);
+            let contributions = params.contributions.map(contribution => ({
+                mint: new web3_js_1.PublicKey(contribution.mint),
+                amount: contribution.amount,
+            }));
+            let rebalanceSlippageBps = (_a = params.rebalance_slippage_bps) !== null && _a !== void 0 ? _a : 100;
+            let perTradeRebalanceSlippageBps = (_b = params.per_trade_rebalance_slippage_bps) !== null && _b !== void 0 ? _b : 100;
+            let executionStartTime = (_c = params.execution_start_time) !== null && _c !== void 0 ? _c : 0;
+            let minBountyAmount = (_d = params.min_bounty_amount) !== null && _d !== void 0 ? _d : 0;
+            let maxBountyAmount = (_e = params.max_bounty_amount) !== null && _e !== void 0 ? _e : 0;
+            const basket = yield this.fetchBasket((0, pda_1.getBasketState)(new web3_js_1.PublicKey(params.basket_mint)).toBase58());
+            let globalConfig = yield this.fetchGlobalConfig();
+            let bountyWsolAmount = 0;
+            if (globalConfig.bountyMint.equals(constants_1.MINTS["mainnet"].WSOL)) {
+                let boundBounty = parseInt(globalConfig.bountyBondAmount.toString());
+                let maxBountyPerTask = parseInt(globalConfig.bountyPerTask.maxBounty.toString());
+                let bountyPerPriceUpdateTaskDivisor = parseInt(globalConfig.bountyPerPriceUpdateTaskDivisor.toString());
+                if (maxBountyAmount > maxBountyPerTask)
+                    maxBountyPerTask = maxBountyAmount;
+                bountyWsolAmount = (0, rebalanceIntent_3.computeRebalanceIntentBountyAmount)(rebalanceIntent_2.RebalanceType.Deposit, basket.numTokens, boundBounty, maxBountyPerTask, Math.floor(maxBountyPerTask / bountyPerPriceUpdateTaskDivisor));
+            }
+            let wsolContributionAmount = (_g = (_f = params.contributions.find(contribution => contribution.mint === constants_1.MINTS["mainnet"].WSOL.toBase58())) === null || _f === void 0 ? void 0 : _f.amount) !== null && _g !== void 0 ? _g : 0;
+            let wsolIxs = yield (0, txUtils_1.wrapWsolIxs)(this.sdkParams.connection, buyer, bountyWsolAmount + wsolContributionAmount);
+            const rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket.ownAddress, buyer);
+            let rentPayer = (0, pda_1.getRentPayerPda)();
+            let rentPayerAi = yield this.sdkParams.connection.getAccountInfo(rentPayer);
+            let rebalanceIntentRentPayer = buyer;
+            // TODO: check actual lamports required for rent
+            if ((_h = rentPayerAi === null || rentPayerAi === void 0 ? void 0 : rentPayerAi.lamports) !== null && _h !== void 0 ? _h : 0 > 500000000)
+                rebalanceIntentRentPayer = rentPayer;
+            let bountyMint = basket.settings.bountyMint;
+            // let lockDepositsIxs: TransactionInstruction[] = [
+            //     lockDepositsIx({
+            //         owner: buyer,
+            //         basket: basket.ownAddress,
+            //     })
+            // ];
+            let txBatchData = { batches: [
+                    [{
+                            payer: buyer,
+                            instructions: [
+                                ...wsolIxs,
+                                (0, rebalanceIntent_1.createRebalanceIntentIx)({
+                                    signer: buyer,
+                                    owner: buyer,
+                                    basket: basket.ownAddress,
+                                }),
+                                (0, rebalanceIntent_1.resizeRebalanceIntentIx)(rebalanceIntent),
+                                (0, rebalanceIntent_1.initRebalanceIntentIx)({
+                                    signer: buyer,
+                                    owner: buyer,
+                                    basket: basket.ownAddress,
+                                    basketTokenMint: basket.mint,
+                                    rebalanceIntentRentPayer: rebalanceIntentRentPayer,
+                                    bountyMint: bountyMint,
+                                    rebalanceType: rebalanceIntent_2.RebalanceType.Deposit,
+                                    basketRebalanceIntent: undefined,
+                                    rebalanceSlippageBps: rebalanceSlippageBps,
+                                    perTradeRebalanceSlippageBps: perTradeRebalanceSlippageBps,
+                                    executionStartTime: executionStartTime,
+                                    minBountyAmount: minBountyAmount,
+                                    maxBountyAmount: maxBountyAmount,
+                                }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }],
+                    (0, deposit_1.depositTokensIx)({
+                        owner: buyer,
+                        basket: basket.ownAddress,
+                        contributions: contributions,
+                    }).map(ix => {
+                        return {
+                            payer: buyer,
+                            instructions: [
+                                ix,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee })
+                            ],
+                            lookupTables: [],
+                        };
+                    }),
+                    // [{
+                    //     payer: buyer,
+                    //     instructions: [
+                    //         ...lockDepositsIxs,
+                    //         ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                    //         ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                    //     ],
+                    //     lookupTables: [],
+                    // }]
+                ] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Deposits additional tokens into an existing user deposit rebalance intent.
+     *
+     * This is useful when the user already created a deposit intent (for example via buyBasketTx),
+     * but has not called lockDepositsTx yet and wants to add more contributions.
+     *
+     * @param {Object} params - The parameters for depositing more tokens.
+     * @param {string} params.buyer - The public key of the buyer / deposit owner.
+     * @param {{mint: string, amount: number}[]} params.contributions - Extra token contributions.
+     * @param {string} params.rebalance_intent - Optional. Existing rebalance intent pubkey.
+     * @param {RebalanceIntent} params.rebalance_intent_chain_data - Optional. Existing rebalance intent chain data.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    depositTokensTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let buyer = new web3_js_1.PublicKey(params.buyer);
+            if (params.contributions.length === 0) {
+                throw new Error("Contributions cannot be empty");
+            }
+            let contributions = params.contributions.map(contribution => ({
+                mint: new web3_js_1.PublicKey(contribution.mint),
+                amount: contribution.amount,
+            }));
+            let rebalanceIntentState;
+            if (params.rebalance_intent_chain_data) {
+                rebalanceIntentState = params.rebalance_intent_chain_data;
+            }
+            else if (params.rebalance_intent) {
+                rebalanceIntentState = (yield this.fetchRebalanceIntent(params.rebalance_intent)).chain_data;
+            }
+            else {
+                throw new Error("Provide one of rebalance_intent_chain_data or rebalance_intent");
+            }
+            let wsolContributionAmount = params.contributions
+                .filter(contribution => contribution.mint === constants_1.MINTS["mainnet"].WSOL.toBase58())
+                .reduce((acc, contribution) => acc + contribution.amount, 0);
+            let wsolIxs = yield (0, txUtils_1.wrapWsolIxs)(this.sdkParams.connection, buyer, wsolContributionAmount);
+            let txBatchData = { batches: [] };
+            if (wsolIxs.length > 0) {
+                txBatchData.batches.push([{
+                        payer: buyer,
+                        instructions: [
+                            ...wsolIxs,
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                        ],
+                        lookupTables: [],
+                    }]);
+            }
+            txBatchData.batches.push((0, deposit_1.depositTokensIx)({
+                owner: buyer,
+                basket: rebalanceIntentState.basket,
+                contributions: contributions,
+            }).map(ix => ({
+                payer: buyer,
+                instructions: [
+                    ix,
+                    web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                    web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                ],
+                lookupTables: [],
+            })));
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Locks deposits for a user and starts auction flow.
+     * @param {Object} params - The parameters for the lock deposits.
+     * @param {string} params.buyer - The public key of the buyer.
+     * @param {string} params.basket_mint - The mint public key of the basket.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    lockDepositsTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let buyer = new web3_js_1.PublicKey(params.buyer);
+            let basket = yield this.fetchBasket((0, pda_1.getBasketState)(new web3_js_1.PublicKey(params.basket_mint)).toBase58());
+            let txBatchData = { batches: [[{
+                            payer: buyer,
+                            instructions: [
+                                (0, deposit_1.lockDepositsIx)({
+                                    owner: buyer,
+                                    basket: basket.ownAddress,
+                                }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Creates a rebalance intent for a user to withdraw tokens from a basket.
+     * @param {{Object}} params - The parameters for the basket sale.
+     * @param {string} params.seller - The public key of the seller.
+     * @param {string} params.basket_mint - The mint public key of the basket.
+     * @param {number} params.withdraw_amount - The amount of the withdrawal.
+     * @param {string[]} params.keep_tokens - The token mints to skip rebalancing (will directly be sent to the user without being rebalanced).
+     * @param {number} params.rebalance_slippage_bps - Optional. The rebalance slippage in basis points.
+     * @param {number} params.per_trade_rebalance_slippage_bps - Optional. The per trade rebalance slippage in basis points.
+     * @param {number} params.execution_start_time - Optional. The execution start time.
+     * @param {number} params.min_bounty_amount - Optional. The minimum bounty amount.
+     * @param {number} params.max_bounty_amount - Optional. The maximum bounty amount.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    sellBasketTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            let seller = new web3_js_1.PublicKey(params.seller);
+            let basketMint = new web3_js_1.PublicKey(params.basket_mint);
+            let withdrawAmount = params.withdraw_amount;
+            let keepTokens = params.keep_tokens;
+            let rebalanceSlippageBps = (_a = params.rebalance_slippage_bps) !== null && _a !== void 0 ? _a : 100;
+            let perTradeRebalanceSlippageBps = (_b = params.per_trade_rebalance_slippage_bps) !== null && _b !== void 0 ? _b : 100;
+            let executionStartTime = (_c = params.execution_start_time) !== null && _c !== void 0 ? _c : 0;
+            let minBountyAmount = (_d = params.min_bounty_amount) !== null && _d !== void 0 ? _d : 0;
+            let maxBountyAmount = (_e = params.max_bounty_amount) !== null && _e !== void 0 ? _e : 0;
+            const basket = yield this.fetchBasket((0, pda_1.getBasketState)(basketMint).toBase58());
+            let globalConfig = yield this.fetchGlobalConfig();
+            let bountyWsolAmount = 0;
+            if (globalConfig.bountyMint.equals(constants_1.MINTS["mainnet"].WSOL)) {
+                let boundBounty = parseInt(globalConfig.bountyBondAmount.toString());
+                let maxBountyPerTask = parseInt(globalConfig.bountyPerTask.maxBounty.toString());
+                let bountyPerPriceUpdateTaskDivisor = parseInt(globalConfig.bountyPerPriceUpdateTaskDivisor.toString());
+                if (maxBountyAmount > maxBountyPerTask)
+                    maxBountyPerTask = maxBountyAmount;
+                bountyWsolAmount = (0, rebalanceIntent_3.computeRebalanceIntentBountyAmount)(rebalanceIntent_2.RebalanceType.Deposit, basket.numTokens, boundBounty, maxBountyPerTask, Math.floor(maxBountyPerTask / bountyPerPriceUpdateTaskDivisor));
+            }
+            let wsolIxs = yield (0, txUtils_1.wrapWsolIxs)(this.sdkParams.connection, seller, bountyWsolAmount);
+            const rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket.ownAddress, seller);
+            let rentPayer = (0, pda_1.getRentPayerPda)();
+            let rentPayerAi = yield this.sdkParams.connection.getAccountInfo(rentPayer);
+            let rebalanceIntentRentPayer = seller;
+            // TODO: check actual lamports required for rent
+            if ((_f = rentPayerAi === null || rentPayerAi === void 0 ? void 0 : rentPayerAi.lamports) !== null && _f !== void 0 ? _f : 0 > 500000000)
+                rebalanceIntentRentPayer = rentPayer;
+            let bountyMint = basket.settings.bountyMint;
+            let keepAllTokensFlag = 1;
+            for (let i = 0; i < basket.numTokens; i++) {
+                if (!keepTokens.includes(basket.composition[i].mint.toBase58())) {
+                    keepAllTokensFlag = 0;
+                    break;
+                }
+            }
+            let tokenMintsHash = (0, basket_1.computeTokenMintsHash)(basket.composition.slice(0, basket.numTokens)
+                .map(asset => asset.mint.toBase58()));
+            let keepTokensBitmask = new bn_js_1.default(0);
+            if (keepTokens && keepTokens.length > 0) {
+                for (const mint of keepTokens) {
+                    let tokenIndex = -1;
+                    for (let i = 0; i < basket.numTokens; i++) {
+                        if (basket.composition[i].mint.toBase58() === mint) {
+                            tokenIndex = i;
+                            break;
+                        }
+                    }
+                    if (tokenIndex === -1) {
+                        throw new Error(`Token mint not in basket: ${mint}`);
+                    }
+                    keepTokensBitmask = keepTokensBitmask.or(new bn_js_1.default(1).shln(tokenIndex));
+                }
+            }
+            const basketRebalanceIntent = basket.settings.activeRebalance.gt(new bn_js_1.default(0))
+                ? (0, pda_1.getRebalanceIntentPda)(basket.ownAddress, basket.ownAddress)
+                : undefined;
+            let txBatchData = { batches: [
+                    [{
+                            payer: seller,
+                            instructions: [
+                                ...wsolIxs,
+                                (0, rebalanceIntent_1.createRebalanceIntentIx)({
+                                    signer: seller,
+                                    owner: seller,
+                                    basket: basket.ownAddress,
+                                }),
+                                (0, rebalanceIntent_1.resizeRebalanceIntentIx)(rebalanceIntent),
+                                (0, rebalanceIntent_1.initRebalanceIntentIx)({
+                                    signer: seller,
+                                    owner: seller,
+                                    basket: basket.ownAddress,
+                                    basketTokenMint: basketMint,
+                                    rebalanceIntentRentPayer: rebalanceIntentRentPayer,
+                                    bountyMint: bountyMint,
+                                    rebalanceType: rebalanceIntent_2.RebalanceType.Withdraw,
+                                    basketRebalanceIntent: basketRebalanceIntent,
+                                    rebalanceSlippageBps: rebalanceSlippageBps,
+                                    perTradeRebalanceSlippageBps: perTradeRebalanceSlippageBps,
+                                    executionStartTime: executionStartTime,
+                                    minBountyAmount: minBountyAmount,
+                                    maxBountyAmount: maxBountyAmount,
+                                    withdrawParamsBurnAmount: withdrawAmount,
+                                    withdrawParamsTokenMintsHash: tokenMintsHash,
+                                    withdrawParamsKeepTokensBitmask: keepTokensBitmask,
+                                    withdrawParamsKeepAllTokens: keepAllTokensFlag,
+                                }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }],
+                ] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Creates a rebalance intent for a basket rebalance.
+     * @param {Object} params - The parameters for the basket rebalance.
+     * @param {string} params.keeper - The public key of the keeper.
+     * @param {string} params.basket_mint - The basket token mint public key.
+     * @param {number} params.rebalance_slippage_bps - Optional. The rebalance slippage in basis points.
+     * @param {number} params.per_trade_rebalance_slippage_bps - Optional. The per trade rebalance slippage in basis points.
+     * @param {number} params.execution_start_time - Optional. The execution start time.
+     * @param {number} params.min_bounty_amount - Optional. The minimum bounty amount.
+     * @param {number} params.max_bounty_amount - Optional. The maximum bounty amount.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+    */
+    rebalanceBasketTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            let keeper = new web3_js_1.PublicKey(params.keeper);
+            let rebalanceSlippageBps = (_a = params.rebalance_slippage_bps) !== null && _a !== void 0 ? _a : 100;
+            let perTradeRebalanceSlippageBps = (_b = params.per_trade_rebalance_slippage_bps) !== null && _b !== void 0 ? _b : 100;
+            let executionStartTime = (_c = params.execution_start_time) !== null && _c !== void 0 ? _c : 0;
+            let minBountyAmount = (_d = params.min_bounty_amount) !== null && _d !== void 0 ? _d : 0;
+            let maxBountyAmount = (_e = params.max_bounty_amount) !== null && _e !== void 0 ? _e : 0;
+            const basket = yield this.fetchBasket((0, pda_1.getBasketState)(new web3_js_1.PublicKey(params.basket_mint)).toBase58());
+            let globalConfig = yield this.fetchGlobalConfig();
+            let bountyWsolAmount = 0;
+            if (globalConfig.bountyMint.equals(constants_1.MINTS["mainnet"].WSOL)) {
+                let boundBounty = parseInt(globalConfig.bountyBondAmount.toString());
+                let maxBountyPerTask = parseInt(globalConfig.bountyPerTask.maxBounty.toString());
+                let bountyPerPriceUpdateTaskDivisor = parseInt(globalConfig.bountyPerPriceUpdateTaskDivisor.toString());
+                if (maxBountyAmount > maxBountyPerTask)
+                    maxBountyPerTask = maxBountyAmount;
+                bountyWsolAmount = (0, rebalanceIntent_3.computeRebalanceIntentBountyAmount)(rebalanceIntent_2.RebalanceType.Basket, basket.numTokens, boundBounty, maxBountyPerTask, Math.floor(maxBountyPerTask / bountyPerPriceUpdateTaskDivisor));
+            }
+            let wsolIxs = yield (0, txUtils_1.wrapWsolIxs)(this.sdkParams.connection, keeper, bountyWsolAmount);
+            const rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket.ownAddress, basket.ownAddress);
+            let rentPayer = (0, pda_1.getRentPayerPda)();
+            let rentPayerAi = yield this.sdkParams.connection.getAccountInfo(rentPayer);
+            let rebalanceIntentRentPayer = keeper;
+            // TODO: check actual lamports required for rent
+            if ((_f = rentPayerAi === null || rentPayerAi === void 0 ? void 0 : rentPayerAi.lamports) !== null && _f !== void 0 ? _f : 0 > 500000000)
+                rebalanceIntentRentPayer = rentPayer;
+            let bountyMint = basket.settings.bountyMint;
+            let txBatchData = { batches: [[{
+                            payer: keeper,
+                            instructions: [
+                                ...wsolIxs,
+                                (0, rebalanceIntent_1.createRebalanceIntentIx)({
+                                    signer: keeper,
+                                    owner: basket.ownAddress,
+                                    basket: basket.ownAddress,
+                                }),
+                                (0, rebalanceIntent_1.resizeRebalanceIntentIx)(rebalanceIntent),
+                                (0, rebalanceIntent_1.initRebalanceIntentIx)({
+                                    signer: keeper,
+                                    owner: basket.ownAddress,
+                                    basket: basket.ownAddress,
+                                    basketTokenMint: basket.mint,
+                                    rebalanceIntentRentPayer: rebalanceIntentRentPayer,
+                                    bountyMint: bountyMint,
+                                    rebalanceType: rebalanceIntent_2.RebalanceType.Basket,
+                                    basketRebalanceIntent: undefined,
+                                    rebalanceSlippageBps: rebalanceSlippageBps,
+                                    perTradeRebalanceSlippageBps: perTradeRebalanceSlippageBps,
+                                    executionStartTime: executionStartTime,
+                                    minBountyAmount: minBountyAmount,
+                                    maxBountyAmount: maxBountyAmount,
+                                }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Build update token prices transactions.
+     *
+     * For pyth oracle accounts, fetches feed IDs, builds vaa [create init encode], [write verify],
+     *
+     * [update feed], [close vaa] instructions. For all tokens, builds [update token prices] instructions.
+     *
+     * returns TxPayloadBatchSequence ready for signAndSendTxPayloadBatchSequence.
+     *
+     * Batch layout:
+     *
+     *  batch 0:
+     * *   tx0: [vaa0CreateIx, vaa0InitIx, vaa0WriteIx],
+     * *   tx1: [vaa1CreateIx, vaa1InitIx, vaa1WriteIx],
+     * *   ...
+     *
+     *  batch 1:
+     * *   tx0: [vaa0WriteVerifyIx, vaa0VerifyIx],
+     * *   tx1: [vaa1WriteVerifyIx, vaa1VerifyIx],
+     * *   ...
+     *
+     *  batch 2:
+     * *   tx0: [updateFeed0Ix],
+     * *   tx1: [updateFeed1Ix],
+     * *   ...
+     *
+     *  batch 3:
+     * *   tx0: [updateTokenPricesIx(max 10 tokens)],
+     * *   tx1: [updateTokenPricesIx(max 10 tokens)],
+     * *   ...
+     * *   txLast: [closeVaa0Ix, closeVaa1Ix, ...]
+     *
+     * @param {Object} params - The parameters for the update token prices.
+     * @param {string} params.keeper - The public key of the keeper.
+     * @param {string} params.basket - The public key of the basket.
+     * @param {string} params.rebalance_intent - The public key of the rebalance intent.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+     */
+    updateTokenPricesTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let keeper = new web3_js_1.PublicKey(params.keeper);
+            let rebalanceIntent = new web3_js_1.PublicKey(params.rebalance_intent);
+            let basketRebalanceIntent = (0, pda_1.getRebalanceIntentPda)(new web3_js_1.PublicKey(params.basket), new web3_js_1.PublicKey(params.basket));
+            let basket = yield this.fetchBasket(params.basket);
+            let pythPriceFeeds = [];
+            let updateTokenPricesIxs = [];
+            for (let startIndex = 0; startIndex < basket.numTokens; startIndex++) {
+                let allKeys = [];
+                let tokenIndices = [];
+                for (let endIndex = startIndex; endIndex < basket.numTokens; endIndex++) {
+                    let numAccounts = basket.composition[endIndex].oracleAggregator.oracles
+                        .slice(0, basket.composition[endIndex].oracleAggregator.numOracles)
+                        .reduce((acc, oracle) => acc + oracle.oracleSettings.numRequiredAccounts, 0);
+                    if (allKeys.length + numAccounts > constants_1.UPDATE_TOKEN_PRICES_MAX_ACCOUNTS)
+                        break;
+                    if (tokenIndices.length == 20)
+                        break;
+                    startIndex = endIndex;
+                    tokenIndices.push(endIndex);
+                    let agg = basket.composition[endIndex].oracleAggregator;
+                    for (let i = 0; i < agg.numOracles; i++) {
+                        const oracleData = agg.oracles[i];
+                        for (let j = 0; j < oracleData.oracleSettings.numRequiredAccounts; j++) {
+                            const lutId = oracleData.accountsToLoadLutIds[j];
+                            const lutIdx = oracleData.accountsToLoadLutIndices[j];
+                            allKeys.push(basket.lutPubkeys[lutId].state.addresses[lutIdx]);
+                            if (oracleData.oracleSettings.oracleType === oracle_1.OracleType.Pyth)
+                                pythPriceFeeds.push(basket.lutPubkeys[lutId].state.addresses[lutIdx]);
+                        }
+                    }
+                }
+                while (tokenIndices.length < 20)
+                    tokenIndices.push(0);
+                // TODO: in last instruction we should include performance fee accounts
+                let performanceFees = basket.settings.fees.hostPerformanceFeeBps + basket.settings.fees.creatorPerformanceFeeBps + basket.settings.fees.managersPerformanceFeeBps;
+                updateTokenPricesIxs.push((0, priceUpdate_1.updateTokenPricesIx)({
+                    keeper: keeper,
+                    basket: basket.ownAddress,
+                    rebalanceIntent: rebalanceIntent,
+                    lookupTable0: basket.lookupTables.active[0],
+                    lookupTable1: basket.lookupTables.active[1],
+                    tokenIndices: tokenIndices,
+                    additionalOracleAccounts: allKeys,
+                    basketRebalanceIntent: basket.settings.activeRebalance.eq(new bn_js_1.default(0)) ? undefined : basketRebalanceIntent,
+                    basketMint: performanceFees > 0 ? basket.mint : undefined,
+                }));
+            }
+            const { feedIds } = yield (0, pythOracle_1.fetchFeedIdsFromAccounts)(this.sdkParams.connection, pythPriceFeeds);
+            const { vaaCreateInitEncodeIxs, vaaWriteVerifyIxs, updateFeedIxs, closeVaaIxs, } = yield (0, pythOracle_1.buildPythPriceFeedUpdateIxs)(keeper, feedIds);
+            let txBatchData = { batches: [
+                    [
+                        ...vaaCreateInitEncodeIxs.map(ixs => ({
+                            payer: keeper,
+                            instructions: [
+                                ...ixs.ixs,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        })),
+                    ],
+                    [
+                        ...vaaWriteVerifyIxs.map(ixs => ({
+                            payer: keeper,
+                            instructions: [
+                                ...ixs,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        })),
+                    ],
+                    [
+                        ...updateFeedIxs.map(ix => ({
+                            payer: keeper,
+                            instructions: [
+                                ix,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        })),
+                    ],
+                    [
+                        ...updateTokenPricesIxs.map(ix => ({
+                            payer: keeper,
+                            instructions: [
+                                ix,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [basket.lookupTables.active[0], basket.lookupTables.active[1]],
+                        })),
+                        {
+                            payer: keeper,
+                            instructions: [
+                                ...closeVaaIxs,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }
+                    ],
+                ] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            for (let [txId, vaaCreateInitEncodeIx] of vaaCreateInitEncodeIxs.entries()) {
+                versionedTxs.batches[0][txId].sign([vaaCreateInitEncodeIx.signer]);
+            }
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Build Pyth price feed update transactions from on-chain price account pubkeys.
+     * Fetches feed IDs from accounts, builds update instructions, and returns
+     * TxPayloadBatchSequence ready for signAndSendTxPayloadBatchSequence.
+     *
+     * Batch layout:
+     *
+     *  batch 0:
+     * *   tx0: [vaa0CreateIx, vaa0InitIx, vaa0WriteIx],
+     * *   tx1: [vaa1CreateIx, vaa1InitIx, vaa1WriteIx],
+     * *   ...
+     *
+     *  batch 1:
+     * *   tx0: [vaa0WriteVerifyIx, vaa0VerifyIx],
+     * *   tx1: [vaa1WriteVerifyIx, vaa1VerifyIx],
+     * *   ...
+     *
+     *  batch 2:
+     * *   tx0: [updateFeed0Ix],
+     * *   tx1: [updateFeed1Ix],
+     * *   ...
+     *
+     *  batch 3:
+     * *   txLast: [closeVaa0Ix, closeVaa1Ix, ...]
+     *
+     */
+    updatePythPriceFeedsTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payer = new web3_js_1.PublicKey(params.keeper);
+            const priceAccounts = params.accounts.map(a => new web3_js_1.PublicKey(a));
+            const { feedIds } = yield (0, pythOracle_1.fetchFeedIdsFromAccounts)(this.sdkParams.connection, priceAccounts);
+            const { vaaCreateInitEncodeIxs, vaaWriteVerifyIxs, updateFeedIxs, closeVaaIxs, } = yield (0, pythOracle_1.buildPythPriceFeedUpdateIxs)(payer, feedIds);
+            let txBatchData = { batches: [
+                    [
+                        ...vaaCreateInitEncodeIxs.map(ixs => ({
+                            payer: payer,
+                            instructions: [
+                                ...ixs.ixs,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        })),
+                    ],
+                    [
+                        ...vaaWriteVerifyIxs.map(ixs => ({
+                            payer: payer,
+                            instructions: [
+                                ...ixs,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        })),
+                    ],
+                    [
+                        ...updateFeedIxs.map(ix => ({
+                            payer: payer,
+                            instructions: [
+                                ix,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        })),
+                    ],
+                    [
+                        {
+                            payer: payer,
+                            instructions: [
+                                ...closeVaaIxs,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }
+                    ],
+                ] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            for (let [txId, vaaCreateInitEncodeIx] of vaaCreateInitEncodeIxs.entries()) {
+                versionedTxs.batches[0][txId].sign([vaaCreateInitEncodeIx.signer]);
+            }
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Build flash swap transactions (Rebalance or MakeDirectSwap).
+     *
+     * Withdraws amount_out tokens(mint_out) from basket, deposits amount_in tokens(mint_in) to basket.
+     *
+     * If jup_swap_ix is provided, uses it to swap amount_out tokens(mint_out) for amount_in tokens(mint_in).
+     *
+     * returns TxPayloadBatchSequence ready for signAndSendTxPayloadBatchSequence.
+     *
+     * Batch layout: batch 0: tx: 0:
+     * * create associated token account_mint_out
+     * * create associated token account_mint_in
+     * * jup_token_ledger_ix
+     * * flash withdraw
+     * * jup_swap_ix
+     * * flash deposit
+     * * set compute unit limit
+     * * set compute unit price
+     *
+     * @param {Object} params - The parameters for the flash swap.
+     * @param {string} params.keeper - The public key of the keeper.
+     * @param {string} params.basket - The public key of the basket.
+     * @param {string} params.rebalance_intent - The public key of the rebalance intent (for Rebalance).
+     * @param {string} params.intent - The public key of the intent (for MakeDirectSwap).
+     * @param {string} params.mint_in - The mint of the input token (deposited to basket).
+     * @param {string} params.mint_out - The mint of the output token (withdrawn from basket).
+     * @param {number} params.amount_in - The amount of the input token (deposited to basket).
+     * @param {number} params.amount_out - The amount of the output token (withdrawn from basket).
+     * @param {"exact_in" | "exact_out" | "ioc"} params.mode - The mode of the flash swap.
+     * @param {TransactionInstruction} params.jup_token_ledger_ix - The jup token ledger ix.
+     * @param {TransactionInstruction} params.jup_swap_ix - The jup swap ix.
+     * @param {PublicKey[]} params.jup_address_lookup_table_addresses - The jup address lookup table addresses.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+     */
+    flashSwapTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let keeper = new web3_js_1.PublicKey(params.keeper);
+            let basket = new web3_js_1.PublicKey(params.basket);
+            let rebalanceIntent = params.rebalance_intent ? new web3_js_1.PublicKey(params.rebalance_intent) : undefined;
+            let intent = params.intent ? new web3_js_1.PublicKey(params.intent) : undefined;
+            let mintIn = new web3_js_1.PublicKey(params.mint_in);
+            let mintOut = new web3_js_1.PublicKey(params.mint_out);
+            let amountIn = new bn_js_1.default(params.amount_in);
+            let amountOut = new bn_js_1.default(params.amount_out);
+            let mode = params.mode ? params.mode : 0;
+            let flashParams = {
+                keeper: keeper,
+                basket: basket,
+                rebalanceIntent: rebalanceIntent,
+                intent: intent,
+                mintIn: mintIn,
+                mintOut: mintOut,
+                amountIn: amountIn,
+                amountOut: amountOut,
+                mode: mode,
+            };
+            let ixWithdraw = (0, flashSwap_1.flashWithdrawIx)(flashParams);
+            let ixDeposit = (0, flashSwap_1.flashDepositIx)(flashParams);
+            let ixs = [];
+            ixs = ixs.concat([
+                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(keeper, (0, pda_1.getAta)(keeper, mintIn), keeper, mintIn),
+                (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(keeper, (0, pda_1.getAta)(keeper, mintOut), keeper, mintOut),
+            ]);
+            if (params.jup_token_ledger_ix) {
+                ixs.push(params.jup_token_ledger_ix);
+            }
+            ixs.push(ixWithdraw);
+            if (params.jup_swap_ix) {
+                ixs.push(params.jup_swap_ix);
+            }
+            ixs.push(ixDeposit);
+            ixs = ixs.concat([
+                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+            ]);
+            let txBatchData = { batches: [[{
+                            payer: keeper,
+                            instructions: ixs,
+                            lookupTables: (_a = params.jup_address_lookup_table_addresses) !== null && _a !== void 0 ? _a : [],
+                        }]] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Mints basket tokens for a user. Executable when the rebalance intent has finished its auctions.
+     *
+     * Returns TxPayloadBatchSequence ready for signAndSendTxPayloadBatchSequence.
+     *
+     * @param {Object} params - The parameters for the mint.
+     * @param {string} params.keeper - The public key of the keeper.
+     * @param {string} params.rebalance_intent - The public key of the rebalance intent.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+     */
+    mintTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let keeper = new web3_js_1.PublicKey(params.keeper);
+            let rebalanceIntent = (yield this.fetchRebalanceIntent(params.rebalance_intent)).chain_data;
+            let basket = yield this.fetchBasket(rebalanceIntent.basket.toBase58());
+            let basketRebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket.ownAddress, rebalanceIntent.owner);
+            let ix = (0, deposit_1.mintBasketIx)({
+                keeper: keeper,
+                basket: basket.ownAddress,
+                basketTokenMint: basket.mint,
+                buyer: rebalanceIntent.owner,
+                basketRebalanceIntent: basket.settings.activeRebalance.eq(new bn_js_1.default(0)) ? undefined : basketRebalanceIntent,
+            });
+            let txBatchData = { batches: [[{
+                            payer: keeper,
+                            instructions: [
+                                ix,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Redeems tokens from the rebalance intent with Withdraw status.
+     *
+     * Returns TxPayloadBatchSequence ready for signAndSendTxPayloadBatchSequence.
+     *
+     * @param {Object} params - The parameters for the redeem tokens.
+     * @param {string} params.keeper - The public key of the keeper.
+     * @param {string} params.rebalance_intent - The public key of the rebalance intent.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+     */
+    redeemTokensTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let keeper = new web3_js_1.PublicKey(params.keeper);
+            let rebalanceIntent = (yield this.fetchRebalanceIntent(params.rebalance_intent)).chain_data;
+            let batchSize = 7;
+            let ixs = [];
+            for (let batchStart = 0; batchStart < rebalanceIntent.tokens.length; batchStart += batchSize) {
+                let tokenMints = [];
+                for (let i = batchStart; i < rebalanceIntent.tokens.length && i < batchStart + batchSize; i++)
+                    if (rebalanceIntent.tokens[i].amount.gt(new bn_js_1.default(0)))
+                        tokenMints.push(rebalanceIntent.tokens[i].mint);
+                if (tokenMints.length > 0) {
+                    ixs.push((0, withdraw_1.redeemTokensIx)({
+                        keeper: keeper,
+                        basket: rebalanceIntent.basket,
+                        owner: rebalanceIntent.owner,
+                        tokenMints: tokenMints,
+                    }));
+                }
+            }
+            let txBatchData = { batches: [ixs.map(ix => ({
+                        payer: keeper,
+                        instructions: [
+                            ix,
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                        ],
+                        lookupTables: [],
+                    }))] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Claims the bounty to keepers who have completed tasks for rebalance intent.
+     *
+     * Executebale when the rebalance intent has finished its auctions.
+     *
+     * For Withdraw status rebalance intent, tokens have to be redeemed first.
+     *
+     * Closes the rebalance intent if all keepers have claimed the bounty.
+     *
+     * @param {Object} params - The parameters for the claim bounty.
+     * @param {string} params.keeper - The public key of the keeper.
+     * @param {string} params.rebalance_intent - The public key of the rebalance intent.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+     */
+    claimBountyTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let keeper = new web3_js_1.PublicKey(params.keeper);
+            let rebalanceIntent = (yield this.fetchRebalanceIntent(params.rebalance_intent)).chain_data;
+            let keepersArray = [];
+            if (!rebalanceIntent.auctionCreationTask.completedBy.equals(web3_js_1.PublicKey.default))
+                keepersArray.push(rebalanceIntent.auctionCreationTask.completedBy.toBase58());
+            if (!rebalanceIntent.cancelRebalanceTask.completedBy.equals(web3_js_1.PublicKey.default))
+                keepersArray.push(rebalanceIntent.cancelRebalanceTask.completedBy.toBase58());
+            if (!rebalanceIntent.placeholderTask.completedBy.equals(web3_js_1.PublicKey.default))
+                keepersArray.push(rebalanceIntent.placeholderTask.completedBy.toBase58());
+            if (!rebalanceIntent.finishPriceUpdateTask.completedBy.equals(web3_js_1.PublicKey.default))
+                keepersArray.push(rebalanceIntent.finishPriceUpdateTask.completedBy.toBase58());
+            if (!rebalanceIntent.mintBasketTask.completedBy.equals(web3_js_1.PublicKey.default))
+                keepersArray.push(rebalanceIntent.mintBasketTask.completedBy.toBase58());
+            for (let i = 0; i < rebalanceIntent.priceUpdateTasks.length; i++)
+                if (!rebalanceIntent.priceUpdateTasks[i].completedBy.equals(web3_js_1.PublicKey.default))
+                    keepersArray.push(rebalanceIntent.priceUpdateTasks[i].completedBy.toBase58());
+            for (let i = 0; i < rebalanceIntent.tokenSettlementTasks.length; i++)
+                if (!rebalanceIntent.tokenSettlementTasks[i].completedBy.equals(web3_js_1.PublicKey.default))
+                    keepersArray.push(rebalanceIntent.tokenSettlementTasks[i].completedBy.toBase58());
+            keepersArray = Array.from(new Set(keepersArray));
+            let batchSize = 10;
+            let ixs = [];
+            let wsolIxs = yield (0, txUtils_1.wrapWsolIxs)(this.sdkParams.connection, keeper, 0);
+            ixs.push(...wsolIxs);
+            for (let batchStart = 0; batchStart < keepersArray.length; batchStart += batchSize)
+                ixs.push((0, claimBounty_1.claimBountyIx)({
+                    keeper: keeper,
+                    basket: rebalanceIntent.basket, //@ts-ignore
+                    intent: rebalanceIntent.ownAddress,
+                    bountyMint: rebalanceIntent.bounty.bountyMint,
+                    bountyDepositor: rebalanceIntent.bounty.bountyDepositor,
+                    rentPayer: rebalanceIntent.rentPayer,
+                    keepers: keepersArray.map(keeper => new web3_js_1.PublicKey(keeper)).slice(batchStart, batchStart + batchSize),
+                }));
+            let txBatchData = { batches: [ixs.map(ix => ({
+                        payer: keeper,
+                        instructions: [
+                            ix,
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                        ],
+                        lookupTables: [],
+                    }))] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Adds bounty for automation to basket.
+     * Returns TxPayloadBatchSequence ready for signAndSendTxPayloadBatchSequence.
+     *
+     * @param {Object} params - The parameters for the add bounty.
+     * @param {string} params.keeper - The public key of the keeper.
+     * @param {string} params.basket - The public key of the basket.
+     * @param {number} params.amount - The amount of the bounty.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+     */
+    addBountyTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let keeper = new web3_js_1.PublicKey(params.keeper);
+            let basket = yield this.fetchBasket(params.basket);
+            let globalConfig = yield this.fetchGlobalConfig();
+            let bountyWsolAmount = 0;
+            if (globalConfig.bountyMint.equals(constants_1.MINTS["mainnet"].WSOL)) {
+                bountyWsolAmount = params.amount;
+            }
+            let wsolIxs = yield (0, txUtils_1.wrapWsolIxs)(this.sdkParams.connection, keeper, bountyWsolAmount);
+            let ix = (0, addBounty_1.addBountyIx)({
+                keeper: keeper,
+                basket: basket.ownAddress,
+                bountyMint: basket.settings.bountyMint,
+                amount: params.amount,
+            });
+            let txBatchData = { batches: [[{
+                            payer: keeper,
+                            instructions: [
+                                ...wsolIxs,
+                                ix,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Withdraws fees from the basket, initializes WithdrawBasketFees accounts, and claims the fee tokens
+     * for all fee types that the claimer is authorized to claim (symmetry, creator, host, or manager fees).
+     *
+     * This function automatically determines which fee types the claimer can claim based on:
+     * - Symmetry fees: if claimer equals globalConfig.symmetryFeeCollector
+     * - Creator fees: if claimer equals basket.settings.creator
+     * - Host fees: if claimer equals basket.settings.host
+     * - Manager fees: if claimer is in basket.settings.managers.managers
+     *
+     * Returns TxPayloadBatchSequence ready for signAndSendTxPayloadBatchSequence.
+     *
+     * Batch layout:
+     * - batch 0: One transaction per claimable fee type, each containing a withdrawFeesIx instruction.
+     *   All transactions in this batch can run in parallel. These create and populate the WithdrawBasketFees accounts.
+     * - batch 1: Multiple transactions for claiming fee tokens, automatically batched based on account limits.
+     *   All transactions in this batch can run in parallel. These transfer tokens from WithdrawBasketFees accounts to claimers.
+     *
+     * Note: If not all tokens are claimed in batch 1 (e.g., due to account limits or errors),
+     * use claimTokenFeesFromBasketTx to claim the remaining tokens.
+     *
+     * @param {Object} params - The parameters for withdrawing and claiming basket fees.
+     * @param {string} params.claimer - The public key of the claimer.
+     * @param {string} params.basket - The public key of the basket.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+     */
+    withdrawBasketFeesTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let claimer = new web3_js_1.PublicKey(params.claimer);
+            let basket = yield this.fetchBasket(params.basket);
+            let globalConfig = yield this.fetchGlobalConfig();
+            let claimableFeeTypes = [];
+            let owners = [];
+            if (claimer.equals(globalConfig.symmetryFeeCollector)) {
+                claimableFeeTypes.push(0);
+                owners.push([globalConfig.symmetryFeeCollector]);
+            }
+            if (claimer.equals(basket.settings.creator)) {
+                claimableFeeTypes.push(1);
+                owners.push([basket.settings.creator]);
+            }
+            if (claimer.equals(basket.settings.host)) {
+                claimableFeeTypes.push(2);
+                owners.push([basket.settings.host]);
+            }
+            if (basket.settings.managers.managers.find(manager => manager.equals(claimer))) {
+                claimableFeeTypes.push(3);
+                owners.push(basket.settings.managers.managers);
+            }
+            let withdrawFeesIxs = [];
+            let claimTokenFeesFromBasketIxs = [];
+            claimableFeeTypes.forEach((feeType, index) => {
+                withdrawFeesIxs.push((0, claimFees_1.withdrawFeesIx)({
+                    claimer,
+                    basketTokenMint: basket.mint,
+                    feeType: feeType,
+                }));
+                claimTokenFeesFromBasketIxs.push(...(0, claimFees_1.claimFeeTokensFromBasketIxs)(claimer, basket.ownAddress, (0, pda_1.getWithdrawBasketFeesPda)(basket.ownAddress, feeType), claimer, owners[index], basket.composition.map(composition => composition.mint)));
+            });
+            let txBatchData = { batches: [
+                    withdrawFeesIxs.map(ix => ({
+                        payer: claimer,
+                        instructions: [
+                            ix,
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                        ],
+                        lookupTables: [],
+                    })),
+                    claimTokenFeesFromBasketIxs.map(ix => ({
+                        payer: claimer,
+                        instructions: [
+                            ix,
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                        ],
+                        lookupTables: [],
+                    })),
+                ] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Claims fee tokens from a WithdrawBasketFees account.
+     *
+     * This function transfers accumulated fee tokens from the WithdrawBasketFees account
+     * to the claimers (owners) based on their weights. The tokens are automatically batched
+     * into multiple transactions if needed to respect Solana's account limit (30 accounts per transaction).
+     *
+     * Returns TxPayloadBatchSequence ready for signAndSendTxPayloadBatchSequence.
+     *
+     * @param {Object} params - The parameters for claiming basket fees.
+     * @param {string} params.claimer - The public key of the claimer.
+     * @param {string} params.basket - The public key of the basket.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+     */
+    claimTokenFeesFromBasketTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let claimer = new web3_js_1.PublicKey(params.claimer);
+            let withdrawBasketFees = yield this.fetchWithdrawBasketFees(params.withdrawBasketFees);
+            let claimTokenFeesFromBasketIxs = (0, claimFees_1.claimFeeTokensFromBasketIxs)(claimer, withdrawBasketFees.basket, withdrawBasketFees.ownAddress, withdrawBasketFees.rentPayer, withdrawBasketFees.owners, withdrawBasketFees.accumulatedTokens);
+            // Create batches: all claim instructions can run in parallel
+            let txBatchData = { batches: [
+                    claimTokenFeesFromBasketIxs.map(ix => ({
+                        payer: claimer,
+                        instructions: [
+                            ix,
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                        ],
+                        lookupTables: [],
+                    }))
+                ] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    /**
+     * Rewrites lookup tables for the basket. (Used when the basket lookup tables are full)
+     *
+     * Returns TxPayloadBatchSequence ready for signAndSendTxPayloadBatchSequence.
+     *
+      * Batch layout:
+     *
+     *  batch 0:
+     * * tx0: [create temp lookup tables],
+     *
+     * batch 1:
+     * * tx0: [extend temp lookup tables (with oracles of active tokens)],
+     * * tx1: [extend temp lookup tables (with oracles of active tokens)],
+     * * ...
+     *
+     * batch 2:
+     * * tx0: [overwrite lookup tables with temp, deactivate old lookup tables],
+     *
+     * @param {Object} params - The parameters for the rewrite lookup tables.
+     * @param {string} params.signer - The public key of the signer.
+     * @param {string} params.basket_mint - The mint of the basket.
+     * @param {string[]} params.additional_accounts - The additional accounts.
+     * @returns {Promise<TxPayloadBatchSequence>} The transaction payload batch sequence.
+     */
+    rewriteLookupTablesTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signer = new web3_js_1.PublicKey(params.signer);
+            const basketMint = new web3_js_1.PublicKey(params.basket_mint);
+            const additionalAccounts = params.additional_accounts.map(a => new web3_js_1.PublicKey(a));
+            const basketAddress = (0, pda_1.getBasketState)(basketMint);
+            const basket = yield this.fetchBasket(basketAddress.toBase58());
+            const activeLut0 = basket.lookupTables.active[0];
+            const activeLut1 = basket.lookupTables.active[1];
+            let oldTempLut0 = basket.lookupTables.temp[0];
+            let oldTempLut1 = basket.lookupTables.temp[1];
+            const slot = yield this.sdkParams.connection.getSlot("finalized");
+            const newLut0 = (0, pda_1.getLookupTableAccount)(basketAddress, slot);
+            const newLut1 = (0, pda_1.getLookupTableAccount)(basketAddress, slot - 1);
+            // Step 1: create lookup tables
+            const createIx = (0, luts_1.createBasketLookupTablesInstruction)({
+                signer,
+                basket: basketAddress,
+                oldTempLookupTable0: oldTempLut0,
+                oldTempLookupTable1: oldTempLut1,
+                newTempLookupTable0: newLut0,
+                newTempLookupTable1: newLut1,
+                slot,
+            });
+            const txBatchData = { batches: [
+                    [{
+                            payer: signer,
+                            instructions: [
+                                createIx,
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }],
+                ] };
+            // Step 2: extend LUTs in batches of ~20
+            const BATCH_SIZE = constants_1.LUT_EXTEND_BATCH_SIZE;
+            for (let i = 0; i < additionalAccounts.length; i += BATCH_SIZE) {
+                const batch = additionalAccounts.slice(i, i + BATCH_SIZE);
+                const extendIx = (0, luts_1.extendBasketLookupTablesIx)({
+                    signer,
+                    basket: basketAddress,
+                    tempLookupTable0: newLut0,
+                    tempLookupTable1: newLut1,
+                    additionalAccounts: batch,
+                });
+                txBatchData.batches.push([{
+                        payer: signer,
+                        instructions: [
+                            extendIx,
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                        ],
+                        lookupTables: [],
+                    }]);
+            }
+            // Step 3: overwrite active LUTs
+            const overwriteIx = (0, luts_1.overwriteBasketLookupTablesIx)({
+                signer,
+                basket: basketAddress,
+                tempLookupTable0: newLut0,
+                tempLookupTable1: newLut1,
+                activeLookupTable0: activeLut0,
+                activeLookupTable1: activeLut1,
+            });
+            txBatchData.batches.push([{
+                    payer: signer,
+                    instructions: [
+                        overwriteIx,
+                        web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                        web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                    ],
+                    lookupTables: [],
+                }]);
+            const versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            const txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
+    signAndSendVersionedTxs(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { versionedTxs, wallet } = params;
+            versionedTxs = yield (0, txUtils_1.signVersionedTxs)(wallet, versionedTxs);
+            return yield (0, txUtils_1.sendVersionedTxs)(this.sdkParams.connection, versionedTxs, false);
+        });
+    }
+    signAndSendTxPayloadBatchSequence(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { txPayloadBatchSequence, wallet, simulateTransactions = false } = params;
+            txPayloadBatchSequence = yield (0, txUtils_1.signTxPayloadBatchSequence)(wallet, txPayloadBatchSequence);
+            return yield (0, txUtils_1.sendTxPayloadBatchSequence)(this.sdkParams.connection, txPayloadBatchSequence, simulateTransactions);
+        });
+    }
+}
+exports.SymmetryCore = SymmetryCore;
+var keeperMonitor_1 = require("./keeperMonitor");
+Object.defineProperty(exports, "KeeperMonitor", { enumerable: true, get: function () { return keeperMonitor_1.KeeperMonitor; } });
+Object.defineProperty(exports, "RebalanceHandler", { enumerable: true, get: function () { return keeperMonitor_1.RebalanceHandler; } });