@haven-fi/solauto-sdk 1.0.582 → 1.0.583

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"}

package/dist/{clients → services/solauto}/referralStateManager.js

@@ -5,24 +5,16 @@ const web3_js_1 = require("@solana/web3.js");
 const spl_token_1 = require("@solana/spl-token");
 const umi_1 = require("@metaplex-foundation/umi");
 const umi_web3js_adapters_1 = require("@metaplex-foundation/umi-web3js-adapters");
-const umi_signer_wallet_adapters_1 = require("@metaplex-foundation/umi-signer-wallet-adapters");
-const generated_1 = require("../generated");
-const utils_1 = require("../utils");
+const generated_1 = require("../../generated");
+const utils_1 = require("../../utils");
 const txHandler_1 = require("./txHandler");
-const constants_1 = require("../constants");
+const constants_1 = require("../../constants");
 class ReferralStateManager extends txHandler_1.TxHandler {
     async initialize(args) {
-        if (!args.signer && !args.wallet) {
-            throw new Error("Signer or wallet must be provided");
-        }
-        this.umi = this.umi.use(args.signer
-            ? (0, umi_1.signerIdentity)(args.signer, true)
-            : (0, umi_signer_wallet_adapters_1.walletAdapterIdentity)(args.wallet, true));
-        this.signer = this.umi.identity;
         this.referralState =
             args.referralState ??
                 (0, utils_1.getReferralState)(args.authority ?? (0, umi_web3js_adapters_1.toWeb3JsPublicKey)(this.signer.publicKey), this.programId);
-        this.referralStateData = await (0, generated_1.safeFetchReferralState)(this.umi, (0, umi_1.publicKey)(this.referralState), { commitment: "confirmed" });
+        await this.refetchReferralState();
         this.authority = this.referralStateData?.authority
             ? (0, umi_web3js_adapters_1.toWeb3JsPublicKey)(this.referralStateData.authority)
             : (args.authority ?? (0, umi_web3js_adapters_1.toWeb3JsPublicKey)(this.signer.publicKey));
@@ -37,6 +29,9 @@ class ReferralStateManager extends txHandler_1.TxHandler {
             ? [constants_1.SOLAUTO_LUT, this.referralStateData?.lookupTable.toString()]
             : [constants_1.SOLAUTO_LUT];
     }
+    async refetchReferralState() {
+        this.referralStateData = await (0, generated_1.safeFetchReferralState)(this.umi, (0, umi_1.publicKey)(this.referralState), { commitment: "confirmed" });
+    }
     setReferredBy(referredBy) {
         const hasReferredBy = this.referralStateData &&
             this.referralStateData.referredByState !== (0, umi_1.publicKey)(web3_js_1.PublicKey.default);
@@ -53,6 +48,9 @@ class ReferralStateManager extends txHandler_1.TxHandler {
                 ? (0, umi_web3js_adapters_1.toWeb3JsPublicKey)(this.referralStateData.referredByState)
                 : undefined;
     }
+    isReferred() {
+        return Boolean(this.referredByState);
+    }
     updateReferralStatesIx(destFeesMint, lookupTable) {
         return (0, generated_1.updateReferralStates)(this.umi, {
             signer: this.signer,

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

@@ -0,0 +1,59 @@
+import "rpc-websockets/dist/lib/client";
+import { PublicKey } from "@solana/web3.js";
+import { TransactionBuilder } from "@metaplex-foundation/umi";
+import { DCASettingsInpArgs, LendingPlatform, RebalanceStep, SolautoActionArgs, SolautoSettingsParametersInpArgs, UpdatePositionDataArgs } from "../../generated";
+import { ContextUpdates } from "../../utils/solautoUtils";
+import { ReferralStateManager, ReferralStateManagerArgs } from "./referralStateManager";
+import { SolautoPositionEx } from "../../solautoPosition";
+import { RebalanceDetails } from "../../types";
+import { FlProviderAggregator } from "../flashLoans/flProviderAggregator";
+export interface SolautoClientArgs extends ReferralStateManagerArgs {
+    new?: boolean;
+    positionId?: number;
+    supplyMint?: PublicKey;
+    debtMint?: PublicKey;
+    lendingPool?: PublicKey;
+    lpUserAccount?: PublicKey;
+}
+export declare abstract class SolautoClient extends ReferralStateManager {
+    lendingPlatform: LendingPlatform;
+    authority: PublicKey;
+    positionId: number;
+    selfManaged: boolean;
+    solautoPosition: SolautoPositionEx;
+    positionSupplyTa: PublicKey;
+    signerSupplyTa: PublicKey;
+    positionDebtTa: PublicKey;
+    signerDebtTa: PublicKey;
+    solautoFeesSupplyTa: PublicKey;
+    solautoFeesDebtTa: PublicKey;
+    authorityLutAddress?: PublicKey;
+    flProvider: FlProviderAggregator;
+    contextUpdates: ContextUpdates;
+    private signerSupplyBalance;
+    private signerDebtBalance;
+    initialize(args: SolautoClientArgs): Promise<void>;
+    referredBySupplyTa(): PublicKey | undefined;
+    referredByDebtTa(): PublicKey | undefined;
+    resetLiveTxUpdates(success?: boolean): Promise<void>;
+    defaultLookupTables(): string[];
+    lutAccountsToAdd(): PublicKey[];
+    fetchExistingAuthorityLutAccounts(): Promise<PublicKey[]>;
+    updateLookupTable(): Promise<{
+        tx: TransactionBuilder;
+        new: boolean;
+        accountsToAdd: PublicKey[];
+    } | undefined>;
+    signerBalances(): Promise<{
+        supplyBalance: bigint;
+        debtBalance: bigint;
+    }>;
+    openPositionIx(settings?: SolautoSettingsParametersInpArgs, dca?: DCASettingsInpArgs): TransactionBuilder;
+    updatePositionIx(args: UpdatePositionDataArgs): TransactionBuilder;
+    abstract closePositionIx(): TransactionBuilder;
+    cancelDCAIx(): TransactionBuilder;
+    abstract refreshIx(): TransactionBuilder;
+    protocolInteractionIx(args: SolautoActionArgs): TransactionBuilder;
+    abstract rebalanceIx(rebalanceStep: RebalanceStep, data: RebalanceDetails): TransactionBuilder;
+}
+//# sourceMappingURL=solautoClient.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"solautoClient.d.ts","sourceRoot":"","sources":["../../../src/services/solauto/solautoClient.ts"],"names":[],"mappings":"AAAA,OAAO,gCAAgC,CAAC;AACxC,OAAO,EAEL,SAAS,EAGV,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,kBAAkB,EAMnB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,gCAAgC,EAEhC,sBAAsB,EAGvB,MAAM,iBAAiB,CAAC;AAWzB,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EACL,oBAAoB,EACpB,wBAAwB,EACzB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAEL,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE1E,MAAM,WAAW,iBAAkB,SAAQ,wBAAwB;IACjE,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,aAAa,CAAC,EAAE,SAAS,CAAC;CAC3B;AAED,8BAAsB,aAAc,SAAQ,oBAAoB;IACvD,eAAe,EAAG,eAAe,CAAC;IAElC,SAAS,EAAG,SAAS,CAAC;IAEtB,UAAU,EAAG,MAAM,CAAC;IACpB,WAAW,EAAG,OAAO,CAAC;IACtB,eAAe,EAAG,iBAAiB,CAAC;IAEpC,gBAAgB,EAAG,SAAS,CAAC;IAC7B,cAAc,EAAG,SAAS,CAAC;IAE3B,cAAc,EAAG,SAAS,CAAC;IAC3B,YAAY,EAAG,SAAS,CAAC;IAEzB,mBAAmB,EAAG,SAAS,CAAC;IAChC,iBAAiB,EAAG,SAAS,CAAC;IAE9B,mBAAmB,CAAC,EAAE,SAAS,CAAC;IAEhC,UAAU,EAAG,oBAAoB,CAAC;IAClC,cAAc,EAAE,cAAc,CAAwB;IAE7D,OAAO,CAAC,mBAAmB,CAAqB;IAChD,OAAO,CAAC,iBAAiB,CAAqB;IAExC,UAAU,CAAC,IAAI,EAAE,iBAAiB;IA8ExC,kBAAkB,IAAI,SAAS,GAAG,SAAS;IAU3C,gBAAgB,IAAI,SAAS,GAAG,SAAS;IAUnC,kBAAkB,CAAC,OAAO,CAAC,EAAE,OAAO;IAmB1C,mBAAmB,IAAI,MAAM,EAAE;IAS/B,gBAAgB,IAAI,SAAS,EAAE;IAmBzB,iCAAiC,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAUzD,iBAAiB,IAAI,OAAO,CAC9B;QACE,EAAE,EAAE,kBAAkB,CAAC;QACvB,GAAG,EAAE,OAAO,CAAC;QACb,aAAa,EAAE,SAAS,EAAE,CAAC;KAC5B,GACD,SAAS,CACZ;IA2DK,cAAc,IAAI,OAAO,CAAC;QAC9B,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IA8CF,cAAc,CACZ,QAAQ,CAAC,EAAE,gCAAgC,EAC3C,GAAG,CAAC,EAAE,kBAAkB,GACvB,kBAAkB;IA0BrB,gBAAgB,CAAC,IAAI,EAAE,sBAAsB,GAAG,kBAAkB;IAsDlE,QAAQ,CAAC,eAAe,IAAI,kBAAkB;IAE9C,WAAW,IAAI,kBAAkB;IAgCjC,QAAQ,CAAC,SAAS,IAAI,kBAAkB;IAExC,qBAAqB,CAAC,IAAI,EAAE,iBAAiB,GAAG,kBAAkB;IAwFlE,QAAQ,CAAC,WAAW,CAClB,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,gBAAgB,GACrB,kBAAkB;CACtB"}