@symmetry-hq/temp-v3-sdk 0.0.36 → 0.0.37

package/dist/src/index.d.ts

@@ -119,6 +119,15 @@ export declare class SymmetryCore {
         min_bounty_amount?: number;
         max_bounty_amount?: number;
     }): Promise<TxPayloadBatchSequence>;
+    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>;
     startPriceUpdatesTx(params: {
         keeper: string;
         basket: string;
@@ -174,3 +183,4 @@ export { FormattedRebalanceType, FormattedRebalanceAction, FormattedOraclePrice,
 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 } from './keeperMonitor';

package/dist/src/index.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getJupTokenLedgerAndSwapInstructions = exports.TaskType = exports.SymmetryCore = void 0;
+exports.KeeperMonitor = exports.getJupTokenLedgerAndSwapInstructions = exports.TaskType = exports.SymmetryCore = void 0;
 const decimal_js_1 = __importDefault(require("decimal.js"));
 const anchor_1 = require("@coral-xyz/anchor");
 const spl_token_1 = require("@solana/spl-token");
@@ -767,6 +767,70 @@ class SymmetryCore {
             return txPayloadBatchSequence;
         });
     }
+    rebalanceBasketTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            let keeper = new web3_js_1.PublicKey(params.keeper);
+            let rebalanceSlippageBps = (_a = params.rebalance_slippage_bps) !== null && _a !== void 0 ? _a : 100;
+            let perTradeRebalanceSlippageBps = (_b = params.per_trade_rebalance_slippage_bps) !== null && _b !== void 0 ? _b : 100;
+            let executionStartTime = (_c = params.execution_start_time) !== null && _c !== void 0 ? _c : 0;
+            let minBountyAmount = (_d = params.min_bounty_amount) !== null && _d !== void 0 ? _d : 0;
+            let maxBountyAmount = (_e = params.max_bounty_amount) !== null && _e !== void 0 ? _e : 0;
+            const basket = yield this.fetchBasket((0, pda_1.getBasketState)(new web3_js_1.PublicKey(params.basket_mint)).toBase58());
+            let globalConfig = yield this.fetchGlobalConfig();
+            let bountyWsolAmount = 0;
+            if (globalConfig.bountyMint.equals(constants_1.MINTS["mainnet"].WSOL)) {
+                let boundBounty = parseInt(globalConfig.bountyBondAmount.toString());
+                let maxBountyPerTask = parseInt(globalConfig.bountyPerTask.maxBounty.toString());
+                let bountyPerPriceUpdateTaskDivisor = parseInt(globalConfig.bountyPerPriceUpdateTaskDivisor.toString());
+                if (maxBountyAmount > maxBountyPerTask)
+                    maxBountyPerTask = maxBountyAmount;
+                bountyWsolAmount = (0, rebalanceIntent_3.computeRebalanceIntentBountyAmount)(rebalanceIntent_2.RebalanceType.Basket, basket.numTokens, boundBounty, maxBountyPerTask, Math.floor(maxBountyPerTask / bountyPerPriceUpdateTaskDivisor));
+            }
+            let wsolIxs = yield (0, txUtils_1.wrapWsolIxs)(this.sdkParams.connection, keeper, bountyWsolAmount);
+            const rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket.ownAddress, basket.ownAddress);
+            let rentPayer = (0, pda_1.getRentPayerPda)();
+            let renPayerAi = yield this.sdkParams.connection.getAccountInfo(rentPayer);
+            let rebalanceIntentRentPayer = keeper;
+            // TODO: check actual lamports required for rent
+            if ((_f = renPayerAi === null || renPayerAi === void 0 ? void 0 : renPayerAi.lamports) !== null && _f !== void 0 ? _f : 0 > 0)
+                rebalanceIntentRentPayer = rentPayer;
+            let bountyMint = basket.settings.bountyMint;
+            let txBatchData = { batches: [[{
+                            payer: keeper,
+                            instructions: [
+                                ...wsolIxs,
+                                (0, rebalanceIntent_1.createRebalanceIntentIx)({
+                                    signer: keeper,
+                                    owner: basket.ownAddress,
+                                    basket: basket.ownAddress,
+                                }),
+                                (0, rebalanceIntent_1.resizeRebalanceIntentIx)(rebalanceIntent),
+                                (0, rebalanceIntent_1.initRebalanceIntentIx)({
+                                    signer: keeper,
+                                    owner: basket.ownAddress,
+                                    basket: basket.ownAddress,
+                                    basketTokenMint: basket.mint,
+                                    rebalanceIntentRentPayer: rebalanceIntentRentPayer,
+                                    bountyMint: bountyMint,
+                                    rebalanceType: rebalanceIntent_2.RebalanceType.Basket,
+                                    basketRebalanceIntent: undefined,
+                                    rebalanceSlippageBps: rebalanceSlippageBps,
+                                    perTradeRebalanceSlippageBps: perTradeRebalanceSlippageBps,
+                                    executionStartTime: executionStartTime,
+                                    minBountyAmount: minBountyAmount,
+                                    maxBountyAmount: maxBountyAmount,
+                                }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: constants_1.COMPUTE_UNITS }),
+                                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.sdkParams.priorityFee }),
+                            ],
+                            lookupTables: [],
+                        }]] };
+            let versionedTxs = yield (0, txUtils_1.prepareVersionedTxs)(this.sdkParams.connection, txBatchData);
+            let txPayloadBatchSequence = (0, txUtils_1.prepareTxPayloadBatchSequence)(txBatchData, versionedTxs);
+            return txPayloadBatchSequence;
+        });
+    }
     startPriceUpdatesTx(params) {
         return __awaiter(this, void 0, void 0, function* () {
             let keeper = new web3_js_1.PublicKey(params.keeper);
@@ -820,6 +884,7 @@ class SymmetryCore {
                 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;
                 ixs.push((0, priceUpdate_1.updateTokenPricesIx)({
                     keeper: keeper,
                     basket: basket.ownAddress,
@@ -829,6 +894,7 @@ class SymmetryCore {
                     tokenIndices: tokenIndices,
                     additionalOracleAccounts: allKeys,
                     basketRebalanceIntent: basket.settings.activeRebalance.eq(new anchor_1.BN(0)) ? undefined : basketRebalanceIntent,
+                    basketMint: performanceFees > 0 ? basket.mint : undefined,
                 }));
             }
             let txBatchData = { batches: [ixs.map(ix => ({
@@ -871,7 +937,7 @@ class SymmetryCore {
             let ixWithdraw = (0, flashSwap_1.flashWithdrawIx)(flashParams);
             let ixDeposit = (0, flashSwap_1.flashDepositIx)(flashParams);
             let ixs = [];
-            ixs.concat([
+            ixs = ixs.concat([
                 (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(keeper, (0, pda_1.getAta)(keeper, mintIn), keeper, mintIn),
                 (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(keeper, (0, pda_1.getAta)(keeper, mintOut), keeper, mintOut),
             ]);
@@ -964,17 +1030,17 @@ class SymmetryCore {
             let rebalanceIntent = yield this.fetchRebalanceIntent(params.rebalance_intent);
             let keepersArray = [];
             if (!rebalanceIntent.startPriceUpdateTask.completedBy.equals(web3_js_1.PublicKey.default))
-                keepersArray.push(rebalanceIntent.startPriceUpdateTask.completedBy);
+                keepersArray.push(rebalanceIntent.startPriceUpdateTask.completedBy.toBase58());
             if (!rebalanceIntent.finishPriceUpdateTask.completedBy.equals(web3_js_1.PublicKey.default))
-                keepersArray.push(rebalanceIntent.finishPriceUpdateTask.completedBy);
+                keepersArray.push(rebalanceIntent.finishPriceUpdateTask.completedBy.toBase58());
             if (!rebalanceIntent.mintBasketTask.completedBy.equals(web3_js_1.PublicKey.default))
-                keepersArray.push(rebalanceIntent.mintBasketTask.completedBy);
+                keepersArray.push(rebalanceIntent.mintBasketTask.completedBy.toBase58());
             for (let i = 0; i < rebalanceIntent.priceUpdateTasks.length; i++)
                 if (!rebalanceIntent.priceUpdateTasks[i].completedBy.equals(web3_js_1.PublicKey.default))
-                    keepersArray.push(rebalanceIntent.priceUpdateTasks[i].completedBy);
+                    keepersArray.push(rebalanceIntent.priceUpdateTasks[i].completedBy.toBase58());
             for (let i = 0; i < rebalanceIntent.tokenSettlementTasks.length; i++)
                 if (!rebalanceIntent.tokenSettlementTasks[i].completedBy.equals(web3_js_1.PublicKey.default))
-                    keepersArray.push(rebalanceIntent.tokenSettlementTasks[i].completedBy);
+                    keepersArray.push(rebalanceIntent.tokenSettlementTasks[i].completedBy.toBase58());
             keepersArray = Array.from(new Set(keepersArray));
             let batchSize = 10;
             let ixs = [];
@@ -986,7 +1052,7 @@ class SymmetryCore {
                     bountyMint: rebalanceIntent.bounty.bountyMint,
                     bountyDepositor: rebalanceIntent.bounty.bountyDepositor,
                     rentPayer: rebalanceIntent.rentPayer,
-                    keepers: keepersArray.slice(batchStart, batchStart + batchSize),
+                    keepers: keepersArray.map(keeper => new web3_js_1.PublicKey(keeper)).slice(batchStart, batchStart + batchSize),
                 }));
             let txBatchData = { batches: [ixs.map(ix => ({
                         payer: keeper,
@@ -1066,3 +1132,5 @@ class SymmetryCore {
     }
 }
 exports.SymmetryCore = SymmetryCore;
+var keeperMonitor_1 = require("./keeperMonitor");
+Object.defineProperty(exports, "KeeperMonitor", { enumerable: true, get: function () { return keeperMonitor_1.KeeperMonitor; } });

package/dist/src/instructions/automation/priceUpdate.d.ts

@@ -14,6 +14,7 @@ export declare function updateTokenPricesIx(params: {
     lookupTable1: PublicKey;
     tokenIndices: number[];
     additionalOracleAccounts: PublicKey[];
+    basketMint?: PublicKey;
 }): TransactionInstruction;
 export declare function updateTokenPricesCustomIx(params: {
     manager: PublicKey;

package/dist/src/instructions/automation/priceUpdate.js

@@ -8,6 +8,7 @@ const constants_1 = require("../../constants");
 const oracle_1 = require("../../layouts/oracle");
 const pda_1 = require("../pda");
 const anchor_1 = require("@coral-xyz/anchor");
+const spl_token_1 = require("@solana/spl-token");
 const START_PRICE_UPDATES_DISCRIMINATOR = Buffer.from([240, 67, 241, 88, 0, 32, 224, 184]);
 const UPDATE_TOKEN_PRICES_DISCRIMINATOR = Buffer.from([147, 87, 140, 33, 214, 189, 181, 242]);
 const UPDATE_TOKEN_PRICES_CUSTOM_DISCRIMINATOR = Buffer.from([71, 100, 35, 136, 116, 239, 54, 126]);
@@ -50,6 +51,13 @@ function updateTokenPricesIx(params) {
     ];
     // remaining accounts
     keys.push(...params.additionalOracleAccounts.map((pubkey) => ({ pubkey, isSigner: false, isWritable: false })));
+    if (params.basketMint) {
+        let basketFeesWallet = (0, pda_1.getBasketFeesPda)(params.basket);
+        let basketFeesTokenAccount = (0, pda_1.getAta)(basketFeesWallet, params.basketMint);
+        keys.push({ pubkey: spl_token_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false });
+        keys.push({ pubkey: params.basketMint, isSigner: false, isWritable: true });
+        keys.push({ pubkey: basketFeesTokenAccount, isSigner: false, isWritable: true });
+    }
     return new web3_js_1.TransactionInstruction({
         keys,
         programId: constants_1.BASKETS_V3_PROGRAM_ID,

package/dist/src/keeperMonitor.d.ts

@@ -0,0 +1,22 @@
+import { Connection } from "@solana/web3.js";
+import { Wallet } from "./txUtils";
+import { SymmetryCore } from ".";
+export declare class KeeperMonitor {
+    private params;
+    private intents;
+    private rebalanceIntents;
+    private baskets;
+    constructor(params: {
+        wallet: Wallet;
+        connection: Connection;
+        symmetryCore: SymmetryCore;
+        network: "devnet" | "mainnet";
+        jupiterApiKey: string;
+        maxAllowedAccounts: number;
+    });
+    delay: (ms: number) => Promise<unknown>;
+    update(): Promise<void>;
+    run(): Promise<void>;
+    checkIntents(): Promise<void>;
+    checkRebalanceIntents(): Promise<void>;
+}

package/dist/src/keeperMonitor.js

@@ -0,0 +1,214 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeeperMonitor = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const _1 = require(".");
+const rebalanceIntent_1 = require("./states/intents/rebalanceIntent");
+class KeeperMonitor {
+    constructor(params) {
+        this.delay = (ms) => __awaiter(this, void 0, void 0, function* () { return new Promise(resolve => setTimeout(resolve, ms)); });
+        this.params = {
+            wallet: params.wallet,
+            connection: params.connection,
+            symmetryCore: new _1.SymmetryCore({
+                connection: params.connection,
+                network: params.network,
+            }),
+            network: params.network,
+            jupiterApiKey: params.jupiterApiKey,
+            maxAllowedAccounts: params.maxAllowedAccounts,
+        };
+        //@ts-ignore
+        this.globalConfig = {};
+        this.intents = [];
+        this.rebalanceIntents = [];
+        this.baskets = [];
+    }
+    update() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.baskets = yield this.params.symmetryCore.fetchAllBaskets();
+            this.rebalanceIntents = yield this.params.symmetryCore.fetchAllRebalanceIntents();
+            this.intents = yield this.params.symmetryCore.fetchAllIntents();
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("Starting keeper monitor", this.params.wallet.publicKey.toBase58());
+            while (true) {
+                yield this.update();
+                yield this.checkIntents();
+                yield this.checkRebalanceIntents();
+                yield this.delay(30 * 1000);
+            }
+        });
+    }
+    checkIntents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let now = Date.now() / 1000;
+            for (let intent of this.intents)
+                try {
+                    if (intent.formatted.activation_timestamp < now)
+                        try {
+                            let tx = yield this.params.symmetryCore.executeBasketIntentTx({
+                                keeper: this.params.wallet.publicKey.toBase58(),
+                                intent: intent.ownAddress.toBase58(),
+                            });
+                            let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet });
+                            console.log("Execute Basket Intent:", res);
+                            let txCancel = yield this.params.symmetryCore.cancelBasketIntentTx({
+                                keeper: this.params.wallet.publicKey.toBase58(),
+                                intent: intent.ownAddress.toBase58(),
+                            });
+                            let resCancel = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: txCancel, wallet: this.params.wallet });
+                            console.log("Cancel Basket Intent:", resCancel);
+                        }
+                        catch (_a) {
+                            let tx = yield this.params.symmetryCore.cancelBasketIntentTx({
+                                keeper: this.params.wallet.publicKey.toBase58(),
+                                intent: intent.ownAddress.toBase58(),
+                            });
+                            let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet });
+                            console.log("Cancel Basket Intent:", res);
+                        }
+                }
+                catch (_b) { }
+        });
+    }
+    checkRebalanceIntents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let now = Date.now() / 1000;
+            for (let intent of this.rebalanceIntents)
+                try {
+                    console.log(intent.ownAddress.toBase58());
+                    if (intent.formatted.current_action == "not_active")
+                        continue;
+                    if (intent.formatted.current_action == "deposit_tokens")
+                        continue;
+                    if (intent.formatted.current_action == "start_price_updates")
+                        try {
+                            let tx = yield this.params.symmetryCore.startPriceUpdatesTx({
+                                keeper: this.params.wallet.publicKey.toBase58(),
+                                basket: intent.basket.toBase58(),
+                                rebalance_intent: intent.ownAddress.toBase58(),
+                            });
+                            let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet });
+                            console.log("Start Price Updates:", res);
+                            continue;
+                        }
+                        catch (_a) {
+                            continue;
+                        }
+                    if (intent.formatted.current_action == "update_prices" && intent.formatted.last_action_timestamp < now)
+                        try {
+                            let tx = yield this.params.symmetryCore.updateTokenPricesTx({
+                                keeper: this.params.wallet.publicKey.toBase58(),
+                                basket: intent.basket.toBase58(),
+                                rebalance_intent: intent.ownAddress.toBase58(),
+                            });
+                            let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet });
+                            console.log("Update Prices:", res);
+                            continue;
+                        }
+                        catch (_b) {
+                            continue;
+                        }
+                    if (intent.formatted.current_action == "update_prices") {
+                        continue;
+                    }
+                    if (intent.formatted.auctions[2].end_time >= now)
+                        try {
+                            let basket = this.baskets.find(basket => basket.ownAddress.equals(intent.basket));
+                            let pairs = (0, rebalanceIntent_1.getSwapPairs)(intent, basket);
+                            for (let pair of pairs)
+                                try {
+                                    let { tokenLedgerInstruction, swapInstruction, addressLookupTableAddresses, quoteResponse } = yield (0, _1.getJupTokenLedgerAndSwapInstructions)({
+                                        keeper: this.params.wallet.publicKey,
+                                        basketMintIn: new web3_js_1.PublicKey(pair.inMint),
+                                        basketMintOut: new web3_js_1.PublicKey(pair.outMint),
+                                        basketAmountIn: pair.inAmount,
+                                        basketAmountOut: pair.outAmount,
+                                        swapMode: "ioc",
+                                        apiKey: this.params.jupiterApiKey,
+                                        maxJupAccounts: 45,
+                                    });
+                                    console.log(pair, "Jup Quote:", parseFloat(quoteResponse.outAmount), "Requested In:", pair.inAmount);
+                                    if (parseFloat(quoteResponse.outAmount) < pair.inAmount)
+                                        continue;
+                                    let tx = yield this.params.symmetryCore.flashSwapTx({
+                                        keeper: this.params.wallet.publicKey.toBase58(),
+                                        basket: basket.ownAddress.toBase58(),
+                                        rebalance_intent: intent.ownAddress.toBase58(),
+                                        mint_in: pair.inMint,
+                                        mint_out: pair.outMint,
+                                        amount_in: pair.inAmount,
+                                        amount_out: pair.outAmount,
+                                        mode: 2,
+                                        jup_token_ledger_ix: tokenLedgerInstruction,
+                                        jup_swap_ix: swapInstruction,
+                                        jup_address_lookup_table_addresses: addressLookupTableAddresses,
+                                    });
+                                    let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet });
+                                    console.log("Flash Swap:", res);
+                                }
+                                catch (_c) {
+                                    (e) => console.log(e);
+                                }
+                            continue;
+                        }
+                        catch (_d) {
+                            continue;
+                        }
+                    if (intent.formatted.rebalance_type == "deposit")
+                        try {
+                            let tx = yield this.params.symmetryCore.mintTx({
+                                keeper: this.params.wallet.publicKey.toBase58(),
+                                rebalance_intent: intent.ownAddress.toBase58(),
+                            });
+                            let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet });
+                            console.log("Mint:", res);
+                            continue;
+                        }
+                        catch (_e) {
+                            continue;
+                        }
+                    let hasTokens = intent.formatted.tokens.find(token => token.amount > 0);
+                    if (hasTokens && intent.formatted.rebalance_type == "withdraw")
+                        try {
+                            let tx = yield this.params.symmetryCore.redeemTokensTx({
+                                keeper: this.params.wallet.publicKey.toBase58(),
+                                rebalance_intent: intent.ownAddress.toBase58(),
+                            });
+                            let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet });
+                            console.log("Redeem Tokens:", res);
+                            continue;
+                        }
+                        catch (_f) {
+                            continue;
+                        }
+                    try {
+                        let tx = yield this.params.symmetryCore.claimBountyTx({
+                            keeper: this.params.wallet.publicKey.toBase58(),
+                            rebalance_intent: intent.ownAddress.toBase58(),
+                        });
+                        let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet });
+                        console.log("Claim Bounty:", res);
+                        continue;
+                    }
+                    catch (_g) {
+                        continue;
+                    }
+                }
+                catch (_h) { }
+        });
+    }
+}
+exports.KeeperMonitor = KeeperMonitor;

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

