@gearbox-protocol/sdk 16.0.0-next.2 → 16.0.0-next.21

package/dist/types/onchain/market/credit/CreditSuite.d.ts

@@ -0,0 +1,213 @@
+import { Timestamp } from "../../../model/primitives.js";
+import { StrategyOpportunity, StrategyOpportunityDetail } from "../../../model/opportunities.js";
+import "../../../model/index.js";
+import { CreditAccountData, CreditSuiteState } from "../../base/types.js";
+import { IRWAFactory, RWAOperationArgs } from "../rwa/types.js";
+import { CreditSuiteStateHuman } from "../../types/state-human.js";
+import { ICreditConfiguratorContract, ICreditFacadeContract, ICreditManagerContract, LiquidationFees, PartialLiquidationParams } from "./types.js";
+import { IRouterContract } from "../../router/types.js";
+import "../../router/index.js";
+import { MarketConfiguratorContract } from "../MarketConfiguratorContract.js";
+import { MarketSuite } from "../MarketSuite.js";
+import { MultiCall, RawTx } from "../../types/transactions.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import "../../types/index.js";
+import { SDKConstruct } from "../../base/SDKConstruct.js";
+import "../../base/index.js";
+import { Address } from "viem";
+//#region src/onchain/market/credit/CreditSuite.d.ts
+/**
+ * SDK aggregate for one credit-manager branch inside a market.
+ *
+ * @remarks
+ * This is the market's "retail branch": it borrows
+ * liquidity from the pool to open credit accounts under an isolated mandate.
+ * The suite groups the three contracts that define that branch:
+ * `creditManager` for debt, collateral, adapters, and account accounting;
+ * `creditFacade` for user-facing account operations and multicalls; and
+ * `creditConfigurator` for risk-parameter and adapter configuration.
+ */
+declare class CreditSuite extends SDKConstruct {
+  #private;
+  /**
+   * Pool that supplies underlying liquidity to this credit manager.
+   */
+  readonly pool: Address;
+  /**
+   * Wrapper around the core credit manager contract.
+   *
+   * @remarks
+   * The credit manager owns account accounting, collateral checks, enabled
+   * collateral token masks, adapter mappings, debt updates, and liquidation
+   * calculations for this branch.
+   */
+  readonly creditManager: ICreditManagerContract;
+  /**
+   * Wrapper around the credit facade contract used to build account
+   * transactions such as open, close, liquidate, and multicall.
+   */
+  readonly creditFacade: ICreditFacadeContract;
+  /**
+   * Wrapper around the credit configurator that mutates risk
+   * parameters, collateral tokens, adapter permissions, and facade settings.
+   */
+  readonly creditConfigurator: ICreditConfiguratorContract;
+  /**
+   * Original compressor contract snapshot for this credit suite.
+   */
+  readonly state: CreditSuiteState;
+  /**
+   * Human-readable credit manager name from the core contract state.
+   */
+  readonly name: string;
+  /**
+   * Creates a credit suite from one entry in a market compressor snapshot.
+   *
+   * @param sdk - Attached SDK instance.
+   * @param data - Parent market snapshot part that contains the credit suite data.
+   */
+  constructor(sdk: OnchainSDK, data: CreditSuiteState);
+  /**
+   * Token borrowed from the pool and used as the account debt asset.
+   */
+  get underlying(): Address;
+  /**
+   * Parent market that contains this credit manager
+   */
+  get market(): MarketSuite;
+  /**
+   * Market configurator that governs this credit suite and its parent pool.
+   */
+  get marketConfigurator(): MarketConfiguratorContract;
+  /**
+   * Factory that opens and manages the accounts of this suite, defined only
+   * for RWA markets.
+   */
+  get rwaFactory(): IRWAFactory | undefined;
+  /**
+   * Builds a transaction that executes a multicall on one of this suite's
+   * credit accounts.
+   *
+   * @param creditAccount - Account to operate on.
+   * @param calls - Multicall body.
+   * @param rwaOptions - Factory-specific args, ignored on non-RWA markets.
+   */
+  multicallTx(creditAccount: Address, calls: MultiCall[], rwaOptions?: RWAOperationArgs): RawTx;
+  /**
+   * Builds a transaction that opens a new credit account in this suite.
+   *
+   * @param to - Owner of the new account.
+   * @param calls - Multicall body executed on the new account.
+   * @param referralCode - Referral code, facade path only.
+   * @param rwaOptions - Factory-specific args, ignored on non-RWA markets.
+   */
+  openCreditAccountTx(to: Address, calls: MultiCall[], referralCode?: bigint, rwaOptions?: RWAOperationArgs): RawTx;
+  /**
+   * Router configured for this credit suite.
+   */
+  get router(): IRouterContract;
+  /**
+   * Whether this suite's facade is past its configured expiration timestamp.
+   *
+   * @remarks
+   * Expired credit suites can have different liquidation parameters on-chain.
+   * Non-expirable facades and facades with zero expiration are treated as not
+   * expired.
+   */
+  get isExpired(): boolean;
+  /**
+   * Moment the facade expires, after which positions can no longer be opened
+   * and open ones become liquidatable, or `null` when it is not expirable.
+   *
+   * @remarks
+   * The facade stores `0` for a non-expirable suite, which as a timestamp
+   * would read as 1970 rather than as "never".
+   */
+  get expirationDate(): Timestamp | null;
+  /**
+   * Liquidation fee pair in effect right now, resolving {@link isExpired} once
+   * for both.
+   */
+  liquidationFees(): LiquidationFees;
+  /**
+   * Whether this suite can be used right now. A paused pool blocks borrowing,
+   * so the suite is unusable even when its own facade is live.
+   */
+  get isPaused(): boolean;
+  /**
+   * Tokens forbidden by the facade.
+   */
+  get forbiddenTokens(): Address[];
+  /**
+   * The single target collateral of this suite's strategy, or `undefined` when
+   * none can be resolved.
+   *
+   * Resolution, in order:
+   * 1. a hardcoded legacy mapping for this credit manager, when that token is
+   *    still a collateral of the manager (it may be absent on an older
+   *    snapshot, or after it was delisted);
+   * 2. the collateral with the biggest index in
+   *    {@link ICreditManagerContract.collateralTokens} that
+   *    {@link isStrategyCollateral} accepts with quota required;
+   * 3. the biggest-index collateral that {@link isStrategyCollateral} accepts
+   *    without quota.
+   */
+  get strategyTargetCollateral(): Address | undefined;
+  /**
+   * Largest debt a single new position can take on right now: the tightest of
+   * this manager's remaining debt limit, the pool's free liquidity and the
+   * facade's per-account maximum.
+   */
+  get maxBorrowAmount(): bigint;
+  /**
+   * Display name of this suite's leveraged strategy, e.g. `"wstETH / WETH"`,
+   * or `undefined` when {@link strategyTargetCollateral} cannot be resolved.
+   */
+  get strategyName(): string | undefined;
+  /**
+   * Describes this suite's leveraged strategy as the shared read model does,
+   * or `undefined` when {@link strategyTargetCollateral} cannot be resolved or
+   * {@link maxBorrowAmount} is at or below {@link MIN_STRATEGY_BORROW_AMOUNT}.
+   */
+  strategyOpportunity(): StrategyOpportunity | undefined;
+  /**
+   * {@link strategyOpportunity} plus the data only its detail screen needs.
+   */
+  strategyOpportunityDetail(): StrategyOpportunityDetail | undefined;
+  /**
+   * Everything a partial liquidation of credit account needs, with any parameter the
+   * caller pinned down taken as given and the rest derived from current state.
+   *
+   * @param ca - Credit account to partially liquidate.
+   * @param overrides - Parameters to use instead of the derived defaults.
+   * @throws If a derived `tokenOut` cannot be picked, or if the seized token is
+   * not a collateral token of this credit manager.
+   */
+  partialLiquidationParams(ca: CreditAccountData, overrides?: PartialLiquidationParams): Required<PartialLiquidationParams>;
+  /**
+   * Health factor a partial liquidation of `ca` should target, in basis points.
+   *
+   * @param ca - Credit account to partially liquidate.
+   */
+  optimalHFForPartialLiquidation(ca: CreditAccountData): bigint;
+  /**
+   * Whether the facade, manager, or configurator has observed logs that require
+   * a credit-suite resync.
+   */
+  get dirty(): boolean;
+  /**
+   * Credit contracts whose events are enough to detect stale suite state.
+   *
+   * @internal
+   */
+  get watchAddresses(): Set<Address>;
+  /**
+   * Returns a label-enriched, JSON-friendly view of this credit suite.
+   *
+   * @param raw - Whether child wrappers should keep raw numeric values instead
+   * of applying human formatting where they support both modes.
+   */
+  stateHuman(raw?: boolean): CreditSuiteStateHuman;
+}
+//#endregion
+export { CreditSuite };

