@haven-fi/solauto-sdk 1.0.581 → 1.0.583

package/dist/services/rebalance/rebalanceSwapManager.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RebalanceSwapManager = void 0;
+const swap_1 = require("../swap");
+const generated_1 = require("../../generated");
+const utils_1 = require("../../utils");
+const umi_web3js_adapters_1 = require("@metaplex-foundation/umi-web3js-adapters");
+class RebalanceSwapManager {
+    constructor(client, values, flRequirements, targetLiqUtilizationRateBps) {
+        this.client = client;
+        this.values = values;
+        this.flRequirements = flRequirements;
+        this.targetLiqUtilizationRateBps = targetLiqUtilizationRateBps;
+        this.jupSwapManager = new swap_1.JupSwapManager(client.signer);
+    }
+    isBoost() {
+        return this.values.rebalanceDirection === generated_1.RebalanceDirection.Boost;
+    }
+    usdToSwap() {
+        return Math.abs(this.values.debtAdjustmentUsd);
+    }
+    postRebalanceLiqUtilizationRateBps(swapOutputAmount) {
+        let supplyUsd = this.client.solautoPosition.supplyUsd();
+        // TODO: add token balance change
+        let debtUsd = this.client.solautoPosition.debtUsd();
+        const outputToken = (0, umi_web3js_adapters_1.toWeb3JsPublicKey)(this.isBoost()
+            ? this.client.solautoPosition.state().supply.mint
+            : this.client.solautoPosition.state().debt.mint);
+        const swapOutputUsd = swapOutputAmount
+            ? (0, utils_1.fromBaseUnit)(swapOutputAmount, (0, utils_1.tokenInfo)(outputToken).decimals) *
+                ((0, utils_1.safeGetPrice)(outputToken) ?? 0)
+            : this.usdToSwap();
+        supplyUsd = this.isBoost()
+            ? supplyUsd + swapOutputUsd
+            : supplyUsd - this.usdToSwap();
+        debtUsd = this.isBoost()
+            ? debtUsd + this.usdToSwap()
+            : debtUsd - swapOutputUsd;
+        return (0, utils_1.getLiqUtilzationRateBps)(supplyUsd, debtUsd, this.client.solautoPosition.state().liqThresholdBps ?? 0);
+    }
+    async findSufficientQuote(swapInput, criteria) {
+        let swapQuote;
+        let insufficient = false;
+        for (let i = 0; i < 10; i++) {
+            (0, utils_1.consoleLog)("Finding sufficient quote...");
+            swapQuote = await this.jupSwapManager.getQuote(swapInput);
+            const outputAmount = parseInt(swapQuote.outAmount);
+            const postRebalanceRate = this.postRebalanceLiqUtilizationRateBps(BigInt(outputAmount));
+            insufficient = criteria.minOutputAmount
+                ? outputAmount < Number(criteria.minOutputAmount)
+                : criteria.minLiqUtilizationRateBps
+                    ? postRebalanceRate < criteria.minLiqUtilizationRateBps
+                    : postRebalanceRate > criteria.maxLiqUtilizationRateBps;
+            if (insufficient) {
+                (0, utils_1.consoleLog)("Insufficient swap quote:", swapQuote);
+                swapInput.amount = this.bigIntWithIncrement(swapInput.amount, 0.01);
+            }
+            else {
+                break;
+            }
+        }
+        return swapQuote;
+    }
+    swapDetails() {
+        const input = this.isBoost()
+            ? this.client.solautoPosition.state().debt
+            : this.client.solautoPosition.state().supply;
+        const output = this.isBoost()
+            ? this.client.solautoPosition.state().supply
+            : this.client.solautoPosition.state().debt;
+        let inputAmount = (0, utils_1.toBaseUnit)(this.usdToSwap() / (0, utils_1.safeGetPrice)(input.mint), input.decimals);
+        return {
+            input,
+            output,
+            inputAmount,
+        };
+    }
+    bigIntWithIncrement(num, inc) {
+        return num + BigInt(Math.round(Number(num) * inc));
+    }
+    async setSwapParams(attemptNum) {
+        const rebalanceToZero = this.targetLiqUtilizationRateBps === 0;
+        let { input, output, inputAmount } = this.swapDetails();
+        let outputAmount = rebalanceToZero
+            ? output.amountUsed.baseUnit +
+                BigInt(Math.round(Number(output.amountUsed.baseUnit) *
+                    // Add this small percentage to account for the APR on the debt between now and the transaction
+                    0.0001))
+            : (0, utils_1.toBaseUnit)(this.usdToSwap() / (0, utils_1.safeGetPrice)(output.mint), output.decimals);
+        const flashLoanRepayFromDebt = !this.isBoost() &&
+            this.flRequirements &&
+            this.flRequirements.liquiditySource === generated_1.TokenType.Debt;
+        const exactOut = flashLoanRepayFromDebt && !rebalanceToZero;
+        const exactIn = !exactOut;
+        if (exactIn && (rebalanceToZero || this.values.repayingCloseToMaxLtv)) {
+            inputAmount = this.bigIntWithIncrement(inputAmount, 0.005);
+        }
+        const swapAmount = exactOut
+            ? this.flRequirements
+                ? this.bigIntWithIncrement(outputAmount, this.flRequirements.flFeeBps ?? 0)
+                : outputAmount
+            : inputAmount;
+        const swapInput = {
+            inputMint: (0, umi_web3js_adapters_1.toWeb3JsPublicKey)(input.mint),
+            outputMint: (0, umi_web3js_adapters_1.toWeb3JsPublicKey)(output.mint),
+            exactIn,
+            exactOut,
+            amount: swapAmount,
+        };
+        (0, utils_1.consoleLog)("Swap input:", swapInput);
+        if (exactIn && (rebalanceToZero || this.values.repayingCloseToMaxLtv)) {
+            this.swapQuote = await this.findSufficientQuote(swapInput, {
+                minOutputAmount: rebalanceToZero ? outputAmount : undefined,
+                maxLiqUtilizationRateBps: this.values.repayingCloseToMaxLtv
+                    ? (0, utils_1.maxRepayToBps)(this.client.solautoPosition.state().maxLtvBps ?? 0, this.client.solautoPosition.state().liqThresholdBps ?? 0) - 15
+                    : undefined,
+            });
+        }
+        if (this.flRequirements) {
+            this.flBorrowAmount = exactOut
+                ? outputAmount
+                : this.swapQuote
+                    ? BigInt(parseInt(this.swapQuote.inAmount))
+                    : inputAmount;
+        }
+        this.swapParams = {
+            ...swapInput,
+            destinationWallet: flashLoanRepayFromDebt
+                ? (0, umi_web3js_adapters_1.toWeb3JsPublicKey)(this.client.signer.publicKey)
+                : this.client.solautoPosition.publicKey,
+            slippageIncFactor: 0.2 + attemptNum * 0.25,
+        };
+    }
+    async getSwapTxData() {
+        const { jupQuote, lookupTableAddresses, setupInstructions, swapIx } = await this.jupSwapManager.getJupSwapTxData(this.swapParams);
+        return {
+            swapQuote: jupQuote,
+            lookupTableAddresses,
+            setupInstructions,
+            swapIx,
+        };
+    }
+}
+exports.RebalanceSwapManager = RebalanceSwapManager;

