@voltr/vault-sdk 1.1.0 → 2.1.0

package/src/extensions/events.ts

@@ -0,0 +1,328 @@
+import { getBase64Encoder, type Decoder } from "@solana/kit";
+
+import {
+  getAcceptProtocolAdminEventDecoder,
+  getAcceptVaultAdminEventDecoder,
+  getAddAdaptorEventDecoder,
+  getCalibrateHighWaterMarkEventDecoder,
+  getCalibrateHighWaterMarkUnsafeEventDecoder,
+  getCancelRequestWithdrawVaultEventDecoder,
+  getCloseStrategyEventDecoder,
+  getDepositStrategyEventDecoder,
+  getDepositVaultEventDecoder,
+  getDirectWithdrawStrategyEventDecoder,
+  getHarvestFeeEventDecoder,
+  getInitializeDirectWithdrawStrategyEventDecoder,
+  getInitializeStrategyEventDecoder,
+  getInitializeVaultEventDecoder,
+  getInitProtocolEventDecoder,
+  getInstantWithdrawStrategyEventDecoder,
+  getInstantWithdrawVaultEventDecoder,
+  getRemoveAdaptorEventDecoder,
+  getRequestWithdrawVaultEventDecoder,
+  getUpdateProtocolEventDecoder,
+  getUpdateVaultConfigEventDecoder,
+  getUpdateVaultEventDecoder,
+  getUpdateVaultProtocolFeeEventDecoder,
+  getWithdrawStrategyEventDecoder,
+  getWithdrawVaultEventDecoder,
+  type AcceptProtocolAdminEvent,
+  type AcceptVaultAdminEvent,
+  type AddAdaptorEvent,
+  type CalibrateHighWaterMarkEvent,
+  type CalibrateHighWaterMarkUnsafeEvent,
+  type CancelRequestWithdrawVaultEvent,
+  type CloseStrategyEvent,
+  type DepositStrategyEvent,
+  type DepositVaultEvent,
+  type DirectWithdrawStrategyEvent,
+  type HarvestFeeEvent,
+  type InitializeDirectWithdrawStrategyEvent,
+  type InitializeStrategyEvent,
+  type InitializeVaultEvent,
+  type InitProtocolEvent,
+  type InstantWithdrawStrategyEvent,
+  type InstantWithdrawVaultEvent,
+  type RemoveAdaptorEvent,
+  type RequestWithdrawVaultEvent,
+  type UpdateProtocolEvent,
+  type UpdateVaultConfigEvent,
+  type UpdateVaultEvent,
+  type UpdateVaultProtocolFeeEvent,
+  type WithdrawStrategyEvent,
+  type WithdrawVaultEvent,
+} from "../generated/types";
+
+/**
+ * Discriminated union of every Voltr Vault event Codama can decode. The first
+ * 8 bytes of each Anchor `emit!` payload identify the variant via
+ * `sha256("event:<EventName>")[..8]`; the remainder is the borsh-encoded
+ * payload for the named struct.
+ */
+export type ParsedVoltrEvent =
+  | ParsedEventOf<"AcceptProtocolAdminEvent", AcceptProtocolAdminEvent>
+  | ParsedEventOf<"AcceptVaultAdminEvent", AcceptVaultAdminEvent>
+  | ParsedEventOf<"AddAdaptorEvent", AddAdaptorEvent>
+  | ParsedEventOf<"CalibrateHighWaterMarkEvent", CalibrateHighWaterMarkEvent>
+  | ParsedEventOf<
+      "CalibrateHighWaterMarkUnsafeEvent",
+      CalibrateHighWaterMarkUnsafeEvent
+    >
+  | ParsedEventOf<
+      "CancelRequestWithdrawVaultEvent",
+      CancelRequestWithdrawVaultEvent
+    >
+  | ParsedEventOf<"CloseStrategyEvent", CloseStrategyEvent>
+  | ParsedEventOf<"DepositStrategyEvent", DepositStrategyEvent>
+  | ParsedEventOf<"DepositVaultEvent", DepositVaultEvent>
+  | ParsedEventOf<"DirectWithdrawStrategyEvent", DirectWithdrawStrategyEvent>
+  | ParsedEventOf<"HarvestFeeEvent", HarvestFeeEvent>
+  | ParsedEventOf<"InitProtocolEvent", InitProtocolEvent>
+  | ParsedEventOf<
+      "InitializeDirectWithdrawStrategyEvent",
+      InitializeDirectWithdrawStrategyEvent
+    >
+  | ParsedEventOf<"InitializeStrategyEvent", InitializeStrategyEvent>
+  | ParsedEventOf<"InitializeVaultEvent", InitializeVaultEvent>
+  | ParsedEventOf<"InstantWithdrawStrategyEvent", InstantWithdrawStrategyEvent>
+  | ParsedEventOf<"InstantWithdrawVaultEvent", InstantWithdrawVaultEvent>
+  | ParsedEventOf<"RemoveAdaptorEvent", RemoveAdaptorEvent>
+  | ParsedEventOf<"RequestWithdrawVaultEvent", RequestWithdrawVaultEvent>
+  | ParsedEventOf<"UpdateProtocolEvent", UpdateProtocolEvent>
+  | ParsedEventOf<"UpdateVaultConfigEvent", UpdateVaultConfigEvent>
+  | ParsedEventOf<"UpdateVaultEvent", UpdateVaultEvent>
+  | ParsedEventOf<"UpdateVaultProtocolFeeEvent", UpdateVaultProtocolFeeEvent>
+  | ParsedEventOf<"WithdrawStrategyEvent", WithdrawStrategyEvent>
+  | ParsedEventOf<"WithdrawVaultEvent", WithdrawVaultEvent>;
+
+type ParsedEventOf<Name extends string, Payload> = {
+  name: Name;
+  payload: Payload;
+  /** Top-level instruction index this event was emitted under. */
+  ixIndex: number;
+  /** Sequential index of this event within the transaction (0-based). */
+  eventIndex: number;
+};
+
+/**
+ * Minimal structural shape of a transaction `meta` object — narrow enough
+ * that callers can pass `meta` from any RPC client (web3.js legacy,
+ * @solana/kit, or a hand-rolled fixture) without conversion.
+ */
+export type TransactionMetaForEvents = {
+  logMessages?: readonly string[] | null;
+};
+
+type DispatchEntry = {
+  name: ParsedVoltrEvent["name"];
+  decoder: Decoder<unknown>;
+};
+
+// Discriminators are sha256("event:<EventName>")[..8] — stable, fixed by the
+// Anchor IDL. Hardcoded so this module has no runtime hashing dependency.
+const EVENT_TABLE: ReadonlyArray<
+  readonly [ParsedVoltrEvent["name"], readonly number[], Decoder<unknown>]
+> = [
+  [
+    "AcceptProtocolAdminEvent",
+    [0xc4, 0x5d, 0xad, 0xfd, 0xaf, 0x8c, 0x79, 0x20],
+    getAcceptProtocolAdminEventDecoder(),
+  ],
+  [
+    "AcceptVaultAdminEvent",
+    [0x8c, 0xff, 0x1d, 0x44, 0x10, 0xc2, 0xfb, 0x23],
+    getAcceptVaultAdminEventDecoder(),
+  ],
+  [
+    "AddAdaptorEvent",
+    [0x18, 0xb5, 0xc9, 0x94, 0xf0, 0xb7, 0xeb, 0x0c],
+    getAddAdaptorEventDecoder(),
+  ],
+  [
+    "CalibrateHighWaterMarkEvent",
+    [0x8c, 0x4c, 0xc3, 0x90, 0xb4, 0xb2, 0x00, 0x9b],
+    getCalibrateHighWaterMarkEventDecoder(),
+  ],
+  [
+    "CalibrateHighWaterMarkUnsafeEvent",
+    [0xcd, 0x4c, 0xa9, 0xff, 0x25, 0xe4, 0x41, 0x82],
+    getCalibrateHighWaterMarkUnsafeEventDecoder(),
+  ],
+  [
+    "CancelRequestWithdrawVaultEvent",
+    [0x2e, 0xa5, 0x18, 0x72, 0x01, 0x50, 0xcd, 0x88],
+    getCancelRequestWithdrawVaultEventDecoder(),
+  ],
+  [
+    "CloseStrategyEvent",
+    [0xd5, 0x5f, 0xdb, 0xa1, 0x11, 0xd0, 0x5d, 0xff],
+    getCloseStrategyEventDecoder(),
+  ],
+  [
+    "DepositStrategyEvent",
+    [0xca, 0xc9, 0x76, 0x31, 0x1d, 0xb4, 0x74, 0xaa],
+    getDepositStrategyEventDecoder(),
+  ],
+  [
+    "DepositVaultEvent",
+    [0x0b, 0x0f, 0x07, 0x5c, 0x96, 0x64, 0xa5, 0xe8],
+    getDepositVaultEventDecoder(),
+  ],
+  [
+    "DirectWithdrawStrategyEvent",
+    [0x71, 0xca, 0x97, 0x7c, 0x89, 0xff, 0x99, 0x65],
+    getDirectWithdrawStrategyEventDecoder(),
+  ],
+  [
+    "HarvestFeeEvent",
+    [0x45, 0x30, 0xc0, 0x17, 0xe8, 0x16, 0x17, 0x1e],
+    getHarvestFeeEventDecoder(),
+  ],
+  [
+    "InitProtocolEvent",
+    [0x0d, 0x51, 0xb7, 0x84, 0x58, 0x2b, 0xca, 0xd5],
+    getInitProtocolEventDecoder(),
+  ],
+  [
+    "InitializeDirectWithdrawStrategyEvent",
+    [0xa9, 0x16, 0x39, 0x08, 0x0f, 0x49, 0xff, 0x73],
+    getInitializeDirectWithdrawStrategyEventDecoder(),
+  ],
+  [
+    "InitializeStrategyEvent",
+    [0x1e, 0xe9, 0xd3, 0xf9, 0x53, 0xbc, 0xea, 0x98],
+    getInitializeStrategyEventDecoder(),
+  ],
+  [
+    "InitializeVaultEvent",
+    [0xb3, 0x4b, 0x32, 0xa1, 0xbf, 0x1c, 0xf5, 0x6b],
+    getInitializeVaultEventDecoder(),
+  ],
+  [
+    "InstantWithdrawStrategyEvent",
+    [0xdd, 0x17, 0x0c, 0xd7, 0x64, 0x2a, 0x61, 0x95],
+    getInstantWithdrawStrategyEventDecoder(),
+  ],
+  [
+    "InstantWithdrawVaultEvent",
+    [0x2e, 0x39, 0x3c, 0x14, 0x06, 0xa0, 0xa4, 0xf7],
+    getInstantWithdrawVaultEventDecoder(),
+  ],
+  [
+    "RemoveAdaptorEvent",
+    [0x9b, 0xb2, 0x02, 0x1d, 0xf5, 0x56, 0xf6, 0x99],
+    getRemoveAdaptorEventDecoder(),
+  ],
+  [
+    "RequestWithdrawVaultEvent",
+    [0x3b, 0x5e, 0x1a, 0x26, 0x2f, 0x83, 0x9e, 0xa2],
+    getRequestWithdrawVaultEventDecoder(),
+  ],
+  [
+    "UpdateProtocolEvent",
+    [0x0e, 0xe3, 0xcc, 0xd9, 0x3e, 0x2e, 0xf1, 0xed],
+    getUpdateProtocolEventDecoder(),
+  ],
+  [
+    "UpdateVaultConfigEvent",
+    [0x3d, 0x5c, 0xce, 0x97, 0xa2, 0x28, 0xed, 0x67],
+    getUpdateVaultConfigEventDecoder(),
+  ],
+  [
+    "UpdateVaultEvent",
+    [0x7b, 0x1f, 0x1b, 0xbd, 0x66, 0x01, 0x79, 0x39],
+    getUpdateVaultEventDecoder(),
+  ],
+  [
+    "UpdateVaultProtocolFeeEvent",
+    [0xac, 0x01, 0xad, 0xe6, 0xe4, 0x3d, 0x4d, 0xf4],
+    getUpdateVaultProtocolFeeEventDecoder(),
+  ],
+  [
+    "WithdrawStrategyEvent",
+    [0x70, 0x2d, 0x10, 0xac, 0xaa, 0x21, 0x16, 0xd4],
+    getWithdrawStrategyEventDecoder(),
+  ],
+  [
+    "WithdrawVaultEvent",
+    [0xc4, 0x7b, 0x4f, 0xd7, 0x04, 0xd6, 0x14, 0xc5],
+    getWithdrawVaultEventDecoder(),
+  ],
+];
+
+const DISPATCH: ReadonlyMap<string, DispatchEntry> = new Map(
+  EVENT_TABLE.map(([name, disc, decoder]) => [
+    discriminatorKey(disc),
+    { name, decoder },
+  ])
+);
+
+const PROGRAM_DATA_PREFIX = "Program data: ";
+// Top-level instructions log "Program <id> invoke [1]" — depth >1 is a CPI.
+const TOP_LEVEL_INVOKE_RE = /^Program \S+ invoke \[1\]$/;
+
+const base64Encoder = getBase64Encoder();
+
+/**
+ * Walk a transaction's `meta.logMessages`, decode every Voltr event emitted
+ * via Anchor's `emit!`, and return them in emission order. Lines whose
+ * discriminator doesn't belong to a Voltr event are skipped, so logs from
+ * other programs in the same tx are safe to pass through.
+ */
+export function parseTransactionEvents(
+  meta: TransactionMetaForEvents | null | undefined
+): ParsedVoltrEvent[] {
+  const logs = meta?.logMessages;
+  if (!logs || logs.length === 0) return [];
+
+  const out: ParsedVoltrEvent[] = [];
+  let ixIndex = -1;
+  let eventIndex = 0;
+
+  for (const line of logs) {
+    if (TOP_LEVEL_INVOKE_RE.test(line)) {
+      ixIndex++;
+      continue;
+    }
+    if (!line.startsWith(PROGRAM_DATA_PREFIX)) continue;
+
+    const b64 = line.slice(PROGRAM_DATA_PREFIX.length);
+    let bytes: Uint8Array;
+    try {
+      bytes = base64Encoder.encode(b64) as Uint8Array;
+    } catch {
+      continue;
+    }
+    if (bytes.length < 8) continue;
+
+    const entry = DISPATCH.get(discriminatorKey(bytes.subarray(0, 8)));
+    if (!entry) continue;
+
+    // The discriminator is 8 bytes of sha256, so spurious matches from other
+    // programs are unlikely but possible — and corrupt fixtures happen too.
+    // Skip the line rather than aborting the whole parse if borsh decode fails.
+    let payload: unknown;
+    try {
+      payload = entry.decoder.decode(bytes, 8);
+    } catch {
+      continue;
+    }
+    out.push({
+      name: entry.name,
+      payload,
+      ixIndex: ixIndex < 0 ? 0 : ixIndex,
+      eventIndex: eventIndex++,
+    } as ParsedVoltrEvent);
+  }
+
+  return out;
+}
+
+function discriminatorKey(disc: ArrayLike<number>): string {
+  let s = "";
+  for (let i = 0; i < disc.length; i++) {
+    const b = disc[i] & 0xff;
+    s += (b < 16 ? "0" : "") + b.toString(16);
+  }
+  return s;
+}