package/dist/types/onchain/market/credit/collateralUtils.d.ts

@@ -0,0 +1,96 @@
+import { CreditAccountData } from "../../base/types.js";
+import { MarketSuite } from "../MarketSuite.js";
+import "../../base/index.js";
+import { Address } from "viem";
+//#region src/onchain/market/credit/collateralUtils.d.ts
+/**
+ * Inputs of {@link isStrategyCollateral} and {@link pickStrategyTargetCollateral},
+ * all resolved against the credit manager, market, and token metadata by the
+ * caller.
+ */
+interface StrategyCollateralProps {
+  /**
+   * Candidate collateral token.
+   **/
+  token: Address;
+  /**
+   * Credit manager underlying (debt asset).
+   **/
+  underlying: Address;
+  /**
+   * Token the market's underlying wraps (same as `underlying` on non-RWA
+   * markets).
+   */
+  unwrappedUnderlying: Address;
+  /**
+   * Liquidation threshold of the token in this credit manager, in bps.
+   **/
+  liquidationThreshold: number;
+  /**
+   * Gearbox contract type of the token (e.g. `"PHANTOM_TOKEN::CONVEX"`).
+   * Optional — plain tokens have none.
+   */
+  contractType?: string;
+  /**
+   * Whether the token itself is expired (e.g. a matured Pendle PT). Optional
+   * — treated as not expired when absent.
+   */
+  isExpired?: boolean;
+  /**
+   * Latest main oracle price for the token in USD (8 decimals), `undefined`
+   * when there is no feed. A failed answer is `0` — PriceFeedCompressor
+   * guarantees `price == 0` when `success == false`.
+   */
+  mainPrice?: bigint;
+  /**
+   * Whether the market still accepts quota for the token.
+   **/
+  hasActiveQuota: boolean;
+}
+/**
+ * Whether a collateral token can be the target of a leveraged strategy.
+ *
+ * A token qualifies when it
+ *
+ * - has a liquidation threshold above `0` and below `100%`, and is not the
+ *   suite's underlying — borrowing an asset against itself is not a position,
+ *   and an LT of `0` or at least `100%` would mean unbounded leverage;
+ * - is not the token the market's underlying wraps, which for an RWA market
+ *   is the same exposure as the underlying itself (also rejected when
+ *   `contractType` starts with `"RWA_UNDERLYING::"`);
+ * - is not a withdrawal or redemption phantom token listed in
+ *   {@link NON_STRATEGY_PHANTOM_TOKEN_TYPES} — those only ever appear as the
+ *   intermediate step of a withdrawal and cannot be acquired;
+ * - is not an expired token, e.g. a matured Pendle PT;
+ * - has a non-zero main price in the market's oracle — a zero or missing
+ *   answer (e.g. a failed or zero price feed) means the position cannot be
+ *   valued.
+ *
+ * Pass `requireQuota` as `true` to also require that the market still accepts
+ * quota for the token.
+ */
+declare function isStrategyCollateral({ token, underlying, unwrappedUnderlying, liquidationThreshold, contractType, isExpired, mainPrice, hasActiveQuota }: StrategyCollateralProps, requireQuota?: boolean): boolean;
+/**
+ * Picks the single strategy target from a credit manager's collateral list.
+ *
+ * Walks {@link tokens} from the end (biggest index first) and returns the
+ * first token that {@link isStrategyCollateral} accepts with quota required.
+ * If none has an active quota, returns the biggest-index candidate that
+ * qualifies without quota. `undefined` when nothing qualifies. A hardcoded
+ * legacy mapping, when present, is applied by the caller before this function.
+ **/
+declare function pickStrategyTargetCollateral(tokens: StrategyCollateralProps[]): Address | undefined;
+/**
+ * The account's dominant collateral: the most valuable enabled non-underlying
+ * token it holds above dust, by USD value.
+ *
+ * Used to pick the collateral a partial liquidation seizes by default.
+ *
+ * @param account - Account to inspect.
+ * @param market - Market of the account, whose oracle prices the candidates.
+ * @returns The dominant collateral, or `undefined` when the account holds
+ * nothing but its underlying, or nothing the oracle can price.
+ **/
+declare function dominantCollateral(account: CreditAccountData, market: MarketSuite): Address | undefined;
+//#endregion
+export { StrategyCollateralProps, dominantCollateral, isStrategyCollateral, pickStrategyTargetCollateral };

