@gearbox-protocol/sdk 3.0.0-next.1 → 3.0.0-next.11

package/contracts/IAirdropDistributor.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.0;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+struct DistributionData {
+    address account;
+    uint8 campaignId;
+    uint256 amount;
+}
+
+struct ClaimedData {
+    address account;
+    uint256 amount;
+}
+
+interface IAirdropDistributorEvents {
+    /// @dev Emits when a user claims tokens
+    event Claimed(
+        address indexed account,
+        uint256 amount,
+        bool indexed historic
+    );
+
+    /// @dev Emits when the owner replaces the merkle root
+    event RootUpdated(bytes32 oldRoot, bytes32 indexed newRoot);
+
+    /// @dev Emitted from a special function after updating the root to index allocations
+    event TokenAllocated(
+        address indexed account,
+        uint8 indexed campaignId,
+        uint256 amount
+    );
+}
+
+interface IAirdropDistributor is IAirdropDistributorEvents {
+    /// @dev Returns the token distributed by this contract.
+    function token() external view returns (IERC20);
+
+    /// @dev Returns the current merkle root containing total claimable balances
+    function merkleRoot() external view returns (bytes32);
+
+    /// @dev Returns the total amount of token claimed by the user
+    function claimed(address user) external view returns (uint256);
+
+    // Claim the given amount of the token to the given address. Reverts if the inputs are invalid.
+    /// @dev Claims the given amount of the token for the account. Reverts if the inputs are not a leaf in the tree
+    ///      or the total claimed amount for the account is more than the leaf amount.
+    function claim(
+        uint256 index,
+        address account,
+        uint256 totalAmount,
+        bytes32[] calldata merkleProof
+    ) external;
+}

package/contracts/IDegenDistributor.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.0;
+
+interface IDegenDistributorEvents {
+    /// @dev Emits when a user claims tokens
+    event Claimed(address indexed account, uint256 amount);
+
+    /// @dev Emits when the owner replaces the merkle root
+    event RootUpdated(bytes32 oldRoot, bytes32 indexed newRoot);
+}
+
+interface IDegenDistributor is IDegenDistributorEvents {
+    // Returns the merkle root of the merkle tree containing account balances available to claim.
+    function merkleRoot() external view returns (bytes32);
+
+    /// @dev Returns the total amount of token claimed by the user
+    function claimed(address user) external view returns (uint256);
+
+    // Claim the given amount of the token to the given address. Reverts if the inputs are invalid.
+    /// @dev Claims the remaining unclaimed amount of the token for the account. Reverts if the inputs are not a leaf in the tree
+    ///      or the total claimed amount for the account is more than the leaf amount.
+    function claim(
+        uint256 index,
+        address account,
+        uint256 totalAmount,
+        bytes32[] calldata merkleProof
+    ) external;
+}

package/contracts/IOffchainOracle.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: BUSL-1.1
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2021
+pragma solidity ^0.8.10;
+
+interface IOffchainOracle {
+    function getRate(
+        address srcToken,
+        address dstToken,
+        bool useWrappers
+    ) external view returns (uint256 weightedRate);
+
+    function getRateToEth(address srcToken, bool useSrcWrappers)
+        external
+        view
+        returns (uint256 weightedRate);
+}

