Add TACo commitment checks and alerts when topping up or de-authing

src/components/Modal/TopupTModal/TopUpTModal.tsx

@@ -61,6 +61,9 @@ const TopupTModal: FC<
             <BodyLg>
               If you want to put your new topped-up tokens at work, make sure to
               increase the authorization to your applications.
+              <br />
+              If you increase the Authorization to TACo, the new tokens will be
+              subject to the same lock-up period as your current stake.
             </BodyLg>
           </InfoBox>
           <StakingStats

src/pages/Staking/AuthorizeStakingApps/AuthorizeApplicationsCardCheckbox/index.tsx

@@ -35,6 +35,7 @@ import { formatDate } from "../../../../utils/date"
 import { calculatePercenteage } from "../../../../utils/percentage"
 import { StakingAppForm } from "../../../../components/StakingApplicationForms"
 import { AuthorizationStatus } from "../../../../types"
+import { StakingProviderInfo } from "../../../../threshold-ts/applications"
 
 interface CommonProps {
   stakingAppId: StakingAppName
@@ -58,6 +59,7 @@ type StakingAppAuthDataBaseProps = {
   remainingAuthorizationDecreaseDelay: string
   isOperatorInPool: boolean | undefined
   operator: string
+  stakingProviderInfo?: StakingProviderInfo | undefined
 }
 
 type AppAuthDataConditionalProps =
@@ -255,8 +257,26 @@ export const AuthorizeApplicationsCardCheckboxBase: FC<
   }
 
   const onSubmitForm = (tokenAmount: string) => {
-    if (isIncreaseAction) onAuthorizeApp(tokenAmount)
-    else onInitiateDeauthorization(tokenAmount)
+    if (isIncreaseAction) {
+      onAuthorizeApp(tokenAmount)
+    } else {
+      if (appAuthData.stakingAppId === "taco") {
+        // const endCommitment = appAuthData.stakingProviderInfo?.endCommitment
+        const endCommitment = appAuthData.stakingProviderInfo?.endCommitment
+        const currentTime = Math.floor(Date.now() / 1000)
+        const isCommited = (Number(endCommitment) ?? 0) > currentTime
+        const endCommitmentDate = new Date(
+          (Number(endCommitment) ?? 0) * 1000
+        ).toLocaleDateString()
+        if (isCommited) {
+          alert(`You are still committed until ${endCommitmentDate}.`)
+        } else {
+          onInitiateDeauthorization(tokenAmount)
+        }
+      } else {
+        onInitiateDeauthorization(tokenAmount)
+      }
+    }
   }
 
   const onConfirmDeauthorization = () => {

src/pages/Staking/StakeDetailsPage/index.tsx

@@ -75,6 +75,12 @@ const StakeDetailsPage: FC = () => {
     stakingProviderAddress || AddressZero
   )
 
+  const endCommitment = tacoApp.stakingProviderInfo?.endCommitment
+  const isCommited = (Number(endCommitment) ?? 0) > 0
+  const endCommitmentDate = new Date(
+    (Number(endCommitment) ?? 0) * 1000
+  ).toLocaleDateString()
+
   const isInActiveStake = BigNumber.from(stake?.totalInTStake ?? "0").isZero()
 
   const { total: rewardsForStake } = useAppSelector((state) =>
@@ -166,10 +172,12 @@ const StakeDetailsPage: FC = () => {
           </StakeDetailRow>
         </Stack>
       </SimpleGrid>
-      {tacoApp.isAuthorized && (
+      {tacoApp.isAuthorized && !isCommited ? (
         <Button onClick={handleCommitToTaco} type="submit">
           Commit to TACo
         </Button>
+      ) : (
+        <p>Your commitment ends on {endCommitmentDate}</p>
       )}
     </Card>
   ) : (

src/store/staking-applications/slice.ts

@@ -287,6 +287,7 @@ export const stakingApplicationsSlice = createSlice({
           deauthorizationCreatedAt: undefined,
           isOperatorInPool: undefined,
           operator: AddressZero,
+          stakingProviderInfo: undefined,
         }
 
         state.randomBeacon.stakingProviders.data[stakingProvider] = {

src/threshold-ts/applications/index.ts

@@ -38,6 +38,20 @@ export interface AuthorizationParameters<
   authorizationDecreaseChangePeriod: NumberType
 }
 
+export interface StakingProviderInfo<
+  NumberType extends BigNumberish = BigNumber
+> {
+  operator: string
+  operatorConfirmed: boolean
+  operatorStartTimestamp: NumberType
+  authorized: NumberType
+  deauthorizing: NumberType
+  endDeauthorization: NumberType
+  tReward: NumberType
+  rewardPerTokenPaid: NumberType
+  endCommitment: NumberType
+}
+
 export interface StakingProviderAppInfo<
   NumberType extends BigNumberish = BigNumber
 > {
@@ -75,6 +89,8 @@ export interface StakingProviderAppInfo<
    * it means that the operator for a given staking provider is not set.
    */
   isOperatorInPool: boolean | undefined
+
+  stakingProviderInfo?: StakingProviderInfo | undefined
 }
 
 /**
@@ -202,6 +218,8 @@ export interface IApplication {
    */
   stakingProviderToOperator(stakingProvider: string): Promise<string>
 
+  stakingProviderInfo(stakingProvider: string): Promise<StakingProviderInfo>
+
   /**
    * Used to get staking provider address mapped to the given registered
    * operator address
@@ -314,6 +332,15 @@ export class Application implements IApplication {
       },
     ]
 
+    const tacoCalls: ContractCall[] = [
+      {
+        interface: this.contract.interface,
+        address: this.contract.address,
+        method: "stakingProviderInfo",
+        args: [stakingProvider],
+      },
+    ]
+
     const [
       authorizedStake,
       pendingAuthorizationDecrease,
@@ -323,6 +350,14 @@ export class Application implements IApplication {
       [operator],
     ] = await this._multicall.aggregate(calls)
 
+    let stakingProviderInfo
+    try {
+      ;[stakingProviderInfo] = await this._multicall.aggregate(tacoCalls)
+    } catch (error) {
+      console.warn("Failed to aggregate tacoCalls", error)
+      stakingProviderInfo = undefined
+    }
+
     let isOperatorInPool = undefined
     if (operator && !isAddressZero(operator)) {
       try {
@@ -368,6 +403,7 @@ export class Application implements IApplication {
       deauthorizationCreatedAt,
       isOperatorInPool,
       operator,
+      stakingProviderInfo,
     }
   }
 
@@ -448,6 +484,12 @@ export class Application implements IApplication {
     )
   }
 
+  stakingProviderInfo = async (
+    stakingProvider: string
+  ): Promise<StakingProviderInfo> => {
+    return await this._application.stakingProviderInfo(stakingProvider)
+  }
+
   stakingProviderToOperator = async (
     stakingProvider: string
   ): Promise<string> => {