package/dist/types/onchain/market/credit/createCreditConfigurator.d.ts

@@ -0,0 +1,8 @@
+import { CreditSuiteState } from "../../base/types.js";
+import { ICreditConfiguratorContract } from "./types.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import "../../base/index.js";
+//#region src/onchain/market/credit/createCreditConfigurator.d.ts
+declare function createCreditConfigurator(sdk: OnchainSDK, data: CreditSuiteState): ICreditConfiguratorContract;
+//#endregion
+export { createCreditConfigurator as default };

package/dist/types/onchain/market/credit/createCreditFacade.d.ts

@@ -0,0 +1,8 @@
+import { CreditSuiteState } from "../../base/types.js";
+import { ICreditFacadeContract } from "./types.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import "../../base/index.js";
+//#region src/onchain/market/credit/createCreditFacade.d.ts
+declare function createCreditFacade(sdk: OnchainSDK, data: CreditSuiteState): ICreditFacadeContract;
+//#endregion
+export { createCreditFacade as default };

package/dist/types/onchain/market/credit/createCreditManager.d.ts

@@ -0,0 +1,8 @@
+import { CreditSuiteState } from "../../base/types.js";
+import { ICreditManagerContract } from "./types.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import "../../base/index.js";
+//#region src/onchain/market/credit/createCreditManager.d.ts
+declare function createCreditManager(sdk: OnchainSDK, data: CreditSuiteState): ICreditManagerContract;
+//#endregion
+export { createCreditManager as default };

