Add calcShortMarketValue to hyperdrive-wasm (#1167)

Co-authored-by: MazyGio <[email protected]>

Author: DannyDelott

apps/hyperdrive-trading/src/routeTree.gen.ts

@@ -10,64 +10,64 @@
 
 // Import Routes
 
-import { Route as rootRoute } from "./ui/routes/__root";
-import { Route as BridgeImport } from "./ui/routes/bridge";
-import { Route as IndexImport } from "./ui/routes/index";
-import { Route as MarketAddressImport } from "./ui/routes/market.$address";
-import { Route as MarketsImport } from "./ui/routes/markets";
-import { Route as VoidImport } from "./ui/routes/void";
+import { Route as rootRoute } from './ui/routes/__root'
+import { Route as VoidImport } from './ui/routes/void'
+import { Route as MarketsImport } from './ui/routes/markets'
+import { Route as BridgeImport } from './ui/routes/bridge'
+import { Route as IndexImport } from './ui/routes/index'
+import { Route as MarketAddressImport } from './ui/routes/market.$address'
 
 // Create/Update Routes
 
 const VoidRoute = VoidImport.update({
-  path: "/void",
+  path: '/void',
   getParentRoute: () => rootRoute,
-} as any);
+} as any)
 
 const MarketsRoute = MarketsImport.update({
-  path: "/markets",
+  path: '/markets',
   getParentRoute: () => rootRoute,
-} as any);
+} as any)
 
 const BridgeRoute = BridgeImport.update({
-  path: "/bridge",
+  path: '/bridge',
   getParentRoute: () => rootRoute,
-} as any);
+} as any)
 
 const IndexRoute = IndexImport.update({
-  path: "/",
+  path: '/',
   getParentRoute: () => rootRoute,
-} as any);
+} as any)
 
 const MarketAddressRoute = MarketAddressImport.update({
-  path: "/market/$address",
+  path: '/market/$address',
   getParentRoute: () => rootRoute,
-} as any);
+} as any)
 
 // Populate the FileRoutesByPath interface
 
-declare module "@tanstack/react-router" {
+declare module '@tanstack/react-router' {
   interface FileRoutesByPath {
-    "/": {
-      preLoaderRoute: typeof IndexImport;
-      parentRoute: typeof rootRoute;
-    };
-    "/bridge": {
-      preLoaderRoute: typeof BridgeImport;
-      parentRoute: typeof rootRoute;
-    };
-    "/markets": {
-      preLoaderRoute: typeof MarketsImport;
-      parentRoute: typeof rootRoute;
-    };
-    "/void": {
-      preLoaderRoute: typeof VoidImport;
-      parentRoute: typeof rootRoute;
-    };
-    "/market/$address": {
-      preLoaderRoute: typeof MarketAddressImport;
-      parentRoute: typeof rootRoute;
-    };
+    '/': {
+      preLoaderRoute: typeof IndexImport
+      parentRoute: typeof rootRoute
+    }
+    '/bridge': {
+      preLoaderRoute: typeof BridgeImport
+      parentRoute: typeof rootRoute
+    }
+    '/markets': {
+      preLoaderRoute: typeof MarketsImport
+      parentRoute: typeof rootRoute
+    }
+    '/void': {
+      preLoaderRoute: typeof VoidImport
+      parentRoute: typeof rootRoute
+    }
+    '/market/$address': {
+      preLoaderRoute: typeof MarketAddressImport
+      parentRoute: typeof rootRoute
+    }
   }
 }
 
@@ -79,6 +79,6 @@ export const routeTree = rootRoute.addChildren([
   MarketsRoute,
   VoidRoute,
   MarketAddressRoute,
-]);
+])
 
 /* prettier-ignore-end */

apps/hyperdrive-trading/src/ui/hyperdrive/shorts/OpenShortsTable/CurrentValueCell.tsx

@@ -7,6 +7,7 @@ import Skeleton from "react-loading-skeleton";
 import { useAppConfig } from "src/ui/appconfig/useAppConfig";
 import { formatBalance } from "src/ui/base/formatting/formatBalance";
 import { useIsTailwindSmallScreen } from "src/ui/base/mediaBreakpoints";