package/dist/services/rebalance/rebalanceTxBuilder.d.ts

@@ -0,0 +1,22 @@
+import { SolautoClient } from "../solauto";
+import { TransactionItemInputs } from "../../types";
+export declare class RebalanceTxBuilder {
+    private client;
+    private targetLiqUtilizationRateBps?;
+    private values;
+    private rebalanceType;
+    private swapManager;
+    private flRequirements?;
+    constructor(client: SolautoClient, targetLiqUtilizationRateBps?: number | undefined);
+    private shouldProceedWithRebalance;
+    private getRebalanceValues;
+    private getFlLiquiditySource;
+    private flashLoanRequirements;
+    private getFlashLoanDetails;
+    private setRebalanceType;
+    private setRebalanceDetails;
+    private refreshBeforeRebalance;
+    private assembleTransaction;
+    buildRebalanceTx(attemptNum: number): Promise<TransactionItemInputs | undefined>;
+}
+//# sourceMappingURL=rebalanceTxBuilder.d.ts.map

package/dist/services/rebalance/rebalanceTxBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebalanceTxBuilder.d.ts","sourceRoot":"","sources":["../../../src/services/rebalance/rebalanceTxBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAGL,qBAAqB,EACtB,MAAM,aAAa,CAAC;AA2BrB,qBAAa,kBAAkB;IAO3B,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,2BAA2B,CAAC;IAPtC,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,aAAa,CAAwB;IAC7C,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,cAAc,CAAC,CAAwB;gBAGrC,MAAM,EAAE,aAAa,EACrB,2BAA2B,CAAC,EAAE,MAAM,YAAA;YAGhC,0BAA0B;IAQxC,OAAO,CAAC,kBAAkB;IAa1B,OAAO,CAAC,oBAAoB;YAyCd,qBAAqB;IAyCnC,OAAO,CAAC,mBAAmB;IAwB3B,OAAO,CAAC,gBAAgB;YAgCV,mBAAmB;YAoBnB,sBAAsB;YA4BtB,mBAAmB;IAkEpB,gBAAgB,CAC3B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC;CAW9C"}

