Liq price in balances (#679)

* add liquidation price to balances table trade

* add depositcap to HLS

* fix: add width classes to the balances table, remove abbreviation, remove flicker

* fix: fixed the account selection and added a tooltip

* fix wasm file for debt liquidation price

---------

Co-authored-by: Linkie Link <linkielink.dev@gmail.com>

src/components/Account/AccountBalancesTable/Columns/Apy.tsx

@@ -1,7 +1,7 @@
 import AssetRate from 'components/Asset/AssetRate'
 import { byDenom } from 'utils/array'
 
-export const APY_META = { accessorKey: 'apy', header: 'APY' }
+export const APY_META = { accessorKey: 'apy', header: 'APY', meta: { className: 'w-30' } }
 
 interface Props {
   apy: number

src/components/Account/AccountBalancesTable/Columns/LiqPrice.tsx

@@ -0,0 +1,66 @@
+import { useEffect, useMemo, useState } from 'react'
+
+import DisplayCurrency from 'components/DisplayCurrency'
+import { InfoCircle } from 'components/Icons'
+import Text from 'components/Text'
+import { Tooltip } from 'components/Tooltip'
+import useLiquidationPrice from 'hooks/useLiquidationPrice'
+import { BNCoin } from 'types/classes/BNCoin'
+import { LiquidationPriceKind } from 'utils/health_computer'
+import { BN } from 'utils/helpers'
+
+export const LIQ_META = {
+  accessorKey: 'symbol',
+  header: 'Liquidation Price',
+  id: 'liqPrice',
+  meta: { className: 'w-40' },
+}
+
+interface Props {
+  amount: number
+  computeLiquidationPrice: (denom: string, kind: LiquidationPriceKind) => number | null
+  denom: string
+  type: 'deposits' | 'borrowing' | 'lending' | 'vault'
+}
+
+export default function LiqPrice(props: Props) {
+  const { denom, type, amount, computeLiquidationPrice } = props
+  const [lastLiquidationPrice, setLastLiquidationPrice] = useState<number | null>(null)
+
+  const liqPrice = useMemo(() => {
+    if (type === 'vault' || amount === 0) return 0
+    return computeLiquidationPrice(denom, type === 'borrowing' ? 'debt' : 'asset')
+  }, [amount, computeLiquidationPrice, denom, type])
+
+  const { liquidationPrice } = useLiquidationPrice(liqPrice)
+
+  useEffect(() => {
+    if (lastLiquidationPrice !== liqPrice && liqPrice !== null) setLastLiquidationPrice(liqPrice)
+  }, [liqPrice, lastLiquidationPrice])
+
+  if (!lastLiquidationPrice || (liquidationPrice === 0 && lastLiquidationPrice === 0))
+    return (
+      <Text size='xs' className='flex items-center justify-end number'>
+        N/A
+        <Tooltip
+          content={
+            type === 'vault'
+              ? 'Liquidation prices cannot be calculated for farm positions. But it a drop in price of the underlying assets can still cause a liquidation.'
+              : 'The position size is too small to liquidate the account, even if the price goes to $0.00.'
+          }
+          type='info'
+          className='ml-1'
+        >
+          <InfoCircle className='w-3.5 h-3.5 text-white/40 hover:text-inherit' />
+        </Tooltip>
+      </Text>
+    )
+
+  return (
+    <DisplayCurrency
+      className='text-xs text-right number'
+      coin={BNCoin.fromDenomAndBigNumber('usd', BN(lastLiquidationPrice))}
+      options={{ abbreviated: false }}
+    />
+  )
+}

src/components/Account/AccountBalancesTable/Columns/Price.tsx

@@ -0,0 +1,26 @@
+import DisplayCurrency from 'components/DisplayCurrency'
+import usePrice from 'hooks/usePrice'
+import { BNCoin } from 'types/classes/BNCoin'
+import { BN } from 'utils/helpers'
+
+export const PRICE_META = { id: 'price', header: 'Price', meta: { className: 'w-30' } }
+
+interface Props {
+  amount: number
+  denom: string
+  type: 'deposits' | 'borrowing' | 'lending' | 'vault'
+}
+
+export default function Price(props: Props) {
+  const price = usePrice(props.denom)
+
+  if (props.amount === 0 || props.type === 'vault') return null
+
+  return (
+    <DisplayCurrency
+      className='text-xs text-right number'
+      coin={BNCoin.fromDenomAndBigNumber('usd', BN(price))}
+      options={{ abbreviated: false }}
+    />
+  )
+}

src/components/Account/AccountBalancesTable/Columns/Size.tsx

@@ -6,7 +6,7 @@ import { FormattedNumber } from 'components/FormattedNumber'
 import { MAX_AMOUNT_DECIMALS, MIN_AMOUNT } from 'constants/math'
 import { formatAmountToPrecision } from 'utils/formatters'
 
-export const SIZE_META = { accessorKey: 'size', header: 'Size' }
+export const SIZE_META = { accessorKey: 'size', header: 'Size', meta: { className: 'w-40' } }
 
 interface Props {
   size: number

src/components/Account/AccountBalancesTable/Columns/useAccountBalancesColumns.tsx

@@ -1,8 +1,10 @@
-import { ColumnDef } from '@tanstack/react-table'
+import { ColumnDef, Row } from '@tanstack/react-table'
 import { useMemo } from 'react'
 
 import Apy, { APY_META } from 'components/Account/AccountBalancesTable/Columns/Apy'
 import Asset, { ASSET_META } from 'components/Account/AccountBalancesTable/Columns/Asset'
+import LiqPrice, { LIQ_META } from 'components/Account/AccountBalancesTable/Columns/LiqPrice'
+import Price, { PRICE_META } from 'components/Account/AccountBalancesTable/Columns/Price'
 import Size, {
   SIZE_META,
   sizeSortingFn,
@@ -11,10 +13,18 @@ import Value, {
   VALUE_META,
   valueSortingFn,
 } from 'components/Account/AccountBalancesTable/Columns/Value'
+import useHealthComputer from 'hooks/useHealthComputer'
 import useMarketAssets from 'hooks/useMarketAssets'
+import useStore from 'store'
 
-export default function useAccountBalancesColumns() {
+export default function useAccountBalancesColumns(
+  account: Account,
+  showLiquidationPrice?: boolean,
+) {
   const { data: markets } = useMarketAssets()
+  const updatedAccount = useStore((s) => s.updatedAccount)
+
+  const { computeLiquidationPrice } = useHealthComputer(updatedAccount ?? account)
 
   return useMemo<ColumnDef<AccountBalanceRow>[]>(() => {
     return [
@@ -46,6 +56,36 @@ export default function useAccountBalancesColumns() {
         ),
         sortingFn: sizeSortingFn,
       },
+      ...(showLiquidationPrice
+        ? [
+            {
+              ...PRICE_META,
+              cell: ({ row }: { row: Row<AccountBalanceRow> }) => (
+                <Price
+                  type={row.original.type}
+                  amount={row.original.amount.toNumber()}
+                  denom={row.original.denom}
+                />
+              ),
+            },
+          ]
+        : []),
+      ...(showLiquidationPrice
+        ? [
+            {
+              ...LIQ_META,
+              enableSorting: false,
+              cell: ({ row }: { row: Row<AccountBalanceRow> }) => (
+                <LiqPrice
+                  denom={row.original.denom}
+                  computeLiquidationPrice={computeLiquidationPrice}
+                  type={row.original.type}
+                  amount={row.original.amount.toNumber()}
+                />
+              ),
+            },
+          ]
+        : []),
       {
         ...APY_META,
         cell: ({ row }) => (
@@ -58,5 +98,5 @@ export default function useAccountBalancesColumns() {
         ),
       },
     ]
-  }, [markets])
+  }, [computeLiquidationPrice, markets, showLiquidationPrice])
 }

src/components/Account/AccountBalancesTable/index.tsx

@@ -19,11 +19,19 @@ interface Props {
   borrowingData: BorrowMarketTableData[]
   hideCard?: boolean
   tableBodyClassName?: string
+  showLiquidationPrice?: boolean
 }
 
 export default function AccountBalancesTable(props: Props) {
   const [searchParams] = useSearchParams()
-  const { account, lendingData, borrowingData, tableBodyClassName, hideCard } = props
+  const {
+    account,
+    lendingData,
+    borrowingData,
+    tableBodyClassName,
+    hideCard,
+    showLiquidationPrice,
+  } = props
   const currentAccount = useCurrentAccount()
   const navigate = useNavigate()
   const { pathname } = useLocation()
@@ -37,7 +45,7 @@ export default function AccountBalancesTable(props: Props) {
     isHls: props.isHls,
   })
 
-  const columns = useAccountBalancesColumns()
+  const columns = useAccountBalancesColumns(account, showLiquidationPrice)
 
   if (accountBalanceData.length === 0)
     return (

src/components/HLS/Staking/Table/Columns/DepositCap.tsx

@@ -15,9 +15,9 @@ export const depositCapSortingFn = (
 }
 
 interface Props {
-  account: HLSAccountWithStrategy
+  depositCap: DepositCap
 }
 
-export default function Name(props: Props) {
-  return <DepositCapCell depositCap={props.account.strategy.depositCap} />
+export default function DepositCap(props: Props) {
+  return <DepositCapCell depositCap={props.depositCap} />
 }

src/components/HLS/Staking/Table/Columns/useAvailableColumns.tsx

@@ -6,6 +6,7 @@ import ApyRange, {
   APY_RANGE_META,
   apyRangeSortingFn,
 } from 'components/HLS/Staking/Table/Columns/ApyRange'
+import DepositCap, { CAP_META } from 'components/HLS/Staking/Table/Columns/DepositCap'
 import MaxLeverage, { MAX_LEV_META } from 'components/HLS/Staking/Table/Columns/MaxLeverage'
 import MaxLTV, { LTV_MAX_META } from 'components/HLS/Staking/Table/Columns/MaxLTV'
 import Name, { NAME_META } from 'components/HLS/Staking/Table/Columns/Name'
@@ -31,6 +32,10 @@ export default function useAvailableColumns(props: Props) {
           <MaxLTV strategy={row.original as HLSStrategy} isLoading={props.isLoading} />
         ),
       },
+      {
+        ...CAP_META,
+        cell: ({ row }) => <DepositCap depositCap={row.original.depositCap} />,
+      },
       {
         ...APY_RANGE_META,
         cell: ({ row }) => (

src/components/HLS/Staking/Table/Columns/useDepositedColumns.tsx

@@ -57,7 +57,7 @@ export default function useDepositedColumns(props: Props) {
       },
       {
         ...CAP_META,
-        cell: ({ row }) => <DepositCap account={row.original} />,
+        cell: ({ row }) => <DepositCap depositCap={row.original.strategy.depositCap} />,
         sortingFn: depositCapSortingFn,
       },
       {

src/components/Portfolio/Account/Balances.tsx

@@ -29,6 +29,7 @@ function Content(props: Props) {
         account={account}
         borrowingData={borrowAssets}
         lendingData={lendingAssets}
+        showLiquidationPrice
         hideCard
       />
     </Skeleton>
@@ -55,7 +56,10 @@ function Skeleton(props: SkeletonProps) {
         {props.children ? (
           props.children
         ) : (
-          <TableSkeleton labels={['Asset', 'Value', 'Size', 'APY']} rowCount={3} />
+          <TableSkeleton
+            labels={['Asset', 'Value', 'Size', 'Price', 'Liquidation Price', 'APY']}
+            rowCount={3}
+          />
         )}
       </Card>
     </div>

src/components/Trade/AccountDetailsCard.tsx

@@ -23,6 +23,7 @@ export default function AccountDetailsCard() {
         borrowingData={borrowAssetsData}
         lendingData={lendingAssetsData}
         tableBodyClassName='gradient-card-content'
+        showLiquidationPrice
       />
     )
 }

src/components/Trade/TradeModule/SwapForm/TradeSummary.tsx

@@ -1,6 +1,5 @@
 import classNames from 'classnames'
-import debounce from 'lodash.debounce'
-import React, { useEffect, useMemo, useState } from 'react'
+import React, { useMemo } from 'react'
 
 import ActionButton from 'components/Button/ActionButton'
 import { CircularProgress } from 'components/CircularProgress'
@@ -11,6 +10,7 @@ import { ChevronDown } from 'components/Icons'
 import Text from 'components/Text'
 import { DEFAULT_SETTINGS } from 'constants/defaultSettings'
 import { LocalStorageKeys } from 'constants/localStorageKeys'
+import useLiquidationPrice from 'hooks/useLiquidationPrice'
 import useLocalStorage from 'hooks/useLocalStorage'
 import usePrice from 'hooks/usePrice'
 import useSwapFee from 'hooks/useSwapFee'
@@ -59,24 +59,14 @@ export default function TradeSummary(props: Props) {
   const sellAssetPrice = usePrice(sellAsset.denom)
   const swapFee = useSwapFee(route.map((r) => r.pool_id))
   const [showSummary, setShowSummary] = useToggle()
-  const [liquidationPrice, setLiquidationPrice] = useState<number | null>(null)
-  const [isUpdatingLiquidationPrice, setIsUpdatingLiquidationPrice] = useState(false)
-  const debouncedSetLiqPrice = useMemo(
-    () => debounce(setLiquidationPrice, 1000, { leading: false }),
-    [],
+  const { liquidationPrice, isUpdatingLiquidationPrice } = useLiquidationPrice(
+    props.liquidationPrice,
   )
 
   const minReceive = useMemo(() => {
     return buyAmount.times(1 - swapFee).times(1 - slippage)
   }, [buyAmount, slippage, swapFee])
 
-  useEffect(() => {
-    setIsUpdatingLiquidationPrice(true)
-    debouncedSetLiqPrice(props.liquidationPrice)
-  }, [debouncedSetLiqPrice, props.liquidationPrice])
-
-  useEffect(() => setIsUpdatingLiquidationPrice(false), [liquidationPrice])
-
   const swapFeeValue = useMemo(() => {
     return sellAssetPrice.times(swapFee).times(sellAmount)
   }, [sellAmount, sellAssetPrice, swapFee])

src/components/Trade/TradeModule/SwapForm/index.tsx

@@ -210,7 +210,7 @@ export default function SwapForm(props: Props) {
   )
 
   const liquidationPrice = useMemo(
-    () => computeLiquidationPrice(props.buyAsset.denom),
+    () => computeLiquidationPrice(props.buyAsset.denom, 'asset'),
     [computeLiquidationPrice, props.buyAsset.denom],
   )
 

src/hooks/useHealthComputer.tsx

@@ -24,6 +24,7 @@ import {
   BorrowTarget,
   compute_health_js,
   liquidation_price_js,
+  LiquidationPriceKind,
   max_borrow_estimate_js,
   max_swap_estimate_js,
   max_withdraw_estimate_js,
@@ -198,13 +199,13 @@ export default function useHealthComputer(account?: Account) {
   )
 
   const computeLiquidationPrice = useCallback(
-    (denom: string) => {
+    (denom: string, kind: LiquidationPriceKind) => {
       if (!healthComputer) return null
       try {
         const asset = getAssetByDenom(denom)
         if (!asset) return null
         const decimalDiff = asset.decimals - PRICE_ORACLE_DECIMALS
-        return BN(liquidation_price_js(healthComputer, denom))
+        return BN(liquidation_price_js(healthComputer, denom, kind))
           .shiftedBy(-VALUE_SCALE_FACTOR)
           .shiftedBy(decimalDiff)
           .toNumber()

src/hooks/useLiquidationPrice.ts

@@ -0,0 +1,22 @@
+import debounce from 'lodash.debounce'
+import { useEffect, useMemo, useState } from 'react'
+
+export default function useLiquidationPrice(liqPrice: number | null) {
+  const [liquidationPrice, setLiquidationPrice] = useState<number | null>(null)
+  const [isUpdatingLiquidationPrice, setIsUpdatingLiquidationPrice] = useState(false)
+  const debouncedSetLiqPrice = useMemo(
+    () => debounce(setLiquidationPrice, 1000, { leading: false }),
+    [],
+  )
+
+  useEffect(() => {
+    setIsUpdatingLiquidationPrice(true)
+    debouncedSetLiqPrice(liqPrice)
+  }, [debouncedSetLiqPrice, liqPrice])
+
+  useEffect(() => {
+    setIsUpdatingLiquidationPrice(false)
+  }, [liquidationPrice])
+
+  return { liquidationPrice, isUpdatingLiquidationPrice }
+}

src/utils/health_computer/index.d.ts

@@ -40,9 +40,14 @@ export function max_swap_estimate_js(
 /**
  * @param {HealthComputer} c
  * @param {string} denom
+ * @param {LiquidationPriceKind} kind
  * @returns {string}
  */
-export function liquidation_price_js(c: HealthComputer, denom: string): string
+export function liquidation_price_js(
+  c: HealthComputer,
+  denom: string,
+  kind: LiquidationPriceKind,
+): string
 export interface HealthComputer {
   kind: AccountKind
   positions: Positions
@@ -61,6 +66,8 @@ export interface HealthValuesResponse {
   above_max_ltv: boolean
 }
 
+export type LiquidationPriceKind = 'asset' | 'debt'
+
 export type Slippage = Decimal
 
 export type SwapKind = 'default' | 'margin'
@@ -88,7 +95,7 @@ export interface InitOutput {
     g: number,
     h: number,
   ) => void
-  readonly liquidation_price_js: (a: number, b: number, c: number, d: number) => void
+  readonly liquidation_price_js: (a: number, b: number, c: number, d: number, e: number) => void
   readonly allocate: (a: number) => number
   readonly deallocate: (a: number) => void
   readonly requires_iterator: () => void

src/utils/health_computer/index.js

@@ -1,389 +1,355 @@
-let wasm
+let wasm;
 
-const heap = new Array(128).fill(undefined)
+const heap = new Array(128).fill(undefined);
 
-heap.push(undefined, null, true, false)
+heap.push(undefined, null, true, false);
 
-function getObject(idx) {
-  return heap[idx]
-}
+function getObject(idx) { return heap[idx]; }
 
-let heap_next = heap.length
+let heap_next = heap.length;
 
 function addHeapObject(obj) {
-  if (heap_next === heap.length) heap.push(heap.length + 1)
-  const idx = heap_next
-  heap_next = heap[idx]
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
 
-  heap[idx] = obj
-  return idx
+    heap[idx] = obj;
+    return idx;
 }
 
 function dropObject(idx) {
-  if (idx < 132) return
-  heap[idx] = heap_next
-  heap_next = idx
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
 }
 
 function takeObject(idx) {
-  const ret = getObject(idx)
-  dropObject(idx)
-  return ret
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
 }
 
-let WASM_VECTOR_LEN = 0
+let WASM_VECTOR_LEN = 0;
 
-let cachedUint8Memory0 = null
+let cachedUint8Memory0 = null;
 
 function getUint8Memory0() {
-  if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
-    cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer)
-  }
-  return cachedUint8Memory0
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
 }
 
-const cachedTextEncoder =
-  typeof TextEncoder !== 'undefined'
-    ? new TextEncoder('utf-8')
-    : {
-        encode: () => {
-          throw Error('TextEncoder not available')
-        },
-      }
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
 
-const encodeString =
-  typeof cachedTextEncoder.encodeInto === 'function'
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
     ? function (arg, view) {
-        return cachedTextEncoder.encodeInto(arg, view)
-      }
+    return cachedTextEncoder.encodeInto(arg, view);
+}
     : function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg)
-        view.set(buf)
-        return {
-          read: arg.length,
-          written: buf.length,
-        }
-      }
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
 
 function passStringToWasm0(arg, malloc, realloc) {
-  if (realloc === undefined) {
-    const buf = cachedTextEncoder.encode(arg)
-    const ptr = malloc(buf.length, 1) >>> 0
-    getUint8Memory0()
-      .subarray(ptr, ptr + buf.length)
-      .set(buf)
-    WASM_VECTOR_LEN = buf.length
-    return ptr
-  }
 
-  let len = arg.length
-  let ptr = malloc(len, 1) >>> 0
-
-  const mem = getUint8Memory0()
-
-  let offset = 0
-
-  for (; offset < len; offset++) {
-    const code = arg.charCodeAt(offset)
-    if (code > 0x7f) break
-    mem[ptr + offset] = code
-  }
-
-  if (offset !== len) {
-    if (offset !== 0) {
-      arg = arg.slice(offset)
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
     }
-    ptr = realloc(ptr, len, (len = offset + arg.length * 3), 1) >>> 0
-    const view = getUint8Memory0().subarray(ptr + offset, ptr + len)
-    const ret = encodeString(arg, view)
 
-    offset += ret.written
-  }
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
 
-  WASM_VECTOR_LEN = offset
-  return ptr
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
 }
 
 function isLikeNone(x) {
-  return x === undefined || x === null
+    return x === undefined || x === null;
 }
 
-let cachedInt32Memory0 = null
+let cachedInt32Memory0 = null;
 
 function getInt32Memory0() {
-  if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
-    cachedInt32Memory0 = new Int32Array(wasm.memory.buffer)
-  }
-  return cachedInt32Memory0
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
 }
 
-const cachedTextDecoder =
-  typeof TextDecoder !== 'undefined'
-    ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true })
-    : {
-        decode: () => {
-          throw Error('TextDecoder not available')
-        },
-      }
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
 
-if (typeof TextDecoder !== 'undefined') {
-  cachedTextDecoder.decode()
-}
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
 
 function getStringFromWasm0(ptr, len) {
-  ptr = ptr >>> 0
-  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len))
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
 }
 /**
- * @param {HealthComputer} c
- * @returns {HealthValuesResponse}
- */
+* @param {HealthComputer} c
+* @returns {HealthValuesResponse}
+*/
 export function compute_health_js(c) {
-  const ret = wasm.compute_health_js(addHeapObject(c))
-  return takeObject(ret)
+    const ret = wasm.compute_health_js(addHeapObject(c));
+    return takeObject(ret);
 }
 
 /**
- * @param {HealthComputer} c
- * @param {string} withdraw_denom
- * @returns {string}
- */
+* @param {HealthComputer} c
+* @param {string} withdraw_denom
+* @returns {string}
+*/
 export function max_withdraw_estimate_js(c, withdraw_denom) {
-  let deferred2_0
-  let deferred2_1
-  try {
-    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16)
-    const ptr0 = passStringToWasm0(withdraw_denom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc)
-    const len0 = WASM_VECTOR_LEN
-    wasm.max_withdraw_estimate_js(retptr, addHeapObject(c), ptr0, len0)
-    var r0 = getInt32Memory0()[retptr / 4 + 0]
-    var r1 = getInt32Memory0()[retptr / 4 + 1]
-    deferred2_0 = r0
-    deferred2_1 = r1
-    return getStringFromWasm0(r0, r1)
-  } finally {
-    wasm.__wbindgen_add_to_stack_pointer(16)
-    wasm.__wbindgen_free(deferred2_0, deferred2_1, 1)
-  }
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(withdraw_denom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.max_withdraw_estimate_js(retptr, addHeapObject(c), ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
 }
 
 /**
- * @param {HealthComputer} c
- * @param {string} borrow_denom
- * @param {BorrowTarget} target
- * @returns {string}
- */
+* @param {HealthComputer} c
+* @param {string} borrow_denom
+* @param {BorrowTarget} target
+* @returns {string}
+*/
 export function max_borrow_estimate_js(c, borrow_denom, target) {
-  let deferred2_0
-  let deferred2_1
-  try {
-    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16)
-    const ptr0 = passStringToWasm0(borrow_denom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc)
-    const len0 = WASM_VECTOR_LEN
-    wasm.max_borrow_estimate_js(retptr, addHeapObject(c), ptr0, len0, addHeapObject(target))
-    var r0 = getInt32Memory0()[retptr / 4 + 0]
-    var r1 = getInt32Memory0()[retptr / 4 + 1]
-    deferred2_0 = r0
-    deferred2_1 = r1
-    return getStringFromWasm0(r0, r1)
-  } finally {
-    wasm.__wbindgen_add_to_stack_pointer(16)
-    wasm.__wbindgen_free(deferred2_0, deferred2_1, 1)
-  }
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(borrow_denom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.max_borrow_estimate_js(retptr, addHeapObject(c), ptr0, len0, addHeapObject(target));
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
 }
 
 /**
- * @param {HealthComputer} c
- * @param {string} from_denom
- * @param {string} to_denom
- * @param {SwapKind} kind
- * @param {Slippage} slippage
- * @returns {string}
- */
+* @param {HealthComputer} c
+* @param {string} from_denom
+* @param {string} to_denom
+* @param {SwapKind} kind
+* @param {Slippage} slippage
+* @returns {string}
+*/
 export function max_swap_estimate_js(c, from_denom, to_denom, kind, slippage) {
-  let deferred3_0
-  let deferred3_1
-  try {
-    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16)
-    const ptr0 = passStringToWasm0(from_denom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc)
-    const len0 = WASM_VECTOR_LEN
-    const ptr1 = passStringToWasm0(to_denom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc)
-    const len1 = WASM_VECTOR_LEN
-    wasm.max_swap_estimate_js(
-      retptr,
-      addHeapObject(c),
-      ptr0,
-      len0,
-      ptr1,
-      len1,
-      addHeapObject(kind),
-      addHeapObject(slippage),
-    )
-    var r0 = getInt32Memory0()[retptr / 4 + 0]
-    var r1 = getInt32Memory0()[retptr / 4 + 1]
-    deferred3_0 = r0
-    deferred3_1 = r1
-    return getStringFromWasm0(r0, r1)
-  } finally {
-    wasm.__wbindgen_add_to_stack_pointer(16)
-    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1)
-  }
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(from_denom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(to_denom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.max_swap_estimate_js(retptr, addHeapObject(c), ptr0, len0, ptr1, len1, addHeapObject(kind), addHeapObject(slippage));
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred3_0 = r0;
+        deferred3_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
 }
 
 /**
- * @param {HealthComputer} c
- * @param {string} denom
- * @returns {string}
- */
-export function liquidation_price_js(c, denom) {
-  let deferred2_0
-  let deferred2_1
-  try {
-    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16)
-    const ptr0 = passStringToWasm0(denom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc)
-    const len0 = WASM_VECTOR_LEN
-    wasm.liquidation_price_js(retptr, addHeapObject(c), ptr0, len0)
-    var r0 = getInt32Memory0()[retptr / 4 + 0]
-    var r1 = getInt32Memory0()[retptr / 4 + 1]
-    deferred2_0 = r0
-    deferred2_1 = r1
-    return getStringFromWasm0(r0, r1)
-  } finally {
-    wasm.__wbindgen_add_to_stack_pointer(16)
-    wasm.__wbindgen_free(deferred2_0, deferred2_1, 1)
-  }
+* @param {HealthComputer} c
+* @param {string} denom
+* @param {LiquidationPriceKind} kind
+* @returns {string}
+*/
+export function liquidation_price_js(c, denom, kind) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(denom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.liquidation_price_js(retptr, addHeapObject(c), ptr0, len0, addHeapObject(kind));
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
 }
 
 function handleError(f, args) {
-  try {
-    return f.apply(this, args)
-  } catch (e) {
-    wasm.__wbindgen_exn_store(addHeapObject(e))
-  }
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
 }
 
 async function __wbg_load(module, imports) {
-  if (typeof Response === 'function' && module instanceof Response) {
-    if (typeof WebAssembly.instantiateStreaming === 'function') {
-      try {
-        return await WebAssembly.instantiateStreaming(module, imports)
-      } catch (e) {
-        if (module.headers.get('Content-Type') != 'application/wasm') {
-          console.warn(
-            '`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n',
-            e,
-          )
-        } else {
-          throw e
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
         }
-      }
-    }
 
-    const bytes = await module.arrayBuffer()
-    return await WebAssembly.instantiate(bytes, imports)
-  } else {
-    const instance = await WebAssembly.instantiate(module, imports)
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
 
-    if (instance instanceof WebAssembly.Instance) {
-      return { instance, module }
     } else {
-      return instance
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
     }
-  }
 }
 
 function __wbg_get_imports() {
-  const imports = {}
-  imports.wbg = {}
-  imports.wbg.__wbindgen_object_clone_ref = function (arg0) {
-    const ret = getObject(arg0)
-    return addHeapObject(ret)
-  }
-  imports.wbg.__wbindgen_is_undefined = function (arg0) {
-    const ret = getObject(arg0) === undefined
-    return ret
-  }
-  imports.wbg.__wbindgen_object_drop_ref = function (arg0) {
-    takeObject(arg0)
-  }
-  imports.wbg.__wbindgen_string_get = function (arg0, arg1) {
-    const obj = getObject(arg1)
-    const ret = typeof obj === 'string' ? obj : undefined
-    var ptr1 = isLikeNone(ret)
-      ? 0
-      : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc)
-    var len1 = WASM_VECTOR_LEN
-    getInt32Memory0()[arg0 / 4 + 1] = len1
-    getInt32Memory0()[arg0 / 4 + 0] = ptr1
-  }
-  imports.wbg.__wbg_parse_670c19d4e984792e = function () {
-    return handleError(function (arg0, arg1) {
-      const ret = JSON.parse(getStringFromWasm0(arg0, arg1))
-      return addHeapObject(ret)
-    }, arguments)
-  }
-  imports.wbg.__wbg_stringify_e25465938f3f611f = function () {
-    return handleError(function (arg0) {
-      const ret = JSON.stringify(getObject(arg0))
-      return addHeapObject(ret)
-    }, arguments)
-  }
-  imports.wbg.__wbindgen_throw = function (arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1))
-  }
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = getObject(arg0) === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
+    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+    };
+    imports.wbg.__wbg_parse_670c19d4e984792e = function() { return handleError(function (arg0, arg1) {
+        const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_stringify_e25465938f3f611f = function() { return handleError(function (arg0) {
+        const ret = JSON.stringify(getObject(arg0));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
 
-  return imports
+    return imports;
 }
 
-function __wbg_init_memory(imports, maybe_memory) {}
+function __wbg_init_memory(imports, maybe_memory) {
+
+}
 
 function __wbg_finalize_init(instance, module) {
-  wasm = instance.exports
-  __wbg_init.__wbindgen_wasm_module = module
-  cachedInt32Memory0 = null
-  cachedUint8Memory0 = null
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedInt32Memory0 = null;
+    cachedUint8Memory0 = null;
 
-  return wasm
+
+    return wasm;
 }
 
 function initSync(module) {
-  if (wasm !== undefined) return wasm
+    if (wasm !== undefined) return wasm;
 
-  const imports = __wbg_get_imports()
+    const imports = __wbg_get_imports();
 
-  __wbg_init_memory(imports)
+    __wbg_init_memory(imports);
 
-  if (!(module instanceof WebAssembly.Module)) {
-    module = new WebAssembly.Module(module)
-  }
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
 
-  const instance = new WebAssembly.Instance(module, imports)
+    const instance = new WebAssembly.Instance(module, imports);
 
-  return __wbg_finalize_init(instance, module)
+    return __wbg_finalize_init(instance, module);
 }
 
 async function __wbg_init(input) {
-  if (wasm !== undefined) return wasm
+    if (wasm !== undefined) return wasm;
 
-  if (typeof input === 'undefined') {
-    input = new URL('index_bg.wasm', import.meta.url)
-  }
-  const imports = __wbg_get_imports()
+    if (typeof input === 'undefined') {
+        input = new URL('index_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
 
-  if (
-    typeof input === 'string' ||
-    (typeof Request === 'function' && input instanceof Request) ||
-    (typeof URL === 'function' && input instanceof URL)
-  ) {
-    input = fetch(input)
-  }
+    if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
+        input = fetch(input);
+    }
 
-  __wbg_init_memory(imports)
+    __wbg_init_memory(imports);
 
-  const { instance, module } = await __wbg_load(await input, imports)
+    const { instance, module } = await __wbg_load(await input, imports);
 
-  return __wbg_finalize_init(instance, module)
+    return __wbg_finalize_init(instance, module);
 }
 
 export { initSync }
-export default __wbg_init
+export default __wbg_init;

src/utils/health_computer/index_bg.wasm.d.ts

@@ -14,7 +14,7 @@ export function max_swap_estimate_js(
   g: number,
   h: number,
 ): void
-export function liquidation_price_js(a: number, b: number, c: number, d: number): void
+export function liquidation_price_js(a: number, b: number, c: number, d: number, e: number): void
 export function allocate(a: number): number
 export function deallocate(a: number): void
 export function requires_iterator(): void

src/utils/messages.ts

@@ -1,4 +1,4 @@
-import { formatAmountWithSymbol } from './formatters'
+import { formatAmountWithSymbol } from 'utils/formatters'
 
 export function getNoBalanceMessage(symbol: string) {
   return `You don't have an ${symbol} balance in your account.`