@symmetry-hq/sdk 1.0.1 → 1.0.2

package/dist/src/index.d.ts

@@ -7,7 +7,7 @@ import { FormattedOraclePrice, FormattedRebalanceAction, FormattedRebalanceInten
 import { FormattedOracleType } from './layouts/oracle';
 import { BasketFilter } from './states/basket';
 import { IntentFilter } from './states/intents/intent';
-import { RebalanceIntentFilter } from './states/intents/rebalanceIntent';
+import { getSwapPairs, isRebalanceRequired, RebalanceIntentFilter } from './states/intents/rebalanceIntent';
 import { WithdrawBasketFeesFilter } from './states/withdrawBasketFees';
 import { BasketCreationTx, TxPayloadBatchSequence, VersionedTxs, Wallet } from './txUtils';
 export declare class SymmetryCore {
@@ -800,5 +800,5 @@ export { FormattedGlobalConfig, FormattedIntentStatus, FormattedTaskType, Format
 export { FormattedRebalanceType, FormattedRebalanceAction, FormattedOraclePrice, FormattedTokenAuction, FormattedTaskCompletion, FormattedRebalanceIntent, UIRebalanceIntent, DepositData, PriceUpdatesData, AuctionData, MintData, RedeemData, ClaimBountyData, };
 export { FormattedCreatorSettings, FormattedManagersSettings, FormattedFeeSettings, FormattedScheduleSettings, FormattedAutomationSettings, FormattedLpSettings, FormattedMetadataSettings, FormattedDepositsSettings, FormattedForceRebalanceSettings, FormattedCustomRebalanceSettings, FormattedAddTokenSettings, FormattedUpdateWeightsSettings, FormattedMakeDirectSwapSettings, FormattedAccumulatedFees, FormattedLookupTables, FormattedAsset, FormattedOracleSettings, FormattedOracleAggregator, FormattedOracle, FormattedOracleType, FormattedBasket, };
 export { EditCreatorSettings, EditManagerSettings, EditFeeSettings, EditScheduleSettings, EditAutomationSettings, EditLpSettings, EditMetadataSettings, EditDepositsSettings, EditForceRebalanceSettings, EditCustomRebalanceSettings, EditAddTokenSettings, EditUpdateWeightsSettings, EditMakeDirectSwapSettings, AddOrEditTokenInput, OracleInput, UpdateWeightsInput, MakeDirectSwapInput, Settings, TaskContext, TaskType, };
-export { getJupTokenLedgerAndSwapInstructions, };
+export { getJupTokenLedgerAndSwapInstructions, getSwapPairs, isRebalanceRequired, };
 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.RebalanceHandler = exports.KeeperMonitor = exports.getJupTokenLedgerAndSwapInstructions = exports.TaskType = exports.SymmetryCore = void 0;
+exports.RebalanceHandler = exports.KeeperMonitor = exports.isRebalanceRequired = exports.getSwapPairs = 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");
@@ -42,6 +42,8 @@ const basket_1 = require("./states/basket");
 const config_1 = require("./states/config");
 const intent_2 = require("./states/intents/intent");
 const rebalanceIntent_3 = require("./states/intents/rebalanceIntent");
+Object.defineProperty(exports, "getSwapPairs", { enumerable: true, get: function () { return rebalanceIntent_3.getSwapPairs; } });
+Object.defineProperty(exports, "isRebalanceRequired", { enumerable: true, get: function () { return rebalanceIntent_3.isRebalanceRequired; } });
 const withdrawBasketFees_1 = require("./states/withdrawBasketFees");
 const pythOracle_1 = require("./states/oracles/pythOracle");
 const txUtils_1 = require("./txUtils");

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/src/states/intents/rebalanceIntent.d.ts

@@ -40,3 +40,4 @@ export declare function getSwapPairs(rebalanceIntent: RebalanceIntent, basket: B
     outAmount: number;
     value: number;
 }[];
+export declare function isRebalanceRequired(rebalanceIntent: RebalanceIntent, basket: Basket): boolean;

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

@@ -18,6 +18,7 @@ exports.fetchRebalanceIntent = fetchRebalanceIntent;
 exports.fetchRebalanceIntentsMultiple = fetchRebalanceIntentsMultiple;
 exports.fetchRebalanceIntents = fetchRebalanceIntents;
 exports.getSwapPairs = getSwapPairs;
+exports.isRebalanceRequired = isRebalanceRequired;
 const web3_js_1 = require("@solana/web3.js");
 const rebalanceIntent_1 = require("../../layouts/intents/rebalanceIntent");
 const constants_1 = require("../../constants");
@@ -401,6 +402,33 @@ class RebalanceIntentRustClass {
                 return i;
         return undefined;
     }
+    isRebalanceRequired(basket) {
+        let requiresRebalance = false;
+        for (let i = 0; i < basket.numTokens; i++) {
+            let tokenAuction = this.self.tokens[i];
+            if (tokenAuction.mint.equals(this.self.bounty.bountyMint)) {
+                continue;
+            }
+            let oraclePrice = tokenAuction.price;
+            let tokenPrice = oraclePrice.price;
+            let tokenValue = (0, fraction_1.fractionMul)(tokenPrice, { high: new bn_js_1.default(tokenAuction.amount), low: new bn_js_1.default(0) });
+            let targetValue = (0, fraction_1.fractionMul)(tokenPrice, { high: new bn_js_1.default(tokenAuction.targetAmount), low: new bn_js_1.default(0) });
+            let [valueDiff, maxValue] = (tokenValue < targetValue) ?
+                [(0, fraction_1.fractionSub)(targetValue, tokenValue), targetValue] :
+                [(0, fraction_1.fractionSub)(tokenValue, targetValue), tokenValue];
+            if (valueDiff.high.eq(new bn_js_1.default(0)) && valueDiff.low.eq(new bn_js_1.default(0))) {
+                continue;
+            }
+            let relBps = (0, fraction_1.fractionDiv)((0, fraction_1.fractionMul)(valueDiff, { high: new bn_js_1.default(constants_1.HUNDRED_PERCENT_BPS), low: new bn_js_1.default(0) }), maxValue);
+            let absBps = (0, fraction_1.fractionDiv)((0, fraction_1.fractionMul)(valueDiff, { high: new bn_js_1.default(constants_1.HUNDRED_PERCENT_BPS), low: new bn_js_1.default(0) }), this.self.initialTvl);
+            let requiredRelBps = { high: new bn_js_1.default(basket.settings.automation.rebalanceActivationThresholdRelBps), low: new bn_js_1.default(0) };
+            let requiredAbsBps = { high: new bn_js_1.default(basket.settings.automation.rebalanceActivationThresholdAbsBps), low: new bn_js_1.default(0) };
+            if ((0, fraction_1.fractionGte)(relBps, requiredRelBps) && (0, fraction_1.fractionGte)(absBps, requiredAbsBps)) {
+                requiresRebalance = true;
+            }
+        }
+        return requiresRebalance;
+    }
     getSelfTvl() {
         let selfTvl = { high: new bn_js_1.default(0), low: new bn_js_1.default(0) };
         for (let i = 0; i < this.self.priceUpdateTasks.length; i++) {
@@ -678,3 +706,23 @@ function getSwapPairs(rebalanceIntent, basket) {
     allPairs.sort((a, b) => b.value - a.value);
     return allPairs;
 }
+function isRebalanceRequired(rebalanceIntent, basket) {
+    if (basket.settings.automation.allowAutomation !== 1)
+        return false;
+    let cycleTimestamp = new bn_js_1.default(0);
+    let currentTimestamp = new bn_js_1.default(Math.floor(Date.now() / 1000));
+    if (basket.settings.schedule.cycleStartTime.gt(currentTimestamp))
+        return false;
+    let timeSinceCycleStart = currentTimestamp.sub(basket.settings.schedule.cycleStartTime);
+    if (basket.settings.schedule.cycleDuration != new bn_js_1.default(0))
+        cycleTimestamp = timeSinceCycleStart.mod(basket.settings.schedule.cycleDuration);
+    if (!(cycleTimestamp.gte(basket.settings.schedule.automationStart) &&
+        cycleTimestamp.lt(basket.settings.schedule.automationEnd)))
+        return false;
+    let nextRebalanceTimestamp = basket.settings.lastAutomationExecutionTimestamp
+        .add(basket.settings.automation.rebalanceActivationCooldown);
+    if (nextRebalanceTimestamp.gte(currentTimestamp))
+        return false;
+    let rebalanceIntentRustClass = new RebalanceIntentRustClass(rebalanceIntent);
+    return rebalanceIntentRustClass.isRebalanceRequired(basket);
+}

package/package.json

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

package/src/index.ts

@@ -76,7 +76,7 @@ import {
 } from './states/intents/intent';
 import {
     computeRebalanceIntentBountyAmount, fetchRebalanceIntent, fetchRebalanceIntents,
-    fetchRebalanceIntentsMultiple, RebalanceIntentFilter
+    fetchRebalanceIntentsMultiple, getSwapPairs, isRebalanceRequired, RebalanceIntentFilter
 } from './states/intents/rebalanceIntent';
 import {
     fetchWithdrawBasketFees, fetchWithdrawBasketFeesMultiple, fetchWithdrawBasketFeesList, WithdrawBasketFeesFilter
@@ -2423,6 +2423,8 @@ export {
 
 export {
     getJupTokenLedgerAndSwapInstructions,
+    getSwapPairs,
+    isRebalanceRequired,
 }
 
 export {

package/src/states/intents/rebalanceIntent.ts

@@ -2,7 +2,7 @@ import { Connection, GetProgramAccountsResponse, PublicKey } from "@solana/web3.
 import { AuctionData, AuctionTimestamps, ClaimBountyData, DepositData, FormattedRebalanceIntent, MintData, PriceUpdatesData, REBALANCE_ACTION_STRINGS, REBALANCE_TYPE_STRINGS, RebalanceAction, RebalanceIntent, RebalanceIntentLayout, RebalanceType, RedeemData, TokenAuction, UIRebalanceIntent } from "../../layouts/intents/rebalanceIntent";
 import { GetProgramAccountsFilter } from "@solana/web3.js";
 import { BASKETS_V3_PROGRAM_ID, HUNDRED_PERCENT_BPS, MAX_SUPPORTED_TOKENS_PER_BASKET, MAX_TRANSFER_TOKENS } from "../../constants";
-import { Fraction, fractionAdd, fractionDiv, fractionLt, fractionLte, fractionMul, fractionRoundDown, fractionRoundUp, fractionSub, fractionToDecimal } from "../../layouts/fraction";
+import { Fraction, fractionAdd, fractionDiv, fractionGte, fractionLt, fractionLte, fractionMul, fractionRoundDown, fractionRoundUp, fractionSub, fractionToDecimal } from "../../layouts/fraction";
 import { getMultipleAccountsInfoBatched } from "../../txUtils";
 import BN from "bn.js";
 import { Basket, FormattedBasket } from "../../layouts/basket";
@@ -408,6 +408,34 @@ class RebalanceIntentRustClass {
         return undefined;
     }
 
+    isRebalanceRequired(basket: Basket): boolean {
+        let requiresRebalance = false;
+        for (let i = 0; i < basket.numTokens; i++) {
+            let tokenAuction = this.self.tokens[i];
+            if (tokenAuction.mint.equals(this.self.bounty.bountyMint)) {
+                continue;
+            }
+            let oraclePrice = tokenAuction.price;
+            let tokenPrice = oraclePrice.price;
+            let tokenValue = fractionMul(tokenPrice, { high: new BN(tokenAuction.amount), low: new BN(0) });
+            let targetValue = fractionMul(tokenPrice, { high: new BN(tokenAuction.targetAmount), low: new BN(0) });
+            let [valueDiff, maxValue] = (tokenValue < targetValue) ?
+                [fractionSub(targetValue, tokenValue), targetValue] :
+                [fractionSub(tokenValue, targetValue), tokenValue];
+            if (valueDiff.high.eq(new BN(0)) && valueDiff.low.eq(new BN(0))) {
+                continue;
+            }
+            let relBps = fractionDiv(fractionMul(valueDiff, { high: new BN(HUNDRED_PERCENT_BPS), low: new BN(0) }), maxValue);
+            let absBps = fractionDiv(fractionMul(valueDiff, { high: new BN(HUNDRED_PERCENT_BPS), low: new BN(0) }), this.self.initialTvl);
+            let requiredRelBps = { high: new BN(basket.settings.automation.rebalanceActivationThresholdRelBps), low: new BN(0) };
+            let requiredAbsBps = { high: new BN(basket.settings.automation.rebalanceActivationThresholdAbsBps), low: new BN(0) };
+            if (fractionGte(relBps, requiredRelBps) && fractionGte(absBps, requiredAbsBps)) {
+                requiresRebalance = true;
+            }
+        }
+        return requiresRebalance;
+    }
+
     getSelfTvl(): Fraction {
         let selfTvl = { high: new BN(0), low: new BN(0) };
         for (let i = 0; i < this.self.priceUpdateTasks.length; i++) {
@@ -749,3 +777,28 @@ export function getSwapPairs(
     allPairs.sort((a, b) => b.value - a.value);
     return allPairs;
 }
+
+export function isRebalanceRequired(
+    rebalanceIntent: RebalanceIntent,
+    basket: Basket
+): boolean {
+    if (basket.settings.automation.allowAutomation !== 1) return false;
+    let cycleTimestamp = new BN(0);
+    let currentTimestamp = new BN(Math.floor(Date.now() / 1000));
+    if (basket.settings.schedule.cycleStartTime.gt(currentTimestamp))
+        return false;
+    let timeSinceCycleStart = currentTimestamp.sub(basket.settings.schedule.cycleStartTime);
+    if (basket.settings.schedule.cycleDuration != new BN(0))
+        cycleTimestamp = timeSinceCycleStart.mod(basket.settings.schedule.cycleDuration);
+    if (!(
+        cycleTimestamp.gte(basket.settings.schedule.automationStart) &&
+        cycleTimestamp.lt(basket.settings.schedule.automationEnd)
+    ))
+        return false;
+    let nextRebalanceTimestamp = basket.settings.lastAutomationExecutionTimestamp
+        .add(basket.settings.automation.rebalanceActivationCooldown);
+    if (nextRebalanceTimestamp.gte(currentTimestamp))
+        return false;
+    let rebalanceIntentRustClass = new RebalanceIntentRustClass(rebalanceIntent);
+    return rebalanceIntentRustClass.isRebalanceRequired(basket);
+}

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

@@ -1,11 +0,0 @@
-import { BN } from '@coral-xyz/anchor';
-import { PublicKey, TransactionInstruction } from '@solana/web3.js';
-export declare function rebalanceSwapIx(params: {
-    keeper: PublicKey;
-    basket: PublicKey;
-    mintFrom: PublicKey;
-    mintTo: PublicKey;
-    amountIn: BN;
-    amountOut: BN;
-    mode: number;
-}): TransactionInstruction;

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

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rebalanceSwapIx = rebalanceSwapIx;
-const spl_token_1 = require("@solana/spl-token");
-const web3_js_1 = require("@solana/web3.js");
-const constants_1 = require("../../constants");
-const pda_1 = require("../pda");
-const REBALANCE_SWAP_DISCRIMINATOR = Buffer.from([101, 122, 61, 201, 21, 165, 177, 213]);
-function rebalanceSwapIx(params) {
-    const { keeper, basket, mintFrom, mintTo, amountIn, amountOut, mode } = params;
-    let rebalanceIntent = (0, pda_1.getRebalanceIntentPda)(basket, keeper); // TODO: incorrect. Pass intent as func param
-    let keeperFromATA = (0, pda_1.getAta)(keeper, mintFrom);
-    let keeperToATA = (0, pda_1.getAta)(keeper, mintTo);
-    let basketFromATA = (0, pda_1.getAta)(basket, mintFrom);
-    let basketToATA = (0, pda_1.getAta)(basket, mintTo);
-    const keys = [
-        { pubkey: params.keeper, isWritable: true, isSigner: true },
-        { pubkey: params.basket, isWritable: true, isSigner: false },
-        { pubkey: rebalanceIntent, isWritable: true, isSigner: false },
-        { pubkey: params.mintFrom, isWritable: false, isSigner: false },
-        { pubkey: params.mintTo, isWritable: false, isSigner: false },
-        { pubkey: keeperFromATA, isWritable: true, isSigner: false },
-        { pubkey: keeperToATA, isWritable: true, isSigner: false },
-        { pubkey: basketFromATA, isWritable: true, isSigner: false },
-        { pubkey: basketToATA, isWritable: true, isSigner: false },
-        { pubkey: (0, pda_1.getGlobalConfigPda)(), isWritable: false, isSigner: false },
-        { pubkey: web3_js_1.SystemProgram.programId, isWritable: false, isSigner: false },
-        { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
-        { pubkey: spl_token_1.TOKEN_2022_PROGRAM_ID, isWritable: false, isSigner: false },
-        { pubkey: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
-    ];
-    const discriminator = REBALANCE_SWAP_DISCRIMINATOR;
-    const amountInBuffer = Buffer.from(amountIn.toArray("le", 8));
-    const amountOutBuffer = Buffer.from(amountOut.toArray("le", 8));
-    const modeBuffer = Buffer.from([mode]);
-    const data = Buffer.concat([discriminator, amountInBuffer, amountOutBuffer, modeBuffer]);
-    return new web3_js_1.TransactionInstruction({
-        keys,
-        programId: constants_1.BASKETS_V3_PROGRAM_ID,
-        data,
-    });
-}