package/dist/services/rebalance/rebalanceTxBuilder.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RebalanceTxBuilder = void 0;
+const utils_1 = require("../../utils");
+const rebalanceValues_1 = require("./rebalanceValues");
+const solautoFees_1 = require("./solautoFees");
+const generated_1 = require("../../generated");
+const web3_js_1 = require("@solana/web3.js");
+const rebalanceSwapManager_1 = require("./rebalanceSwapManager");
+const umi_web3js_adapters_1 = require("@metaplex-foundation/umi-web3js-adapters");
+const umi_1 = require("@metaplex-foundation/umi");
+class RebalanceTxBuilder {
+    constructor(client, targetLiqUtilizationRateBps) {
+        this.client = client;
+        this.targetLiqUtilizationRateBps = targetLiqUtilizationRateBps;
+    }
+    async shouldProceedWithRebalance() {
+        return (this.client.solautoPosition.supplyUsd() > 0 &&
+            (this.targetLiqUtilizationRateBps !== undefined ||
+                this.client.solautoPosition.eligibleForRebalance()));
+    }
+    getRebalanceValues(flFee) {
+        return (0, rebalanceValues_1.getRebalanceValues)(this.client.solautoPosition, new solautoFees_1.SolautoFeesBps(this.client.isReferred(), this.targetLiqUtilizationRateBps, this.client.solautoPosition.netWorthUsd()), flFee ?? 0, this.targetLiqUtilizationRateBps);
+    }
+    getFlLiquiditySource(supplyLiquidityAvailable, debtLiquidityAvailable) {
+        const debtAdjustmentUsd = Math.abs(this.values.debtAdjustmentUsd);
+        const insufficientLiquidity = (amountNeededUsd, liquidityAvailable, tokenMint) => {
+            return (amountNeededUsd >
+                (0, utils_1.fromBaseUnit)(liquidityAvailable, (0, utils_1.tokenInfo)(tokenMint).decimals) *
+                    ((0, utils_1.safeGetPrice)(tokenMint) ?? 0) *
+                    0.95);
+        };
+        const insufficientSupplyLiquidity = insufficientLiquidity(debtAdjustmentUsd, supplyLiquidityAvailable, this.client.solautoPosition.supplyMint());
+        const insufficientDebtLiquidity = insufficientLiquidity(debtAdjustmentUsd, debtLiquidityAvailable, this.client.solautoPosition.debtMint());
+        let useDebtLiquidity = this.values.rebalanceDirection === generated_1.RebalanceDirection.Boost ||
+            insufficientSupplyLiquidity;
+        if (useDebtLiquidity) {
+            return !insufficientDebtLiquidity ? generated_1.TokenType.Debt : undefined;
+        }
+        else {
+            return !insufficientSupplyLiquidity ? generated_1.TokenType.Supply : undefined;
+        }
+    }
+    async flashLoanRequirements(attemptNum) {
+        const maxLtvRateBps = (0, utils_1.getMaxLiqUtilizationRateBps)(this.client.solautoPosition.state().maxLtvBps, this.client.solautoPosition.state().liqThresholdBps, 0.02);
+        if (this.values.intermediaryLiqUtilizationRateBps < maxLtvRateBps) {
+            return undefined;
+        }
+        const stdFlLiquiditySource = this.getFlLiquiditySource(this.client.flProvider.liquidityAvailable(generated_1.TokenType.Supply), this.client.flProvider.liquidityAvailable(generated_1.TokenType.Debt));
+        if ((attemptNum ?? 0) >= 3 || stdFlLiquiditySource === undefined) {
+            const { supplyBalance, debtBalance } = await this.client.signerBalances();
+            const signerFlLiquiditySource = this.getFlLiquiditySource(supplyBalance, debtBalance);
+            if (signerFlLiquiditySource) {
+                return {
+                    liquiditySource: signerFlLiquiditySource,
+                    signerFlashLoan: true,
+                };
+            }
+            else {
+                throw new Error(`Insufficient liquidity to perform the transaction`);
+            }
+        }
+        else {
+            return {
+                liquiditySource: stdFlLiquiditySource,
+                flFeeBps: this.client.flProvider.flFeeBps(stdFlLiquiditySource),
+            };
+        }
+    }
+    getFlashLoanDetails() {
+        if (!this.flRequirements) {
+            throw new Error("Flash loan requirements data needed");
+        }
+        const boosting = this.values.rebalanceDirection === generated_1.RebalanceDirection.Boost;
+        const useDebtLiquidity = this.flRequirements.liquiditySource === generated_1.TokenType.Debt;
+        let flashLoanToken = undefined;
+        if (boosting || useDebtLiquidity) {
+            flashLoanToken = this.client.solautoPosition.state().debt;
+        }
+        else {
+            flashLoanToken = this.client.solautoPosition.state().supply;
+        }
+        return {
+            ...this.flRequirements,
+            baseUnitAmount: this.swapManager.flBorrowAmount,
+            mint: (0, umi_web3js_adapters_1.toWeb3JsPublicKey)(flashLoanToken.mint),
+        };
+    }
+    setRebalanceType() {
+        if (this.flRequirements) {
+            const tokenBalanceChangeType = this.values.tokenBalanceChange?.changeType;
+            const firstRebalanceTokenChanges = tokenBalanceChangeType === generated_1.TokenBalanceChangeType.PreSwapDeposit;
+            const lastRebalanceTokenChanges = [
+                generated_1.TokenBalanceChangeType.PostSwapDeposit,
+                generated_1.TokenBalanceChangeType.PostRebalanceWithdrawDebtToken,
+                generated_1.TokenBalanceChangeType.PostRebalanceWithdrawSupplyToken,
+            ].includes(tokenBalanceChangeType ?? generated_1.TokenBalanceChangeType.None);
+            const swapType = this.swapManager.swapParams.exactIn
+                ? generated_1.SwapType.ExactIn
+                : generated_1.SwapType.ExactOut;
+            if ((firstRebalanceTokenChanges && swapType === generated_1.SwapType.ExactIn) ||
+                (lastRebalanceTokenChanges && swapType === generated_1.SwapType.ExactOut)) {
+                this.rebalanceType = generated_1.SolautoRebalanceType.DoubleRebalanceWithFL;
+            }
+            else {
+                this.rebalanceType =
+                    swapType === generated_1.SwapType.ExactOut
+                        ? generated_1.SolautoRebalanceType.FLRebalanceThenSwap
+                        : generated_1.SolautoRebalanceType.FLSwapThenRebalance;
+            }
+        }
+        else {
+            this.rebalanceType = generated_1.SolautoRebalanceType.Regular;
+        }
+        (0, utils_1.consoleLog)("Rebalance type:", this.rebalanceType);
+    }
+    async setRebalanceDetails(attemptNum) {
+        this.values = this.getRebalanceValues();
+        this.flRequirements = await this.flashLoanRequirements(attemptNum);
+        if (this.flRequirements?.flFeeBps) {
+            this.values = this.getRebalanceValues(this.flRequirements.flFeeBps);
+        }
+        (0, utils_1.consoleLog)("Rebalance values:", this.values);
+        this.swapManager = new rebalanceSwapManager_1.RebalanceSwapManager(this.client, this.values, this.flRequirements, this.targetLiqUtilizationRateBps);
+        await this.swapManager.setSwapParams(attemptNum);
+        this.setRebalanceType();
+    }
+    async refreshBeforeRebalance() {
+        if (this.client.selfManaged ||
+            this.client.contextUpdates.supplyAdjustment > BigInt(0) ||
+            this.client.contextUpdates.debtAdjustment > BigInt(0)) {
+            return false;
+        }
+        // Rebalance ix will already refresh internally if position is self managed
+        if (!this.client.solautoPosition.data().position) {
+            return true;
+        }
+        const utilizationRateDiff = Math.abs(await this.client.solautoPosition.utilizationRateBpsDrift());
+        (0, utils_1.consoleLog)("Liq utilization rate diff:", utilizationRateDiff);
+        if (utilizationRateDiff >= 10) {
+            (0, utils_1.consoleLog)("Refreshing before rebalance");
+            return true;
+        }
+        (0, utils_1.consoleLog)("Not refreshing before rebalance");
+        return false;
+    }
+    async assembleTransaction() {
+        const { swapQuote, lookupTableAddresses, setupInstructions, swapIx } = await this.swapManager.getSwapTxData();
+        const flashLoanDetails = this.flRequirements
+            ? this.getFlashLoanDetails()
+            : undefined;
+        let tx = (0, umi_1.transactionBuilder)();
+        if (await this.refreshBeforeRebalance()) {
+            tx = tx.add(this.client.refreshIx());
+        }
+        const rebalanceDetails = {
+            values: this.values,
+            rebalanceType: this.rebalanceType,
+            flashLoan: flashLoanDetails,
+            swapQuote,
+            targetLiqUtilizationRateBps: this.targetLiqUtilizationRateBps,
+        };
+        const firstRebalance = this.client.rebalanceIx(generated_1.RebalanceStep.PreSwap, rebalanceDetails);
+        const lastRebalance = this.client.rebalanceIx(generated_1.RebalanceStep.PostSwap, rebalanceDetails);
+        if (!flashLoanDetails) {
+            tx = tx.add([setupInstructions, firstRebalance, swapIx, lastRebalance]);
+        }
+        else {
+            (0, utils_1.consoleLog)("Flash loan details:", flashLoanDetails);
+            const exactOut = swapQuote.swapMode === "ExactOut";
+            const addFirstRebalance = (0, utils_1.hasFirstRebalance)(this.rebalanceType);
+            const addLastRebalance = (0, utils_1.hasLastRebalance)(this.rebalanceType);
+            const flashBorrowDest = exactOut
+                ? (0, utils_1.getTokenAccount)(this.client.solautoPosition.publicKey, new web3_js_1.PublicKey(swapQuote.outputMint))
+                : (0, utils_1.getTokenAccount)((0, umi_web3js_adapters_1.toWeb3JsPublicKey)(this.client.signer.publicKey), new web3_js_1.PublicKey(swapQuote.inputMint));
+            tx = tx.add([
+                setupInstructions,
+                this.client.flProvider.flashBorrow(flashLoanDetails, flashBorrowDest),
+                ...(addFirstRebalance ? [firstRebalance] : []),
+                swapIx,
+                ...(addLastRebalance ? [lastRebalance] : []),
+                this.client.flProvider.flashRepay(flashLoanDetails),
+            ]);
+        }
+        return {
+            tx,
+            lookupTableAddresses,
+        };
+    }
+    async buildRebalanceTx(attemptNum) {
+        await this.client.solautoPosition.refreshPositionState();
+        if (!this.shouldProceedWithRebalance()) {
+            this.client.log("Not eligible for a rebalance");
+            return undefined;
+        }
+        await this.setRebalanceDetails(attemptNum);
+        return await this.assembleTransaction();
+    }
+}
+exports.RebalanceTxBuilder = RebalanceTxBuilder;