+import { useEstimateShortMarketValue } from "src/ui/hyperdrive/shorts/hooks/useEstimateShortMarketValue";
 import { usePreviewCloseShort } from "src/ui/hyperdrive/shorts/hooks/usePreviewCloseShort";
 
 export function CurrentValueCell({
@@ -33,8 +34,14 @@ export function CurrentValueCell({
     shortAmountIn: openShort.bondAmount,
   });
 
+  const { marketEstimate } = useEstimateShortMarketValue({
+    hyperdriveAddress: hyperdrive.address,
+    maturityTime: openShort.maturity,
+    shortAmountIn: openShort.bondAmount,
+  });
+
   const currentValueLabel = formatBalance({
-    balance: currentValueInBase || 0n,
+    balance: currentValueInBase || marketEstimate || 0n,
     decimals: baseToken.decimals,
     places: baseToken.places,
   });

apps/hyperdrive-trading/src/ui/hyperdrive/shorts/hooks/useEstimateShortMarketValue.ts

@@ -0,0 +1,68 @@
+import { useQuery } from "@tanstack/react-query";
+import { makeQueryKey } from "src/base/makeQueryKey";
+import { QueryStatusWithIdle, getStatus } from "src/base/queryStatus";
+import { useAppConfig } from "src/ui/appconfig/useAppConfig";
+import { prepareSharesOut } from "src/ui/hyperdrive/hooks/usePrepareSharesOut";
+import { useReadHyperdrive } from "src/ui/hyperdrive/hooks/useReadHyperdrive";
+import { Address } from "viem";
+
+interface UseEstimateShortMarketValue {
+  hyperdriveAddress: Address;
+  maturityTime: bigint | undefined;
+  shortAmountIn: bigint | undefined;
+  asBase?: boolean;
+  enabled?: boolean;
+}
+
+interface UseEstimateShortMarketValueResult {
+  estimateShortMarketValueStatus: QueryStatusWithIdle;
+  marketEstimate: bigint | undefined;
+}
+
+export function useEstimateShortMarketValue({
+  hyperdriveAddress,
+  maturityTime,
+  shortAmountIn,
+  asBase = true,
+  enabled = true,
+}: UseEstimateShortMarketValue): UseEstimateShortMarketValueResult {
+  const readHyperdrive = useReadHyperdrive(hyperdriveAddress);
+  const appConfig = useAppConfig();
+  const queryEnabled =
+    !!readHyperdrive && !!maturityTime && !!shortAmountIn && enabled;
+
+  const { data, status, fetchStatus } = useQuery({
+    queryKey: makeQueryKey("estimateShortMarketValue", {
+      hyperdriveAddress,
+      maturityTime: maturityTime?.toString(),
+      shortAmountIn: shortAmountIn?.toString(),
+      asBase,
+    }),
+
+    enabled: queryEnabled,
+    queryFn: queryEnabled
+      ? async () => {
+          const result = await readHyperdrive.estimateShortMarketValue({
+            maturityTime,
+            shortAmountIn,
+            asBase,
+          });
+
+          // All shares from the sdk need to be prepared for the UI
+          return asBase
+            ? result
+            : await prepareSharesOut({
+                appConfig,
+                hyperdriveAddress,
+                readHyperdrive,
+                sharesAmount: result,
+              });
+        }
+      : undefined,
+  });
+
+  return {
+    marketEstimate: data,
+    estimateShortMarketValueStatus: getStatus(status, fetchStatus),
+  };
+}

crates/hyperdrive-wasm/src/short/close.rs

@@ -1,10 +1,13 @@
+use std::ops::{Div, Mul, Sub};
+
+use fixed_point::fixed;
 use hyperdrive_math::State;
 use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
 
 use crate::{
     error::ToJsResult,
     types::{JsPoolConfig, JsPoolInfo},
-    utils::ToU256,
+    utils::{ToFixedPoint, ToU256},
 };
 
 /// Calculates the amount of shares the trader will receive after fees for
@@ -57,3 +60,100 @@ pub fn calcCloseShort(
 
     Ok(result_fp.to_u256()?.to_string())
 }
+
+/// Calculates the market value of a short position using the equation:
+/// market_estimate = yield_accrued + trading_proceeds - curve_fees_paid + flat_fees_returned
+///
+/// yield_accrued      = dy * (c-c0)/c0
+/// trading_proceeds   = dy * (1 - p) * t
+/// curve_fees_paid    = trading_proceeds * curve_fee
+/// flat_fees_returned = dy * t * flat_fee
+///
+/// dy = bond amount
+/// c  = closeVaultSharePrice (current if non-matured, or checkpoint's if matured)
+/// c0 = openVaultSharePrice
+/// p  = spotPrice
+/// t  = timeRemaining
+///
+/// @param poolInfo - The current state of the pool
+///
+/// @param poolConfig - The pool's configuration
+///
+/// @param bondAmount - The number of short bonds to close
+///
+/// @param openVaultSharePrice - The vault share price at the checkpoint when
+/// the position was opened
+///
+/// @param closeVaultSharePrice - The current vault share price, or if the
+/// position has matured, the vault share price from the closing checkpoint
+///
+/// @param maturityTime - The maturity timestamp of the short (in seconds)
+///
+/// @param currentTime - The current timestamp (in seconds)
+#[wasm_bindgen(skip_jsdoc)]
+pub fn calcShortMarketValue(
+    poolInfo: &JsPoolInfo,
+    poolConfig: &JsPoolConfig,
+    bondAmount: &str,
+    openVaultSharePrice: &str,
+    closeVaultSharePrice: &str,
+    maturityTime: &str,
+    currentTime: &str,
+) -> Result<String, JsValue> {
+    let state = State {
+        info: poolInfo.try_into()?,
+        config: poolConfig.try_into()?,
+    };
+    // dy is the bonds shorted
+    let bond_amount = bondAmount.to_fixed_point()?;
+
+    // c is the closing vault share price
+    let close_vault_share_price = closeVaultSharePrice.to_fixed_point()?;
+
+    // c0 is the open vault share price
+    let open_vault_share_price = openVaultSharePrice.to_fixed_point()?;
+
+    let maturity_time = maturityTime.to_fixed_point()?;
+    let current_time = currentTime.to_fixed_point()?;
+
+    // p is the current pool spot price
+    let spot_price = state
+        .calculate_spot_price()
+        .to_js_result()?
+        .to_fixed_point()?;
+
+    // t is the time remaining
+    // (maturity_time - latest_checkpoint) / position_duration
+    let latest_checkpoint = state.to_checkpoint(current_time.into()).to_fixed_point()?;
+    let time_remaining = if maturity_time > latest_checkpoint {
+        // NOTE: Round down to underestimate the time remaining.
+        (maturity_time.sub(latest_checkpoint))
+            .div_down(state.config.position_duration.to_fixed_point()?)
+    } else {
+        fixed!(0)
+    };
+
+    // yield accrued
+    // dy * (c-c0)/c0
+    let yield_accrued = bond_amount
+        .mul(close_vault_share_price.sub(open_vault_share_price))
+        .div(open_vault_share_price);
+
+    // trading_proceeds
+    // dy * (1 - p) * t
+    let trading_proceeds = bond_amount
+        .mul(fixed!(1e18).sub(spot_price))
+        .mul(time_remaining);
+
+    // curve_fees_paid = trading_proceeds * curve_fee
+    let curve_fees_paid = trading_proceeds.mul(state.config.fees.curve.to_fixed_point()?);
+
+    // flat_fees_returned = dy * t * flat_fee
+    let flat_fees_returned = bond_amount
+        .mul(time_remaining)
+        .mul(state.config.fees.flat.to_fixed_point()?);
+
+    let result = yield_accrued + trading_proceeds - curve_fees_paid + flat_fees_returned;
+
+    Ok(result.to_u256()?.to_string())
+}

packages/hyperdrive-js-core/src/hyperdrive/ReadHyperdrive/ReadHyperdrive.ts

@@ -1816,9 +1816,72 @@ export class ReadHyperdrive extends ReadModel {
       }),
     };
   }
