@symmetry-hq/temp-v3-sdk 0.0.62 → 0.0.63

package/dist/src/index.d.ts

@@ -796,4 +796,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';
+export { KeeperMonitor, RebalanceHandler, } 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.KeeperMonitor = exports.getJupTokenLedgerAndSwapInstructions = exports.TaskType = exports.SymmetryCore = void 0;
+exports.RebalanceHandler = exports.KeeperMonitor = exports.getJupTokenLedgerAndSwapInstructions = exports.TaskType = exports.SymmetryCore = void 0;
 const decimal_js_1 = __importDefault(require("decimal.js"));
 const bn_js_1 = __importDefault(require("bn.js"));
 const spl_token_1 = require("@solana/spl-token");
@@ -2087,3 +2087,4 @@ class SymmetryCore {
 exports.SymmetryCore = SymmetryCore;
 var keeperMonitor_1 = require("./keeperMonitor");
 Object.defineProperty(exports, "KeeperMonitor", { enumerable: true, get: function () { return keeperMonitor_1.KeeperMonitor; } });
+Object.defineProperty(exports, "RebalanceHandler", { enumerable: true, get: function () { return keeperMonitor_1.RebalanceHandler; } });

package/dist/src/keeperMonitor.d.ts

@@ -1,5 +1,6 @@
-import { Connection } from "@solana/web3.js";
+import { Connection, PublicKey } from "@solana/web3.js";
 import { Wallet } from "./txUtils";
+import { Basket, UIRebalanceIntent } from ".";
 export declare class KeeperMonitor {
     private params;
     private intents;
@@ -20,3 +21,32 @@ export declare class KeeperMonitor {
     monitorIntent(pubkey: string): Promise<void>;
     monitorRebalanceIntent(pubkey: string): Promise<void>;
 }
+export declare class RebalanceHandler {
+    private params;
+    private intent;
+    private basket;
+    constructor(params: {
+        intent: UIRebalanceIntent;
+        basket: Basket;
+        wallet: Wallet;
+        connection: Connection;
+        network: "devnet" | "mainnet";
+        jupiterApiKey: string;
+        maxAllowedAccounts: number;
+        priorityFee?: number;
+        simulateTransactions?: boolean;
+    });
+    delay: (ms: number) => Promise<unknown>;
+    refresh(): Promise<void>;
+    static run(params: {
+        intentPubkey: PublicKey;
+        wallet: Wallet;
+        connection: Connection;
+        network: "devnet" | "mainnet";
+        jupiterApiKey: string;
+        maxAllowedAccounts: number;
+        priorityFee?: number;
+        simulateTransactions?: boolean;
+    }): Promise<void>;
+    private execute;
+}

package/dist/src/keeperMonitor.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeeperMonitor = void 0;
+exports.RebalanceHandler = exports.KeeperMonitor = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const _1 = require(".");
 const rebalanceIntent_1 = require("./states/intents/rebalanceIntent");
@@ -156,7 +156,7 @@ class KeeperMonitor {
                             intent: intent.ownAddress.toBase58(),
                         });
                         let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions });
-                        console.log("Execute Basket Intent - ", pubkey, " : ", res);
+                        console.log("Execute Basket Intent -", pubkey, " : ", res);
                         nextCheckTime = now + 60;
                     }
                     catch (_a) { }
@@ -172,12 +172,12 @@ class KeeperMonitor {
                         intent: intent.ownAddress.toBase58(),
                     });
                     let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions });
-                    console.log("Cancel Basket Intent - ", pubkey, " : ", res);
+                    console.log("Cancel Basket Intent -", pubkey, " : ", res);
                     nextCheckTime = now + 60;
                 }
                 catch (e) {
                     if (numTries == 4) {
-                        console.log("Stop monitoring - ", pubkey, " : ", e);
+                        console.log("Stop monitoring -", pubkey, " : ", e);
                     }
                 }
                 continue;
@@ -186,12 +186,14 @@ class KeeperMonitor {
     }
     monitorRebalanceIntent(pubkey) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a, _b, _c, _d, _e;
             let nextCheckTime = 0;
             let numTriesUpdatePrices = 0;
             let numTriesMint = 0;
             let numTriesRedeemTokens = 0;
             let numTriesClaimBounty = 0;
