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

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

@@ -0,0 +1,131 @@
+import type { Address } from "viem";
+
+import type { NetworkType } from "../../chain";
+import { chains, isSupportedNetwork } from "../../chain";
+
+export const TESTNET_CHAINS: Record<NetworkType, number> = {
+  Mainnet: 7878,
+  Optimism: 7879,
+  Arbitrum: 7880,
+  Base: 7881,
+  Sonic: 7882,
+};
+
+type ChartsPriceSource = "chainlink" | "spot";
+
+const CHARTS_BACKEND_ADDRESSES: Record<number, string> = {
+  [chains.Mainnet.id]: "https://charts-server.fly.dev",
+  [chains.Arbitrum.id]: "https://charts-server.fly.dev",
+  [chains.Optimism.id]: "https://charts-server.fly.dev",
+  [chains.Base.id]: "https://charts-server.fly.dev",
+  [chains.Sonic.id]: "https://charts-server.fly.dev",
+
+  [TESTNET_CHAINS.Mainnet]: "https://testnet.gearbox.foundation",
+  [TESTNET_CHAINS.Arbitrum]: "https://arbtest.gearbox.foundation",
+  [TESTNET_CHAINS.Optimism]: "https://opttest.gearbox.foundation",
+  // !& Base & Sonic
+};
+
+const LAMA_URL = "https://charts-server.fly.dev/api/defillama?ids=";
+
+const STATIC_TOKEN = "https://static.gearbox.fi/tokens/";
+
+const LEADERBOARD_APIS: Record<number, string> = {
+  [chains.Mainnet.id]: "https://gpointbot.fly.dev",
+  [chains.Optimism.id]: "https://gpointbot.fly.dev",
+  [chains.Arbitrum.id]: "https://gpointbot.fly.dev",
+  [chains.Base.id]: "https://gpointbot.fly.dev",
+  [chains.Sonic.id]: "https://gpointbot.fly.dev",
+
+  [TESTNET_CHAINS.Mainnet]: "https://testnet.gearbox.foundation/gpointbot",
+  [TESTNET_CHAINS.Optimism]: "https://testnet.gearbox.foundation/gpointbot",
+  [TESTNET_CHAINS.Arbitrum]: "https://testnet.gearbox.foundation/gpointbot",
+  [TESTNET_CHAINS.Base]: "https://testnet.gearbox.foundation/gpointbot",
+  [TESTNET_CHAINS.Sonic]: "https://testnet.gearbox.foundation/gpointbot",
+};
+
+const REFERRAL_API = "https://referral-gen.fly.dev/generate";
+
+export class GearboxBackendApi {
+  static getChartsUrl = (
+    url: string,
+    chainId: number,
+    options: Options = { params: {} },
+    priceSource?: ChartsPriceSource,
+  ) => {
+    const domain = CHARTS_BACKEND_ADDRESSES[chainId];
+    const priceSourceArr = priceSource ? [priceSource] : [];
+
+    const isMain = isSupportedNetwork(chainId);
+
+    const relativePath = URLApi.getRelativeUrl(
+      url,
+      isMain
+        ? {
+            ...options,
+            params: { ...options.params, chainId: chainId },
+          }
+        : options,
+    );
+
+    return [domain, "api", ...priceSourceArr, relativePath].join("/");
+  };
+
+  static getLlamaAPYUrl = (idList: Array<string>) => {
+    return `${LAMA_URL}${idList.join(",")}`;
+  };
+
+  static getStaticTokenUrl = () => STATIC_TOKEN;
+
+  static getRewardsMerkleUrl = (
+    network: NetworkType,
+    root: Address,
+    account: Address,
+  ) => {
+    const path = `${network}_${root.slice(2)}/${account.slice(2, 4)}`;
+    const url = `https://am.gearbox.finance/${path.toLowerCase()}.json`;
+
+    return url;
+  };
+
+  static getNFTMerkleUrl = (network: NetworkType, root: Address) => {
+    const url = `https://dm.gearbox.finance/${network.toLowerCase()}_${root}.json`;
+
+    return url;
+  };
+
+  static getLeaderboardUrl = (url: string, chainId: number) => {
+    return `${LEADERBOARD_APIS[chainId]}${url}`;
+  };
+
+  static getReferralUrl = () => REFERRAL_API;
+
+  static apyServerAllRewards = (chainId: number) =>
+    URLApi.getRelativeUrl("https://apy-server.fly.dev/api/rewards/tokens/all", {
+      params: { chain_id: chainId },
+    });
+  static apyServerGearAPY = (chainId: number) =>
+    URLApi.getRelativeUrl("https://apy-server.fly.dev/api/rewards/gear-apy", {
+      params: { chain_id: chainId },
+    });
+  static apyServerAllPoolRewards = (chainId: number) =>
+    URLApi.getRelativeUrl("https://apy-server.fly.dev/api/rewards/pools/all", {
+      params: { chain_id: chainId },
+    });
+}
+
+interface Options {
+  params?: Record<string, string | number>;
+}
+
+export class URLApi {
+  static getRelativeUrl = (url: string, options?: Options) => {
+    const { params = {} } = options || {};
+
+    const paramsString = Object.entries(params)
+      .map<string>(([key, value]) => `${key}=${value}`)
+      .join("&");
+
+    return [url, ...(paramsString ? [paramsString] : [])].join("?");
+  };
+}

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