package/dist/services/rebalance/rebalanceValues.d.ts

@@ -0,0 +1,31 @@
+import { RebalanceDirection, TokenBalanceChange } from "../../generated";
+import { SolautoPositionEx } from "../../solautoPosition";
+import { SolautoFeesBps } from "./solautoFees";
+export interface PositionValues {
+    supplyUsd: number;
+    debtUsd: number;
+}
+export interface DebtAdjustment {
+    debtAdjustmentUsd: number;
+    endResult: PositionValues;
+    intermediaryLiqUtilizationRateBps: number;
+}
+export interface RebalanceFeesBps {
+    solauto: number;
+    lpBorrow: number;
+    flashLoan: number;
+}
+interface ApplyDebtAdjustmentResult {
+    newPos: PositionValues;
+    intermediaryLiqUtilizationRateBps: number;
+}
+export declare function applyDebtAdjustmentUsd(debtAdjustmentUsd: number, pos: PositionValues, fees: RebalanceFeesBps, liqThreshold: number): ApplyDebtAdjustmentResult;
+export declare function getDebtAdjustment(liqThreshold: number, pos: PositionValues, fees: RebalanceFeesBps, targetLiqUtilizationRateBps: number): DebtAdjustment;
+export interface RebalanceValues extends DebtAdjustment {
+    rebalanceDirection: RebalanceDirection;
+    tokenBalanceChange?: TokenBalanceChange;
+    repayingCloseToMaxLtv: boolean;
+}
+export declare function getRebalanceValues(solautoPosition: SolautoPositionEx, solautoFeeBps: SolautoFeesBps, flFeeBps: number, targetLiqUtilizationRateBps?: number): RebalanceValues;
+export {};
+//# sourceMappingURL=rebalanceValues.d.ts.map