+            let lastJupQuotesUpdate = 0;
+            let jupQuotes = [];
             while (true) {
                 let uiIntent = this.rebalanceIntents.get(pubkey);
                 if (!uiIntent)
@@ -213,7 +215,7 @@ class KeeperMonitor {
                     continue;
                 }
                 if (intent.current_action == "update_prices") {
-                    if (numTriesUpdatePrices >= 3)
+                    if (numTriesUpdatePrices >= 5)
                         break;
                     numTriesUpdatePrices += 1;
                     try {
@@ -226,86 +228,90 @@ class KeeperMonitor {
                         console.log("Update Prices - ", pubkey, " : ", res);
                     }
                     catch (e) {
-                        if (numTriesUpdatePrices == 3) {
+                        if (numTriesUpdatePrices == 4) {
                             console.log("Stop monitoring - ", pubkey, " : ", e);
                         }
                     }
+                    nextCheckTime += 60;
                     continue;
                 }
                 if (intent.auctions[2].end_time > now) {
                     let basket = this.baskets.get(intent.basket);
                     if (!basket)
                         continue;
-                    let auction0StartTime = intent.auctions[0].start_time;
-                    let auction0EndTime = intent.auctions[0].end_time;
-                    let auction0MidTime = auction0StartTime + (auction0EndTime - auction0StartTime) / 2;
-                    let auction1StartTime = intent.auctions[1].start_time;
-                    let auction1EndTime = intent.auctions[1].end_time;
-                    let auction1MidTime = auction1StartTime + (auction1EndTime - auction1StartTime) / 2;
-                    let auction2StartTime = intent.auctions[2].start_time;
-                    let auction2EndTime = intent.auctions[2].end_time;
-                    let auction2MidTime = auction2StartTime + (auction2EndTime - auction2StartTime) / 2;
-                    if (now < auction0MidTime + 30) {
-                        nextCheckTime = auction0MidTime + 30;
-                        continue;
-                    }
-                    if (now >= auction0EndTime) {
-                        if (now < auction1MidTime + 10) {
-                            nextCheckTime = auction1MidTime + 10;
-                            continue;
-                        }
-                        if (now >= auction1EndTime)
-                            if (now < auction2MidTime + 5) {
-                                nextCheckTime = auction2MidTime + 5;
-                                continue;
-                            }
-                    }
                     let pairs = (0, rebalanceIntent_1.getSwapPairs)(chainData, basket);
-                    for (let pair of pairs)
-                        try {
+                    if (Date.now() / 1000 > lastJupQuotesUpdate + 60) {
+                        lastJupQuotesUpdate = Date.now() / 1000;
+                        jupQuotes = [];
+                        for (let pair of pairs) {
                             if (pair.value < 0.005)
                                 continue;
-                            yield this.delay(1000);
-                            let { tokenLedgerInstruction, swapInstruction, addressLookupTableAddresses, quoteResponse } = this.params.network == "mainnet" ?
-                                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: this.params.maxAllowedAccounts,
-                                }) : { tokenLedgerInstruction: undefined, swapInstruction: undefined, addressLookupTableAddresses: [], quoteResponse: undefined };
-                            console.log(pair, "Jup Quote:", parseFloat((_a = quoteResponse === null || quoteResponse === void 0 ? void 0 : quoteResponse.outAmount) !== null && _a !== void 0 ? _a : 0), "Requested In:", pair.inAmount);
-                            if (this.params.network == "devnet" || parseFloat((_b = quoteResponse === null || quoteResponse === void 0 ? void 0 : quoteResponse.outAmount) !== null && _b !== void 0 ? _b : 0) > pair.inAmount) {
+                            if (this.params.network == "mainnet")
                                 try {
-                                    let tx = yield this.params.symmetryCore.flashSwapTx({
-                                        keeper: this.params.wallet.publicKey.toBase58(),
-                                        basket: basket.ownAddress.toBase58(),
-                                        rebalance_intent: intent.pubkey,
-                                        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 (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: this.params.maxAllowedAccounts,
                                     });
-                                    let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions });
-                                    console.log("Flash Swap - ", pubkey, " : ", res);
+                                    jupQuotes.push(Object.assign(Object.assign({}, res), { inMint: pair.inMint, outMint: pair.outMint }));
+                                    console.log("Fetch new Jup Quote:", pair.inMint, pair.outMint);
+                                    console.log(pair, "Jup Quote:", parseFloat((_b = (_a = res.quoteResponse) === null || _a === void 0 ? void 0 : _a.outAmount) !== null && _b !== void 0 ? _b : 0), "Requested In:", pair.inAmount);
                                 }
-                                catch (_c) { }
+                                catch (_f) { }
+                        }
+                    }
+                    for (let index = 0; index < pairs.length; index++)
+                        try {
+                            let pair = pairs[index];
+                            let jupIndex = jupQuotes.findIndex(q => q && q.inMint == pair.inMint && q.outMint == pair.outMint);
+                            let quote = jupIndex >= 0 ? jupQuotes[jupIndex] : undefined;
+                            if (!quote && this.params.network == "mainnet")
+                                continue;
+                            if (pair.value < 0.005)
+                                continue;
+                            let tokenLedgerInstruction = quote === null || quote === void 0 ? void 0 : quote.tokenLedgerInstruction;
+                            let swapInstruction = quote === null || quote === void 0 ? void 0 : quote.swapInstruction;
+                            let addressLookupTableAddresses = (_c = quote === null || quote === void 0 ? void 0 : quote.addressLookupTableAddresses) !== null && _c !== void 0 ? _c : [];
+                            let quoteResponse = quote === null || quote === void 0 ? void 0 : quote.quoteResponse;
+                            if (this.params.network == "mainnet" && !quoteResponse)
+                                continue;
+                            console.log(pair, "Jup Quote:", parseFloat((_d = quoteResponse === null || quoteResponse === void 0 ? void 0 : quoteResponse.outAmount) !== null && _d !== void 0 ? _d : 0), "Requested In:", pair.inAmount);
+                            let quoteResponseAmount = parseFloat((_e = quoteResponse === null || quoteResponse === void 0 ? void 0 : quoteResponse.outAmount) !== null && _e !== void 0 ? _e : 0);
+                            if (this.params.network == "mainnet" && quoteResponseAmount * 1.005 <= pair.inAmount)
+                                continue;
+                            try {
+                                let tx = yield this.params.symmetryCore.flashSwapTx({
+                                    keeper: this.params.wallet.publicKey.toBase58(),
+                                    basket: basket.ownAddress.toBase58(),
+                                    rebalance_intent: intent.pubkey,
+                                    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, simulateTransactions: this.params.simulateTransactions });
+                                console.log("Flash Swap - ", pubkey, " : ", res);
+                                jupQuotes = jupQuotes.filter(q => q && (q.inMint != pair.inMint || q.outMint != pair.outMint));
                             }
+                            catch (_g) { }
                         }
-                        catch (_d) { }
+                        catch (_h) { }
                     nextCheckTime = (Date.now() / 1000) + 8;
                     continue;
                 }
                 if (intent.rebalance_type == "deposit") {
                     if (numTriesMint >= 3)
                         break;
+                    lastJupQuotesUpdate = 0;
                     numTriesMint += 1;
                     try {
                         let tx = yield this.params.symmetryCore.mintTx({
@@ -365,3 +371,254 @@ class KeeperMonitor {
     }
 }
 exports.KeeperMonitor = KeeperMonitor;
+class RebalanceHandler {
+    constructor(params) {
+        var _a, _b;
+        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,
+                priorityFee: (_a = params.priorityFee) !== null && _a !== void 0 ? _a : constants_1.PRIORITY_FEE,
+            }),
+            network: params.network,
+            jupiterApiKey: params.jupiterApiKey,
+            maxAllowedAccounts: params.maxAllowedAccounts,
+            simulateTransactions: (_b = params.simulateTransactions) !== null && _b !== void 0 ? _b : false,
+        };
+        this.intent = params.intent;
+        this.basket = params.basket;
+    }
+    refresh() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.intent = yield this.params.symmetryCore.fetchRebalanceIntent(this.intent.formatted_data.pubkey);
+            this.basket = yield this.params.symmetryCore.fetchBasket(this.intent.formatted_data.basket);
+        });
+    }
+    static run(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let symmetryCore = new _1.SymmetryCore({
+                connection: params.connection,
+                network: params.network,
+                priorityFee: (_a = params.priorityFee) !== null && _a !== void 0 ? _a : constants_1.PRIORITY_FEE,
+            });
+            let intent = yield symmetryCore.fetchRebalanceIntent(params.intentPubkey.toBase58());
+            let basket = yield symmetryCore.fetchBasket(intent.formatted_data.basket);
+            let handler = new RebalanceHandler({
+                intent, basket,
+                wallet: params.wallet,
+                connection: params.connection,
+                network: params.network,
+                jupiterApiKey: params.jupiterApiKey,
+                maxAllowedAccounts: params.maxAllowedAccounts,
+                simulateTransactions: params.simulateTransactions,
+            });
+            handler.execute();
+            for (let i = 0; i < 20; i++) {
+                yield handler.delay(15 * 1000);
+                try {
+                    yield handler.refresh();
+                }
+                catch (e) {
+                    handler.intent = undefined;
+                    break;
+                }
+            }
+        });
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            console.log("Starting rebalance handler for intent:", this.intent.formatted_data.pubkey);
+            let nextCheckTime = 0;
+            let numTriesUpdatePrices = 0;
+            let numTriesMint = 0;
+            let numTriesRedeemTokens = 0;
+            let numTriesClaimBounty = 0;
+            let rebalancePairs = [];
+            let lastJupQuotesUpdate = 0;
+            let jupQuotes = [];
+            while (true) {
+                if (!this.intent)
+                    break;
+                let intent = this.intent.formatted_data;
+                let chainData = this.intent.chain_data;
+                let now = Date.now() / 1000;
+                if (now < nextCheckTime) {
+                    yield this.delay(Math.min(30 * 1000, Math.max(0, nextCheckTime - now + 0.2) * 1000));
+                    continue;
+                }
+                nextCheckTime = now + 5;
+                if (intent.current_action == "not_active") {
+                    console.log("Intent not active, stopping");
+                    break;
+                }
+                if (intent.current_action == "deposit_tokens") {
+                    console.log("Waiting for deposit...");
+                    continue;
+                }
+                if (intent.current_action == "update_prices" && intent.last_action_timestamp > now) {
+                    nextCheckTime = intent.last_action_timestamp;
+                    continue;
+                }
+                if (intent.current_action == "update_prices") {
+                    if (numTriesUpdatePrices >= 3) {
+                        console.log("Max retries for update_prices");
+                        break;
+                    }
+                    numTriesUpdatePrices += 1;
+                    try {
+                        let tx = yield this.params.symmetryCore.updateTokenPricesTx({
+                            keeper: this.params.wallet.publicKey.toBase58(),
+                            basket: intent.basket,
+                            rebalance_intent: intent.pubkey,
+                        });
+                        let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions });
+                        console.log("Update Prices:", res);
+                    }
+                    catch (e) {
+                        if (numTriesUpdatePrices == 3) {
+                            console.log("Stop - update prices failed:", e);
+                        }
+                    }
+                    continue;
+                }
+                if (intent.auctions[2].end_time > now) {
+                    rebalancePairs = (0, rebalanceIntent_1.getSwapPairs)(chainData, this.basket);
+                    if (Date.now() / 1000 > lastJupQuotesUpdate + 60) {
+                        let usedValue = new Map();
+                        jupQuotes = [];
+                        for (let pair of rebalancePairs) {
+                            let inValue = (_a = usedValue.get(pair.inMint)) !== null && _a !== void 0 ? _a : 0;
+                            let outValue = (_b = usedValue.get(pair.outMint)) !== null && _b !== void 0 ? _b : 0;
+                            let swapValue = Math.min(pair.value - inValue, pair.value - outValue);
+                            if (swapValue < 0.005) {
+                                jupQuotes.push(undefined);
+                                continue;
+                            }
+                            usedValue.set(pair.inMint, inValue + swapValue);
+                            usedValue.set(pair.outMint, outValue + swapValue);
+                            let res = undefined;
+                            if (this.params.network == "mainnet")
+                                try {
+                                    res = Object.assign(Object.assign({}, (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: this.params.maxAllowedAccounts,
+                                    }))), { inMint: pair.inMint, outMint: pair.outMint });
+                                }
+                                catch (_c) { }
+                            ;
+                            jupQuotes.push(res);
+                        }
+                    }
+                    for (let index = 0; index < rebalancePairs.length; index++)
+                        try {
+                            let pair = rebalancePairs[index];
+                            let quote = jupQuotes.find(q => q && q.inMint == pair.inMint && q.outMint == pair.outMint);
+                            if (!quote)
+                                continue;
+                            if (pair.value < 0.005)
+                                continue;
+                            let { tokenLedgerInstruction, swapInstruction, addressLookupTableAddresses, quoteResponse } = quote;
+                            if (!quoteResponse)
+                                continue;
+                            console.log(pair, "Jup Quote:", parseFloat(quoteResponse.outAmount), "Requested In:", pair.inAmount);
+                            if (parseFloat(quoteResponse.outAmount) <= pair.inAmount && this.params.network == "mainnet")
+                                continue;
+                            try {
+                                let tx = yield this.params.symmetryCore.flashSwapTx({
+                                    keeper: this.params.wallet.publicKey.toBase58(),
+                                    basket: this.basket.ownAddress.toBase58(),
+                                    rebalance_intent: intent.pubkey,
+                                    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, simulateTransactions: this.params.simulateTransactions });
+                                console.log("Flash Swap:", res);
+                                rebalancePairs = rebalancePairs.splice(index, 1);
+                                index -= 1;
+                            }
+                            catch (_d) { }
+                        }
+                        catch (_e) { }
+                    nextCheckTime = (Date.now() / 1000) + 10;
+                    continue;
+                }
+                if (intent.rebalance_type == "deposit") {
+                    if (numTriesMint >= 3)
+                        break;
+                    lastJupQuotesUpdate = 0;
+                    numTriesMint += 1;
+                    try {
+                        let tx = yield this.params.symmetryCore.mintTx({
+                            keeper: this.params.wallet.publicKey.toBase58(),
+                            rebalance_intent: intent.pubkey,
+                        });
+                        let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions });
+                        console.log("Mint -", res);
+                    }
+                    catch (e) {
+                        if (numTriesMint == 3) {
+                            console.log("Stop monitoring -", e);
+                        }
+                    }
+                    continue;
+                }
+                let hasTokens = intent.tokens.find(token => token.amount > 0);
+                if (hasTokens && intent.rebalance_type == "withdraw") {
+                    if (numTriesRedeemTokens >= 3)
+                        break;
+                    numTriesRedeemTokens += 1;
+                    try {
+                        let tx = yield this.params.symmetryCore.redeemTokensTx({
+                            keeper: this.params.wallet.publicKey.toBase58(),
+                            rebalance_intent: intent.pubkey,
+                        });
+                        let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions });
+                        console.log("Redeem Tokens -", res);
+                    }
+                    catch (e) {
+                        if (numTriesRedeemTokens == 3) {
+                            console.log("Stop monitoring -", e);
+                        }
+                    }
+                    continue;
+                }
+                if (numTriesClaimBounty >= 3)
+                    break;
+                numTriesClaimBounty += 1;
+                try {
+                    let tx = yield this.params.symmetryCore.claimBountyTx({
+                        keeper: this.params.wallet.publicKey.toBase58(),
+                        rebalance_intent: intent.pubkey,
+                    });
+                    let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions });
+                    console.log("Claim Bounty -", res);
+                    nextCheckTime = now + 60;
+                }
+                catch (e) {
+                    if (numTriesClaimBounty == 3) {
+                        console.log("Stop monitoring -", e);
+                    }
+                }
+                continue;
+            }
+        });
+    }
+}
+exports.RebalanceHandler = RebalanceHandler;

