@gearbox-protocol/sdk 3.0.0-vfourabi.1 → 3.0.0-vfourabi.3

package/src/sdk/sdk-legacy/core/creditManager.ts

@@ -0,0 +1,316 @@
+import type { Address } from "viem";
+
+import { PERCENTAGE_DECIMALS, PERCENTAGE_FACTOR, RAY } from "../../constants";
+import { toBigInt } from "../../utils";
+import type {
+  ChartsCreditManagerPayload,
+  CreditManagerDataPayload,
+  QuotaInfo,
+} from "../payload/creditManager";
+
+export type CreditManagerType = "universal" | "trade" | "farm" | "restaking";
+
+export class CreditManagerData_Legacy {
+  readonly address: Address;
+  readonly type: CreditManagerType;
+  readonly underlyingToken: Address;
+  readonly pool: Address;
+  readonly creditFacade: Address; // V2 only: address of creditFacade
+  readonly creditConfigurator: Address; // V2 only: address of creditFacade
+  readonly degenNFT: Address; // V2 only: degenNFT, address(0) if not in degen mode
+  readonly isDegenMode: boolean;
+  readonly version: number;
+  readonly isPaused: boolean;
+  readonly forbiddenTokenMask: bigint; // V2 only: mask which forbids some particular tokens
+  readonly isBorrowingForbidden: boolean;
+  readonly maxEnabledTokensLength: number;
+  readonly name: string;
+  readonly tier: number;
+  readonly marketConfigurator: Address;
+
+  readonly baseBorrowRate: number;
+
+  readonly minDebt: bigint;
+  readonly maxDebt: bigint;
+  readonly availableToBorrow: bigint;
+  readonly totalDebt: bigint;
+  readonly totalDebtLimit: bigint;
+
+  readonly feeInterest: number;
+  readonly feeLiquidation: number;
+  readonly liquidationDiscount: number;
+  readonly feeLiquidationExpired: number;
+  readonly liquidationDiscountExpired: number;
+
+  readonly collateralTokens: Array<Address> = [];
+  readonly supportedTokens: Record<Address, true> = {};
+  readonly usableTokens: Record<Address, true> = {};
+  readonly adapters: Record<Address, CreditManagerDataPayload["adapters"][1]> =
+    {};
+  readonly contractsByAdapter: Record<Address, Address> = {};
+  readonly liquidationThresholds: Record<Address, bigint>;
+  readonly quotas: Record<Address, QuotaInfo>;
+
+  constructor(payload: CreditManagerDataPayload) {
+    this.address = payload.addr.toLowerCase() as Address;
+    this.underlyingToken = payload.underlying.toLowerCase() as Address;
+    this.type = CreditManagerData_Legacy.getType(payload.name || "");
+    this.name = payload.name;
+    this.pool = payload.pool.toLowerCase() as Address;
+    this.tier = CreditManagerData_Legacy.getTier(payload.name);
+    this.creditFacade = payload.creditFacade.toLowerCase() as Address;
+    this.creditConfigurator =
+      payload.creditConfigurator.toLowerCase() as Address;
+    this.degenNFT = payload.degenNFT.toLowerCase() as Address;
+    this.isDegenMode = payload.isDegenMode;
+    this.version = Number(payload.cfVersion);
+    this.isPaused = payload.isPaused;
+    this.forbiddenTokenMask = payload.forbiddenTokenMask;
+    this.maxEnabledTokensLength = Number(payload.maxEnabledTokensLength);
+    this.isBorrowingForbidden = payload.isBorrowingForbidden;
+    this.marketConfigurator =
+      payload.marketConfigurator.toLowerCase() as Address;
+
+    this.baseBorrowRate = Number(
+      (payload.baseBorrowRate *
+        (BigInt(payload.feeInterest) + PERCENTAGE_FACTOR) *
+        PERCENTAGE_DECIMALS) /
+        RAY,
+    );
+
+    this.minDebt = payload.minDebt;
+    this.maxDebt = payload.maxDebt;
+    this.availableToBorrow = payload.availableToBorrow;
+    this.totalDebt = payload.totalDebt;
+    this.totalDebtLimit = payload.totalDebtLimit;
+
+    this.feeInterest = Number(payload.feeInterest);
+    this.feeLiquidation = Number(payload.feeLiquidation);
+    this.liquidationDiscount = Number(payload.liquidationDiscount);
+    this.feeLiquidationExpired = Number(payload.feeLiquidationExpired);
+    this.liquidationDiscountExpired = Number(
+      payload.liquidationDiscountExpired,
+    );
+
+    payload.adapters.forEach(a => {
+      const contractLc = a.targetContract.toLowerCase() as Address;
+      const adapterLc = a.address.toLowerCase() as Address;
+
+      this.adapters[contractLc] = {
+        address: adapterLc,
+        contractType: a.contractType,
+        version: a.version,
+        name: a.name,
+        targetContract: contractLc,
+      };
+      this.contractsByAdapter[adapterLc] = contractLc;
+    });
+
+    this.liquidationThresholds = payload.liquidationThresholds.reduce<
+      CreditManagerData_Legacy["liquidationThresholds"]
+    >((acc, [token, threshold]) => {
+      acc[token.toLowerCase() as Address] = BigInt(threshold);
+      return acc;
+    }, {});
+
+    this.quotas = payload.quotas.reduce<CreditManagerData_Legacy["quotas"]>(
+      (acc, q) => {
+        const addressLc = q.token.toLowerCase() as Address;
+
+        acc[addressLc] = {
+          token: addressLc,
+          rate: BigInt(q.rate) * PERCENTAGE_DECIMALS,
+          quotaIncreaseFee: BigInt(q.quotaIncreaseFee),
+          totalQuoted: q.totalQuoted,
+          limit: q.limit,
+          isActive: q.isActive,
+        };
+
+        return acc;
+      },
+      {},
+    );
+
+    payload.collateralTokens.forEach(t => {
+      const tLc = t.toLowerCase() as Address;
+
+      const zeroLt = this.liquidationThresholds[tLc] === 0n;
+      const quotaNotActive = this.quotas[tLc]?.isActive === false;
+
+      const allowed = !zeroLt && !quotaNotActive;
+      if (allowed) this.usableTokens[tLc] = true;
+
+      this.collateralTokens.push(tLc);
+      this.supportedTokens[tLc] = true;
+    });
+  }
+
+  isQuoted(token: Address) {
+    return !!this.quotas[token];
+  }
+
+  static getTier(name: string): number {
+    const DEFAULT_TIER = 99;
+    const l = name.split(" ") || [];
+
+    const index = l.findIndex(w => w.toLowerCase() === "tier");
+    if (index < 0) return DEFAULT_TIER;
+
+    const number = l[index + 1];
+
+    const n = Number(number || DEFAULT_TIER);
+    return Number.isNaN(n) ? DEFAULT_TIER : n;
+  }
+
+  static getType(name: string): CreditManagerType {
+    const [identity = ""] = name.split(" ") || [];
+    const lc = identity.toLowerCase();
+
+    if (lc === "farm") return "farm";
+    if (lc === "trade") return "trade";
+    if (lc === "restaking") return "restaking";
+
+    return "universal";
+  }
+}
+
+export class ChartsCreditManagerData {
+  readonly address: Address;
+  readonly underlyingToken: Address;
+  readonly configurator: Address;
+  readonly creditFacade: Address;
+  readonly pool: Address;
+  readonly version: number;
+  readonly name: string;
+  readonly tier: number;
+
+  readonly borrowRate: number;
+  readonly borrowRateOld: number;
+  readonly borrowRateChange: number;
+
+  readonly minAmount: bigint;
+  readonly maxAmount: bigint;
+  readonly maxLeverageFactor: number; // for V1 only
+  readonly availableLiquidity: bigint;
+
+  readonly feeInterest: number;
+  readonly feeLiquidation: number;
+  readonly feeLiquidationExpired: number;
+
+  readonly openedAccountsCount: number;
+  readonly totalOpenedAccounts: number;
+  readonly totalClosedAccounts: number;
+  readonly totalRepaidAccounts: number;
+  readonly totalLiquidatedAccounts: number;
+
+  readonly totalBorrowed: bigint;
+  readonly totalBorrowedOld: bigint;
+  readonly totalBorrowedChange: number;
+  readonly totalDebtLimit: bigint;
+
+  readonly totalRepaid: bigint;
+
+  readonly totalProfit: bigint;
+  readonly totalProfitOld: bigint;
+  readonly pnlChange: number;
+  readonly totalLosses: bigint;
+  readonly totalLossesOld: bigint;
+
+  readonly totalBorrowedInUSD: number;
+  readonly totalLossesInUSD: number;
+  readonly totalProfitInUSD: number;
+  readonly totalRepaidInUSD: number;
+  readonly availableLiquidityInUSD: number;
+  readonly openedAccountsCountChange: number;
+  readonly totalOpenedAccountsChange: number;
+  readonly totalClosedAccountsChange: number;
+  readonly totalLiquidatedAccountsChange: number;
+
+  readonly liquidationThresholds: Record<string, bigint>;
+
+  constructor(payload: ChartsCreditManagerPayload) {
+    this.address = (payload.addr || "").toLowerCase() as Address;
+    this.underlyingToken = (
+      payload.underlyingToken || ""
+    ).toLowerCase() as Address;
+    this.configurator = (payload.configurator || "").toLowerCase() as Address;
+    this.creditFacade = (payload.creditFacade || "").toLowerCase() as Address;
+    this.pool = (payload.poolAddress || "").toLowerCase() as Address;
+    this.version = payload.version || 2;
+    this.name = payload.name || "";
+    this.tier = CreditManagerData_Legacy.getTier(payload.name || "");
+
+    this.borrowRate = Number(
+      (toBigInt(payload.borrowRate || 0) *
+        (toBigInt(payload.feeInterest || 0) + PERCENTAGE_FACTOR) *
+        PERCENTAGE_DECIMALS) /
+        RAY,
+    );
+    this.borrowRateOld = Number(
+      (toBigInt(payload.borrowRateOld || 0) *
+        (toBigInt(payload.feeInterest || 0) + PERCENTAGE_FACTOR) *
+        PERCENTAGE_DECIMALS) /
+        RAY,
+    );
+    this.borrowRateChange = Number(
+      toBigInt(payload.borrowRate10kBasis || 0) * PERCENTAGE_DECIMALS,
+    );
+
+    this.maxLeverageFactor = payload.maxLeverageFactor || 0;
+
+    this.feeInterest = payload.feeInterest || 0;
+    this.feeLiquidation = payload.feeLiquidation || 0;
+    this.feeLiquidationExpired = payload.feeLiquidationExpired || 0;
+
+    this.minAmount = toBigInt(payload.minAmount || 0);
+    this.maxAmount = toBigInt(payload.maxAmount || 0);
+
+    this.availableLiquidity = toBigInt(payload.availableLiquidity || 0);
+    this.availableLiquidityInUSD = payload.availableLiquidityInUSD || 0;
+
+    this.liquidationThresholds = Object.entries(
+      payload.liquidityThresholds || {},
+    ).reduce<Record<string, bigint>>((acc, [t, tr]) => {
+      acc[t.toLowerCase()] = BigInt(tr);
+
+      return acc;
+    }, {});
+
+    this.totalBorrowed = toBigInt(payload.totalBorrowed || 0);
+    this.totalBorrowedOld = toBigInt(payload.totalBorrowedBIOld || 0);
+    this.totalBorrowedInUSD = payload.totalBorrowedInUSD || 0;
+    this.totalBorrowedChange = Number(
+      toBigInt(payload.totalBorrowedBI10kBasis || 0) * PERCENTAGE_DECIMALS,
+    );
+    this.totalDebtLimit = toBigInt(payload.totalDebtLimit || 0);
+
+    this.totalLosses = toBigInt(payload.totalLosses || 0);
+    this.totalLossesOld = toBigInt(payload.totalLossesOld || 0);
+    this.totalLossesInUSD = payload.totalLossesInUSD || 0;
+
+    this.totalRepaid = toBigInt(payload.totalRepaid || 0);
+    this.totalRepaidInUSD = payload.totalRepaidInUSD || 0;
+
+    this.totalProfit = toBigInt(payload.totalProfit || 0);
+    this.totalProfitOld = toBigInt(payload.totalProfitOld || 0);
+    this.totalProfitInUSD = payload.totalProfitInUSD || 0;
+    this.pnlChange = Number(
+      toBigInt(payload.pnl10kBasis || 0) * PERCENTAGE_DECIMALS,
+    );
+
+    this.openedAccountsCount = payload.openedAccountsCount || 0;
+    this.openedAccountsCountChange = payload.openedAccountsCountChange || 0;
+
+    this.totalOpenedAccounts = payload.totalOpenedAccounts || 0;
+    this.totalOpenedAccountsChange = payload.totalOpenedAccountsChange || 0;
+
+    this.totalClosedAccounts = payload.totalClosedAccounts || 0;
+    this.totalClosedAccountsChange = payload.totalClosedAccountsChange || 0;
+
+    this.totalRepaidAccounts = payload.totalRepaidAccounts || 0;
+
+    this.totalLiquidatedAccounts = payload.totalLiquidatedAccounts || 0;
+    this.totalLiquidatedAccountsChange =
+      payload.totalLiquidatedAccountsChange || 0;
+  }
+}