package/contracts/IRouter.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2021
+pragma solidity ^0.8.10;
+
+import {Balance} from "@gearbox-protocol/core-v2/contracts/libraries/Balances.sol";
+import {IVersion} from "@gearbox-protocol/core-v2/contracts/interfaces/IVersion.sol";
+import {MultiCall} from "@gearbox-protocol/core-v2/contracts/libraries/MultiCall.sol";
+
+struct PathOption {
+    address target;
+    uint8 option;
+    uint8 totalOptions;
+}
+
+enum SwapOperation {
+    EXACT_INPUT,
+    EXACT_INPUT_ALL,
+    EXACT_OUTPUT
+}
+
+struct SwapTask {
+    SwapOperation swapOperation;
+    address creditAccount;
+    address tokenIn;
+    address tokenOut;
+    address[] connectors;
+    uint256 amount;
+    uint256 slippage;
+    bool externalSlippage;
+}
+
+struct RouterResult {
+    uint256 amount;
+    uint256 gasUsage;
+    MultiCall[] calls;
+}
+
+interface IRouter is IVersion {
+    /// @dev Emits each time when routerComponent is set / updated
+    event RouterComponentUpdate(uint8 indexed, address indexed);
+
+    /// @dev Emits each time when resolver is set / updated
+    event ResolverUpdate(uint8 indexed ttIn, uint8 indexed ttOut, uint8 indexed rc);
+
+    event TokenTypeUpdate(address indexed tokenAddress, uint8 indexed tt);
+
+    /// @dev Finds all available swaps for NORMAL tokens
+    function findAllSwaps(SwapTask memory swapTask) external returns (RouterResult[] memory);
+
+    /// @dev Finds best path to swap all Normal tokens and tokens "on the way" to target one and vice versa
+    function findOneTokenPath(
+        address tokenIn,
+        uint256 amount,
+        address tokenOut,
+        address creditAccount,
+        address[] calldata connectors,
+        uint256 slippage
+    ) external returns (RouterResult memory);
+
+    /// @dev Finds the best swap to deposit (or swap) all provided tokens into target one
+    /// Currently it takes ALL Normal tokens and all LP "on the way" tokens into target one.
+    /// It some token is not "on the way" it would be skipped.
+    /// @param creditManager Address of creditManager
+    /// @param balances Expected balances on credit account
+    /// @param target Address of target token
+    /// @param connectors Addresses of "connectors" - internidiatery tokens which're used for swap operations
+    /// @param slippage Slippage in PERCENTAGE_FORMAT
+    function findOpenStrategyPath(
+        address creditManager,
+        Balance[] calldata balances,
+        address target,
+        address[] calldata connectors,
+        uint256 slippage
+    ) external returns (Balance[] memory, RouterResult memory);
+
+    /// @dev Finds the best close path - withdraw all tokens and swap them into underlying one
+    /// @param creditAccount Address of closing creditAccount
+    /// @param connectors Addresses of "connectors" - internidiatery tokens which're used for swap operations
+    /// @param slippage Slippage in PERCENTAGE_FORMAT
+    /// @param pathOptions Starting point for iterating routes. More info in PathOption file
+    /// @param iterations How many iterations algo should compute starting from PathOptions
+    function findBestClosePath(
+        address creditAccount,
+        address[] memory connectors,
+        uint256 slippage,
+        PathOption[] memory pathOptions,
+        uint256 iterations,
+        bool force
+    ) external returns (RouterResult memory result, uint256 gasPriceTargetRAY);
+
+    /// @dev Returns TokenType for provided token
+    function tokenTypes(address) external view returns (uint8);
+
+    /// @dev Returns current address for RouterComponent. Used for self-discovery
+    function componentAddressById(uint8) external view returns (address);
+
+    /// @dev @return True if address is router configurator, otherwise false
+    function isRouterConfigurator(address account) external view returns (bool);
+}

package/contracts/IWETHGateway.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2022
+pragma solidity ^0.8.10;
+
+interface IWETHGateway {
+    /// @dev Converts ETH to WETH and add liqudity to the pool
+    /// @param pool Address of PoolService contract to add liquidity to. This pool must have WETH as an underlying.
+    /// @param onBehalfOf The address that will receive the diesel token.
+    /// @param referralCode Code used to log the transaction facilitator, for potential rewards. 0 if non-applicable.
+    function addLiquidityETH(
+        address pool,
+        address onBehalfOf,
+        uint16 referralCode
+    ) external payable;
+
+    /// @dev Removes liquidity from the pool and converts WETH to ETH
+    ///       - burns lp's diesel (LP) tokens
+    ///       - unwraps WETH to ETH and sends to the LP
+    /// @param pool Address of PoolService contract to withdraw liquidity from. This pool must have WETH as an underlying.
+    /// @param amount Amount of Diesel tokens to send.
+    /// @param to Address to transfer ETH to.
+    function removeLiquidityETH(
+        address pool,
+        uint256 amount,
+        address payable to
+    ) external;
+
+    /// @dev Converts WETH to ETH, and sends to the passed address
+    /// @param to Address to send ETH to
+    /// @param amount Amount of WETH to unwrap
+    function unwrapWETH(address to, uint256 amount) external;
+}

package/contracts/IwstETHGateway.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+interface IwstETHGateWay {
+    error NonRegisterPoolException();
+
+    /**
+     * @dev Adds stETH liquidity to wstETH pool
+     * - transfers the underlying to the pool
+     * - mints Diesel (LP) tokens to onBehalfOf
+     * @param amount Amount of tokens to be deposited
+     * @param onBehalfOf The address that will receive the dToken
+     * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
+     *   0 if the action is executed directly by the user, without a facilitator.
+     */
+    function addLiquidity(uint256 amount, address onBehalfOf, uint256 referralCode) external;
+
+    /// @dev Removes liquidity from pool
+    ///  - burns LP's Diesel (LP) tokens
+    ///  - returns the equivalent amount of underlying to 'to'
+    /// @param amount Amount of Diesel tokens to burn
+    /// @param to Address to transfer the underlying to
+    function removeLiquidity(uint256 amount, address to) external returns (uint256 amountGet);
+}