package/src/extensions/fees.ts

@@ -0,0 +1,36 @@
+import type { Address } from "@solana/kit";
+
+import { fetchVault, type Vault } from "../generated";
+import type { GetAccountInfoRpc } from "./rpc";
+
+async function loadVault(
+  rpc: GetAccountInfoRpc,
+  vault: Address,
+): Promise<Vault> {
+  const account = await fetchVault(rpc, vault);
+  return account.data;
+}
+
+export async function getAccumulatedAdminFeesForVault(
+  rpc: GetAccountInfoRpc,
+  vault: Address,
+): Promise<bigint> {
+  const data = await loadVault(rpc, vault);
+  return data.feeState.accumulatedLpAdminFees;
+}
+
+export async function getAccumulatedManagerFeesForVault(
+  rpc: GetAccountInfoRpc,
+  vault: Address,
+): Promise<bigint> {
+  const data = await loadVault(rpc, vault);
+  return data.feeState.accumulatedLpManagerFees;
+}
+
+export async function getAccumulatedProtocolFeesForVault(
+  rpc: GetAccountInfoRpc,
+  vault: Address,
+): Promise<bigint> {
+  const data = await loadVault(rpc, vault);
+  return data.feeState.accumulatedLpProtocolFees;
+}

package/src/extensions/index.ts