package/src/sdk/sdk-legacy/core/creditSession.ts

@@ -0,0 +1,352 @@
+import type { Address } from "viem";
+
+import { PERCENTAGE_DECIMALS } from "../../constants";
+import { toBigInt, TypedObjectUtils } from "../../utils";
+import type {
+  CreditSessionFilteredPayload,
+  CreditSessionPayload,
+  CreditSessionsAggregatedStatsPayload,
+  SecondaryStatus,
+  UserCreditSessionsAggregatedStatsPayload,
+} from "../payload/creditSession";
+import type { AssetWithView } from "./assets";
+
+export interface CreditSessionAsset extends AssetWithView {
+  ind: number;
+  isForbidden: boolean;
+  isEnabled: boolean;
+
+  quota: bigint;
+  quotaIndexLU: bigint;
+  isQuoted: boolean;
+}
+
+export interface CreditSessionReward extends AssetWithView {
+  pool: Address;
+}
+
+export type CreditSessionStatus =
+  | "active"
+  | "closed"
+  | "repaid"
+  | "liquidated"
+  | "liquidateExpired"
+  | "liquidatePaused";
+
+export const CREDIT_SESSION_STATUS_BY_ID: Record<number, CreditSessionStatus> =
+  {
+    0: "active",
+    1: "closed",
+    2: "repaid",
+    3: "liquidated",
+    4: "liquidateExpired",
+    5: "liquidatePaused",
+  };
+
+export const CREDIT_SESSION_ID_BY_STATUS = TypedObjectUtils.swapKeyValue(
+  CREDIT_SESSION_STATUS_BY_ID,
+);
+
+export class CreditSession {
+  readonly id: string;
+  readonly status: CreditSessionStatus;
+  readonly borrower: Address;
+  readonly creditManager: Address;
+  readonly account: Address;
+  readonly underlyingToken: Address;
+  readonly version: number;
+
+  readonly since: number;
+  readonly closedAt: number;
+
+  readonly initialAmount: bigint;
+  readonly borrowedAmount: bigint;
+  readonly totalValue: bigint;
+  readonly healthFactor: number;
+
+  readonly profitInUSD: number;
+  readonly profitInUnderlying: number;
+  readonly collateralInUSD: number;
+  readonly collateralInUnderlying: number;
+  readonly roi: number;
+  readonly apy: number;
+  readonly currentBlock: number;
+  readonly currentTimestamp: number;
+
+  readonly baseBorrowAPY7DAverage: number;
+  readonly baseBorrowAPY_RAY: bigint;
+  readonly baseToken: Address;
+  readonly pool: Address;
+
+  readonly entryPrice: number;
+  readonly closePrice: number;
+  readonly quoteToken: Address;
+  readonly tradingToken: Address;
+
+  readonly sinceTimestamp: number;
+  readonly closedAtTimestamp: number;
+
+  readonly borrowAPY_RAY: bigint;
+  readonly borrowAPY7DAverage: number;
+  readonly totalValueUSD: number;
+  readonly debt: bigint;
+  readonly debtUSD: number;
+  readonly leverage: number;
+  readonly tfIndex: number;
+
+  readonly spotDebt: bigint;
+  readonly spotTotalValue: bigint;
+  readonly spotUserFunds: bigint;
+
+  readonly cvxUnclaimedRewards: Array<CreditSessionReward>;
+  readonly balances: Array<CreditSessionAsset> = [];
+  readonly forbiddenTokens: Record<string, true> = {};
+  readonly disabledTokens: Record<string, true> = {};
+  readonly teritaryStatus: SecondaryStatus;
+
+  constructor(payload: CreditSessionPayload) {
+    this.id = (payload.id || "").toLowerCase();
+    this.teritaryStatus = payload.teritaryStatus || { secStatus: [] };
+    this.status = CREDIT_SESSION_STATUS_BY_ID[payload.status || 0];
+    this.borrower = (payload.borrower || "").toLowerCase() as Address;
+    this.creditManager = (payload.creditManager || "").toLowerCase() as Address;
+    this.account = (payload.account || "").toLowerCase() as Address;
+    this.underlyingToken = (
+      payload.underlyingToken || ""
+    ).toLowerCase() as Address;
+    this.version = payload.version || 2;
+
+    this.initialAmount = toBigInt(payload.initialAmount || 0);
+    this.borrowedAmount = toBigInt(payload.borrowedAmount || 0);
+    this.totalValue = toBigInt(payload.totalValue || 0);
+    this.healthFactor = Number(toBigInt(payload.healthFactor || 0));
+
+    this.since = payload.since || 0;
+    this.closedAt = payload.closedAt || 0;
+    this.sinceTimestamp = payload.sinceTimestamp || 0;
+    this.closedAtTimestamp = payload.closedAtTimestamp || 0;
+
+    this.profitInUSD = payload.profitInUSD || 0;
+    this.profitInUnderlying = payload.profitInUnderlying || 0;
+    this.collateralInUSD = payload.collateralInUSD || 0;
+    this.collateralInUnderlying = payload.collateralInUnderlying || 0;
+
+    this.baseBorrowAPY7DAverage = payload.baseBorrowAPY7DAverage || 0;
+    this.baseBorrowAPY_RAY = toBigInt(payload.baseBorrowAPY_RAY || 0);
+    this.baseToken = (payload.tradingToken || "").toLowerCase() as Address;
+    this.pool = (payload.tradingToken || "").toLowerCase() as Address;
+
+    this.entryPrice = payload.entryPrice || 0;
+    this.closePrice = payload.closePrice || 0;
+    this.tradingToken = (payload.tradingToken || "").toLowerCase() as Address;
+    this.quoteToken = (payload.quoteToken || "").toLowerCase() as Address;
+
+    this.borrowAPY_RAY = toBigInt(payload.borrowAPY_RAY || 0);
+    this.borrowAPY7DAverage =
+      (payload.borrowAPY7DAverage || 0) * Number(PERCENTAGE_DECIMALS);
+    this.totalValueUSD = payload.totalValueUSD || 0;
+    this.debt = toBigInt(payload.debt || 0);
+    this.debtUSD = payload.debtUSD || 0;
+    this.leverage = payload.leverage || 0;
+    this.tfIndex = (payload.tfIndex || 0) * Number(PERCENTAGE_DECIMALS);
+
+    this.roi = (payload.roi || 0) / Number(PERCENTAGE_DECIMALS);
+    this.apy = (payload.apy || 0) / Number(PERCENTAGE_DECIMALS);
+
+    this.currentBlock = payload.currentBlock || 0;
+    this.currentTimestamp = payload.currentTimestamp || 0;
+
+    this.spotDebt = toBigInt(payload.spotDebt || 0);
+    this.spotTotalValue = toBigInt(payload.spotTotalValue || 0);
+    this.spotUserFunds = toBigInt(payload.spotUserFunds || 0);
+
+    this.cvxUnclaimedRewards = Object.entries(
+      payload.cvxUnclaimedRewards || {},
+    ).map(([t, b]): CreditSessionReward => {
+      return {
+        token: t.toLowerCase() as Address,
+        balance: toBigInt(b.bi || 0),
+        balanceView: b.f.toString(),
+        pool: b.pool.toLowerCase() as Address,
+      };
+    });
+
+    Object.entries(payload.balances || {}).forEach(([t, b]) => {
+      const token = t.toLowerCase();
+
+      if (!b.isEnabled) {
+        this.disabledTokens[token] = true;
+      }
+      if (b.isForbidden) {
+        this.forbiddenTokens[token] = true;
+      }
+
+      this.balances.push({
+        token: token.toLowerCase() as Address,
+        balance: toBigInt(b.BI || 0),
+        balanceView: b.F.toString(),
+
+        ind: b.ind,
+
+        isEnabled: b.isEnabled,
+        isForbidden: b.isForbidden,
+
+        quota: toBigInt(b.quota || 0),
+        quotaIndexLU: toBigInt(b.quotaIndexLU || 0),
+        isQuoted: b.isQuoted || false,
+      });
+    });
+  }
+}
+
+export class CreditSessionFiltered {
+  readonly id: string;
+  readonly borrower: Address;
+  readonly account: Address;
+  readonly creditManager: Address;
+  readonly underlyingToken: Address;
+
+  readonly status: CreditSessionStatus;
+  readonly since: number;
+  readonly closedAt: number;
+
+  readonly sinceTimestamp: number;
+  readonly closedAtTimestamp: number;
+
+  readonly healthFactor: number;
+  readonly leverage: number;
+
+  readonly debt: bigint;
+  readonly debtUSD: number;
+  readonly totalValue: bigint;
+  readonly totalValueUSD: number;
+
+  readonly profitInUSD: number;
+  readonly profitInUnderlying: number;
+
+  readonly tfIndex: number;
+
+  readonly balances: Array<AssetWithView>;
+  readonly teritaryStatus: SecondaryStatus;
+
+  constructor(payload: CreditSessionFilteredPayload) {
+    this.id = (payload.id || "").toLowerCase();
+    this.borrower = (payload.borrower || "").toLowerCase() as Address;
+    this.account = (payload.account || "").toLowerCase() as Address;
+    this.creditManager = (payload.creditManager || "").toLowerCase() as Address;
+    this.underlyingToken = (
+      payload.underlyingToken || ""
+    ).toLowerCase() as Address;
+
+    this.teritaryStatus = payload.teritaryStatus || { secStatus: [] };
+    this.status = CREDIT_SESSION_STATUS_BY_ID[payload.status || 0];
+    this.since = payload.since || 0;
+    this.closedAt = payload.closedAt || 0;
+    this.sinceTimestamp = payload.sinceTimestamp || 0;
+    this.closedAtTimestamp = payload.closedAtTimestamp || 0;
+
+    this.healthFactor = Number(toBigInt(payload.healthFactor || 0));
+    this.leverage = payload.leverage || 0;
+
+    this.debt = toBigInt(payload.debt || 0);
+    this.debtUSD = payload.debtUSD || 0;
+    this.totalValue = toBigInt(payload.totalValue || 0);
+    this.totalValueUSD = payload.totalValueUSD || 0;
+
+    this.profitInUSD = payload.pnlUSD || 0;
+    this.profitInUnderlying = payload.pnl || 0;
+
+    this.tfIndex = (payload.tfIndex || 0) * Number(PERCENTAGE_DECIMALS);
+
+    this.balances = Object.entries(payload.balances || {}).map(
+      ([token, balance]) => ({
+        token: token.toLowerCase() as Address,
+        balance: toBigInt(balance.BI || 0),
+        balanceView: balance.F.toString(),
+      }),
+    );
+  }
+}
+
+export type CreditSessionSortFields =
+  | "type"
+  | "tvl"
+  | "hf"
+  | "debt"
+  | "pnl"
+  | "leverage"
+  | "tfIndex";
+export type CreditSessionSortType = "asc" | "desc";
+
+export interface UserCreditSessions
+  extends Omit<
+    UserCreditSessionsAggregatedStatsPayload,
+    "accounts" | "totalValue10kBasis"
+  > {
+  totalValueChange: number;
+  accounts: Array<CreditSession>;
+}
+
+type AggregatedOmit =
+  | "healthFactor10kBasis"
+  | "leverage10kBasis"
+  | "activeAccounts10kBasis"
+  | "openedAccounts10kBasis"
+  | "healthFactor"
+  | "healthFactorOld";
+
+export type CreditSessionsAggregatedStats = Omit<
+  CreditSessionsAggregatedStatsPayload,
+  AggregatedOmit
+> & {
+  healthFactorChange: number;
+  leverageChange: number;
+  activeAccountsChange: number;
+  openedAccountsChange: number;
+  healthFactor: bigint;
+  healthFactorOld: bigint;
+};
+
+export class UserCreditSessionsBuilder {
+  static buildUserCreditSessions(
+    payload: UserCreditSessionsAggregatedStatsPayload,
+  ): UserCreditSessions {
+    const { accounts, totalValue10kBasis = 0, ...sessionsUnfiltered } = payload;
+
+    return {
+      ...sessionsUnfiltered,
+      totalValueChange: totalValue10kBasis * Number(PERCENTAGE_DECIMALS),
+      accounts: accounts.map(p => new CreditSession(p)),
+    };
+  }
+
+  static buildCreditSessionsAggregatedStats(
+    payload: CreditSessionsAggregatedStatsPayload,
+  ): CreditSessionsAggregatedStats {
+    const {
+      healthFactor10kBasis = 0,
+      leverage10kBasis = 0,
+      activeAccounts10kBasis = 0,
+      openedAccounts10kBasis = 0,
+      healthFactor = 0,
+      healthFactorOld = 0,
+      leverage,
+      leverageOld,
+      ...rest
+    } = payload;
+
+    return {
+      ...rest,
+      leverage: leverage,
+      leverageOld: leverageOld,
+      healthFactorChange: healthFactor10kBasis * Number(PERCENTAGE_DECIMALS),
+      leverageChange: leverage10kBasis * Number(PERCENTAGE_DECIMALS),
+      activeAccountsChange:
+        activeAccounts10kBasis * Number(PERCENTAGE_DECIMALS),
+      openedAccountsChange:
+        openedAccounts10kBasis * Number(PERCENTAGE_DECIMALS),
+      healthFactor: toBigInt(healthFactor || 0),
+      healthFactorOld: toBigInt(healthFactorOld || 0),
+    };
+  }
+}