package/dist/src/keeperRebalaneHandler.d.ts

@@ -0,0 +1,32 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import { Wallet } from "./txUtils";
+import { Basket, UIRebalanceIntent } from ".";
+export declare class RebalanceHandler {
+    private params;
+    private intent;
+    private basket;
+    constructor(params: {
+        intent: UIRebalanceIntent;
+        basket: Basket;
+        wallet: Wallet;
+        connection: Connection;
+        network: "devnet" | "mainnet";
+        jupiterApiKey: string;
+        maxAllowedAccounts: number;
+        priorityFee?: number;
+        simulateTransactions?: boolean;
+    });
+    delay: (ms: number) => Promise<unknown>;
+    refresh(): Promise<void>;
+    static run(params: {
+        intentPubkey: PublicKey;
+        wallet: Wallet;
+        connection: Connection;
+        network: "devnet" | "mainnet";
+        jupiterApiKey: string;
+        maxAllowedAccounts: number;
+        priorityFee?: number;
+        simulateTransactions?: boolean;
+    }): Promise<void>;
+    private execute;
+}

package/dist/src/keeperRebalaneHandler.js

@@ -0,0 +1,278 @@
+"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.RebalanceHandler = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const _1 = require(".");
+const rebalanceIntent_1 = require("./states/intents/rebalanceIntent");
+const constants_1 = require("./constants");
+class RebalanceHandler {
+    constructor(params) {
+        var _a, _b;
+        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,
+                priorityFee: (_a = params.priorityFee) !== null && _a !== void 0 ? _a : constants_1.PRIORITY_FEE,
+            }),
+            network: params.network,
+            jupiterApiKey: params.jupiterApiKey,
+            maxAllowedAccounts: params.maxAllowedAccounts,
+            simulateTransactions: (_b = params.simulateTransactions) !== null && _b !== void 0 ? _b : false,
+        };
+        this.intent = params.intent;
+        this.basket = params.basket;
+    }
+    refresh() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.intent = yield this.params.symmetryCore.fetchRebalanceIntent(this.intent.formatted_data.pubkey);
+            this.basket = yield this.params.symmetryCore.fetchBasket(this.intent.formatted_data.basket);
+        });
+    }
+    static run(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let symmetryCore = new _1.SymmetryCore({
+                connection: params.connection,
+                network: params.network,
+                priorityFee: (_a = params.priorityFee) !== null && _a !== void 0 ? _a : constants_1.PRIORITY_FEE,
+            });
+            let intent = yield symmetryCore.fetchRebalanceIntent(params.intentPubkey.toBase58());
+            let basket = yield symmetryCore.fetchBasket(intent.formatted_data.basket);
+            let handler = new RebalanceHandler({
+                intent, basket,
+                wallet: params.wallet,
+                connection: params.connection,
+                network: params.network,
+                jupiterApiKey: params.jupiterApiKey,
+                maxAllowedAccounts: params.maxAllowedAccounts,
+                simulateTransactions: params.simulateTransactions,
+            });
+            handler.execute();
+            for (let i = 0; i < 20; i++) {
+                yield handler.delay(15 * 1000);
+                try {
+                    yield handler.refresh();
+                }
+                catch (e) {
+                    break;
+                }
+            }
+        });
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            console.log("Starting rebalance handler for intent:", this.intent.formatted_data.pubkey);
+            let nextCheckTime = 0;
+            let numTriesUpdatePrices = 0;
+            let numTriesMint = 0;
+            let numTriesRedeemTokens = 0;
+            let numTriesClaimBounty = 0;
+            let rebalancePairs = [];
+            let lastJupQuotesUpdate = 0;
+            let jupQuotes = [];
+            while (true) {
+                if (!this.intent)
+                    break;
+                let intent = this.intent.formatted_data;
+                let chainData = this.intent.chain_data;
+                let now = Date.now() / 1000;
+                if (now < nextCheckTime) {
+                    yield this.delay(Math.min(30 * 1000, Math.max(0, nextCheckTime - now + 0.2) * 1000));
+                    continue;
+                }
+                nextCheckTime = now + 35;
+                if (intent.current_action == "not_active") {
+                    console.log("Intent not active, stopping");
+                    break;
+                }
+                if (intent.current_action == "deposit_tokens") {
+                    console.log("Waiting for deposit...");
+                    continue;
+                }
+                if (intent.current_action == "update_prices" && intent.last_action_timestamp > now) {
+                    nextCheckTime = intent.last_action_timestamp;
+                    continue;
+                }
+                if (intent.current_action == "update_prices") {
+                    if (numTriesUpdatePrices >= 3) {
+                        console.log("Max retries for update_prices");
+                        break;
+                    }
+                    numTriesUpdatePrices += 1;
+                    try {
+                        let tx = yield this.params.symmetryCore.updateTokenPricesTx({
+                            keeper: this.params.wallet.publicKey.toBase58(),
+                            basket: intent.basket,
+                            rebalance_intent: intent.pubkey,
+                        });
+                        let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions });
+                        console.log("Update Prices:", res);
+                    }
+                    catch (e) {
+                        if (numTriesUpdatePrices == 3) {
+                            console.log("Stop - update prices failed:", e);
+                        }
+                    }
+                    continue;
+                }
+                if (intent.auctions[2].end_time > now) {
+                    let auction0StartTime = intent.auctions[0].start_time;
+                    let auction0EndTime = intent.auctions[0].end_time;
+                    let auction1StartTime = intent.auctions[1].start_time;
+                    let auction1EndTime = intent.auctions[1].end_time;
+                    let auction2StartTime = intent.auctions[2].start_time;
+                    let auction2EndTime = intent.auctions[2].end_time;
+                    rebalancePairs = (0, rebalanceIntent_1.getSwapPairs)(chainData, this.basket);
+                    if (Date.now() / 1000 > lastJupQuotesUpdate + 60) {
+                        let usedValue = new Map();
+                        jupQuotes = [];
+                        for (let pair of rebalancePairs) {
+                            let inValue = (_a = usedValue.get(pair.inMint)) !== null && _a !== void 0 ? _a : 0;
+                            let outValue = (_b = usedValue.get(pair.outMint)) !== null && _b !== void 0 ? _b : 0;
+                            let swapValue = Math.min(pair.value - inValue, pair.value - outValue);
+                            if (swapValue < 0.005) {
+                                jupQuotes.push(undefined);
+                                continue;
+                            }
+                            usedValue.set(pair.inMint, inValue + swapValue);
+                            usedValue.set(pair.outMint, outValue + swapValue);
+                            let res = undefined;
+                            if (this.params.network == "mainnet")
+                                try {
+                                    res = Object.assign(Object.assign({}, (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: this.params.maxAllowedAccounts,
+                                    }))), { inMint: pair.inMint, outMint: pair.outMint });
+                                }
+                                catch (_c) { }
+                            ;
+                            jupQuotes.push(res);
+                        }
+                    }
+                    for (let index = 0; index < rebalancePairs.length; index++)
+                        try {
+                            let pair = rebalancePairs[index];
+                            let quote = jupQuotes.find(q => q && q.inMint == pair.inMint && q.outMint == pair.outMint);
+                            if (!quote)
+                                continue;
+                            if (pair.value < 0.005)
+                                continue;
+                            let { tokenLedgerInstruction, swapInstruction, addressLookupTableAddresses, quoteResponse } = quote;
+                            if (!quoteResponse)
+                                continue;
+                            console.log(pair, "Jup Quote:", parseFloat(quoteResponse.outAmount), "Requested In:", pair.inAmount);
+                            if (parseFloat(quoteResponse.outAmount) <= pair.inAmount && this.params.network == "mainnet")
+                                continue;
+                            try {
+                                let tx = yield this.params.symmetryCore.flashSwapTx({
+                                    keeper: this.params.wallet.publicKey.toBase58(),
+                                    basket: this.basket.ownAddress.toBase58(),
+                                    rebalance_intent: intent.pubkey,
+                                    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, simulateTransactions: this.params.simulateTransactions });
+                                console.log("Flash Swap:", res);
+                                rebalancePairs = rebalancePairs.splice(index, 1);
+                                index -= 1;
+                            }
+                            catch (_d) { }
+                        }
+                        catch (_e) { }
+                    nextCheckTime = (Date.now() / 1000) + 10;
+                    continue;
+                }
+                if (intent.rebalance_type == "deposit") {
+                    lastJupQuotesUpdate = 0;
+                    if (numTriesMint >= 3) {
+                        console.log("Max retries for mint");
+                        break;
+                    }
+                    numTriesMint += 1;
+                    try {
+                        let tx = yield this.params.symmetryCore.mintTx({
+                            keeper: this.params.wallet.publicKey.toBase58(),
+                            rebalance_intent: intent.pubkey,
+                        });
+                        let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions });
+                        console.log("Mint:", res);
+                    }
+                    catch (e) {
+                        if (numTriesMint == 3) {
+                            console.log("Stop - mint failed:", e);
+                        }
+                    }
+                    continue;
+                }
+                let hasTokens = intent.tokens.find((token) => token.amount > 0);
+                if (hasTokens && intent.rebalance_type == "withdraw") {
+                    if (numTriesRedeemTokens >= 3) {
+                        console.log("Max retries for redeem");
+                        break;
+                    }
+                    numTriesRedeemTokens += 1;
+                    try {
+                        let tx = yield this.params.symmetryCore.redeemTokensTx({
+                            keeper: this.params.wallet.publicKey.toBase58(),
+                            rebalance_intent: intent.pubkey,
+                        });
+                        let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions });
+                        console.log("Redeem Tokens:", res);
+                    }
+                    catch (e) {
+                        if (numTriesRedeemTokens == 3) {
+                            console.log("Stop - redeem failed:", e);
+                        }
+                    }
+                    continue;
+                }
+                if (numTriesClaimBounty >= 3) {
+                    console.log("Max retries for claim bounty");
+                    break;
+                }
+                numTriesClaimBounty += 1;
+                try {
+                    let tx = yield this.params.symmetryCore.claimBountyTx({
+                        keeper: this.params.wallet.publicKey.toBase58(),
+                        rebalance_intent: intent.pubkey,
+                    });
+                    let res = yield this.params.symmetryCore.signAndSendTxPayloadBatchSequence({ txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions });
+                    console.log("Claim Bounty:", res);
+                    nextCheckTime = now + 60;
+                }
+                catch (e) {
+                    if (numTriesClaimBounty == 3) {
+                        console.log("Stop - claim bounty failed:", e);
+                    }
+                }
+            }
+            console.log("Rebalance handler finished for intent:", this.intent.formatted_data.pubkey);
+        });
+    }
+}
+exports.RebalanceHandler = RebalanceHandler;