package/contracts/index.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: UNLICENSED
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2023.
+
+pragma solidity ^0.8.10;
+
+import {IDataCompressorV2_10} from "@gearbox-protocol/periphery-v3/contracts/interfaces/IDataCompressorV2_10.sol";
+import {IDataCompressorV3_00} from "@gearbox-protocol/periphery-v3/contracts/interfaces/IDataCompressorV3_00.sol";
+import {IAddressProviderV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IAddressProviderV3.sol";
+import {IPoolV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IPoolV3.sol";
+import {ICreditFacadeV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditFacadeV3.sol";
+import {IPoolService} from "@gearbox-protocol/core-v2/contracts/interfaces/IPoolService.sol";
+import {ICreditFacadeV2} from "@gearbox-protocol/core-v2/contracts/interfaces/ICreditFacadeV2.sol";
+import {ICreditConfiguratorV2} from "@gearbox-protocol/core-v2/contracts/interfaces/ICreditConfiguratorV2.sol";
+import {IWERC20Zapper} from "@gearbox-protocol/integrations-v3/contracts/interfaces/zappers/IWERC20Zapper.sol";
+import {IWETHZapper} from "@gearbox-protocol/integrations-v3/contracts/interfaces/zappers/IWETHZapper.sol";
+
+// Adapters
+import {ILidoV1Adapter} from "@gearbox-protocol/integrations-v3/contracts/interfaces/lido/ILidoV1Adapter.sol";
+import {IBaseRewardPool} from "@gearbox-protocol/integrations-v3/contracts/integrations/convex/IBaseRewardPool.sol";
+import {IConvexToken} from "@gearbox-protocol/integrations-v3/contracts/integrations/convex/IConvexToken.sol";
+import {ICurvePool} from "@gearbox-protocol/integrations-v3/contracts/integrations/curve/ICurvePool.sol";
+import {IConvexV1BaseRewardPoolAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/convex/IConvexV1BaseRewardPoolAdapter.sol";
+import {IConvexV1BoosterAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/convex/IConvexV1BoosterAdapter.sol";
+
+import {IInterestRateModel} from "@gearbox-protocol/core-v2/contracts/interfaces/IInterestRateModel.sol";
+import {IUniswapV2Adapter} from "@gearbox-protocol/integrations-v3/contracts/interfaces/uniswap/IUniswapV2Adapter.sol";
+import {IUniswapV3Adapter} from "@gearbox-protocol/integrations-v3/contracts/interfaces/uniswap/IUniswapV3Adapter.sol";
+import {IYVault} from "@gearbox-protocol/integrations-v3/contracts/integrations/yearn/IYVault.sol";
+import {IYearnV2Adapter} from "@gearbox-protocol/integrations-v3/contracts/interfaces/yearn/IYearnV2Adapter.sol";
+
+import {IwstETHV1Adapter} from "@gearbox-protocol/integrations-v3/contracts/interfaces/lido/IwstETHV1Adapter.sol";
+import {IstETH} from "@gearbox-protocol/integrations-v3/contracts/integrations/lido/IstETH.sol";
+import {IwstETH} from "@gearbox-protocol/integrations-v3/contracts/integrations/lido/IwstETH.sol";
+import {IPriceOracleBase} from "@gearbox-protocol/core-v2/contracts/interfaces/IPriceOracleBase.sol";
+
+import {ICurveV1_2AssetsAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/curve/ICurveV1_2AssetsAdapter.sol";
+
+import {ICurveV1_3AssetsAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/curve/ICurveV1_3AssetsAdapter.sol";
+
+import {ICurveV1_4AssetsAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/curve/ICurveV1_4AssetsAdapter.sol";
+
+import {IOffchainOracle} from "./IOffchainOracle.sol";

package/lib/apy/convexAPY.d.ts

@@ -29,7 +29,7 @@ export interface GetConvexAPYBulkCallsProps {
 }
 export declare function getConvexAPYBulkCalls({ pools, networkType, }: GetConvexAPYBulkCallsProps): {
     poolsInfo: PoolInfo[];
-    calls: [MCall<import("../types/@gearbox-protocol/integrations-v2/contracts/integrations/convex/IBaseRewardPool").IBaseRewardPoolInterface>, MCall<import("../types/@gearbox-protocol/integrations-v2/contracts/integrations/convex/IBaseRewardPool").IBaseRewardPoolInterface>, MCall<import("../types/@gearbox-protocol/integrations-v2/contracts/integrations/convex/IBaseRewardPool").IBaseRewardPoolInterface>, MCall<import("../types/@gearbox-protocol/integrations-v2/contracts/integrations/curve/ICurvePool").ICurvePoolInterface>, MCall<import("../types/@gearbox-protocol/integrations-v2/contracts/integrations/convex/IConvexToken").IConvexTokenInterface>, ...(MCall<import("../types/@gearbox-protocol/integrations-v2/contracts/integrations/convex/IBaseRewardPool").IBaseRewardPoolInterface> | MCall<any>)[]][];
+    calls: [MCall<import("../types/IBaseRewardPool").IBaseRewardPoolInterface>, MCall<import("../types/IBaseRewardPool").IBaseRewardPoolInterface>, MCall<import("../types/IBaseRewardPool").IBaseRewardPoolInterface>, MCall<import("../types/ICurvePool").ICurvePoolInterface>, MCall<import("../types/IConvexToken").IConvexTokenInterface>, ...(MCall<import("../types/IBaseRewardPool").IBaseRewardPoolInterface> | MCall<any>)[]][];
 };
 export interface CalculateConvexAPYProps {
     cvxPoolRate: bigint;

package/lib/apy/convexAPY.js

@@ -5,7 +5,6 @@ const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const token_1 = require("@gearbox-protocol/sdk-gov/lib/tokens/token");
 const utils_1 = require("ethers/lib/utils");
 const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
 const V2_POOLS = { 20: true };
 function getConvexAPYBulk(props) {
     const { poolsInfo, calls } = props.generated;
@@ -24,14 +23,14 @@ function getConvexAPYBulk(props) {
         const lpPriceEnd = extraFinishEnd + crvLpPriceList.length;
         const crvLpPrice = rest.slice(extraFinishEnd, lpPriceEnd);
         const apy = calculateConvexAPY({
-            cvxPoolRewardsFinish: (0, formatter_1.toBigInt)(cvxPoolRewardsFinish),
-            cvxPoolRate: (0, formatter_1.toBigInt)(cvxPoolRate),
-            cvxPoolSupply: (0, formatter_1.toBigInt)(cvxPoolSupply),
-            crvVPrice: (0, formatter_1.toBigInt)(crvVPrice),
-            cvxTokenSupply: (0, formatter_1.toBigInt)(cvxTokenSupply),
-            cvxExtraRewards: cvxExtraRewards.map(v => (0, formatter_1.toBigInt)(v)),
-            cvxExtraRewardsFinish: cvxExtraRewardsFinish.map(v => (0, formatter_1.toBigInt)(v)),
-            crvLpPrice: crvLpPrice.map(v => (0, formatter_1.toBigInt)(v)),
+            cvxPoolRewardsFinish: (0, sdk_gov_1.toBigInt)(cvxPoolRewardsFinish),
+            cvxPoolRate: (0, sdk_gov_1.toBigInt)(cvxPoolRate),
+            cvxPoolSupply: (0, sdk_gov_1.toBigInt)(cvxPoolSupply),
+            crvVPrice: (0, sdk_gov_1.toBigInt)(crvVPrice),
+            cvxTokenSupply: (0, sdk_gov_1.toBigInt)(cvxTokenSupply),
+            cvxExtraRewards: cvxExtraRewards.map(v => (0, sdk_gov_1.toBigInt)(v)),
+            cvxExtraRewardsFinish: cvxExtraRewardsFinish.map(v => (0, sdk_gov_1.toBigInt)(v)),
+            crvLpPrice: crvLpPrice.map(v => (0, sdk_gov_1.toBigInt)(v)),
             info: poolsInfo[i],
             getTokenPrice: props.getTokenPrice,
             curveAPY: props.curveAPY,

package/lib/apy/yearnAPY.js

@@ -8,7 +8,7 @@ const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const axios_1 = __importDefault(require("axios"));
 const formatter_1 = require("../utils/formatter");
 const RESPONSE_DECIMALS = 1;
-const URL = "https://api.yearn.finance/v1/chains/1/vaults/all";
+const URL = "https://api.yexporter.io/v1/chains/1/vaults/all";
 const transformSymbol = (s) => s.replaceAll("_", "-").toLowerCase();
 async function getYearnAPY() {
     try {

package/lib/config.d.ts

@@ -1,2 +1 @@
 export declare const STATIC_TOKEN = "https://static.gearbox.fi/tokens/";
-export declare const MULTICALL_ADDRESS = "0x5ba1e12693dc8f9c48aad8770482f4739beed696";

package/lib/config.js

@@ -1,5 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MULTICALL_ADDRESS = exports.STATIC_TOKEN = void 0;
+exports.STATIC_TOKEN = void 0;
 exports.STATIC_TOKEN = "https://static.gearbox.fi/tokens/";
-exports.MULTICALL_ADDRESS = "0x5ba1e12693dc8f9c48aad8770482f4739beed696";

package/lib/core/assets.d.ts

@@ -16,12 +16,12 @@ interface NextAssetProps<T extends Asset> {
     tokensList: Record<string, TokenData>;
     prices?: Record<string, bigint>;
 }
-export type WrapResult<T> = [Array<T>, bigint, bigint];
+export type WrapResult = [Array<Asset>, bigint, bigint];
 export declare class AssetUtils {
     static nextAsset<T extends Asset>({ allowedTokens, selectedAssets, balances, tokensList, prices, }: NextAssetProps<T>): string | undefined;
     static getBalances(allowedTokens: Array<string>, externalBalances: Record<string, bigint>): Record<string, bigint>;
     static constructAssetRecord<A extends Asset>(a: Array<A>): Record<string, A>;
-    static memoWrapETH: (ethAddress: string, wethAddress: string) => <T extends Asset>(assets: T[]) => WrapResult<T>;
+    static memoWrap: (unwrappedAddress: string, wrappedAddress: string, prices: Record<string, bigint>, tokensList: Record<string, TokenData>) => (assets: Array<Asset>) => WrapResult;
     /**
      * Sums the the second assets list into the first assets list
      * Creates new assets.

package/lib/core/assets.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetUtils = void 0;
 const math_1 = require("../utils/math");
+const price_1 = require("../utils/price");
 const creditAccount_1 = require("./creditAccount");
 class AssetUtils {
     static nextAsset({ allowedTokens, selectedAssets, balances, tokensList, prices = {}, }) {
@@ -33,24 +34,34 @@ class AssetUtils {
         }, {});
         return record;
     }
-    static memoWrapETH = (ethAddress, wethAddress) => function wrapETH(assets) {
+    static memoWrap = (unwrappedAddress, wrappedAddress, prices, tokensList) => function wrap(assets) {
         const assetsRecord = AssetUtils.constructAssetRecord(assets);
-        const weth = assetsRecord[wethAddress];
-        const { balance: wethAmount = 0n } = weth || {};
-        const eth = assetsRecord[ethAddress];
-        const { balance: ethAmount = 0n } = eth || {};
-        const wethOrETH = weth || eth;
-        if (wethOrETH) {
-            assetsRecord[wethAddress] = {
-                ...wethOrETH,
-                token: wethAddress,
-                balance: (0, math_1.nonNegativeBn)(ethAmount) + (0, math_1.nonNegativeBn)(wethAmount),
+        const unwrapped = assetsRecord[unwrappedAddress];
+        const { balance: unwrappedAmount = 0n } = unwrapped || {};
+        const wrapped = assetsRecord[wrappedAddress];
+        const { balance: wrappedAmount = 0n } = wrapped || {};
+        // if there unwrapped token
+        if (unwrapped) {
+            const unwrappedToken = tokensList[unwrappedAddress];
+            const unwrappedPrice = prices[unwrappedAddress] || 0n;
+            const wrappedToken = tokensList[wrappedAddress];
+            const wrappedPrice = prices[wrappedAddress] || 0n;
+            // convert unwrapped into wrapped by price
+            const unwrappedInWrapped = price_1.PriceUtils.convertByPrice(price_1.PriceUtils.calcTotalPrice(unwrappedPrice, (0, math_1.nonNegativeBn)(unwrappedAmount), unwrappedToken.decimals), {
+                price: wrappedPrice,
+                decimals: wrappedToken.decimals,
+            });
+            // sum them
+            assetsRecord[wrappedAddress] = {
+                token: wrappedAddress,
+                balance: (0, math_1.nonNegativeBn)(wrappedAmount) + unwrappedInWrapped,
             };
+            // remove unwrapped
+            delete assetsRecord[unwrappedAddress];
+            return [Object.values(assetsRecord), unwrappedInWrapped, wrappedAmount];
         }
-        if (eth) {
-            delete assetsRecord[ethAddress];
-        }
-        return [Object.values(assetsRecord), ethAmount, wethAmount];
+        // else no actions needed
+        return [Object.values(assetsRecord), unwrappedAmount, wrappedAmount];
     };
     /**
      * Sums the the second assets list into the first assets list

package/lib/core/creditAccount.d.ts

@@ -1,9 +1,7 @@
 import { LpTokensAPY } from "../apy";
-import { CreditAccountDataPayload } from "../payload/creditAccount";
+import { CaTokenBalance, CreditAccountDataPayload, ScheduledWithdrawal } from "../payload/creditAccount";
 import { TokenData } from "../tokens/tokenData";
 import { Asset } from "./assets";
-import { CreditManagerData } from "./creditManager";
-import { PriceOracleData } from "./priceOracle";
 export interface CalcOverallAPYProps {
     caAssets: Array<Asset>;
     lpAPY: LpTokensAPY | undefined;
@@ -23,36 +21,45 @@ export interface CalcHealthFactorProps {
 export declare class CreditAccountData {
     readonly addr: string;
     readonly borrower: string;
-    readonly inUse: boolean;
     readonly creditManager: string;
+    readonly creditFacade: string;
     readonly underlyingToken: string;
     readonly since: number;
-    readonly cumulativeIndexAtOpen: bigint;
+    readonly expirationDate: number;
+    readonly version: number;
+    readonly enabledTokenMask: bigint;
+    readonly healthFactor: number;
+    isDeleting: boolean;
+    readonly baseBorrowRate: number;
+    readonly borrowRate: number;
     readonly borrowedAmount: bigint;
+    readonly accruedInterest: bigint;
+    readonly accruedFees: bigint;
+    readonly totalDebtUSD: bigint;
     readonly borrowedAmountPlusInterestAndFees: bigint;
-    readonly borrowedAmountPlusInterest: bigint;
     readonly totalValue: bigint;
-    healthFactor: number;
-    readonly borrowRate: number;
-    isDeleting: boolean;
-    readonly enabledTokenMask: bigint;
-    readonly version: number;
-    readonly collateralTokens: Array<string>;
-    readonly allTokens: Array<string>;
-    readonly forbiddenTokens: Array<string>;
+    readonly totalValueUSD: bigint;
+    readonly twvUSD: bigint;
+    readonly cumulativeIndexNow: bigint;
+    readonly cumulativeIndexLastUpdate: bigint;
+    readonly cumulativeQuotaInterest: bigint;
+    readonly activeBots: string[];
+    readonly maxApprovedBots: bigint;
     readonly balances: Record<string, bigint>;
-    readonly allBalances: Record<string, bigint>;
-    readonly repayAmount: bigint;
-    readonly liquidationAmount: bigint;
-    readonly canBeClosed: boolean;
+    readonly collateralTokens: Array<string>;
+    readonly allBalances: Record<string, CaTokenBalance>;
+    readonly forbiddenTokens: Record<string, true>;
+    readonly quotedTokens: Record<string, true>;
+    readonly schedultedWithdrawals: Array<ScheduledWithdrawal>;
     constructor(payload: CreditAccountDataPayload);
+    setDeleteInProgress(d: boolean): void;
     balancesSorted(prices: Record<string, bigint>, tokens: Record<string, TokenData>): Array<Asset>;
     static sortBalances(balances: Record<string, bigint>, prices: Record<string, bigint>, tokens: Record<string, TokenData>): Array<[string, bigint]>;
     static tokensAbcComparator(t1?: TokenData, t2?: TokenData): 1 | -1;
     static amountAbcComparator(t1: bigint, t2: bigint): 1 | -1;
-    calcBorrowAmountPlusInterestRate(currentCumulativeIndex: bigint): bigint;
     isForbidden(token: string): boolean;
-    updateHealthFactor(creditManager: CreditManagerData, currentCumulativeIndex: bigint, priceOracle: PriceOracleData): void;
+    isQuoted(token: string): boolean;
+    isTokenEnabled(index: number): boolean;
     static isTokenEnabled(index: number, enabledTokenMask: bigint): boolean;
     static calcMaxDebtIncrease(healthFactor: number, borrowAmountPlusInterest: bigint, underlyingLT: number, minHf?: number): bigint;
     static calcOverallAPY({ caAssets, lpAPY, prices, totalValue, debt, borrowRate, underlyingToken, }: CalcOverallAPYProps): number | undefined;