@gearbox-protocol/sdk 3.0.0-vfourabi.7 → 3.0.0-vfourabi.8

package/dist/cjs/sdk/accounts/CreditAccountsService.js

@@ -0,0 +1,665 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreditAccountsService = void 0;
+const viem_1 = require("viem");
+const compressors_1 = require("../../abi/compressors");
+const v300_1 = require("../../abi/v300");
+const base_1 = require("../base");
+const constants_1 = require("../constants");
+const market_1 = require("../market");
+const router_1 = require("../router");
+const sdk_legacy_1 = require("../sdk-legacy");
+const utils_1 = require("../utils");
+const viem_2 = require("../utils/viem");
+class CreditAccountsService extends base_1.SDKConstruct {
+    #compressor;
+    #batchSize;
+    #logger;
+    constructor(sdk, options) {
+        super(sdk);
+        this.#compressor = sdk.addressProvider.getLatestVersion(constants_1.AP_CREDIT_ACCOUNT_COMPRESSOR);
+        this.#batchSize = options?.batchSize;
+        this.#logger = (0, utils_1.childLogger)("CreditAccountsService", sdk.logger);
+    }
+    /**
+     * Returns single credit account data, or undefined if it's not found
+     * Performs all necessary price feed updates under the hood
+     * @param account
+     * @param options
+     * @returns
+     */
+    async getCreditAccountData(account, options) {
+        const blockNumber = options?.blockNumber;
+        let raw;
+        try {
+            raw = await this.provider.publicClient.readContract({
+                abi: compressors_1.iCreditAccountCompressorAbi,
+                address: this.#compressor,
+                functionName: "getCreditAccountData",
+                args: [account],
+                blockNumber,
+            });
+        }
+        catch (e) {
+            // TODO: reverts if account is not found, how to handle other revert reasons?
+            return undefined;
+        }
+        if (raw.success) {
+            return raw;
+        }
+        const { txs: priceUpdateTxs, timestamp: _ } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(undefined, {
+            account,
+        });
+        const resp = await (0, viem_2.simulateMulticall)(this.provider.publicClient, {
+            contracts: [
+                ...priceUpdateTxs.map(market_1.rawTxToMulticallPriceUpdate),
+                {
+                    abi: compressors_1.iCreditAccountCompressorAbi,
+                    address: this.#compressor,
+                    functionName: "getCreditAccountData",
+                    args: [account],
+                },
+            ],
+            allowFailure: false,
+            // gas: 550_000_000n,
+            batchSize: 0, // we cannot have price updates and compressor request in different batches
+            blockNumber,
+        });
+        const cad = resp.pop();
+        return cad;
+    }
+    /**
+     * Methods to get all credit accounts with some optional filtering
+     * Performs all necessary price feed updates under the hood
+     *
+     * TODO: do we want to expose pagination?
+     * TODO: do we want to expose "reverting"?
+     * TODO: do we want to expose MarketFilter in any way? If so, we need to check that the MarketFilter is compatibled with attached markets?
+     * @param args
+     * @param options
+     * @returns returned credit accounts are sorted by health factor in ascending order
+     */
+    async getCreditAccounts(args, options) {
+        const { creditManager, includeZeroDebt = false, maxHealthFactor = 65_535, // TODO: this will change to bigint
+        minHealthFactor = 0, owner = constants_1.ADDRESS_0X0, } = args ?? {};
+        // either credit manager or all attached markets
+        const arg0 = creditManager ?? {
+            configurators: this.marketConfigurators,
+            pools: [],
+            underlying: constants_1.ADDRESS_0X0,
+        };
+        const caFilter = {
+            owner,
+            includeZeroDebt,
+            minHealthFactor,
+            maxHealthFactor,
+        };
+        const { txs: priceUpdateTxs, timestamp: _ } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs();
+        const allCAs = [];
+        // reverting filter is exclusive, we need both options to get all accounts
+        for (const reverting of [false, true]) {
+            let offset = 0n;
+            do {
+                const [accounts, newOffset] = await this.#getCreditAccounts(this.#batchSize
+                    ? [
+                        arg0,
+                        { ...caFilter, reverting },
+                        offset,
+                        BigInt(this.#batchSize), // limit
+                    ]
+                    : [arg0, { ...caFilter, reverting }, offset], priceUpdateTxs, options);
+                allCAs.push(...accounts);
+                offset = newOffset;
+            } while (offset !== 0n);
+        }
+        // sort by health factor ascending
+        return allCAs.sort((a, b) => Number(a.healthFactor - b.healthFactor));
+    }
+    async getRewards(creditAccount) {
+        const rewards = await this.provider.publicClient.readContract({
+            abi: compressors_1.iRewardsCompressorAbi,
+            address: this.rewardCompressor,
+            functionName: "getRewards",
+            args: [creditAccount],
+        });
+        const r = rewards.reduce((acc, r) => {
+            const adapter = r.adapter.toLowerCase();
+            const stakedPhantomToken = r.stakedPhantomToken.toLowerCase();
+            const rewardToken = r.rewardToken.toLowerCase();
+            const key = [adapter, stakedPhantomToken].join("-");
+            if (!acc[key]) {
+                const callData = (0, viem_1.encodeFunctionData)({
+                    abi: sdk_legacy_1.iBaseRewardPoolAbi,
+                    functionName: "getReward",
+                    args: [],
+                });
+                acc[adapter] = {
+                    adapter,
+                    stakedPhantomToken,
+                    calls: [
+                        {
+                            target: adapter,
+                            callData,
+                        },
+                    ],
+                    rewards: [],
+                };
+            }
+            acc[adapter].rewards.push({
+                token: rewardToken,
+                balance: r.amount,
+            });
+            return acc;
+        }, {});
+        return Object.values(r);
+    }
+    async getConnectedBots(accountsToCheck) {
+        const resp = await this.provider.publicClient.multicall({
+            contracts: accountsToCheck.map(o => {
+                const pool = this.sdk.marketRegister.findByCreditManager(o.creditManager);
+                return {
+                    abi: compressors_1.iPeripheryCompressorAbi,
+                    address: this.peripheryCompressor,
+                    functionName: "getConnectedBots",
+                    args: [pool.configurator.address, o.creditAccount],
+                };
+            }),
+            allowFailure: true,
+        });
+        return resp;
+    }
+    /**
+     * Generates transaction to liquidate credit account
+     * @param account
+     * @param to Address to transfer underlying left after liquidation
+     * @param slippage
+     * @returns
+     */
+    async fullyLiquidate(account, to, slippage = 50n) {
+        const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
+        const routerCloseResult = await this.sdk.router.findBestClosePath({
+            creditAccount: account,
+            creditManager: cm.creditManager,
+            slippage,
+        });
+        const priceUpdates = await this.getPriceUpdatesForFacade(account.creditManager, account, undefined);
+        const calls = [...priceUpdates, ...routerCloseResult.calls];
+        const tx = cm.creditFacade.liquidateCreditAccount(account.creditAccount, to, calls);
+        return { tx, calls, routerCloseResult, creditFacade: cm.creditFacade };
+    }
+    /**
+     * Closes credit account or sets debt to zero (but keep account)
+     * @param operation
+     * @param creditAccount
+     * @param assetsToWithdraw Tokens to withdraw from credit account
+     * @param to Address to withdraw underlying to
+     * @param slippage
+     * @param closePath
+     * @returns
+     */
+    async closeCreditAccount({ operation, assetsToWithdraw, creditAccount: ca, to, slippage = 50n, closePath, }) {
+        const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+        const routerCloseResult = closePath ||
+            (await this.sdk.router.findBestClosePath({
+                creditAccount: ca,
+                creditManager: cm.creditManager,
+                slippage,
+            }));
+        const calls = [
+            ...routerCloseResult.calls,
+            ...this.#prepareDisableQuotas(ca),
+            ...this.#prepareDecreaseDebt(ca),
+            ...this.#prepareDisableTokens(ca),
+            ...assetsToWithdraw.map(t => this.#prepareWithdrawToken(ca.creditFacade, t, constants_1.MAX_UINT256, to)),
+        ];
+        const tx = operation === "close"
+            ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls)
+            : cm.creditFacade.multicall(ca.creditAccount, calls);
+        return { tx, calls, routerCloseResult, creditFacade: cm.creditFacade };
+    }
+    /**
+     * Repays credit account or sets debt to zero (but keep account)
+     * @param operation
+     * @param creditAccount
+     * @param assetsToWithdraw Tokens to withdraw from credit account
+     * @param collateralAssets Tokens to pay for
+     * @param to Address to withdraw underlying to
+     * @param slippage
+     * @param permits
+     * @returns
+     */
+    async repayCreditAccount({ operation, collateralAssets, assetsToWithdraw, creditAccount: ca, permits, to, }) {
+        const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+        const addCollateral = collateralAssets.filter(a => a.balance > 0);
+        const calls = [
+            ...this.#prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+            ...this.#prepareDisableQuotas(ca),
+            ...this.#prepareDecreaseDebt(ca),
+            ...this.#prepareDisableTokens(ca),
+            // TODO: probably needs a better way to handle reward tokens
+            ...assetsToWithdraw.map(t => this.#prepareWithdrawToken(ca.creditFacade, t, constants_1.MAX_UINT256, to)),
+        ];
+        const tx = operation === "close"
+            ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls)
+            : cm.creditFacade.multicall(ca.creditAccount, calls);
+        return { tx, calls, creditFacade: cm.creditFacade };
+    }
+    /**
+     * Repays liquidatable credit account
+     * @param creditAccount
+     * @param assetsToWithdraw Tokens to withdraw from credit account
+     * @param collateralAssets Tokens to pay for
+     * @param to Address to withdraw underlying to
+     * @param slippage
+     * @returns
+     */
+    async repayAndLiquidateCreditAccount({ collateralAssets, assetsToWithdraw, creditAccount: ca, permits, to, }) {
+        const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+        const priceUpdates = await this.getPriceUpdatesForFacade(ca.creditManager, ca, undefined);
+        const addCollateral = collateralAssets.filter(a => a.balance > 0);
+        const calls = [
+            ...priceUpdates,
+            ...this.#prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+            ...assetsToWithdraw.map(t => this.#prepareWithdrawToken(ca.creditFacade, t, constants_1.MAX_UINT256, to)),
+        ];
+        const tx = cm.creditFacade.liquidateCreditAccount(ca.creditAccount, to, calls);
+        return { tx, calls, creditFacade: cm.creditFacade };
+    }
+    async updateQuotas(props) {
+        const { creditAccount } = props;
+        const cm = this.sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+        const priceUpdates = await this.getPriceUpdatesForFacade(creditAccount.creditManager, creditAccount, undefined);
+        const calls = [
+            ...priceUpdates,
+            ...this.#prepareUpdateQuotas(props.creditAccount.creditFacade, props),
+        ];
+        const tx = cm.creditFacade.multicall(creditAccount.creditAccount, [
+            ...priceUpdates,
+            ...this.#prepareUpdateQuotas(props.creditAccount.creditFacade, props),
+        ]);
+        return { tx, calls, creditFacade: cm.creditFacade };
+    }
+    async addCollateral(props) {
+        const { creditAccount, asset, permit, ethAmount } = props;
+        const cm = this.sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+        const priceUpdatesCalls = await this.getPriceUpdatesForFacade(creditAccount.creditManager, creditAccount, props.averageQuota);
+        const calls = [
+            ...priceUpdatesCalls,
+            ...this.#prepareAddCollateral(creditAccount.creditFacade, [asset], permit ? { [asset.token]: permit } : {}),
+            ...this.#prepareUpdateQuotas(creditAccount.creditFacade, props),
+        ];
+        const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+        tx.value = ethAmount.toString(10);
+        return { tx, calls, creditFacade: cm.creditFacade };
+    }
+    async changeDebt({ creditAccount, amount, }) {
+        if (amount === 0n) {
+            throw new Error("debt increase or decrease must be non-zero");
+        }
+        const isDecrease = amount < 0n;
+        const change = isDecrease ? -amount : amount;
+        const cm = this.sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+        const priceUpdatesCalls = await this.getPriceUpdatesForFacade(creditAccount.creditManager, creditAccount, undefined);
+        const underlyingEnabled = (creditAccount.enabledTokensMask & 1n) === 1n;
+        const shouldEnable = !isDecrease && !underlyingEnabled;
+        const calls = [
+            ...priceUpdatesCalls,
+            ...(shouldEnable
+                ? this.#prepareEnableTokens(creditAccount.creditFacade, [
+                    creditAccount.underlying,
+                ])
+                : []),
+            this.#prepareChangeDebt(creditAccount.creditFacade, change, isDecrease),
+        ];
+        const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+        return { tx, calls, creditFacade: cm.creditFacade };
+    }
+    async withdrawCollateral(props) {
+        const { creditAccount, assetsToWithdraw, to } = props;
+        const cm = this.sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+        const priceUpdatesCalls = await this.getPriceUpdatesForFacade(creditAccount.creditManager, creditAccount, undefined);
+        const calls = [
+            ...priceUpdatesCalls,
+            ...assetsToWithdraw.map(a => this.#prepareWithdrawToken(creditAccount.creditFacade, a.token, a.balance, to)),
+            ...this.#prepareUpdateQuotas(creditAccount.creditFacade, props),
+        ];
+        const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+        return { tx, calls, creditFacade: cm.creditFacade };
+    }
+    async executeSwap(props) {
+        const { creditAccount, calls: swapCalls } = props;
+        if (swapCalls.length === 0)
+            throw new Error("No path to execute");
+        const cm = this.sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+        const priceUpdatesCalls = await this.getPriceUpdatesForFacade(creditAccount.creditManager, creditAccount, props.averageQuota);
+        const calls = [
+            ...priceUpdatesCalls,
+            ...swapCalls,
+            ...this.#prepareUpdateQuotas(creditAccount.creditFacade, props),
+        ];
+        const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+        return { tx, calls, creditFacade: cm.creditFacade };
+    }
+    async claimFarmRewards(props) {
+        const { tokensToDisable, calls: claimCalls, creditAccount: ca } = props;
+        if (claimCalls.length === 0)
+            throw new Error("No path to execute");
+        const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+        const priceUpdatesCalls = await this.getPriceUpdatesForFacade(ca.creditManager, ca, props.averageQuota);
+        // TODO: probably needs a better way to handle reward tokens
+        const calls = [
+            ...priceUpdatesCalls,
+            ...claimCalls,
+            ...tokensToDisable.map(a => this.#prepareDisableToken(ca.creditFacade, a.token)),
+            ...this.#prepareUpdateQuotas(ca.creditFacade, props),
+        ];
+        const tx = cm.creditFacade.multicall(ca.creditAccount, calls);
+        return { tx, calls, creditFacade: cm.creditFacade };
+    }
+    async openCA(props) {
+        const { ethAmount, creditManager, collateral, permits, debt, withdrawDebt, referralCode, to, calls: openPathCalls, } = props;
+        const cmSuite = this.sdk.marketRegister.findCreditManager(creditManager);
+        const cm = cmSuite.creditManager;
+        const priceUpdatesCalls = await this.getPriceUpdatesForFacade(cm.address, undefined, props.averageQuota);
+        const calls = [
+            ...priceUpdatesCalls,
+            this.#prepareIncreaseDebt(cm.creditFacade, debt),
+            ...this.#prepareAddCollateral(cm.creditFacade, collateral, permits),
+            ...this.#prepareUpdateQuotas(cm.creditFacade, props),
+            ...openPathCalls,
+            ...(withdrawDebt
+                ? [this.#prepareWithdrawToken(cm.creditFacade, cm.underlying, debt, to)]
+                : []),
+        ];
+        const tx = cmSuite.creditFacade.openCreditAccount(to, calls, referralCode);
+        tx.value = ethAmount.toString(10);
+        return { calls, tx, creditFacade: cmSuite.creditFacade };
+    }
+    /**
+     * Internal wrapper for CreditAccountCompressor.getCreditAccounts + price updates wrapped into multicall
+     * @param args
+     * @param priceUpdateTxs
+     * @param options
+     * @returns
+     */
+    async #getCreditAccounts(args, priceUpdateTxs, options) {
+        const blockNumber = options?.blockNumber;
+        if (priceUpdateTxs?.length) {
+            const resp = await (0, viem_2.simulateMulticall)(this.provider.publicClient, {
+                contracts: [
+                    ...priceUpdateTxs.map(market_1.rawTxToMulticallPriceUpdate),
+                    {
+                        abi: compressors_1.iCreditAccountCompressorAbi,
+                        address: this.#compressor,
+                        functionName: "getCreditAccounts",
+                        args,
+                    },
+                ],
+                allowFailure: false,
+                // gas: 550_000_000n,
+                batchSize: 0, // we cannot have price updates and compressor request in different batches
+                blockNumber,
+            });
+            const getCreditAccountsResp = resp.pop();
+            return getCreditAccountsResp;
+        }
+        return this.provider.publicClient.readContract({
+            abi: compressors_1.iCreditAccountCompressorAbi,
+            address: this.#compressor,
+            functionName: "getCreditAccounts",
+            args,
+            blockNumber,
+        });
+    }
+    /**
+     * Returns raw txs that are needed to update all price feeds so that all credit accounts (possibly from different markets) compute
+     * @param accounts
+     * @returns
+     */
+    async getUpdateForAccounts(accounts) {
+        // for each market, using pool address as key, gather tokens to update and find PriceFeedFactories
+        const tokensByPool = new Map();
+        const oracleByPool = new Map();
+        for (const acc of accounts) {
+            const market = this.sdk.marketRegister.findByCreditManager(acc.creditManager);
+            const pool = market.pool.pool.address;
+            oracleByPool.set(pool, market.priceOracle);
+            for (const t of acc.tokens) {
+                if (t.balance > 10n) {
+                    const tokens = tokensByPool.get(pool) ?? new Set();
+                    tokens.add(t.token);
+                    tokensByPool.set(pool, tokens);
+                }
+            }
+        }
+        // priceFeeds can contain PriceFeeds from different markets
+        const priceFeeds = [];
+        for (const [pool, oracle] of oracleByPool.entries()) {
+            const tokens = Array.from(tokensByPool.get(pool) ?? []);
+            priceFeeds.push(...oracle.priceFeedsForTokens(tokens));
+        }
+        return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(priceFeeds);
+    }
+    async getUpdateForAccount(creditManager, creditAccount, desiredQuotas) {
+        // for each market, using pool address as key, gather tokens to update and find PriceFeedFactories
+        const tokensByPool = new Map();
+        const oracleByPool = new Map();
+        const quotaRecord = desiredQuotas
+            ? (0, router_1.assetsMap)(desiredQuotas)
+            : desiredQuotas;
+        const caBalancesRecord = creditAccount
+            ? (0, router_1.assetsMap)(creditAccount.tokens)
+            : creditAccount;
+        const market = this.sdk.marketRegister.findByCreditManager(creditManager);
+        const cm = this.sdk.marketRegister.findCreditManager(creditManager).creditManager;
+        const pool = market.pool.pool.address;
+        oracleByPool.set(pool, market.priceOracle);
+        const insertToken = (p, t) => {
+            const tokens = tokensByPool.get(p) ?? new Set();
+            tokens.add(t);
+            tokensByPool.set(pool, tokens);
+        };
+        for (const t of cm.collateralTokens) {
+            if (creditAccount && caBalancesRecord && quotaRecord) {
+                const balanceAsset = caBalancesRecord.get(t);
+                const balance = balanceAsset?.balance || 0n;
+                const mask = balanceAsset?.mask || 0n;
+                const isEnabled = (mask & creditAccount.enabledTokensMask) !== 0n;
+                const quotaAsset = quotaRecord.get(t);
+                const quotaBalance = quotaAsset?.balance || 0n;
+                if ((balance > 10n && isEnabled) || quotaBalance > 0)
+                    insertToken(pool, t);
+            }
+            else if (creditAccount && caBalancesRecord) {
+                const balanceAsset = caBalancesRecord.get(t);
+                const balance = balanceAsset?.balance || 0n;
+                const mask = balanceAsset?.mask || 0n;
+                const isEnabled = (mask & creditAccount.enabledTokensMask) !== 0n;
+                if (balance > 10n && isEnabled)
+                    insertToken(pool, t);
+            }
+            else if (quotaRecord) {
+                const quotaAsset = quotaRecord.get(t);
+                const quotaBalance = quotaAsset?.balance || 0n;
+                if (quotaBalance > 0)
+                    insertToken(pool, t);
+            }
+        }
+        // priceFeeds can contain PriceFeeds from different markets
+        const priceFeeds = [];
+        for (const [pool, oracle] of oracleByPool.entries()) {
+            const tokens = Array.from(tokensByPool.get(pool) ?? []);
+            priceFeeds.push(...oracle.priceFeedsForTokens(tokens));
+        }
+        this.#logger?.debug({ account: creditAccount?.creditAccount, manager: cm.name }, `generating price feed updates for ${priceFeeds.length} price feeds`);
+        return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(priceFeeds, creditAccount ? { account: creditAccount.creditAccount } : undefined);
+    }
+    /**
+     * Returns account price updates in a non-encoded format
+     * @param acc
+     * @returns
+     */
+    async getOnDemandPriceUpdates(creditManager, creditAccount, desiredQuotas) {
+        const market = this.sdk.marketRegister.findByCreditManager(creditManager);
+        const cm = this.sdk.marketRegister.findCreditManager(creditManager);
+        const update = await this.getUpdateForAccount(creditManager, creditAccount, desiredQuotas);
+        this.#logger?.debug({ account: creditAccount?.creditAccount, manager: cm.name }, `getting on demand price updates from ${update.txs.length} txs`);
+        return market.priceOracle.onDemandPriceUpdates(update);
+    }
+    /**
+     * Returns price updates in format that is accepted by various credit facade methods (multicall, close/liquidate, etc...)
+     * @param acc
+     * @returns
+     */
+    async getPriceUpdatesForFacade(creditManager, creditAccount, desiredQuotas) {
+        const cm = this.sdk.marketRegister.findCreditManager(creditManager);
+        const updates = await this.getOnDemandPriceUpdates(creditManager, creditAccount, desiredQuotas);
+        return cm.creditFacade.encodeOnDemandPriceUpdates(updates);
+    }
+    #prepareDisableQuotas(ca) {
+        const calls = [];
+        for (const { token, quota } of ca.tokens) {
+            if (quota > 0n) {
+                calls.push({
+                    target: ca.creditFacade,
+                    callData: (0, viem_1.encodeFunctionData)({
+                        abi: v300_1.iCreditFacadeV300MulticallAbi,
+                        functionName: "updateQuota",
+                        args: [token, constants_1.MIN_INT96, 0n],
+                    }),
+                });
+            }
+        }
+        return calls;
+    }
+    #prepareUpdateQuotas(creditFacade, { averageQuota, minQuota }) {
+        const minRecord = (0, router_1.assetsMap)(minQuota);
+        const calls = averageQuota.map(q => {
+            const minAsset = minRecord.get(q.token);
+            const min = minAsset && minAsset?.balance > 0 ? minAsset.balance : 0n;
+            return {
+                target: creditFacade,
+                callData: (0, viem_1.encodeFunctionData)({
+                    abi: v300_1.iCreditFacadeV300MulticallAbi,
+                    functionName: "updateQuota",
+                    args: [q.token, q.balance, min],
+                }),
+            };
+        });
+        return calls;
+    }
+    #prepareDecreaseDebt(ca) {
+        if (ca.debt > 0n) {
+            return [
+                {
+                    target: ca.creditFacade,
+                    callData: (0, viem_1.encodeFunctionData)({
+                        abi: v300_1.iCreditFacadeV300MulticallAbi,
+                        functionName: "decreaseDebt",
+                        args: [constants_1.MAX_UINT256],
+                    }),
+                },
+            ];
+        }
+        return [];
+    }
+    #prepareDisableTokens(ca) {
+        const calls = [];
+        for (const t of ca.tokens) {
+            if (t.token !== ca.underlying &&
+                (t.mask & ca.enabledTokensMask) !== 0n &&
+                t.quota === 0n) {
+                calls.push(this.#prepareDisableToken(ca.creditFacade, t.token));
+            }
+        }
+        return calls;
+    }
+    #prepareDisableToken(creditFacade, token) {
+        return {
+            target: creditFacade,
+            callData: (0, viem_1.encodeFunctionData)({
+                abi: v300_1.iCreditFacadeV300MulticallAbi,
+                functionName: "disableToken",
+                args: [token],
+            }),
+        };
+    }
+    #prepareEnableTokens(creditFacade, tokens) {
+        return tokens.map(t => ({
+            target: creditFacade,
+            callData: (0, viem_1.encodeFunctionData)({
+                abi: v300_1.iCreditFacadeV300MulticallAbi,
+                functionName: "enableToken",
+                args: [t],
+            }),
+        }));
+    }
+    #prepareWithdrawToken(creditFacade, token, amount, to) {
+        return {
+            target: creditFacade,
+            callData: (0, viem_1.encodeFunctionData)({
+                abi: v300_1.iCreditFacadeV300MulticallAbi,
+                functionName: "withdrawCollateral",
+                args: [token, amount, to],
+            }),
+        };
+    }
+    #prepareIncreaseDebt(creditFacade, debt) {
+        return {
+            target: creditFacade,
+            callData: (0, viem_1.encodeFunctionData)({
+                abi: v300_1.iCreditFacadeV300MulticallAbi,
+                functionName: "increaseDebt",
+                args: [debt],
+            }),
+        };
+    }
+    #prepareChangeDebt(creditFacade, change, isDecrease) {
+        return {
+            target: creditFacade,
+            callData: (0, viem_1.encodeFunctionData)({
+                abi: v300_1.iCreditFacadeV300MulticallAbi,
+                functionName: isDecrease ? "decreaseDebt" : "increaseDebt",
+                args: [change],
+            }),
+        };
+    }
+    #prepareAddCollateral(creditFacade, assets, permits) {
+        const calls = assets.map(({ token, balance }) => {
+            const p = permits[token];
+            if (p) {
+                return {
+                    target: creditFacade,
+                    callData: (0, viem_1.encodeFunctionData)({
+                        abi: v300_1.iCreditFacadeV300MulticallAbi,
+                        functionName: "addCollateralWithPermit",
+                        args: [token, balance, p.deadline, p.v, p.r, p.s],
+                    }),
+                };
+            }
+            return {
+                target: creditFacade,
+                callData: (0, viem_1.encodeFunctionData)({
+                    abi: v300_1.iCreditFacadeV300MulticallAbi,
+                    functionName: "addCollateral",
+                    args: [token, balance],
+                }),
+            };
+        });
+        return calls;
+    }
+    /**
+     * Returns addresses of market configurators
+     */
+    get marketConfigurators() {
+        return this.sdk.marketRegister.marketConfigurators.map(mc => mc.address);
+    }
+    get rewardCompressor() {
+        return this.sdk.addressProvider.getLatestVersion(constants_1.AP_REWARDS_COMPRESSOR);
+    }
+    get peripheryCompressor() {
+        return this.sdk.addressProvider.getLatestVersion(constants_1.AP_PERIPHERY_COMPRESSOR);
+    }
+}
+exports.CreditAccountsService = CreditAccountsService;
+//# sourceMappingURL=CreditAccountsService.js.map