package/dist/test.js

@@ -28,7 +28,7 @@ function testStates() {
         let sdk = new src_1.SymmetryCore({
             connection: connection,
             network: "mainnet",
-            priorityFee: 237,
+            priorityFee: 5237,
         });
         let keeperMonitor = new src_1.KeeperMonitor({
             wallet: wallet,
@@ -37,7 +37,7 @@ function testStates() {
             jupiterApiKey: jupApiKey,
             maxAllowedAccounts: 40,
             simulateTransactions: false,
-            priorityFee: 237,
+            priorityFee: 5237,
         });
         // keeperMonitor.run();
         // return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symmetry-hq/temp-v3-sdk",
-  "version": "0.0.62",
+  "version": "0.0.63",
   "description": "Symmetry V3 SDK",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",

package/src/index.ts

@@ -2417,4 +2417,7 @@ export {
     getJupTokenLedgerAndSwapInstructions,
 }
 
-export { KeeperMonitor } from './keeperMonitor';
+export {
+    KeeperMonitor,
+    RebalanceHandler,
+} from './keeperMonitor';

package/src/keeperMonitor.ts

@@ -1,4 +1,4 @@
-import { Connection, PublicKey } from "@solana/web3.js";
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
 import { Wallet } from "./txUtils";
 import { Basket, FormattedRebalanceIntent, getJupTokenLedgerAndSwapInstructions, Intent, SymmetryCore, UIRebalanceIntent } from ".";
 import { getSwapPairs } from "./states/intents/rebalanceIntent";
@@ -150,7 +150,7 @@ export class KeeperMonitor {
                     intent: intent.ownAddress!.toBase58(),
                 });
                 let res = await this.params.symmetryCore.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions});