+  /**
+   * Get a rough estimate of the market value of a short. This can be used to
+   * value a position that cannot be fully closed.
+   */
+  async estimateShortMarketValue({
+    maturityTime,
+    asBase,
+    shortAmountIn,
+    options,
+  }: {
+    maturityTime: bigint;
+    shortAmountIn: bigint;
+    asBase: boolean;
+    extraData?: `0x${string}`;
+    options?: ContractReadOptions;
+  }): Promise<bigint> {
+    const poolConfig = await this.getPoolConfig(options);
+    const poolInfo = await this.getPoolInfo(options);
+
+    // The checkpoint in which this position was opened.
+    // This is always maturity time - position duration thanks to mint on demand
+    const openCheckpointTimestamp = maturityTime - poolConfig.positionDuration;
+    const { vaultSharePrice: openSharePrice } = await this.getCheckpoint({
+      timestamp: openCheckpointTimestamp,
+      options,
+    });
+
+    const currentTime = Math.floor(Date.now() / 1000);
+
+    // If the position is mature, we use the closing vault share price otherwise
+    // use the current vault share price
+    let closeSharePrice = poolInfo.vaultSharePrice;
+    if (maturityTime <= currentTime) {
+      const closingCheckpoint = await this.getCheckpoint({
+        timestamp: maturityTime,
+        options,
+      });
+      closeSharePrice = closingCheckpoint.vaultSharePrice;
+    }
+
+    const marketEstimateInShares = BigInt(
+      hyperwasm.calcShortMarketValue(
+        convertBigIntsToStrings(poolInfo),
+        convertBigIntsToStrings(poolConfig),
+        shortAmountIn.toString(),
+        openSharePrice.toString(),
+        closeSharePrice.toString(),
+        maturityTime.toString(),
+        currentTime.toString(),
+      ),
+    );
+
+    if (!asBase) {
+      return marketEstimateInShares;
+    }
+
+    return this.convertToBase({
+      sharesAmount: marketEstimateInShares,
+      options,
+    });
+  }
 
   /**
    * Predicts the amount of base asset a user will receive when closing a short.
+   * If closing the short would result in negative interest, an error will be
+   * thrown.
    */
   async previewCloseShort({
     maturityTime,
@@ -2082,3 +2145,7 @@ function calculateLpApy({
 
   return lpApy;
 }
+
+function isNegativeInterestError(error: string) {
+  return error.includes("InsufficientLiquidity: Negative Interest");
+}