package/dist/services/rebalance/rebalanceValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebalanceValues.d.ts","sourceRoot":"","sources":["../../../src/services/rebalance/rebalanceValues.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAEnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAO1D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,cAAc,CAAC;IAC1B,iCAAiC,EAAE,MAAM,CAAC;CAC3C;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,yBAAyB;IACjC,MAAM,EAAE,cAAc,CAAC;IACvB,iCAAiC,EAAE,MAAM,CAAC;CAC3C;AAED,wBAAgB,sBAAsB,CACpC,iBAAiB,EAAE,MAAM,EACzB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,gBAAgB,EACtB,YAAY,EAAE,MAAM,GACnB,yBAAyB,CA6B3B;AAED,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,gBAAgB,EACtB,2BAA2B,EAAE,MAAM,GAClC,cAAc,CA+BhB;AAqED,MAAM,WAAW,eAAgB,SAAQ,cAAc;IACrD,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,qBAAqB,EAAE,OAAO,CAAC;CAChC;AAED,wBAAgB,kBAAkB,CAChC,eAAe,EAAE,iBAAiB,EAClC,aAAa,EAAE,cAAc,EAC7B,QAAQ,EAAE,MAAM,EAChB,2BAA2B,CAAC,EAAE,MAAM,GACnC,eAAe,CA2CjB"}