@@ -0,0 +1,10 @@
+export * from "./batchFetchers";
+export * from "./decimal";
+export * from "./events";
+export * from "./fees";
+export * from "./lpEconomics";
+export * from "./math";
+export * from "./metadataPda";
+export * from "./position";
+export * from "./rpc";
+export * from "./withdrawals";

package/src/extensions/lpEconomics.ts

@@ -0,0 +1,225 @@
+import type { Address } from "@solana/kit";
+
+import {
+  fetchVault,
+  findVaultLpMintPda,
+  VOLTR_VAULT_PROGRAM_ADDRESS,
+  type FeeConfiguration,
+  type Vault,
+} from "../generated";
+import {
+  calculateAssetsForWithdrawAmount,
+  calculateLpForDepositAmount,
+  calculateLpForWithdrawAmount,
+  calculateUnrealisedLpFees,
+  getTotalLpSupplyInclFees,
+} from "./math";
+import type { ExtensionsRpc } from "./rpc";
+
+/**
+ * Total management fee in BPS — sum of manager + admin + protocol, matching
+ * the program's `Vault::get_total_fee_configuration_management_fee`.
+ */
+export function getTotalManagementFeeBps(
+  feeConfiguration: FeeConfiguration,
+): number {
+  return (
+    feeConfiguration.managerManagementFee +
+    feeConfiguration.adminManagementFee +
+    feeConfiguration.protocolManagementFee
+  );
+}
+
+async function vaultLpMintAddress(vault: Address): Promise<Address> {
+  const [address] = await findVaultLpMintPda(
+    { vault },
+    { programAddress: VOLTR_VAULT_PROGRAM_ADDRESS },
+  );
+  return address;
+}
+
+async function fetchTokenSupply(
+  rpc: ExtensionsRpc,
+  mint: Address,
+): Promise<{ amount: bigint; decimals: number }> {
+  const { value } = await rpc.getTokenSupply(mint).send();
+  return { amount: BigInt(value.amount), decimals: value.decimals };
+}
+
+async function loadVaultAndLpSupply(
+  rpc: ExtensionsRpc,
+  vault: Address,
+): Promise<{ data: Vault; lpSupply: bigint; lpDecimals: number }> {
+  const account = await fetchVault(rpc, vault);
+  const lpMint = await vaultLpMintAddress(vault);
+  const { amount, decimals } = await fetchTokenSupply(rpc, lpMint);
+  return { data: account.data, lpSupply: amount, lpDecimals: decimals };
+}
+
+/**
+ * Returns the on-chain "asset per LP" ratio used by mint/burn math: total
+ * asset value divided by `total_lp_supply_incl_fees + unrealised management
+ * fee LP`. Mirrors what the deposit/withdraw handlers see after they call
+ * `handle_management_fee`. Returns 0 when there is no LP at all.
+ */
+export async function getCurrentAssetPerLpForVault(
+  rpc: ExtensionsRpc,
+  vault: Address,
+): Promise<number> {
+  const { data, lpSupply } = await loadVaultAndLpSupply(rpc, vault);
+
+  const totalLpSupplyInclFees = getTotalLpSupplyInclFees({
+    lpSupply,
+    vaultAccumulatedLpAdminFees: data.feeState.accumulatedLpAdminFees,
+    vaultAccumulatedLpManagerFees: data.feeState.accumulatedLpManagerFees,
+    vaultAccumulatedLpProtocolFees: data.feeState.accumulatedLpProtocolFees,
+    vaultDeadWeight: data.deadWeight,
+  });
+
+  const unrealisedLpFees = calculateUnrealisedLpFees(
+    totalLpSupplyInclFees,
+    data.asset.totalValue,
+    data.feeUpdate.lastManagementFeeUpdateTs,
+    BigInt(getTotalManagementFeeBps(data.feeConfiguration)),
+  );
+
+  const totalLpSupply = totalLpSupplyInclFees + unrealisedLpFees;
+  if (totalLpSupply === 0n) return 0;
+
+  return Number(data.asset.totalValue) / Number(totalLpSupply);
+}
+
+export type VaultLpSupplyBreakdown = {
+  circulating: bigint;
+  unharvestedFees: bigint;
+  deadWeight: bigint;
+  unrealisedFees: bigint;
+  total: bigint;
+};
+
+export async function getVaultLpSupplyBreakdown(
+  rpc: ExtensionsRpc,
+  vault: Address,
+): Promise<VaultLpSupplyBreakdown> {
+  const { data, lpSupply } = await loadVaultAndLpSupply(rpc, vault);
+
+  const unharvestedFees =
+    data.feeState.accumulatedLpAdminFees +
+    data.feeState.accumulatedLpManagerFees +
+    data.feeState.accumulatedLpProtocolFees;
+  const deadWeight = data.deadWeight;
+
+  const currentTotalLp = lpSupply + unharvestedFees + deadWeight;
+
+  const unrealisedFees = calculateUnrealisedLpFees(
+    currentTotalLp,
+    data.asset.totalValue,
+    data.feeUpdate.lastManagementFeeUpdateTs,
+    BigInt(getTotalManagementFeeBps(data.feeConfiguration)),
+  );
+
+  return {
+    circulating: lpSupply,
+    unharvestedFees,
+    deadWeight,
+    unrealisedFees,
+    total: currentTotalLp + unrealisedFees,
+  };
+}
+
+export async function calculateAssetsForWithdraw(
+  rpc: ExtensionsRpc,
+  vault: Address,
+  lpAmount: bigint,
+): Promise<bigint> {
+  const { data, lpSupply } = await loadVaultAndLpSupply(rpc, vault);
+
+  return calculateAssetsForWithdrawAmount({
+    vaultTotalValue: data.asset.totalValue,
+    vaultLastUpdatedLockedProfit:
+      data.lockedProfitState.lastUpdatedLockedProfit,
+    vaultLastReport: data.lockedProfitState.lastReport,
+    vaultLockedProfitDegradationDuration:
+      data.vaultConfiguration.lockedProfitDegradationDuration,
+    vaultAccumulatedLpAdminFees: data.feeState.accumulatedLpAdminFees,
+    vaultAccumulatedLpManagerFees: data.feeState.accumulatedLpManagerFees,
+    vaultAccumulatedLpProtocolFees: data.feeState.accumulatedLpProtocolFees,
+    vaultDeadWeight: data.deadWeight,
+    vaultRedemptionFeeBps: data.feeConfiguration.redemptionFee,
+    vaultManagementFeeBps: getTotalManagementFeeBps(data.feeConfiguration),
+    vaultLastManagementFeeUpdateTs: data.feeUpdate.lastManagementFeeUpdateTs,
+    lpSupply,
+    lpAmount,
+  });
+}
+
+export async function calculateLpForWithdraw(
+  rpc: ExtensionsRpc,
+  vault: Address,
+  assetAmount: bigint,
+): Promise<bigint> {
+  const { data, lpSupply } = await loadVaultAndLpSupply(rpc, vault);
+
+  return calculateLpForWithdrawAmount({
+    vaultTotalValue: data.asset.totalValue,
+    vaultLastUpdatedLockedProfit:
+      data.lockedProfitState.lastUpdatedLockedProfit,
+    vaultLastReport: data.lockedProfitState.lastReport,
+    vaultLockedProfitDegradationDuration:
+      data.vaultConfiguration.lockedProfitDegradationDuration,
+    vaultAccumulatedLpAdminFees: data.feeState.accumulatedLpAdminFees,
+    vaultAccumulatedLpManagerFees: data.feeState.accumulatedLpManagerFees,
+    vaultAccumulatedLpProtocolFees: data.feeState.accumulatedLpProtocolFees,
+    vaultDeadWeight: data.deadWeight,
+    vaultRedemptionFeeBps: data.feeConfiguration.redemptionFee,
+    vaultManagementFeeBps: getTotalManagementFeeBps(data.feeConfiguration),
+    vaultLastManagementFeeUpdateTs: data.feeUpdate.lastManagementFeeUpdateTs,
+    lpSupply,
+    assetAmount,
+  });
+}
+
+export async function calculateLpForDeposit(
+  rpc: ExtensionsRpc,
+  vault: Address,
+  assetAmount: bigint,
+): Promise<bigint> {
+  const { data, lpSupply, lpDecimals } = await loadVaultAndLpSupply(rpc, vault);
+
+  // Asset decimals are only required when the LP pool is empty (1:1 mint).
+  // Avoid an extra RPC round-trip in the common case.
+  let assetDecimals = 0;
+  const lpSupplyInclAccumulatedFees = getTotalLpSupplyInclFees({
+    lpSupply,
+    vaultAccumulatedLpAdminFees: data.feeState.accumulatedLpAdminFees,
+    vaultAccumulatedLpManagerFees: data.feeState.accumulatedLpManagerFees,
+    vaultAccumulatedLpProtocolFees: data.feeState.accumulatedLpProtocolFees,
+    vaultDeadWeight: data.deadWeight,
+  });
+  const unrealisedLpFees = calculateUnrealisedLpFees(
+    lpSupplyInclAccumulatedFees,
+    data.asset.totalValue,
+    data.feeUpdate.lastManagementFeeUpdateTs,
+    BigInt(getTotalManagementFeeBps(data.feeConfiguration)),
+  );
+  const lpSupplyInclFees = lpSupplyInclAccumulatedFees + unrealisedLpFees;
+  if (lpSupplyInclFees === 0n) {
+    const { decimals } = await fetchTokenSupply(rpc, data.asset.mint);
+    assetDecimals = decimals;
+  }
+
+  return calculateLpForDepositAmount({
+    vaultTotalValue: data.asset.totalValue,
+    vaultAccumulatedLpAdminFees: data.feeState.accumulatedLpAdminFees,
+    vaultAccumulatedLpManagerFees: data.feeState.accumulatedLpManagerFees,
+    vaultAccumulatedLpProtocolFees: data.feeState.accumulatedLpProtocolFees,
+    vaultDeadWeight: data.deadWeight,
+    vaultIssuanceFeeBps: data.feeConfiguration.issuanceFee,
+    vaultManagementFeeBps: getTotalManagementFeeBps(data.feeConfiguration),
+    vaultLastManagementFeeUpdateTs: data.feeUpdate.lastManagementFeeUpdateTs,
+    lpSupply,
+    assetAmount,
+    assetDecimals,
+    lpDecimals,
+  });
+}