@symmetry-hq/sdk 1.0.1

package/dist/src/keeperMonitor.js

@@ -0,0 +1,624 @@
+"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 = exports.KeeperMonitor = 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 KeeperMonitor {
+    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,
+        };
+        //@ts-ignore
+        this.globalConfig = {};
+        this.intents = new Map();
+        this.rebalanceIntents = new Map();
+        this.baskets = new Map();
+    }
+    update() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let baskets;
+            try {
+                baskets = yield this.params.symmetryCore.fetchAllBaskets();
+            }
+            catch (e) {
+                console.log("Error fetching baskets:", e);
+            }
+            if (baskets) {
+                for (let basket of baskets)
+                    this.baskets.set(basket.ownAddress.toBase58(), basket);
+            }
+            let intents;
+            try {
+                intents = yield this.params.symmetryCore.fetchAllIntents();
+            }
+            catch (e) {
+                console.log("Error fetching intents:", e);
+            }
+            if (intents) {
+                for (let intent of intents) {
+                    let oldInstance = this.intents.get(intent.ownAddress.toBase58());
+                    this.intents.set(intent.ownAddress.toBase58(), intent);
+                    let isMonitored = oldInstance ? true : false;
+                    if (!isMonitored) {
+                        console.log("New Intent:", intent.ownAddress.toBase58());
+                        this.monitorIntent(intent.ownAddress.toBase58());
+                    }
+                }
+                for (let intent of this.intents.values()) {
+                    if (!intents.find(i => i.ownAddress.equals(intent.ownAddress))) {
+                        this.intents.delete(intent.ownAddress.toBase58());
+                        console.log("Intent deleted:", intent.ownAddress.toBase58());
+                    }
+                }
+            }
+            let rebalanceIntents;
+            try {
+                rebalanceIntents = yield this.params.symmetryCore.fetchAllRebalanceIntents();
+            }
+            catch (e) {
+                console.log("Error fetching rebalance intents:", e);
+            }
+            if (rebalanceIntents) {
+                for (let rebalanceIntent of rebalanceIntents) {
+                    let oldInstance = this.rebalanceIntents.get(rebalanceIntent.formatted_data.pubkey);
+                    this.rebalanceIntents.set(rebalanceIntent.formatted_data.pubkey, rebalanceIntent);
+                    let isMonitored = oldInstance && (oldInstance.formatted_data.current_action != "deposit_tokens" &&
+                        oldInstance.formatted_data.current_action != "not_active");
+                    let shouldMonitor = rebalanceIntent && (rebalanceIntent.formatted_data.current_action != "deposit_tokens" &&
+                        rebalanceIntent.formatted_data.current_action != "not_active");
+                    if (!isMonitored && shouldMonitor) {
+                        console.log("New Rebalance Intent:", rebalanceIntent.formatted_data.pubkey);
+                        this.monitorRebalanceIntent(rebalanceIntent.formatted_data.pubkey);
+                    }
+                }
+                for (let rebalanceIntent of this.rebalanceIntents.values()) {
+                    if (!rebalanceIntents.find(i => i.formatted_data.pubkey == rebalanceIntent.formatted_data.pubkey)) {
+                        this.rebalanceIntents.delete(rebalanceIntent.formatted_data.pubkey);
+                        console.log("Rebalance Intent deleted:", rebalanceIntent.formatted_data.pubkey);
+                    }
+                }
+            }
+            console.log("Baskets: ", (_a = this.baskets) === null || _a === void 0 ? void 0 : _a.size, " Intents: ", this.intents.size, " Rebalance intents: ", this.rebalanceIntents.size);
+        });
+    }
+    run(runTime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("Starting keeper monitor", this.params.wallet.publicKey.toBase58());
+            if (!runTime)
+                runTime = 10 * 60;
+            if (runTime < 60)
+                runTime = 60;
+            let startTime = Date.now() / 1000;
+            while (true) {
+                let now = Date.now() / 1000;
+                if (now + 45 > startTime + runTime)
+                    break;
+                yield this.update();
+                yield this.delay(Math.min(30 * 1000, Math.max(0, startTime + runTime - now - 45 + 0.2) * 1000));
+            }
+            this.baskets = new Map();
+            this.intents = new Map();
+            this.rebalanceIntents = new Map();
+            yield this.delay(45 * 1000);
+        });
+    }
+    monitorIntent(pubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let nextCheckTime = 0;
+            let numTries = 0;
+            while (true) {
+                let intent = this.intents.get(pubkey);
+                if (!intent)
+                    break;
+                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.formatted.activation_timestamp > now) {
+                    nextCheckTime = intent.formatted.activation_timestamp;
+                    continue;
+                }
+                if (now < intent.formatted.expiration_timestamp && numTries >= 2) {
+                    nextCheckTime = intent.formatted.expiration_timestamp;
+                    continue;
+                }
+                if (now < intent.formatted.expiration_timestamp) {
+                    numTries += 1;
+                    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, simulateTransactions: this.params.simulateTransactions });
+                        console.log("Execute Basket Intent - ", pubkey, " : ", res);
+                        nextCheckTime = now + 60;
+                    }
+                    catch (_a) { }
+                    continue;
+                }
+                numTries = Math.max(2, numTries);
+                if (numTries >= 4)
+                    break;
+                numTries += 1;
+                try {
+                    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, simulateTransactions: this.params.simulateTransactions });
+                    console.log("Cancel Basket Intent - ", pubkey, " : ", res);
+                    nextCheckTime = now + 60;
+                }
+                catch (e) {
+                    if (numTries == 4) {
+                        console.log("Stop monitoring - ", pubkey, " : ", e);
+                    }
+                }
+                continue;
+            }
+        });
+    }
+    monitorRebalanceIntent(pubkey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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)
+                    break;
+                let intent = uiIntent.formatted_data;
+                let chainData = uiIntent.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")
+                    continue;
+                if (intent.current_action == "deposit_tokens")
+                    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 >= 5)
+                        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 - ", pubkey, " : ", res);
+                    }
+                    catch (e) {
+                        if (numTriesUpdatePrices == 5) {
+                            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 pairs = (0, rebalanceIntent_1.getSwapPairs)(chainData, basket);
+                    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 = 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,
+                                    });
+                                    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 (_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 (_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({
+                            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 - ", pubkey, " : ", res);
+                    }
+                    catch (e) {
+                        if (numTriesMint == 3) {
+                            console.log("Stop monitoring - ", pubkey, " : ", 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 - ", pubkey, " : ", 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 - ", pubkey, " : ", res);
+                    nextCheckTime = now + 60;
+                }
+                catch (e) {
+                    if (numTriesClaimBounty == 3) {
+                        console.log("Stop monitoring - ", pubkey, " : ", e);
+                    }
+                }
+                continue;
+            }
+        });
+    }
+}
+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 >= 5) {
+                        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 == 5) {
+                            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;