@huma-finance/widgets 0.0.51-beta.225 → 0.0.51-beta.346

package/src/components/Lend/supplyV2/index.tsx

@@ -0,0 +1,175 @@
+import {
+  POOL_NAME,
+  TrancheType,
+  openInNewTab,
+  useLenderApprovedV2,
+  usePoolInfoV2,
+  usePoolUnderlyingTokenInfoV2,
+} from '@huma-finance/shared'
+import { useWeb3React } from '@web3-react/core'
+import React, { useEffect, useState } from 'react'
+import { useDispatch } from 'react-redux'
+
+import { useAppSelector } from '../../../hooks/useRedux'
+import { setStep } from '../../../store/widgets.reducers'
+import { selectWidgetState } from '../../../store/widgets.selectors'
+import { WIDGET_STEP } from '../../../store/widgets.store'
+import { ErrorModal } from '../../ErrorModal'
+import { WidgetWrapper } from '../../WidgetWrapper'
+import { ChooseTranche } from './1-ChooseTranche'
+import { Evaluation } from './2-Evaluation'
+import { ChooseAmount } from './3-ChooseAmount'
+import { ApproveAllowance } from './4-ApproveAllowance'
+import { Transfer } from './5-Transfer'
+import { Success } from './6-Success'
+import { Notifications } from './7-Notifications'
+
+/**
+ * Lend pool supply props
+ * @typedef {Object} LendSupplyPropsV2
+ * @property {POOL_NAME} poolName The name of the pool.
+ * @property {function():void} handleClose Function to notify to close the widget modal when user clicks the 'x' close button.
+ * @property {function((number|undefined)):void|undefined} handleSuccess Optional function to notify that the lending pool supply action is successful.
+ */
+export interface LendSupplyPropsV2 {
+  poolName: keyof typeof POOL_NAME
+  handleClose: () => void
+  handleSuccess?: (blockNumber?: number) => void
+}
+
+export function LendSupplyV2({
+  poolName: poolNameStr,
+  handleClose,
+  handleSuccess,
+}: LendSupplyPropsV2): React.ReactElement | null {
+  const dispatch = useDispatch()
+  const poolName = POOL_NAME[poolNameStr]
+  const { chainId, provider, account } = useWeb3React()
+  const poolInfo = usePoolInfoV2(poolName, chainId)
+  const { step, errorMessage } = useAppSelector(selectWidgetState)
+  const [selectedTranche, setSelectedTranche] = useState<TrancheType>()
+  const poolUnderlyingToken = usePoolUnderlyingTokenInfoV2(poolName, provider)
+
+  const [lenderApprovedSenior] = useLenderApprovedV2(
+    poolName,
+    'senior',
+    account,
+    provider,
+  )
+  const [lenderApprovedJunior] = useLenderApprovedV2(
+    poolName,
+    'junior',
+    account,
+    provider,
+  )
+
+  const lenderApproveStatusFetched =
+    lenderApprovedSenior !== undefined && lenderApprovedJunior !== undefined
+
+  useEffect(() => {
+    if (!step && poolInfo && lenderApproveStatusFetched) {
+      if (lenderApprovedJunior && !lenderApprovedSenior) {
+        setSelectedTranche('junior')
+        dispatch(setStep(WIDGET_STEP.ChooseAmount))
+        return
+      }
+
+      if (lenderApprovedSenior && !lenderApprovedJunior) {
+        setSelectedTranche('senior')
+        dispatch(setStep(WIDGET_STEP.ChooseAmount))
+        return
+      }
+
+      if (lenderApprovedJunior && lenderApprovedSenior) {
+        dispatch(setStep(WIDGET_STEP.ChooseTranche))
+        return
+      }
+
+      if (poolInfo.KYC) {
+        dispatch(setStep(WIDGET_STEP.Evaluation))
+        return
+      }
+
+      if (poolInfo.supplyLink) {
+        openInNewTab(poolInfo.supplyLink)
+      }
+    }
+  }, [
+    dispatch,
+    lenderApproveStatusFetched,
+    lenderApprovedJunior,
+    lenderApprovedSenior,
+    poolInfo,
+    step,
+  ])
+
+  if (!poolInfo || !poolUnderlyingToken || !lenderApproveStatusFetched) {
+    return (
+      <WidgetWrapper
+        isOpen
+        isLoading
+        loadingTitle='Supply'
+        handleClose={handleClose}
+        handleSuccess={handleSuccess}
+      />
+    )
+  }
+
+  return (
+    <WidgetWrapper
+      isOpen
+      loadingTitle={`Supply ${poolUnderlyingToken.symbol}`}
+      handleClose={handleClose}
+      handleSuccess={handleSuccess}
+    >
+      {step === WIDGET_STEP.ChooseTranche && (
+        <ChooseTranche
+          poolUnderlyingToken={poolUnderlyingToken}
+          selectedTranche={selectedTranche}
+          changeTranche={setSelectedTranche}
+        />
+      )}
+      {step === WIDGET_STEP.Evaluation && (
+        <Evaluation poolInfo={poolInfo} handleClose={handleClose} />
+      )}
+      {step === WIDGET_STEP.ChooseAmount && (
+        <ChooseAmount
+          poolInfo={poolInfo}
+          poolUnderlyingToken={poolUnderlyingToken}
+          selectedTranche={selectedTranche}
+        />
+      )}
+      {step === WIDGET_STEP.ApproveAllowance && (
+        <ApproveAllowance
+          poolInfo={poolInfo}
+          poolUnderlyingToken={poolUnderlyingToken}
+        />
+      )}
+      {step === WIDGET_STEP.Transfer && selectedTranche && (
+        <Transfer
+          poolInfo={poolInfo}
+          poolUnderlyingToken={poolUnderlyingToken}
+          trancheType={selectedTranche}
+        />
+      )}
+      {step === WIDGET_STEP.Done && (
+        <Success
+          poolInfo={poolInfo}
+          poolUnderlyingToken={poolUnderlyingToken}
+          handleAction={handleClose}
+        />
+      )}
+      {step === WIDGET_STEP.Notifications && (
+        <Notifications handleAction={handleClose} />
+      )}
+      {step === WIDGET_STEP.Error && (
+        <ErrorModal
+          title='Supply'
+          errorReason='Sorry there was an error'
+          errorMessage={errorMessage}
+          handleOk={handleClose}
+        />
+      )}
+    </WidgetWrapper>
+  )
+}