package/dist/services/rebalance/rebalanceValues.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDebtAdjustmentUsd = applyDebtAdjustmentUsd;
+exports.getDebtAdjustment = getDebtAdjustment;
+exports.getRebalanceValues = getRebalanceValues;
+const generated_1 = require("../../generated");
+const utils_1 = require("../../utils");
+function applyDebtAdjustmentUsd(debtAdjustmentUsd, pos, fees, liqThreshold) {
+    const newPos = { ...pos };
+    const isBoost = debtAdjustmentUsd > 0;
+    const daMinusSolautoFees = debtAdjustmentUsd - debtAdjustmentUsd * (0, utils_1.fromBps)(fees.solauto);
+    const daWithFlashLoan = debtAdjustmentUsd * (1.0 + (0, utils_1.fromBps)(fees.flashLoan));
+    let intermediaryLiqUtilizationRateBps = 0;
+    if (isBoost) {
+        newPos.debtUsd +=
+            daWithFlashLoan * (0, utils_1.fromBps)(fees.lpBorrow) + daWithFlashLoan;
+        intermediaryLiqUtilizationRateBps = (0, utils_1.getLiqUtilzationRateBps)(newPos.supplyUsd, newPos.debtUsd, (0, utils_1.toBps)(liqThreshold));
+        newPos.supplyUsd += daMinusSolautoFees;
+    }
+    else {
+        newPos.supplyUsd += daWithFlashLoan;
+        intermediaryLiqUtilizationRateBps = (0, utils_1.getLiqUtilzationRateBps)(newPos.supplyUsd, newPos.debtUsd, (0, utils_1.toBps)(liqThreshold));
+        newPos.debtUsd += daMinusSolautoFees;
+    }
+    return { newPos, intermediaryLiqUtilizationRateBps };
+}
+function getDebtAdjustment(liqThreshold, pos, fees, targetLiqUtilizationRateBps) {
+    const isBoost = (0, utils_1.getLiqUtilzationRateBps)(pos.supplyUsd, pos.debtUsd, (0, utils_1.toBps)(liqThreshold)) <
+        targetLiqUtilizationRateBps;
+    const targetUtilizationRate = (0, utils_1.fromBps)(targetLiqUtilizationRateBps);
+    const actualizedFee = 1.0 - (0, utils_1.fromBps)(fees.solauto);
+    const flFee = (0, utils_1.fromBps)(fees.flashLoan);
+    const lpBorrowFee = (0, utils_1.fromBps)(fees.lpBorrow);
+    const debtAdjustmentUsd = isBoost
+        ? (targetUtilizationRate * liqThreshold * pos.supplyUsd - pos.debtUsd) /
+            (1.0 +
+                lpBorrowFee +
+                flFee -
+                targetUtilizationRate * actualizedFee * liqThreshold)
+        : (targetUtilizationRate * liqThreshold * pos.supplyUsd - pos.debtUsd) /
+            (actualizedFee - targetUtilizationRate * liqThreshold * (1.0 + flFee));
+    const newPos = applyDebtAdjustmentUsd(debtAdjustmentUsd, pos, fees, liqThreshold);
+    return {
+        debtAdjustmentUsd,
+        endResult: newPos.newPos,
+        intermediaryLiqUtilizationRateBps: newPos.intermediaryLiqUtilizationRateBps,
+    };
+}
+function getTokenBalanceChange() {
+    // TODO: DCA, limit orders, take profit, stop loss, etc.
+    return undefined;
+}
+function getTargetLiqUtilizationRateBps(solautoPosition, targetLiqUtilizationRateBps, tokenBalanceChange) {
+    if (targetLiqUtilizationRateBps !== undefined) {
+        return targetLiqUtilizationRateBps;
+    }
+    const currentRate = solautoPosition.state().liqUtilizationRateBps;
+    if (currentRate <= solautoPosition.boostFromBps()) {
+        return solautoPosition.settings().boostToBps;
+    }
+    else if (currentRate >= solautoPosition.repayFromBps()) {
+        return solautoPosition.settings().repayToBps;
+    }
+    // TODO: DCA, limit orders, take profit, stop loss, etc.
+    //   else if (tokenBalanceChange !== null) {
+    //     return currentRate;
+    //   }
+    throw new Error("Invalid rebalance condition");
+}
+function getAdjustedPositionValues(solautoPosition, tokenBalanceChange) {
+    let supplyUsd = solautoPosition.supplyUsd();
+    const debtUsd = solautoPosition.debtUsd();
+    if (tokenBalanceChange) {
+        const tb = tokenBalanceChange;
+        switch (tb.changeType) {
+            case generated_1.TokenBalanceChangeType.PreSwapDeposit:
+            case generated_1.TokenBalanceChangeType.PostSwapDeposit:
+                supplyUsd += Number(tb.amountUsd);
+                break;
+            case generated_1.TokenBalanceChangeType.PostRebalanceWithdrawDebtToken:
+            case generated_1.TokenBalanceChangeType.PostRebalanceWithdrawSupplyToken:
+                supplyUsd -= Number(tb.amountUsd);
+                break;
+            default:
+                break;
+        }
+    }
+    return {
+        supplyUsd,
+        debtUsd,
+    };
+}
+function getRebalanceDirection(solautoPosition, targetLtvBps) {
+    return solautoPosition.state().liqUtilizationRateBps < targetLtvBps
+        ? generated_1.RebalanceDirection.Boost
+        : generated_1.RebalanceDirection.Repay;
+}
+function getRebalanceValues(solautoPosition, solautoFeeBps, flFeeBps, targetLiqUtilizationRateBps) {
+    const tokenBalanceChange = getTokenBalanceChange();
+    const targetRate = getTargetLiqUtilizationRateBps(solautoPosition, targetLiqUtilizationRateBps, tokenBalanceChange);
+    const rebalanceDirection = getRebalanceDirection(solautoPosition, targetRate);
+    const position = getAdjustedPositionValues(solautoPosition, tokenBalanceChange);
+    const fees = {
+        solauto: solautoFeeBps.getSolautoFeesBps(rebalanceDirection).total,
+        lpBorrow: solautoPosition.state().debt.borrowFeeBps,
+        flashLoan: flFeeBps,
+    };
+    const debtAdjustment = getDebtAdjustment((0, utils_1.fromBps)(solautoPosition.state().liqThresholdBps), position, fees, targetRate);
+    const repayingCloseToMaxLtv = rebalanceDirection === generated_1.RebalanceDirection.Repay &&
+        targetRate >=
+            (0, utils_1.maxRepayToBps)(solautoPosition.state().maxLtvBps, solautoPosition.state().liqThresholdBps);
+    return {
+        ...debtAdjustment,
+        rebalanceDirection,
+        tokenBalanceChange,
+        repayingCloseToMaxLtv,
+    };
+}