package/dist/types/onchain/market/credit/expectedBalanceDeltas.d.ts

@@ -0,0 +1,39 @@
+import { BalanceDelta } from "./types.js";
+import { Address } from "viem";
+//#region src/onchain/market/credit/expectedBalanceDeltas.d.ts
+/**
+ * One token amount a multicall is expected to produce on the credit account.
+ * `WithdrawalOutput` satisfy it without this module knowing about them.
+ */
+interface ExpectedOutput {
+  token: Address;
+  /**
+   * Non-negative amount of `token` the multicall is expected to produce.
+   */
+  amount: bigint;
+}
+/**
+ * Props for {@link expectedBalanceDeltas}.
+ */
+interface ExpectedBalanceDeltasProps {
+  /**
+   * Amounts the multicall is expected to produce, summed per token.
+   */
+  outputs: readonly ExpectedOutput[];
+  /**
+   * Token the multicall spends, e.g. the source token of a delayed withdrawal
+   * request or the withdrawal phantom token burned by a claim.
+   */
+  spentToken: Address;
+  /**
+   * Amount of `spentToken` spent. No negative delta is emitted when it is 0.
+   */
+  spentAmount: bigint;
+}
+/**
+ * Builds the `storeExpectedBalances` deltas of a multicall from the amounts it
+ * is expected to produce and the token it spends.
+ */
+declare function expectedBalanceDeltas({ outputs, spentToken, spentAmount }: ExpectedBalanceDeltasProps): BalanceDelta[];
+//#endregion
+export { ExpectedBalanceDeltasProps, ExpectedOutput, expectedBalanceDeltas };