-                console.log("Execute Basket Intent - ", pubkey, " : ", res);
+                console.log("Execute Basket Intent -", pubkey, " : ", res);
                 nextCheckTime = now + 60;
                 } catch {}
                 continue;
@@ -163,9 +163,9 @@ export class KeeperMonitor {
                 intent: intent.ownAddress!.toBase58(),
             });
             let res = await this.params.symmetryCore.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions});
-            console.log("Cancel Basket Intent - ", pubkey, " : ", res);
+            console.log("Cancel Basket Intent -", pubkey, " : ", res);
             nextCheckTime = now + 60;
-            } catch (e) { if (numTries == 4) { console.log("Stop monitoring - ", pubkey, " : ", e); } }
+            } catch (e) { if (numTries == 4) { console.log("Stop monitoring -", pubkey, " : ", e); } }
             continue;
         }
     }
@@ -176,6 +176,16 @@ export class KeeperMonitor {
         let numTriesMint = 0;
         let numTriesRedeemTokens = 0;
         let numTriesClaimBounty = 0;
+        let lastJupQuotesUpdate = 0;
+        let jupQuotes: ({
+            inMint: string,
+            outMint: string,
+            tokenLedgerInstruction: TransactionInstruction,
+            swapInstruction: TransactionInstruction,
+            addressLookupTableAddresses: PublicKey[],
+            quoteResponse: any,
+        } | undefined)[] = [];
+
         while (true) {
             let uiIntent = this.rebalanceIntents.get(pubkey);
             if (!uiIntent) break;
@@ -192,7 +202,7 @@ export class KeeperMonitor {
             if (intent.current_action == "update_prices" && intent.last_action_timestamp > now)
                 { nextCheckTime = intent.last_action_timestamp; continue; }
             if (intent.current_action == "update_prices") {
-                if (numTriesUpdatePrices >= 3) break;
+                if (numTriesUpdatePrices >= 5) break;
                 numTriesUpdatePrices += 1; try {
                 let tx = await this.params.symmetryCore.updateTokenPricesTx({
                     keeper: this.params.wallet.publicKey.toBase58(),
@@ -201,47 +211,62 @@ export class KeeperMonitor {
                 });
                 let res = await this.params.symmetryCore.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions});
                 console.log("Update Prices - ", pubkey, " : ", res);
-                } catch (e) { if (numTriesUpdatePrices == 3) { console.log("Stop monitoring - ", pubkey, " : ", e); } }
+                } catch (e) { if (numTriesUpdatePrices == 4) { console.log("Stop monitoring - ", pubkey, " : ", e); } }
+                nextCheckTime += 60;
                 continue;
             }
             if (intent.auctions[2].end_time > now) {
                 let basket = this.baskets.get(intent.basket);
                 if (!basket) continue;
-                let auction0StartTime = intent.auctions[0].start_time;
-                let auction0EndTime = intent.auctions[0].end_time;
-                let auction0MidTime = auction0StartTime + (auction0EndTime - auction0StartTime) / 2;
-    
-                let auction1StartTime = intent.auctions[1].start_time;
-                let auction1EndTime = intent.auctions[1].end_time;
-                let auction1MidTime = auction1StartTime + (auction1EndTime - auction1StartTime) / 2;
-        
-                let auction2StartTime = intent.auctions[2].start_time;
-                let auction2EndTime = intent.auctions[2].end_time;
-                let auction2MidTime = auction2StartTime + (auction2EndTime - auction2StartTime) / 2;
-                
-                if (now < auction0MidTime + 30) { nextCheckTime = auction0MidTime + 30; continue; }
-                if (now >= auction0EndTime) {
-                    if (now < auction1MidTime + 10) { nextCheckTime = auction1MidTime + 10; continue; }
-                    if (now >= auction1EndTime)
-                        if (now < auction2MidTime + 5) { nextCheckTime = auction2MidTime + 5; continue; }
-                }
+
                 let pairs = getSwapPairs(chainData, basket!);
-                for (let pair of pairs) try {
+
+                if (Date.now() / 1000 > lastJupQuotesUpdate + 60) {
+                    lastJupQuotesUpdate = Date.now() / 1000;
+                    jupQuotes = [];
+                    for (let pair of pairs) {
+                        if (pair.value < 0.005) continue;
+                        if (this.params.network == "mainnet") try {
+                        let res = await getJupTokenLedgerAndSwapInstructions({
+                                keeper: this.params.wallet.publicKey,
+                                basketMintIn: new PublicKey(pair.inMint),
+                                basketMintOut: new PublicKey(pair.outMint),
+                                basketAmountIn: pair.inAmount,
+                                basketAmountOut: pair.outAmount,
+                                swapMode: "ioc",
+                                apiKey: this.params.jupiterApiKey,
+                                maxJupAccounts: this.params.maxAllowedAccounts,
+                            });
+                            jupQuotes.push({
+                                ...res,
+                                inMint: pair.inMint,
+                                outMint: pair.outMint,
+                            });
+                            console.log("Fetch new Jup Quote:", pair.inMint, pair.outMint);
+                            console.log(pair, "Jup Quote:", parseFloat(res.quoteResponse?.outAmount ?? 0), "Requested In:", pair.inAmount);
+                        } catch {}
+                    }
+                }
+
+                for (let index = 0; index < pairs.length; index++) try {
+                    let pair = pairs[index];
+                    let jupIndex = jupQuotes.findIndex(q => q && q.inMint == pair.inMint && q.outMint == pair.outMint);
+                    let quote = jupIndex >= 0 ? jupQuotes[jupIndex] : undefined;
+                    if (!quote && this.params.network == "mainnet") continue;
                     if (pair.value < 0.005) continue;
-                    await this.delay(1000);
-                    let { tokenLedgerInstruction, swapInstruction, addressLookupTableAddresses , quoteResponse} = this.params.network == "mainnet" ?
-                        await getJupTokenLedgerAndSwapInstructions({
-                            keeper: this.params.wallet.publicKey,
-                            basketMintIn: new PublicKey(pair.inMint),
-                            basketMintOut: new PublicKey(pair.outMint),
-                            basketAmountIn: pair.inAmount,
-                            basketAmountOut: pair.outAmount,
-                            swapMode: "ioc",
-                            apiKey: this.params.jupiterApiKey,
-                            maxJupAccounts: this.params.maxAllowedAccounts,
-                        }) : { tokenLedgerInstruction: undefined, swapInstruction: undefined, addressLookupTableAddresses: [], quoteResponse: undefined };
+                    
+                    let tokenLedgerInstruction = quote?.tokenLedgerInstruction;
+                    let swapInstruction = quote?.swapInstruction;
+                    let addressLookupTableAddresses = quote?.addressLookupTableAddresses ?? [];
+                    let quoteResponse = quote?.quoteResponse;
+
+                    if (this.params.network == "mainnet" && !quoteResponse) continue;
                     console.log(pair, "Jup Quote:", parseFloat(quoteResponse?.outAmount ?? 0), "Requested In:", pair.inAmount);
-                    if (this.params.network == "devnet" || parseFloat(quoteResponse?.outAmount ?? 0) > pair.inAmount) {
+                    
+                    let quoteResponseAmount = parseFloat(quoteResponse?.outAmount ?? 0);
+                    if (this.params.network == "mainnet" && quoteResponseAmount * 1.005 <= pair.inAmount)
+                        continue;
+
                     try {
                     let tx = await this.params.symmetryCore.flashSwapTx({
                         keeper: this.params.wallet.publicKey.toBase58(),
@@ -258,14 +283,15 @@ export class KeeperMonitor {
                     });
                     let res = await this.params.symmetryCore.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions});
                     console.log("Flash Swap - ", pubkey, " : ", res);
+                    jupQuotes = jupQuotes.filter(q => q && (q.inMint != pair.inMint || q.outMint != pair.outMint));
                     } catch {}
-                    }
                 } catch { }
                 nextCheckTime = (Date.now() / 1000) + 8;
                 continue;
             }
             if (intent.rebalance_type == "deposit") {
                 if (numTriesMint >= 3) break;
+                lastJupQuotesUpdate = 0;
                 numTriesMint += 1; try {
                 let tx = await this.params.symmetryCore.mintTx({
                     keeper: this.params.wallet.publicKey.toBase58(),
@@ -303,3 +329,257 @@ export class KeeperMonitor {
         }
     }
 }
+
+export class RebalanceHandler {
+    private params: {
+        wallet: Wallet,
+        connection: Connection,
+        symmetryCore: SymmetryCore,
+        network: "devnet" | "mainnet",
+        jupiterApiKey: string;
+        maxAllowedAccounts: number;
+        simulateTransactions: boolean;
+    }
+
+    private intent: UIRebalanceIntent;
+    private basket: Basket;
+
+    constructor(params: {
+        intent: UIRebalanceIntent,
+        basket: Basket,
+        wallet: Wallet,
+        connection: Connection,
+        network: "devnet" | "mainnet",
+        jupiterApiKey: string,
+        maxAllowedAccounts: number,
+        priorityFee?: number,
+        simulateTransactions?: boolean,
+    }) {
+        this.params = {
+            wallet: params.wallet,
+            connection: params.connection,
+            symmetryCore: new SymmetryCore({
+                connection: params.connection,
+                network: params.network,
+                priorityFee: params.priorityFee ?? PRIORITY_FEE,
+            }),
+            network: params.network,
+            jupiterApiKey: params.jupiterApiKey,
+            maxAllowedAccounts: params.maxAllowedAccounts,
+            simulateTransactions: params.simulateTransactions ?? false,
+        };
+        this.intent = params.intent;
+        this.basket = params.basket;
+    }
+
+    delay = async (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+    async refresh() {
+        this.intent = await this.params.symmetryCore.fetchRebalanceIntent(this.intent.formatted_data.pubkey);
+        this.basket = await this.params.symmetryCore.fetchBasket(this.intent.formatted_data.basket);
+    }
+
+    static async run(params: {
+        intentPubkey: PublicKey,
+        wallet: Wallet,
+        connection: Connection,
+        network: "devnet" | "mainnet",
+        jupiterApiKey: string,
+        maxAllowedAccounts: number,
+        priorityFee?: number,
+        simulateTransactions?: boolean,
+    }) {
+        let symmetryCore = new SymmetryCore({
+            connection: params.connection,
+            network: params.network,
+            priorityFee: params.priorityFee ?? PRIORITY_FEE,
+        });
+        let intent = await symmetryCore.fetchRebalanceIntent(params.intentPubkey.toBase58());
+        let basket = await symmetryCore.fetchBasket(intent.formatted_data.basket);
+        let handler = new RebalanceHandler({
+            intent, basket,
+            wallet: params.wallet,
+            connection: params.connection,
+            network: params.network,
+            jupiterApiKey: params.jupiterApiKey,
+            maxAllowedAccounts: params.maxAllowedAccounts,
+            simulateTransactions: params.simulateTransactions,
+        });
+        handler.execute();
+        for (let i = 0; i < 20; i++) {
+            await handler.delay(15 * 1000);
+            try { await handler.refresh(); }
+            catch (e) { handler.intent = undefined as any; break;}
+        }
+    }
+
+    private async execute() {
+        console.log("Starting rebalance handler for intent:", this.intent.formatted_data.pubkey);
+        let nextCheckTime = 0;
+        let numTriesUpdatePrices = 0;
+        let numTriesMint = 0;
+        let numTriesRedeemTokens = 0;
+        let numTriesClaimBounty = 0;
+        let rebalancePairs: {
+            inMint: string,
+            outMint: string,
+            inAmount: number,
+            outAmount: number,
+            value: number,
+        }[] = [];
+        let lastJupQuotesUpdate = 0;
+        let jupQuotes: ({
+            inMint: string,
+            outMint: string,
+            tokenLedgerInstruction: TransactionInstruction,
+            swapInstruction: TransactionInstruction,
+            addressLookupTableAddresses: PublicKey[],
+            quoteResponse: any, 
+        }|undefined)[] = [];
+
+        while (true) {
+            if (!this.intent) break;
+            let intent = this.intent.formatted_data;
+            let chainData = this.intent.chain_data;
+            let now = Date.now() / 1000;
+
+            if (now < nextCheckTime) {
+                await this.delay(Math.min(30 * 1000, Math.max(0, nextCheckTime - now + 0.2) * 1000));
+                continue;
+            }
+            nextCheckTime = now + 5;
+
+            if (intent.current_action == "not_active") { console.log("Intent not active, stopping"); break; }
+            if (intent.current_action == "deposit_tokens") { console.log("Waiting for deposit..."); continue; }
+
+            if (intent.current_action == "update_prices" && intent.last_action_timestamp > now)
+                { nextCheckTime = intent.last_action_timestamp; continue; }
+
+            if (intent.current_action == "update_prices") {
+                if (numTriesUpdatePrices >= 3) { console.log("Max retries for update_prices"); break; }
+                numTriesUpdatePrices += 1; try {
+                let tx = await this.params.symmetryCore.updateTokenPricesTx({
+                    keeper: this.params.wallet.publicKey.toBase58(),
+                    basket: intent.basket,
+                    rebalance_intent: intent.pubkey,
+                });
+                let res = await this.params.symmetryCore.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions});
+                console.log("Update Prices:", res);
+                } catch (e) { if (numTriesUpdatePrices == 3) { console.log("Stop - update prices failed:", e); } }
+                continue;
+            }
+
+            if (intent.auctions[2].end_time > now) {
+
+                rebalancePairs = getSwapPairs(chainData, this.basket);
+
+                if (Date.now() / 1000 > lastJupQuotesUpdate + 60) {
+                    let usedValue: Map<string, number> = new Map();
+                    jupQuotes = [];
+                    for (let pair of rebalancePairs) {
+                        let inValue = usedValue.get(pair.inMint) ?? 0;
+                        let outValue = usedValue.get(pair.outMint) ?? 0;
+                        let swapValue = Math.min(pair.value - inValue, pair.value - outValue);
+                        if (swapValue < 0.005) {
+                            jupQuotes.push(undefined);
+                            continue;
+                        }
+                        usedValue.set(pair.inMint, inValue + swapValue);
+                        usedValue.set(pair.outMint, outValue + swapValue);
+                        let res = undefined;
+                        if (this.params.network == "mainnet") try {
+                            res = {
+                                ...(await getJupTokenLedgerAndSwapInstructions({
+                                    keeper: this.params.wallet.publicKey,
+                                    basketMintIn: new PublicKey(pair.inMint),
+                                    basketMintOut: new PublicKey(pair.outMint),
+                                    basketAmountIn: pair.inAmount,
+                                    basketAmountOut: pair.outAmount,
+                                    swapMode: "ioc",
+                                    apiKey: this.params.jupiterApiKey,
+                                    maxJupAccounts: this.params.maxAllowedAccounts,
+                                })),
+                                inMint: pair.inMint,
+                                outMint: pair.outMint,
+                            };
+                        } catch {};
+                        jupQuotes.push(res);
+                    }
+                }
+
+                for (let index = 0; index < rebalancePairs.length; index++) try {
+                    let pair = rebalancePairs[index];
+                    let quote = jupQuotes.find(q => q && q.inMint == pair.inMint && q.outMint == pair.outMint);
+                    if (!quote) continue;
+                    if (pair.value < 0.005) continue;
+                    let { tokenLedgerInstruction, swapInstruction, addressLookupTableAddresses, quoteResponse } = quote;
+                    if (!quoteResponse) continue;
+                    console.log(pair, "Jup Quote:", parseFloat(quoteResponse.outAmount), "Requested In:", pair.inAmount);
+                    if (parseFloat(quoteResponse.outAmount) <= pair.inAmount && this.params.network == "mainnet")
+                        continue;
+                    try {
+                    let tx = await this.params.symmetryCore.flashSwapTx({
+                        keeper: this.params.wallet.publicKey.toBase58(),
+                        basket: this.basket.ownAddress.toBase58(),
+                        rebalance_intent: intent.pubkey,
+                        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 = await this.params.symmetryCore.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions});
+                    console.log("Flash Swap:", res);
+                    rebalancePairs = rebalancePairs.splice(index, 1);
+                    index -= 1;
+                    } catch {}
+                } catch { }
+                nextCheckTime = (Date.now() / 1000) + 10;
+                continue;
+            }
+            if (intent.rebalance_type == "deposit") {
+                if (numTriesMint >= 3) break;
+                lastJupQuotesUpdate = 0;
+                numTriesMint += 1; try {
+                let tx = await this.params.symmetryCore.mintTx({
+                    keeper: this.params.wallet.publicKey.toBase58(),
+                    rebalance_intent: intent.pubkey,
+                });
+                let res = await this.params.symmetryCore.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions});
+                console.log("Mint -", res);
+                } catch (e) { if (numTriesMint == 3) { console.log("Stop monitoring -", e); } }
+                continue;
+            }
+            let hasTokens = intent.tokens.find(token => token.amount > 0);
+            if (hasTokens && intent.rebalance_type == "withdraw") {
+                if (numTriesRedeemTokens >= 3) break;
+                numTriesRedeemTokens += 1; try {
+                let tx = await this.params.symmetryCore.redeemTokensTx({
+                    keeper: this.params.wallet.publicKey.toBase58(),
+                    rebalance_intent: intent.pubkey,
+                });
+                let res = await this.params.symmetryCore.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions});
+                console.log("Redeem Tokens -", res);
+                } catch (e) { if (numTriesRedeemTokens == 3) { console.log("Stop monitoring -", e); } }
+                continue;
+            }
+            if (numTriesClaimBounty >= 3) break;
+            numTriesClaimBounty += 1; try {
+            let tx = await this.params.symmetryCore.claimBountyTx({
+                keeper: this.params.wallet.publicKey.toBase58(),
+                rebalance_intent: intent.pubkey,
+            });
+            let res = await this.params.symmetryCore.signAndSendTxPayloadBatchSequence({txPayloadBatchSequence: tx, wallet: this.params.wallet, simulateTransactions: this.params.simulateTransactions});
+            console.log("Claim Bounty -", res);
+            nextCheckTime = now + 60;
+            } catch (e) { if (numTriesClaimBounty == 3) { console.log("Stop monitoring -", e); } }
+            continue;
+        }
+
+    }
+}
+
+

package/test.ts

@@ -13,7 +13,6 @@ import { getSwapPairs } from "./src/states/intents/rebalanceIntent";
 let kp = Array.from(Keypair.generate().secretKey);
 
 let jupApiKey = "";
-
 let connection = new Connection("https://api.devnet.solana.com");
 
 async function testStates() {
@@ -24,7 +23,7 @@ async function testStates() {
     let sdk = new SymmetryCore({
         connection: connection,
         network: "mainnet",
-        priorityFee: 237,
+        priorityFee: 5237,
     });
     let keeperMonitor = new KeeperMonitor({
         wallet: wallet,
@@ -33,7 +32,7 @@ async function testStates() {
         jupiterApiKey: jupApiKey,
         maxAllowedAccounts: 40,
         simulateTransactions: false,
-        priorityFee: 237,
+        priorityFee: 5237,
     });
     // keeperMonitor.run();
     // return;