package/dist/services/rebalance/solautoFees.d.ts

@@ -0,0 +1,13 @@
+import { RebalanceDirection } from "../../generated";
+export declare class SolautoFeesBps {
+    private isReferred;
+    private targetLiqUtilizationRateBps;
+    private positionNetWorthUsd;
+    constructor(isReferred: boolean, targetLiqUtilizationRateBps: number | undefined, positionNetWorthUsd: number);
+    getSolautoFeesBps(rebalanceDirection: RebalanceDirection): {
+        solauto: number;
+        referrer: number;
+        total: number;
+    };
+}
+//# sourceMappingURL=solautoFees.d.ts.map

package/dist/services/rebalance/solautoFees.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solautoFees.d.ts","sourceRoot":"","sources":["../../../src/services/rebalance/solautoFees.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,qBAAa,cAAc;IAEvB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,2BAA2B;IACnC,OAAO,CAAC,mBAAmB;gBAFnB,UAAU,EAAE,OAAO,EACnB,2BAA2B,EAAE,MAAM,GAAG,SAAS,EAC/C,mBAAmB,EAAE,MAAM;IAG9B,iBAAiB,CAAC,kBAAkB,EAAE,kBAAkB;;;;;CAkDhE"}

package/dist/services/rebalance/solautoFees.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolautoFeesBps = void 0;
+const constants_1 = require("../../constants");
+const generated_1 = require("../../generated");
+class SolautoFeesBps {
+    constructor(isReferred, targetLiqUtilizationRateBps, positionNetWorthUsd) {
+        this.isReferred = isReferred;
+        this.targetLiqUtilizationRateBps = targetLiqUtilizationRateBps;
+        this.positionNetWorthUsd = positionNetWorthUsd;
+    }
+    getSolautoFeesBps(rebalanceDirection) {
+        const minSize = 10000; // Minimum position size
+        const maxSize = 250000; // Maximum position size
+        const maxFeeBps = 50; // Fee in basis points for minSize (0.5%)
+        const minFeeBps = 25; // Fee in basis points for maxSize (0.25%)
+        const k = 1.5;
+        if (this.targetLiqUtilizationRateBps !== undefined &&
+            this.targetLiqUtilizationRateBps === 0) {
+            return {
+                solauto: 0,
+                referrer: 0,
+                total: 0,
+            };
+        }
+        let feeBps = 0;
+        if (this.targetLiqUtilizationRateBps !== undefined ||
+            rebalanceDirection === generated_1.RebalanceDirection.Repay) {
+            feeBps = 25;
+        }
+        else if (this.positionNetWorthUsd <= minSize) {
+            feeBps = maxFeeBps;
+        }
+        else if (this.positionNetWorthUsd >= maxSize) {
+            feeBps = minFeeBps;
+        }
+        else {
+            const t = (Math.log(this.positionNetWorthUsd) - Math.log(minSize)) /
+                (Math.log(maxSize) - Math.log(minSize));
+            feeBps = Math.round(minFeeBps + (maxFeeBps - minFeeBps) * (1 - Math.pow(t, k)));
+        }
+        let referrer = 0;
+        if (this.isReferred) {
+            feeBps *= 1.0 - constants_1.REFERRER_PERCENTAGE;
+            referrer = Math.floor(feeBps * constants_1.REFERRER_PERCENTAGE);
+        }
+        return {
+            solauto: feeBps - referrer,
+            referrer,
+            total: feeBps,
+        };
+    }
+}
+exports.SolautoFeesBps = SolautoFeesBps;

