@symmetry-hq/sdk 1.0.1

package/src/index.ts

@@ -0,0 +1,2431 @@
+import Decimal from 'decimal.js';
+
+import BN from 'bn.js';
+import {
+    createAssociatedTokenAccountIdempotentInstruction, createAssociatedTokenAccountInstruction,
+    TOKEN_2022_PROGRAM_ID,
+    TOKEN_PROGRAM_ID,
+} from '@solana/spl-token';
+import {
+    ComputeBudgetProgram, Connection, Keypair, PublicKey, TransactionInstruction,
+    TransactionSignature
+} from '@solana/web3.js';
+
+import {
+    COMPUTE_UNITS, LUT_EXTEND_BATCH_SIZE, MINTS, PRIORITY_FEE, UPDATE_TOKEN_PRICES_MAX_ACCOUNTS
+} from './constants';
+import { claimBountyIx } from './instructions/automation/claimBounty';
+import { flashDepositIx, flashWithdrawIx } from './instructions/automation/flashSwap';
+import { updateTokenPricesIx } from './instructions/automation/priceUpdate';
+import {
+    cancelRebalanceIx, createRebalanceIntentIx, initRebalanceIntentIx, resizeRebalanceIntentIx
+} from './instructions/automation/rebalanceIntent';
+import { addBountyIx } from './instructions/management/addBounty';
+import { createGlobalConfigIx, editGlobalConfigIx } from './instructions/management/admin';
+import { withdrawFeesIx, claimFeeTokensFromBasketIx, claimFeeTokensFromBasketIxs } from './instructions/management/claimFees';
+import {
+    createBasketIx, createBasketStateAccountIx, resizeBasketStateIx
+} from './instructions/management/createBasket';
+import {
+    cancelIntentIx, createEditBasketIntentIx, executeEditBasketIntentIx
+} from './instructions/management/edit';
+import {
+    createBasketLookupTablesInstruction, extendBasketLookupTablesIx, overwriteBasketLookupTablesIx
+} from './instructions/management/luts';
+import {
+    getAta, getBasketFeesPda, getBasketState, getBasketTokenMintPda,
+    getIntentPda, getLookupTableAccount, getRebalanceIntentPda, getRentPayerPda, getWithdrawBasketFeesPda
+} from './instructions/pda';
+import { depositTokensIx, lockDepositsIx, mintBasketIx } from './instructions/user/deposit';
+import { redeemTokensIx } from './instructions/user/withdraw';
+import { getJupTokenLedgerAndSwapInstructions } from './jup';
+import {
+    Basket, FormattedAccumulatedFees, FormattedAddTokenSettings, FormattedAsset,
+    FormattedAutomationSettings, FormattedBasket, FormattedCreatorSettings,
+    FormattedCustomRebalanceSettings, FormattedDepositsSettings, FormattedFeeSettings,
+    FormattedForceRebalanceSettings, FormattedLookupTables, FormattedLpSettings,
+    FormattedMakeDirectSwapSettings, FormattedManagersSettings, FormattedMetadataSettings,
+    FormattedOracle, FormattedOracleAggregator, FormattedOracleSettings, FormattedScheduleSettings,
+    FormattedUpdateWeightsSettings, WithdrawBasketFees
+} from './layouts/basket';
+import { FormattedGlobalConfig, GlobalConfig } from './layouts/config';
+import { decimalToFraction } from './layouts/fraction';
+import {
+    AddOrEditTokenInput, EditAddTokenSettings, EditAutomationSettings, EditCreatorSettings,
+    EditCustomRebalanceSettings, EditDepositsSettings, EditFeeSettings, EditForceRebalanceSettings,
+    EditLpSettings, EditMakeDirectSwapSettings, EditManagerSettings, EditMetadataSettings,
+    EditScheduleSettings, EditUpdateWeightsSettings, FormattedBounty, FormattedBountySchedule,
+    FormattedIntent, FormattedIntentStatus, FormattedTaskType, Intent, MakeDirectSwapInput,
+    OracleInput, Settings, TaskContext, TaskType, UpdateWeightsInput
+} from './layouts/intents/intent';
+import {
+    FormattedOraclePrice, FormattedRebalanceAction, FormattedRebalanceIntent,
+    FormattedRebalanceType, FormattedTaskCompletion, FormattedTokenAuction, MintData, PriceUpdatesData, RebalanceIntent,
+    RebalanceType, AuctionData,
+    RedeemData, DepositData, ClaimBountyData,
+    UIRebalanceIntent
+} from './layouts/intents/rebalanceIntent';
+import { FormattedOracleType, OracleType } from './layouts/oracle';
+import {
+    BasketFilter, computeTokenMintsHash, fetchBasketsMultiple, fetchBasket, fetchBaskets,
+    loadBasketPrice
+} from './states/basket';
+import { fetchGlobalConfig } from './states/config';
+import {
+    fetchIntent, fetchIntents, fetchIntentsMultiple, IntentFilter
+} from './states/intents/intent';
+import {
+    computeRebalanceIntentBountyAmount, fetchRebalanceIntent, fetchRebalanceIntents,
+    fetchRebalanceIntentsMultiple, RebalanceIntentFilter
+} from './states/intents/rebalanceIntent';
+import {
+    fetchWithdrawBasketFees, fetchWithdrawBasketFeesMultiple, fetchWithdrawBasketFeesList, WithdrawBasketFeesFilter
+} from './states/withdrawBasketFees';
+import {
+    buildPythPriceFeedUpdateIxs, fetchFeedIdsFromAccounts
+} from './states/oracles/pythOracle';
+import {
+    BasketCreationTx,
+    prepareTxPayloadBatchSequence, prepareVersionedTxs, sendTxPayloadBatchSequence,
+    sendVersionedTxs, signTxPayloadBatchSequence, signVersionedTxs, TxBatchData,
+    TxPayloadBatchSequence, VersionedTxs, Wallet, wrapWsolIxs
+} from './txUtils';
+
+export class SymmetryCore {
+
+    private sdkParams: {
+        connection: Connection,
+        network: "devnet" | "mainnet",
+        priorityFee: number,
+        //TODO: lower comput units for all txs
+    }
+
+    /**
+     * 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: {
+        connection: Connection,
+        network: "devnet" | "mainnet",
+        priorityFee?: number,
+    }) {
+        this.sdkParams = {
+            connection: params.connection,
+            network: params.network,
+            priorityFee: params.priorityFee ?? PRIORITY_FEE,
+        };
+    }
+
+    /**
+     * Sets the priority fee for the SDK.
+     * @param {number} priorityFee - The priority fee in micro-lamports.
+    */
+    setPriorityFee(priorityFee: number) {
+        this.sdkParams.priorityFee = priorityFee;
+    }
+
+    /**
+     * Fetches the global config account.
+     * @returns {Promise<GlobalConfig>} The global config.
+    */
+    async fetchGlobalConfig(): Promise<GlobalConfig> {
+        return await 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.
+    */
+    async fetchBasket(basketPubkey: string): Promise<Basket> {
+        return await fetchBasket(this.sdkParams.connection, new 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.
+    */
+    async fetchMultipleBaskets(basketPubkeys: string[]): Promise<Map<string, Basket>> {
+        return await fetchBasketsMultiple(this.sdkParams.connection, basketPubkeys.map(key => new 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.
+    */
+    async fetchAllBaskets(basketFilter?: BasketFilter): Promise<Basket[]> {
+        return await 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.
+    */
+    async fetchCreatedBaskets(creatorPubkey: string): Promise<Basket[]> {
+        return await 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.
+    */
+    async fetchHostedBaskets(hostPubkey: string): Promise<Basket[]> {
+        return await 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.
+    */
+    async fetchManagedBaskets(managerPubkey: string): Promise<Basket[]> {
+        return await 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.
+    */
+    async deriveBasketsByMints(mints: string[]): Promise<Map<string, string>> {
+        let result: Map<string, string> = new Map();
+        for (let basketId = 0; basketId < 50000; basketId++) {
+            let mint = getBasketTokenMintPda(basketId).toBase58();
+            if (mints.includes(mint)) {
+                result.set(mint, getBasketState(new 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.
+    */
+    async fetchBasketsFromMints(
+        mints: string[],
+    ): Promise<Map<string, Basket>> {
+        let basketPubkeys: PublicKey[] = mints.map(mint => {
+            let res: PublicKey | null = null;
+            try { res = getBasketState(new PublicKey(mint)) } catch (e) { return null }
+            return res;
+        }).filter(mint => mint !== null);
+        const basketsMap = await fetchBasketsMultiple(this.sdkParams.connection, basketPubkeys);
+        let mintsMap: Map<string, Basket> = 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.
+    */
+    async loadBasketPrice(
+        basket: Basket,
+    ): Promise<Basket> {
+        return await 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.
+    */
+    async fetchIntent(intentPubkey: string): Promise<Intent> {
+        return await fetchIntent(this.sdkParams.connection, new 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.
+    */
+    async fetchMultipleIntents(intentPubkeys: string[]): Promise<Map<string, Intent>> {
+        return await fetchIntentsMultiple(this.sdkParams.connection, intentPubkeys.map(key => new 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.
+    */
+    async fetchAllIntents(filter?: IntentFilter): Promise<Intent[]> {
+        return await 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.
+    */
+    async fetchCreatedIntents(creatorPubkey: string): Promise<Intent[]> {
+        return await 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.
+    */
+    async fetchBasketIntents(basketPubkey: string): Promise<Intent[]> {
+        return await 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.
+    */
+    async fetchRebalanceIntent(rebalanceIntentPubkey: string): Promise<UIRebalanceIntent> {
+        return await fetchRebalanceIntent(this.sdkParams.connection, new 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.
+    */
+    async fetchMultipleRebalanceIntents(rebalanceIntentPubkeys: string[]): Promise<Map<string, UIRebalanceIntent>> {
+        return await fetchRebalanceIntentsMultiple(this.sdkParams.connection, rebalanceIntentPubkeys.map(key => new 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.
+    */
+    async fetchAllRebalanceIntents(filter?: RebalanceIntentFilter): Promise<UIRebalanceIntent[]> {
+        return await 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.
+    */
+    async fetchOwnerRebalanceIntents(ownerPubkey: string): Promise<UIRebalanceIntent[]> {
+        return await 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.
+    */
+    async fetchBasketRebalanceIntents(basketPubkey: string): Promise<UIRebalanceIntent[]> {
+        return await 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.
+    */
+    async fetchWithdrawBasketFees(withdrawBasketFeesPubkey: string): Promise<WithdrawBasketFees> {
+        return await fetchWithdrawBasketFees(this.sdkParams.connection, new 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.
+    */
+    async fetchMultipleWithdrawBasketFees(withdrawBasketFeesPubkeys: string[]): Promise<Map<string, WithdrawBasketFees>> {
+        return await fetchWithdrawBasketFeesMultiple(this.sdkParams.connection, withdrawBasketFeesPubkeys.map(key => new 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.
+    */
+    async fetchAllWithdrawBasketFees(filter?: WithdrawBasketFeesFilter): Promise<WithdrawBasketFees[]> {
+        return await 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.
+    */
+    async fetchBasketWithdrawBasketFees(basketPubkey: string): Promise<WithdrawBasketFees[]> {
+        return await 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.
+    */
+    async fetchManagerWithdrawBasketFees(managerPubkey: string): Promise<WithdrawBasketFees[]> {
+        return await 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.
+    */
+    async fetchCreatorWithdrawBasketFees(creatorPubkey: string): Promise<WithdrawBasketFees[]> {
+        return await 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.
+    */
+    async fetchHostWithdrawBasketFees(hostPubkey: string): Promise<WithdrawBasketFees[]> {
+        return await 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.
+    */
+    async fetchSymmetryWithdrawBasketFees(symmetryPubkey: string): Promise<WithdrawBasketFees[]> {
+        return await fetchWithdrawBasketFeesList(this.sdkParams.connection, { type: "symmetry", pubkey: symmetryPubkey });
+    }
+
+    async createGlobalConfigTx(params: {
+        signer: PublicKey,
+    }): Promise<TxPayloadBatchSequence> {
+        let ix = createGlobalConfigIx({admin: params.signer});
+        let txBatchData: TxBatchData = {batches: [[{
+            payer: params.signer,
+            instructions: [
+                ix,
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+            ],
+            lookupTables: [],
+        }]]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = prepareTxPayloadBatchSequence(txBatchData, versionedTxs);
+        return txPayloadBatchSequence;
+    }
+
+    async editGlobalConfigTx(params: {
+        signer: PublicKey,
+        config: GlobalConfig,
+    }): Promise<TxPayloadBatchSequence> {
+        let ix = editGlobalConfigIx(params);
+        let txBatchData: TxBatchData = {batches: [[{
+            payer: params.signer,
+            instructions: [
+                ix,
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+            ],
+            lookupTables: [],
+        }]]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+    */
+    async createBasketTx(params: {
+        creator: string, 
+        start_price: string, 
+        name: string,
+        symbol: string,
+        metadata_uri: string,
+        host_platform_params?: {
+            host_pubkey: string,
+            host_deposit_fee_bps: number,
+            host_withdraw_fee_bps: number,
+            host_management_fee_bps: number,
+            host_performance_fee_bps: number,
+        },
+    }): Promise<BasketCreationTx> {
+        const creator = new PublicKey(params.creator);
+        const host = new PublicKey(params.host_platform_params?.host_pubkey ?? params.creator);
+        const hostFees = {
+            hostDepositFeeBps: params.host_platform_params?.host_deposit_fee_bps ?? 0,
+            hostWithdrawalFeeBps: params.host_platform_params?.host_withdraw_fee_bps ?? 0,
+            hostManagementFeeBps: params.host_platform_params?.host_management_fee_bps ?? 0,
+            hostPerformanceFeeBps: params.host_platform_params?.host_performance_fee_bps ?? 0,
+        };
+        const metadataParams = {
+            name: params.name,
+            symbol: params.symbol,
+            uri: params.metadata_uri,
+        };
+        const startPrice = decimalToFraction(new Decimal(parseFloat(params.start_price) / 10 ** 6));
+        let globalConfig = await this.fetchGlobalConfig();
+        let bountyWsolAmount = 0;
+        if (globalConfig.bountyMint.equals(MINTS["mainnet"].WSOL)) {
+            let boundBounty = parseInt(globalConfig.bountyBondAmount.toString());
+            let minBasketAutomationBounty = parseInt(globalConfig.minBountyForBasketAutomation.toString());
+            bountyWsolAmount = boundBounty + minBasketAutomationBounty;
+        }
+        let wsolIxs = await wrapWsolIxs(
+            this.sdkParams.connection,
+            creator,
+            bountyWsolAmount,
+        );
+        let basketId = parseInt(globalConfig.totalNumberOfBaskets.toString());
+        let mint = getBasketTokenMintPda(basketId);
+        let basket = getBasketState(mint);
+        const slot = await this.sdkParams.connection.getSlot();
+
+        let ix = createBasketIx({
+            basket,
+            mint,
+            slot,
+            creator,
+            host,
+            startPrice: startPrice,
+            hostFees,
+            metadataParams,
+            network: this.sdkParams.network,
+        });
+
+        let preIx = createBasketStateAccountIx({
+            creator,
+            basket
+        });
+
+        let preIx2 = resizeBasketStateIx({
+            basket
+        });
+
+        let createBasketFeesAccountIx = createAssociatedTokenAccountInstruction(
+            creator,
+            getAta(getBasketFeesPda(basket), mint),
+            getBasketFeesPda(basket),
+            mint,
+        );
+
+        let txBatchData: TxBatchData = {batches: [[{
+            payer: creator,
+            instructions: [
+                ...wsolIxs,
+                preIx, preIx2, preIx2, ix, createBasketFeesAccountIx,
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+            ],
+            lookupTables: [],
+        }]]};
+
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+    */
+    async editCreatorTx(context: TaskContext, settings: EditCreatorSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async editManagersTx(context: TaskContext, settings: EditManagerSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async editScheduleTx(context: TaskContext, settings: EditScheduleSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async editFeesTx(context: TaskContext, settings: EditFeeSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async editAutomationTx(context: TaskContext, settings: EditAutomationSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async editLpTx(context: TaskContext, settings: EditLpSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async editMetadataTx(context: TaskContext, settings: EditMetadataSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async editDepositsTx(context: TaskContext, settings: EditDepositsSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async editForceRebalanceTx(context: TaskContext, settings: EditForceRebalanceSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async editCustomRebalanceTx(context: TaskContext, settings: EditCustomRebalanceSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async editAddTokenDelayTx(context: TaskContext, settings: EditAddTokenSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async editUpdateWeightsDelayTx(context: TaskContext, settings: EditUpdateWeightsSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async editSwapDelayTx(context: TaskContext, settings: EditMakeDirectSwapSettings): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async addOrEditTokenTx(context: TaskContext, settings: AddOrEditTokenInput): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async updateWeightsTx(context: TaskContext, settings: UpdateWeightsInput): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async makeDirectSwapTx(context: TaskContext, settings: MakeDirectSwapInput, jup_swap_ix?: TransactionInstruction): Promise<TxPayloadBatchSequence> {
+        return this.openBasketIntentTx({ type: 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.
+    */
+    async openBasketIntentTx(params: {
+        context: TaskContext,
+        type: TaskType,
+        settings: Settings,
+        jup_swap_ix?: TransactionInstruction,
+    }): Promise<TxPayloadBatchSequence> {
+        let basket = await this.fetchBasket(params.context.basket);
+        let manager = new PublicKey(params.context.manager);
+        let activationTimestamp = new BN(params.context.activation_timestamp ?? 0);
+        let expirationTimestamp = new BN(params.context.expiration_timestamp ?? 0);
+        let editType = params.type;
+        let editData = params.settings;
+        let modificationDelay = (() => {
+            switch(editType) {
+                case TaskType.EditCreator: return new BN(0);
+                case TaskType.EditManagerSettings: return basket.settings.managers.modificationDelay;
+                case TaskType.EditFeeSettings: return basket.settings.fees.modificationDelay;
+                case TaskType.EditScheduleSettings: return basket.settings.schedule.modificationDelay;
+                case TaskType.EditAutomationSettings: return basket.settings.automation.modificationDelay;
+                case TaskType.EditLpSettings: return  basket.settings.lp.modificationDelay;
+                case TaskType.EditMetadataSettings: return basket.settings.metadata.modificationDelay;
+                case TaskType.EditDepositsSettings: return new BN(0);
+                case TaskType.EditForceRebalanceSettings: return basket.settings.forceRebalanceModificationDelay;
+                case TaskType.EditCustomRebalanceSettings: return basket.settings.customRebalanceModificationDelay;
+                case TaskType.EditAddTokenDelay: return basket.settings.addTokenDelay;
+                case TaskType.EditUpdateWeightsDelay: return basket.settings.updateWeightsDelay;
+                case TaskType.EditMakeDirectSwapDelay: return basket.settings.makeDirectSwapDelay;
+                case TaskType.AddToken: return basket.settings.addTokenDelay;
+                case TaskType.UpdateWeights: return basket.settings.updateWeightsDelay;
+                case TaskType.MakeDirectSwap: return basket.settings.makeDirectSwapDelay;
+                default: return new BN(0);
+            }
+        })();
+
+        let globalConfig = await this.fetchGlobalConfig();
+        let minBounty = params.context.min_bounty !== undefined
+            ? new BN(params.context.min_bounty)
+            : globalConfig.bountyPerTask.minBounty;
+        let maxBounty = params.context.max_bounty !== undefined
+            ? new BN(params.context.max_bounty)
+            : globalConfig.bountyPerTask.maxBounty;
+        if (parseInt(minBounty.toString()) > parseInt(maxBounty.toString()))
+            minBounty = maxBounty.div(new BN(2));
+        let bountyWsolAmount = 0;
+        if (globalConfig.bountyMint.equals(MINTS["mainnet"].WSOL)) {
+            let boundBounty = parseInt(globalConfig.bountyBondAmount.toString());
+            let maxBountyPerTask = parseInt(maxBounty.toString());
+            bountyWsolAmount = maxBountyPerTask + boundBounty;
+        }
+        let wsolIxs = await wrapWsolIxs(
+            this.sdkParams.connection,
+            manager,
+            bountyWsolAmount,
+        );
+
+        let intentSeedArray = Keypair.generate().publicKey.toBytes();
+        let tokenProgram: PublicKey | undefined = undefined;
+        if (editType === TaskType.AddToken) {
+            let tokenMint = new PublicKey((editData as AddOrEditTokenInput).token_mint);
+            intentSeedArray = tokenMint.toBytes();
+            let tokenInfo = await this.sdkParams.connection.getAccountInfo(tokenMint);
+            if (tokenInfo!.owner.equals(TOKEN_PROGRAM_ID) || tokenInfo!.owner.equals(TOKEN_2022_PROGRAM_ID)) {
+                tokenProgram = tokenInfo!.owner;
+            }
+        }
+
+        let intent = getIntentPda(basket.ownAddress, intentSeedArray, editType); 
+        
+        let openBasketIntentIx = 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: TxBatchData = {batches: [[{
+            payer: manager,
+            instructions: [
+                ...wsolIxs,
+                openBasketIntentIx,
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                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(0)) && activationTimestamp.eq(new BN(0))) {
+            let executeBasketIntentIx = executeEditBasketIntentIx({
+                basket: basket.ownAddress,
+                intent: intent,
+                editType: editType,
+                manager: manager,
+                bountyMint: basket.settings.bountyMint,
+                keeper: manager,
+                basketMint: basket.mint,
+            });
+            if (editType == TaskType.MakeDirectSwap && params.jup_swap_ix) {
+                let flashParams = {
+                    keeper: manager,
+                    basket: basket.ownAddress,
+                    rebalanceIntent: undefined,
+                    intent: intent,
+                    mintIn: new PublicKey((editData as MakeDirectSwapInput).from_token_mint),
+                    mintOut: new PublicKey((editData as MakeDirectSwapInput).to_token_mint),
+                    amountIn: new BN((editData as MakeDirectSwapInput).amount_from),
+                    amountOut: new BN((editData as MakeDirectSwapInput).amount_to),
+                    mode: undefined,
+                }
+                let ixWithdraw = flashWithdrawIx(flashParams);
+                let ixDeposit = flashDepositIx(flashParams);
+                txBatchData.batches.push([{
+                    payer: manager,
+                    instructions: [
+                        createAssociatedTokenAccountIdempotentInstruction(manager, getAta(manager, flashParams.mintIn), manager, flashParams.mintIn),
+                        createAssociatedTokenAccountIdempotentInstruction(manager, getAta(manager, flashParams.mintOut), manager, flashParams.mintOut),
+                        ixWithdraw,
+                        params.jup_swap_ix,
+                        ixDeposit,
+                        ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                        ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                    ],
+                    lookupTables: [],
+                }]);
+                txBatchData.batches.push([{
+                    payer: manager,
+                    instructions: [
+                        executeBasketIntentIx,
+                        ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                        ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                    ],
+                    lookupTables: [],
+                }]);
+            } else {
+                txBatchData.batches[0][0].instructions = [
+                    ...wsolIxs,
+                    openBasketIntentIx,
+                    executeBasketIntentIx,
+                    ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                    ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                ];
+            }
+        }
+
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+    */
+    async executeBasketIntentTx(params: {
+        keeper: string,
+        intent: string,
+    }): Promise<TxPayloadBatchSequence> {
+        let keeper = new PublicKey(params.keeper);
+        let intent = await this.fetchIntent(params.intent);
+        let basketMint: PublicKey | undefined;
+        if (intent.taskType === TaskType.EditMetadataSettings) {
+            let basket = await this.fetchBasket(intent.basket.toBase58());
+            basketMint = basket.mint;
+        }
+        let ix = executeEditBasketIntentIx({
+            basket: intent.basket,
+            intent: intent.ownAddress!,
+            editType: intent.taskType,
+            manager: intent.manager,
+            bountyMint: intent.bounty.bountyMint,
+            keeper: keeper,
+            basketMint: intent.taskType === TaskType.EditMetadataSettings ? basketMint : undefined,
+        });
+
+        let txBatchData: TxBatchData = {batches: [[{
+            payer: keeper,
+            instructions: [
+                ix,
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+            ],
+            lookupTables: [],
+        }]]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+    */
+    async cancelBasketIntentTx(params: {
+        keeper: string,
+        intent: string,
+    }): Promise<TxPayloadBatchSequence> {
+        let keeper = new PublicKey(params.keeper);
+        let intent = await this.fetchIntent(params.intent);
+        let ix = cancelIntentIx({
+            keeper: keeper,
+            basket: intent.basket,
+            intent: intent.ownAddress!,
+            editType: intent.taskType,
+            manager: intent.manager,
+            bountyMint: intent.bounty.bountyMint,
+        });
+
+        let txBatchData: TxBatchData = {batches: [[{
+            payer: keeper,
+            instructions: [
+                ix,
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+            ],
+            lookupTables: [],
+        }]]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+    */
+    async cancelRebalanceIntentTx(params: {
+        keeper: string,
+        rebalance_intent: string,
+    }): Promise<TxPayloadBatchSequence> {
+        let keeper = new PublicKey(params.keeper);
+        let intent: RebalanceIntent = (await this.fetchRebalanceIntent(params.rebalance_intent)).chain_data;
+        let ix = cancelRebalanceIx({
+            keeper: keeper,
+            basket: intent.basket,
+            rebalanceIntent: intent.ownAddress!,
+        });
+        let txBatchData: TxBatchData = {batches: [[{
+            payer: keeper,
+            instructions: [
+                ix,
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+            ],
+            lookupTables: [],
+        }]]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+    */
+    async buyBasketTx(params: {
+        buyer: string,
+        basket_mint: string,
+        contributions: {mint: string, amount: number}[],
+        rebalance_slippage_bps?: number,
+        per_trade_rebalance_slippage_bps?: number,
+        execution_start_time?: number,
+        min_bounty_amount?: number,
+        max_bounty_amount?: number,
+    }): Promise<TxPayloadBatchSequence> {
+        let buyer = new PublicKey(params.buyer);
+        let contributions = params.contributions.map(contribution => ({
+            mint: new PublicKey(contribution.mint),
+            amount: contribution.amount,
+        }));
+        let rebalanceSlippageBps = params.rebalance_slippage_bps ?? 100;
+        let perTradeRebalanceSlippageBps = params.per_trade_rebalance_slippage_bps ?? 100;
+        let executionStartTime = params.execution_start_time ?? 0;
+        let minBountyAmount = params.min_bounty_amount ?? 0;
+        let maxBountyAmount = params.max_bounty_amount ?? 0;
+
+        const basket = await this.fetchBasket(getBasketState(new PublicKey(params.basket_mint)).toBase58());
+        let globalConfig = await this.fetchGlobalConfig();
+        
+        let bountyWsolAmount = 0;
+        if (globalConfig.bountyMint.equals(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 = computeRebalanceIntentBountyAmount(
+                RebalanceType.Deposit,
+                basket.numTokens,
+                boundBounty,
+                maxBountyPerTask,
+                Math.floor(maxBountyPerTask / bountyPerPriceUpdateTaskDivisor),
+            );
+        }
+        let wsolContributionAmount = params.contributions.find(contribution => contribution.mint === MINTS["mainnet"].WSOL.toBase58())?.amount ?? 0;
+        
+        let wsolIxs = await wrapWsolIxs(
+            this.sdkParams.connection,
+            buyer,
+            bountyWsolAmount + wsolContributionAmount,
+        );
+
+        const rebalanceIntent = getRebalanceIntentPda(basket.ownAddress, buyer);
+
+        let rentPayer = getRentPayerPda();
+
+        let rentPayerAi = await this.sdkParams.connection.getAccountInfo(rentPayer);
+
+        let rebalanceIntentRentPayer = buyer;
+        // TODO: check actual lamports required for rent
+        if (rentPayerAi?.lamports ?? 0 > 500_000_000)
+            rebalanceIntentRentPayer = rentPayer;
+        let bountyMint = basket.settings.bountyMint;
+
+        // let lockDepositsIxs: TransactionInstruction[] = [
+        //     lockDepositsIx({
+        //         owner: buyer,
+        //         basket: basket.ownAddress,
+        //     })
+        // ];
+
+        let txBatchData: TxBatchData = {batches: [
+            [{
+                payer: buyer,
+                instructions: [
+                    ...wsolIxs,
+                    createRebalanceIntentIx({
+                        signer: buyer,
+                        owner: buyer,
+                        basket: basket.ownAddress,
+                    }),
+                    resizeRebalanceIntentIx(rebalanceIntent),
+                    initRebalanceIntentIx({
+                        signer: buyer,
+                        owner: buyer,
+                        basket: basket.ownAddress,
+                        basketTokenMint: basket.mint,
+                        rebalanceIntentRentPayer: rebalanceIntentRentPayer,
+                        bountyMint: bountyMint,
+                        rebalanceType: RebalanceType.Deposit,
+                        basketRebalanceIntent: undefined,
+                        rebalanceSlippageBps: rebalanceSlippageBps,
+                        perTradeRebalanceSlippageBps: perTradeRebalanceSlippageBps,
+                        executionStartTime: executionStartTime,
+                        minBountyAmount: minBountyAmount,
+                        maxBountyAmount: maxBountyAmount,
+                    }),
+                    ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                    ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                ],
+                lookupTables: [],
+            }],
+            depositTokensIx({
+                owner: buyer,
+                basket: basket.ownAddress,
+                contributions: contributions,
+            }).map(ix => {
+                return {
+                    payer: buyer,
+                    instructions: [
+                        ix,
+                        ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                        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 = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+    */
+    async depositTokensTx(params: {
+        buyer: string,
+        contributions: {mint: string, amount: number}[],
+        rebalance_intent?: string,
+        rebalance_intent_chain_data?: RebalanceIntent,
+    }): Promise<TxPayloadBatchSequence> {
+        let buyer = new PublicKey(params.buyer);
+        if (params.contributions.length === 0) {
+            throw new Error("Contributions cannot be empty");
+        }
+
+        let contributions = params.contributions.map(contribution => ({
+            mint: new PublicKey(contribution.mint),
+            amount: contribution.amount,
+        }));
+
+        let rebalanceIntentState: RebalanceIntent;
+        if (params.rebalance_intent_chain_data) {
+            rebalanceIntentState = params.rebalance_intent_chain_data;
+        } else if (params.rebalance_intent) {
+            rebalanceIntentState = (await 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 === MINTS["mainnet"].WSOL.toBase58())
+            .reduce((acc, contribution) => acc + contribution.amount, 0);
+
+        let wsolIxs = await wrapWsolIxs(
+            this.sdkParams.connection,
+            buyer,
+            wsolContributionAmount,
+        );
+
+        let txBatchData: TxBatchData = { batches: [] };
+
+        if (wsolIxs.length > 0) {
+            txBatchData.batches.push([{
+                payer: buyer,
+                instructions: [
+                    ...wsolIxs,
+                    ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                    ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                ],
+                lookupTables: [],
+            }]);
+        }
+
+        txBatchData.batches.push(
+            depositTokensIx({
+                owner: buyer,
+                basket: rebalanceIntentState.basket,
+                contributions: contributions,
+            }).map(ix => ({
+                payer: buyer,
+                instructions: [
+                    ix,
+                    ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                    ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                ],
+                lookupTables: [],
+            }))
+        );
+
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+    */
+    async lockDepositsTx(params: {
+        buyer: string,
+        basket_mint: string,
+    }): Promise<TxPayloadBatchSequence> {
+        let buyer = new PublicKey(params.buyer);
+        let basket = await this.fetchBasket(getBasketState(new PublicKey(params.basket_mint)).toBase58());
+        let txBatchData: TxBatchData = {batches: [[{
+            payer: buyer,
+            instructions: [
+                lockDepositsIx({
+                    owner: buyer,
+                    basket: basket.ownAddress,
+                }),
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+            ],
+            lookupTables: [],
+        }]]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+    */
+    async sellBasketTx(params: {
+        seller: string,
+        basket_mint: string,
+        withdraw_amount: number,
+        keep_tokens: string[],
+        rebalance_slippage_bps?: number,
+        per_trade_rebalance_slippage_bps?: number,
+        execution_start_time?: number,
+        min_bounty_amount?: number,
+        max_bounty_amount?: number,
+    }): Promise<TxPayloadBatchSequence> {
+        let seller = new PublicKey(params.seller);
+        let basketMint = new PublicKey(params.basket_mint);
+        let withdrawAmount = params.withdraw_amount;
+        let keepTokens = params.keep_tokens;
+        let rebalanceSlippageBps = params.rebalance_slippage_bps ?? 100;
+        let perTradeRebalanceSlippageBps = params.per_trade_rebalance_slippage_bps ?? 100;
+        let executionStartTime = params.execution_start_time ?? 0;
+        let minBountyAmount = params.min_bounty_amount ?? 0;
+        let maxBountyAmount = params.max_bounty_amount ?? 0;
+
+        const basket = await this.fetchBasket(getBasketState(basketMint).toBase58());
+        let globalConfig = await this.fetchGlobalConfig();
+
+        let bountyWsolAmount = 0;
+        if (globalConfig.bountyMint.equals(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 = computeRebalanceIntentBountyAmount(
+                RebalanceType.Deposit,
+                basket.numTokens,
+                boundBounty,
+                maxBountyPerTask,
+                Math.floor(maxBountyPerTask / bountyPerPriceUpdateTaskDivisor),
+            );
+        }
+        
+        let wsolIxs = await wrapWsolIxs(
+            this.sdkParams.connection,
+            seller,
+            bountyWsolAmount,
+        );
+
+        const rebalanceIntent = getRebalanceIntentPda(basket.ownAddress, seller);
+
+        let rentPayer = getRentPayerPda();
+
+        let rentPayerAi = await this.sdkParams.connection.getAccountInfo(rentPayer);
+
+        let rebalanceIntentRentPayer = seller;
+        // TODO: check actual lamports required for rent
+        if (rentPayerAi?.lamports ?? 0 > 500_000_000)
+            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 = computeTokenMintsHash(
+            basket.composition.slice(0, basket.numTokens)
+                .map(asset => asset.mint.toBase58())
+        );
+
+        let keepTokensBitmask = new BN(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(1).shln(tokenIndex));
+            }
+        }
+
+        const basketRebalanceIntent = basket.settings.activeRebalance.gt(new BN(0))
+            ? getRebalanceIntentPda(basket.ownAddress, basket.ownAddress)
+            : undefined;
+
+        let txBatchData: TxBatchData = {batches: [
+            [{
+                payer: seller,
+                instructions: [
+                    ...wsolIxs,
+                    createRebalanceIntentIx({
+                        signer: seller,
+                        owner: seller,
+                        basket: basket.ownAddress,
+                    }),
+                    resizeRebalanceIntentIx(rebalanceIntent),
+                    initRebalanceIntentIx({
+                        signer: seller,
+                        owner: seller,
+                        basket: basket.ownAddress,
+                        basketTokenMint: basketMint,
+                        rebalanceIntentRentPayer: rebalanceIntentRentPayer,
+                        bountyMint: bountyMint,
+                        rebalanceType: RebalanceType.Withdraw,
+                        basketRebalanceIntent: basketRebalanceIntent,
+                        rebalanceSlippageBps: rebalanceSlippageBps,
+                        perTradeRebalanceSlippageBps: perTradeRebalanceSlippageBps,
+                        executionStartTime: executionStartTime,
+                        minBountyAmount: minBountyAmount,
+                        maxBountyAmount: maxBountyAmount,
+                        withdrawParamsBurnAmount: withdrawAmount,
+                        withdrawParamsTokenMintsHash: tokenMintsHash,
+                        withdrawParamsKeepTokensBitmask: keepTokensBitmask,
+                        withdrawParamsKeepAllTokens: keepAllTokensFlag,
+                    }),
+                    ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                    ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                ],
+                lookupTables: [],
+            }],
+        ]};
+
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+    */
+    async rebalanceBasketTx(params: {
+        keeper: string,
+        basket_mint: string,
+        rebalance_slippage_bps?: number,
+        per_trade_rebalance_slippage_bps?: number,
+        execution_start_time?: number,
+        min_bounty_amount?: number,
+        max_bounty_amount?: number,
+    }): Promise<TxPayloadBatchSequence> {
+        let keeper = new PublicKey(params.keeper);
+        let rebalanceSlippageBps = params.rebalance_slippage_bps ?? 100;
+        let perTradeRebalanceSlippageBps = params.per_trade_rebalance_slippage_bps ?? 100;
+        let executionStartTime = params.execution_start_time ?? 0;
+        let minBountyAmount = params.min_bounty_amount ?? 0;
+        let maxBountyAmount = params.max_bounty_amount ?? 0;
+
+        const basket = await this.fetchBasket(getBasketState(new PublicKey(params.basket_mint)).toBase58());
+        let globalConfig = await this.fetchGlobalConfig();
+        
+        let bountyWsolAmount = 0;
+        if (globalConfig.bountyMint.equals(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 = computeRebalanceIntentBountyAmount(
+                RebalanceType.Basket,
+                basket.numTokens,
+                boundBounty,
+                maxBountyPerTask,
+                Math.floor(maxBountyPerTask / bountyPerPriceUpdateTaskDivisor),
+            );
+        }
+        
+        let wsolIxs = await wrapWsolIxs(
+            this.sdkParams.connection,
+            keeper,
+            bountyWsolAmount,
+        );
+
+        const rebalanceIntent = getRebalanceIntentPda(basket.ownAddress, basket.ownAddress);
+
+        let rentPayer = getRentPayerPda();
+
+        let rentPayerAi = await this.sdkParams.connection.getAccountInfo(rentPayer);
+
+        let rebalanceIntentRentPayer = keeper;
+        // TODO: check actual lamports required for rent
+        if (rentPayerAi?.lamports ?? 0 > 500_000_000)
+            rebalanceIntentRentPayer = rentPayer;
+        let bountyMint = basket.settings.bountyMint;
+
+        let txBatchData: TxBatchData = {batches: [[{
+            payer: keeper,
+            instructions: [
+                ...wsolIxs,
+                createRebalanceIntentIx({
+                    signer: keeper,
+                    owner: basket.ownAddress,
+                    basket: basket.ownAddress,
+                }),
+                resizeRebalanceIntentIx(rebalanceIntent),
+                initRebalanceIntentIx({
+                    signer: keeper,
+                    owner: basket.ownAddress,
+                    basket: basket.ownAddress,
+                    basketTokenMint: basket.mint,
+                    rebalanceIntentRentPayer: rebalanceIntentRentPayer,
+                    bountyMint: bountyMint,
+                    rebalanceType: RebalanceType.Basket,
+                    basketRebalanceIntent: undefined,
+                    rebalanceSlippageBps: rebalanceSlippageBps,
+                    perTradeRebalanceSlippageBps: perTradeRebalanceSlippageBps,
+                    executionStartTime: executionStartTime,
+                    minBountyAmount: minBountyAmount,
+                    maxBountyAmount: maxBountyAmount,
+                }),
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+            ],
+            lookupTables: [],
+        }]]};
+
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+     */
+    async updateTokenPricesTx(params: {
+        keeper: string,
+        basket: string,
+        rebalance_intent: string,
+    }): Promise<TxPayloadBatchSequence> {
+        let keeper = new PublicKey(params.keeper);
+        let rebalanceIntent = new PublicKey(params.rebalance_intent);
+        let basketRebalanceIntent = getRebalanceIntentPda(new PublicKey(params.basket), new PublicKey(params.basket));
+        let basket = await this.fetchBasket(params.basket);
+        let pythPriceFeeds: PublicKey[] = [];
+        let updateTokenPricesIxs: TransactionInstruction[] = [];
+        for (let startIndex = 0; startIndex < basket.numTokens; startIndex++) {
+            let allKeys: PublicKey[] = [];
+            let tokenIndices: number[] = [];
+            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 > 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 === 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(
+                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(0)) ? undefined : basketRebalanceIntent,
+                    basketMint: performanceFees > 0 ? basket.mint : undefined,
+                }),
+            );
+        }
+        const {feedIds }= await fetchFeedIdsFromAccounts(this.sdkParams.connection, pythPriceFeeds);
+        const {
+            vaaCreateInitEncodeIxs,
+            vaaWriteVerifyIxs,
+            updateFeedIxs,
+            closeVaaIxs,
+        } = await buildPythPriceFeedUpdateIxs(
+            keeper,
+            feedIds,
+        );
+        let txBatchData: TxBatchData = {batches: [
+            [
+                ...vaaCreateInitEncodeIxs.map(ixs => ({
+                    payer: keeper,
+                    instructions: [
+                        ...ixs.ixs,
+                        ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                        ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                    ],
+                    lookupTables: [],
+                })),
+            ],
+            [
+                ...vaaWriteVerifyIxs.map(ixs => ({
+                    payer: keeper,
+                    instructions: [
+                        ...ixs,
+                        ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                        ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                    ],
+                    lookupTables: [],
+                })),
+            ],
+            [
+                ...updateFeedIxs.map(ix => ({
+                    payer: keeper,
+                    instructions: [
+                        ix,
+                        ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                        ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                    ],
+                    lookupTables: [],
+                })),
+            ],
+            [
+                ...updateTokenPricesIxs.map(ix => ({
+                    payer: keeper,
+                    instructions: [
+                        ix,
+                        ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                        ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                    ],
+                    lookupTables: [basket.lookupTables.active[0], basket.lookupTables.active[1]],
+                })),
+                {
+                    payer: keeper,
+                    instructions: [
+                        ...closeVaaIxs,
+                        ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                        ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                    ],
+                    lookupTables: [],
+                }
+            ],
+        ]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        for (let [txId, vaaCreateInitEncodeIx] of vaaCreateInitEncodeIxs.entries()) {
+            versionedTxs.batches[0][txId].sign([vaaCreateInitEncodeIx.signer]);
+        }
+        let txPayloadBatchSequence = 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, ...]
+     * 
+     */
+    async updatePythPriceFeedsTx(params: {
+        keeper: string,
+        accounts: string[],
+    }): Promise<TxPayloadBatchSequence> {
+        const payer = new PublicKey(params.keeper);
+        const priceAccounts = params.accounts.map(a => new PublicKey(a));
+        const { feedIds } = await fetchFeedIdsFromAccounts(this.sdkParams.connection, priceAccounts);
+        const {
+            vaaCreateInitEncodeIxs,
+            vaaWriteVerifyIxs,
+            updateFeedIxs,
+            closeVaaIxs,
+        } = await buildPythPriceFeedUpdateIxs(
+            payer,
+            feedIds,
+        );
+        let txBatchData: TxBatchData = {batches: [
+            [
+                ...vaaCreateInitEncodeIxs.map(ixs => ({
+                    payer: payer,
+                    instructions: [
+                        ...ixs.ixs,
+                        ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                        ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                    ],
+                    lookupTables: [],
+                })),
+            ],
+            [
+                ...vaaWriteVerifyIxs.map(ixs => ({
+                    payer: payer,
+                    instructions: [
+                        ...ixs,
+                        ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                        ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                    ],
+                    lookupTables: [],
+                })),
+            ],
+            [
+                ...updateFeedIxs.map(ix => ({
+                    payer: payer,
+                    instructions: [
+                        ix,
+                        ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                        ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                    ],
+                    lookupTables: [],
+                })),
+            ],
+            [
+                {
+                    payer: payer,
+                    instructions: [
+                        ...closeVaaIxs,
+                        ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                        ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                    ],
+                    lookupTables: [],
+                }
+            ],
+        ]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        for (let [txId, vaaCreateInitEncodeIx] of vaaCreateInitEncodeIxs.entries()) {
+            versionedTxs.batches[0][txId].sign([vaaCreateInitEncodeIx.signer]);
+        }
+        let txPayloadBatchSequence = 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.
+     */
+    async flashSwapTx(params: {
+        keeper: string,
+        basket: string,
+        rebalance_intent?: string,
+        intent?: string,
+        mint_in: string,
+        mint_out: string,
+        amount_in: number,
+        amount_out: number,
+        mode?: number,
+        jup_token_ledger_ix?: TransactionInstruction,
+        jup_swap_ix?: TransactionInstruction,
+        jup_address_lookup_table_addresses?: PublicKey[],
+    }): Promise<TxPayloadBatchSequence> {
+        let keeper = new PublicKey(params.keeper);
+        let basket = new PublicKey(params.basket);
+        let rebalanceIntent = params.rebalance_intent ? new PublicKey(params.rebalance_intent) : undefined;
+        let intent = params.intent ? new PublicKey(params.intent) : undefined;
+        let mintIn = new PublicKey(params.mint_in);
+        let mintOut = new PublicKey(params.mint_out);
+        let amountIn = new BN(params.amount_in);
+        let amountOut = new BN(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 = flashWithdrawIx(flashParams);
+        let ixDeposit = flashDepositIx(flashParams);
+        let ixs: TransactionInstruction[] = [];
+        ixs = ixs.concat([
+            createAssociatedTokenAccountIdempotentInstruction(keeper, getAta(keeper, mintIn), keeper, mintIn),
+            createAssociatedTokenAccountIdempotentInstruction(keeper, 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([
+            ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+            ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+        ]);
+        let txBatchData: TxBatchData = {batches: [[{
+            payer: keeper,
+            instructions: ixs,
+            lookupTables: params.jup_address_lookup_table_addresses ?? [],
+        }]]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+     */
+    async mintTx(params: {
+        keeper: string,
+        rebalance_intent: string,
+    }): Promise<TxPayloadBatchSequence> {
+        let keeper = new PublicKey(params.keeper);
+        let rebalanceIntent: RebalanceIntent = (await this.fetchRebalanceIntent(params.rebalance_intent)).chain_data;
+        let basket = await this.fetchBasket(rebalanceIntent.basket.toBase58());
+        let basketRebalanceIntent = getRebalanceIntentPda(basket.ownAddress, rebalanceIntent.owner);
+        let ix = mintBasketIx({
+            keeper: keeper,
+            basket: basket.ownAddress,
+            basketTokenMint: basket.mint,
+            buyer: rebalanceIntent.owner,
+            basketRebalanceIntent: basket.settings.activeRebalance.eq(new BN(0)) ? undefined : basketRebalanceIntent,
+        });
+        let txBatchData: TxBatchData = {batches: [[{
+            payer: keeper,
+            instructions: [
+                ix,
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+            ],
+            lookupTables: [],
+        }]]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+     */
+    async redeemTokensTx(params: {
+        keeper: string,
+        rebalance_intent: string,
+    }): Promise<TxPayloadBatchSequence> {
+        let keeper = new PublicKey(params.keeper);
+        let rebalanceIntent: RebalanceIntent = (await this.fetchRebalanceIntent(params.rebalance_intent)).chain_data;
+        let batchSize = 7;
+        let ixs: TransactionInstruction[] = [];
+        for (let batchStart = 0; batchStart < rebalanceIntent.tokens.length; batchStart += batchSize) {
+            let tokenMints: PublicKey[] = [];
+            for (let i = batchStart; i < rebalanceIntent.tokens.length && i < batchStart + batchSize; i++)
+                if (rebalanceIntent.tokens[i].amount.gt(new BN(0)))
+                    tokenMints.push(rebalanceIntent.tokens[i].mint);
+            if (tokenMints.length > 0) {
+                ixs.push(
+                    redeemTokensIx({
+                        keeper: keeper,
+                        basket: rebalanceIntent.basket,
+                        owner: rebalanceIntent.owner,
+                        tokenMints: tokenMints,
+                    })
+                );
+            }
+        }
+        let txBatchData: TxBatchData = {batches: [ixs.map(ix => ({
+            payer: keeper,
+            instructions: [
+                ix,
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+            ],
+            lookupTables: [],
+        }))]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+     */
+    async claimBountyTx(params: {
+        keeper: string,
+        rebalance_intent: string,
+    }): Promise<TxPayloadBatchSequence> {
+        let keeper = new PublicKey(params.keeper);
+        let rebalanceIntent: RebalanceIntent = (await this.fetchRebalanceIntent(params.rebalance_intent)).chain_data;
+        let keepersArray: string[] = [];
+        if (!rebalanceIntent.auctionCreationTask .completedBy.equals(PublicKey.default))
+            keepersArray.push(rebalanceIntent.auctionCreationTask.completedBy.toBase58());
+        if (!rebalanceIntent.cancelRebalanceTask.completedBy.equals(PublicKey.default))
+            keepersArray.push(rebalanceIntent.cancelRebalanceTask.completedBy.toBase58());
+        if (!rebalanceIntent.placeholderTask.completedBy.equals(PublicKey.default))
+            keepersArray.push(rebalanceIntent.placeholderTask.completedBy.toBase58());
+        if (!rebalanceIntent.finishPriceUpdateTask.completedBy.equals(PublicKey.default))
+            keepersArray.push(rebalanceIntent.finishPriceUpdateTask.completedBy.toBase58());
+        if (!rebalanceIntent.mintBasketTask.completedBy.equals(PublicKey.default))
+            keepersArray.push(rebalanceIntent.mintBasketTask.completedBy.toBase58());
+        for (let i = 0; i < rebalanceIntent.priceUpdateTasks.length; i++)
+            if (!rebalanceIntent.priceUpdateTasks[i].completedBy.equals(PublicKey.default))
+                keepersArray.push(rebalanceIntent.priceUpdateTasks[i].completedBy.toBase58());
+        for (let i = 0; i < rebalanceIntent.tokenSettlementTasks.length; i++)
+            if (!rebalanceIntent.tokenSettlementTasks[i].completedBy.equals(PublicKey.default))
+                keepersArray.push(rebalanceIntent.tokenSettlementTasks[i].completedBy.toBase58());
+        keepersArray = Array.from(new Set(keepersArray));
+        let batchSize = 10;
+        let ixs: TransactionInstruction[] = [];
+        let wsolIxs = await wrapWsolIxs(this.sdkParams.connection, keeper, 0);
+        ixs.push(...wsolIxs);
+        for (let batchStart = 0; batchStart < keepersArray.length; batchStart += batchSize)
+            ixs.push(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 PublicKey(keeper)).slice(batchStart, batchStart + batchSize),
+            })
+        );
+        let txBatchData: TxBatchData = {batches: [ixs.map(ix => ({
+            payer: keeper,
+            instructions: [
+                ix,
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+            ],
+            lookupTables: [],
+        }))]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+     */
+    async addBountyTx(params: {
+        keeper: string,
+        basket: string,
+        amount: number,
+    }): Promise<TxPayloadBatchSequence> {
+        let keeper = new PublicKey(params.keeper);
+        let basket = await this.fetchBasket(params.basket);
+        let globalConfig = await this.fetchGlobalConfig();
+        let bountyWsolAmount = 0;
+        if (globalConfig.bountyMint.equals(MINTS["mainnet"].WSOL)) {
+            bountyWsolAmount = params.amount;
+        }
+        let wsolIxs = await wrapWsolIxs(
+            this.sdkParams.connection,
+            keeper,
+            bountyWsolAmount,
+        );
+        let ix = addBountyIx({
+            keeper: keeper,
+            basket: basket.ownAddress,
+            bountyMint: basket.settings.bountyMint,
+            amount: params.amount,
+        });
+        let txBatchData: TxBatchData = {batches: [[{
+            payer: keeper,
+            instructions: [
+                ...wsolIxs,
+                ix,
+                ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+            ],
+            lookupTables: [],
+        }]]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+     */
+    async withdrawBasketFeesTx(params: {
+        claimer: string,
+        basket: string,
+    }): Promise<TxPayloadBatchSequence> {
+        let claimer = new PublicKey(params.claimer);
+        let basket = await this.fetchBasket(params.basket);
+        let globalConfig = await this.fetchGlobalConfig();
+        
+        let claimableFeeTypes: number[] = [];
+        let owners: PublicKey[][] = [];
+        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: TransactionInstruction[] = [];
+        let claimTokenFeesFromBasketIxs: TransactionInstruction[] = [];
+        claimableFeeTypes.forEach((feeType, index) => {
+            withdrawFeesIxs.push(
+                withdrawFeesIx({
+                    claimer,
+                    basketTokenMint: basket.mint,
+                    feeType: feeType,
+                })
+            );
+            claimTokenFeesFromBasketIxs.push(
+                ...claimFeeTokensFromBasketIxs(
+                    claimer,
+                    basket.ownAddress,
+                    getWithdrawBasketFeesPda(basket.ownAddress, feeType),
+                    claimer,
+                    owners[index],
+                    basket.composition.map(composition => composition.mint),
+                )
+            );
+       });
+        
+        let txBatchData: TxBatchData = {batches: [
+            withdrawFeesIxs.map(ix => ({
+                payer: claimer,
+                instructions: [
+                    ix,
+                    ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                    ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                ],
+                lookupTables: [],
+            })),
+            claimTokenFeesFromBasketIxs.map(ix => ({
+                payer: claimer,
+                instructions: [
+                    ix,
+                    ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                    ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                ],
+                lookupTables: [],
+            })),
+        ]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+     */
+    async claimTokenFeesFromBasketTx(params: {
+        claimer: string,
+        withdrawBasketFees: string,
+    }): Promise<TxPayloadBatchSequence> {
+        let claimer = new PublicKey(params.claimer);
+        let withdrawBasketFees = await this.fetchWithdrawBasketFees(params.withdrawBasketFees);
+        
+        let claimTokenFeesFromBasketIxs = claimFeeTokensFromBasketIxs(
+            claimer,
+            withdrawBasketFees.basket,
+            withdrawBasketFees.ownAddress!,
+            withdrawBasketFees.rentPayer,
+            withdrawBasketFees.owners,
+            withdrawBasketFees.accumulatedTokens,
+        );
+        
+        // Create batches: all claim instructions can run in parallel
+        let txBatchData: TxBatchData = {batches: [
+            claimTokenFeesFromBasketIxs.map(ix => ({
+                payer: claimer,
+                instructions: [
+                    ix,
+                    ComputeBudgetProgram.setComputeUnitLimit({units: COMPUTE_UNITS}),
+                    ComputeBudgetProgram.setComputeUnitPrice({microLamports: this.sdkParams.priorityFee}),
+                ],
+                lookupTables: [],
+            }))
+        ]};
+        let versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        let txPayloadBatchSequence = 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.
+     */
+    async rewriteLookupTablesTx(params: {
+        signer: string,
+        basket_mint: string,
+        additional_accounts: string[],
+    }): Promise<TxPayloadBatchSequence> {
+        const signer = new PublicKey(params.signer);
+        const basketMint = new PublicKey(params.basket_mint);
+        const additionalAccounts = params.additional_accounts.map(a => new PublicKey(a));
+
+        const basketAddress = getBasketState(basketMint);
+        const basket = await 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 = await this.sdkParams.connection.getSlot("finalized");
+        const newLut0 = getLookupTableAccount(basketAddress, slot);
+        const newLut1 = getLookupTableAccount(basketAddress, slot - 1);
+
+        // Step 1: create lookup tables
+        const createIx = createBasketLookupTablesInstruction({
+            signer,
+            basket: basketAddress,
+            oldTempLookupTable0: oldTempLut0,
+            oldTempLookupTable1: oldTempLut1,
+            newTempLookupTable0: newLut0,
+            newTempLookupTable1: newLut1,
+            slot,
+        });
+
+        const txBatchData: TxBatchData = { batches: [
+            [{
+                payer: signer,
+                instructions: [
+                    createIx,
+                    ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNITS }),
+                    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                ],
+                lookupTables: [],
+            }],
+        ]};
+
+        // Step 2: extend LUTs in batches of ~20
+        const BATCH_SIZE = LUT_EXTEND_BATCH_SIZE;
+        for (let i = 0; i < additionalAccounts.length; i += BATCH_SIZE) {
+            const batch = additionalAccounts.slice(i, i + BATCH_SIZE);
+            const extendIx = extendBasketLookupTablesIx({
+                signer,
+                basket: basketAddress,
+                tempLookupTable0: newLut0,
+                tempLookupTable1: newLut1,
+                additionalAccounts: batch,
+            });
+            txBatchData.batches.push([{
+                payer: signer,
+                instructions: [
+                    extendIx,
+                    ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNITS }),
+                    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                ],
+                lookupTables: [],
+            }]);
+        }
+
+        // Step 3: overwrite active LUTs
+        const overwriteIx = overwriteBasketLookupTablesIx({
+            signer,
+            basket: basketAddress,
+            tempLookupTable0: newLut0,
+            tempLookupTable1: newLut1,
+            activeLookupTable0: activeLut0,
+            activeLookupTable1: activeLut1,
+        });
+
+        txBatchData.batches.push([{
+            payer: signer,
+            instructions: [
+                overwriteIx,
+                ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNITS }),
+                ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+            ],
+            lookupTables: [],
+        }]);
+
+        const versionedTxs = await prepareVersionedTxs(this.sdkParams.connection, txBatchData);
+        const txPayloadBatchSequence = prepareTxPayloadBatchSequence(txBatchData, versionedTxs);
+        return txPayloadBatchSequence;
+    }
+
+
+    async signAndSendVersionedTxs(params: {
+        versionedTxs: VersionedTxs,
+        wallet: Wallet,
+    }): Promise<TransactionSignature[][]> {
+        let { versionedTxs, wallet } = params;
+        versionedTxs = await signVersionedTxs(wallet, versionedTxs);
+        return await sendVersionedTxs(this.sdkParams.connection, versionedTxs, false);
+    }
+
+    async signAndSendTxPayloadBatchSequence(params: {
+        txPayloadBatchSequence: TxPayloadBatchSequence,
+        wallet: Wallet,
+        simulateTransactions?: boolean,
+    }): Promise<TransactionSignature[][]> {
+        let { txPayloadBatchSequence, wallet, simulateTransactions = false } = params;
+        txPayloadBatchSequence = await signTxPayloadBatchSequence(wallet, txPayloadBatchSequence);
+        return await sendTxPayloadBatchSequence(this.sdkParams.connection, txPayloadBatchSequence, simulateTransactions);
+    }
+
+}
+
+export {
+    BasketCreationTx,
+    TxPayloadBatchSequence,
+    VersionedTxs,
+}
+
+export {
+    GlobalConfig,
+    Basket,
+    BasketFilter,
+    Intent,
+    IntentFilter,
+    RebalanceIntent,
+    RebalanceIntentFilter
+}
+
+export {
+    FormattedGlobalConfig,
+    FormattedIntentStatus,
+    FormattedTaskType,
+    FormattedBounty,
+    FormattedBountySchedule,
+    FormattedIntent,
+}
+
+export {
+    FormattedRebalanceType,
+    FormattedRebalanceAction,
+    FormattedOraclePrice,
+    FormattedTokenAuction,
+    FormattedTaskCompletion,
+    FormattedRebalanceIntent,
+    UIRebalanceIntent,
+    DepositData,
+    PriceUpdatesData,
+    AuctionData,
+    MintData,
+    RedeemData,
+    ClaimBountyData,
+}
+
+export {
+    FormattedCreatorSettings,
+    FormattedManagersSettings,
+    FormattedFeeSettings,
+    FormattedScheduleSettings,
+    FormattedAutomationSettings,
+    FormattedLpSettings,
+    FormattedMetadataSettings,
+    FormattedDepositsSettings,
+    FormattedForceRebalanceSettings,
+    FormattedCustomRebalanceSettings,
+    FormattedAddTokenSettings,
+    FormattedUpdateWeightsSettings,
+    FormattedMakeDirectSwapSettings,
+    FormattedAccumulatedFees,
+    FormattedLookupTables,
+    FormattedAsset,
+    FormattedOracleSettings,
+    FormattedOracleAggregator,
+    FormattedOracle,
+    FormattedOracleType,
+    FormattedBasket,
+}
+
+export {
+    EditCreatorSettings,
+    EditManagerSettings,
+    EditFeeSettings,
+    EditScheduleSettings,
+    EditAutomationSettings,
+    EditLpSettings,
+    EditMetadataSettings,
+    EditDepositsSettings,
+    EditForceRebalanceSettings,
+    EditCustomRebalanceSettings,
+    EditAddTokenSettings,
+    EditUpdateWeightsSettings,
+    EditMakeDirectSwapSettings,
+    AddOrEditTokenInput,
+    OracleInput,
+    UpdateWeightsInput,
+    MakeDirectSwapInput,
+    Settings,
+    TaskContext,
+    TaskType,
+}
+
+export {
+    getJupTokenLedgerAndSwapInstructions,
+}
+
+export {
+    KeeperMonitor,
+    RebalanceHandler,
+} from './keeperMonitor';