@@ -223,14 +223,14 @@ class RebalanceIntentRustClass {
         this.self = rebalanceIntent;
     }
     findTokenIndex(mint) {
-        for (let i = 0; i < constants_1.MAX_SUPPORTED_TOKENS_PER_BASKET; i++)
+        for (let i = 0; i < this.self.priceUpdateTasks.length; i++)
             if (this.self.tokens[i].mint.equals(mint))
                 return i;
         return undefined;
     }
     getSelfTvl() {
         let selfTvl = { high: new anchor_1.BN(0), low: new anchor_1.BN(0) };
-        for (let i = 0; i < constants_1.MAX_SUPPORTED_TOKENS_PER_BASKET; i++) {
+        for (let i = 0; i < this.self.priceUpdateTasks.length; i++) {
             if (this.self.priceUpdateTasks[i].completedTime.isZero()) {
                 continue;
             }
@@ -377,7 +377,7 @@ class RebalanceIntentRustClass {
         this.self.auctionUpdateTimestamp = new anchor_1.BN(Math.floor(Date.now() / 1000));
         const selfTvl = this.getSelfTvl();
         const { basketTvl, weightSum } = this.getBasketTvlAndWeightSum(basket);
-        for (let tokenIndex = 0; tokenIndex < constants_1.MAX_SUPPORTED_TOKENS_PER_BASKET; tokenIndex++) {
+        for (let tokenIndex = 0; tokenIndex < this.self.priceUpdateTasks.length; tokenIndex++) {
             if (this.self.tokens[tokenIndex].mint.equals(web3_js_1.PublicKey.default)) {
                 continue;
             }
@@ -456,10 +456,10 @@ function getSwapPairs(rebalanceIntent, basket) {
     let timeSinceAuctionStart = timestamp.sub(currentAuction.startTime);
     let auctionDuration = currentAuction.endTime.sub(currentAuction.startTime);
     let allPairs = [];
-    for (let inTokenIndex = 0; inTokenIndex < constants_1.MAX_SUPPORTED_TOKENS_PER_BASKET; inTokenIndex++) {
+    for (let inTokenIndex = 0; inTokenIndex < rebalanceIntentRustClass.self.priceUpdateTasks.length; inTokenIndex++) {
         if (rebalanceIntentRustClass.self.priceUpdateTasks[inTokenIndex].completedTime.isZero())
             continue;
-        for (let outTokenIndex = 0; outTokenIndex < constants_1.MAX_SUPPORTED_TOKENS_PER_BASKET; outTokenIndex++) {
+        for (let outTokenIndex = 0; outTokenIndex < rebalanceIntentRustClass.self.priceUpdateTasks.length; outTokenIndex++) {
             if (inTokenIndex === outTokenIndex)
                 continue;
             if (rebalanceIntentRustClass.self.priceUpdateTasks[outTokenIndex].completedTime.isZero())

package/dist/test.d.ts

@@ -1,22 +1 @@
-import { Connection } from "@solana/web3.js";
-import { Wallet } from "@coral-xyz/anchor";
-import { SymmetryCore } from "./src";
-export declare class KeeperMonitor {
-    private params;
-    private intents;
-    private rebalanceIntents;
-    private baskets;
-    constructor(params: {
-        wallet: Wallet;
-        connection: Connection;
-        symmetryCore: SymmetryCore;
-        network: "devnet" | "mainnet";
-        jupiterApiKey: string;
-        maxAllowedAccounts: number;
-    });
-    delay: (ms: number) => Promise<unknown>;
-    update(): Promise<void>;
-    run(): Promise<void>;
-    checkIntents(): Promise<void>;
-    checkRebalanceIntents(): Promise<void>;
-}
+export {};