package/dist/services/solauto/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./referralStateManager";
+export * from "./solautoClient";
+export * from "./solautoMarginfiClient";
+export * from "./txHandler";
+//# sourceMappingURL=index.d.ts.map

package/dist/services/solauto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/solauto/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,aAAa,CAAC"}

package/dist/{clients → services/solauto}/referralStateManager.d.ts

@@ -1,11 +1,8 @@
 import { PublicKey } from "@solana/web3.js";
-import { Signer, TransactionBuilder, Umi } from "@metaplex-foundation/umi";
-import { WalletAdapter } from "@metaplex-foundation/umi-signer-wallet-adapters";
-import { ReferralState } from "../generated";
+import { TransactionBuilder, Umi } from "@metaplex-foundation/umi";
+import { ReferralState } from "../../generated";
 import { TxHandler } from "./txHandler";
 export interface ReferralStateManagerArgs {
-    signer?: Signer;
-    wallet?: WalletAdapter;
     authority?: PublicKey;
     referralState?: PublicKey;
     referredByAuthority?: PublicKey;
@@ -19,7 +16,9 @@ export declare class ReferralStateManager extends TxHandler {
     referredByState?: PublicKey;
     initialize(args: ReferralStateManagerArgs): Promise<void>;
     defaultLookupTables(): string[];
+    refetchReferralState(): Promise<void>;
     setReferredBy(referredBy?: PublicKey): void;
+    isReferred(): boolean;
     updateReferralStatesIx(destFeesMint?: PublicKey, lookupTable?: PublicKey): TransactionBuilder;
     claimReferralFeesIx(): TransactionBuilder;
     resetLiveTxUpdates(success?: boolean): Promise<void>;

package/dist/services/solauto/referralStateManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"referralStateManager.d.ts","sourceRoot":"","sources":["../../../src/services/solauto/referralStateManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAa,kBAAkB,EAAE,GAAG,EAAE,MAAM,0BAA0B,CAAC;AAE9E,OAAO,EAEL,aAAa,EAGd,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,MAAM,WAAW,wBAAwB;IACvC,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B,mBAAmB,CAAC,EAAE,SAAS,CAAC;CACjC;AAED,qBAAa,oBAAqB,SAAQ,SAAS;IAC1C,GAAG,EAAG,GAAG,CAAC;IAEV,aAAa,EAAG,SAAS,CAAC;IAC1B,iBAAiB,EAAG,aAAa,GAAG,IAAI,CAAC;IACzC,SAAS,EAAG,SAAS,CAAC;IAEtB,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,eAAe,CAAC,EAAE,SAAS,CAAC;IAE7B,UAAU,CAAC,IAAI,EAAE,wBAAwB;IAoB/C,mBAAmB,IAAI,MAAM,EAAE;IASzB,oBAAoB;IAQ1B,aAAa,CAAC,UAAU,CAAC,EAAE,SAAS;IAsBpC,UAAU,IAAI,OAAO;IAIrB,sBAAsB,CACpB,YAAY,CAAC,EAAE,SAAS,EACxB,WAAW,CAAC,EAAE,SAAS,GACtB,kBAAkB;IAerB,mBAAmB,IAAI,kBAAkB;IA0BnC,kBAAkB,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAC3D"}