@@ -0,0 +1,101 @@
+import type { Address } from "viem";
+
+import type { TokenData } from "../tokens/tokenData";
+import type { TxSerialized } from "./transactions";
+
+export interface Display {
+  toString: (tokenData: Record<string, TokenData>) => string;
+}
+
+export type TxStatus = "pending" | "success" | "reverted";
+
+export interface EventOrTxProps {
+  block: number;
+  txHash: Address;
+  txStatus: TxStatus;
+  timestamp: number;
+}
+
+export abstract class EventOrTx implements Display {
+  public block: number;
+
+  public readonly txHash: Address;
+
+  public readonly timestamp: number;
+
+  protected _txStatus: TxStatus;
+
+  constructor({ block, txHash, txStatus, timestamp = 0 }: EventOrTxProps) {
+    this.block = block;
+    this.txHash = txHash;
+    this._txStatus = txStatus;
+    this.timestamp = timestamp;
+  }
+
+  public get isPending(): boolean {
+    return this._txStatus === "pending";
+  }
+
+  public get txStatus() {
+    return this._txStatus;
+  }
+
+  public compare(item: EventOrTx): number {
+    if (this.isPending && !item.isPending) {
+      return -1;
+    }
+
+    if (!this.isPending && item.isPending) {
+      return 1;
+    }
+
+    return item.block - this.block;
+  }
+
+  public abstract toString(): string;
+}
+
+export type EVMEventProps = Omit<EventOrTxProps, "txStatus"> & {
+  logId?: number;
+};
+
+export abstract class EVMEvent extends EventOrTx {
+  logId?: number;
+  constructor(opts: EVMEventProps) {
+    super({ ...opts, txStatus: "success" });
+    this.logId = opts.logId;
+  }
+}
+
+export type EVMTxProps = Omit<EventOrTxProps, "block" | "txStatus"> &
+  Partial<Pick<EventOrTxProps, "block" | "txStatus">>;
+export abstract class EVMTx extends EventOrTx {
+  constructor({
+    txHash,
+    block = 0,
+    txStatus = "pending",
+    timestamp = 0,
+  }: EVMTxProps) {
+    super({
+      block,
+      txStatus,
+      txHash,
+      timestamp,
+    });
+    if (this.txStatus !== "pending" && this.block === 0) {
+      throw new Error("Block not specified for non-pending tx");
+    }
+  }
+
+  abstract serialize(): TxSerialized;
+
+  public revert(block: number) {
+    this._txStatus = "reverted";
+    this.block = block;
+  }
+
+  public success(block: number) {
+    this._txStatus = "success";
+    this.block = block;
+  }
+}

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