package/src/components/Lend/withdraw/1-CheckWithdrawble.tsx

@@ -23,15 +23,19 @@ export function CheckWithdrawable({
   handleClose,
 }: Props): React.ReactElement | null {
   const dispatch = useAppDispatch()
-  const { account } = useWeb3React()
+  const { account, chainId, provider } = useWeb3React()
   const withdrawlLockoutSeconds = useWithdrawlLockoutInSeconds(
     poolInfo.poolName,
     poolInfo.poolType,
+    chainId,
+    provider,
   )
   const lastDepositTime = useLastDepositTime(
     poolInfo.poolName,
     poolInfo.poolType,
+    chainId,
     account,
+    provider,
   )
 
   const { symbol } = poolInfo.poolUnderlyingToken

package/src/components/Lend/withdraw/index.tsx

@@ -42,17 +42,24 @@ export function LendWithdraw({
   handleSuccess,
 }: LendWithdrawProps): React.ReactElement | null {
   const dispatch = useDispatch()
-  const { account } = useWeb3React()
+  const { account, chainId, provider } = useWeb3React()
   const poolName = POOL_NAME[poolNameStr]
   const poolType = POOL_TYPE[poolTypeStr]
-  const poolInfo = usePoolInfo(poolName, poolType)
+  const poolInfo = usePoolInfo(poolName, poolType, chainId)
   const { step, errorMessage } = useAppSelector(selectWidgetState)
   const [lenderPosition, refreshLenderPosition] = useLenderPosition(
     poolName,
     poolType,
+    chainId,
     account,
+    provider,
+  )
+  const [poolBalance, refreshPoolBalance] = usePoolBalance(
+    poolName,
+    poolType,
+    chainId,
+    provider,
   )
-  const [poolBalance, refreshPoolBalance] = usePoolBalance(poolName, poolType)
 
   useEffect(() => {
     if (!step && lenderPosition && poolBalance) {

package/src/components/Lend/withdrawV2/1-ConfirmTransfer.tsx

@@ -0,0 +1,135 @@
+import {
+  PoolInfoV2,
+  TrancheRedemptionStatus,
+  TrancheType,
+  UnderlyingTokenInfo,
+  formatAmount,
+  getTrancheVaultContractV2,
+} from '@huma-finance/shared'
+import { Box, Divider, css, useTheme } from '@mui/material'
+import React, { useEffect, useState } from 'react'
+import { useDispatch } from 'react-redux'
+
+import { useWeb3React } from '@web3-react/core'
+import { setStep } from '../../../store/widgets.reducers'
+import { WIDGET_STEP } from '../../../store/widgets.store'
+import { BottomButton } from '../../BottomButton'
+import { WrapperModal } from '../../WrapperModal'
+
+type Props = {
+  poolInfo: PoolInfoV2
+  tranche: TrancheType
+  poolUnderlyingToken: UnderlyingTokenInfo
+  redemptionStatus: TrancheRedemptionStatus
+  poolIsClosed: boolean
+}
+
+export function ConfirmTransfer({
+  poolInfo,
+  tranche,
+  poolUnderlyingToken,
+  redemptionStatus,
+  poolIsClosed,
+}: Props): React.ReactElement {
+  const theme = useTheme()
+  const dispatch = useDispatch()
+  const { provider } = useWeb3React()
+  const { symbol, decimals } = poolUnderlyingToken
+  const { lenderRedemptionRecords, cancellableRedemptionShares } =
+    redemptionStatus
+  const { numSharesRequested } = lenderRedemptionRecords
+  const sharesProcessed = formatAmount(
+    numSharesRequested.sub(cancellableRedemptionShares),
+    decimals,
+  )
+  const withdrawableAmount = formatAmount(
+    redemptionStatus.withdrawableAssets,
+    decimals,
+  )
+  const [sharePrice, setSharePrice] = useState(0)
+
+  useEffect(() => {
+    const fetchData = async () => {
+      const vaultContract = await getTrancheVaultContractV2(
+        poolInfo.poolName,
+        tranche,
+        provider,
+      )
+      if (vaultContract) {
+        const shares = await vaultContract.convertToShares(
+          redemptionStatus.withdrawableAssets,
+        )
+        setSharePrice(
+          redemptionStatus.withdrawableAssets.toNumber() / shares.toNumber(),
+        )
+      }
+    }
+    fetchData()
+  }, [
+    poolInfo.poolName,
+    provider,
+    redemptionStatus.withdrawableAssets,
+    tranche,
+  ])
+
+  const goToWithdraw = () => {
+    dispatch(setStep(WIDGET_STEP.Transfer))
+  }
+
+  const styles = {
+    itemWrapper: css`
+      margin-top: ${theme.spacing(9)};
+      color: ${theme.palette.text.primary};
+      font-family: 'Uni-Neue-Regular';
+      font-size: 16px;
+      line-height: 175%;
+      letter-spacing: 0.15px;
+    `,
+    item: css`
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      margin-bottom: ${theme.spacing(3)};
+    `,
+    itemValue: css`
+      font-size: 20px;
+      font-family: 'Uni-Neue-Bold';
+    `,
+    divider: css`
+      border-color: #eae6f0;
+      margin-bottom: ${theme.spacing(3)};
+    `,
+  }
+
+  return (
+    <WrapperModal
+      title={`Withdraw ${symbol}`}
+      subTitle='Withdraw all the available amount'
+    >
+      <Box css={styles.itemWrapper}>
+        {!poolIsClosed && (
+          <Box css={styles.item}>
+            <Box>Shares processed</Box>
+            <Box css={styles.itemValue}>{sharesProcessed}</Box>
+          </Box>
+        )}
+        <Box css={styles.item}>
+          <Box>Price Per Share</Box>
+          <Box css={styles.itemValue}>
+            {sharePrice.toFixed(1)} {symbol}
+          </Box>
+        </Box>
+        <Divider css={styles.divider} orientation='horizontal' />
+        <Box css={styles.item}>
+          <Box fontWeight={700}>Available to withdraw</Box>
+          <Box css={styles.itemValue}>
+            {withdrawableAmount} {symbol}
+          </Box>
+        </Box>
+      </Box>
+      <BottomButton variant='contained' onClick={goToWithdraw}>
+        WITHDRAW
+      </BottomButton>
+    </WrapperModal>
+  )
+}

package/src/components/Lend/withdrawV2/2-Transfer.tsx

@@ -0,0 +1,50 @@
+import {
+  PoolInfoV2,
+  TrancheType,
+  useTrancheVaultContractV2,
+} from '@huma-finance/shared'
+import { useWeb3React } from '@web3-react/core'
+import React, { useCallback } from 'react'
+
+import { useAppDispatch } from '../../../hooks/useRedux'
+import { setStep } from '../../../store/widgets.reducers'
+import { WIDGET_STEP } from '../../../store/widgets.store'
+import { TxSendModalV2 } from '../../TxSendModalV2'
+
+type Props = {
+  poolInfo: PoolInfoV2
+  tranche: TrancheType
+  poolIsClosed: boolean
+}
+
+export function Transfer({
+  poolInfo,
+  tranche,
+  poolIsClosed,
+}: Props): React.ReactElement | null {
+  const dispatch = useAppDispatch()
+  const { account, provider } = useWeb3React()
+  const trancheVaultContract = useTrancheVaultContractV2(
+    poolInfo.poolName,
+    tranche,
+    provider,
+    account,
+  )
+
+  const handleSuccess = useCallback(() => {
+    dispatch(setStep(WIDGET_STEP.Done))
+  }, [dispatch])
+
+  if (!trancheVaultContract || !account) {
+    return null
+  }
+
+  return (
+    <TxSendModalV2
+      contract={trancheVaultContract}
+      method={poolIsClosed ? 'withdrawAfterPoolClosure' : 'disburse'}
+      params={[]}
+      handleSuccess={handleSuccess}
+    />
+  )
+}

package/src/components/Lend/withdrawV2/3-Done.tsx

@@ -0,0 +1,31 @@
+import { formatMoney, UnderlyingTokenInfo } from '@huma-finance/shared'
+import { BigNumber, ethers } from 'ethers'
+import React from 'react'
+
+import { TxDoneModal } from '../../TxDoneModal'
+
+type Props = {
+  poolUnderlyingToken: UnderlyingTokenInfo
+  withdrawAmount: BigNumber
+  handleAction: () => void
+}
+
+export function Done({
+  poolUnderlyingToken,
+  withdrawAmount,
+  handleAction,
+}: Props): React.ReactElement {
+  const { symbol } = poolUnderlyingToken
+  const withdrawAmountFormatted = ethers.utils.formatUnits(
+    withdrawAmount,
+    poolUnderlyingToken.decimals,
+  )
+
+  const content = [
+    `You successfully withdrew ${formatMoney(
+      withdrawAmountFormatted,
+    )} ${symbol}.`,
+  ]
+
+  return <TxDoneModal handleAction={handleAction} content={content} />
+}

package/src/components/Lend/withdrawV2/index.tsx

@@ -0,0 +1,177 @@
+import {
+  getPoolContractV2,
+  getTrancheRedemptionStatusV2,
+  POOL_NAME,
+  TrancheRedemptionStatus,
+  TrancheType,
+  usePoolInfoV2,
+  usePoolUnderlyingTokenInfoV2,
+} from '@huma-finance/shared'
+import { useWeb3React } from '@web3-react/core'
+import React, { useCallback, useEffect, useState } from 'react'
+import { useDispatch } from 'react-redux'
+
+import { useAppSelector } from '../../../hooks/useRedux'
+import { setStep } from '../../../store/widgets.reducers'
+import { selectWidgetState } from '../../../store/widgets.selectors'
+import { WIDGET_STEP } from '../../../store/widgets.store'
+import { ErrorModal } from '../../ErrorModal'
+import { WidgetWrapper } from '../../WidgetWrapper'
+import { ConfirmTransfer } from './1-ConfirmTransfer'
+import { Transfer } from './2-Transfer'
+import { Done } from './3-Done'
+
+/**
+ * Lend pool withdraw props
+ * @typedef {Object} LendWithdrawPropsV2
+ * @property {POOL_NAME} poolName The name of the pool.
+ * @property {TrancheType} trancheType The type of the tranche.
+ * @property {function():void} handleClose Function to notify to close the widget modal when user clicks the 'x' close button.
+ * @property {function((number|undefined)):void|undefined} handleSuccess Optional function to notify that the lending pool withdraw action is successful.
+ */
+export type LendWithdrawPropsV2 = {
+  poolName: keyof typeof POOL_NAME
+  trancheType: TrancheType
+  handleClose: () => void
+  handleSuccess?: (blockNumber?: number) => void
+}
+
+export function LendWithdrawV2({
+  poolName: poolNameStr,
+  trancheType,
+  handleClose,
+  handleSuccess,
+}: LendWithdrawPropsV2): React.ReactElement | null {
+  const dispatch = useDispatch()
+  const { account, chainId, provider } = useWeb3React()
+  const poolName = POOL_NAME[poolNameStr]
+  const poolInfo = usePoolInfoV2(poolName, chainId)
+  const { step, errorMessage } = useAppSelector(selectWidgetState)
+  const poolUnderlyingToken = usePoolUnderlyingTokenInfoV2(poolName, provider)
+  const title = poolUnderlyingToken
+    ? `Withdraw ${poolUnderlyingToken.symbol}`
+    : 'Withdraw'
+
+  const [redemptionStatus, setRedemptionStatus] = React.useState<
+    TrancheRedemptionStatus | undefined
+  >()
+  const [poolIsClosed, setPoolIsClosed] = useState<boolean | undefined>(
+    undefined,
+  )
+
+  useEffect(() => {
+    const fetchData = async () => {
+      if (account && provider) {
+        const result = await getTrancheRedemptionStatusV2(
+          poolName,
+          trancheType,
+          account,
+          provider,
+        )
+        setRedemptionStatus(result)
+      }
+    }
+    fetchData()
+  }, [account, poolName, provider, trancheType])
+
+  useEffect(() => {
+    const fetchData = async () => {
+      if (account && provider) {
+        const result = await getTrancheRedemptionStatusV2(
+          poolName,
+          trancheType,
+          account,
+          provider,
+        )
+        setRedemptionStatus(result)
+      }
+    }
+    fetchData()
+  }, [account, poolName, provider, trancheType])
+
+  useEffect(() => {
+    const fetchData = async () => {
+      if (account && provider) {
+        const poolContract = await getPoolContractV2(poolName, provider)
+        if (poolContract) {
+          const poolIsClosed = await poolContract.isPoolClosed()
+          setPoolIsClosed(poolIsClosed)
+        }
+      }
+    }
+    fetchData()
+  }, [account, poolName, provider])
+
+  useEffect(() => {
+    if (!step) {
+      dispatch(setStep(WIDGET_STEP.ConfirmTransfer))
+    }
+  }, [dispatch, step])
+
+  const handleWithdrawSuccess = useCallback(
+    (blockNumber: number) => {
+      if (handleSuccess) {
+        handleSuccess(blockNumber)
+      }
+    },
+    [handleSuccess],
+  )
+
+  if (
+    !poolInfo ||
+    !poolUnderlyingToken ||
+    !redemptionStatus ||
+    poolIsClosed === undefined
+  ) {
+    return (
+      <WidgetWrapper
+        isOpen
+        isLoading
+        loadingTitle={title}
+        handleClose={handleClose}
+        handleSuccess={handleSuccess}
+      />
+    )
+  }
+
+  return (
+    <WidgetWrapper
+      isOpen
+      loadingTitle={title}
+      handleClose={handleClose}
+      handleSuccess={handleWithdrawSuccess}
+    >
+      {step === WIDGET_STEP.ConfirmTransfer && (
+        <ConfirmTransfer
+          poolInfo={poolInfo}
+          tranche={trancheType}
+          redemptionStatus={redemptionStatus}
+          poolUnderlyingToken={poolUnderlyingToken}
+          poolIsClosed={poolIsClosed}
+        />
+      )}
+      {step === WIDGET_STEP.Transfer && (
+        <Transfer
+          poolInfo={poolInfo}
+          tranche={trancheType}
+          poolIsClosed={poolIsClosed}
+        />
+      )}
+      {step === WIDGET_STEP.Done && (
+        <Done
+          poolUnderlyingToken={poolUnderlyingToken}
+          withdrawAmount={redemptionStatus.withdrawableAssets}
+          handleAction={handleClose}
+        />
+      )}
+      {step === WIDGET_STEP.Error && (
+        <ErrorModal
+          title={title}
+          errorReason='Sorry there was an error'
+          errorMessage={errorMessage}
+          handleOk={handleClose}
+        />
+      )}
+    </WidgetWrapper>
+  )
+}