package/dist/types/onchain/market/credit/types.d.ts

@@ -0,0 +1,313 @@
+import { Bps, Leverage } from "../../../model/primitives.js";
+import "../../../model/index.js";
+import { AddressMap } from "../../utils/AddressMap.js";
+import { Asset, IBaseContract, PermitResult } from "../../base/types.js";
+import { CreditConfiguratorStateHuman, CreditFacadeStateHuman, CreditManagerStateHuman } from "../../types/state-human.js";
+import { IAdapterContract } from "../adapters/types.js";
+import "../adapters/index.js";
+import { PriceUpdate } from "../pricefeeds/types.js";
+import "../pricefeeds/index.js";
+import { RampEvent } from "./CreditConfiguratorV310Contract.js";
+import { MultiCall, RawTx } from "../../types/transactions.js";
+import "../../utils/index.js";
+import "../../types/index.js";
+import "../../base/index.js";
+import { Address, Hex } from "viem";
+//#region src/onchain/market/credit/types.d.ts
+interface ICreditConfiguratorContract extends IBaseContract {
+  isPaused: boolean;
+  checkRamps: () => Promise<RampEvent[]>;
+  stateHuman: (raw?: boolean) => CreditConfiguratorStateHuman;
+}
+/**
+ * Fee parameters of a liquidation, with the suite's expiration already resolved.
+ **/
+interface LiquidationFees {
+  /** Protocol's cut of the liquidated collateral, in basis points. */
+  feeLiquidation: Bps;
+  /** Price the liquidator pays for collateral, in basis points. */
+  liquidationDiscount: Bps;
+}
+/**
+ * Expected balance change of one token, as the facade's `storeExpectedBalances`
+ * takes it. Negative amounts mark tokens the multicall spends.
+ */
+interface BalanceDelta {
+  token: Address;
+  /**
+   * Signed balance change, `int256` on-chain.
+   */
+  amount: bigint;
+}
+/**
+ * Quota a credit account currently holds for one token, in pool underlying
+ * units. Enough to decide whether the quota needs a disabling call.
+ */
+interface CreditAccountTokenQuota {
+  token: Address;
+  quota: bigint;
+}
+/**
+ * Quota `Asset.balance` values are denominated in **pool underlying token
+ * units**, not in the quoted token's own units.
+ **/
+interface PrepareUpdateQuotasProps {
+  /**
+   * Average quota for desired token, in pool underlying units
+   * (see {@link PrepareUpdateQuotasProps})
+   */
+  averageQuota: Array<Asset>;
+  /**
+   * Minimum quota for desired token, in pool underlying units.
+   * The credit facade rounds quota changes down to a multiple of
+   * `PERCENTAGE_FACTOR`; the min quota bound must not exceed the rounded
+   * value, otherwise the quota keeper reverts with
+   * `QuotaIsOutOfBoundsException`.
+   */
+  minQuota: Array<Asset>;
+}
+/**
+ * Wrapper around the core credit manager contract.
+ */
+interface ICreditManagerContract extends IBaseContract {
+  /**
+   * Account factory contract address.
+   */
+  accountFactory: Address;
+  /**
+   * Underlying token address.
+   */
+  underlying: Address;
+  /**
+   * Address of the pool credit manager is connected to.
+   */
+  pool: Address;
+  /**
+   * Address of the connected credit facade.
+   */
+  creditFacade: Address;
+  /**
+   * Address of the connected credit configurator.
+   */
+  creditConfigurator: Address;
+  /**
+   * Maximum number of tokens that a credit account can have enabled as collateral.
+   */
+  maxEnabledTokens: number;
+  /**
+   * Percentage of accrued interest in bps taken by the protocol as profit.
+   */
+  feeInterest: number;
+  /**
+   * Percentage of liquidated account value in bps taken by the protocol as profit.
+   */
+  feeLiquidation: number;
+  /**
+   * Percentage of liquidated account value in bps that is used to repay debt
+   * (i.e. `100% - liquidation premium`).
+   */
+  liquidationDiscount: number;
+  /**
+   * Percentage of liquidated expired account value in bps taken by the protocol as profit.
+   */
+  feeLiquidationExpired: number;
+  /**
+   * Percentage of liquidated expired account value in bps that is used to repay debt.
+   */
+  liquidationDiscountExpired: number;
+  /**
+   * Mapping targetContract => adapter
+   */
+  adapters: AddressMap<IAdapterContract>;
+  /**
+   * Mapping collateral token address => liquidation threshold
+   */
+  liquidationThresholds: AddressMap<number>;
+  /**
+   * List of collateral tokens
+   */
+  collateralTokens: Address[];
+  /**
+   * Percentage of liquidated account value in bps paid to the liquidator
+   * (i.e. `100% - liquidationDiscount`).
+   */
+  readonly liquidationPremium: Bps;
+  /**
+   * Highest total-value leverage a collateral's liquidation threshold allows.
+   *
+   * @param collateral - Collateral token address.
+   * @param targetHF - Health factor the maxed position should leave, in basis
+   * points. Omitted keeps the flat buffer.
+   * @throws If the credit manager does not value the token.
+   */
+  maxLeverage: (collateral: Address, targetHF?: Bps) => Leverage;
+  stateHuman: (raw?: boolean) => CreditManagerStateHuman;
+}
+/**
+ * Wrapper around the credit facade contract used to build account
+ * transactions such as open, close, liquidate, and multicall.
+ */
+interface ICreditFacadeContract extends IBaseContract {
+  /**
+   * Degen NFT address (`address(0)` when Degen mode is disabled).
+   */
+  degenNFT: Address;
+  /**
+   * Bot list address.
+   */
+  botList: Address;
+  /**
+   * Whether the credit facade is expirable.
+   */
+  expirable: boolean;
+  /**
+   * Expiration timestamp (only meaningful when `expirable` is `true`).
+   */
+  expirationDate: number;
+  /**
+   * Maximum amount that can be borrowed by a credit manager in a single
+   * block, expressed as a multiple of `maxDebt`.
+   */
+  maxDebtPerBlockMultiplier: number;
+  /**
+   * Minimum credit account debt allowed by the facade, in underlying.
+   */
+  minDebt: bigint;
+  /**
+   * Maximum credit account debt allowed by the facade, in underlying.
+   */
+  maxDebt: bigint;
+  /**
+   * Bit mask encoding the set of forbidden tokens.
+   */
+  forbiddenTokensMask: bigint;
+  /**
+   * Whether the facade is currently paused.
+   */
+  isPaused: boolean;
+  /**
+   * Underlying token of the connected credit manager.
+   */
+  readonly underlying: Address;
+  stateHuman: (raw?: boolean) => CreditFacadeStateHuman;
+  /**
+   * Builds a raw transaction that liquidates a credit account.
+   *
+   * @param ca Credit account to liquidate.
+   * @param to Recipient of the liquidator's reward.
+   * @param calls Multicall body executed during liquidation.
+   * @param lossPolicyData Optional loss policy payload forwarded to the facade.
+   */
+  liquidateCreditAccount(ca: Address, to: Address, calls: MultiCall[], lossPolicyData?: Hex): RawTx;
+  /**
+   * Builds a raw transaction that partially liquidates a credit account's
+   * debt in exchange for discounted collateral.
+   */
+  partiallyLiquidateCreditAccount(ca: Address, token: Address, repaidAmount: bigint, minSeizedAmount: bigint, to: Address, updates: PriceUpdate[]): RawTx;
+  /**
+   * Builds a raw transaction that closes a credit account.
+   */
+  closeCreditAccount(ca: Address, calls: MultiCall[]): RawTx;
+  /**
+   * Builds a raw transaction that executes an owner-driven multicall on a
+   * credit account.
+   */
+  multicall(ca: Address, calls: MultiCall[]): RawTx;
+  /**
+   * Builds a raw transaction that executes a bot-driven multicall on a
+   * credit account.
+   */
+  botMulticall(ca: Address, calls: MultiCall[]): RawTx;
+  /**
+   * Builds a raw transaction that opens a new credit account.
+   */
+  openCreditAccount(to: Address, calls: MultiCall[], referralCode: bigint): RawTx;
+  /**
+   * Encodes an `increaseDebt` multicall entry.
+   */
+  prepareIncreaseDebt(amount: bigint): MultiCall;
+  /**
+   * Encodes an `increaseDebt` or `decreaseDebt` multicall entry.
+   */
+  prepareChangeDebt(change: bigint, isDecrease: boolean): MultiCall;
+  /**
+   * Encodes a `decreaseDebt` multicall entry that repays the whole debt.
+   */
+  prepareDecreaseDebtFull(): MultiCall;
+  /**
+   * Encodes a `withdrawCollateral` multicall entry.
+   */
+  prepareWithdrawCollateral(token: Address, amount: bigint, to: Address): MultiCall;
+  /**
+   * Encodes `addCollateral` / `addCollateralWithPermit` multicall entries, one
+   * per asset, using the permit when one is available for the asset's token.
+   */
+  prepareAddCollateral(assets: Asset[], permits: Record<string, PermitResult>): MultiCall[];
+  /**
+   * Encodes `updateQuota` multicall entries from average and min quota assets.
+   */
+  prepareUpdateQuotas(props: PrepareUpdateQuotasProps): MultiCall[];
+  /**
+   * Encodes `updateQuota` multicall entries that zero out the quotas the
+   * account currently holds.
+   */
+  prepareDisableQuotas(tokens: CreditAccountTokenQuota[]): MultiCall[];
+  /**
+   * Encodes a `setBotPermissions` multicall entry.
+   */
+  prepareSetBotPermissions(bot: Address, permissions: bigint): MultiCall;
+  /**
+   * Encodes an `onDemandPriceUpdates` multicall entry.
+   */
+  prepareOnDemandPriceUpdates(updates: PriceUpdate[]): MultiCall;
+  /**
+   * Encodes a `storeExpectedBalances` multicall entry.
+   */
+  prepareStoreExpectedBalances(deltas: BalanceDelta[]): MultiCall;
+  /**
+   * Encodes a `compareBalances` multicall entry.
+   */
+  prepareCompareBalances(): MultiCall;
+  /**
+   * Wraps `calls` in a `storeExpectedBalances` / `compareBalances` bracket, so
+   * that the facade asserts the multicall produced at least `deltas`.
+   */
+  prepareWithBalanceCheck(deltas: BalanceDelta[], calls: MultiCall[]): MultiCall[];
+}
+/**
+ * Partial liquidation parameters a caller wants to pin down instead of letting
+ * {@link CreditSuite.partialLiquidationParams} derive them.
+ *
+ * @remarks
+ * The defaults are derived in order - `optimalHF` feeds `repaidAmount`, which
+ * feeds `minSeizedAmount` - so overriding one still lets the ones after it
+ * follow from the override.
+ **/
+interface PartialLiquidationParams {
+  /**
+   * Collateral token to seize.
+   * If omitted, the most valuable enabled non-underlying collateral token
+   * (by oracle)
+   */
+  tokenOut?: Address;
+  /**
+   * Amount of underlying token to repay.
+   * If omitted, computed internally
+   */
+  repaidAmount?: bigint;
+  /**
+   * Minimum amount of `token` to seize from `creditAccount`.
+   * If `token` is a phantom token, it's withdrawn first, and its `depositedToken` is then sent to the liquidator.
+   * In this case, `minSeizedAmount` is denominated in `depositedToken`.
+   * If omitted, computed internally.
+   */
+  minSeizedAmount?: bigint;
+  /**
+   * Target health factor for partial liquidation (4 digits precision, 10000 = 100%).
+   * If omitted, defaults to {@link CreditSuite.optimalHFForPartialLiquidation}.
+   * Only used when `repaidAmount` is not explicitly provided.
+   */
+  optimalHF?: bigint;
+}
+//#endregion
+export { BalanceDelta, CreditAccountTokenQuota, ICreditConfiguratorContract, ICreditFacadeContract, ICreditManagerContract, LiquidationFees, PartialLiquidationParams, PrepareUpdateQuotasProps };