@@ -0,0 +1,439 @@
+import type { Address, PublicClient } from "viem";
+import { getContract } from "viem";
+
+import { PERCENTAGE_DECIMALS, PERCENTAGE_FACTOR } from "../../constants";
+import { toBigInt } from "../../utils";
+import type {
+  ChartsPoolDataPayload,
+  LinearModel,
+  PoolDataExtraPayload,
+  PoolDataPayload,
+  UserPoolPayload,
+} from "../payload/pool";
+import { iInterestRateModelAbi } from "../types";
+import { rayToNumber } from "../utils/formatter";
+
+export type PoolType = "universal" | "trade" | "farm";
+
+export class PoolData_Legacy {
+  readonly address: Address;
+  readonly type: PoolType;
+  readonly underlyingToken: Address;
+  readonly dieselToken: Address;
+  readonly stakedDieselToken: Array<Address>;
+  readonly stakedDieselToken_old: Array<Address>;
+  readonly isPaused: boolean;
+  readonly version: number;
+  readonly poolQuotaKeeper: Address;
+  readonly gauge: Address;
+  readonly name: string;
+  readonly symbol: string;
+  readonly marketConfigurator: Address;
+
+  // Information
+  readonly expectedLiquidity: bigint;
+  readonly expectedLiquidityLimit: bigint;
+  readonly availableLiquidity: bigint;
+  readonly baseInterestIndex: bigint;
+  readonly utilization: number;
+
+  readonly totalBorrowed: bigint;
+  readonly totalDebtLimit: bigint;
+  readonly quotas: Record<
+    Address,
+    {
+      token: Address;
+      rate: bigint;
+      quotaIncreaseFee: bigint;
+      totalQuoted: bigint;
+      limit: bigint;
+      isActive: boolean;
+    }
+  >;
+  readonly zappers: Record<
+    Address,
+    Record<
+      Address,
+      {
+        zapper: Address;
+        tokenIn: Address;
+        tokenOut: Address;
+      }
+    >
+  >;
+
+  readonly totalSupply: bigint;
+
+  readonly depositAPY: number;
+  readonly borrowAPY: number;
+
+  readonly interestModel: LinearModel;
+  readonly dieselRate: number;
+  readonly dieselRateRay: bigint;
+  readonly withdrawFee: number;
+  readonly lastBaseInterestUpdate: bigint;
+
+  constructor(payload: PoolDataPayload, extra: PoolDataExtraPayload) {
+    this.address = payload.addr.toLowerCase() as Address;
+    this.type = PoolData_Legacy.getPoolType(payload.name || "");
+    this.underlyingToken = payload.underlying.toLowerCase() as Address;
+    this.dieselToken = payload.dieselToken.toLowerCase() as Address;
+    this.stakedDieselToken = (extra.stakedDieselToken || []).map(
+      t => t.toLowerCase() as Address,
+    );
+    this.stakedDieselToken_old = (extra.stakedDieselToken_old || []).map(
+      t => t.toLowerCase() as Address,
+    );
+    this.isPaused = payload.isPaused;
+    this.version = Number(payload.version);
+    this.poolQuotaKeeper = payload.poolQuotaKeeper.toLowerCase() as Address;
+    this.gauge = payload.gauge.toLowerCase() as Address;
+    this.name = payload.name;
+    this.symbol = payload.symbol;
+    this.marketConfigurator =
+      payload.marketConfigurator.toLowerCase() as Address;
+
+    const expected = payload.expectedLiquidity;
+    const available = payload.availableLiquidity;
+    this.expectedLiquidity = expected;
+    this.availableLiquidity = available;
+    this.expectedLiquidityLimit =
+      this.expectedLiquidity + this.availableLiquidity;
+    this.baseInterestIndex = payload.baseInterestIndex;
+
+    this.utilization = PoolData_Legacy.calculateUtilization(
+      expected,
+      available,
+    );
+
+    this.totalBorrowed = payload.totalBorrowed;
+    this.totalDebtLimit = payload.totalDebtLimit;
+
+    this.quotas = payload.quotas.reduce<PoolData_Legacy["quotas"]>((acc, q) => {
+      const token = q.token.toLowerCase() as Address;
+      acc[token] = {
+        token,
+        rate: toBigInt(q.rate) * PERCENTAGE_DECIMALS,
+        quotaIncreaseFee: toBigInt(q.quotaIncreaseFee),
+        totalQuoted: q.totalQuoted,
+        limit: q.limit,
+        isActive: q.isActive,
+      };
+
+      return acc;
+    }, {});
+
+    this.zappers = payload.zappers.reduce<PoolData_Legacy["zappers"]>(
+      (acc, z) => {
+        const tokenIn = z.tokenIn.addr.toLowerCase() as Address;
+        const tokenOut = z.tokenOut.addr.toLowerCase() as Address;
+        const zapper = z.baseParams.addr.toLowerCase() as Address;
+        const old = acc[tokenIn] || {};
+
+        return {
+          ...acc,
+          [tokenIn]: {
+            ...old,
+            [tokenOut]: { tokenIn, tokenOut, zapper },
+          },
+        };
+      },
+      {},
+    );
+
+    this.totalSupply = payload.totalSupply;
+
+    this.depositAPY = rayToNumber(payload.supplyRate * PERCENTAGE_DECIMALS);
+    this.borrowAPY = rayToNumber(
+      payload.baseInterestRate * PERCENTAGE_DECIMALS,
+    );
+
+    this.interestModel = {
+      interestModel: payload.lirm.interestModel.toLowerCase() as Address,
+      U_1: toBigInt(payload.lirm.U_1),
+      U_2: toBigInt(payload.lirm.U_2),
+      R_base: toBigInt(payload.lirm.R_base),
+      R_slope1: toBigInt(payload.lirm.R_slope1),
+      R_slope2: toBigInt(payload.lirm.R_slope2),
+      R_slope3: toBigInt(payload.lirm.R_slope3),
+      version: Number(payload?.lirm?.version),
+      isBorrowingMoreU2Forbidden: payload?.lirm?.isBorrowingMoreU2Forbidden,
+    };
+    this.dieselRate = rayToNumber(payload.dieselRate_RAY);
+    this.dieselRateRay = payload.dieselRate_RAY;
+    this.lastBaseInterestUpdate = payload.lastBaseInterestUpdate;
+    this.withdrawFee =
+      Number(payload.withdrawFee) / Number(PERCENTAGE_DECIMALS);
+  }
+
+  async calculateBorrowRate({
+    provider,
+    expectedLiquidity,
+    availableLiquidity,
+  }: CalculateBorrowRateProps) {
+    const model = getContract({
+      address: this.interestModel.interestModel,
+      abi: iInterestRateModelAbi,
+      client: provider,
+    });
+
+    return model.read.calcBorrowRate([expectedLiquidity, availableLiquidity]);
+  }
+
+  static getPoolType(name: string): PoolType {
+    const [identity = ""] = name.split(" ") || [];
+    const lc = identity.toLowerCase();
+
+    if (lc === "farm") return "farm";
+    if (lc === "trade") return "trade";
+
+    return "universal";
+  }
+
+  static calculateUtilization(expected: bigint, available: bigint) {
+    if (expected === 0n) return 0;
+
+    const borrowed = expected - available;
+
+    const u =
+      Number((borrowed * PERCENTAGE_FACTOR) / expected) /
+      Number(PERCENTAGE_DECIMALS);
+
+    return Math.max(0, u);
+  }
+}
+
+interface CalculateBorrowRateProps {
+  provider: PublicClient;
+  expectedLiquidity: bigint;
+  availableLiquidity: bigint;
+}
+
+export class ChartsPoolData {
+  readonly address: Address;
+  readonly underlyingToken: Address;
+  readonly dieselToken: Address;
+  readonly type: PoolType;
+  readonly version: number;
+  readonly name: string;
+
+  readonly addLiqCount: number;
+  readonly addedLiquidity: number;
+  readonly removeLiqCount: number;
+  readonly removedLiquidity: number;
+
+  readonly earned7D: number;
+  readonly earned7DInUSD: number;
+  readonly utilization: number;
+
+  readonly dieselRate: number;
+  readonly dieselRateRay: bigint;
+  readonly depositAPY: number;
+  readonly depositAPYRay: bigint;
+  readonly borrowAPY: number;
+  readonly borrowAPYRay: bigint;
+  readonly lmAPY: number;
+  readonly lmRewardAll: Array<{ apy: number; token: Address }>;
+
+  readonly availableLiquidity: bigint;
+  readonly availableLiquidityChange: number;
+  readonly availableLiquidityInUSD: number;
+
+  readonly caLockedValue: number;
+  readonly caLockedValueChange: number;
+  readonly caLockedValueInUSD: number;
+
+  readonly expectedLiquidity: bigint;
+  readonly expectedLiquidityChange: number;
+  readonly expectedLiquidityInUSD: number;
+  readonly expectedLiqWeekAgo: number;
+  readonly expectedLiquidityLimit: bigint;
+  readonly expectedLiquidityLimitInUSD: number;
+
+  readonly totalBorrowed: bigint;
+  readonly totalBorrowedChange: number;
+  readonly totalBorrowedInUSD: number;
+
+  readonly debtWithInterest: bigint;
+  readonly debtWithInterestChange: number;
+  readonly debtWithInterestInUSD: number;
+  readonly debtWithInterestOld: bigint;
+
+  readonly oldAvailableLiquidity: bigint;
+  readonly oldCALockedValue: number;
+  readonly oldExpectedLiquidity: bigint;
+  readonly oldTotalBorrowed: bigint;
+
+  readonly withdrawFee: number;
+
+  readonly depositAPY1DAverage: number;
+  readonly depositAPY1DAverageChange: number;
+  readonly depositAPY7DAverage: number;
+  readonly depositAPY30DAverage: number;
+
+  readonly oldUniqueLPs: number;
+  readonly uniqueLPs: number;
+  readonly uniqueLPsChange: number;
+
+  constructor(payload: ChartsPoolDataPayload) {
+    this.address = (payload.addr || "").toLowerCase() as Address;
+    this.underlyingToken = (
+      payload.underlyingToken || ""
+    ).toLowerCase() as Address;
+    this.dieselToken = (payload.dieselToken || "").toLowerCase() as Address;
+    this.type = PoolData_Legacy.getPoolType(payload.name || "");
+    this.version = payload.version || 1;
+    this.name = payload.name || "";
+
+    this.earned7D = payload.earned7D || 0;
+    this.earned7DInUSD = payload.earned7DInUSD || 0;
+
+    this.dieselRate = rayToNumber(payload.dieselRate_RAY || 0);
+    this.dieselRateRay = toBigInt(payload.dieselRate_RAY || 0);
+    this.depositAPY =
+      rayToNumber(payload.depositAPY_RAY || 0) * Number(PERCENTAGE_DECIMALS);
+    this.depositAPYRay = toBigInt(payload.depositAPY_RAY);
+    this.borrowAPY =
+      rayToNumber(payload.borrowAPY_RAY || 0) * Number(PERCENTAGE_DECIMALS);
+    this.borrowAPYRay = toBigInt(payload.borrowAPY_RAY || 0);
+    this.lmAPY = (payload.lmAPY || 0) / Number(PERCENTAGE_DECIMALS);
+    this.lmRewardAll = (payload.lmRewardAll || []).map(r => ({
+      apy: (r.apy || 0) / Number(PERCENTAGE_DECIMALS),
+      token: (r.token || "").toLowerCase() as Address,
+    }));
+
+    const expected = toBigInt(payload.expectedLiquidity || 0);
+    const available = toBigInt(payload.availableLiquidity || 0);
+    this.availableLiquidity = available;
+    this.oldAvailableLiquidity = toBigInt(payload.availableLiquidityOld || 0);
+    this.availableLiquidityChange =
+      (payload.availableLiquidity10kBasis || 0) * Number(PERCENTAGE_DECIMALS);
+    this.availableLiquidityInUSD = payload.availableLiquidityInUSD || 0;
+
+    this.utilization = PoolData_Legacy.calculateUtilization(
+      expected,
+      available,
+    );
+
+    this.caLockedValue = payload.caLockedValue || 0;
+    this.oldCALockedValue = payload.caLockedValueOld || 0;
+    this.caLockedValueChange =
+      (payload.caLockedValue10kBasis || 0) * Number(PERCENTAGE_DECIMALS);
+    this.caLockedValueInUSD = payload.caLockedValueUSD || 0;
+
+    this.expectedLiquidity = toBigInt(payload.expectedLiquidity || 0);
+    this.oldExpectedLiquidity = toBigInt(payload.expectedLiquidityOld || 0);
+    this.expectedLiquidityChange =
+      (payload.expectedLiquidity10kBasis || 0) * Number(PERCENTAGE_DECIMALS);
+    this.expectedLiquidityInUSD = payload.expectedLiquidityInUSD || 0;
+    this.expectedLiqWeekAgo = payload.expectedLiqWeekAgo || 0;
+
+    this.expectedLiquidityLimit = toBigInt(payload.expectedLiquidityLimit || 0);
+    this.expectedLiquidityLimitInUSD = payload.expectedLiquidityLimitInUSD || 0;
+
+    this.totalBorrowed = toBigInt(payload.totalBorrowed || 0);
+    this.oldTotalBorrowed = toBigInt(payload.totalBorrowedOld || 0);
+    this.totalBorrowedChange =
+      (payload.totalBorrowed10kBasis || 0) * Number(PERCENTAGE_DECIMALS);
+    this.totalBorrowedInUSD = payload.totalBorrowedInUSD || 0;
+
+    this.debtWithInterest = toBigInt(payload.debtWithInterest || 0);
+    this.debtWithInterestOld = toBigInt(payload.debtWithInterestOld || 0);
+    this.debtWithInterestChange =
+      (payload.debtWithInterest10kBasis || 0) * Number(PERCENTAGE_DECIMALS);
+    this.debtWithInterestInUSD = payload.debtWithInterestInUSD || 0;
+
+    this.withdrawFee = payload.withdrawFee || 0;
+
+    this.addLiqCount = payload.addLiqCount || 0;
+    this.addedLiquidity = payload.addedLiquidity || 0;
+    this.removeLiqCount = payload.removeLiqCount || 0;
+    this.removedLiquidity = payload.removedLiquidity || 0;
+
+    this.depositAPY1DAverage =
+      (payload.depositAPY1DAverage || 0) / Number(PERCENTAGE_DECIMALS);
+    this.depositAPY1DAverageChange =
+      (payload.depositAPY1DAverage10kBasis || 0) * Number(PERCENTAGE_DECIMALS);
+    this.depositAPY7DAverage =
+      (payload.depositAPY7DAverage || 0) / Number(PERCENTAGE_DECIMALS);
+    this.depositAPY30DAverage =
+      (payload.depositAPY30DAverage || 0) / Number(PERCENTAGE_DECIMALS);
+
+    this.uniqueLPs = payload.uniqueLPs || 0;
+    this.oldUniqueLPs = payload.uniqueLPsOld || 0;
+    this.uniqueLPsChange =
+      (payload.uniqueLPs10kBasis || 0) * Number(PERCENTAGE_DECIMALS);
+  }
+}
+
+export class UserPoolData {
+  readonly id: string;
+  readonly address: Address;
+  readonly dieselToken: Address;
+  readonly underlyingToken: Address;
+
+  readonly depositAPY: number;
+  readonly depositAPYRay: bigint;
+  readonly lmRewardAll: Array<{ apy: number; token: Address }>;
+
+  readonly providedLiquidity: bigint;
+  readonly providedLiquidityInUSD: number;
+
+  readonly dieselBalance: bigint;
+  readonly dieselBalanceInUSD: number;
+
+  readonly userRewards: Array<{
+    token: Address;
+    pool: Address;
+    lmRewards: bigint;
+    lmRewardsInUSD: number;
+  }>;
+
+  readonly pnlInNativeToken: number;
+  readonly pnlInUSD: number;
+
+  readonly addedLiq: number;
+  readonly addLiqCount: number;
+
+  readonly removeLiqCount: number;
+  readonly removedLiq: number;
+
+  constructor(payload: UserPoolPayload) {
+    this.id = (payload.pool || "").toLowerCase();
+    this.address = (payload.pool || "").toLowerCase() as Address;
+    this.underlyingToken = (
+      payload.underlyingToken || ""
+    ).toLowerCase() as Address;
+    this.dieselToken = (payload.dieselToken || "").toLowerCase() as Address;
+
+    this.depositAPY =
+      rayToNumber(payload.depositAPY_RAY || 0) * Number(PERCENTAGE_DECIMALS);
+    this.depositAPYRay = toBigInt(payload.depositAPY_RAY || 0);
+    this.lmRewardAll = (payload.lmRewardAll || []).map(r => ({
+      apy: (r.apy || 0) / Number(PERCENTAGE_DECIMALS),
+      token: (r.token || "").toLowerCase() as Address,
+    }));
+
+    this.providedLiquidity = toBigInt(payload.liqValue || 0);
+    this.providedLiquidityInUSD = payload.liqValueInUSD;
+
+    this.dieselBalance = toBigInt(payload.dieselBalanceBI || 0);
+    this.dieselBalanceInUSD = payload.dieselBalance;
+
+    this.userRewards = (payload.userRewards || []).map(r => ({
+      token: (r.rewardToken || "").toLowerCase() as Address,
+      pool: (r.pool || "").toLowerCase() as Address,
+      lmRewards: toBigInt(r.lmRewards || 0),
+      lmRewardsInUSD: r.lmRewardsInUSD,
+    }));
+
+    this.pnlInNativeToken = payload.liqPnlInNativeToken;
+    this.pnlInUSD = payload.liqPnlInUSD;
+
+    this.addedLiq = payload.addedLiq;
+    this.addLiqCount = payload.addLiqCount;
+
+    this.removeLiqCount = payload.removeLiqCount;
+    this.removedLiq = payload.removedLiq;
+  }
+}